1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <mutex>
16 #include <shared_mutex>
17 #include <string>
18 #include <refbase.h>
19 #include "cstdio"
20 #include "cstdlib"
21 #include <securec.h>
22 #include "native_drm_common.h"
23 #include "native_drm_err.h"
24 #include "gmock/gmock.h"
25 #include "native_drm_base.h"
26 #include "native_drm_object.h"
27 #include "i_mediadecryptmodule_service.h"
28 #include "native_mediakeysession.h"
29 #include "native_mediakeysystem.h"
30 #include "cstdbool"
31 #include "drm_types.h"
32 #include "drm_framework_unittest.h"
33 #include "drm_log.h"
34 #include "drm_death_recipient.h"
35 #include "key_session_impl.h"
36 #include "i_mediakeysystem_service.h"
37 #include "media_key_system_factory_impl.h"
38 #include "mediakeysystem_service_callback_stub.h"
39 #include "http.h"
40 #include "ashmem.h"
41 #include "media_decrypt_module_service_proxy.h"
42 #include <cstring>
43 #include <map>
44 #include <unordered_map>
45 #include "nocopyable.h"
46 #include "ipc_skeleton.h"
47 #include "i_keysession_service.h"
48 #include "i_keysession_service_callback.h"
49 #include "key_session_service_callback_stub.h"
50
51 #define DRM_SAMPLE_CHECK_AND_RETURN_RET_LOG(cond, ret, fmt, ...) \
52 do { \
53 if ((cond)) { \
54 printf(fmt, ##__VA_ARGS__); \
55 return ret; \
56 } \
57 } while (0)
58 #define DRM_SAMPLE_INFO_LOG(fmt, ...) fprintf(stdout, "[INFO] " fmt "\n", ##__VA_ARGS__)
59 #define DRM_SAMPLE_ERROR_LOG(fmt, ...) fprintf(stdout, "[ERROR] " fmt "\n", ##__VA_ARGS__)
60 #define OFFRESPONSE \
61 { \
62 0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \
63 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \
64 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \
65 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \
66 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \
67 }
68 #define REQUESTINFODATA \
69 { \
70 0x00, 0x00, 0x00, 0x8B, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \
71 0x00, 0x3D, 0x5E, 0x6D, 0x35, 0x9B, 0x9A, 0x41, 0xE8, 0xB8, \
72 0x43, 0xDD, 0x3C, 0x6E, 0x72, 0xC4, 0x2C, 0x00, 0x00, 0x00, \
73 0x6B, 0x7B, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6F, 0x6E, \
74 0x22, 0x3A, 0x22, 0x56, 0x31, 0x2E, 0x30, 0x22, 0x2C, 0x22, \
75 0x63, 0x6F, 0x6E, 0x74, 0x65, 0x6E, 0x74, 0x49, 0x44, 0x22, \
76 0x3A, 0x22, 0x64, 0x48, 0x4D, 0x74, 0x4D, 0x6A, 0x59, 0x30, \
77 0x4C, 0x54, 0x45, 0x77, 0x4F, 0x44, 0x41, 0x74, 0x59, 0x57, \
78 0x56, 0x7A, 0x22, 0x2C, 0x22, 0x6B, 0x69, 0x64, 0x73, 0x22, \
79 0x3A, 0x5B, 0x22, 0x47, 0x2B, 0x45, 0x6B, 0x2F, 0x2B, 0x58, \
80 0x6D, 0x55, 0x6B, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \
81 0x57, 0x51, 0x51, 0x49, 0x67, 0x3D, 0x3D, 0x22, 0x5D, 0x2C, \
82 0x22, 0x65, 0x6E, 0x73, 0x63, 0x68, 0x65, 0x6D, 0x61, 0x22, \
83 0x3A, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7D \
84 }
85 #define OFFREQUESTINFODATA \
86 { \
87 0x00, 0x00, 0x00, 0x8b, 0x70, 0x73, 0x73, 0x68, 0x00, 0x00, 0x00, \
88 0x00, 0x3d, 0x5e, 0x6d, 0x35, 0x9b, 0x9a, 0x41, 0xe8, 0xb8, \
89 0x43, 0xdd, 0x3c, 0x6e, 0x72, 0xc4, 0x2c, 0x00, 0x00, 0x00, \
90 0x6b, 0x7b, 0x22, 0x76, 0x65, 0x72, 0x73, 0x69, 0x6f, 0x6e, \
91 0x22, 0x3a, 0x22, 0x56, 0x31, 0x2e, 0x30, 0x22, 0x2c, 0x22, \
92 0x63, 0x6f, 0x6e, 0x74, 0x65, 0x6e, 0x74, 0x49, 0x44, 0x22, \
93 0x3a, 0x22, 0x64, 0x48, 0x4d, 0x74, 0x4d, 0x6a, 0x59, 0x30, \
94 0x4c, 0x54, 0x45, 0x77, 0x4f, 0x44, 0x41, 0x74, 0x59, 0x57, \
95 0x56, 0x7a, 0x22, 0x2c, 0x22, 0x6b, 0x69, 0x64, 0x73, 0x22, \
96 0x3a, 0x5b, 0x22, 0x47, 0x2b, 0x45, 0x6b, 0x2f, 0x2b, 0x58, \
97 0x6d, 0x55, 0x6b, 0x70, 0x42, 0x48, 0x51, 0x67, 0x58, 0x59, \
98 0x57, 0x51, 0x51, 0x49, 0x67, 0x3d, 0x3d, 0x22, 0x5d, 0x2c, \
99 0x22, 0x65, 0x6e, 0x73, 0x63, 0x68, 0x65, 0x6d, 0x61, 0x22, \
100 0x3a, 0x22, 0x63, 0x62, 0x63, 0x31, 0x22, 0x7d \
101 }
102 #define ONRESPONSE \
103 { \
104 0x30, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47, \
105 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, \
106 0x4E, 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, \
107 0x48, 0x64, 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, \
108 0x34, 0x5A, 0x48, 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D \
109 }
110
111
112 #define LICENSE_URL "http://license.dev.trustdta.com:8080/drmproxy/v3/getLicense"
113 #define PROVISION_URL "https://wiseplay-prv.cloud.huawei.com/provision/v1/wiseplay"
114 using namespace testing::ext;
115 using namespace std;
116
117 namespace {
118 const int32_t STEP_ONE = 1;
119 const int32_t STEP_TWO = 2;
120 const int32_t STEP_THREE = 3;
121 const int32_t STEP_FOUR = 4;
122 }
123
124 namespace OHOS {
125 namespace DrmStandard {
126
127 bool g_isWisePlay = false;
SetUpTestCase(void)128 void DrmFrameworkUnitTest::SetUpTestCase(void) {}
129
TearDownTestCase(void)130 void DrmFrameworkUnitTest::TearDownTestCase(void) {}
131
GetUuid()132 static const char *GetUuid()
133 {
134 if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) {
135 return "com.clearplay.drm";
136 } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) {
137 return "com.wiseplay.drm";
138 } else {
139 return "ERROR";
140 }
141 }
142
SetUp()143 void DrmFrameworkUnitTest::SetUp()
144 {
145 if (strcmp(GetUuid(), "com.wiseplay.drm") == 0) {
146 g_isWisePlay = true;
147 }
148 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
149 MediaKeySystem *mediaKeySystem = nullptr;
150 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
151 EXPECT_NE(mediaKeySystem, nullptr);
152 EXPECT_EQ(errNo, DRM_ERR_OK);
153 unsigned char request[12288] = { 0 }; // 12288:request len
154 int32_t requestLen = 12288; // 12288:request len
155 char defaultUrl[2048] = { 0 }; // 2048:url len
156 int32_t defaultUrlLen = 2048; // 2048:url len
157 DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
158 errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus);
159 EXPECT_EQ(errNo, DRM_ERR_OK);
160 if (certStatus == CERT_STATUS_NOT_PROVISIONED) {
161 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl,
162 defaultUrlLen);
163 unsigned char KeySystemResponse[12288] = OFFRESPONSE;
164 int32_t KeySystemResponseLen = 12288;
165 if (g_isWisePlay) {
166 int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10);
167 EXPECT_EQ(rett, 0);
168 } else {
169 KeySystemResponseLen = 50; // 50 is the length of system response
170 }
171 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, 0);
172 EXPECT_NE(errNo, DRM_ERR_OK);
173 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen);
174 EXPECT_EQ(errNo, DRM_ERR_OK);
175 }
176 OH_MediaKeySystem_Destroy(mediaKeySystem);
177 mediaKeySystem = nullptr;
178 }
179
TearDown()180 void DrmFrameworkUnitTest::TearDown() {}
181
GetDrmPlugin()182 static const char *GetDrmPlugin()
183 {
184 if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) {
185 return "killall -9 clearplay_host";
186 } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) {
187 return "killall -9 wiseplay_host";
188 } else {
189 return "ERROR";
190 }
191 }
192
TestSystemEventCallBack(DRM_EventType eventType,unsigned char * info,int32_t infoLen,char * extra)193 Drm_ErrCode TestSystemEventCallBack(DRM_EventType eventType, unsigned char *info,
194 int32_t infoLen, char *extra)
195 {
196 DRM_SAMPLE_INFO_LOG("TestSystemEventCallBack ok");
197 return DRM_ERR_OK;
198 }
199
TestSessoinEventCallBack(DRM_EventType eventType,unsigned char * info,int32_t infoLen,char * extra)200 Drm_ErrCode TestSessoinEventCallBack(DRM_EventType eventType, unsigned char *info,
201 int32_t infoLen, char *extra)
202 {
203 DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBack ok");
204 return DRM_ERR_OK;
205 }
206
TestSessoinKeyChangeCallBack(DRM_KeysInfo * keysInfo,bool hasNewGoodKeys)207 Drm_ErrCode TestSessoinKeyChangeCallBack(DRM_KeysInfo *keysInfo, bool hasNewGoodKeys)
208 {
209 DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBack ok");
210 return DRM_ERR_OK;
211 }
212
TestSystemEventCallBackWithObj(MediaKeySystem * mediaKeySystem,DRM_EventType eventType,uint8_t * info,int32_t infoLen,char * extra)213 Drm_ErrCode TestSystemEventCallBackWithObj(MediaKeySystem *mediaKeySystem, DRM_EventType eventType,
214 uint8_t *info, int32_t infoLen, char *extra)
215 {
216 DRM_SAMPLE_INFO_LOG("TestSystemEventCallBackWithObj ok");
217 if (mediaKeySystem == nullptr) {
218 return DRM_ERR_UNKNOWN;
219 }
220 DRM_SAMPLE_INFO_LOG("Event: event type: %d", eventType);
221 DRM_SAMPLE_INFO_LOG("Event: the info body is: ");
222 if (info != nullptr) {
223 for (int32_t i = 0; i < infoLen; i++) {
224 DRM_SAMPLE_INFO_LOG("%x", info[i]);
225 }
226 }
227 if (extra != nullptr) {
228 DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra);
229 }
230 return DRM_ERR_OK;
231 }
232
TestSessoinEventCallBackWithObj(MediaKeySession * mediaKeySessoin,DRM_EventType eventType,uint8_t * info,int32_t infoLen,char * extra)233 Drm_ErrCode TestSessoinEventCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_EventType eventType,
234 uint8_t *info, int32_t infoLen, char *extra)
235 {
236 DRM_SAMPLE_INFO_LOG("TestSessoinEventCallBackWithObj ok");
237 if (mediaKeySessoin == nullptr) {
238 return DRM_ERR_UNKNOWN;
239 }
240 DRM_SAMPLE_INFO_LOG("Event: the event type: %d", eventType);
241 DRM_SAMPLE_INFO_LOG("Event: the info body is: ");
242 if (info != nullptr) {
243 for (int32_t i = 0; i < infoLen; i++) {
244 DRM_SAMPLE_INFO_LOG("%x", info[i]);
245 }
246 }
247 if (extra != nullptr) {
248 DRM_SAMPLE_INFO_LOG("Event: the extra is: %s", extra);
249 }
250 return DRM_ERR_OK;
251 }
252
TestSessoinKeyChangeCallBackWithObj(MediaKeySession * mediaKeySessoin,DRM_KeysInfo * keysInfo,bool hasNewGoodKeys)253 Drm_ErrCode TestSessoinKeyChangeCallBackWithObj(MediaKeySession *mediaKeySessoin, DRM_KeysInfo *keysInfo,
254 bool hasNewGoodKeys)
255 {
256 DRM_SAMPLE_INFO_LOG("TestSessoinKeyChangeCallBackWithObj ok");
257 if (mediaKeySessoin == nullptr) {
258 return DRM_ERR_UNKNOWN;
259 }
260 for (uint32_t i = 0; i < keysInfo->keysInfoCount; i++) {
261 for (uint32_t j = 0; j < MAX_KEY_ID_LEN; j += STEP_FOUR) {
262 DRM_SAMPLE_INFO_LOG("KeyChangedEvent: keyid is: ");
263 DRM_SAMPLE_INFO_LOG("%x %x %x %x",
264 keysInfo->keyId[i][j], keysInfo->keyId[i][j + STEP_ONE],
265 keysInfo->keyId[i][j + STEP_TWO], keysInfo->keyId[i][j + STEP_THREE]);
266 }
267 DRM_SAMPLE_INFO_LOG("KeyChangedEvent: statusValue %s", keysInfo->statusValue[i]);
268 }
269 return DRM_ERR_OK;
270 }
271
272 /*
273 * Feature: Framework
274 * Function: Test to determine if the creation of this DRM instance is supported
275 * Sub function: NA
276 * Function point: NA
277 * Environmental conditions: NA
278 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
279 */
280 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedNormal_001, TestSize.Level0)
281 {
282 bool supported;
283 supported = OH_MediaKeySystem_IsSupported(GetUuid());
284 EXPECT_EQ(supported, true);
285 }
286
287 /*
288 * Feature: Framework
289 * Function: Test to determine if the creation of this DRM instance is supported
290 * Sub function: NA
291 * Function point: NA
292 * Environmental conditions: NA
293 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
294 */
295 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2Normal_002, TestSize.Level0)
296 {
297 bool supported;
298 supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4");
299 EXPECT_EQ(supported, true);
300 }
301
302 /*
303 * Feature: Framework
304 * Function: Test to determine if the creation of this DRM instance is supported
305 * Sub function: NA
306 * Function point: NA
307 * Environmental conditions: NA
308 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
309 */
310 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3Normal_003, TestSize.Level0)
311 {
312 bool supported;
313 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
314 EXPECT_EQ(supported, true);
315 }
316
317 /*
318 * Feature: Framework
319 * Function: Test to determine if the creation of this DRM instance is supported
320 * Sub function: NA
321 * Function point: NA
322 * Environmental conditions: NA
323 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
324 */
325 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupportedAbNormal_004, TestSize.Level0)
326 {
327 bool supported = true;
328 supported = OH_MediaKeySystem_IsSupported("com.drm.clearpla");
329 EXPECT_EQ(supported, false);
330 supported = OH_MediaKeySystem_IsSupported("");
331 EXPECT_EQ(supported, false);
332 supported = OH_MediaKeySystem_IsSupported(nullptr);
333 EXPECT_EQ(supported, false);
334 }
335
336 /*
337 * Feature: Framework
338 * Function: Test to determine if the creation of this DRM instance is supported
339 * Sub function: NA
340 * Function point: NA
341 * Environmental conditions: NA
342 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
343 */
344 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported2AbNormal_005, TestSize.Level0)
345 {
346 bool supported = true;
347 supported = OH_MediaKeySystem_IsSupported2("com.drm.clearpla", "video/mp4");
348 EXPECT_EQ(supported, false);
349 supported = OH_MediaKeySystem_IsSupported2("", "video/mp4");
350 EXPECT_EQ(supported, false);
351 supported = OH_MediaKeySystem_IsSupported2(nullptr, "video/mp4");
352 EXPECT_EQ(supported, false);
353 supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "ideo/mp4");
354 if (g_isWisePlay) {
355 EXPECT_EQ(supported, true);
356 } else {
357 EXPECT_EQ(supported, false);
358 }
359 supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "");
360 EXPECT_EQ(supported, false);
361 supported = OH_MediaKeySystem_IsSupported2(GetUuid(), nullptr);
362 EXPECT_EQ(supported, false);
363 }
364
365 /*
366 * Feature: Framework
367 * Function: Test to determine if the creation of this DRM instance is supported
368 * Sub function: NA
369 * Function point: NA
370 * Environmental conditions: NA
371 * Case description: Test to determine if it supports creating the DRM instance interface OH_MediaKeySystem_IsSupported
372 */
373 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemIsSupported3AbNormal_006, TestSize.Level0)
374 {
375 bool supported = true;
376 supported = OH_MediaKeySystem_IsSupported3("com.drm.clearpla", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
377 EXPECT_EQ(supported, false);
378 supported = OH_MediaKeySystem_IsSupported3("", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
379 EXPECT_EQ(supported, false);
380 supported = OH_MediaKeySystem_IsSupported3(nullptr, "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
381 EXPECT_EQ(supported, false);
382 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "ideo/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
383 if (g_isWisePlay) {
384 EXPECT_EQ(supported, true);
385 } else {
386 EXPECT_EQ(supported, false);
387 }
388 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
389 EXPECT_EQ(supported, false);
390 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), nullptr, CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
391 EXPECT_EQ(supported, false);
392 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4",
393 (DRM_ContentProtectionLevel)(CONTENT_PROTECTION_LEVEL_UNKNOWN - 1));
394 EXPECT_EQ(supported, false);
395 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4",
396 (DRM_ContentProtectionLevel)CONTENT_PROTECTION_LEVEL_MAX);
397 EXPECT_EQ(supported, false);
398 }
399
400 /*
401 * Feature: Framework
402 * Function: Test and create DRM instances
403 * Sub function: NA
404 * Function point: NA
405 * Environmental conditions: NA
406 * Case Description: Test Creating DRM Instance
407 */
408 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_007, TestSize.Level0)
409 {
410 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
411 MediaKeySystem *mediaKeySystem = nullptr;
412 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
413 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
414 EXPECT_NE(mediaKeySystem, nullptr);
415 EXPECT_EQ(errNo, DRM_ERR_OK);
416 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
417 EXPECT_EQ(errNo, DRM_ERR_OK);
418 EXPECT_GT(contentProtectionLevel, 0);
419 if (mediaKeySystem != nullptr) {
420 OH_MediaKeySystem_Destroy(mediaKeySystem);
421 mediaKeySystem = nullptr;
422 }
423 }
424
425 /*
426 * Feature: Framework
427 * Function: Test and create DRM instances
428 * Sub function: NA
429 * Function point: NA
430 * Environmental conditions: NA
431 * Case Description: Testing for an incorrect uuid and unsuccessful creation of DRM instance.
432 */
433 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_008, TestSize.Level0)
434 {
435 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
436 MediaKeySystem *mediaKeySystem = nullptr;
437 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
438 errNo = OH_MediaKeySystem_Create("com.drm.clerpay", &mediaKeySystem);
439 EXPECT_EQ(mediaKeySystem, nullptr);
440 EXPECT_NE(errNo, DRM_ERR_OK);
441 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
442 EXPECT_NE(errNo, DRM_ERR_OK);
443 }
444
445 /*
446 * Feature: Framework
447 * Function: Test and create DRM instances
448 * Sub function: NA
449 * Function point: NA
450 * Environmental conditions: NA
451 * Case Description: Test passed in an empty uuid and failed to create a DRM instance.
452 */
453 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemAbNormal_009, TestSize.Level0)
454 {
455 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
456 MediaKeySystem *mediaKeySystem = nullptr;
457 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
458 errNo = OH_MediaKeySystem_Create("", &mediaKeySystem);
459 EXPECT_EQ(mediaKeySystem, nullptr);
460 EXPECT_NE(errNo, DRM_ERR_OK);
461 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
462 EXPECT_NE(errNo, DRM_ERR_OK);
463 }
464
465 /*
466 * Feature: Framework
467 * Function: Test and create DRM instances
468 * Sub function: NA
469 * Function point: NA
470 * Environmental conditions: NA
471 * Case description: After the DRM instance is created, it is destroyed, and then the subsequent interface is called.
472 * The interface returns unsuccessful.
473 */
474 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystemNormal_010, TestSize.Level0)
475 {
476 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
477 MediaKeySystem *mediaKeySystem = nullptr;
478 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
479 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
480 EXPECT_NE(mediaKeySystem, nullptr);
481 EXPECT_EQ(errNo, DRM_ERR_OK);
482 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
483 mediaKeySystem = nullptr;
484 EXPECT_EQ(errNo, DRM_ERR_OK);
485 mediaKeySystem = nullptr;
486 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
487 EXPECT_NE(errNo, DRM_ERR_OK);
488 }
489
490 /*
491 * Feature: Framework
492 * Function: Test and create sessions
493 * Sub function: NA
494 * Function point: NA
495 * Environmental conditions: NA
496 * Case Description: Test Creating Sessions
497 */
498 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionNormal_011, TestSize.Level0)
499 {
500 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
501 MediaKeySystem *mediaKeySystem = nullptr;
502 MediaKeySession *mediaKeySession = nullptr;
503 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
504 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
505 EXPECT_NE(mediaKeySystem, nullptr);
506 EXPECT_EQ(errNo, DRM_ERR_OK);
507 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
508 EXPECT_EQ(errNo, DRM_ERR_OK);
509 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
510 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
511 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
512 mediaKeySystem = nullptr;
513 EXPECT_EQ(errNo, DRM_ERR_OK);
514 }
515
516 /*
517 * Feature: Framework
518 * Function: Test that the RequireSecureDecoderModule interface is functioning properly
519 * Sub function: NA
520 * Function point: NA
521 * Environmental conditions: NA
522 * Case description: Testing that the RequireSecureDecoderModule interface is functioning properly
523 */
524 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleNormal_012, TestSize.Level0)
525 {
526 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
527 MediaKeySystem *mediaKeySystem = nullptr;
528 MediaKeySession *mediaKeySession = nullptr;
529 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
530 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
531 EXPECT_NE(mediaKeySystem, nullptr);
532 EXPECT_EQ(errNo, DRM_ERR_OK);
533 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
534 EXPECT_NE(mediaKeySession, nullptr);
535 EXPECT_EQ(errNo, DRM_ERR_OK);
536 bool requireSecureDecoder;
537 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder);
538 EXPECT_EQ(errNo, DRM_ERR_OK);
539 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
540 EXPECT_EQ(errNo, DRM_ERR_OK);
541 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
542 mediaKeySystem = nullptr;
543 EXPECT_EQ(errNo, DRM_ERR_OK);
544 }
545
546 /*
547 * Feature: Framework
548 * Function: RequireSecureDecoderModule Exception Test Input Error mimtype
549 * Sub function: NA
550 * Function point: NA
551 * Environmental conditions: NA
552 * Case Description: RequireSecureDecoderModule Exception Test
553 */
554 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_013, TestSize.Level0)
555 {
556 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
557 MediaKeySystem *mediaKeySystem = nullptr;
558 MediaKeySession *mediaKeySession = nullptr;
559 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
560 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
561 EXPECT_NE(mediaKeySystem, nullptr);
562 EXPECT_EQ(errNo, DRM_ERR_OK);
563 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
564 EXPECT_NE(mediaKeySession, nullptr);
565 EXPECT_EQ(errNo, DRM_ERR_OK);
566 bool requireSecureDecoder = false;
567 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "asdssadadsa", &requireSecureDecoder);
568 EXPECT_EQ(errNo, DRM_ERR_OK);
569 EXPECT_EQ(requireSecureDecoder, false);
570 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
571 EXPECT_EQ(errNo, DRM_ERR_OK);
572 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
573 mediaKeySystem = nullptr;
574 EXPECT_EQ(errNo, DRM_ERR_OK);
575 }
576
577 /*
578 * Feature: Framework
579 * Function: RequireSecureDecoderModule Exception Test Input Error mimtype
580 * Sub function: NA
581 * Function point: NA
582 * Environmental conditions: NA
583 * Case Description: RequireSecureDecoderModule Exception Test
584 */
585 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_014, TestSize.Level0)
586 {
587 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
588 MediaKeySystem *mediaKeySystem = nullptr;
589 MediaKeySession *mediaKeySession = nullptr;
590 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
591 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
592 EXPECT_NE(mediaKeySystem, nullptr);
593 EXPECT_EQ(errNo, DRM_ERR_OK);
594 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
595 EXPECT_NE(mediaKeySession, nullptr);
596 EXPECT_EQ(errNo, DRM_ERR_OK);
597 bool requireSecureDecoder = false;
598 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "", &requireSecureDecoder);
599 EXPECT_NE(errNo, DRM_ERR_OK);
600 EXPECT_EQ(requireSecureDecoder, false);
601 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
602 EXPECT_EQ(errNo, DRM_ERR_OK);
603 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
604 mediaKeySystem = nullptr;
605 EXPECT_EQ(errNo, DRM_ERR_OK);
606 }
607
608 /*
609 * Feature: Framework
610 * Function: RequireSecureDecoderModule Exception Test Input Error mimtype
611 * Sub function: NA
612 * Function point: NA
613 * Environmental conditions: NA
614 * Case Description: RequireSecureDecoderModule Exception Test
615 */
616 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_015, TestSize.Level0)
617 {
618 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
619 MediaKeySystem *mediaKeySystem = nullptr;
620 MediaKeySession *mediaKeySession = nullptr;
621 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
622 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
623 EXPECT_NE(mediaKeySystem, nullptr);
624 EXPECT_EQ(errNo, DRM_ERR_OK);
625 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
626 EXPECT_NE(mediaKeySession, nullptr);
627 EXPECT_EQ(errNo, DRM_ERR_OK);
628 bool requireSecureDecoder = false;
629 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, nullptr, &requireSecureDecoder);
630 EXPECT_NE(errNo, DRM_ERR_OK);
631 EXPECT_EQ(requireSecureDecoder, false);
632 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
633 EXPECT_EQ(errNo, DRM_ERR_OK);
634 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
635 mediaKeySystem = nullptr;
636 EXPECT_EQ(errNo, DRM_ERR_OK);
637 }
638
639 /*
640 * Feature: Framework
641 * Function: RequireSecureDecoderModule Exception Test Input Error mimtype
642 * Sub function: NA
643 * Function point: NA
644 * Environmental conditions: NA
645 * Case Description: RequireSecureDecoderModule Exception Test
646 */
647 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_016, TestSize.Level0)
648 {
649 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
650 MediaKeySystem *mediaKeySystem = nullptr;
651 MediaKeySession *mediaKeySession = nullptr;
652 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
653 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
654 EXPECT_NE(mediaKeySystem, nullptr);
655 EXPECT_EQ(errNo, DRM_ERR_OK);
656 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
657 EXPECT_NE(mediaKeySession, nullptr);
658 EXPECT_EQ(errNo, DRM_ERR_OK);
659 bool requireSecureDecoder = false;
660 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", nullptr);
661 EXPECT_NE(errNo, DRM_ERR_OK);
662 EXPECT_EQ(requireSecureDecoder, false);
663 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
664 EXPECT_EQ(errNo, DRM_ERR_OK);
665 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
666 EXPECT_EQ(errNo, DRM_ERR_OK);
667 }
668
669 /*
670 * Feature: Framework
671 * Function: RequireSecureDecoderModule Exception Test Input Error mimtype
672 * Sub function: NA
673 * Function point: NA
674 * Environmental conditions: NA
675 * Case Description: RequireSecureDecoderModule Exception Test
676 */
677 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RequireSecureDecoderModuleAbNormal_017, TestSize.Level0)
678 {
679 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
680 MediaKeySystem *mediaKeySystem = nullptr;
681 MediaKeySession *mediaKeySession = nullptr;
682 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
683 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
684 EXPECT_NE(mediaKeySystem, nullptr);
685 EXPECT_EQ(errNo, DRM_ERR_OK);
686 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
687 EXPECT_NE(mediaKeySession, nullptr);
688 EXPECT_EQ(errNo, DRM_ERR_OK);
689 bool requireSecureDecoder = false;
690 errNo = OH_MediaKeySession_RequireSecureDecoderModule(nullptr, "video/mp4", &requireSecureDecoder);
691 EXPECT_NE(errNo, DRM_ERR_OK);
692 EXPECT_EQ(requireSecureDecoder, false);
693 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
694 EXPECT_EQ(errNo, DRM_ERR_OK);
695 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
696 EXPECT_EQ(errNo, DRM_ERR_OK);
697 }
698
699 /*
700 * Feature: Framework
701 * Function: GenerateKeySystemRequest normal testing to obtain normal requests
702 * Sub function: NA
703 * Function point: NA
704 * Environmental conditions: NA
705 * Case description: GenerateKeySystemRequest obtained a normal request through normal testing
706 */
707 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestNormal_018, TestSize.Level0)
708 {
709 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
710 MediaKeySystem *mediaKeySystem = nullptr;
711 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
712 EXPECT_NE(mediaKeySystem, nullptr);
713 EXPECT_EQ(errNo, DRM_ERR_OK);
714 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
715 EXPECT_EQ(errNo, DRM_ERR_OK);
716 }
717
718 /*
719 * Feature: Framework
720 * Function: GenerateKeySystemRequest parameter exception testing
721 * Sub function: NA
722 * Function point: NA
723 * Environmental conditions: NA
724 * Case Description: GenerateKeySystemRequest Parameter Exception Test
725 */
726 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateKeySystemRequestAbNormal_019, TestSize.Level0)
727 {
728 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
729 MediaKeySystem *mediaKeySystem = nullptr;
730 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
731 EXPECT_NE(mediaKeySystem, nullptr);
732 EXPECT_EQ(errNo, DRM_ERR_OK);
733 unsigned char request[12288] = { 0 }; // 12288:request len
734 int32_t requestLen = 12288; // 12288:request len
735 char defaultUrl[2048] = { 0 }; // 2048:url len
736 int32_t defaultUrlLen = 2048; // 2048:url len
737 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(nullptr, request, &requestLen, defaultUrl, defaultUrlLen);
738 EXPECT_NE(errNo, DRM_ERR_OK);
739 requestLen = 12288; // 12288:request len
740 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, nullptr, &requestLen, defaultUrl,
741 defaultUrlLen);
742 EXPECT_NE(errNo, DRM_ERR_OK);
743 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, nullptr, defaultUrl, defaultUrlLen);
744 EXPECT_NE(errNo, DRM_ERR_OK);
745 requestLen = 12288; // 12288:request len
746 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, nullptr, defaultUrlLen);
747 EXPECT_NE(errNo, DRM_ERR_OK);
748 requestLen = 12288; // 12288:request len
749 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl, 0);
750 EXPECT_NE(errNo, DRM_ERR_OK);
751 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
752 EXPECT_EQ(errNo, DRM_ERR_OK);
753 }
754
755 /*
756 * Feature: Framework
757 * Function: Processing device certificate response testing
758 * Sub function: NA
759 * Function point: NA
760 * Environmental conditions: NA
761 * Case Description: Processing Device Certificate Response Testing
762 */
763 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_020, TestSize.Level0)
764 {
765 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
766 MediaKeySystem *mediaKeySystem = nullptr;
767 MediaKeySession *mediaKeySession = nullptr;
768 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
769 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
770 EXPECT_NE(mediaKeySystem, nullptr);
771 EXPECT_EQ(errNo, DRM_ERR_OK);
772 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
773 EXPECT_EQ(errNo, DRM_ERR_OK);
774 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
775 EXPECT_NE(mediaKeySession, nullptr);
776 EXPECT_EQ(errNo, DRM_ERR_OK);
777 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
778 EXPECT_EQ(errNo, DRM_ERR_OK);
779 }
780
781
782 /*
783 * Feature: Framework
784 * Function: Processing device certificate response testing
785 * Sub function: NA
786 * Function point: NA
787 * Environmental conditions: NA
788 * Case Description: Processing Device Certificate Response Testing
789 */
790 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_021, TestSize.Level0)
791 {
792 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
793 MediaKeySystem *mediaKeySystem = nullptr;
794 MediaKeySession *mediaKeySession = nullptr;
795 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
796 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
797 EXPECT_NE(mediaKeySystem, nullptr);
798 EXPECT_EQ(errNo, DRM_ERR_OK);
799 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
800 EXPECT_NE(mediaKeySession, nullptr);
801 EXPECT_EQ(errNo, DRM_ERR_OK);
802 unsigned char KeySystemResponse[12288] = OFFRESPONSE;
803 int32_t KeySystemResponseLen = 12288;
804 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(nullptr, KeySystemResponse, KeySystemResponseLen);
805 EXPECT_NE(errNo, DRM_ERR_OK);
806 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
807 EXPECT_EQ(errNo, DRM_ERR_OK);
808 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
809 EXPECT_EQ(errNo, DRM_ERR_OK);
810 }
811
812 /*
813 * Feature: Framework
814 * Function: Processing device certificate response testing
815 * Sub function: NA
816 * Function point: NA
817 * Environmental conditions: NA
818 * Case Description: Processing Device Certificate Response Testing
819 */
820 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_022, TestSize.Level0)
821 {
822 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
823 MediaKeySystem *mediaKeySystem = nullptr;
824 MediaKeySession *mediaKeySession = nullptr;
825 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
826 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
827 EXPECT_NE(mediaKeySystem, nullptr);
828 EXPECT_EQ(errNo, DRM_ERR_OK);
829 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
830 EXPECT_NE(mediaKeySession, nullptr);
831 EXPECT_EQ(errNo, DRM_ERR_OK);
832 int32_t KeySystemResponseLen = 12288;
833 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, nullptr, KeySystemResponseLen);
834 EXPECT_NE(errNo, DRM_ERR_OK);
835 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
836 EXPECT_EQ(errNo, DRM_ERR_OK);
837 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
838 EXPECT_EQ(errNo, DRM_ERR_OK);
839 }
840
841 /*
842 * Feature: Framework
843 * Function: Processing device certificate response testing
844 * Sub function: NA
845 * Function point: NA
846 * Environmental conditions: NA
847 * Case Description: Processing Device Certificate Response Testing
848 */
849 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_023, TestSize.Level0)
850 {
851 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
852 MediaKeySystem *mediaKeySystem = nullptr;
853 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
854 EXPECT_NE(mediaKeySystem, nullptr);
855 EXPECT_EQ(errNo, DRM_ERR_OK);
856 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
857 EXPECT_EQ(errNo, DRM_ERR_OK);
858 }
859
860 /*
861 * Feature: Framework
862 * Function: Processing device certificate response testing
863 * Sub function: NA
864 * Function point: NA
865 * Environmental conditions: NA
866 * Case Description: Processing Device Certificate Response Testing
867 */
868 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestNormal_024, TestSize.Level0)
869 {
870 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
871 MediaKeySystem *mediaKeySystem = nullptr;
872 MediaKeySession *mediaKeySession = nullptr;
873 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
874 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
875 EXPECT_NE(mediaKeySystem, nullptr);
876 EXPECT_EQ(errNo, DRM_ERR_OK);
877 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
878 EXPECT_NE(mediaKeySession, nullptr);
879 EXPECT_EQ(errNo, DRM_ERR_OK);
880 // mediakeysession
881 DRM_MediaKeyRequest mediaKeyRequest;
882 DRM_MediaKeyRequestInfo info;
883 unsigned char testData[139] = REQUESTINFODATA;
884 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
885 info.initDataLen = sizeof(testData);
886 info.type = MEDIA_KEY_TYPE_ONLINE;
887 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
888 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
889 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
890 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
891 info.optionsCount = 1;
892 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
893 EXPECT_EQ(errNo, DRM_ERR_OK);
894 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
895 EXPECT_EQ(errNo, DRM_ERR_OK);
896 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
897 EXPECT_EQ(errNo, DRM_ERR_OK);
898 }
899
900 /*
901 * Feature: Framework
902 * Function: Processing device certificate response testing
903 * Sub function: NA
904 * Function point: NA
905 * Environmental conditions: NA
906 * Case Description: Processing Device Certificate Response Testing
907 */
908 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_025, TestSize.Level0)
909 {
910 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
911 MediaKeySystem *mediaKeySystem = nullptr;
912 MediaKeySession *mediaKeySession = nullptr;
913 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
914 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
915 EXPECT_NE(mediaKeySystem, nullptr);
916 EXPECT_EQ(errNo, DRM_ERR_OK);
917 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
918 EXPECT_NE(mediaKeySession, nullptr);
919 EXPECT_EQ(errNo, DRM_ERR_OK);
920 // mediakeysession
921 DRM_MediaKeyRequest mediaKeyRequest;
922 DRM_MediaKeyRequestInfo info;
923 unsigned char testData[139] = REQUESTINFODATA;
924 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
925 info.initDataLen = sizeof(testData);
926 info.type = MEDIA_KEY_TYPE_ONLINE;
927 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
928 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
929 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
930 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
931 info.optionsCount = 1;
932 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(nullptr, &info, &mediaKeyRequest);
933 EXPECT_NE(errNo, DRM_ERR_OK);
934 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
935 EXPECT_EQ(errNo, DRM_ERR_OK);
936 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
937 EXPECT_EQ(errNo, DRM_ERR_OK);
938 }
939
940 /*
941 * Feature: Framework
942 * Function: Processing device certificate response testing
943 * Sub function: NA
944 * Function point: NA
945 * Environmental conditions: NA
946 * Case Description: Processing Device Certificate Response Testing
947 */
948 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_026, TestSize.Level0)
949 {
950 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
951 MediaKeySystem *mediaKeySystem = nullptr;
952 MediaKeySession *mediaKeySession = nullptr;
953 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
954 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
955 EXPECT_NE(mediaKeySystem, nullptr);
956 EXPECT_EQ(errNo, DRM_ERR_OK);
957 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
958 EXPECT_NE(mediaKeySession, nullptr);
959 EXPECT_EQ(errNo, DRM_ERR_OK);
960 // mediakeysession
961 DRM_MediaKeyRequest mediaKeyRequest;
962 DRM_MediaKeyRequestInfo info;
963 unsigned char testData[139] = REQUESTINFODATA;
964 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
965 info.initDataLen = sizeof(testData);
966 info.type = MEDIA_KEY_TYPE_ONLINE;
967 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
968 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
969 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
970 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
971 info.optionsCount = 1;
972 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, nullptr, &mediaKeyRequest);
973 EXPECT_NE(errNo, DRM_ERR_OK);
974 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
975 EXPECT_EQ(errNo, DRM_ERR_OK);
976 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
977 EXPECT_EQ(errNo, DRM_ERR_OK);
978 }
979
980 /*
981 * Feature: Framework
982 * Function: Processing device certificate response testing
983 * Sub function: NA
984 * Function point: NA
985 * Environmental conditions: NA
986 * Case Description: Processing Device Certificate Response Testing
987 */
988 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateMediaKeyRequestAbNormal_027, TestSize.Level0)
989 {
990 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
991 MediaKeySystem *mediaKeySystem = nullptr;
992 MediaKeySession *mediaKeySession = nullptr;
993 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
994 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
995 EXPECT_NE(mediaKeySystem, nullptr);
996 EXPECT_EQ(errNo, DRM_ERR_OK);
997 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
998 EXPECT_NE(mediaKeySession, nullptr);
999 EXPECT_EQ(errNo, DRM_ERR_OK);
1000 // mediakeysession
1001 DRM_MediaKeyRequestInfo info;
1002 unsigned char testData[139] = REQUESTINFODATA;
1003 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1004 info.initDataLen = sizeof(testData);
1005 info.type = MEDIA_KEY_TYPE_ONLINE;
1006 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1007 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1008 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1009 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1010 info.optionsCount = 1;
1011 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, nullptr);
1012 EXPECT_NE(errNo, DRM_ERR_OK);
1013 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1014 EXPECT_EQ(errNo, DRM_ERR_OK);
1015 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1016 EXPECT_EQ(errNo, DRM_ERR_OK);
1017 }
1018
1019 /*
1020 * Feature: Framework
1021 * Function: Processing device certificate response testing
1022 * Sub function: NA
1023 * Function point: NA
1024 * Environmental conditions: NA
1025 * Case Description: Processing Device Certificate Response Testing
1026 */
1027 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseNormal_028, TestSize.Level0)
1028 {
1029 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1030 MediaKeySystem *mediaKeySystem = nullptr;
1031 MediaKeySession *mediaKeySession = nullptr;
1032 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1033 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1034 EXPECT_NE(mediaKeySystem, nullptr);
1035 EXPECT_EQ(errNo, DRM_ERR_OK);
1036 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1037 EXPECT_NE(mediaKeySession, nullptr);
1038 EXPECT_EQ(errNo, DRM_ERR_OK);
1039 // mediakeysession
1040 DRM_MediaKeyRequest mediaKeyRequest;
1041 DRM_MediaKeyRequestInfo info;
1042 unsigned char testData[139] = REQUESTINFODATA;
1043 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1044 info.initDataLen = sizeof(testData);
1045 info.type = MEDIA_KEY_TYPE_ONLINE;
1046 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1047 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1048 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1049 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1050 info.optionsCount = 1;
1051 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1052 EXPECT_EQ(errNo, DRM_ERR_OK);
1053 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1054 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1055 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1056 int32_t testKeySessionResponseLen = 12288;
1057 if (g_isWisePlay) {
1058 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1059 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1060 EXPECT_EQ(rett, 0);
1061 } else {
1062 testKeySessionResponseLen = 50;
1063 }
1064 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1065 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1066 EXPECT_EQ(errNo, DRM_ERR_OK);
1067 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1068 EXPECT_EQ(errNo, DRM_ERR_OK);
1069 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1070 EXPECT_EQ(errNo, DRM_ERR_OK);
1071 }
1072
1073 /*
1074 * Feature: Framework
1075 * Function: Processing device certificate response testing
1076 * Sub function: NA
1077 * Function point: NA
1078 * Environmental conditions: NA
1079 * Case Description: Processing Device Certificate Response Testing
1080 */
1081 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_029, TestSize.Level0)
1082 {
1083 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1084 MediaKeySystem *mediaKeySystem = nullptr;
1085 MediaKeySession *mediaKeySession = nullptr;
1086 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1087 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1088 EXPECT_NE(mediaKeySystem, nullptr);
1089 EXPECT_EQ(errNo, DRM_ERR_OK);
1090 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1091 EXPECT_NE(mediaKeySession, nullptr);
1092 EXPECT_EQ(errNo, DRM_ERR_OK);
1093 // mediakeysession
1094 DRM_MediaKeyRequest mediaKeyRequest;
1095 DRM_MediaKeyRequestInfo info;
1096 unsigned char testData[1] = { 0 };
1097 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1098 info.initDataLen = sizeof(testData);
1099 info.type = MEDIA_KEY_TYPE_ONLINE;
1100 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1101 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1102 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1103 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1104 info.optionsCount = 1;
1105 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1106 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1107 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1108 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1109 int32_t testKeySessionResponseLen = 12288;
1110 if (g_isWisePlay) {
1111 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1112 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1113 EXPECT_EQ(rett, 0);
1114 } else {
1115 testKeySessionResponseLen = 50;
1116 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(nullptr, testKeySessionResponse,
1117 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1118 EXPECT_NE(errNo, DRM_ERR_OK);
1119 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1120 EXPECT_EQ(errNo, DRM_ERR_OK);
1121 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1122 EXPECT_EQ(errNo, DRM_ERR_OK);
1123 }
1124
1125 /*
1126 * Feature: Framework
1127 * Function: Processing device certificate response testing
1128 * Sub function: NA
1129 * Function point: NA
1130 * Environmental conditions: NA
1131 * Case Description: Processing Device Certificate Response Testing
1132 */
1133 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_030, TestSize.Level0)
1134 {
1135 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1136 MediaKeySystem *mediaKeySystem = nullptr;
1137 MediaKeySession *mediaKeySession = nullptr;
1138 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1139 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1140 EXPECT_NE(mediaKeySystem, nullptr);
1141 EXPECT_EQ(errNo, DRM_ERR_OK);
1142 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1143 EXPECT_NE(mediaKeySession, nullptr);
1144 EXPECT_EQ(errNo, DRM_ERR_OK);
1145 // mediakeysession
1146 DRM_MediaKeyRequest mediaKeyRequest;
1147 DRM_MediaKeyRequestInfo info;
1148 unsigned char testData[1] = { 0 };
1149 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1150 info.initDataLen = sizeof(testData);
1151 info.type = MEDIA_KEY_TYPE_ONLINE;
1152 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1153 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1154 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1155 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1156 info.optionsCount = 1;
1157 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1158 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1159 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1160 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, nullptr, 0,
1161 onlineMediaKeyId, &onlineMediaKeyIdLen);
1162 EXPECT_NE(errNo, DRM_ERR_OK);
1163 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1164 EXPECT_EQ(errNo, DRM_ERR_OK);
1165 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1166 EXPECT_EQ(errNo, DRM_ERR_OK);
1167 }
1168
1169 /*
1170 * Feature: Framework
1171 * Function: Processing device certificate response testing
1172 * Sub function: NA
1173 * Function point: NA
1174 * Environmental conditions: NA
1175 * Case Description: Processing Device Certificate Response Testing
1176 */
1177 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_031, TestSize.Level0)
1178 {
1179 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1180 MediaKeySystem *mediaKeySystem = nullptr;
1181 MediaKeySession *mediaKeySession = nullptr;
1182 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1183 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1184 EXPECT_NE(mediaKeySystem, nullptr);
1185 EXPECT_EQ(errNo, DRM_ERR_OK);
1186 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1187 EXPECT_NE(mediaKeySession, nullptr);
1188 EXPECT_EQ(errNo, DRM_ERR_OK);
1189 // mediakeysession
1190 DRM_MediaKeyRequest mediaKeyRequest;
1191 DRM_MediaKeyRequestInfo info;
1192 unsigned char testData[139] = REQUESTINFODATA;
1193 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1194 info.initDataLen = sizeof(testData);
1195 info.type = MEDIA_KEY_TYPE_ONLINE;
1196 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1197 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1198 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1199 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1200 info.optionsCount = 1;
1201 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1202 EXPECT_EQ(errNo, DRM_ERR_OK);
1203 unsigned char testKeySessionResponse[50] = OFFRESPONSE;
1204 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1205 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1206 (int32_t)(sizeof(testKeySessionResponse)), nullptr, &onlineMediaKeyIdLen);
1207 EXPECT_NE(errNo, DRM_ERR_OK);
1208 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1209 EXPECT_EQ(errNo, DRM_ERR_OK);
1210 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1211 EXPECT_EQ(errNo, DRM_ERR_OK);
1212 }
1213
1214
1215 /*
1216 * Feature: Framework
1217 * Function: Processing device certificate response testing
1218 * Sub function: NA
1219 * Function point: NA
1220 * Environmental conditions: NA
1221 * Case Description: Processing Device Certificate Response Testing
1222 */
1223 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_032, TestSize.Level0)
1224 {
1225 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1226 MediaKeySystem *mediaKeySystem = nullptr;
1227 MediaKeySession *mediaKeySession = nullptr;
1228 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1229 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1230 EXPECT_NE(mediaKeySystem, nullptr);
1231 EXPECT_EQ(errNo, DRM_ERR_OK);
1232 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1233 EXPECT_NE(mediaKeySession, nullptr);
1234 EXPECT_EQ(errNo, DRM_ERR_OK);
1235 // mediakeysession
1236 DRM_MediaKeyRequest mediaKeyRequest;
1237 DRM_MediaKeyRequestInfo info;
1238 unsigned char testData[139] = REQUESTINFODATA;
1239 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1240 info.initDataLen = sizeof(testData);
1241 info.type = MEDIA_KEY_TYPE_ONLINE;
1242 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1243 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1244 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1245 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1246 info.optionsCount = 1;
1247 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1248 EXPECT_EQ(errNo, DRM_ERR_OK);
1249 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1250 unsigned char testKeySessionResponse[50] = OFFRESPONSE;
1251 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1252 (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, nullptr);
1253 EXPECT_NE(errNo, DRM_ERR_OK);
1254 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1255 EXPECT_EQ(errNo, DRM_ERR_OK);
1256 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1257 EXPECT_EQ(errNo, DRM_ERR_OK);
1258 }
1259
1260 /*
1261 * Feature: Framework
1262 * Function: Processing device certificate response testing
1263 * Sub function: NA
1264 * Function point: NA
1265 * Environmental conditions: NA
1266 * Case Description: Processing Device Certificate Response Testing
1267 */
1268 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusNormal_033, TestSize.Level0)
1269 {
1270 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1271 MediaKeySystem *mediaKeySystem = nullptr;
1272 MediaKeySession *mediaKeySession = nullptr;
1273 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1274 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1275 EXPECT_NE(mediaKeySystem, nullptr);
1276 EXPECT_EQ(errNo, DRM_ERR_OK);
1277 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1278 EXPECT_NE(mediaKeySession, nullptr);
1279 EXPECT_EQ(errNo, DRM_ERR_OK);
1280 // mediakeysession
1281 DRM_MediaKeyRequest mediaKeyRequest;
1282 DRM_MediaKeyRequestInfo info;
1283 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1284 unsigned char testData[139] = REQUESTINFODATA;
1285 info.type = MEDIA_KEY_TYPE_ONLINE;
1286 info.initDataLen = sizeof(testData);
1287 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1288 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1289 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1290 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1291 info.optionsCount = 1;
1292 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1293 EXPECT_EQ(errNo, DRM_ERR_OK);
1294 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1295 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1296 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1297 int32_t testKeySessionResponseLen = 12288;
1298 if (g_isWisePlay) {
1299 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1300 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1301 EXPECT_EQ(rett, 0);
1302 } else {
1303 testKeySessionResponseLen = 50;
1304 }
1305 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1306 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1307 EXPECT_EQ(errNo, DRM_ERR_OK);
1308 DRM_MediaKeyStatus mediaKeyStatus;
1309 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1310 EXPECT_EQ(errNo, DRM_ERR_OK);
1311
1312 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1313 EXPECT_EQ(errNo, DRM_ERR_OK);
1314 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1315 EXPECT_EQ(errNo, DRM_ERR_OK);
1316 }
1317
1318 /*
1319 * Feature: Framework
1320 * Function: Processing device certificate response testing
1321 * Sub function: NA
1322 * Function point: NA
1323 * Environmental conditions: NA
1324 * Case Description: Processing Device Certificate Response Testing
1325 */
1326 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_034, TestSize.Level0)
1327 {
1328 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1329 MediaKeySystem *mediaKeySystem = nullptr;
1330 MediaKeySession *mediaKeySession = nullptr;
1331 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1332 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1333 EXPECT_NE(mediaKeySystem, nullptr);
1334 EXPECT_EQ(errNo, DRM_ERR_OK);
1335 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1336 EXPECT_NE(mediaKeySession, nullptr);
1337 EXPECT_EQ(errNo, DRM_ERR_OK);
1338 // mediakeysession
1339 DRM_MediaKeyRequest mediaKeyRequest;
1340 DRM_MediaKeyRequestInfo info;
1341 unsigned char testData[139] = REQUESTINFODATA;
1342 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1343 info.initDataLen = sizeof(testData);
1344 info.type = MEDIA_KEY_TYPE_ONLINE;
1345 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1346 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1347 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1348 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1349 info.optionsCount = 1;
1350 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1351 EXPECT_EQ(errNo, DRM_ERR_OK);
1352 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1353 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1354 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1355 int32_t testKeySessionResponseLen = 12288;
1356 if (g_isWisePlay) {
1357 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1358 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1359 EXPECT_EQ(rett, 0);
1360 } else {
1361 testKeySessionResponseLen = 50;
1362 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1363 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1364 EXPECT_EQ(errNo, DRM_ERR_OK);
1365 DRM_MediaKeyStatus mediaKeyStatus;
1366 errNo = OH_MediaKeySession_CheckMediaKeyStatus(nullptr, &mediaKeyStatus);
1367 EXPECT_NE(errNo, DRM_ERR_OK);
1368 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1369 EXPECT_EQ(errNo, DRM_ERR_OK);
1370 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1371 EXPECT_EQ(errNo, DRM_ERR_OK);
1372 }
1373
1374 /*
1375 * Feature: Framework
1376 * Function: Processing device certificate response testing
1377 * Sub function: NA
1378 * Function point: NA
1379 * Environmental conditions: NA
1380 * Case Description: Processing Device Certificate Response Testing
1381 */
1382 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CheckMediaKeyStatusAbNormal_035, TestSize.Level0)
1383 {
1384 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1385 MediaKeySystem *mediaKeySystem = nullptr;
1386 MediaKeySession *mediaKeySession = nullptr;
1387 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1388 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1389 EXPECT_NE(mediaKeySystem, nullptr);
1390 EXPECT_EQ(errNo, DRM_ERR_OK);
1391 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1392 EXPECT_NE(mediaKeySession, nullptr);
1393 EXPECT_EQ(errNo, DRM_ERR_OK);
1394 // mediakeysession
1395 DRM_MediaKeyRequest mediaKeyRequest;
1396 DRM_MediaKeyRequestInfo info;
1397 unsigned char testData[139] = REQUESTINFODATA;
1398 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1399 info.initDataLen = sizeof(testData);
1400 info.type = MEDIA_KEY_TYPE_ONLINE;
1401 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1402 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1403 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1404 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1405 info.optionsCount = 1;
1406 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1407 EXPECT_EQ(errNo, DRM_ERR_OK);
1408 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1409 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1410 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1411 int32_t testKeySessionResponseLen = 12288;
1412 if (g_isWisePlay) {
1413 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1414 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1415 EXPECT_EQ(rett, 0);
1416 } else {
1417 testKeySessionResponseLen = 50;
1418 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1419 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1420 EXPECT_EQ(errNo, DRM_ERR_OK);
1421 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, nullptr);
1422 EXPECT_NE(errNo, DRM_ERR_OK);
1423 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1424 EXPECT_EQ(errNo, DRM_ERR_OK);
1425 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1426 EXPECT_EQ(errNo, DRM_ERR_OK);
1427 }
1428
1429 /*
1430 * Feature: Framework
1431 * Function: Processing device certificate response testing
1432 * Sub function: NA
1433 * Function point: NA
1434 * Environmental conditions: NA
1435 * Case Description: Processing Device Certificate Response Testing
1436 */
1437 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysNormal_036, TestSize.Level0)
1438 {
1439 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1440 MediaKeySystem *mediaKeySystem = nullptr;
1441 MediaKeySession *mediaKeySession = nullptr;
1442 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1443 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1444 EXPECT_NE(mediaKeySystem, nullptr);
1445 EXPECT_EQ(errNo, DRM_ERR_OK);
1446 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1447 EXPECT_NE(mediaKeySession, nullptr);
1448 EXPECT_EQ(errNo, DRM_ERR_OK);
1449 // mediakeysession
1450 DRM_MediaKeyRequest mediaKeyRequest;
1451 DRM_MediaKeyRequestInfo info;
1452 unsigned char testData[139] = REQUESTINFODATA;
1453 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1454 info.initDataLen = sizeof(testData);
1455 info.type = MEDIA_KEY_TYPE_ONLINE;
1456 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1457 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1458 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1459 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1460 info.optionsCount = 1;
1461 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1462 EXPECT_EQ(errNo, DRM_ERR_OK);
1463 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1464 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1465 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1466 int32_t testKeySessionResponseLen = 12288;
1467 if (g_isWisePlay) {
1468 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1469 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1470 EXPECT_EQ(rett, 0);
1471 } else {
1472 testKeySessionResponseLen = 50;
1473 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1474 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1475 EXPECT_EQ(errNo, DRM_ERR_OK);
1476 DRM_MediaKeyStatus mediaKeyStatus;
1477 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1478 EXPECT_EQ(errNo, DRM_ERR_OK);
1479
1480 errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession);
1481 EXPECT_EQ(errNo, DRM_ERR_OK);
1482 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1483 if (g_isWisePlay) {
1484 EXPECT_EQ(errNo, DRM_ERR_OK);
1485 } else {
1486 EXPECT_NE(errNo, DRM_ERR_OK);
1487 }
1488 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1489 EXPECT_EQ(errNo, DRM_ERR_OK);
1490 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1491 EXPECT_EQ(errNo, DRM_ERR_OK);
1492 }
1493
1494 /*
1495 * Feature: Framework
1496 * Function: Processing device certificate response testing
1497 * Sub function: NA
1498 * Function point: NA
1499 * Environmental conditions: NA
1500 * Case Description: Processing Device Certificate Response Testing
1501 */
1502 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_037, TestSize.Level0)
1503 {
1504 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1505 MediaKeySystem *mediaKeySystem = nullptr;
1506 MediaKeySession *mediaKeySession = nullptr;
1507 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1508 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1509 EXPECT_NE(mediaKeySystem, nullptr);
1510 EXPECT_EQ(errNo, DRM_ERR_OK);
1511 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1512 EXPECT_NE(mediaKeySession, nullptr);
1513 EXPECT_EQ(errNo, DRM_ERR_OK);
1514 // mediakeysession
1515 DRM_MediaKeyRequest mediaKeyRequest;
1516 DRM_MediaKeyRequestInfo info;
1517 unsigned char testData[139] = REQUESTINFODATA;
1518 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1519 info.initDataLen = sizeof(testData);
1520 info.type = MEDIA_KEY_TYPE_ONLINE;
1521 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1522 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1523 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1524 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1525 info.optionsCount = 1;
1526 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1527 EXPECT_EQ(errNo, DRM_ERR_OK);
1528 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1529 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1530 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1531 int32_t testKeySessionResponseLen = 12288;
1532 if (g_isWisePlay) {
1533 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1534 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1535 EXPECT_EQ(rett, 0);
1536 } else {
1537 testKeySessionResponseLen = 50;
1538 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1539 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1540 EXPECT_EQ(errNo, DRM_ERR_OK);
1541 DRM_MediaKeyStatus mediaKeyStatus;
1542 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1543 errNo = OH_MediaKeySession_ClearMediaKeys(nullptr);
1544 EXPECT_NE(errNo, DRM_ERR_OK);
1545 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1546 EXPECT_EQ(errNo, DRM_ERR_OK);
1547 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1548 EXPECT_EQ(errNo, DRM_ERR_OK);
1549 }
1550
1551 /*
1552 * Feature: Framework
1553 * Function: Processing device certificate response testing
1554 * Sub function: NA
1555 * Function point: NA
1556 * Environmental conditions: NA
1557 * Case Description: Processing Device Certificate Response Testing
1558 */
1559 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusNormal_038, TestSize.Level0)
1560 {
1561 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1562 MediaKeySystem *mediaKeySystem = nullptr;
1563 MediaKeySession *mediaKeySession = nullptr;
1564 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1565 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1566 EXPECT_NE(mediaKeySystem, nullptr);
1567 EXPECT_EQ(errNo, DRM_ERR_OK);
1568 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1569 EXPECT_NE(mediaKeySession, nullptr);
1570 EXPECT_EQ(errNo, DRM_ERR_OK);
1571 // mediakeysession
1572 DRM_MediaKeyRequest mediaKeyRequest;
1573 DRM_MediaKeyRequestInfo info;
1574 unsigned char testData[241] = OFFREQUESTINFODATA;
1575 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1576 info.initDataLen = testData[3];
1577 info.type = MEDIA_KEY_TYPE_OFFLINE;
1578 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1579 memcpy_s(info.initData, sizeof(testData), testData, info.initDataLen);
1580 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1581 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1582 info.optionsCount = 1;
1583 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1584 EXPECT_EQ(errNo, DRM_ERR_OK);
1585 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1586 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1587 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1588 int32_t testKeySessionResponseLen = 12288;
1589 if (g_isWisePlay) {
1590 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1591 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1592 EXPECT_EQ(rett, 0);
1593 } else {
1594 testKeySessionResponseLen = 50;
1595 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1596 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1597 DRM_MediaKeyStatus mediaKeyStatus;
1598 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1599 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
1600 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
1601 &OfflineMediaKeyStatus);
1602 EXPECT_EQ(errNo, DRM_ERR_OK);
1603 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1604 EXPECT_EQ(errNo, DRM_ERR_OK);
1605 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1606 EXPECT_EQ(errNo, DRM_ERR_OK);
1607 }
1608
1609 /*
1610 * Feature: Framework
1611 * Function: Processing device certificate response testing
1612 * Sub function: NA
1613 * Function point: NA
1614 * Environmental conditions: NA
1615 * Case Description: Processing Device Certificate Response Testing
1616 */
1617 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_039, TestSize.Level0)
1618 {
1619 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1620 MediaKeySystem *mediaKeySystem = nullptr;
1621 MediaKeySession *mediaKeySession = nullptr;
1622 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1623 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1624 EXPECT_NE(mediaKeySystem, nullptr);
1625 EXPECT_EQ(errNo, DRM_ERR_OK);
1626 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1627 EXPECT_NE(mediaKeySession, nullptr);
1628 EXPECT_EQ(errNo, DRM_ERR_OK);
1629 // mediakeysession
1630 DRM_MediaKeyRequest mediaKeyRequest;
1631 DRM_MediaKeyRequestInfo info;
1632 unsigned char testData[139] = REQUESTINFODATA;
1633 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1634 info.initDataLen = sizeof(testData);
1635 info.type = MEDIA_KEY_TYPE_ONLINE;
1636 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1637 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1638 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1639 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1640 info.optionsCount = 1;
1641 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1642 EXPECT_EQ(errNo, DRM_ERR_OK);
1643 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1644 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1645 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1646 int32_t testKeySessionResponseLen = 12288;
1647 if (g_isWisePlay) {
1648 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1649 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1650 EXPECT_EQ(rett, 0);
1651 } else {
1652 testKeySessionResponseLen = 50;
1653 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1654 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1655 EXPECT_EQ(errNo, DRM_ERR_OK);
1656 DRM_MediaKeyStatus mediaKeyStatus;
1657 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1658
1659 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
1660 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen,
1661 &OfflineMediaKeyStatus);
1662 EXPECT_NE(errNo, DRM_ERR_OK);
1663 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1664 EXPECT_EQ(errNo, DRM_ERR_OK);
1665 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1666 EXPECT_EQ(errNo, DRM_ERR_OK);
1667 }
1668
1669 /*
1670 * Feature: Framework
1671 * Function: Processing device certificate response testing
1672 * Sub function: NA
1673 * Function point: NA
1674 * Environmental conditions: NA
1675 * Case Description: Processing Device Certificate Response Testing
1676 */
1677 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_040, TestSize.Level0)
1678 {
1679 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1680 MediaKeySystem *mediaKeySystem = nullptr;
1681 MediaKeySession *mediaKeySession = nullptr;
1682 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1683 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1684 EXPECT_NE(mediaKeySystem, nullptr);
1685 EXPECT_EQ(errNo, DRM_ERR_OK);
1686 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1687 EXPECT_NE(mediaKeySession, nullptr);
1688 EXPECT_EQ(errNo, DRM_ERR_OK);
1689 // mediakeysession
1690 DRM_MediaKeyRequest mediaKeyRequest;
1691 DRM_MediaKeyRequestInfo info;
1692 unsigned char testData[139] = REQUESTINFODATA;
1693 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1694 info.initDataLen = sizeof(testData);
1695 info.type = MEDIA_KEY_TYPE_ONLINE;
1696 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1697 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1698 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1699 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1700 info.optionsCount = 1;
1701 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1702 EXPECT_EQ(errNo, DRM_ERR_OK);
1703 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1704 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1705 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1706 int32_t testKeySessionResponseLen = 12288;
1707 if (g_isWisePlay) {
1708 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1709 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1710 EXPECT_EQ(rett, 0);
1711 } else {
1712 testKeySessionResponseLen = 50;
1713 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1714 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1715 EXPECT_EQ(errNo, DRM_ERR_OK);
1716 DRM_MediaKeyStatus mediaKeyStatus;
1717 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1718
1719 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
1720 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, nullptr, onlineMediaKeyIdLen,
1721 &OfflineMediaKeyStatus);
1722 EXPECT_NE(errNo, DRM_ERR_OK);
1723 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1724 EXPECT_EQ(errNo, DRM_ERR_OK);
1725 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1726 EXPECT_EQ(errNo, DRM_ERR_OK);
1727 }
1728
1729 /*
1730 * Feature: Framework
1731 * Function: Processing device certificate response testing
1732 * Sub function: NA
1733 * Function point: NA
1734 * Environmental conditions: NA
1735 * Case Description: Processing Device Certificate Response Testing
1736 */
1737 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyStatusAbNormal_041, TestSize.Level0)
1738 {
1739 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1740 MediaKeySystem *mediaKeySystem = nullptr;
1741 MediaKeySession *mediaKeySession = nullptr;
1742 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1743 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1744 EXPECT_NE(mediaKeySystem, nullptr);
1745 EXPECT_EQ(errNo, DRM_ERR_OK);
1746 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1747 EXPECT_NE(mediaKeySession, nullptr);
1748 EXPECT_EQ(errNo, DRM_ERR_OK);
1749 // mediakeysession
1750 DRM_MediaKeyRequest mediaKeyRequest;
1751 DRM_MediaKeyRequestInfo info;
1752 unsigned char testData[139] = REQUESTINFODATA;
1753 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1754 info.initDataLen = sizeof(testData);
1755 info.type = MEDIA_KEY_TYPE_ONLINE;
1756 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1757 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1758 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1759 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1760 info.optionsCount = 1;
1761 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1762 EXPECT_EQ(errNo, DRM_ERR_OK);
1763 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1764 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1765 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1766 int32_t testKeySessionResponseLen = 12288;
1767 if (g_isWisePlay) {
1768 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1769 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1770 EXPECT_EQ(rett, 0);
1771 } else {
1772 testKeySessionResponseLen = 50;
1773 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1774 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1775 EXPECT_EQ(errNo, DRM_ERR_OK);
1776 DRM_MediaKeyStatus mediaKeyStatus;
1777 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
1778
1779 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
1780 nullptr);
1781 EXPECT_NE(errNo, DRM_ERR_OK);
1782 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1783 EXPECT_EQ(errNo, DRM_ERR_OK);
1784 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1785 EXPECT_EQ(errNo, DRM_ERR_OK);
1786 }
1787
1788 /*
1789 * Feature: Framework
1790 * Function: Processing device certificate response testing
1791 * Sub function: NA
1792 * Function point: NA
1793 * Environmental conditions: NA
1794 * Case Description: Processing Device Certificate Response Testing
1795 */
1796 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsNormal_042, TestSize.Level0)
1797 {
1798 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1799 MediaKeySystem *mediaKeySystem = nullptr;
1800 MediaKeySession *mediaKeySession = nullptr;
1801 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1802 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1803 EXPECT_NE(mediaKeySystem, nullptr);
1804 EXPECT_EQ(errNo, DRM_ERR_OK);
1805 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1806 EXPECT_NE(mediaKeySession, nullptr);
1807 EXPECT_EQ(errNo, DRM_ERR_OK);
1808 // mediakeysession
1809 DRM_MediaKeyRequest mediaKeyRequest;
1810 DRM_MediaKeyRequestInfo info;
1811 unsigned char testData[241] = OFFREQUESTINFODATA;
1812 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1813 info.initDataLen = testData[3];
1814 info.type = MEDIA_KEY_TYPE_OFFLINE;
1815 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1816 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1817 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1818 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1819 info.optionsCount = 1;
1820 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1821 EXPECT_EQ(errNo, DRM_ERR_OK);
1822 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1823 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1824 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1825 int32_t testKeySessionResponseLen = 12288;
1826 if (g_isWisePlay) {
1827 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1828 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1829 EXPECT_EQ(rett, 0);
1830 } else {
1831 testKeySessionResponseLen = 50;
1832 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1833 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1834 EXPECT_EQ(errNo, DRM_ERR_OK);
1835 DRM_OfflineMediakeyIdArray offlineMediaKeyIds;
1836 errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds);
1837 EXPECT_EQ(errNo, DRM_ERR_OK);
1838 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1839 EXPECT_EQ(errNo, DRM_ERR_OK);
1840 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1841 EXPECT_EQ(errNo, DRM_ERR_OK);
1842 }
1843
1844 /*
1845 * Feature: Framework
1846 * Function: Processing device certificate response testing
1847 * Sub function: NA
1848 * Function point: NA
1849 * Environmental conditions: NA
1850 * Case Description: Processing Device Certificate Response Testing
1851 */
1852 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_043, TestSize.Level0)
1853 {
1854 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1855 MediaKeySystem *mediaKeySystem = nullptr;
1856 MediaKeySession *mediaKeySession = nullptr;
1857 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1858 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1859 EXPECT_NE(mediaKeySystem, nullptr);
1860 EXPECT_EQ(errNo, DRM_ERR_OK);
1861 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1862 EXPECT_NE(mediaKeySession, nullptr);
1863 EXPECT_EQ(errNo, DRM_ERR_OK);
1864 // mediakeysession
1865 DRM_MediaKeyRequest mediaKeyRequest;
1866 DRM_MediaKeyRequestInfo info;
1867 unsigned char testData[139] = REQUESTINFODATA;
1868 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1869 info.initDataLen = sizeof(testData);
1870 info.type = MEDIA_KEY_TYPE_ONLINE;
1871 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1872 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1873 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1874 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1875 info.optionsCount = 1;
1876 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1877 EXPECT_EQ(errNo, DRM_ERR_OK);
1878 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1879 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1880 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1881 int32_t testKeySessionResponseLen = 12288;
1882 if (g_isWisePlay) {
1883 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1884 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1885 EXPECT_EQ(rett, 0);
1886 } else {
1887 testKeySessionResponseLen = 50;
1888 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1889 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1890 EXPECT_EQ(errNo, DRM_ERR_OK);
1891 DRM_OfflineMediakeyIdArray offlineMediaKeyIds;
1892 errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(nullptr, &offlineMediaKeyIds);
1893 EXPECT_NE(errNo, DRM_ERR_OK);
1894 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1895 EXPECT_EQ(errNo, DRM_ERR_OK);
1896 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1897 EXPECT_EQ(errNo, DRM_ERR_OK);
1898 }
1899
1900 /*
1901 * Feature: Framework
1902 * Function: Processing device certificate response testing
1903 * Sub function: NA
1904 * Function point: NA
1905 * Environmental conditions: NA
1906 * Case Description: Processing Device Certificate Response Testing
1907 */
1908 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetOfflineMediaKeyIdsAbNormal_044, TestSize.Level0)
1909 {
1910 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1911 MediaKeySystem *mediaKeySystem = nullptr;
1912 MediaKeySession *mediaKeySession = nullptr;
1913 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1914 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1915 EXPECT_NE(mediaKeySystem, nullptr);
1916 EXPECT_EQ(errNo, DRM_ERR_OK);
1917 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1918 EXPECT_NE(mediaKeySession, nullptr);
1919 EXPECT_EQ(errNo, DRM_ERR_OK);
1920 // mediakeysession
1921 DRM_MediaKeyRequest mediaKeyRequest;
1922 DRM_MediaKeyRequestInfo info;
1923 unsigned char testData[139] = REQUESTINFODATA;
1924 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1925 info.initDataLen = sizeof(testData);
1926 info.type = MEDIA_KEY_TYPE_ONLINE;
1927 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1928 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1929 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1930 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1931 info.optionsCount = 1;
1932 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1933 EXPECT_EQ(errNo, DRM_ERR_OK);
1934 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1935 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1936 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1937 int32_t testKeySessionResponseLen = 12288;
1938 if (g_isWisePlay) {
1939 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1940 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1941 EXPECT_EQ(rett, 0);
1942 } else {
1943 testKeySessionResponseLen = 50;
1944 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
1945 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
1946 EXPECT_EQ(errNo, DRM_ERR_OK);
1947 errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, nullptr);
1948 EXPECT_NE(errNo, DRM_ERR_OK);
1949 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
1950 EXPECT_EQ(errNo, DRM_ERR_OK);
1951 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
1952 EXPECT_EQ(errNo, DRM_ERR_OK);
1953 }
1954
1955 /*
1956 * Feature: Framework
1957 * Function: Processing device certificate response testing
1958 * Sub function: NA
1959 * Function point: NA
1960 * Environmental conditions: NA
1961 * Case Description: Processing Device Certificate Response Testing
1962 */
1963 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestNormal_045, TestSize.Level0)
1964 {
1965 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
1966 MediaKeySystem *mediaKeySystem = nullptr;
1967 MediaKeySession *mediaKeySession = nullptr;
1968 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1969 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
1970 EXPECT_NE(mediaKeySystem, nullptr);
1971 EXPECT_EQ(errNo, DRM_ERR_OK);
1972 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
1973 EXPECT_NE(mediaKeySession, nullptr);
1974 EXPECT_EQ(errNo, DRM_ERR_OK);
1975 // mediakeysession
1976 DRM_MediaKeyRequest mediaKeyRequest;
1977 DRM_MediaKeyRequestInfo info;
1978 unsigned char testData[241] = OFFREQUESTINFODATA;
1979 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
1980 info.initDataLen = testData[3];
1981 info.type = MEDIA_KEY_TYPE_OFFLINE;
1982 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
1983 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
1984 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
1985 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
1986 info.optionsCount = 1;
1987 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
1988 EXPECT_EQ(errNo, DRM_ERR_OK);
1989 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1990 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
1991 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
1992 int32_t testKeySessionResponseLen = 12288;
1993 if (g_isWisePlay) {
1994 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
1995 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
1996 EXPECT_EQ(rett, 0);
1997 } else {
1998 testKeySessionResponseLen = 50;
1999 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2000 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2001 EXPECT_EQ(errNo, DRM_ERR_OK);
2002 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2003 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2004 &OfflineMediaKeyStatus);
2005 EXPECT_EQ(errNo, DRM_ERR_OK);
2006 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2007 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2008 int32_t releaseRequestLen = 12288; // 12288:request len
2009 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2010 releaseRequest, &releaseRequestLen);
2011 EXPECT_EQ(errNo, DRM_ERR_OK);
2012 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2013 EXPECT_EQ(errNo, DRM_ERR_OK);
2014 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2015 EXPECT_EQ(errNo, DRM_ERR_OK);
2016 }
2017
2018 /*
2019 * Feature: Framework
2020 * Function: Processing device certificate response testing
2021 * Sub function: NA
2022 * Function point: NA
2023 * Environmental conditions: NA
2024 * Case Description: Processing Device Certificate Response Testing
2025 */
2026 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GenerateOfflineReleaseRequestAbNormal_046, TestSize.Level0)
2027 {
2028 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2029 MediaKeySystem *mediaKeySystem = nullptr;
2030 MediaKeySession *mediaKeySession = nullptr;
2031 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2032 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2033 EXPECT_NE(mediaKeySystem, nullptr);
2034 EXPECT_EQ(errNo, DRM_ERR_OK);
2035 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2036 EXPECT_NE(mediaKeySession, nullptr);
2037 EXPECT_EQ(errNo, DRM_ERR_OK);
2038 // mediakeysession
2039 DRM_MediaKeyRequest mediaKeyRequest;
2040 DRM_MediaKeyRequestInfo info;
2041 unsigned char testData[241] = OFFREQUESTINFODATA;
2042 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2043 info.initDataLen = testData[3];
2044 info.type = MEDIA_KEY_TYPE_OFFLINE;
2045 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2046 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2047 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2048 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2049 info.optionsCount = 1;
2050 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2051 EXPECT_EQ(errNo, DRM_ERR_OK);
2052 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2053 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2054 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2055 int32_t testKeySessionResponseLen = 12288;
2056 if (g_isWisePlay) {
2057 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2058 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2059 EXPECT_EQ(rett, 0);
2060 } else {
2061 testKeySessionResponseLen = 50;
2062 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2063 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2064 EXPECT_EQ(errNo, DRM_ERR_OK);
2065 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2066 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2067 &OfflineMediaKeyStatus);
2068 EXPECT_EQ(errNo, DRM_ERR_OK);
2069 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2070 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2071 int32_t releaseRequestLen = 12288; // 12288:request len
2072 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen,
2073 releaseRequest, &releaseRequestLen);
2074 EXPECT_NE(errNo, DRM_ERR_OK);
2075 releaseRequestLen = 12288; // 12288:request len
2076 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, onlineMediaKeyIdLen,
2077 releaseRequest, &releaseRequestLen);
2078 EXPECT_NE(errNo, DRM_ERR_OK);
2079 releaseRequestLen = 12288; // 12288:request len
2080 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2081 nullptr, &releaseRequestLen);
2082 EXPECT_NE(errNo, DRM_ERR_OK);
2083 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2084 releaseRequest, nullptr);
2085 EXPECT_NE(errNo, DRM_ERR_OK);
2086 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2087 EXPECT_EQ(errNo, DRM_ERR_OK);
2088 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2089 EXPECT_EQ(errNo, DRM_ERR_OK);
2090 }
2091
2092 /*
2093 * Feature: Framework
2094 * Function: Processing device certificate response testing
2095 * Sub function: NA
2096 * Function point: NA
2097 * Environmental conditions: NA
2098 * Case Description: Processing Device Certificate Response Testing
2099 */
2100 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseNormal_047, TestSize.Level0)
2101 {
2102 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2103 MediaKeySystem *mediaKeySystem = nullptr;
2104 MediaKeySession *mediaKeySession = nullptr;
2105 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2106 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2107 EXPECT_NE(mediaKeySystem, nullptr);
2108 EXPECT_EQ(errNo, DRM_ERR_OK);
2109 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2110 EXPECT_NE(mediaKeySession, nullptr);
2111 EXPECT_EQ(errNo, DRM_ERR_OK);
2112 // mediakeysession
2113 DRM_MediaKeyRequest mediaKeyRequest;
2114 DRM_MediaKeyRequestInfo info;
2115 unsigned char testData[241] = OFFREQUESTINFODATA;
2116 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2117 info.initDataLen = testData[3];
2118 info.type = MEDIA_KEY_TYPE_OFFLINE;
2119 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2120 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2121 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2122 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2123 info.optionsCount = 1;
2124 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2125 EXPECT_EQ(errNo, DRM_ERR_OK);
2126 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2127 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2128 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2129 int32_t testKeySessionResponseLen = 12288;
2130 if (g_isWisePlay) {
2131 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2132 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2133 EXPECT_EQ(rett, 0);
2134 } else {
2135 testKeySessionResponseLen = 50;
2136 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2137 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2138 EXPECT_EQ(errNo, DRM_ERR_OK);
2139 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2140 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2141 &OfflineMediaKeyStatus);
2142 EXPECT_EQ(errNo, DRM_ERR_OK);
2143 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2144 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2145 int32_t releaseRequestLen = 12288; // 12288:request len
2146 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2147 releaseRequest, &releaseRequestLen);
2148 EXPECT_EQ(errNo, DRM_ERR_OK);
2149 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2150 if (!g_isWisePlay) {
2151 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2152 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2153 EXPECT_EQ(errNo, DRM_ERR_OK);
2154 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2155 &OfflineMediaKeyStatus);
2156 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2157 EXPECT_EQ(errNo, DRM_ERR_OK);
2158 }
2159 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2160 EXPECT_EQ(errNo, DRM_ERR_OK);
2161 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2162 EXPECT_EQ(errNo, DRM_ERR_OK);
2163 }
2164
2165 /*
2166 * Feature: Framework
2167 * Function: Processing device certificate response testing
2168 * Sub function: NA
2169 * Function point: NA
2170 * Environmental conditions: NA
2171 * Case Description: Processing Device Certificate Response Testing
2172 */
2173 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_048, TestSize.Level0)
2174 {
2175 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2176 MediaKeySystem *mediaKeySystem = nullptr;
2177 MediaKeySession *mediaKeySession = nullptr;
2178 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2179 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2180 EXPECT_NE(mediaKeySystem, nullptr);
2181 EXPECT_EQ(errNo, DRM_ERR_OK);
2182 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2183 EXPECT_NE(mediaKeySession, nullptr);
2184 EXPECT_EQ(errNo, DRM_ERR_OK);
2185 // mediakeysession
2186 DRM_MediaKeyRequest mediaKeyRequest;
2187 DRM_MediaKeyRequestInfo info;
2188 unsigned char testData[241] = OFFREQUESTINFODATA;
2189 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2190 info.initDataLen = testData[3];
2191 info.type = MEDIA_KEY_TYPE_OFFLINE;
2192 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2193 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2194 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2195 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2196 info.optionsCount = 1;
2197 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2198 EXPECT_EQ(errNo, DRM_ERR_OK);
2199 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2200 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2201 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2202 int32_t testKeySessionResponseLen = 12288;
2203 if (g_isWisePlay) {
2204 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2205 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2206 EXPECT_EQ(rett, 0);
2207 } else {
2208 testKeySessionResponseLen = 50;
2209 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2210 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2211 EXPECT_EQ(errNo, DRM_ERR_OK);
2212 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2213 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2214 &OfflineMediaKeyStatus);
2215 EXPECT_EQ(errNo, DRM_ERR_OK);
2216 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2217 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2218 int32_t releaseRequestLen = 12288; // 12288:request len
2219 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2220 releaseRequest, &releaseRequestLen);
2221 EXPECT_EQ(errNo, DRM_ERR_OK);
2222 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2223 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen,
2224 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2225 EXPECT_NE(errNo, DRM_ERR_OK);
2226 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, onlineMediaKeyIdLen,
2227 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2228 EXPECT_NE(errNo, DRM_ERR_OK);
2229 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2230 nullptr, (int32_t)(sizeof(testKeyReleaseResponse)));
2231 EXPECT_NE(errNo, DRM_ERR_OK);
2232 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2233 EXPECT_EQ(errNo, DRM_ERR_OK);
2234 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2235 EXPECT_EQ(errNo, DRM_ERR_OK);
2236 }
2237
2238 /*
2239 * Feature: Framework
2240 * Function: Processing device certificate response testing
2241 * Sub function: NA
2242 * Function point: NA
2243 * Environmental conditions: NA
2244 * Case Description: Processing Device Certificate Response Testing
2245 */
2246 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusNormal_049, TestSize.Level0)
2247 {
2248 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2249 MediaKeySystem *mediaKeySystem = nullptr;
2250 MediaKeySession *mediaKeySession = nullptr;
2251 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2252 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2253 EXPECT_NE(mediaKeySystem, nullptr);
2254 EXPECT_EQ(errNo, DRM_ERR_OK);
2255 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2256 EXPECT_NE(mediaKeySession, nullptr);
2257 EXPECT_EQ(errNo, DRM_ERR_OK);
2258 DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
2259 errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus);
2260 EXPECT_EQ(certStatus, 0);
2261 EXPECT_EQ(errNo, DRM_ERR_OK);
2262 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2263 EXPECT_EQ(errNo, DRM_ERR_OK);
2264 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2265 EXPECT_EQ(errNo, DRM_ERR_OK);
2266 }
2267
2268 /*
2269 * Feature: Framework
2270 * Function: Processing device certificate response testing
2271 * Sub function: NA
2272 * Function point: NA
2273 * Environmental conditions: NA
2274 * Case Description: Processing Device Certificate Response Testing
2275 */
2276 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetCertificateStatusAbNormal_050, TestSize.Level0)
2277 {
2278 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2279 MediaKeySystem *mediaKeySystem = nullptr;
2280 MediaKeySession *mediaKeySession = nullptr;
2281 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2282 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2283 EXPECT_NE(mediaKeySystem, nullptr);
2284 EXPECT_EQ(errNo, DRM_ERR_OK);
2285 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2286 EXPECT_NE(mediaKeySession, nullptr);
2287 EXPECT_EQ(errNo, DRM_ERR_OK);
2288 DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
2289 errNo = OH_MediaKeySystem_GetCertificateStatus(nullptr, &certStatus);
2290 EXPECT_NE(errNo, DRM_ERR_OK);
2291 errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, nullptr);
2292 EXPECT_NE(errNo, DRM_ERR_OK);
2293 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2294 EXPECT_EQ(errNo, DRM_ERR_OK);
2295 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2296 EXPECT_EQ(errNo, DRM_ERR_OK);
2297 }
2298
2299 /*
2300 * Feature: Framework
2301 * Function: Processing device certificate response testing
2302 * Sub function: NA
2303 * Function point: NA
2304 * Environmental conditions: NA
2305 * Case Description: Processing Device Certificate Response Testing
2306 */
2307 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringNormal_051, TestSize.Level0)
2308 {
2309 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2310 MediaKeySystem *mediaKeySystem = nullptr;
2311 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2312 EXPECT_NE(mediaKeySystem, nullptr);
2313 EXPECT_EQ(errNo, DRM_ERR_OK);
2314 errNo =
2315 OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString");
2316 if (g_isWisePlay) {
2317 EXPECT_NE(errNo, DRM_ERR_OK);
2318 } else {
2319 EXPECT_EQ(errNo, DRM_ERR_OK);
2320 }
2321 char value[32];
2322 int32_t valueLen = 32;
2323 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "version", value, valueLen);
2324 if (g_isWisePlay) {
2325 EXPECT_EQ(errNo, DRM_ERR_OK);
2326 } else {
2327 EXPECT_NE(errNo, DRM_ERR_OK);
2328 }
2329 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 10);
2330 EXPECT_NE(errNo, DRM_ERR_OK);
2331 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2332 EXPECT_EQ(errNo, DRM_ERR_OK);
2333 }
2334
2335 /*
2336 * Feature: Framework
2337 * Function: Processing device certificate response testing
2338 * Sub function: NA
2339 * Function point: NA
2340 * Environmental conditions: NA
2341 * Case Description: Processing Device Certificate Response Testing
2342 */
2343 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationStringAbNormal_052, TestSize.Level0)
2344 {
2345 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2346 MediaKeySystem *mediaKeySystem = nullptr;
2347 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2348 EXPECT_NE(mediaKeySystem, nullptr);
2349 EXPECT_EQ(errNo, DRM_ERR_OK);
2350 errNo = OH_MediaKeySystem_SetConfigurationString(nullptr, "testConfigurationString", "gezhegezhegezhe");
2351 EXPECT_NE(errNo, DRM_ERR_OK);
2352 errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "", "gezhegezhegezhe");
2353 EXPECT_NE(errNo, DRM_ERR_OK);
2354 errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, nullptr, "gezhegezhegezhe");
2355 EXPECT_NE(errNo, DRM_ERR_OK);
2356 errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "");
2357 EXPECT_NE(errNo, DRM_ERR_OK);
2358 errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr);
2359 EXPECT_NE(errNo, DRM_ERR_OK);
2360 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2361 EXPECT_EQ(errNo, DRM_ERR_OK);
2362 }
2363
2364 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationStringAbNormal_053, TestSize.Level0)
2365 {
2366 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2367 MediaKeySystem *mediaKeySystem = nullptr;
2368 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2369 EXPECT_NE(mediaKeySystem, nullptr);
2370 EXPECT_EQ(errNo, DRM_ERR_OK);
2371 errNo = OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "gezhegezhegezhe");
2372 if (g_isWisePlay) {
2373 EXPECT_NE(errNo, DRM_ERR_OK);
2374 } else {
2375 EXPECT_EQ(errNo, DRM_ERR_OK);
2376 }
2377 char value[32];
2378 int32_t valueLen = 32;
2379 errNo = OH_MediaKeySystem_GetConfigurationString(nullptr, "testConfigurationString", value, valueLen);
2380 EXPECT_NE(errNo, DRM_ERR_OK);
2381 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "", value, valueLen);
2382 EXPECT_NE(errNo, DRM_ERR_OK);
2383 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, nullptr, value, valueLen);
2384 EXPECT_NE(errNo, DRM_ERR_OK);
2385 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", nullptr, valueLen);
2386 EXPECT_NE(errNo, DRM_ERR_OK);
2387 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 0);
2388 EXPECT_NE(errNo, DRM_ERR_OK);
2389 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2390 EXPECT_EQ(errNo, DRM_ERR_OK);
2391 }
2392
2393 /*
2394 * Feature: Framework
2395 * Function: Processing device certificate response testing
2396 * Sub function: NA
2397 * Function point: NA
2398 * Environmental conditions: NA
2399 * Case Description: Processing Device Certificate Response Testing
2400 */
2401 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayNormal_054, TestSize.Level0)
2402 {
2403 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2404 MediaKeySystem *mediaKeySystem = nullptr;
2405 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2406 EXPECT_NE(mediaKeySystem, nullptr);
2407 EXPECT_EQ(errNo, DRM_ERR_OK);
2408 unsigned char testArray[5] = {1, 2, 3, 4, 5};
2409 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray,
2410 sizeof(testArray));
2411 if (g_isWisePlay) {
2412 EXPECT_NE(errNo, DRM_ERR_OK);
2413 } else {
2414 EXPECT_EQ(errNo, DRM_ERR_OK);
2415 }
2416 unsigned char configByteArray[128];
2417 int32_t byteArrayLen = 128;
2418 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "deviceUniqueId", configByteArray,
2419 &byteArrayLen);
2420 if (g_isWisePlay) {
2421 EXPECT_EQ(errNo, DRM_ERR_OK);
2422 } else {
2423 EXPECT_NE(errNo, DRM_ERR_OK);
2424 }
2425
2426 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2427 EXPECT_EQ(errNo, DRM_ERR_OK);
2428 }
2429
2430 /*
2431 * Feature: Framework
2432 * Function: Processing device certificate response testing
2433 * Sub function: NA
2434 * Function point: NA
2435 * Environmental conditions: NA
2436 * Case Description: Processing Device Certificate Response Testing
2437 */
2438 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetConfigurationByteArrayAbNormal_055, TestSize.Level0)
2439 {
2440 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2441 MediaKeySystem *mediaKeySystem = nullptr;
2442 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2443 EXPECT_NE(mediaKeySystem, nullptr);
2444 EXPECT_EQ(errNo, DRM_ERR_OK);
2445 unsigned char testArray[5] = {1, 2, 3, 4, 5};
2446 errNo = OH_MediaKeySystem_SetConfigurationByteArray(nullptr, "testConfigurationByteArray", testArray,
2447 sizeof(testArray));
2448 EXPECT_NE(errNo, DRM_ERR_OK);
2449 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "", testArray, sizeof(testArray));
2450 EXPECT_NE(errNo, DRM_ERR_OK);
2451 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, nullptr, testArray, sizeof(testArray));
2452 EXPECT_NE(errNo, DRM_ERR_OK);
2453 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr,
2454 sizeof(testArray));
2455 EXPECT_NE(errNo, DRM_ERR_OK);
2456 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray, 0);
2457 EXPECT_NE(errNo, DRM_ERR_OK);
2458 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2459 EXPECT_EQ(errNo, DRM_ERR_OK);
2460 }
2461
2462 /*
2463 * Feature: Framework
2464 * Function: Processing device certificate response testing
2465 * Sub function: NA
2466 * Function point: NA
2467 * Environmental conditions: NA
2468 * Case Description: Processing Device Certificate Response Testing
2469 */
2470 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetConfigurationByteArrayAbNormal_056, TestSize.Level0)
2471 {
2472 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2473 MediaKeySystem *mediaKeySystem = nullptr;
2474 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2475 EXPECT_NE(mediaKeySystem, nullptr);
2476 EXPECT_EQ(errNo, DRM_ERR_OK);
2477 unsigned char testArray[5] = {1, 2, 3, 4, 5};
2478 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray,
2479 sizeof(testArray));
2480 unsigned char configByteArray[32];
2481 int32_t byteArrayLen = 32;
2482 errNo = OH_MediaKeySystem_GetConfigurationByteArray(nullptr, "testConfigurationByteArray", configByteArray,
2483 &byteArrayLen);
2484 EXPECT_NE(errNo, DRM_ERR_OK);
2485 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "", configByteArray, &byteArrayLen);
2486 EXPECT_NE(errNo, DRM_ERR_OK);
2487 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, nullptr, configByteArray, &byteArrayLen);
2488 EXPECT_NE(errNo, DRM_ERR_OK);
2489 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", nullptr,
2490 &byteArrayLen);
2491 EXPECT_NE(errNo, DRM_ERR_OK);
2492 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray,
2493 nullptr);
2494 EXPECT_NE(errNo, DRM_ERR_OK);
2495 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2496 EXPECT_EQ(errNo, DRM_ERR_OK);
2497 }
2498
2499 /*
2500 * Feature: Framework
2501 * Function: Processing device certificate response testing
2502 * Sub function: NA
2503 * Function point: NA
2504 * Environmental conditions: NA
2505 * Case Description: Processing Device Certificate Response Testing
2506 */
2507 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsNormal_057, TestSize.Level0)
2508 {
2509 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2510 MediaKeySystem *mediaKeySystem = nullptr;
2511 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2512 EXPECT_NE(mediaKeySystem, nullptr);
2513 EXPECT_EQ(errNo, DRM_ERR_OK);
2514 DRM_Statistics statistics;
2515 errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics);
2516 EXPECT_EQ(errNo, DRM_ERR_OK);
2517 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2518 EXPECT_EQ(errNo, DRM_ERR_OK);
2519 }
2520
2521 /*
2522 * Feature: Framework
2523 * Function: Processing device certificate response testing
2524 * Sub function: NA
2525 * Function point: NA
2526 * Environmental conditions: NA
2527 * Case Description: Processing Device Certificate Response Testing
2528 */
2529 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetStatisticsAbNormal_058, TestSize.Level0)
2530 {
2531 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2532 MediaKeySystem *mediaKeySystem = nullptr;
2533 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2534 EXPECT_NE(mediaKeySystem, nullptr);
2535 EXPECT_EQ(errNo, DRM_ERR_OK);
2536 DRM_Statistics statistics;
2537 errNo = OH_MediaKeySystem_GetStatistics(nullptr, &statistics);
2538 EXPECT_NE(errNo, DRM_ERR_OK);
2539 errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, nullptr);
2540 EXPECT_NE(errNo, DRM_ERR_OK);
2541 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2542 EXPECT_EQ(errNo, DRM_ERR_OK);
2543 }
2544
2545 /*
2546 * Feature: Framework
2547 * Function: Test and create DRM instances
2548 * Sub function: NA
2549 * Function point: NA
2550 * Environmental conditions: NA
2551 * Case Description: Test Creating DRM Instance
2552 */
2553 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetMaxContentProtectionLevelAbNormal_059, TestSize.Level0)
2554 {
2555 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2556 MediaKeySystem *mediaKeySystem = nullptr;
2557 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
2558 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2559 EXPECT_NE(mediaKeySystem, nullptr);
2560 EXPECT_EQ(errNo, DRM_ERR_OK);
2561 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(nullptr, &contentProtectionLevel);
2562 EXPECT_NE(errNo, DRM_ERR_OK);
2563 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, nullptr);
2564 EXPECT_NE(errNo, DRM_ERR_OK);
2565 if (mediaKeySystem != nullptr) {
2566 OH_MediaKeySystem_Destroy(mediaKeySystem);
2567 }
2568 }
2569
2570 /*
2571 * Feature: Framework
2572 * Function: Processing device certificate response testing
2573 * Sub function: NA
2574 * Function point: NA
2575 * Environmental conditions: NA
2576 * Case Description: Processing Device Certificate Response Testing
2577 */
2578 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysNormal_060, TestSize.Level0)
2579 {
2580 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2581 MediaKeySystem *mediaKeySystem = nullptr;
2582 MediaKeySession *mediaKeySession = nullptr;
2583 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2584 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2585 EXPECT_NE(mediaKeySystem, nullptr);
2586 EXPECT_EQ(errNo, DRM_ERR_OK);
2587 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2588 EXPECT_NE(mediaKeySession, nullptr);
2589 EXPECT_EQ(errNo, DRM_ERR_OK);
2590 // mediakeysession
2591 DRM_MediaKeyRequest mediaKeyRequest;
2592 DRM_MediaKeyRequestInfo info;
2593 unsigned char testData[241] = OFFREQUESTINFODATA;
2594 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2595 info.initDataLen = testData[3];
2596 info.type = MEDIA_KEY_TYPE_OFFLINE;
2597 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2598 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2599 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2600 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2601 info.optionsCount = 1;
2602 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2603 EXPECT_EQ(errNo, DRM_ERR_OK);
2604 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2605 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2606 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2607 int32_t testKeySessionResponseLen = 12288;
2608 if (g_isWisePlay) {
2609 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2610 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2611 EXPECT_EQ(rett, 0);
2612 } else {
2613 testKeySessionResponseLen = 50;
2614 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2615 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2616 EXPECT_EQ(errNo, DRM_ERR_OK);
2617 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2618 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2619 &OfflineMediaKeyStatus);
2620 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2621 EXPECT_EQ(errNo, DRM_ERR_OK);
2622 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2623 int32_t releaseRequestLen = 12288; // 12288:request len
2624 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2625 releaseRequest, &releaseRequestLen);
2626 EXPECT_EQ(errNo, DRM_ERR_OK);
2627 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2628 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2629 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2630
2631 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2632 &OfflineMediaKeyStatus);
2633
2634 EXPECT_EQ(errNo, DRM_ERR_OK);
2635 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen);
2636 EXPECT_EQ(errNo, DRM_ERR_OK);
2637 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2638 &OfflineMediaKeyStatus);
2639
2640 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2641 EXPECT_EQ(errNo, DRM_ERR_OK);
2642 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2643 EXPECT_EQ(errNo, DRM_ERR_OK);
2644 }
2645
2646 /*
2647 * Feature: Framework
2648 * Function: Processing device certificate response testing
2649 * Sub function: NA
2650 * Function point: NA
2651 * Environmental conditions: NA
2652 * Case Description: Processing Device Certificate Response Testing
2653 */
2654 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearOfflineMediaKeysAbNormal_061, TestSize.Level0)
2655 {
2656 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2657 MediaKeySystem *mediaKeySystem = nullptr;
2658 MediaKeySession *mediaKeySession = nullptr;
2659 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2660 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2661 EXPECT_NE(mediaKeySystem, nullptr);
2662 EXPECT_EQ(errNo, DRM_ERR_OK);
2663 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2664 EXPECT_NE(mediaKeySession, nullptr);
2665 EXPECT_EQ(errNo, DRM_ERR_OK);
2666 // mediakeysession
2667 DRM_MediaKeyRequest mediaKeyRequest;
2668 DRM_MediaKeyRequestInfo info;
2669 unsigned char testData[241] = OFFREQUESTINFODATA;
2670 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2671 info.initDataLen = testData[3];
2672 info.type = MEDIA_KEY_TYPE_OFFLINE;
2673 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2674 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2675 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2676 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2677 info.optionsCount = 1;
2678 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2679 EXPECT_EQ(errNo, DRM_ERR_OK);
2680 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2681 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2682 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2683 int32_t testKeySessionResponseLen = 12288;
2684 if (g_isWisePlay) {
2685 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2686 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2687 EXPECT_EQ(rett, 0);
2688 } else {
2689 testKeySessionResponseLen = 50;
2690 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2691 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2692 EXPECT_EQ(errNo, DRM_ERR_OK);
2693 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2694 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2695 &OfflineMediaKeyStatus);
2696 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2697 EXPECT_EQ(errNo, DRM_ERR_OK);
2698 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2699 int32_t releaseRequestLen = 12288; // 12288:request len
2700 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2701 releaseRequest, &releaseRequestLen);
2702 EXPECT_EQ(errNo, DRM_ERR_OK);
2703 if (!g_isWisePlay) {
2704 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2705 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2706 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2707 EXPECT_EQ(errNo, DRM_ERR_OK);
2708 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2709 &OfflineMediaKeyStatus);
2710 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2711 EXPECT_EQ(errNo, DRM_ERR_OK);
2712 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen);
2713 EXPECT_NE(errNo, DRM_ERR_OK);
2714 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, onlineMediaKeyIdLen);
2715 EXPECT_NE(errNo, DRM_ERR_OK);
2716 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2717 &OfflineMediaKeyStatus);
2718 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2719 EXPECT_EQ(errNo, DRM_ERR_OK);
2720 }
2721 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2722 EXPECT_EQ(errNo, DRM_ERR_OK);
2723 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2724 EXPECT_EQ(errNo, DRM_ERR_OK);
2725 }
2726
2727 /*
2728 * Feature: Framework
2729 * Function: Processing device certificate response testing
2730 * Sub function: NA
2731 * Function point: NA
2732 * Environmental conditions: NA
2733 * Case Description: Processing Device Certificate Response Testing
2734 */
2735 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysNormal_062, TestSize.Level0)
2736 {
2737 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2738 MediaKeySystem *mediaKeySystem = nullptr;
2739 MediaKeySession *mediaKeySession = nullptr;
2740 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2741 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2742 EXPECT_NE(mediaKeySystem, nullptr);
2743 EXPECT_EQ(errNo, DRM_ERR_OK);
2744 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2745 EXPECT_NE(mediaKeySession, nullptr);
2746 EXPECT_EQ(errNo, DRM_ERR_OK);
2747 // mediakeysession
2748 DRM_MediaKeyRequest mediaKeyRequest;
2749 DRM_MediaKeyRequestInfo info;
2750 unsigned char testData[241] = OFFREQUESTINFODATA;
2751 info.initDataLen = testData[3];
2752 info.type = MEDIA_KEY_TYPE_OFFLINE;
2753 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2754 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
2755 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2756 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2757 info.optionsCount = 1;
2758 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2759 EXPECT_EQ(errNo, DRM_ERR_OK);
2760 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2761 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2762 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2763 int32_t testKeySessionResponseLen = 12288;
2764 if (g_isWisePlay) {
2765 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2766 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2767 EXPECT_EQ(rett, 0);
2768 } else {
2769 testKeySessionResponseLen = 50;
2770 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2771 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2772 EXPECT_EQ(errNo, DRM_ERR_OK);
2773 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2774 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2775 &OfflineMediaKeyStatus);
2776 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2777 EXPECT_EQ(errNo, DRM_ERR_OK);
2778 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2779 int32_t releaseRequestLen = 12288; // 12288:request len
2780 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2781 releaseRequest, &releaseRequestLen);
2782 EXPECT_EQ(errNo, DRM_ERR_OK);
2783 if (!g_isWisePlay) {
2784 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2785 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2786 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2787 EXPECT_EQ(errNo, DRM_ERR_OK);
2788 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2789 &OfflineMediaKeyStatus);
2790 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2791 EXPECT_EQ(errNo, DRM_ERR_OK);
2792 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen);
2793 EXPECT_EQ(errNo, DRM_ERR_OK);
2794 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2795 &OfflineMediaKeyStatus);
2796 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2797 EXPECT_EQ(errNo, DRM_ERR_OK);
2798 }
2799 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2800 EXPECT_EQ(errNo, DRM_ERR_OK);
2801 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2802 EXPECT_EQ(errNo, DRM_ERR_OK);
2803 }
2804 /*
2805 * Feature: Framework
2806 * Function: Processing device certificate response testing
2807 * Sub function: NA
2808 * Function point: NA
2809 * Environmental conditions: NA
2810 * Case Description: Processing Device Certificate Response Testing
2811 */
2812 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_063, TestSize.Level0)
2813 {
2814 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2815 MediaKeySystem *mediaKeySystem = nullptr;
2816 MediaKeySession *mediaKeySession = nullptr;
2817 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2818 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2819 EXPECT_NE(mediaKeySystem, nullptr);
2820 EXPECT_EQ(errNo, DRM_ERR_OK);
2821 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2822 EXPECT_NE(mediaKeySession, nullptr);
2823 EXPECT_EQ(errNo, DRM_ERR_OK);
2824 // mediakeysession
2825 DRM_MediaKeyRequest mediaKeyRequest;
2826 DRM_MediaKeyRequestInfo info;
2827 unsigned char testData[241] = OFFREQUESTINFODATA;
2828 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2829 info.initDataLen = 139;
2830 info.type = MEDIA_KEY_TYPE_OFFLINE;
2831 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2832 memcpy_s(info.initData, 139, testData, 139);
2833 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2834 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
2835 info.optionsCount = 1;
2836 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2837 EXPECT_EQ(errNo, DRM_ERR_OK);
2838 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2839 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2840 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
2841 int32_t testKeySessionResponseLen = 12288;
2842 if (g_isWisePlay) {
2843 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2844 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
2845 EXPECT_EQ(rett, 0);
2846 } else {
2847 testKeySessionResponseLen = 50;
2848 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
2849 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2850 EXPECT_EQ(errNo, DRM_ERR_OK);
2851 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2852 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2853 &OfflineMediaKeyStatus);
2854 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2855 EXPECT_EQ(errNo, DRM_ERR_OK);
2856 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2857 int32_t releaseRequestLen = 12288; // 12288:request len
2858 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2859 releaseRequest, &releaseRequestLen);
2860 EXPECT_EQ(errNo, DRM_ERR_OK);
2861 if (!g_isWisePlay) {
2862 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
2863 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2864 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
2865 EXPECT_EQ(errNo, DRM_ERR_OK);
2866 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2867 &OfflineMediaKeyStatus);
2868 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2869 EXPECT_EQ(errNo, DRM_ERR_OK);
2870 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(nullptr, onlineMediaKeyId, onlineMediaKeyIdLen);
2871 EXPECT_NE(errNo, DRM_ERR_OK);
2872 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen);
2873 EXPECT_NE(errNo, DRM_ERR_OK);
2874 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0);
2875 EXPECT_NE(errNo, DRM_ERR_OK);
2876 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2877 &OfflineMediaKeyStatus);
2878 EXPECT_EQ(OfflineMediaKeyStatus, 2);
2879 EXPECT_EQ(errNo, DRM_ERR_OK);
2880 }
2881 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2882 EXPECT_EQ(errNo, DRM_ERR_OK);
2883 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2884 EXPECT_EQ(errNo, DRM_ERR_OK);
2885 }
2886
2887 #define MAX_BUFF 139
filldata(DRM_MediaKeyRequestInfo * info)2888 static void filldata(DRM_MediaKeyRequestInfo *info)
2889 {
2890 unsigned char testData[139] = REQUESTINFODATA;
2891 memset_s(info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
2892 info->initDataLen = sizeof(testData);
2893 info->type = MEDIA_KEY_TYPE_ONLINE;
2894 memcpy_s(info->mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
2895 memcpy_s(info->initData, sizeof(testData), testData, sizeof(testData));
2896 memcpy_s(info->optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2897 memcpy_s(info->optionData[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
2898 info->optionsCount = 1;
2899 }
2900
2901 const unsigned char TESTKEYRELEASERESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47,
2902 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E,
2903 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64,
2904 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48,
2905 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D};
2906 const unsigned char TESTKEYSESSIONRESPONSE[50] = {0x31, 0x64, 0x6E, 0x5A, 0x32, 0x4E, 0x57, 0x74, 0x76, 0x4D, 0x47,
2907 0x34, 0x34, 0x4E, 0x6A, 0x42, 0x30, 0x4D, 0x32, 0x77, 0x33, 0x4E,
2908 0x67, 0x3D, 0x3D, 0x3A, 0x59, 0x7A, 0x56, 0x78, 0x63, 0x48, 0x64,
2909 0x70, 0x61, 0x6D, 0x30, 0x34, 0x59, 0x57, 0x45, 0x34, 0x5A, 0x48,
2910 0x6B, 0x79, 0x4D, 0x67, 0x3D, 0x3D};
2911
filltest3(MediaKeySystem * mediaKeySystem,MediaKeySession * mediaKeySession,unsigned char * keySystemResponse,int32_t KeySystemResponseLen)2912 static void filltest3(MediaKeySystem *mediaKeySystem,
2913 MediaKeySession *mediaKeySession, unsigned char *keySystemResponse, int32_t KeySystemResponseLen)
2914 {
2915 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2916 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2917 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
2918 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, keySystemResponse,
2919 KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
2920 EXPECT_EQ(errNo, DRM_ERR_OK);
2921 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
2922 if (!g_isWisePlay) {
2923 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, onlineMediaKeyId, onlineMediaKeyIdLen,
2924 &OfflineMediaKeyStatus);
2925 EXPECT_EQ(OfflineMediaKeyStatus, 1);
2926 EXPECT_EQ(errNo, DRM_ERR_OK);
2927 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
2928 int32_t releaseRequestLen = 12288; // 12288:request len
2929 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2930 releaseRequest, &releaseRequestLen);
2931 EXPECT_EQ(errNo, DRM_ERR_OK);
2932 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
2933 (uint8_t *)(TESTKEYRELEASERESPONSE), (int32_t)(sizeof(TESTKEYRELEASERESPONSE)));
2934 EXPECT_EQ(errNo, DRM_ERR_OK);
2935 }
2936 DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
2937 errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel);
2938 EXPECT_EQ(errNo, DRM_ERR_OK);
2939 errNo = OH_MediaKeySession_GetContentProtectionLevel(nullptr, &sessionContentProtectionLevel);
2940 EXPECT_NE(errNo, DRM_ERR_OK);
2941 errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, nullptr);
2942 EXPECT_NE(errNo, DRM_ERR_OK);
2943 }
2944
2945 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_064, TestSize.Level0)
2946 {
2947 MediaKeySystem *mediaKeySystem = nullptr;
2948 MediaKeySession *mediaKeySession = nullptr;
2949 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2950 Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2951 EXPECT_NE(mediaKeySystem, nullptr);
2952 EXPECT_EQ(errNo, DRM_ERR_OK);
2953 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2954 EXPECT_NE(mediaKeySession, nullptr);
2955 EXPECT_EQ(errNo, DRM_ERR_OK);
2956 // mediakeysession
2957 DRM_MediaKeyRequest mediaKeyRequest;
2958 DRM_MediaKeyRequestInfo info;
2959 filldata(&info);
2960 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
2961 int32_t KeySystemResponseLen = 12288;
2962 unsigned char KeySystemResponse[12288] = OFFRESPONSE;
2963 if (g_isWisePlay) {
2964 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
2965 (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10);
2966 EXPECT_EQ(rett, 0);
2967 } else {
2968 KeySystemResponseLen = 50;
2969 }
2970 EXPECT_EQ(errNo, DRM_ERR_OK);
2971 filltest3(mediaKeySystem, mediaKeySession, KeySystemResponse, KeySystemResponseLen);
2972 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2973 mediaKeySession = nullptr;
2974 EXPECT_EQ(errNo, DRM_ERR_OK);
2975 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
2976 mediaKeySession = nullptr;
2977 EXPECT_NE(errNo, DRM_ERR_OK);
2978 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
2979 mediaKeySystem = nullptr;
2980 EXPECT_EQ(errNo, DRM_ERR_OK);
2981 }
2982
2983 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_GetContentProtectionLevelNormal_065, TestSize.Level0)
2984 {
2985 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
2986 MediaKeySystem *mediaKeySystem = nullptr;
2987 MediaKeySession *mediaKeySession = nullptr;
2988 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
2989 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
2990 EXPECT_NE(mediaKeySystem, nullptr);
2991 EXPECT_EQ(errNo, DRM_ERR_OK);
2992 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
2993 EXPECT_NE(mediaKeySession, nullptr);
2994 EXPECT_EQ(errNo, DRM_ERR_OK);
2995 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
2996 EXPECT_EQ(errNo, DRM_ERR_OK);
2997 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
2998 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback);
2999 EXPECT_EQ(errNo, DRM_ERR_OK);
3000 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3001 EXPECT_EQ(errNo, DRM_ERR_OK);
3002 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3003 EXPECT_EQ(errNo, DRM_ERR_OK);
3004 }
3005
3006 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_066, TestSize.Level0)
3007 {
3008 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3009 MediaKeySystem *mediaKeySystem = nullptr;
3010 MediaKeySession *mediaKeySession = nullptr;
3011 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3012 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3013 EXPECT_NE(mediaKeySystem, nullptr);
3014 EXPECT_EQ(errNo, DRM_ERR_OK);
3015 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3016 EXPECT_NE(mediaKeySession, nullptr);
3017 EXPECT_EQ(errNo, DRM_ERR_OK);
3018 // mediakeysession
3019 DRM_MediaKeyRequest mediaKeyRequest;
3020 DRM_MediaKeyRequestInfo info;
3021 filldata(&info);
3022 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3023 EXPECT_EQ(errNo, DRM_ERR_OK);
3024 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3025 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3026 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
3027 int32_t testKeySessionResponseLen = 12288;
3028 if (g_isWisePlay) {
3029 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
3030 (uint32_t)mediaKeyRequest.dataLen, testKeySessionResponse, &testKeySessionResponseLen, 10);
3031 EXPECT_EQ(rett, 0);
3032 } else {
3033 testKeySessionResponseLen = 50;
3034 }
3035 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3036 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3037 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3038 EXPECT_EQ(errNo, DRM_ERR_OK);
3039 if (mediaKeySession) {
3040 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3041 sptr<IMediaKeySessionService> SessionServiceProxy =
3042 sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy();
3043 sptr<IMediaDecryptModuleService> decryptModule;
3044 SessionServiceProxy->GetMediaDecryptModule(decryptModule);
3045 MessageParcel data;
3046 IMediaDecryptModuleService::DrmBuffer srcBuffer;
3047 IMediaDecryptModuleService::DrmBuffer dstBuffer;
3048 bool secureDecodrtState = false;
3049 IMediaDecryptModuleService::CryptInfo cryptInfo;
3050 decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer);
3051 decryptModule->Release();
3052 sptr<MediaKeySessionImplCallback> callback = sessionObject->sessionImpl_->GetApplicationCallback();
3053 callback->~MediaKeySessionImplCallback();
3054 }
3055 if (mediaKeySystem) {
3056 MediaKeySystemObject *systemObject = reinterpret_cast<MediaKeySystemObject *>(mediaKeySystem);
3057 sptr<IMediaKeySystemServiceCallback> serviceCallback =
3058 new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_);
3059 sptr<MediaKeySystemCallback> Callback = new (std::nothrow) MediaKeySystemCallback(systemObject->systemImpl_);
3060 const std::vector<uint8_t> data = { 0x01 };
3061 MessageParcel data1;
3062 MessageParcel reply;
3063 MessageOption option;
3064 Callback->OnRemoteRequest(MEDIA_KEY_SYSTEM_SERVICE_CALLBACK_SEND_EVENT, data1, reply, option);
3065 serviceCallback->SendEvent(OHOS::DrmStandard::DrmEventType::DRM_EVENT_PROVISION_REQUIRED, 1, data);
3066 OHOS::sptr<OHOS::DrmStandard::MediaKeySystemCallbackCapi> SystemCallbackCapi =
3067 new (std::nothrow) MediaKeySystemCallbackCapi();
3068 SystemCallbackCapi->SetCallbackReference(&TestSystemEventCallBack);
3069 SystemCallbackCapi->SendEvent("1", 1, data);
3070 sptr<MediaKeySystemImplCallback> SystemImplCallba = systemObject->systemImpl_->GetApplicationCallback();
3071 SystemImplCallba->~MediaKeySystemImplCallback();
3072 }
3073 EXPECT_EQ(errNo, DRM_ERR_OK);
3074 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3075 EXPECT_EQ(errNo, DRM_ERR_OK);
3076 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3077 EXPECT_EQ(errNo, DRM_ERR_OK);
3078 }
3079
3080 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_DecryptModuleNormal_067, TestSize.Level0)
3081 {
3082 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3083 int32_t releaseRequestLen = 12288; // 12288:request len
3084 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
3085 uint8_t mediaKeyIdToRelease;
3086 MediaKeySession *mediaKeySession = (MediaKeySession *)&mediaKeyIdToRelease;
3087 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, nullptr, 11, releaseRequest, // 11:len
3088 &releaseRequestLen);
3089 EXPECT_NE(errNo, DRM_ERR_OK);
3090 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)&releaseRequestLen, 0,
3091 releaseRequest, &releaseRequestLen);
3092 EXPECT_NE(errNo, DRM_ERR_OK);
3093 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
3094 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen, 0,
3095 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
3096 EXPECT_NE(errNo, DRM_ERR_OK);
3097 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, nullptr, 11, // 11:len
3098 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
3099 EXPECT_NE(errNo, DRM_ERR_OK);
3100 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen,
3101 11, nullptr, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len
3102 EXPECT_NE(errNo, DRM_ERR_OK);
3103 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)&releaseRequestLen,
3104 11, testKeyReleaseResponse, 0);
3105 EXPECT_NE(errNo, DRM_ERR_OK);
3106 }
3107
3108 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_RestoreOfflineMediaKeysAbNormal_068, TestSize.Level0)
3109 {
3110 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3111 unsigned char onlineMediaKeyId[88]; // 88:keyId len
3112 uint32_t onlineMediaKeyIdLen = 88; // 88:keyId len
3113 MediaKeySession *mediaKeySession = (MediaKeySession *)&onlineMediaKeyId;
3114 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, onlineMediaKeyId, 0);
3115 EXPECT_NE(errNo, DRM_ERR_OK);
3116 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, nullptr, onlineMediaKeyIdLen);
3117 EXPECT_NE(errNo, DRM_ERR_OK);
3118 }
3119
3120 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetMediaKeySessionCallbackNormal_069, TestSize.Level0)
3121 {
3122 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3123 MediaKeySystem *mediaKeySystem = nullptr;
3124 MediaKeySession *mediaKeySession = nullptr;
3125 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3126 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3127 EXPECT_NE(mediaKeySystem, nullptr);
3128 EXPECT_EQ(errNo, DRM_ERR_OK);
3129 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3130 EXPECT_NE(mediaKeySession, nullptr);
3131 EXPECT_EQ(errNo, DRM_ERR_OK);
3132 // test 3: system callback
3133 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(nullptr, &TestSystemEventCallBack);
3134 EXPECT_NE(errNo, DRM_ERR_OK);
3135 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, nullptr);
3136 EXPECT_NE(errNo, DRM_ERR_OK);
3137 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3138 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, nullptr);
3139 EXPECT_NE(errNo, DRM_ERR_OK);
3140 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(nullptr, &sessionCallback);
3141 EXPECT_NE(errNo, DRM_ERR_OK);
3142 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3143 EXPECT_EQ(errNo, DRM_ERR_OK);
3144 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3145 EXPECT_EQ(errNo, DRM_ERR_OK);
3146 }
3147
3148 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_070, TestSize.Level0)
3149 {
3150 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3151 MediaKeySystem *mediaKeySystem = nullptr;
3152 MediaKeySession *mediaKeySession = nullptr;
3153 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3154 errNo = OH_MediaKeySystem_Create(nullptr, &mediaKeySystem);
3155 EXPECT_EQ(mediaKeySystem, nullptr);
3156 errNo = OH_MediaKeySystem_Create(GetUuid(), nullptr);
3157 EXPECT_EQ(mediaKeySystem, nullptr);
3158 errNo = OH_MediaKeySystem_CreateMediaKeySession(nullptr, &contentProtectionLevel, &mediaKeySession);
3159 EXPECT_EQ(mediaKeySession, nullptr);
3160 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, nullptr, &mediaKeySession);
3161 EXPECT_EQ(mediaKeySession, nullptr);
3162 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, nullptr);
3163 EXPECT_EQ(mediaKeySession, nullptr);
3164 uint8_t mediaKeyIdToClear;
3165 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&mediaKeyIdToClear, 0);
3166 EXPECT_NE(errNo, DRM_ERR_OK);
3167 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, nullptr, 11); // 11:len
3168 EXPECT_NE(errNo, DRM_ERR_OK);
3169 errNo = OH_MediaKeySession_Destroy(nullptr);
3170 EXPECT_NE(errNo, DRM_ERR_OK);
3171 errNo = OH_MediaKeySystem_Destroy(nullptr);
3172 EXPECT_NE(errNo, DRM_ERR_OK);
3173 }
3174
3175 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySystemDestroyAbNormal_071, TestSize.Level0)
3176 {
3177 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3178 MediaKeySystem *mediaKeySystem = nullptr;
3179 MediaKeySession *mediaKeySession = nullptr;
3180 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3181 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3182 EXPECT_NE(mediaKeySystem, nullptr);
3183 EXPECT_EQ(errNo, DRM_ERR_OK);
3184 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3185 EXPECT_NE(mediaKeySession, nullptr);
3186 EXPECT_EQ(errNo, DRM_ERR_OK);
3187 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3188 EXPECT_EQ(errNo, DRM_ERR_OK);
3189 if (mediaKeySystem) {
3190 MediaKeySystemObject *systemObject = reinterpret_cast<MediaKeySystemObject *>(mediaKeySystem);
3191 systemObject->systemImpl_->~MediaKeySystemImpl();
3192 }
3193 errNo =
3194 OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString");
3195 EXPECT_NE(errNo, DRM_ERR_OK);
3196 char value[32];
3197 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, 32);
3198 EXPECT_NE(errNo, DRM_ERR_OK);
3199 unsigned char testArray[5] = {1, 2, 3, 4, 5};
3200 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray,
3201 sizeof(testArray));
3202 EXPECT_NE(errNo, DRM_ERR_OK);
3203 unsigned char configByteArray[32];
3204 int32_t byteArrayLen = 32;
3205 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray,
3206 &byteArrayLen);
3207 EXPECT_NE(errNo, DRM_ERR_OK);
3208 DRM_Statistics statistics;
3209 errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics);
3210 EXPECT_NE(errNo, DRM_ERR_OK);
3211 contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
3212 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
3213 }
3214
3215 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_OH_MediaKeySystemDestroyAbNormal2_072, TestSize.Level0)
3216 {
3217 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3218 MediaKeySystem *mediaKeySystem = nullptr;
3219 MediaKeySession *mediaKeySession = nullptr;
3220 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3221 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3222 EXPECT_NE(mediaKeySystem, nullptr);
3223 EXPECT_EQ(errNo, DRM_ERR_OK);
3224 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3225 EXPECT_NE(mediaKeySession, nullptr);
3226 EXPECT_EQ(errNo, DRM_ERR_OK);
3227 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3228 EXPECT_EQ(errNo, DRM_ERR_OK);
3229 if (mediaKeySystem) {
3230 MediaKeySystemObject *systemObject = reinterpret_cast<MediaKeySystemObject *>(mediaKeySystem);
3231 systemObject->systemImpl_->~MediaKeySystemImpl();
3232 }
3233 DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
3234 errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus);
3235 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3236 EXPECT_EQ(errNo, DRM_ERR_OK);
3237 contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
3238 MediaKeySession *OH_MediaKeySession2 = nullptr;
3239 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &OH_MediaKeySession2);
3240 EXPECT_EQ(OH_MediaKeySession2, nullptr);
3241 EXPECT_NE(errNo, DRM_ERR_OK);
3242 DRM_OfflineMediakeyIdArray offlineMediaKeyIds;
3243 errNo = OH_MediaKeySystem_GetOfflineMediaKeyIds(mediaKeySystem, &offlineMediaKeyIds);
3244 DRM_OfflineMediaKeyStatus OfflineMediaKeyStatus = OFFLINE_MEDIA_KEY_STATUS_UNKNOWN;
3245 errNo = OH_MediaKeySystem_GetOfflineMediaKeyStatus(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1,
3246 &OfflineMediaKeyStatus);
3247 errNo = OH_MediaKeySystem_ClearOfflineMediaKeys(mediaKeySystem, (uint8_t *)&OfflineMediaKeyStatus, 1);
3248 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3249 }
3250
3251 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal_073, TestSize.Level0)
3252 {
3253 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3254 MediaKeySystem *mediaKeySystem = nullptr;
3255 MediaKeySession *mediaKeySession = nullptr;
3256 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3257 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3258 EXPECT_NE(mediaKeySystem, nullptr);
3259 EXPECT_EQ(errNo, DRM_ERR_OK);
3260 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3261 EXPECT_NE(mediaKeySession, nullptr);
3262 EXPECT_EQ(errNo, DRM_ERR_OK);
3263 if (mediaKeySession) {
3264 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3265 sessionObject->sessionImpl_->~MediaKeySessionImpl();
3266 }
3267 DRM_MediaKeyRequest mediaKeyRequest;
3268 DRM_MediaKeyRequestInfo info;
3269 unsigned char testData[139] = REQUESTINFODATA;
3270 memset_s(&info, sizeof(DRM_MediaKeyRequestInfo), 0, sizeof(DRM_MediaKeyRequestInfo));
3271 info.initDataLen = sizeof(testData);
3272 info.type = MEDIA_KEY_TYPE_ONLINE;
3273 memcpy_s(info.mimeType, sizeof("video/mp4"), (char *)"video/mp4", sizeof("video/mp4"));
3274 memcpy_s(info.initData, sizeof(testData), testData, sizeof(testData));
3275 memcpy_s(info.optionName[0], sizeof("optionalDataName"), (char *)"optionalDataName", sizeof("optionalDataName"));
3276 memcpy_s(info.optionData[0], sizeof("optionalDataValue"), (char *)"optionalDataValue", sizeof("optionalDataValue"));
3277 info.optionsCount = 1;
3278 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3279 EXPECT_NE(errNo, DRM_ERR_OK);
3280 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3281 EXPECT_EQ(errNo, DRM_ERR_OK);
3282 }
3283
3284 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal2_074, TestSize.Level0)
3285 {
3286 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3287 MediaKeySystem *mediaKeySystem = nullptr;
3288 MediaKeySession *mediaKeySession = nullptr;
3289 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3290 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3291 EXPECT_NE(mediaKeySystem, nullptr);
3292 EXPECT_EQ(errNo, DRM_ERR_OK);
3293 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3294 EXPECT_NE(mediaKeySession, nullptr);
3295 EXPECT_EQ(errNo, DRM_ERR_OK);
3296 if (mediaKeySession) {
3297 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3298 sessionObject->sessionImpl_->~MediaKeySessionImpl();
3299 }
3300 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3301 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3302 unsigned char testKeySessionResponse[12288] = { 0 };
3303 int32_t testKeySessionResponseLen = 12288;
3304 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3305 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3306 EXPECT_NE(errNo, DRM_ERR_OK);
3307 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3308 EXPECT_EQ(errNo, DRM_ERR_OK);
3309 }
3310
3311 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySession_DestroyAbNormal3_075, TestSize.Level0)
3312 {
3313 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3314 MediaKeySystem *mediaKeySystem = nullptr;
3315 MediaKeySession *mediaKeySession = nullptr;
3316 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3317 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3318 EXPECT_NE(mediaKeySystem, nullptr);
3319 EXPECT_EQ(errNo, DRM_ERR_OK);
3320 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3321 EXPECT_NE(mediaKeySession, nullptr);
3322 EXPECT_EQ(errNo, DRM_ERR_OK);
3323 if (mediaKeySession) {
3324 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3325 sessionObject->sessionImpl_->~MediaKeySessionImpl();
3326 }
3327 DRM_MediaKeyStatus mediaKeyStatus;
3328 errNo = OH_MediaKeySession_CheckMediaKeyStatus(mediaKeySession, &mediaKeyStatus);
3329 EXPECT_NE(errNo, DRM_ERR_OK);
3330 errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession);
3331 EXPECT_NE(errNo, DRM_ERR_OK);
3332 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
3333 int32_t releaseRequestLen = 12288; // 12288:request len
3334 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)GetUuid(),
3335 11, releaseRequest, &releaseRequestLen); // 11:len
3336 EXPECT_NE(errNo, DRM_ERR_OK);
3337 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3338 EXPECT_EQ(errNo, DRM_ERR_OK);
3339 }
3340
3341 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_MediaKeySessionDestroyAbNormal4_076, TestSize.Level0)
3342 {
3343 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3344 MediaKeySystem *mediaKeySystem = nullptr;
3345 MediaKeySession *mediaKeySession = nullptr;
3346 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3347 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3348 EXPECT_NE(mediaKeySystem, nullptr);
3349 EXPECT_EQ(errNo, DRM_ERR_OK);
3350 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3351 EXPECT_NE(mediaKeySession, nullptr);
3352 EXPECT_EQ(errNo, DRM_ERR_OK);
3353 if (mediaKeySession) {
3354 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3355 sessionObject->sessionImpl_->~MediaKeySessionImpl();
3356 }
3357 unsigned char testKeyReleaseResponse[50] = OFFRESPONSE;
3358 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, (uint8_t *)GetUuid(),
3359 11, testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse))); // 11:len
3360 EXPECT_NE(errNo, DRM_ERR_OK);
3361 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)GetUuid(), 1);
3362 EXPECT_NE(errNo, DRM_ERR_OK);
3363 DRM_ContentProtectionLevel sessionContentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
3364 errNo = OH_MediaKeySession_GetContentProtectionLevel(mediaKeySession, &sessionContentProtectionLevel);
3365 EXPECT_NE(errNo, DRM_ERR_OK);
3366 bool requireSecureDecoder;
3367 errNo = OH_MediaKeySession_RequireSecureDecoderModule(mediaKeySession, "video/mp4", &requireSecureDecoder);
3368 EXPECT_NE(errNo, DRM_ERR_OK);
3369 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3370 EXPECT_EQ(errNo, DRM_ERR_OK);
3371 }
3372
3373 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal_077, TestSize.Level0)
3374 {
3375 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3376 MediaKeySystem *mediaKeySystem = nullptr;
3377 MediaKeySession *mediaKeySession = nullptr;
3378 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3379 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3380 EXPECT_NE(mediaKeySystem, nullptr);
3381 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3382 EXPECT_EQ(errNo, DRM_ERR_OK);
3383 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3384 EXPECT_NE(mediaKeySession, nullptr);
3385 EXPECT_EQ(errNo, DRM_ERR_OK);
3386 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3387 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback);
3388 EXPECT_EQ(errNo, DRM_ERR_OK);
3389 // mediakeysession
3390 DRM_MediaKeyRequest mediaKeyRequest;
3391 DRM_MediaKeyRequestInfo info;
3392 filldata(&info);
3393 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3394 EXPECT_EQ(errNo, DRM_ERR_OK);
3395 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3396 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3397 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
3398 int32_t testKeySessionResponseLen = 12288;
3399 if (g_isWisePlay) {
3400 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen,
3401 testKeySessionResponse, &testKeySessionResponseLen, 10);
3402 EXPECT_EQ(rett, 0);} else {
3403 testKeySessionResponseLen = 50;
3404 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3405 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3406 EXPECT_EQ(errNo, DRM_ERR_OK);
3407 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3408 EXPECT_EQ(errNo, DRM_ERR_OK);
3409 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3410 EXPECT_EQ(errNo, DRM_ERR_OK);
3411 }
3412
3413 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackNormal2_078, TestSize.Level0)
3414 {
3415 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3416 MediaKeySystem *mediaKeySystem = nullptr;
3417 MediaKeySession *mediaKeySession = nullptr;
3418 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3419 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3420 EXPECT_NE(mediaKeySystem, nullptr);
3421 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3422 EXPECT_EQ(errNo, DRM_ERR_OK);
3423 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3424 EXPECT_NE(mediaKeySession, nullptr);
3425 EXPECT_EQ(errNo, DRM_ERR_OK);
3426 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3427 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback);
3428 EXPECT_EQ(errNo, DRM_ERR_OK);
3429 // mediakeysession
3430 DRM_MediaKeyRequest mediaKeyRequest;
3431 DRM_MediaKeyRequestInfo info;
3432 filldata(&info);
3433 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3434 EXPECT_EQ(errNo, DRM_ERR_OK);
3435 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3436 unsigned char testKeySessionResponse[2] = {0x07, 0x22};
3437 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3438 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3439 (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen);
3440 EXPECT_NE(errNo, DRM_ERR_OK);
3441 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3442 EXPECT_EQ(errNo, DRM_ERR_OK);
3443 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3444 EXPECT_EQ(errNo, DRM_ERR_OK);
3445 }
3446
3447 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessMediaKeyResponseAbNormal_079, TestSize.Level0)
3448 {
3449 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3450 MediaKeySystem *mediaKeySystem = nullptr;
3451 MediaKeySession *mediaKeySession = nullptr;
3452 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3453 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3454 EXPECT_NE(mediaKeySystem, nullptr);
3455 EXPECT_EQ(errNo, DRM_ERR_OK);
3456 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3457 EXPECT_NE(mediaKeySession, nullptr);
3458 EXPECT_EQ(errNo, DRM_ERR_OK);
3459 // mediakeysession
3460 DRM_MediaKeyRequest mediaKeyRequest;
3461 DRM_MediaKeyRequestInfo info;
3462 filldata(&info);
3463 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3464 EXPECT_EQ(errNo, DRM_ERR_OK);
3465 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3466 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3467 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
3468 int32_t testKeySessionResponseLen = 12288;
3469 if (g_isWisePlay) {
3470 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data, (uint32_t)mediaKeyRequest.dataLen,
3471 testKeySessionResponse, &testKeySessionResponseLen, 10);
3472 EXPECT_EQ(rett, 0);
3473 } else {
3474 testKeySessionResponseLen = 50;
3475 }errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3476 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3477 EXPECT_EQ(errNo, DRM_ERR_OK);
3478 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
3479 int32_t releaseRequestLen = 12288; // 12288:request len
3480 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, (uint8_t *)("onlineMediaKeyId"),
3481 2, releaseRequest, &releaseRequestLen); // 2:len
3482 EXPECT_EQ(errNo, DRM_ERR_OK);
3483 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3484 EXPECT_EQ(errNo, DRM_ERR_OK);
3485 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3486 EXPECT_EQ(errNo, DRM_ERR_OK);
3487 }
3488
3489 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ProcessOfflineReleaseResponseAbNormal_080, TestSize.Level0)
3490 {
3491 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3492 MediaKeySystem *mediaKeySystem = nullptr;
3493 MediaKeySession *mediaKeySession = nullptr;
3494 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3495 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3496 EXPECT_NE(mediaKeySystem, nullptr);
3497 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3498 // mediakeysession
3499 DRM_MediaKeyRequest mediaKeyRequest;
3500 DRM_MediaKeyRequestInfo info;
3501 filldata(&info);
3502 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3503 EXPECT_EQ(errNo, DRM_ERR_OK);
3504 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3505 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3506 int32_t KeySystemResponseLen = 12288;
3507 unsigned char KeySystemResponse[12288] = OFFRESPONSE;
3508 if (g_isWisePlay) {
3509 int rett = HttpPost(LICENSE_URL, mediaKeyRequest.data,
3510 (uint32_t)mediaKeyRequest.dataLen, KeySystemResponse, &KeySystemResponseLen, 10);
3511 EXPECT_EQ(rett, 0);
3512 } else {
3513 KeySystemResponseLen = 50;
3514 }
3515 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, KeySystemResponse,
3516 KeySystemResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3517 EXPECT_EQ(errNo, DRM_ERR_OK);
3518 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
3519 int32_t releaseRequestLen = 12288; // 12288:request len
3520 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
3521 releaseRequest, &releaseRequestLen);
3522 EXPECT_EQ(errNo, DRM_ERR_OK);
3523 unsigned char testKeyReleaseResponse[2] = {0x33, 0x22};
3524 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
3525 testKeyReleaseResponse, (int32_t)(sizeof(testKeyReleaseResponse)));
3526 EXPECT_EQ(errNo, DRM_ERR_OK);
3527 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3528 EXPECT_EQ(errNo, DRM_ERR_OK);
3529 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3530 }
3531
filltest(MediaKeySystem * mediaKeySystem,MediaKeySession * mediaKeySession)3532 static void filltest(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession)
3533 {
3534 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3535 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3536 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3537 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, (uint8_t *)TESTKEYSESSIONRESPONSE,
3538 (int32_t)(sizeof(TESTKEYSESSIONRESPONSE)), onlineMediaKeyId, &onlineMediaKeyIdLen);
3539 unsigned char releaseRequest[12288] = { 0 }; // 12288:request len
3540 int32_t releaseRequestLen = 12288; // 12288:request len
3541 errNo = OH_MediaKeySession_GenerateOfflineReleaseRequest(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
3542 releaseRequest, &releaseRequestLen);
3543 EXPECT_EQ(errNo, DRM_ERR_OK);
3544 errNo = OH_MediaKeySession_ProcessOfflineReleaseResponse(mediaKeySession, onlineMediaKeyId, onlineMediaKeyIdLen,
3545 (uint8_t *)TESTKEYRELEASERESPONSE, (int32_t)(sizeof(TESTKEYRELEASERESPONSE)));
3546 EXPECT_EQ(errNo, DRM_ERR_OK);
3547 errNo = OH_MediaKeySession_RestoreOfflineMediaKeys(mediaKeySession, (unsigned char *)"onlineMediaKeyId", 1);
3548 EXPECT_NE(errNo, DRM_ERR_OK);
3549 }
3550 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_ClearMediaKeysAbNormal_081, TestSize.Level0)
3551 {
3552 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3553 MediaKeySystem *mediaKeySystem = nullptr;
3554 MediaKeySession *mediaKeySession = nullptr;
3555 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3556 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3557 EXPECT_NE(mediaKeySystem, nullptr);
3558 EXPECT_EQ(errNo, DRM_ERR_OK);
3559 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3560 EXPECT_NE(mediaKeySession, nullptr);
3561 EXPECT_EQ(errNo, DRM_ERR_OK);
3562 errNo = OH_MediaKeySession_ClearMediaKeys(mediaKeySession);
3563 EXPECT_EQ(errNo, DRM_ERR_OK);
3564 // mediakeysession
3565 DRM_MediaKeyRequest mediaKeyRequest;
3566 DRM_MediaKeyRequestInfo info;
3567 filldata(&info);
3568 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3569 EXPECT_EQ(errNo, DRM_ERR_OK);
3570 filltest(mediaKeySystem, mediaKeySession);
3571 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3572 EXPECT_EQ(errNo, DRM_ERR_OK);
3573 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3574 EXPECT_EQ(errNo, DRM_ERR_OK);
3575 sleep(1);
3576 }
3577
3578 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySessionAbNormal_082, TestSize.Level0)
3579 {
3580 MediaKeySystem *mediaKeySystem = nullptr;
3581 Drm_ErrCode errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3582 EXPECT_NE(mediaKeySystem, nullptr);
3583 EXPECT_EQ(errNo, DRM_ERR_OK);
3584 if (mediaKeySystem) {
3585 MediaKeySystemObject *systemObject = reinterpret_cast<MediaKeySystemObject *>(mediaKeySystem);
3586 IMediaKeySessionService::ContentProtectionLevel securityLevel =
3587 IMediaKeySessionService::CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3588 OHOS::sptr<MediaKeySessionImpl> keySessionImpl = nullptr;
3589 systemObject->systemImpl_->~MediaKeySystemImpl();
3590 systemObject->systemImpl_->CreateMediaKeySession(securityLevel, &keySessionImpl);
3591 keySessionImpl = nullptr;
3592 MediaKeySystemCallback *allback = new MediaKeySystemCallback();
3593 allback->~MediaKeySystemCallback();
3594 OHOS::sptr<MediaKeySystemFactoryImpl> fatory = MediaKeySystemFactoryImpl::GetInstance();
3595 fatory->Init();
3596 }
3597 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3598 mediaKeySystem = nullptr;
3599 EXPECT_NE(errNo, DRM_ERR_OK);
3600 MediaKeySystem *mediaKeySystem2 = nullptr;
3601 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem2);
3602 EXPECT_NE(mediaKeySystem2, nullptr);
3603 EXPECT_EQ(errNo, DRM_ERR_OK);
3604 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem2);
3605 mediaKeySystem2 = nullptr;
3606 EXPECT_EQ(errNo, DRM_ERR_OK);
3607 }
3608
3609 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SessionImplAbNormal_083, TestSize.Level0)
3610 {
3611 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3612 MediaKeySystem *mediaKeySystem = nullptr;
3613 MediaKeySession *mediaKeySession = nullptr;
3614 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3615 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3616 EXPECT_NE(mediaKeySystem, nullptr);
3617 EXPECT_EQ(errNo, DRM_ERR_OK);
3618 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3619 EXPECT_NE(mediaKeySession, nullptr);
3620 EXPECT_EQ(errNo, DRM_ERR_OK);
3621 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3622 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback);
3623 EXPECT_EQ(errNo, DRM_ERR_OK);
3624 unsigned char onlineMediaKeyId[128] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3625 int32_t onlineMediaKeyIdLen = 128; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3626 unsigned char testKeySessionResponse[12288] = OFFRESPONSE;
3627 int32_t testKeySessionResponseLen = 50;
3628 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3629 (int32_t)testKeySessionResponseLen, onlineMediaKeyId, &onlineMediaKeyIdLen);
3630 if (mediaKeySession) {
3631 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3632 MediaKeySessionServiceCallback *Object = new MediaKeySessionServiceCallback(sessionObject->sessionImpl_);
3633 std::map<std::vector<uint8_t>, MediaKeySessionKeyStatus> statusTable = { { { 0x01 },
3634 MEDIA_KEY_SESSION_KEY_STATUS_USABLE } };
3635 bool hasNewGoodLicense = false;
3636 Object->SendEventKeyChanged(statusTable, hasNewGoodLicense);
3637 }
3638 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3639 EXPECT_EQ(errNo, DRM_ERR_OK);
3640 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3641 mediaKeySystem = nullptr;
3642 EXPECT_EQ(errNo, DRM_ERR_OK);
3643 }
3644
killclearplay(MediaKeySystem * mediaKeySystem,MediaKeySession * mediaKeySession)3645 static void killclearplay(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession)
3646 {
3647 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3648 std::vector<uint8_t> licenseIdVec = { 0x01 };
3649 std::vector<uint8_t> ReleaseRequest = { 0x01 };
3650 IMediaKeySessionService::ContentProtectionLevel securityLevel;
3651 system(GetDrmPlugin());
3652 if (mediaKeySession) {
3653 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3654 uint32_t result = sessionObject->sessionImpl_->GenerateOfflineReleaseRequest(licenseIdVec, ReleaseRequest);
3655 EXPECT_NE(result, DRM_ERR_OK);
3656 result = sessionObject->sessionImpl_->ProcessOfflineReleaseResponse(licenseIdVec, ReleaseRequest);
3657 EXPECT_NE(result, DRM_ERR_OK);
3658 result = sessionObject->sessionImpl_->GetContentProtectionLevel(&securityLevel);
3659 EXPECT_NE(result, DRM_ERR_OK);
3660 std::map<std::string, std::string> licenseStatus2;
3661 result = sessionObject->sessionImpl_->CheckMediaKeyStatus(licenseStatus2);
3662 EXPECT_NE(result, DRM_ERR_OK);
3663 result = sessionObject->sessionImpl_->RestoreOfflineMediaKeys(licenseIdVec);
3664 EXPECT_NE(result, DRM_ERR_OK);
3665 result = sessionObject->sessionImpl_->ClearMediaKeys();
3666 EXPECT_NE(result, DRM_ERR_OK);
3667 std::string mimeType;
3668 bool status;
3669 result = sessionObject->sessionImpl_->RequireSecureDecoderModule(mimeType, &status);
3670 EXPECT_NE(result, DRM_ERR_OK);
3671 }
3672 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3673 EXPECT_EQ(errNo, DRM_ERR_OK);
3674 MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3675 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &sessionCallback);
3676 EXPECT_EQ(errNo, DRM_ERR_OK);
3677 }
3678
killclearplay2(MediaKeySystem * mediaKeySystem,MediaKeySession * mediaKeySession)3679 static void killclearplay2(MediaKeySystem *mediaKeySystem, MediaKeySession *mediaKeySession)
3680 {
3681 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3682 bool supported = true;
3683 supported = OH_MediaKeySystem_IsSupported(GetUuid());
3684 EXPECT_EQ(supported, true);
3685 supported = OH_MediaKeySystem_IsSupported2(GetUuid(), "video/mp4");
3686 supported = OH_MediaKeySystem_IsSupported3(GetUuid(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
3687
3688 errNo =
3689 OH_MediaKeySystem_SetConfigurationString(mediaKeySystem, "testConfigurationString", "testConfigurationString");
3690 EXPECT_NE(errNo, DRM_ERR_OK);
3691 char value[32];
3692 int32_t valueLen = 32;
3693 errNo = OH_MediaKeySystem_GetConfigurationString(mediaKeySystem, "testConfigurationString", value, valueLen);
3694 EXPECT_NE(errNo, DRM_ERR_OK);
3695 unsigned char testArray[5] = {1, 2, 3, 4, 5};
3696 errNo = OH_MediaKeySystem_SetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", testArray,
3697 sizeof(testArray));
3698 EXPECT_NE(errNo, DRM_ERR_OK);
3699 unsigned char configByteArray[32];
3700 int32_t byteArrayLen = 32;
3701 errNo = OH_MediaKeySystem_GetConfigurationByteArray(mediaKeySystem, "testConfigurationByteArray", configByteArray,
3702 &byteArrayLen);
3703 EXPECT_NE(errNo, DRM_ERR_OK);
3704 DRM_Statistics statistics;
3705 errNo = OH_MediaKeySystem_GetStatistics(mediaKeySystem, &statistics);
3706 EXPECT_NE(errNo, DRM_ERR_OK);
3707 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_UNKNOWN;
3708 errNo = OH_MediaKeySystem_GetMaxContentProtectionLevel(mediaKeySystem, &contentProtectionLevel);
3709 EXPECT_NE(errNo, DRM_ERR_OK);
3710 }
3711
3712 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_SetCallbackWithObject_084, TestSize.Level0)
3713 {
3714 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3715 MediaKeySystem *mediaKeySystem = nullptr;
3716 MediaKeySession *mediaKeySession = nullptr;
3717 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3718 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3719 EXPECT_NE(mediaKeySystem, nullptr);
3720 errNo = OH_MediaKeySystem_SetMediaKeySystemCallback(mediaKeySystem, &TestSystemEventCallBack);
3721 EXPECT_EQ(errNo, DRM_ERR_OK);
3722 errNo = OH_MediaKeySystem_SetCallback(mediaKeySystem, &TestSystemEventCallBackWithObj);
3723 EXPECT_EQ(errNo, DRM_ERR_OK);
3724 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3725 EXPECT_NE(mediaKeySession, nullptr);
3726 EXPECT_EQ(errNo, DRM_ERR_OK);
3727 MediaKeySession_Callback callback = { &TestSessoinEventCallBack, &TestSessoinKeyChangeCallBack };
3728 errNo = OH_MediaKeySession_SetMediaKeySessionCallback(mediaKeySession, &callback);
3729 EXPECT_EQ(errNo, DRM_ERR_OK);
3730 OH_MediaKeySession_Callback sessionCallback = { &TestSessoinEventCallBackWithObj,
3731 &TestSessoinKeyChangeCallBackWithObj };
3732 errNo = OH_MediaKeySession_SetCallback(mediaKeySession, &sessionCallback);
3733 EXPECT_EQ(errNo, DRM_ERR_OK);
3734 DRM_MediaKeyRequest mediaKeyRequest;
3735 DRM_MediaKeyRequestInfo info;
3736 filldata(&info);
3737 errNo = OH_MediaKeySession_GenerateMediaKeyRequest(mediaKeySession, &info, &mediaKeyRequest);
3738 EXPECT_EQ(errNo, DRM_ERR_OK);
3739 unsigned char onlineMediaKeyId[64] = { 0 }; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3740 unsigned char testKeySessionResponse[2] = {0x07, 0x22};
3741 int32_t onlineMediaKeyIdLen = 64; // 64:OFFLINE_MEDIA_KEY_ID_LEN
3742 errNo = OH_MediaKeySession_ProcessMediaKeyResponse(mediaKeySession, testKeySessionResponse,
3743 (int32_t)(sizeof(testKeySessionResponse)), onlineMediaKeyId, &onlineMediaKeyIdLen);
3744 EXPECT_NE(errNo, DRM_ERR_OK);
3745 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3746 EXPECT_EQ(errNo, DRM_ERR_OK);
3747 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3748 mediaKeySystem = nullptr;
3749 EXPECT_EQ(errNo, DRM_ERR_OK);
3750 }
3751
3752 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_KillClearPlayHostAbNormal1, TestSize.Level0)
3753 {
3754 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3755 MediaKeySystem *mediaKeySystem = nullptr;
3756 MediaKeySession *mediaKeySession = nullptr;
3757 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3758 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3759 EXPECT_NE(mediaKeySystem, nullptr);
3760 EXPECT_EQ(errNo, DRM_ERR_OK);
3761 unsigned char request[12288] = { 0 }; // 12288:request len
3762 int32_t requestLen = 12288; // 12288:request len
3763 char defaultUrl[2048] = { 0 }; // 2048:url len
3764 int32_t defaultUrlLen = 2048; // 2048:url len
3765 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl,
3766 defaultUrlLen);
3767 unsigned char KeySystemResponse[12288] = OFFRESPONSE;
3768 int32_t KeySystemResponseLen = 12288;
3769 if (g_isWisePlay) {
3770 int rett = HttpPost(PROVISION_URL, request, requestLen, KeySystemResponse, &KeySystemResponseLen, 10);
3771 EXPECT_EQ(rett, 0);
3772 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen);
3773 EXPECT_NE(errNo, DRM_ERR_OK);
3774 } else {
3775 KeySystemResponseLen = 50;
3776 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen);
3777 EXPECT_EQ(errNo, DRM_ERR_OK);
3778 }
3779 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3780 EXPECT_NE(mediaKeySession, nullptr);
3781 EXPECT_EQ(errNo, DRM_ERR_OK);
3782 killclearplay(mediaKeySystem, mediaKeySession);
3783 sleep(5);
3784 killclearplay2(mediaKeySystem, mediaKeySession);
3785 requestLen = 12288; // 12288:request len
3786 errNo = OH_MediaKeySystem_GenerateKeySystemRequest(mediaKeySystem, request, &requestLen, defaultUrl,
3787 defaultUrlLen);
3788 EXPECT_NE(errNo, DRM_ERR_OK);
3789 errNo = OH_MediaKeySystem_ProcessKeySystemResponse(mediaKeySystem, KeySystemResponse, KeySystemResponseLen);
3790 EXPECT_NE(errNo, DRM_ERR_OK);
3791 DRM_CertificateStatus certStatus = CERT_STATUS_INVALID;
3792 errNo = OH_MediaKeySystem_GetCertificateStatus(mediaKeySystem, &certStatus);
3793 EXPECT_NE(errNo, DRM_ERR_OK);
3794 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3795 EXPECT_NE(errNo, DRM_ERR_OK);
3796 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3797 EXPECT_EQ(errNo, DRM_ERR_OK);
3798 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3799 mediaKeySystem = nullptr;
3800 EXPECT_EQ(errNo, DRM_ERR_OK);
3801 sleep(5);
3802 }
3803
3804 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_Dump_01, TestSize.Level0)
3805 {
3806 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3807 MediaKeySystem *mediaKeySystem = nullptr;
3808 MediaKeySession *mediaKeySession = nullptr;
3809 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3810 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3811 EXPECT_NE(mediaKeySystem, nullptr);
3812 EXPECT_EQ(errNo, DRM_ERR_OK);
3813 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3814 EXPECT_NE(mediaKeySession, nullptr);
3815 EXPECT_EQ(errNo, DRM_ERR_OK);
3816
3817 if (mediaKeySession) {
3818 MediaKeySessionObject *sessionObject = reinterpret_cast<MediaKeySessionObject *>(mediaKeySession);
3819 sptr<IMediaKeySessionService> SessionServiceProxy =
3820 sessionObject->sessionImpl_->GetMediaKeySessionServiceProxy();
3821 sptr<IMediaDecryptModuleService> decryptModule;
3822 SessionServiceProxy->GetMediaDecryptModule(decryptModule);
3823 MessageParcel data;
3824 IMediaDecryptModuleService::DrmBuffer srcBuffer;
3825 IMediaDecryptModuleService::DrmBuffer dstBuffer;
3826 bool secureDecodrtState = false;
3827 IMediaDecryptModuleService::CryptInfo cryptInfo;
3828 decryptModule->DecryptMediaData(secureDecodrtState, cryptInfo, srcBuffer, dstBuffer);
3829 system("hidumper -s 3012");
3830 decryptModule->Release();
3831 }
3832
3833 EXPECT_EQ(errNo, DRM_ERR_OK);
3834 errNo = OH_MediaKeySession_Destroy(mediaKeySession);
3835 EXPECT_EQ(errNo, DRM_ERR_OK);
3836 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3837 EXPECT_EQ(errNo, DRM_ERR_OK);
3838 }
3839
3840 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySystem_MAX_01, TestSize.Level0)
3841 {
3842 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3843 const uint32_t maxNum = 64;
3844 std::vector<MediaKeySystem *> systems(maxNum, nullptr);
3845 const char *name = GetUuid();
3846 for (uint i = 0; i < maxNum; i++) {
3847 errNo = OH_MediaKeySystem_Create(name, &systems[i]);
3848 EXPECT_EQ(errNo, DRM_ERR_OK);
3849 EXPECT_NE(systems[i], nullptr);
3850 }
3851
3852 MediaKeySystem *mediaKeySystem = nullptr;
3853 errNo = OH_MediaKeySystem_Create(name, &mediaKeySystem);
3854 EXPECT_EQ(errNo, DRM_ERR_MAX_SYSTEM_NUM_REACHED);
3855 EXPECT_EQ(mediaKeySystem, nullptr);
3856
3857 for (uint i = 0; i < maxNum; i++) {
3858 errNo = OH_MediaKeySystem_Destroy(systems[i]);
3859 systems[i] = nullptr;
3860 EXPECT_EQ(errNo, DRM_ERR_OK);
3861 }
3862 }
3863
3864 HWTEST_F(DrmFrameworkUnitTest, Drm_unittest_CreateMediaKeySession_MAX_01, TestSize.Level0)
3865 {
3866 Drm_ErrCode errNo = DRM_ERR_UNKNOWN;
3867 const uint32_t maxNum = 64;
3868 std::vector<MediaKeySession *> sessions(maxNum, nullptr);
3869
3870 MediaKeySystem *mediaKeySystem = nullptr;
3871 errNo = OH_MediaKeySystem_Create(GetUuid(), &mediaKeySystem);
3872 EXPECT_NE(mediaKeySystem, nullptr);
3873 EXPECT_EQ(errNo, DRM_ERR_OK);
3874
3875 DRM_ContentProtectionLevel contentProtectionLevel = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
3876 for (uint i = 0; i < maxNum; i++) {
3877 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &sessions[i]);
3878 EXPECT_EQ(errNo, DRM_ERR_OK);
3879 EXPECT_NE(sessions[i], nullptr);
3880 }
3881
3882 MediaKeySession *mediaKeySession = nullptr;
3883 errNo = OH_MediaKeySystem_CreateMediaKeySession(mediaKeySystem, &contentProtectionLevel, &mediaKeySession);
3884 EXPECT_EQ(errNo, DRM_ERR_MAX_SESSION_NUM_REACHED);
3885 EXPECT_EQ(mediaKeySession, nullptr);
3886
3887 for (uint i = 0; i < maxNum; i++) {
3888 errNo = OH_MediaKeySession_Destroy(sessions[i]);
3889 sessions[i] = nullptr;
3890 EXPECT_EQ(errNo, DRM_ERR_OK);
3891 }
3892
3893 errNo = OH_MediaKeySystem_Destroy(mediaKeySystem);
3894 EXPECT_EQ(errNo, DRM_ERR_OK);
3895 }
3896
3897 } // DrmStandard
3898 } // OHOS