diff --git a/frameworks/c/drm_capi/native_mediakeysession.cpp b/frameworks/c/drm_capi/native_mediakeysession.cpp index 240d52e1b57c4568cc8d2e2b0fe7e5d56410ac25..ab707eef74f0668d9d59603aef70bd11d62286cb 100644 --- a/frameworks/c/drm_capi/native_mediakeysession.cpp +++ b/frameworks/c/drm_capi/native_mediakeysession.cpp @@ -191,7 +191,7 @@ Drm_ErrCode OH_MediaKeySession_ClearMediaKeys(MediaKeySession *mediaKeySessoin) Drm_ErrCode OH_MediaKeySession_GenerateOfflineReleaseRequest(MediaKeySession *mediaKeySessoin, uint8_t *offlineMediaKeyId, int32_t offlineMediaKeyIdLen, uint8_t *releaseRequest, int32_t *releaseRequestLen) -{ +{ DRM_INFO_LOG("OH_MediaKeySession_GenerateOfflineReleaseRequest enter"); DRM_CHECK_AND_RETURN_RET_LOG(((mediaKeySessoin != nullptr) && (offlineMediaKeyId != nullptr) && (offlineMediaKeyIdLen > 0) && (offlineMediaKeyIdLen <= MAX_OFFLINE_MEDIA_KEY_ID_LEN) && diff --git a/frameworks/js/drm_napi/native_module_ohos_drm.cpp b/frameworks/js/drm_napi/native_module_ohos_drm.cpp index 56ad0d70cacd5ad895ba620a50c61078cfca311f..20bd56575e90be7bbd9db76e41a0b7f4961e5921 100644 --- a/frameworks/js/drm_napi/native_module_ohos_drm.cpp +++ b/frameworks/js/drm_napi/native_module_ohos_drm.cpp @@ -27,6 +27,7 @@ static napi_value Export(napi_env env, napi_value exports) MediaKeySessionNapi::Init(env, exports); MediaKeySystemNapi::Init(env, exports); return exports; + } /* diff --git a/frameworks/native/drm/key_session_impl.cpp b/frameworks/native/drm/key_session_impl.cpp index 9c8eef78a70d63623bd5fe6d1d1297d7e583a407..6cb44a7b809aa4f7d61e712e516cd658ca09b968 100644 --- a/frameworks/native/drm/key_session_impl.cpp +++ b/frameworks/native/drm/key_session_impl.cpp @@ -117,10 +117,27 @@ int32_t MediaKeySessionImpl::ProcessMediaKeyResponse(std::vector &licen std::lock_guard lock(mutex_); int32_t retCode = DRM_INNER_ERR_OK; + std::string licenseIdHex; + for (auto b : licenseId) { + char buf[4]; + snprintf(buf, sizeof(buf), "%02X", b); + licenseIdHex += buf; + } + DRM_ERR_LOG("licenseId: %{public}s", licenseIdHex.c_str()); + std::string licenseResponseHex; + for (auto b : licenseResponse) { + char buf[4]; + snprintf(buf, sizeof(buf), "%02X", b); + licenseResponseHex += buf; + } + DRM_ERR_LOG("licenseResponse: %{public}s", licenseResponseHex.c_str()); + if (keySessionServiceProxy_ == nullptr) { DRM_ERR_LOG("ProcessMediaKeyResponse keySessionServiceProxy_ is null"); return DRM_INNER_ERR_INVALID_KEY_SESSION; } + + retCode = keySessionServiceProxy_->ProcessMediaKeyResponse(licenseId, licenseResponse); if (retCode != DRM_INNER_ERR_OK) { DRM_ERR_LOG("ProcessMediaKeyResponse failed, retCode: %{public}d", retCode); diff --git a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp index cf02385bacedd74baee5162b924766469c2e1ccf..26e5a6659f4b3ec871934bf752ef95a2861facca 100644 --- a/frameworks/native/test/unittest/src/drm_framework_unittest.cpp +++ b/frameworks/native/test/unittest/src/drm_framework_unittest.cpp @@ -271,257 +271,76 @@ Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin /* * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedNormal_001, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported(GetUuid()); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2Normal_002, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4"); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3Normal_003, TestSize.Level0) -{ - bool supported; - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, true); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedAbNormal_004, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported("com.drm.clearpla"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported(""); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported(nullptr); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2AbNormal_005, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported2("com.drm.clearpla", "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2("", "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(nullptr, "video/mp4"); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "ideo/mp4"); - if (g_isWisePlay) { - EXPECT_EQ(supported, true); - } else { - EXPECT_EQ(supported, false); - } - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), ""); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported2(GetUuid(), nullptr); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test to determine if the creation of this DRM instance is supported - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3AbNormal_006, TestSize.Level0) -{ - bool supported = true; - supported = OH_MediaKeySystem_IsSupported3("com.drm.clearpla", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3("", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(nullptr, "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "ideo/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - if (g_isWisePlay) { - EXPECT_EQ(supported, true); - } else { - EXPECT_EQ(supported, false); - } - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), nullptr, CONTENT_PROTECTION_LEVEL_HW_CRYPTO); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", - (DRM_ContentProtectionLevel)(CONTENT_PROTECTION_LEVEL_UNKNOWN - 1)); - EXPECT_EQ(supported, false); - supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", - (DRM_ContentProtectionLevel)CONTENT_PROTECTION_LEVEL_MAX); - EXPECT_EQ(supported, false); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: Test Creating DRM Instance + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_007, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); EXPECT_NE(mediaKeySystem, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_GT(contentProtectionLevel, 0); - if (mediaKeySystem != nullptr) { - OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; } -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Testing for an incorrect uuid and unsuccessful creation of DRM instance. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_008, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create("com.drm.clerpay", &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test passed in an empty uuid and failed to create a DRM instance. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_009, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create("", &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case description: After the DRM instance is created, it is destroyed, and then the subsequent interface is called. - * The interface returns unsuccessful. - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_010, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); - mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); } /* * Feature: Framework - * Function: Test and create sessions + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: Test Creating Sessions + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionNormal_011, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} /* * Feature: Framework - * Function: Test that the RequireSecureDecoderModule interface is functioning properly + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case description: Testing that the RequireSecureDecoderModule interface is functioning properly + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleNormal_012, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -533,25 +352,53 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleNormal_012 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + unsigned char testData[139] = REQUESTINFODATA; + info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = sizeof(testData); + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); } /* * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_013, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -563,26 +410,51 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "asdssadadsa", &requireSecureDecoder); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(nullptr, &mediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); } /* * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_014, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -594,57 +466,50 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "", &requireSecureDecoder); - EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_015, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, nullptr, &requireSecureDecoder); + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, nullptr); EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); } /* * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_016, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -656,8 +521,45 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + + errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + if (g_isWisePlay) { + EXPECT_EQ(errNo, DRM_ERR_OK); + } else { + EXPECT_NE(errNo, DRM_ERR_OK); + } errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -666,13 +568,13 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 /* * Feature: Framework - * Function: RequireSecureDecoderModule Exception Test Input Error mimtype + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: RequireSecureDecoderModule Exception Test + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_017, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_037, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -684,10 +586,37 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - bool requireSecureDecoder = false; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(nullptr, "video/mp4", &requireSecureDecoder); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + errNo = OH_MediaKeySession_ClearMediaKeys(nullptr); EXPECT_NE(errNo, DRM_ERR_OK); - EXPECT_EQ(requireSecureDecoder, false); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -696,56 +625,119 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_0 /* * Feature: Framework - * Function: GenerateKeySystemRequest normal testing to obtain normal requests + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case description: GenerateKeySystemRequest obtained a normal request through normal testing + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestNormal_018, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusNormal_038, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); EXPECT_NE(mediaKeySystem, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, info.initDataLen); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + } + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } /* * Feature: Framework - * Function: GenerateKeySystemRequest parameter exception testing + * Function: Processing device certificate response testing * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: GenerateKeySystemRequest Parameter Exception Test + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestAbNormal_019, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_039, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; + MediaKeySession *mediaKeySession = nullptr; + DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); EXPECT_NE(mediaKeySystem, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char request[12288] = { 0 }; // 12288:request len - int32_t requestLen = 12288; // 12288:request len - char defaultUrl[2048] = { 0 }; // 2048:url len - int32_t defaultUrlLen = 2048; // 2048:url len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(nullptr, request, &requestLen, defaultUrl, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, nullptr, &requestLen, defaultUrl, - defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, nullptr, defaultUrl, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, nullptr, defaultUrlLen); - EXPECT_NE(errNo, DRM_ERR_OK); - requestLen = 12288; // 12288:request len - errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, 0); + errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); + EXPECT_NE(mediaKeySession, nullptr); + EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } @@ -758,7 +750,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestAbNormal_019 * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_040, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -767,16 +759,49 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, T errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); EXPECT_NE(mediaKeySystem, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[139] = REQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = sizeof(testData); + info.type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, nullptr, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } - /* * Feature: Framework * Function: Processing device certificate response testing @@ -785,85 +810,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, T * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_021, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - int32_t KeySystemResponseLen = 12288; - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(nullptr, KeySystemResponse, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_022, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - int32_t KeySystemResponseLen = 12288; - errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, nullptr, KeySystemResponseLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_023, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_041, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -889,6 +836,25 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, T info.optionsCount = 1; errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_MediaKeyStatus mediaKeyStatus; + errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr); + EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -903,7 +869,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, T * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsNormal_042, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -918,17 +884,33 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(nullptr, &info, &mediaKeyRequest); - EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediakeyIdArray offlineMediaKeyIds; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -943,7 +925,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_043, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -967,7 +949,23 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, nullptr, &mediaKeyRequest); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediakeyIdArray offlineMediaKeyIds; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(nullptr, &offlineMediaKeyIds); EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); @@ -981,9 +979,9 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, * Sub function: NA * Function point: NA * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing + * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_044, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -996,6 +994,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; unsigned char testData[139] = REQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); @@ -1006,7 +1005,22 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, nullptr); + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, nullptr); EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); @@ -1022,7 +1036,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestNormal_045, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1037,10 +1051,10 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, T // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); @@ -1058,10 +1072,19 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, T EXPECT_EQ(rett, 0); } else { testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -1076,7 +1099,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, T * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestAbNormal_046, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1091,16 +1114,17 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[1] = { 0 }; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); info.optionsCount = 1; errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN unsigned char testKeySessionResponse[12288] = OFFRESPONSE; @@ -1111,8 +1135,29 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, EXPECT_EQ(rett, 0); } else { testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(nullptr, testKeySessionResponse, + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr, &releaseRequestLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, nullptr); EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); @@ -1128,7 +1173,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseNormal_047, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1143,21 +1188,50 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[1] = { 0 }; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); info.optionsCount = 1; errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, nullptr, 0, - onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(errNo, DRM_ERR_OK); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + if (!g_isWisePlay) { + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -1172,7 +1246,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_048, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1187,10 +1261,10 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); @@ -1198,56 +1272,38 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, info.optionsCount = 1; errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeySessionResponse[50] = OFFRESPONSE; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), nullptr, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_032, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, nullptr); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); @@ -1263,55 +1319,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_032, * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - unsigned char testData[139] = REQUESTINFODATA; - info.type = MEDIA_KEY_TYPE_ONLINE; - info.initDataLen = sizeof(testData); - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} /* * Feature: Framework @@ -1321,7 +1329,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestS * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysNormal_060, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1336,10 +1344,10 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, Tes // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); @@ -1360,9 +1368,29 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, Tes }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(nullptr, &mediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -1377,7 +1405,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, Tes * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysAbNormal_061, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1392,10 +1420,10 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, Tes // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; + unsigned char testData[241] = OFFREQUESTINFODATA; memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); @@ -1416,8 +1444,34 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, Tes }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); @@ -1432,7 +1486,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, Tes * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysNormal_062, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -1447,10 +1501,9 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.L // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; + unsigned char testData[241] = OFFREQUESTINFODATA; + info.initDataLen = testData[3]; + info.type = MEDIA_KEY_TYPE_OFFLINE; memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); @@ -1471,24 +1524,37 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.L }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); EXPECT_EQ(errNo, DRM_ERR_OK); - - errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - if (g_isWisePlay) { + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); EXPECT_EQ(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); } errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } - /* * Feature: Framework * Function: Processing device certificate response testing @@ -1497,1827 +1563,7 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.L * Environmental conditions: NA * Case Description: Processing Device Certificate Response Testing */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_037, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - errNo = OH_MediaKeySession_ClearMediaKeys(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusNormal_038, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, info.initDataLen); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_039, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_040, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, nullptr, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_041, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsNormal_042, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_043, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(nullptr, &offlineMediaKeyIds); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_044, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestNormal_045, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestAbNormal_046, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseNormal_047, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - if (!g_isWisePlay) { - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_048, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(errNo, DRM_ERR_OK); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusNormal_049, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - EXPECT_EQ(certStatus, 0); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusAbNormal_050, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(nullptr, &certStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringNormal_051, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = - OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - char value[32]; - int32_t valueLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, valueLen); - if (g_isWisePlay) { - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 10); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringAbNormal_052, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(nullptr, "testConfigurationString", "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "", "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, nullptr, "gezhegezhegezhe"); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", ""); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationStringAbNormal_053, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "gezhegezhegezhe"); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - char value[32]; - int32_t valueLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationString(nullptr, "testConfigurationString", value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "", value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, nullptr, value, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr, valueLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayNormal_054, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - if (g_isWisePlay) { - EXPECT_NE(errNo, DRM_ERR_OK); - } else { - EXPECT_EQ(errNo, DRM_ERR_OK); - } - unsigned char configByteArray[128]; - int32_t byteArrayLen = 128; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "deviceUniqueId", configByteArray, - &byteArrayLen); - if (g_isWisePlay) { - EXPECT_EQ(errNo, DRM_ERR_OK); - } else { - EXPECT_NE(errNo, DRM_ERR_OK); - } - - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationByteArrayAbNormal_055, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(nullptr, "testConfigurationByteArray", testArray, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "", testArray, sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, nullptr, testArray, sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayAbNormal_056, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - unsigned char configByteArray[32]; - int32_t byteArrayLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(nullptr, "testConfigurationByteArray", configByteArray, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "", configByteArray, &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, nullptr, configByteArray, &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, - nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsNormal_057, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsAbNormal_058, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(nullptr, &statistics); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Test and create DRM instances - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Test Creating DRM Instance - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetMaxContentProtectionLevelAbNormal_059, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(nullptr, &contentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - if (mediaKeySystem != nullptr) { - OH_MediaKeySystem_Destroy(mediaKeySystem); - } -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysNormal_060, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysAbNormal_061, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysNormal_062, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - info.initDataLen = testData[3]; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} -/* - * Feature: Framework - * Function: Processing device certificate response testing - * Sub function: NA - * Function point: NA - * Environmental conditions: NA - * Case Description: Processing Device Certificate Response Testing - */ -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_063, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[241] = OFFREQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = 139; - info.type = MEDIA_KEY_TYPE_OFFLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, 139, testData, 139); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (!g_isWisePlay) { - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 2); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -#define MAX_BUFF 139 -static void filldata(DRM_MediaKeyRequestInfo *info) -{ - unsigned char testData[139] = REQUESTINFODATA; - memset_s(info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info->initDataLen = sizeof(testData); - info->type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info->mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info->initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info->optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info->optionData[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - info->optionsCount = 1; -} - -const unsigned char TESTKEYRELEASERESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, - 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, - 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, - 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; -const unsigned char TESTKEYSESSIONRESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, - 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, - 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, - 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, - 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; - -static void filltest3(MediaKeySystem *mediaKeySystem, - MediaKeySession *mediaKeySession, unsigned char *keySystemResponse, int32_t KeySystemResponseLen) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, keySystemResponse, - KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - if (!g_isWisePlay) { - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, - &OfflineMediaKeyStatus); - EXPECT_EQ(OfflineMediaKeyStatus, 1); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - releaseRequest, &releaseRequestLen); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, - (uint8_t *)(TESTKEYRELEASERESPONSE), (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); - EXPECT_EQ(errNo, DRM_ERR_OK); - } - DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GetContentProtectionLevel(nullptr, &sessionContentProtectionLevel); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_064, TestSize.Level0) -{ - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - int32_t KeySystemResponseLen = 12288; - unsigned char KeySystemResponse[12288] = OFFRESPONSE; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - KeySystemResponseLen = 50; - } - EXPECT_EQ(errNo, DRM_ERR_OK); - filltest3(mediaKeySystem, mediaKeySession, KeySystemResponse, KeySystemResponseLen); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - mediaKeySession = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - mediaKeySession = nullptr; - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_065, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_066, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // mediakeysession - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; - if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, - (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0); - } else { - testKeySessionResponseLen = 50; - } - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sptr SessionServiceProxy = - sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy(); - sptr decryptModule; - SessionServiceProxy->GetMediaDecryptModule(decryptModule); - MessageParcel data; - DrmBuffer srcBuffer; - DrmBuffer dstBuffer; - bool secureDecodrtState = false; - CryptInfo cryptInfo; - decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer); - decryptModule->Release(); - sptr callback = sessionObject->sessionImpl_->GetApplicationCallback(); - callback->~MediaKeySessionImplCallback(); - } - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - sptr serviceCallback = - new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); - sptr Callback = new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_); - const std::vector data = { 0x01 }; - MessageParcel data1; - MessageParcel reply; - MessageOption option; - data1.WriteInt32(static_cast(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED)); - data1.WriteInt32(1); - data1.WriteInt32(data.size()); - for (auto it = data.begin(); it != data.end(); ++it) { - int32_t ret = data1.WriteUint8((*it)); - EXPECT_NE(ret, 0); - } - Callback->OnRemoteRequest(static_cast(IMediaKeySystemServiceCallbackIpcCode::COMMAND_SEND_EVENT), - data1, reply, option); - serviceCallback->SendEvent(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED, 1, data); - OHOS::sptr SystemCallbackCapi = - new (std::nothrow) MediaKeySystemCallbackCapi(); - SystemCallbackCapi->SetCallbackReference(&TestSystemEventCallBack); - SystemCallbackCapi->SendEvent("1", 1, data); - sptr SystemImplCallba = systemObject->systemImpl_->GetApplicationCallback(); - SystemImplCallba->~MediaKeySystemImplCallback(); - } - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_067, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - int32_t releaseRequestLen = 12288; // 12288:request len - unsigned char releaseRequest[12288] = { 0 }; // 12288:request len - uint8_t mediaKeyIdToRelease; - MediaKeySession *mediaKeySession = (MediaKeySession *)&mediaKeyIdToRelease; - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, 11, releaseRequest, // 11:len - &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, - releaseRequest, &releaseRequestLen); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, 0, - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, 11, // 11:len - testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, - 11, nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, - 11, testKeyReleaseResponse, 0); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_068, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - unsigned char onlineMediaKeyId[88]; // 88:keyId len - uint32_t onlineMediaKeyIdLen = 88; // 88:keyId len - MediaKeySession *mediaKeySession = (MediaKeySession *)&onlineMediaKeyId; - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetMediaKeySessionCallbackNormal_069, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - // test 3: system callback - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(nullptr, &TestSystemEventCallBack); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(nullptr, &sessionCallback); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_070, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(nullptr, &mediaKeySystem); - EXPECT_EQ(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_Create(GetUuid(), nullptr); - EXPECT_EQ(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(nullptr, &contentProtectionLevel, &mediaKeySession); - EXPECT_EQ(mediaKeySession, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, nullptr, &mediaKeySession); - EXPECT_EQ(mediaKeySession, nullptr); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, nullptr); - EXPECT_EQ(mediaKeySession, nullptr); - uint8_t mediaKeyIdToClear; - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&mediaKeyIdToClear, 0); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, 11); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemDestroyAbNormal_071, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - systemObject->systemImpl_->~MediaKeySystemImpl(); - } - errNo = - OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString"); - EXPECT_NE(errNo, DRM_ERR_OK); - char value[32]; - errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 32); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char testArray[5] = {1, 2, 3, 4, 5}; - errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, - sizeof(testArray)); - EXPECT_NE(errNo, DRM_ERR_OK); - unsigned char configByteArray[32]; - int32_t byteArrayLen = 32; - errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray, - &byteArrayLen); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_Statistics statistics; - errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics); - EXPECT_NE(errNo, DRM_ERR_OK); - contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_OH_MediaKeySystemDestroyAbNormal2_072, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - systemObject->systemImpl_->~MediaKeySystemImpl(); - } - DRM_CertificateStatus certStatus = CERT_STATUS_INVALID; - errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; - MediaKeySession *OH_MediaKeySession2 = nullptr; - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &OH_MediaKeySession2); - EXPECT_EQ(OH_MediaKeySession2, nullptr); - EXPECT_NE(errNo, DRM_ERR_OK); - DRM_OfflineMediakeyIdArray offlineMediaKeyIds; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds); - DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; - errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1, - &OfflineMediaKeyStatus); - errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal_073, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - unsigned char testData[139] = REQUESTINFODATA; - memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); - info.initDataLen = sizeof(testData); - info.type = MEDIA_KEY_TYPE_ONLINE; - memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); - memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData)); - memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); - memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); - info.optionsCount = 1; - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal2_074, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = { 0 }; - int32_t testKeySessionResponseLen = 12288; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySession_DestroyAbNormal3_075, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_063, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -3329,97 +1575,166 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySession_DestroyAbNormal3_075 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); - } - DRM_MediaKeyStatus mediaKeyStatus; - errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession); - EXPECT_NE(errNo, DRM_ERR_OK); + // mediakeysession + DRM_MediaKeyRequest mediaKeyRequest; + DRM_MediaKeyRequestInfo info; + unsigned char testData[241] = OFFREQUESTINFODATA; + memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info.initDataLen = 139; + info.type = MEDIA_KEY_TYPE_OFFLINE; + memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info.initData, 139, testData, 139); + memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue")); + info.optionsCount = 1; + errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); unsigned char releaseRequest[12288] = { 0 }; // 12288:request len int32_t releaseRequestLen = 12288; // 12288:request len - errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)GetUuid(), - 11, releaseRequest, &releaseRequestLen); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + if (!g_isWisePlay) { + unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0); + EXPECT_NE(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 2); + EXPECT_EQ(errNo, DRM_ERR_OK); + } + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal4_076, TestSize.Level0) +#define MAX_BUFF 139 +static void filldata(DRM_MediaKeyRequestInfo *info) +{ + unsigned char testData[139] = REQUESTINFODATA; + memset_s(info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo)); + info->initDataLen = sizeof(testData); + info->type = MEDIA_KEY_TYPE_ONLINE; + memcpy_s(info->mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4")); + memcpy_s(info->initData, sizeof(testData), testData, sizeof(testData)); + memcpy_s(info->optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + memcpy_s(info->optionData[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName")); + info->optionsCount = 1; +} + +const unsigned char TESTKEYRELEASERESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, + 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, + 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, + 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; +const unsigned char TESTKEYSESSIONRESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, + 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E, + 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64, + 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48, + 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D}; + +static void filltest3(MediaKeySystem *mediaKeySystem, + MediaKeySession *mediaKeySession, unsigned char *keySystemResponse, int32_t KeySystemResponseLen) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, keySystemResponse, + KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - sessionObject->sessionImpl_->~MediaKeySessionImpl(); + DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN; + if (!g_isWisePlay) { + errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen, + &OfflineMediaKeyStatus); + EXPECT_EQ(OfflineMediaKeyStatus, 1); + EXPECT_EQ(errNo, DRM_ERR_OK); + unsigned char releaseRequest[12288] = { 0 }; // 12288:request len + int32_t releaseRequestLen = 12288; // 12288:request len + errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + releaseRequest, &releaseRequestLen); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen, + (uint8_t *)(TESTKEYRELEASERESPONSE), (int32_t)(sizeof(TESTKEYRELEASERESPONSE))); + EXPECT_EQ(errNo, DRM_ERR_OK); } - unsigned char testKeyReleaseResponse[50] = OFFRESPONSE; - errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)GetUuid(), - 11, testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)GetUuid(), 1); - EXPECT_NE(errNo, DRM_ERR_OK); DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN; errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel); + EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_GetContentProtectionLevel(nullptr, &sessionContentProtectionLevel); EXPECT_NE(errNo, DRM_ERR_OK); - bool requireSecureDecoder; - errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder); + errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, nullptr); EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - EXPECT_EQ(errNo, DRM_ERR_OK); } -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal_077, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_064, TestSize.Level0) { - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; MediaKeySession *mediaKeySession = nullptr; DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); + Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); EXPECT_NE(mediaKeySession, nullptr); EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); // mediakeysession DRM_MediaKeyRequest mediaKeyRequest; DRM_MediaKeyRequestInfo info; filldata(&info); errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 12288; + int32_t KeySystemResponseLen = 12288; + unsigned char KeySystemResponse[12288] = OFFRESPONSE; if (g_isWisePlay) { - int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, - testKeySessionResponse, &testKeySessionResponseLen, 10); - EXPECT_EQ(rett, 0);} else { - testKeySessionResponseLen = 50; - }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, + (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10); + EXPECT_EQ(rett, 0); + } else { + KeySystemResponseLen = 50; + } EXPECT_EQ(errNo, DRM_ERR_OK); + filltest3(mediaKeySystem, mediaKeySession, KeySystemResponse, KeySystemResponseLen); errNo = OH_MediaKeySession_Destroy(mediaKeySession); + mediaKeySession = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); + errNo = OH_MediaKeySession_Destroy(mediaKeySession); + mediaKeySession = nullptr; + EXPECT_NE(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); + mediaKeySystem = nullptr; EXPECT_EQ(errNo, DRM_ERR_OK); } -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal2_078, TestSize.Level0) +HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal_077, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; MediaKeySystem *mediaKeySystem = nullptr; @@ -3441,18 +1756,25 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal2_078, TestSize.Lev filldata(&info); errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[2] = {0x07, 0x22}; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); + unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN + int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN + unsigned char testKeySessionResponse[12288] = OFFRESPONSE; + int32_t testKeySessionResponseLen = 12288; + if (g_isWisePlay) { + int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen, + testKeySessionResponse, &testKeySessionResponseLen, 10); + EXPECT_EQ(rett, 0);} else { + testKeySessionResponseLen = 50; + }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, + (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); + EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySession_Destroy(mediaKeySession); EXPECT_EQ(errNo, DRM_ERR_OK); errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); EXPECT_EQ(errNo, DRM_ERR_OK); } + HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_079, TestSize.Level0) { Drm_ErrCode errNo = DRM_ERR_UNKNOWN; @@ -3584,82 +1906,6 @@ HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_081, TestSize sleep(1); } -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_082, TestSize.Level0) -{ - MediaKeySystem *mediaKeySystem = nullptr; - string name; - string uuid; - Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - if (mediaKeySystem) { - MediaKeySystemObject *systemObject = reinterpret_cast(mediaKeySystem); - ContentProtectionLevel securityLevel = - ContentProtectionLevel::CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - OHOS::sptr keySessionImpl = nullptr; - systemObject->systemImpl_->~MediaKeySystemImpl(); - systemObject->systemImpl_->CreateMediaKeySession(securityLevel, &keySessionImpl); - keySessionImpl = nullptr; - MediaKeySystemCallback *allback = new MediaKeySystemCallback(); - allback->~MediaKeySystemCallback(); - OHOS::sptr fatory = MediaKeySystemFactoryImpl::GetInstance(); - fatory->Init(); - if (g_isWisePlay) { - name = "com.wiseplay.drm"; - } else { - name = "com.wiseplay.drm"; - } - fatory->GetMediaKeySystemUuid(name, uuid); - name = "com.test"; - fatory->GetMediaKeySystemUuid(name, uuid); - } - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_NE(errNo, DRM_ERR_OK); - MediaKeySystem *mediaKeySystem2 = nullptr; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem2); - EXPECT_NE(mediaKeySystem2, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem2); - mediaKeySystem2 = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} - -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SessionImplAbNormal_083, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[12288] = OFFRESPONSE; - int32_t testKeySessionResponseLen = 50; - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen); - if (mediaKeySession) { - MediaKeySessionObject *sessionObject = reinterpret_cast(mediaKeySession); - MediaKeySessionServiceCallback *Object = new MediaKeySessionServiceCallback(sessionObject->sessionImpl_); - std::map, MediaKeySessionKeyStatus> statusTable = { { { 0x01 }, - MediaKeySessionKeyStatus::MEDIA_KEY_SESSION_KEY_STATUS_USABLE } }; - bool hasNewGoodLicense = false; - Object->SendEventKeyChanged(statusTable, hasNewGoodLicense); - } - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} static void killclearplay(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession) { @@ -3728,45 +1974,7 @@ static void killclearplay2(MediaKeySystem *mediaKeySystem, MediaKeySession *medi EXPECT_NE(errNo, DRM_ERR_OK); } -HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackWithObject_084, TestSize.Level0) -{ - Drm_ErrCode errNo = DRM_ERR_UNKNOWN; - MediaKeySystem *mediaKeySystem = nullptr; - MediaKeySession *mediaKeySession = nullptr; - DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO; - errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem); - EXPECT_NE(mediaKeySystem, nullptr); - errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession); - EXPECT_NE(mediaKeySession, nullptr); - EXPECT_EQ(errNo, DRM_ERR_OK); - MediaKeySession_Callback callback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack }; - errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &callback); - EXPECT_EQ(errNo, DRM_ERR_OK); - OH_MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBackWithObj, - &TestSessoinKeyChangeCallBackWithObj }; - errNo = OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallback); - EXPECT_EQ(errNo, DRM_ERR_OK); - DRM_MediaKeyRequest mediaKeyRequest; - DRM_MediaKeyRequestInfo info; - filldata(&info); - errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest); - EXPECT_EQ(errNo, DRM_ERR_OK); - unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN - unsigned char testKeySessionResponse[2] = {0x07, 0x22}; - int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN - errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse, - (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen); - EXPECT_NE(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySession_Destroy(mediaKeySession); - EXPECT_EQ(errNo, DRM_ERR_OK); - errNo = OH_MediaKeySystem_Destroy(mediaKeySystem); - mediaKeySystem = nullptr; - EXPECT_EQ(errNo, DRM_ERR_OK); -} + HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_KillClearPlayHostAbNormal1, TestSize.Level0) {