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