Merge "make descrambler test optional since it may be provided through tuner... (1e2f00fa) · Commits · e / os / android_hardware_interfaces

cas/1.0/vts/functional/Android.bp

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -20,6 +20,8 @@ cc_test {
	srcs: ["VtsHalCasV1_0TargetTest.cpp"],		srcs: ["VtsHalCasV1_0TargetTest.cpp"],
	static_libs: [		static_libs: [
	"android.hardware.cas@1.0",		"android.hardware.cas@1.0",
			"android.hardware.cas@1.1",
			"android.hardware.cas@1.2",
	"android.hardware.cas.native@1.0",		"android.hardware.cas.native@1.0",
	"android.hidl.allocator@1.0",		"android.hidl.allocator@1.0",
	"android.hidl.memory@1.0",		"android.hidl.memory@1.0",

cas/1.0/vts/functional/VtsHalCasV1_0TargetTest.cpp

+180 −180

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@
	#include <android/hardware/cas/1.0/IDescramblerBase.h>		#include <android/hardware/cas/1.0/IDescramblerBase.h>
	#include <android/hardware/cas/1.0/IMediaCasService.h>		#include <android/hardware/cas/1.0/IMediaCasService.h>
	#include <android/hardware/cas/1.0/types.h>		#include <android/hardware/cas/1.0/types.h>
			#include <android/hardware/cas/1.2/IMediaCasService.h>
	#include <android/hardware/cas/native/1.0/IDescrambler.h>		#include <android/hardware/cas/native/1.0/IDescrambler.h>
	#include <android/hardware/cas/native/1.0/types.h>		#include <android/hardware/cas/native/1.0/types.h>
	#include <binder/MemoryDealer.h>		#include <binder/MemoryDealer.h>
	@@ -212,6 +213,10 @@ void MediaCasListener::testEventEcho(sp<ICas>& mediaCas, int32_t& event, int32_t
	class MediaCasHidlTest : public testing::TestWithParam<std::string> {		class MediaCasHidlTest : public testing::TestWithParam<std::string> {
	public:		public:
	virtual void SetUp() override {		virtual void SetUp() override {
			if (android::hardware::cas::V1_2::IMediaCasService::getService(GetParam()) == nullptr) {
			ALOGI("Descrambler is need to be tested before cas@1.2.");
			mIsTestDescrambler = true;
			}
	mService = IMediaCasService::getService(GetParam());		mService = IMediaCasService::getService(GetParam());
	ASSERT_NE(mService, nullptr);		ASSERT_NE(mService, nullptr);
	}		}
	@@ -226,6 +231,7 @@ class MediaCasHidlTest : public testing::TestWithParam<std::string> {
	sp<ICas> mMediaCas;		sp<ICas> mMediaCas;
	sp<IDescramblerBase> mDescramblerBase;		sp<IDescramblerBase> mDescramblerBase;
	sp<MediaCasListener> mCasListener;		sp<MediaCasListener> mCasListener;
			bool mIsTestDescrambler = false;
	typedef struct _OobInputTestParams {		typedef struct _OobInputTestParams {
	const SubSample* subSamples;		const SubSample* subSamples;
	uint32_t numSubSamples;		uint32_t numSubSamples;
	@@ -270,8 +276,14 @@ class MediaCasHidlTest : public testing::TestWithParam<std::string> {

	auto descramblerStatus = mService->createDescrambler(caSystemId);		auto descramblerStatus = mService->createDescrambler(caSystemId);
	if (!descramblerStatus.isOk()) {		if (!descramblerStatus.isOk()) {
			if (mIsTestDescrambler) {
	return ::testing::AssertionFailure();		return ::testing::AssertionFailure();
			} else {
			ALOGI("Skip Descrambler test since it's not required in cas@1.2.");
			return ::testing::AssertionSuccess();
			}
	}		}
			mIsTestDescrambler = true;
	mDescramblerBase = descramblerStatus;		mDescramblerBase = descramblerStatus;
	return ::testing::AssertionResult(mDescramblerBase != nullptr);		return ::testing::AssertionResult(mDescramblerBase != nullptr);
	}		}
	@@ -494,7 +506,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApis) {
	returnStatus = mMediaCas->setSessionPrivateData(streamSessionId, hidlPvtData);		returnStatus = mMediaCas->setSessionPrivateData(streamSessionId, hidlPvtData);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			if (mIsTestDescrambler) {
	returnStatus = mDescramblerBase->setMediaCasSession(sessionId);		returnStatus = mDescramblerBase->setMediaCasSession(sessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
	@@ -502,6 +514,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApis) {
	returnStatus = mDescramblerBase->setMediaCasSession(streamSessionId);		returnStatus = mDescramblerBase->setMediaCasSession(streamSessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}

	hidl_vec<uint8_t> hidlNullPtr;		hidl_vec<uint8_t> hidlNullPtr;
	hidlNullPtr.setToExternal(static_cast<uint8_t*>(nullptr), 0);		hidlNullPtr.setToExternal(static_cast<uint8_t*>(nullptr), 0);
	@@ -543,6 +556,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApis) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

			if (mIsTestDescrambler) {
	EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("video/avc"));		EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("video/avc"));

	sp<IDescrambler> descrambler;		sp<IDescrambler> descrambler;
	@@ -556,16 +570,18 @@ TEST_P(MediaCasHidlTest, TestClearKeyApis) {
	EXPECT_EQ(Status::OK, descrambleStatus);		EXPECT_EQ(Status::OK, descrambleStatus);

	ASSERT_NE(nullptr, dataMemory.get());		ASSERT_NE(nullptr, dataMemory.get());
	uint8_t* opBuffer = static_cast<uint8_t>(static_cast<void>(dataMemory->unsecurePointer()));		uint8_t* opBuffer =
			static_cast<uint8_t>(static_cast<void>(dataMemory->unsecurePointer()));

	int compareResult =		int compareResult =
	memcmp(static_cast<const void>(opBuffer), static_cast<const void>(kOutRefBinaryBuffer),		memcmp(static_cast<const void*>(opBuffer),
	sizeof(kOutRefBinaryBuffer));		static_cast<const void*>(kOutRefBinaryBuffer), sizeof(kOutRefBinaryBuffer));
	EXPECT_EQ(0, compareResult);		EXPECT_EQ(0, compareResult);

	returnStatus = mDescramblerBase->release();		returnStatus = mDescramblerBase->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}

	returnStatus = mMediaCas->release();		returnStatus = mMediaCas->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	@@ -590,6 +606,7 @@ TEST_P(MediaCasHidlTest, TestClearKeySessionClosedAfterRelease) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

			if (mIsTestDescrambler) {
	returnStatus = mDescramblerBase->setMediaCasSession(sessionId);		returnStatus = mDescramblerBase->setMediaCasSession(sessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::ERROR_CAS_SESSION_NOT_OPENED, returnStatus);		EXPECT_EQ(Status::ERROR_CAS_SESSION_NOT_OPENED, returnStatus);
	@@ -598,6 +615,7 @@ TEST_P(MediaCasHidlTest, TestClearKeySessionClosedAfterRelease) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::ERROR_CAS_SESSION_NOT_OPENED, returnStatus);		EXPECT_EQ(Status::ERROR_CAS_SESSION_NOT_OPENED, returnStatus);
	}		}
			}

	TEST_P(MediaCasHidlTest, TestClearKeyErrors) {		TEST_P(MediaCasHidlTest, TestClearKeyErrors) {
	description("Test that invalid call sequences fail with expected error codes");		description("Test that invalid call sequences fail with expected error codes");
	@@ -654,6 +672,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyErrors) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::ERROR_CAS_UNKNOWN, returnStatus);		EXPECT_EQ(Status::ERROR_CAS_UNKNOWN, returnStatus);

			if (mIsTestDescrambler) {
	/*		/*
	* Test MediaDescrambler error codes		* Test MediaDescrambler error codes
	*/		*/
	@@ -687,6 +706,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyErrors) {
	// Verify that requiresSecureDecoderComponent handles invalid mime		// Verify that requiresSecureDecoderComponent handles invalid mime
	EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("bad"));		EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("bad"));
	}		}
			}

	TEST_P(MediaCasHidlTest, TestClearKeyOobFails) {		TEST_P(MediaCasHidlTest, TestClearKeyOobFails) {
	description("Test that oob descramble request fails with expected error");		description("Test that oob descramble request fails with expected error");
	@@ -700,9 +720,11 @@ TEST_P(MediaCasHidlTest, TestClearKeyOobFails) {
	std::vector<uint8_t> sessionId;		std::vector<uint8_t> sessionId;
	ASSERT_TRUE(openCasSession(&sessionId));		ASSERT_TRUE(openCasSession(&sessionId));

			if (mIsTestDescrambler) {
	returnStatus = mDescramblerBase->setMediaCasSession(sessionId);		returnStatus = mDescramblerBase->setMediaCasSession(sessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}

	hidl_vec<uint8_t> hidlEcm;		hidl_vec<uint8_t> hidlEcm;
	hidlEcm.setToExternal(const_cast<uint8_t*>(kEcmBinaryBuffer), sizeof(kEcmBinaryBuffer));		hidlEcm.setToExternal(const_cast<uint8_t*>(kEcmBinaryBuffer), sizeof(kEcmBinaryBuffer));
	@@ -710,126 +732,104 @@ TEST_P(MediaCasHidlTest, TestClearKeyOobFails) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

			if (mIsTestDescrambler) {
	sp<IDescrambler> descrambler = IDescrambler::castFrom(mDescramblerBase);		sp<IDescrambler> descrambler = IDescrambler::castFrom(mDescramblerBase);
	ASSERT_NE(nullptr, descrambler.get());		ASSERT_NE(nullptr, descrambler.get());

	Status descrambleStatus = Status::OK;		Status descrambleStatus = Status::OK;

	// test invalid src buffer offset		// test invalid src buffer offset
	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(
	descrambler,		descrambleTestOobInput(descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = kSubSamples,
	{
	.subSamples = kSubSamples,
	.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),		.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0xcccccc,		.imemOffset = 0xcccccc,
	.imemSize = sizeof(kInBinaryBuffer),		.imemSize = sizeof(kInBinaryBuffer),
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test invalid src buffer size		// test invalid src buffer size
	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(
	descrambler,		descrambleTestOobInput(descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = kSubSamples,
	{
	.subSamples = kSubSamples,
	.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),		.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0,		.imemOffset = 0,
	.imemSize = 0xcccccc,		.imemSize = 0xcccccc,
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test invalid src buffer size		// test invalid src buffer size
	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(
	descrambler,		descrambleTestOobInput(descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = kSubSamples,
	{
	.subSamples = kSubSamples,
	.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),		.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 1,		.imemOffset = 1,
	.imemSize = (uint64_t)-1,		.imemSize = (uint64_t)-1,
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test invalid srcOffset		// test invalid srcOffset
	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(
	descrambler,		descrambleTestOobInput(descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = kSubSamples,
	{
	.subSamples = kSubSamples,
	.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),		.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0,		.imemOffset = 0,
	.imemSize = sizeof(kInBinaryBuffer),		.imemSize = sizeof(kInBinaryBuffer),
	.srcOffset = 0xcccccc,		.srcOffset = 0xcccccc,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test invalid dstOffset		// test invalid dstOffset
	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(
	descrambler,		descrambleTestOobInput(descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = kSubSamples,
	{
	.subSamples = kSubSamples,
	.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),		.numSubSamples = sizeof(kSubSamples) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0,		.imemOffset = 0,
	.imemSize = sizeof(kInBinaryBuffer),		.imemSize = sizeof(kInBinaryBuffer),
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0xcccccc		.dstOffset = 0xcccccc}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test detection of oob subsample sizes		// test detection of oob subsample sizes
	const SubSample invalidSubSamples1[] =		const SubSample invalidSubSamples1[] = {{162, 0}, {0, 184}, {0, 0xdddddd}};
	{{162, 0}, {0, 184}, {0, 0xdddddd}};

	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(descrambleTestOobInput(
	descrambler,		descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = invalidSubSamples1,
	{
	.subSamples = invalidSubSamples1,
	.numSubSamples = sizeof(invalidSubSamples1) / sizeof(SubSample),		.numSubSamples = sizeof(invalidSubSamples1) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0,		.imemOffset = 0,
	.imemSize = sizeof(kInBinaryBuffer),		.imemSize = sizeof(kInBinaryBuffer),
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	// test detection of overflowing subsample sizes		// test detection of overflowing subsample sizes
	const SubSample invalidSubSamples2[] =		const SubSample invalidSubSamples2[] = {{162, 0}, {0, 184}, {2, (uint32_t)-1}};
	{{162, 0}, {0, 184}, {2, (uint32_t)-1}};

	ASSERT_TRUE(descrambleTestOobInput(		ASSERT_TRUE(descrambleTestOobInput(
	descrambler,		descrambler, &descrambleStatus,
	&descrambleStatus,		{.subSamples = invalidSubSamples2,
	{
	.subSamples = invalidSubSamples2,
	.numSubSamples = sizeof(invalidSubSamples2) / sizeof(SubSample),		.numSubSamples = sizeof(invalidSubSamples2) / sizeof(SubSample),
	.imemSizeActual = sizeof(kInBinaryBuffer),		.imemSizeActual = sizeof(kInBinaryBuffer),
	.imemOffset = 0,		.imemOffset = 0,
	.imemSize = sizeof(kInBinaryBuffer),		.imemSize = sizeof(kInBinaryBuffer),
	.srcOffset = 0,		.srcOffset = 0,
	.dstOffset = 0		.dstOffset = 0}));
	}));
	EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);		EXPECT_EQ(Status::BAD_VALUE, descrambleStatus);

	returnStatus = mDescramblerBase->release();		returnStatus = mDescramblerBase->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}
	returnStatus = mMediaCas->release();		returnStatus = mMediaCas->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

cas/1.1/vts/functional/Android.bp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -21,6 +21,7 @@ cc_test {
	static_libs: [		static_libs: [
	"android.hardware.cas@1.0",		"android.hardware.cas@1.0",
	"android.hardware.cas@1.1",		"android.hardware.cas@1.1",
			"android.hardware.cas@1.2",
	"android.hardware.cas.native@1.0",		"android.hardware.cas.native@1.0",
	"android.hidl.allocator@1.0",		"android.hidl.allocator@1.0",
	"android.hidl.memory@1.0",		"android.hidl.memory@1.0",

cas/1.1/vts/functional/VtsHalCasV1_1TargetTest.cpp

+41 −24

Original line number	Original line	Diff line number	Diff line
	@@ -22,6 +22,7 @@
	#include <android/hardware/cas/1.1/ICas.h>		#include <android/hardware/cas/1.1/ICas.h>
	#include <android/hardware/cas/1.1/ICasListener.h>		#include <android/hardware/cas/1.1/ICasListener.h>
	#include <android/hardware/cas/1.1/IMediaCasService.h>		#include <android/hardware/cas/1.1/IMediaCasService.h>
			#include <android/hardware/cas/1.2/IMediaCasService.h>
	#include <android/hardware/cas/native/1.0/IDescrambler.h>		#include <android/hardware/cas/native/1.0/IDescrambler.h>
	#include <android/hardware/cas/native/1.0/types.h>		#include <android/hardware/cas/native/1.0/types.h>
	#include <binder/MemoryDealer.h>		#include <binder/MemoryDealer.h>
	@@ -255,6 +256,10 @@ void MediaCasListener::testSessionEventEcho(sp<ICas>& mediaCas, const hidl_vec<u
	class MediaCasHidlTest : public testing::TestWithParam<std::string> {		class MediaCasHidlTest : public testing::TestWithParam<std::string> {
	public:		public:
	virtual void SetUp() override {		virtual void SetUp() override {
			if (android::hardware::cas::V1_2::IMediaCasService::getService(GetParam()) == nullptr) {
			ALOGI("Descrambler is need to be tested before cas@1.2.");
			mIsTestDescrambler = true;
			}
	mService = IMediaCasService::getService(GetParam());		mService = IMediaCasService::getService(GetParam());
	ASSERT_NE(mService, nullptr);		ASSERT_NE(mService, nullptr);
	}		}
	@@ -269,6 +274,7 @@ class MediaCasHidlTest : public testing::TestWithParam<std::string> {
	sp<ICas> mMediaCas;		sp<ICas> mMediaCas;
	sp<IDescramblerBase> mDescramblerBase;		sp<IDescramblerBase> mDescramblerBase;
	sp<MediaCasListener> mCasListener;		sp<MediaCasListener> mCasListener;
			bool mIsTestDescrambler = false;
	typedef struct _OobInputTestParams {		typedef struct _OobInputTestParams {
	const SubSample* subSamples;		const SubSample* subSamples;
	uint32_t numSubSamples;		uint32_t numSubSamples;
	@@ -311,8 +317,15 @@ class MediaCasHidlTest : public testing::TestWithParam<std::string> {

	auto descramblerStatus = mService->createDescrambler(caSystemId);		auto descramblerStatus = mService->createDescrambler(caSystemId);
	if (!descramblerStatus.isOk()) {		if (!descramblerStatus.isOk()) {
			if (mIsTestDescrambler) {
	return ::testing::AssertionFailure();		return ::testing::AssertionFailure();
			} else {
			ALOGI("Skip Descrambler test since it's not required in cas@1.2.");
			return ::testing::AssertionSuccess();
			}
	}		}
			mIsTestDescrambler = true;

	mDescramblerBase = descramblerStatus;		mDescramblerBase = descramblerStatus;
	return ::testing::AssertionResult(mDescramblerBase != nullptr);		return ::testing::AssertionResult(mDescramblerBase != nullptr);
	}		}
	@@ -468,6 +481,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApisWithSession) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

			if (mIsTestDescrambler) {
	returnStatus = mDescramblerBase->setMediaCasSession(sessionId);		returnStatus = mDescramblerBase->setMediaCasSession(sessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
	@@ -475,6 +489,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApisWithSession) {
	returnStatus = mDescramblerBase->setMediaCasSession(streamSessionId);		returnStatus = mDescramblerBase->setMediaCasSession(streamSessionId);
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}

	hidl_vec<uint8_t> hidlNullPtr;		hidl_vec<uint8_t> hidlNullPtr;
	hidlNullPtr.setToExternal(static_cast<uint8_t*>(nullptr), 0);		hidlNullPtr.setToExternal(static_cast<uint8_t*>(nullptr), 0);
	@@ -518,6 +533,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApisWithSession) {
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);

			if (mIsTestDescrambler) {
	EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("video/avc"));		EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("video/avc"));

	sp<IDescrambler> descrambler;		sp<IDescrambler> descrambler;
	@@ -541,6 +557,7 @@ TEST_P(MediaCasHidlTest, TestClearKeyApisWithSession) {
	returnStatus = mDescramblerBase->release();		returnStatus = mDescramblerBase->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());
	EXPECT_EQ(Status::OK, returnStatus);		EXPECT_EQ(Status::OK, returnStatus);
			}

	returnStatus = mMediaCas->release();		returnStatus = mMediaCas->release();
	EXPECT_TRUE(returnStatus.isOk());		EXPECT_TRUE(returnStatus.isOk());

cas/1.2/vts/functional/VtsHalCasV1_2TargetTest.cpp

+32 −25