1 /*
2 * Copyright (c) 2025 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
16 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "native_mediakeysession.h"
20 #include "native_mediakeysystem.h"
21 #define private public
22 #include "drm_adapter.h"
23 #include "drm_adapter_impl.h"
24
25 using namespace testing;
26 using namespace testing::ext;
27 using ::testing::NiceMock;
28
29 namespace OHOS::NWeb {
30 namespace {
31 std::shared_ptr<SessionInfo> g_sessioninfo;
32 std::shared_ptr<DrmCallbackImpl> g_callback;
33 std::shared_ptr<DrmAdapterImpl> g_adapter;
34 bool g_isWisePlay = false;
35 bool g_isSupportDrm = true;
36 } // namespace
37
GetKeySystemName()38 static const std::string GetKeySystemName()
39 {
40 if (OH_MediaKeySystem_IsSupported("com.clearplay.drm")) {
41 g_isSupportDrm = true;
42 return "com.clearplay.drm";
43 } else if (OH_MediaKeySystem_IsSupported("com.wiseplay.drm")) {
44 g_isWisePlay = true;
45 g_isSupportDrm = true;
46 return "com.wiseplay.drm";
47 } else {
48 g_isSupportDrm = false;
49 return "ERROR";
50 }
51 }
52
53 class DrmCallbackAdapterMock : public DrmCallbackAdapter {
54 public:
55 MOCK_METHOD(void, OnSessionMessage, (const std::string&, int32_t&, const std::vector<uint8_t>&), (override));
56 MOCK_METHOD(void, OnProvisionRequest, (const std::string&, const std::string&), (override));
57 MOCK_METHOD(void, OnProvisioningComplete, (bool), (override));
58 MOCK_METHOD(void, OnMediaKeySessionReady, (void*), (override));
59 MOCK_METHOD(void, OnPromiseRejected, (uint32_t, const std::string&), (override));
60 MOCK_METHOD(void, OnPromiseResolved, (uint32_t), (override));
61 MOCK_METHOD(void, OnPromiseResolvedWithSession, (uint32_t, const std::string&), (override));
62 MOCK_METHOD(void, OnStorageProvisioned, (), (override));
63 MOCK_METHOD(void, OnStorageSaveInfo, (const std::vector<uint8_t>&, const std::string&, const std::string&, int32_t),
64 (override));
65 MOCK_METHOD(void, OnSessionClosed, (const std::string&), (override));
66 MOCK_METHOD(void, OnStorageLoadInfo, (const std::string&), (override));
67 MOCK_METHOD(void, OnSessionKeysChange,
68 (const std::string&, const std::vector<std::string>&, const std::vector<uint32_t>&, bool, bool), (override));
69 MOCK_METHOD(void, OnSessionExpirationUpdate, (const std::string&, uint64_t), (override));
70 MOCK_METHOD(void, OnStorageClearInfoForKeyRelease, (const std::string&), (override));
71 MOCK_METHOD(void, OnStorageClearInfoForLoadFail, (const std::string&), (override));
72 MOCK_METHOD(void, OnMediaLicenseReady, (bool), (override));
73 };
74
75 class SessionIdTest : public testing::Test {
76 public:
77 static void SetUpTestCase(void);
78 static void TearDownTestCase(void);
79 void SetUp();
80 void TearDown();
81 };
82
83 class SessionInfoTest : public testing::Test {
84 public:
85 static void SetUpTestCase(void);
86 static void TearDownTestCase(void);
87 void SetUp();
88 void TearDown();
89 };
90
91 class DrmCallbackImplTest : public testing::Test {
92 public:
93 static void SetUpTestCase(void);
94 static void TearDownTestCase(void);
95 void SetUp();
96 void TearDown();
97
98 protected:
99 std::shared_ptr<DrmCallbackAdapterMock> mockCallback_;
100 };
101
102 class DrmAdapterImplTest : public testing::Test {
103 public:
104 static void SetUpTestCase(void);
105 static void TearDownTestCase(void);
106 void SetUp();
107 void TearDown();
108
109 protected:
110 std::shared_ptr<DrmCallbackAdapterMock> mockCallback_;
111 };
112
SetUpTestCase(void)113 void SessionIdTest::SetUpTestCase(void) {}
114
TearDownTestCase(void)115 void SessionIdTest::TearDownTestCase(void) {}
116
SetUp(void)117 void SessionIdTest::SetUp(void) {}
118
TearDown(void)119 void SessionIdTest::TearDown(void) {}
120
121 /**
122 * @tc.name: SessionIdTest_SessionId_001.
123 * @tc.desc: test of SessionId :: CreateSessionId
124 * @tc.type: FUNC.
125 * @tc.require:
126 */
127 HWTEST_F(SessionIdTest, SessionIdTest_SessionId_001, TestSize.Level1)
128 {
129 auto sessionId = SessionId::CreateSessionId("testSessionId");
130 EXPECT_EQ(sessionId->EmeId(), "testSessionId");
131 EXPECT_EQ(sessionId->KeySetIdLen(), 0);
132 }
133
134 /**
135 * @tc.name: SessionIdTest_SessionId_002.
136 * @tc.desc: test of SessionId :: CreateSessionId
137 * @tc.type: FUNC.
138 * @tc.require:
139 */
140 HWTEST_F(SessionIdTest, SessionIdTest_SessionId_002, TestSize.Level1)
141 {
142 auto sessionId = SessionId::CreateSessionId("tempSessionId02");
143 EXPECT_NE(sessionId->EmeId(), "tempSessionId");
144 EXPECT_EQ(sessionId->KeySetIdLen(), 0);
145 }
146
147 /**
148 * @tc.name: SessionIdTest_SessionId_003.
149 * @tc.desc: test of SessionId :: emeId & keySetId & keySetIdLen
150 * @tc.type: FUNC.
151 * @tc.require:
152 */
153 HWTEST_F(SessionIdTest, SessionIdTest_SessionId_003, TestSize.Level1)
154 {
155 unsigned char keySetId[] = { 1, 2, 3, 4, 5 };
156 SessionId sessionId("emeIdTest", keySetId, 5);
157
158 EXPECT_EQ(sessionId.EmeId(), "emeIdTest");
159 EXPECT_EQ(sessionId.KeySetIdLen(), 5);
160 EXPECT_EQ(memcmp(sessionId.KeySetId(), keySetId, 5), 0);
161 }
162
163 /**
164 * @tc.name: SessionIdTest_SessionId_004.
165 * @tc.desc: test of SessionId :: SetKeySetId
166 * @tc.type: FUNC.
167 * @tc.require:
168 */
169 HWTEST_F(SessionIdTest, SessionIdTest_SessionId_004, TestSize.Level1)
170 {
171 unsigned char keySetId[] = { 10, 20, 30 };
172 unsigned char newKeySetId[] = { 40, 50, 60 };
173 SessionId sessionId("emeIdTest", keySetId, 3);
174
175 sessionId.SetKeySetId(newKeySetId, 3);
176 EXPECT_EQ(memcmp(sessionId.KeySetId(), newKeySetId, 3), 0);
177 }
178
SetUpTestCase(void)179 void SessionInfoTest::SetUpTestCase(void) {}
180
TearDownTestCase(void)181 void SessionInfoTest::TearDownTestCase(void) {}
182
SetUp(void)183 void SessionInfoTest::SetUp(void)
184 {
185 unsigned char keySetId[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
186 auto sessionId = SessionId::CreateSessionId("session123");
187 sessionId->SetKeySetId(keySetId, sizeof(keySetId));
188 g_sessioninfo = std::make_shared<SessionInfo>(
189 sessionId, "video/mp4", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
190 }
191
TearDown(void)192 void SessionInfoTest::TearDown(void)
193 {
194 g_sessioninfo = nullptr;
195 }
196
197 /**
198 * @tc.name: SessionInfoTest_SessionInfo_001.
199 * @tc.desc: test of SessionInfo :: mimeType
200 * @tc.type: FUNC.
201 * @tc.require:
202 */
203 HWTEST_F(SessionInfoTest, SessionInfoTest_SessionInfo_001, TestSize.Level1)
204 {
205 EXPECT_EQ(g_sessioninfo->MimeType(), "video/mp4");
206 EXPECT_EQ(g_sessioninfo->KeyType(), static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
207 }
208
209 /**
210 * @tc.name: SessionInfoTest_SessionInfo_002.
211 * @tc.desc: test of SessionInfo :: SetKeyType & keyType
212 * @tc.type: FUNC.
213 * @tc.require:
214 */
215 HWTEST_F(SessionInfoTest, SessionInfoTest_SessionInfo_002, TestSize.Level1)
216 {
217 g_sessioninfo->SetKeyType(MEDIA_KEY_TYPE_ONLINE);
218 EXPECT_EQ(g_sessioninfo->KeyType(), MEDIA_KEY_TYPE_ONLINE);
219 }
220
221 /**
222 * @tc.name: SessionInfoTest_SessionInfo_003.
223 * @tc.desc: test of SessionInfo :: sessionId
224 * @tc.type: FUNC.
225 * @tc.require:
226 */
227 HWTEST_F(SessionInfoTest, SessionInfoTest_SessionInfo_003, TestSize.Level1)
228 {
229 auto sessionId = g_sessioninfo->GetSessionId();
230 EXPECT_EQ(sessionId->EmeId(), "session123");
231 }
232
SetUpTestCase(void)233 void DrmCallbackImplTest::SetUpTestCase(void) {}
234
TearDownTestCase(void)235 void DrmCallbackImplTest::TearDownTestCase(void) {}
236
SetUp(void)237 void DrmCallbackImplTest::SetUp(void)
238 {
239 mockCallback_ = std::make_shared<DrmCallbackAdapterMock>();
240 g_callback = std::make_shared<DrmCallbackImpl>(mockCallback_);
241 }
242
TearDown(void)243 void DrmCallbackImplTest::TearDown(void)
244 {
245 g_callback = nullptr;
246 }
247
248 /**
249 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_002.
250 * @tc.desc: test of DrmCallbackImpl :: OnSessionMessage
251 * @tc.type: FUNC.
252 * @tc.require:
253 */
254 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_002, TestSize.Level1)
255 {
256 std::string sessionId = "sessionId";
257 int32_t type = 1;
258 std::vector<uint8_t> message = { 0x01, 0x02 };
259
260 EXPECT_CALL(*mockCallback_, OnSessionMessage(sessionId, type, message)).Times(1);
261 g_callback->OnSessionMessage(sessionId, type, message);
262 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
263 g_callback->callbackAdapter_ = nullptr;
264 g_callback->OnSessionMessage(sessionId, type, message);
265 }
266
267 /**
268 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_003.
269 * @tc.desc: test of DrmCallbackImpl :: OnProvisionRequest
270 * @tc.type: FUNC.
271 * @tc.require:
272 */
273 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_003, TestSize.Level1)
274 {
275 std::string defaultUrl = "http://example.com";
276 std::string requestData = "requestData";
277
278 EXPECT_CALL(*mockCallback_, OnProvisionRequest(defaultUrl, requestData)).Times(1);
279 g_callback->OnProvisionRequest(defaultUrl, requestData);
280 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
281 g_callback->callbackAdapter_ = nullptr;
282 g_callback->OnProvisionRequest(defaultUrl, requestData);
283 }
284
285 /**
286 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_004.
287 * @tc.desc: test of DrmCallbackImpl :: OnProvisioningComplete
288 * @tc.type: FUNC.
289 * @tc.require:
290 */
291 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_004, TestSize.Level1)
292 {
293 bool success = true;
294
295 EXPECT_CALL(*mockCallback_, OnProvisioningComplete(success)).Times(1);
296 g_callback->OnProvisioningComplete(success);
297 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
298 g_callback->callbackAdapter_ = nullptr;
299 g_callback->OnProvisioningComplete(success);
300 }
301 /**
302 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_005.
303 * @tc.desc: test of DrmCallbackImpl :: OnMediaKeySessionReady
304 * @tc.type: FUNC.
305 * @tc.require:
306 */
307 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_005, TestSize.Level1)
308 {
309 void* session = reinterpret_cast<void*>(0x1234);
310
311 EXPECT_CALL(*mockCallback_, OnMediaKeySessionReady(session)).Times(1);
312 g_callback->OnMediaKeySessionReady(session);
313 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
314 g_callback->callbackAdapter_ = nullptr;
315 g_callback->OnMediaKeySessionReady(session);
316 }
317
318 /**
319 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_006.
320 * @tc.desc: test of DrmCallbackImpl :: OnPromiseRejected
321 * @tc.type: FUNC.
322 * @tc.require:
323 */
324 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_006, TestSize.Level1)
325 {
326 uint32_t promiseId = 1;
327 std::string errorMessage = "error";
328
329 EXPECT_CALL(*mockCallback_, OnPromiseRejected(promiseId, errorMessage)).Times(1);
330 g_callback->OnPromiseRejected(promiseId, errorMessage);
331 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
332 g_callback->callbackAdapter_ = nullptr;
333 g_callback->OnPromiseRejected(promiseId, errorMessage);
334 }
335
336 /**
337 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_007.
338 * @tc.desc: test of DrmCallbackImpl :: OnPromiseResolved
339 * @tc.type: FUNC.
340 * @tc.require:
341 */
342 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_007, TestSize.Level1)
343 {
344 uint32_t promiseId = 1;
345
346 EXPECT_CALL(*mockCallback_, OnPromiseResolved(promiseId)).Times(1);
347 g_callback->OnPromiseResolved(promiseId);
348 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
349 g_callback->callbackAdapter_ = nullptr;
350 g_callback->OnPromiseResolved(promiseId);
351 }
352
353 /**
354 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_008.
355 * @tc.desc: test of DrmCallbackImpl :: OnPromiseResolvedWithSession
356 * @tc.type: FUNC.
357 * @tc.require:
358 */
359 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_008, TestSize.Level1)
360 {
361 uint32_t promiseId = 1;
362 std::string sessionId = "sessionId";
363
364 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(promiseId, sessionId)).Times(1);
365 g_callback->OnPromiseResolvedWithSession(promiseId, sessionId);
366 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
367 g_callback->callbackAdapter_ = nullptr;
368 g_callback->OnPromiseResolvedWithSession(promiseId, sessionId);
369 }
370
371 /**
372 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_009.
373 * @tc.desc: test of DrmCallbackImpl :: OnSessionClosed
374 * @tc.type: FUNC.
375 * @tc.require:
376 */
377 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_009, TestSize.Level1)
378 {
379 std::string testSessionId = "sessionId";
380
381 EXPECT_CALL(*mockCallback_, OnSessionClosed(testSessionId)).Times(1);
382 g_callback->OnSessionClosed(testSessionId);
383 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
384 g_callback->callbackAdapter_ = nullptr;
385 g_callback->OnSessionClosed(testSessionId);
386 }
387
388 /**
389 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_010.
390 * @tc.desc: test of DrmCallbackImpl :: OnSessionKeysChange
391 * @tc.type: FUNC.
392 * @tc.require:
393 */
394 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_010, TestSize.Level1)
395 {
396 std::string testSessionId = "sessionId";
397 std::vector<std::string> dummyKeyId;
398 std::vector<uint32_t> dummyStatus;
399 dummyKeyId.push_back("");
400 dummyStatus.push_back(static_cast<uint32_t>(KeyStatus::KEY_STATUS_INTERNAL_ERROR));
401 bool hasAdditionalUsableKey = false;
402 bool isKeyRelease = true;
403
404 EXPECT_CALL(*mockCallback_,
405 OnSessionKeysChange(testSessionId, dummyKeyId, dummyStatus, hasAdditionalUsableKey, isKeyRelease))
406 .Times(1);
407 g_callback->OnSessionKeysChange(testSessionId, dummyKeyId, dummyStatus, hasAdditionalUsableKey, isKeyRelease);
408 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
409 g_callback->callbackAdapter_ = nullptr;
410 g_callback->OnSessionKeysChange(testSessionId, dummyKeyId, dummyStatus, hasAdditionalUsableKey, isKeyRelease);
411 }
412
413 /**
414 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_011.
415 * @tc.desc: test of DrmCallbackImpl :: OnSessionExpirationUpdate
416 * @tc.type: FUNC.
417 * @tc.require:
418 */
419 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_011, TestSize.Level1)
420 {
421 std::string testSessionId = "sessionId";
422 uint64_t expirationTime = 1234567890;
423 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(testSessionId, expirationTime)).Times(1);
424 g_callback->OnSessionExpirationUpdate(testSessionId, expirationTime);
425 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
426 g_callback->callbackAdapter_ = nullptr;
427 g_callback->OnSessionExpirationUpdate(testSessionId, expirationTime);
428 }
429
430 /**
431 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_012.
432 * @tc.desc: test of DrmCallbackImpl :: OnStorageProvisioned
433 * @tc.type: FUNC.
434 * @tc.require:
435 */
436 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_012, TestSize.Level1)
437 {
438 EXPECT_CALL(*mockCallback_, OnStorageProvisioned()).Times(1);
439 g_callback->OnStorageProvisioned();
440 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
441 g_callback->callbackAdapter_ = nullptr;
442 g_callback->OnStorageProvisioned();
443 }
444
445 /**
446 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_013.
447 * @tc.desc: test of DrmCallbackImpl :: OnStorageSaveInfo
448 * @tc.type: FUNC.
449 * @tc.require:
450 */
451 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_013, TestSize.Level1)
452 {
453 std::vector<uint8_t> ketSetId = { 0x01, 0x02 };
454 std::string mimeType = "video/mp4";
455 std::string sessionId = "sessionId";
456 int32_t keyType = 1;
457
458 EXPECT_CALL(*mockCallback_, OnStorageSaveInfo(ketSetId, mimeType, sessionId, keyType)).Times(1);
459 g_callback->OnStorageSaveInfo(ketSetId, mimeType, sessionId, keyType);
460 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
461 g_callback->callbackAdapter_ = nullptr;
462 g_callback->OnStorageSaveInfo(ketSetId, mimeType, sessionId, keyType);
463 }
464
465 /**
466 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_014.
467 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
468 * @tc.type: FUNC.
469 * @tc.require:
470 */
471 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_014, TestSize.Level1)
472 {
473 std::string sessionId = "sessionId";
474
475 EXPECT_CALL(*mockCallback_, OnStorageLoadInfo(sessionId)).Times(1);
476 g_callback->OnStorageLoadInfo(sessionId);
477 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
478 g_callback->callbackAdapter_ = nullptr;
479 g_callback->OnStorageLoadInfo(sessionId);
480 }
481
482 /**
483 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_015.
484 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
485 * @tc.type: FUNC.
486 * @tc.require:
487 */
488 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_015, TestSize.Level1)
489 {
490 std::string sessionId = "sessionId";
491
492 EXPECT_CALL(*mockCallback_, OnStorageClearInfoForKeyRelease(sessionId)).Times(1);
493 g_callback->OnStorageClearInfoForKeyRelease(sessionId);
494 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
495 g_callback->callbackAdapter_ = nullptr;
496 g_callback->OnStorageClearInfoForKeyRelease(sessionId);
497 }
498
499 /**
500 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_016.
501 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
502 * @tc.type: FUNC.
503 * @tc.require:
504 */
505 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_016, TestSize.Level1)
506 {
507 std::string sessionId = "sessionId";
508
509 EXPECT_CALL(*mockCallback_, OnStorageClearInfoForLoadFail(sessionId)).Times(1);
510 g_callback->OnStorageClearInfoForLoadFail(sessionId);
511 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
512 g_callback->callbackAdapter_ = nullptr;
513 g_callback->OnStorageClearInfoForLoadFail(sessionId);
514 }
515
516 /**
517 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_017.
518 * @tc.desc: test of DrmCallbackImpl::GetMediaKeySessionInfo
519 * @tc.type: FUNC.
520 * @tc.require:
521 */
522 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_017, TestSize.Level1)
523 {
524 auto sessionInfo = g_callback->GetMediaKeySessionInfo(nullptr);
525 EXPECT_EQ(sessionInfo, nullptr);
526 }
527
528 /**
529 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_019.
530 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
531 * @tc.type: FUNC.
532 * @tc.require:
533 */
534 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_019, TestSize.Level1)
535 {
536 EXPECT_CALL(*mockCallback_, OnMediaLicenseReady(true)).Times(1);
537 g_callback->OnMediaLicenseReady(true);
538 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
539 g_callback->callbackAdapter_ = nullptr;
540 g_callback->OnMediaLicenseReady(true);
541 }
542
SetUpTestCase(void)543 void DrmAdapterImplTest::SetUpTestCase(void) {}
544
TearDownTestCase(void)545 void DrmAdapterImplTest::TearDownTestCase(void) {}
546
SetUp(void)547 void DrmAdapterImplTest::SetUp(void)
548 {
549 g_adapter = std::make_shared<DrmAdapterImpl>();
550 mockCallback_ = std::make_shared<NiceMock<DrmCallbackAdapterMock>>();
551 }
552
TearDown(void)553 void DrmAdapterImplTest::TearDown(void)
554 {
555 g_adapter = nullptr;
556 }
557
558 /**
559 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_001.
560 * @tc.desc: test of DrmAdapterImpl :: IsSupported
561 * @tc.type: FUNC.
562 * @tc.require:
563 */
564 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_001, TestSize.Level1)
565 {
566 EXPECT_FALSE(g_adapter->IsSupported(""));
567 GetKeySystemName();
568 if (g_isSupportDrm) {
569 EXPECT_TRUE(g_adapter->IsSupported(GetKeySystemName()));
570 } else {
571 EXPECT_FALSE(g_adapter->IsSupported(GetKeySystemName()));
572 }
573 }
574
575 /**
576 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_002.
577 * @tc.desc: test of DrmAdapterImpl :: IsSupported2
578 * @tc.type: FUNC.
579 * @tc.require:
580 */
581 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_002, TestSize.Level1)
582 {
583 EXPECT_FALSE(g_adapter->IsSupported2("", ""));
584 EXPECT_FALSE(g_adapter->IsSupported2("example", ""));
585
586 bool isSupported = g_adapter->IsSupported2(GetKeySystemName(), "video/mp4");
587 if (g_isSupportDrm) {
588 EXPECT_EQ(isSupported, true);
589 } else {
590 EXPECT_EQ(isSupported, false);
591 }
592 }
593
594 /**
595 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_003.
596 * @tc.desc: test of DrmAdapterImpl :: IsSupported3
597 * @tc.type: FUNC.
598 * @tc.require:
599 */
600 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_003, TestSize.Level1)
601 {
602 EXPECT_FALSE(g_adapter->IsSupported3("", "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
603 EXPECT_FALSE(g_adapter->IsSupported3("example", "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
604 EXPECT_FALSE(g_adapter->IsSupported3("example", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
605 bool isSupported = g_adapter->IsSupported3(GetKeySystemName(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
606 if (g_isSupportDrm) {
607 EXPECT_EQ(isSupported, true);
608 } else {
609 EXPECT_EQ(isSupported, false);
610 }
611 }
612
613 /**
614 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_004.
615 * @tc.desc: test of DrmAdapterImpl :: CreateKeySystem
616 * @tc.type: FUNC.
617 * @tc.require:
618 */
619 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_004, TestSize.Level1)
620 {
621 g_adapter->RegistDrmCallback(mockCallback_);
622
623 auto result = g_adapter->CreateKeySystem("", "", SECURITY_LEVEL_3);
624 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
625
626 result = g_adapter->CreateKeySystem("com.test.drm", "", SECURITY_LEVEL_3);
627 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
628
629 result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
630 if (g_isSupportDrm) {
631 int32_t certStatus = -1;
632 g_adapter->GetCertificateStatus(certStatus);
633 if (certStatus == 0) {
634 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
635 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
636 g_adapter->ReleaseMediaKeySession();
637 g_adapter->ReleaseMediaKeySystem();
638
639 result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_1);
640 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
641 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
642 g_adapter->ReleaseMediaKeySession();
643 g_adapter->ReleaseMediaKeySystem();
644 } else {
645 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
646 }
647
648 EXPECT_EQ(g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_UNKNOWN),
649 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
650 g_adapter->ReleaseMediaKeySession();
651 g_adapter->ReleaseMediaKeySystem();
652
653 EXPECT_EQ(g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", -1),
654 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
655 g_adapter->ReleaseMediaKeySession();
656 g_adapter->ReleaseMediaKeySystem();
657 } else {
658 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
659 }
660 }
661
662 /**
663 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_005.
664 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySystem
665 * @tc.type: FUNC.
666 * @tc.require:
667 */
668 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_005, TestSize.Level1)
669 {
670 g_adapter->RegistDrmCallback(mockCallback_);
671 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
672 if (g_isSupportDrm) {
673 g_adapter->ReleaseMediaKeySession();
674 int32_t result = g_adapter->ReleaseMediaKeySystem();
675 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
676
677 result = g_adapter->ReleaseMediaKeySystem();
678 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
679 } else {
680 int32_t result = g_adapter->ReleaseMediaKeySystem();
681 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
682 }
683 }
684
685 /**
686 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_006.
687 * @tc.desc: test of DrmAdapterImpl :: CreateMediaKeySession
688 * @tc.type: FUNC.
689 * @tc.require:
690 */
691 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_006, TestSize.Level1)
692 {
693 g_adapter->RegistDrmCallback(mockCallback_);
694 EXPECT_EQ(g_adapter->CreateMediaKeySession(), -1);
695
696 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
697 if (g_isSupportDrm) {
698 int32_t certStatus = -1;
699 g_adapter->GetCertificateStatus(certStatus);
700 if (certStatus == 0) {
701 EXPECT_EQ(g_adapter->CreateMediaKeySession(), 0);
702 g_adapter->ReleaseMediaKeySession();
703
704 EXPECT_EQ(g_adapter->CreateMediaKeySession("emeId_006"), 0);
705 g_adapter->ReleaseMediaKeySession(g_adapter->GetMediaKeySession("emeId_006"));
706
707 g_adapter->keySystemType_ = KeySystemType::WIDEVINE;
708 EXPECT_EQ(g_adapter->GetMediaKeySession(""), nullptr);
709
710 EXPECT_EQ(g_adapter->CreateMediaKeySession("emeId_006"), 0);
711 g_adapter->ReleaseMediaKeySession(g_adapter->GetMediaKeySession("emeId_006"));
712 } else {
713 EXPECT_NE(g_adapter->CreateMediaKeySession(), 0);
714 }
715 } else {
716 EXPECT_NE(g_adapter->CreateMediaKeySession(), 0);
717 }
718 }
719
720 /**
721 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_007.
722 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySession
723 * @tc.type: FUNC.
724 * @tc.require:
725 */
726 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_007, TestSize.Level1)
727 {
728 int32_t result = g_adapter->ReleaseMediaKeySession();
729 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
730 g_adapter->RegistDrmCallback(mockCallback_);
731 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
732 if (g_isSupportDrm) {
733 int32_t certStatus = -1;
734 g_adapter->GetCertificateStatus(certStatus);
735 result = g_adapter->ReleaseMediaKeySession();
736 if (certStatus == 0) {
737 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
738 } else {
739 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
740 }
741 g_adapter->ReleaseMediaKeySystem();
742
743 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
744 result = g_adapter->ReleaseMediaKeySession(nullptr);
745 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
746 result = g_adapter->ReleaseMediaKeySession(g_adapter->drmKeySession_);
747 if (certStatus == 0) {
748 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
749 } else {
750 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
751 }
752 } else {
753 result = g_adapter->ReleaseMediaKeySession();
754 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
755 }
756 }
757
758 /**
759 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_008.
760 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySession
761 * @tc.type: FUNC.
762 * @tc.require:
763 */
764 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_008, TestSize.Level1)
765 {
766 g_adapter->callback_ = nullptr;
767 int32_t result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
768 int32_t certStatus = -1;
769 g_adapter->GetCertificateStatus(certStatus);
770 if (certStatus == 0) {
771 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
772 g_adapter->keySystemType_ = KeySystemType::WIDEVINE;
773 } else {
774 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
775 }
776 g_adapter->mediaKeySessionCallbackMap_.clear();
777 }
778
779 /**
780 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_009.
781 * @tc.desc: test of DrmAdapterImpl :: SetConfigurationString
782 * @tc.type: FUNC.
783 * @tc.require:
784 */
785 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_009, TestSize.Level1)
786 {
787 int32_t result = g_adapter->SetConfigurationString("", "");
788 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
789
790 result = g_adapter->SetConfigurationString("version", "");
791 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
792
793 result = g_adapter->SetConfigurationString("version", "2.0");
794 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
795 }
796
797 /**
798 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_010.
799 * @tc.desc: test of DrmAdapterImpl :: GetConfigurationString
800 * @tc.type: FUNC.
801 * @tc.require:
802 */
803 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_010, TestSize.Level1)
804 {
805 char value[256];
806 int32_t valueLen = sizeof(value);
807 int32_t result;
808
809 result = g_adapter->GetConfigurationString("", value, valueLen);
810 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
811
812 result = g_adapter->GetConfigurationString("version", nullptr, valueLen);
813 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
814
815 result = g_adapter->GetConfigurationString("version", value, valueLen);
816 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
817
818 if (g_isSupportDrm) {
819 g_adapter->RegistDrmCallback(mockCallback_);
820 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
821 g_adapter->SetConfigurationString("version", "2.0");
822
823 result = g_adapter->GetConfigurationString("testVersion", value, valueLen);
824 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
825
826 result = g_adapter->GetConfigurationString("version", value, valueLen);
827 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
828 g_adapter->ReleaseMediaKeySession();
829 g_adapter->ReleaseMediaKeySystem();
830 }
831 }
832
833 /**
834 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_011.
835 * @tc.desc: test of DrmAdapterImpl :: SetConfigurationByteArray
836 * @tc.type: FUNC.
837 * @tc.require:
838 */
839 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_011, TestSize.Level1)
840 {
841 uint8_t description[4] = { 0x00, 0x00, 0x00, 0x00 };
842 int32_t valueLen = sizeof(description);
843
844 EXPECT_EQ(g_adapter->SetConfigurationByteArray("", description, valueLen),
845 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
846 EXPECT_EQ(g_adapter->SetConfigurationByteArray("description", nullptr, valueLen),
847 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
848 EXPECT_EQ(g_adapter->SetConfigurationByteArray("description", description, valueLen),
849 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
850 }
851
852 /**
853 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_012.
854 * @tc.desc: test of DrmAdapterImpl :: GetConfigurationByteArray
855 * @tc.type: FUNC.
856 * @tc.require:
857 */
858 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_012, TestSize.Level1)
859 {
860 uint8_t description[4] = { 0x00, 0x00, 0x00, 0x00 };
861 int32_t descriptionValueLen = 32;
862
863 EXPECT_EQ(g_adapter->GetConfigurationByteArray("", description, &descriptionValueLen),
864 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
865 EXPECT_EQ(g_adapter->GetConfigurationByteArray("description", nullptr, &descriptionValueLen),
866 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
867 EXPECT_EQ(g_adapter->GetConfigurationByteArray("description", description, &descriptionValueLen),
868 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
869 EXPECT_EQ(g_adapter->GetConfigurationByteArray("description", description, nullptr),
870 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
871
872 if (g_isSupportDrm) {
873 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
874
875 unsigned char configByteArray[128];
876 int32_t byteArrayLen = 128;
877 g_adapter->SetConfigurationByteArray("deviceUniqueId", description, descriptionValueLen);
878 auto result = g_adapter->GetConfigurationByteArray("deviceUniqueId", configByteArray, &byteArrayLen);
879 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
880 result = g_adapter->GetConfigurationByteArray("testArrayConfig", configByteArray, &byteArrayLen);
881 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
882
883 g_adapter->ReleaseMediaKeySession();
884 g_adapter->ReleaseMediaKeySystem();
885 }
886 }
887
888 /**
889 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_013.
890 * @tc.desc: test of DrmAdapterImpl :: GetMaxContentProtectionLevel
891 * @tc.type: FUNC.
892 * @tc.require:
893 */
894 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_013, TestSize.Level1)
895 {
896 int32_t level = 0;
897
898 EXPECT_EQ(g_adapter->GetMaxContentProtectionLevel(level), static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
899 if (g_isSupportDrm) {
900 g_adapter->RegistDrmCallback(mockCallback_);
901 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
902 EXPECT_EQ(g_adapter->GetMaxContentProtectionLevel(level), static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
903 EXPECT_NE(level, CONTENT_PROTECTION_LEVEL_UNKNOWN);
904 g_adapter->ReleaseMediaKeySession();
905 g_adapter->ReleaseMediaKeySystem();
906 }
907 }
908
909 /**
910 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_014.
911 * @tc.desc: test of DrmAdapterImpl :: ProcessKeySystemResponse
912 * @tc.type: FUNC.
913 * @tc.require:
914 */
915 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_014, TestSize.Level1)
916 {
917 std::string KeySystemResponse = "response";
918 EXPECT_EQ(g_adapter->ProcessKeySystemResponse("", false), static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
919 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
920 EXPECT_EQ(g_adapter->ProcessKeySystemResponse(KeySystemResponse, false),
921 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
922
923 g_adapter->RegistDrmCallback(mockCallback_);
924 EXPECT_EQ(g_adapter->ProcessKeySystemResponse(KeySystemResponse, false),
925 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
926
927 g_adapter->ReleaseMediaKeySystem();
928 }
929
930 /**
931 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_015.
932 * @tc.desc: test of DrmAdapterImpl :: GenerateMediaKeyRequest
933 * @tc.type: FUNC.
934 * @tc.require:
935 */
936 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_015, TestSize.Level1)
937 {
938 std::string emeId = "invalidEmeId";
939 int32_t type = 1;
940 int32_t initDataLen = 128;
941 std::vector<uint8_t> initData;
942 initData.resize(128);
943 uint32_t optionsCount = 1;
944 int32_t result = g_adapter->GenerateMediaKeyRequest(emeId, type, initDataLen, initData, "video/avc", optionsCount);
945 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
946 g_adapter->RegistDrmCallback(mockCallback_);
947 result = g_adapter->GenerateMediaKeyRequest(emeId, type, initDataLen, initData, "video/avc", optionsCount);
948 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
949
950 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
951 result = g_adapter->GenerateMediaKeyRequest(emeId, type, initDataLen, initData,
952 "test_mime_type_long_xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
953 optionsCount);
954 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
955
956 g_adapter->ReleaseMediaKeySystem();
957 }
958
959 /**
960 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_017.
961 * @tc.desc: test of DrmAdapterImpl :: ClearMediaKeys
962 * @tc.type: FUNC.
963 * @tc.require:
964 */
965 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_017, TestSize.Level1)
966 {
967 EXPECT_EQ(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
968
969 if (g_isSupportDrm) {
970 g_adapter->RegistDrmCallback(mockCallback_);
971 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
972 int32_t certStatus = -1;
973 g_adapter->GetCertificateStatus(certStatus);
974 if (certStatus == 0) {
975 EXPECT_EQ(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
976 } else {
977 EXPECT_NE(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
978 }
979 g_adapter->ReleaseMediaKeySession();
980 g_adapter->ReleaseMediaKeySystem();
981 }
982 }
983
984 /**
985 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_019.
986 * @tc.desc: test of DrmAdapterImpl :: GetCertificateStatus
987 * @tc.type: FUNC.
988 * @tc.require:
989 */
990 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_019, TestSize.Level1)
991 {
992 int32_t certStatus;
993 int32_t result = g_adapter->GetCertificateStatus(certStatus);
994 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
995 if (g_isSupportDrm) {
996 g_adapter->RegistDrmCallback(mockCallback_);
997 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
998 result = g_adapter->GetCertificateStatus(certStatus);
999 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1000 g_adapter->ReleaseMediaKeySession();
1001 g_adapter->ReleaseMediaKeySystem();
1002 }
1003 }
1004
1005 /**
1006 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_020.
1007 * @tc.desc: test of DrmAdapterImpl :: PutSessionInfo & GetSessionInfo
1008 * @tc.type: FUNC.
1009 * @tc.require:
1010 */
1011 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_020, TestSize.Level1)
1012 {
1013 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1014 std::string mimeType = "video/mp4";
1015 int32_t sessionType = 1; // Assume valid session type
1016 auto sessionInfo = g_adapter->GetSessionInfo(nullptr);
1017 EXPECT_EQ(sessionInfo, nullptr);
1018 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1019 EXPECT_EQ(sessionInfo, nullptr);
1020 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1021
1022 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1023 ASSERT_NE(sessionInfo, nullptr);
1024 }
1025
1026 /**
1027 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_022.
1028 * @tc.desc: test of DrmAdapterImpl :: RegistDrmCallback
1029 * @tc.type: FUNC.
1030 * @tc.require:
1031 */
1032 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_022, TestSize.Level1)
1033 {
1034 int32_t result = g_adapter->RegistDrmCallback(mockCallback_);
1035 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1036
1037 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK)); // Check that the return value is as expected
1038 g_adapter->ReleaseMediaKeySession();
1039 g_adapter->ReleaseMediaKeySystem();
1040 }
1041
1042 /**
1043 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_023.
1044 * @tc.desc: test of DrmAdapterImpl :: GetSessionIdByEmeId
1045 * @tc.type: FUNC.
1046 * @tc.require:
1047 */
1048 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_023, TestSize.Level1)
1049 {
1050 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1051 std::string mimeType = "video/mp4";
1052 int32_t sessionType = 1;
1053
1054 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1055 auto sessionId = g_adapter->GetSessionIdByEmeId(validSessionId->EmeId());
1056
1057 EXPECT_NE(sessionId, nullptr);
1058 EXPECT_EQ(sessionId->EmeId(), validSessionId->EmeId());
1059
1060 sessionId = g_adapter->GetSessionIdByEmeId("invalid_eme_id");
1061 EXPECT_EQ(sessionId, nullptr);
1062
1063 g_adapter->emeSessionInfoMap_["nullptr_eme_id"] = nullptr;
1064 sessionId = g_adapter->GetSessionIdByEmeId("nullptr_eme_id");
1065 EXPECT_EQ(sessionId, nullptr);
1066 }
1067
1068 /**
1069 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_024.
1070 * @tc.desc: test of DrmAdapterImpl :: RemoveSessionInfo
1071 * @tc.type: FUNC.
1072 * @tc.require:
1073 */
1074 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_024, TestSize.Level1)
1075 {
1076 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1077 std::string mimeType = "video/mp4";
1078 int32_t sessionType = 1;
1079 g_adapter->PutSessionInfo(nullptr, mimeType, sessionType);
1080 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1081 auto sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1082 ASSERT_NE(sessionInfo, nullptr);
1083 g_adapter->RemoveSessionInfo(nullptr);
1084 g_adapter->RemoveSessionInfo(validSessionId);
1085 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1086 EXPECT_EQ(sessionInfo, nullptr);
1087 }
1088
1089 /**
1090 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_026.
1091 * @tc.desc: test of DrmAdapterImpl :: SetKeyType
1092 * @tc.type: FUNC.
1093 * @tc.require:
1094 */
1095 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_026, TestSize.Level1)
1096 {
1097 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
1098 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
1099 auto sessionInfo = std::make_shared<SessionInfo>(
1100 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1101 g_adapter->SetKeyType(nullptr, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1102 g_adapter->RegistDrmCallback(mockCallback_);
1103 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1104 g_adapter->RegistDrmCallback(mockCallback_);
1105 g_adapter->PutSessionInfo(sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1106 EXPECT_CALL(*mockCallback_, OnStorageSaveInfo(_, _, _, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE)))
1107 .Times(1);
1108 g_adapter->SetKeyType(sessionId, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1109 g_adapter->RemoveSessionInfo(sessionId);
1110 g_adapter->ReleaseMediaKeySession();
1111 g_adapter->ReleaseMediaKeySystem();
1112 }
1113
1114 /**
1115 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_027.
1116 * @tc.desc: test of DrmAdapterImpl :: SetKeySetId
1117 * @tc.type: FUNC.
1118 * @tc.require:
1119 */
1120 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_027, TestSize.Level1)
1121 {
1122 auto sessionId = std::make_shared<SessionId>("sessionId", nullptr, 0);
1123 unsigned char mediaKeyId[] = { 0x01, 0x02, 0x03 };
1124 g_adapter->SetKeySetId(nullptr, mediaKeyId, sizeof(mediaKeyId));
1125 g_adapter->SetKeySetId(sessionId, mediaKeyId, sizeof(mediaKeyId));
1126 g_adapter->RegistDrmCallback(mockCallback_);
1127 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1128 g_adapter->RegistDrmCallback(mockCallback_);
1129 g_adapter->PutSessionInfo(sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1130 EXPECT_CALL(*mockCallback_, OnStorageSaveInfo(_, _, _, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE)))
1131 .Times(1);
1132 g_adapter->SetKeySetId(sessionId, mediaKeyId, sizeof(mediaKeyId));
1133 g_adapter->RemoveSessionInfo(sessionId);
1134 g_adapter->ReleaseMediaKeySession();
1135 g_adapter->ReleaseMediaKeySystem();
1136 }
1137
1138 /**
1139 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_028.
1140 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1141 * @tc.type: FUNC.
1142 * @tc.require:
1143 */
1144 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_028, TestSize.Level1)
1145 {
1146 g_adapter->LoadSessionWithLoadedStorage(nullptr, 1);
1147 auto sessionId = std::make_shared<SessionId>("sessionId_028", nullptr, 0);
1148 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(0);
1149 g_adapter->LoadSessionWithLoadedStorage(sessionId, 1);
1150 }
1151
1152 /**
1153 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_029.
1154 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1155 * @tc.type: FUNC.
1156 * @tc.require:
1157 */
1158 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_029, TestSize.Level1)
1159 {
1160 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1161 std::string mimeType = "video/mp4";
1162 uint32_t promiseId = 1;
1163 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1164 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1165 g_adapter->RegistDrmCallback(mockCallback_);
1166 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1167 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1168 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(1);
1169 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1170 g_adapter->RemoveSessionInfo(validSessionId);
1171 g_adapter->ReleaseMediaKeySession();
1172 g_adapter->ReleaseMediaKeySystem();
1173 }
1174
1175 /**
1176 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_030.
1177 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1178 * @tc.type: FUNC.
1179 * @tc.require:
1180 */
1181 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_030, TestSize.Level1)
1182 {
1183 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1184 std::string mimeType = "video/mp4";
1185 uint32_t promiseId = 1; // Example promiseId
1186 g_adapter->RegistDrmCallback(mockCallback_);
1187 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1188 g_adapter->RegistDrmCallback(mockCallback_);
1189 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_ONLINE));
1190
1191 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, "sessionId")).Times(0);
1192 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1193 g_adapter->RemoveSessionInfo(validSessionId);
1194 g_adapter->ReleaseMediaKeySession();
1195 g_adapter->ReleaseMediaKeySystem();
1196 }
1197
1198 /**
1199 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_031.
1200 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1201 * @tc.type: FUNC.
1202 * @tc.require:
1203 */
1204 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_031, TestSize.Level1)
1205 {
1206 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1207 std::string mimeType = "video/mp4";
1208 uint32_t promiseId = 1;
1209 g_adapter->RegistDrmCallback(mockCallback_);
1210 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1211 g_adapter->RegistDrmCallback(mockCallback_);
1212 int32_t certStatus = -1;
1213 g_adapter->GetCertificateStatus(certStatus);
1214 if (certStatus == 0) {
1215 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1216 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1217 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1218 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1219 } else {
1220 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1221 }
1222 g_adapter->ReleaseMediaKeySession();
1223 g_adapter->ReleaseMediaKeySystem();
1224 }
1225
1226 /**
1227 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_032.
1228 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1229 * @tc.type: FUNC.
1230 * @tc.require:
1231 */
1232 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_032, TestSize.Level1)
1233 {
1234 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1235 std::string mimeType = "video/mp4";
1236 uint32_t promiseId = 1; // Example promiseId
1237 g_adapter->RegistDrmCallback(mockCallback_);
1238 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1239 g_adapter->RegistDrmCallback(mockCallback_);
1240 int32_t certStatus = -1;
1241 g_adapter->GetCertificateStatus(certStatus);
1242 if (certStatus == 0) {
1243 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1244 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1245 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1246 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1247 } else {
1248 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1249 }
1250 g_adapter->ReleaseMediaKeySession();
1251 g_adapter->ReleaseMediaKeySystem();
1252 }
1253
1254 /**
1255 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_033.
1256 * @tc.desc: test of DrmAdapterImpl :: HandleKeyUpdatedCallback
1257 * @tc.type: FUNC.
1258 * @tc.require:
1259 */
1260 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_033, TestSize.Level1)
1261 {
1262 uint32_t promiseId = 2;
1263 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
1264 g_adapter->RegistDrmCallback(mockCallback_);
1265 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1266 g_adapter->HandleKeyUpdatedCallback(promiseId, true);
1267
1268 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1269
1270 g_adapter->HandleKeyUpdatedCallback(promiseId, false);
1271 g_adapter->ReleaseMediaKeySession();
1272 g_adapter->ReleaseMediaKeySystem();
1273 }
1274
1275 /**
1276 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_035.
1277 * @tc.desc: test of DrmAdapterImpl :: ProcessKeySystemResponse
1278 * @tc.type: FUNC.
1279 * @tc.require:
1280 */
1281 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_035, TestSize.Level1)
1282 {
1283 std::string response = "valid_response";
1284 int32_t result = g_adapter->ProcessKeySystemResponse(response, true);
1285 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1286 g_adapter->RegistDrmCallback(mockCallback_);
1287 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1288 result = g_adapter->ProcessKeySystemResponse(response, false);
1289 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1290 g_adapter->ReleaseMediaKeySession();
1291 g_adapter->ReleaseMediaKeySystem();
1292 }
1293
1294 /**
1295 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_039.
1296 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1297 * @tc.type: FUNC.
1298 * @tc.require:
1299 */
1300 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_039, TestSize.Level1)
1301 {
1302 DRM_EventType eventType = EVENT_DRM_BASE;
1303 uint8_t info[] = { 0 };
1304 int32_t infoLen = sizeof(info);
1305 char extra[] = "extra";
1306
1307 EXPECT_CALL(*mockCallback_, OnProvisionRequest(testing::_, testing::_)).Times(0);
1308
1309 MediaKeySystem* drmKeySystem = nullptr;
1310 auto result = g_adapter->SystemCallBackWithObj(drmKeySystem, eventType, info, infoLen, extra);
1311 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1312 }
1313
1314 /**
1315 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_040.
1316 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1317 * @tc.type: FUNC.
1318 * @tc.require:
1319 */
1320 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_040, TestSize.Level1)
1321 {
1322 uint8_t info[10] = { 0 };
1323 char extra[10] = "extra";
1324 DRM_EventType eventType = EVENT_DRM_BASE;
1325 int32_t infoLen = sizeof(info);
1326 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1327
1328 Drm_ErrCode ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1329 EXPECT_EQ(ret, DRM_ERR_INVALID_VAL);
1330
1331 g_adapter->mediaKeySystemCallbackMap_.clear();
1332 ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1333 EXPECT_EQ(ret, DRM_ERR_INVALID_VAL);
1334
1335 g_adapter->ReleaseMediaKeySession();
1336 g_adapter->ReleaseMediaKeySystem();
1337 }
1338
1339 /**
1340 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_041.
1341 * @tc.desc: test of DrmAdapterImpl :: SessionEventCallBackWithObj
1342 * @tc.type: FUNC.
1343 * @tc.require:
1344 */
1345 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_041, TestSize.Level1)
1346 {
1347 DRM_EventType eventType = EVENT_DRM_BASE;
1348 uint8_t info[] = { 0 };
1349 int32_t infoLen = sizeof(info);
1350 char extra[] = "extra";
1351 MediaKeySession* mediaKeySession = nullptr;
1352
1353 Drm_ErrCode result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1354 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1355 }
1356
1357 /**
1358 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_042.
1359 * @tc.desc: test of DrmAdapterImpl :: SessionKeyChangeCallBackWithObj
1360 * @tc.type: FUNC.
1361 * @tc.require:
1362 */
1363 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_042, TestSize.Level1)
1364 {
1365 bool newKeysAvailable = true;
1366 DRM_KeysInfo keysInfo;
1367 MediaKeySession* mediaKeySession = nullptr;
1368
1369 Drm_ErrCode result = g_adapter->SessionKeyChangeCallBackWithObj(mediaKeySession, &keysInfo, newKeysAvailable);
1370
1371 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1372 }
1373
1374 /**
1375 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_043.
1376 * @tc.desc: test of DrmAdapterImpl :: GetSecurityLevel
1377 * @tc.type: FUNC.
1378 * @tc.require:
1379 */
1380 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_043, TestSize.Level1)
1381 {
1382 EXPECT_EQ(g_adapter->GetSecurityLevel(), -1);
1383 if (g_isSupportDrm) {
1384 g_adapter->RegistDrmCallback(mockCallback_);
1385 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1386 int32_t certStatus = -1;
1387 g_adapter->GetCertificateStatus(certStatus);
1388 if (certStatus == 0) {
1389 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
1390 } else {
1391 EXPECT_EQ(g_adapter->GetSecurityLevel(), -1);
1392 }
1393 g_adapter->ReleaseMediaKeySession();
1394 g_adapter->ReleaseMediaKeySystem();
1395 }
1396 }
1397
1398 /**
1399 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_044.
1400 * @tc.desc: test of DrmAdapterImpl :: RequireSecureDecoderModule
1401 * @tc.type: FUNC.
1402 * @tc.require:
1403 */
1404 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_044, TestSize.Level1)
1405 {
1406 std::string mimeType = "video/avc";
1407 bool status = false;
1408 int32_t result = g_adapter->RequireSecureDecoderModule(mimeType, status);
1409 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1410 result = g_adapter->RequireSecureDecoderModule("", status);
1411 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1412 if (g_isSupportDrm) {
1413 g_adapter->RegistDrmCallback(mockCallback_);
1414 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1415 result = g_adapter->RequireSecureDecoderModule(mimeType, status);
1416 int32_t certStatus = -1;
1417 g_adapter->GetCertificateStatus(certStatus);
1418 if (certStatus == 0) {
1419 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1420 } else {
1421 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1422 }
1423 g_adapter->ReleaseMediaKeySession();
1424 g_adapter->ReleaseMediaKeySystem();
1425 }
1426 }
1427
1428 /**
1429 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_045.
1430 * @tc.desc: test of DrmAdapterImpl :: GetUUID
1431 * @tc.type: FUNC.
1432 * @tc.require:
1433 */
1434 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_045, TestSize.Level1)
1435 {
1436 if (g_isSupportDrm) {
1437 std::string name = GetKeySystemName();
1438 auto result = g_adapter->GetUUID(name);
1439 EXPECT_EQ(result.empty(), false);
1440
1441 result = g_adapter->GetUUID("com.test.drm");
1442 EXPECT_NE(result.empty(), false);
1443 } else {
1444 std::string name = GetKeySystemName();
1445 auto result = g_adapter->GetUUID(name);
1446 EXPECT_NE(result.empty(), false);
1447 }
1448 }
1449
1450 /**
1451 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_046.
1452 * @tc.desc: test of DrmAdapterImpl :: StorageProvisionedResult
1453 * @tc.type: FUNC.
1454 * @tc.require:
1455 */
1456 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_046, TestSize.Level1)
1457 {
1458 g_adapter->StorageProvisionedResult(false);
1459 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1460
1461 if (g_isSupportDrm) {
1462 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1463 g_adapter->RegistDrmCallback(mockCallback_);
1464 g_adapter->contentProtectionLevel_ = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1465
1466 int32_t certStatus = -1;
1467 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1468 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1469 if (certStatus == 0) {
1470 g_adapter->StorageProvisionedResult(true);
1471 g_adapter->ReleaseMediaKeySession();
1472 g_adapter->StorageProvisionedResult(true);
1473 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1474 }
1475 g_adapter->ReleaseMediaKeySession();
1476 g_adapter->ReleaseMediaKeySystem();
1477 }
1478 }
1479
1480 /**
1481 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_047.
1482 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1483 * @tc.type: FUNC.
1484 * @tc.require:
1485 */
1486 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_047, TestSize.Level1)
1487 {
1488 g_adapter->StorageSaveInfoResult(true, 1);
1489 g_adapter->RegistDrmCallback(mockCallback_);
1490 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
1491 g_adapter->StorageSaveInfoResult(true, 1);
1492 }
1493
1494 /**
1495 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_048.
1496 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1497 * @tc.type: FUNC.
1498 * @tc.require:
1499 */
1500 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_048, TestSize.Level1)
1501 {
1502 g_adapter->StorageSaveInfoResult(false, 1);
1503 g_adapter->RegistDrmCallback(mockCallback_);
1504 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1505 g_adapter->StorageSaveInfoResult(false, 1);
1506 }
1507
1508 /**
1509 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_055.
1510 * @tc.desc: test of DrmAdapterImpl :: CloseSession
1511 * @tc.type: FUNC.
1512 * @tc.require:
1513 */
1514 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_055, TestSize.Level1)
1515 {
1516 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1517 uint32_t promiseId = 1;
1518 std::string emeId = "test_eme_id";
1519 g_adapter->RegistDrmCallback(mockCallback_);
1520 int32_t result = g_adapter->CloseSession(promiseId, emeId);
1521 EXPECT_EQ(result, -1);
1522 if (g_isSupportDrm) {
1523 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1524 result = g_adapter->CloseSession(promiseId, emeId);
1525 EXPECT_EQ(result, -1);
1526 std::string mimeType = "video/mp4";
1527 int32_t sessionType = 1;
1528 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1529 result = g_adapter->CloseSession(promiseId, emeId);
1530 EXPECT_EQ(result, 0);
1531 g_adapter->RemoveSessionInfo(validSessionId);
1532
1533 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1534 g_adapter->keySystemType_ = KeySystemType::WIDEVINE;
1535 result = g_adapter->CloseSession(promiseId, emeId);
1536 EXPECT_NE(result, 0);
1537 g_adapter->ReleaseMediaKeySession();
1538 g_adapter->ReleaseMediaKeySystem();
1539 }
1540 }
1541
1542 /**
1543 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_056.
1544 * @tc.desc: test of DrmAdapterImpl :: RemoveSession
1545 * @tc.type: FUNC.
1546 * @tc.require:
1547 */
1548 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_056, TestSize.Level1)
1549 {
1550 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1551 std::string mimeType = "video/mp4";
1552 uint32_t promiseId = 1;
1553 std::string emeId = "test_eme_id";
1554
1555 g_adapter->emeSessionInfoMap_[emeId] = nullptr;
1556 int32_t result = g_adapter->RemoveSession(promiseId, emeId);
1557 EXPECT_EQ(result, -1);
1558
1559 g_adapter->RegistDrmCallback(mockCallback_);
1560 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1561 g_adapter->PutSessionInfo(validSessionId, mimeType, MEDIA_KEY_TYPE_ONLINE);
1562 result = g_adapter->RemoveSession(promiseId, "invalid_eme_id");
1563 EXPECT_EQ(result, -1);
1564
1565 result = g_adapter->RemoveSession(promiseId, emeId);
1566 EXPECT_EQ(result, -1);
1567
1568 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1569 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1570 result = g_adapter->RemoveSession(promiseId, emeId);
1571 EXPECT_EQ(result, 0);
1572 g_adapter->ReleaseMediaKeySession();
1573 g_adapter->ReleaseMediaKeySystem();
1574 }
1575
1576 /**
1577 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_057.
1578 * @tc.desc: test of DrmAdapterImpl :: LoadSession
1579 * @tc.type: FUNC.
1580 * @tc.require:
1581 */
1582 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_057, TestSize.Level1)
1583 {
1584 uint32_t promiseId = 1;
1585 std::string sessionId = "sessionId";
1586 int32_t result = g_adapter->LoadSession(promiseId, sessionId);
1587 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1588
1589 g_adapter->RegistDrmCallback(mockCallback_);
1590 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1591
1592 result = g_adapter->LoadSession(promiseId, sessionId);
1593 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1594 g_adapter->ReleaseMediaKeySession();
1595 g_adapter->ReleaseMediaKeySystem();
1596 }
1597
1598 /**
1599 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_058.
1600 * @tc.desc: test of DrmAdapterImpl :: UpdateSession
1601 * @tc.type: FUNC.
1602 * @tc.require:
1603 */
1604 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_058, TestSize.Level1)
1605 {
1606 uint32_t promiseId = 1;
1607 std::string emeId = "test_eme_id";
1608 std::vector<uint8_t> response = { 0x01, 0x02, 0x03 }; // Example response data
1609 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1610 std::string mimeType = "video/mp4";
1611 int32_t result = g_adapter->UpdateSession(promiseId, emeId, response);
1612 EXPECT_EQ(result, -1);
1613 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1614 result = g_adapter->UpdateSession(promiseId, emeId, response);
1615 EXPECT_EQ(result, -1);
1616
1617 g_adapter->RegistDrmCallback(mockCallback_);
1618 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_ONLINE));
1619 result = g_adapter->UpdateSession(promiseId, emeId, response);
1620 EXPECT_EQ(result, -1);
1621
1622 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1623 result = g_adapter->UpdateSession(promiseId, emeId, response);
1624 EXPECT_EQ(result, -1);
1625
1626 result = g_adapter->UpdateSession(promiseId, "invalid_eme_id", response);
1627 EXPECT_EQ(result, -1);
1628
1629 g_adapter->RemoveSessionInfo(validSessionId);
1630 g_adapter->ReleaseMediaKeySession();
1631 g_adapter->ReleaseMediaKeySystem();
1632 }
1633
1634 /**
1635 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_059.
1636 * @tc.desc: test of DrmAdapterImpl::OnSessionExpirationUpdate
1637 * @tc.type: FUNC.
1638 * @tc.require:
1639 */
1640 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_059, TestSize.Level1)
1641 {
1642 g_adapter->callback_ = nullptr;
1643 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1644 if (g_isSupportDrm) {
1645 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1646 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, nullptr, 0);
1647 g_adapter->mediaKeySessionCallbackMap_.clear();
1648 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, nullptr, 0);
1649 g_adapter->ReleaseMediaKeySession();
1650 g_adapter->ReleaseMediaKeySystem();
1651 g_adapter->RegistDrmCallback(mockCallback_);
1652 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1653 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1654 int32_t certStatus = -1;
1655 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1656 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1657 if (certStatus == 0) {
1658 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1659 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(_, _)).Times(1);
1660 std::string infoString = "123456ms";
1661 uint32_t infoSize = infoString.size();
1662 uint8_t info[32] = { 0 };
1663 errno_t ret = memcpy_s(info, infoSize, infoString.data(), infoSize);
1664 EXPECT_EQ(ret, EOK);
1665
1666 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
1667 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
1668 auto sessionInfo = std::make_shared<SessionInfo>(
1669 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1670 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo);
1671
1672 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoSize);
1673
1674 g_adapter->callback_->RemoveMediaKeySessionInfo(g_adapter->drmKeySession_);
1675 } else {
1676 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1677 }
1678 g_adapter->ReleaseMediaKeySession();
1679 g_adapter->ReleaseMediaKeySystem();
1680 } else {
1681 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1682 }
1683 }
1684
1685 /**
1686 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_060.
1687 * @tc.desc: test of DrmAdapterImpl::GetKeyRequest
1688 * @tc.type: FUNC.
1689 * @tc.require:
1690 */
1691 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_060, TestSize.Level1)
1692 {
1693 uint8_t info[10] = { 0 };
1694 int32_t infoLen = sizeof(info);
1695 g_adapter->GetKeyRequest(nullptr, info, infoLen);
1696 g_adapter->RegistDrmCallback(mockCallback_);
1697 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1698 if (g_isSupportDrm) {
1699 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1700
1701 int32_t certStatus = -1;
1702 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1703 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1704
1705 if (certStatus == 0 && g_isWisePlay) {
1706 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1707 g_adapter->GetKeyRequest(g_adapter->drmKeySession_, info, infoLen);
1708
1709 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
1710 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
1711 auto sessionInfo = std::make_shared<SessionInfo>(
1712 sessionId, "test_mime_type_longxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx",
1713 static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1714 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo);
1715 g_adapter->GetKeyRequest(g_adapter->drmKeySession_, info, infoLen);
1716
1717 g_adapter->mediaKeySessionCallbackMap_.clear();
1718 g_adapter->GetKeyRequest(g_adapter->drmKeySession_, info, infoLen);
1719
1720 g_adapter->mediaKeySessionCallbackMap_[g_adapter->drmKeySession_] = nullptr;
1721 g_adapter->GetKeyRequest(g_adapter->drmKeySession_, info, infoLen);
1722 }
1723 g_adapter->ReleaseMediaKeySession();
1724 g_adapter->ReleaseMediaKeySystem();
1725 } else {
1726 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1727 }
1728 }
1729
1730 /**
1731 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_061.
1732 * @tc.desc: test of DrmAdapterImpl :: SessionEventCallBackWithObj
1733 * @tc.type: FUNC.
1734 * @tc.require:
1735 */
1736 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_061, TestSize.Level1)
1737 {
1738 DRM_EventType eventType = EVENT_KEY_REQUIRED;
1739 uint8_t info[] = { 0 };
1740 int32_t infoLen = sizeof(info);
1741 char extra[] = "extra";
1742 MediaKeySession* mediaKeySession = nullptr;
1743
1744 Drm_ErrCode result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1745 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1746
1747 eventType = EVENT_EXPIRATION_UPDATE;
1748 result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1749 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1750
1751 eventType = EVENT_PROVISION_REQUIRED;
1752 result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1753 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1754
1755 eventType = EVENT_KEY_EXPIRED;
1756 result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1757 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1758
1759 eventType = EVENT_VENDOR_DEFINED;
1760 result = g_adapter->SessionEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1761 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1762
1763 result =
1764 g_adapter->SessionEventCallBackWithObj(mediaKeySession, static_cast<DRM_EventType>(0), info, infoLen, extra);
1765 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1766 }
1767
1768 /**
1769 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_062.
1770 * @tc.desc: test of DrmAdapterImpl :: SessionKeyChangeCallBackWithObj
1771 * @tc.type: FUNC.
1772 * @tc.require:
1773 */
1774 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_062, TestSize.Level1)
1775 {
1776 bool newKeysAvailable = true;
1777 DRM_KeysInfo keysInfo;
1778 keysInfo.keysInfoCount = 0;
1779
1780 Drm_ErrCode result =
1781 g_adapter->SessionKeyChangeCallBackWithObj(g_adapter->drmKeySession_, nullptr, newKeysAvailable);
1782 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1783
1784 if (g_isSupportDrm) {
1785 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1786 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1787
1788 int32_t certStatus = -1;
1789 int32_t certResult = g_adapter->GetCertificateStatus(certStatus);
1790 EXPECT_EQ(certResult, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1791
1792 if (certStatus == 0) {
1793 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1794 g_adapter->RegistDrmCallback(mockCallback_);
1795 result = g_adapter->SessionKeyChangeCallBackWithObj(g_adapter->drmKeySession_, &keysInfo, newKeysAvailable);
1796 EXPECT_EQ(result, DRM_ERR_OK);
1797 }
1798 g_adapter->ReleaseMediaKeySession();
1799 g_adapter->ReleaseMediaKeySystem();
1800 } else {
1801 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1802 }
1803 }
1804
1805 /**
1806 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_063.
1807 * @tc.desc: test of DrmAdapterImpl::StorageLoadInfoResult
1808 * @tc.type: FUNC.
1809 * @tc.require:
1810 */
1811 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_063, TestSize.Level1)
1812 {
1813 std::vector<uint8_t> keySetId;
1814 keySetId.clear();
1815 g_adapter->callback_ = nullptr;
1816 g_adapter->StorageLoadInfoResult("", keySetId, "", 0);
1817
1818 g_adapter->RegistDrmCallback(mockCallback_);
1819 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(1);
1820 g_adapter->StorageLoadInfoResult("", keySetId, "", 0);
1821 EXPECT_NE(g_adapter->callback_, nullptr);
1822 g_adapter->callback_ = nullptr;
1823
1824 std::vector<uint8_t> keySetId2 = { 0x01, 0x02 };
1825 g_adapter->StorageLoadInfoResult("testEmeId063", keySetId2, "", 0);
1826 g_adapter->StorageLoadInfoResult("testEmeId063", keySetId2, "", 0);
1827 EXPECT_NE(g_adapter->GetSessionIdByEmeId("testEmeId063"), nullptr);
1828 }
1829
1830 /**
1831 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_064.
1832 * @tc.desc: test of DrmAdapterImpl::ClearPersistentSessionInfoFroKeyRelease
1833 * @tc.type: FUNC.
1834 * @tc.require:
1835 */
1836 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_064, TestSize.Level1)
1837 {
1838 g_adapter->ClearPersistentSessionInfoFroKeyRelease(nullptr);
1839
1840 auto sessionId = SessionId::CreateSessionId("testSessionId");
1841 g_adapter->ClearPersistentSessionInfoForLoadFail(nullptr);
1842 g_adapter->callback_ = nullptr;
1843 g_adapter->ClearPersistentSessionInfoForLoadFail(sessionId);
1844
1845 g_adapter->RegistDrmCallback(mockCallback_);
1846 EXPECT_CALL(*mockCallback_, OnStorageClearInfoForKeyRelease(_)).Times(1);
1847 g_adapter->ClearPersistentSessionInfoFroKeyRelease(sessionId);
1848 }
1849
1850 /**
1851 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_065.
1852 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1853 * @tc.type: FUNC.
1854 * @tc.require:
1855 */
1856 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_065, TestSize.Level1)
1857 {
1858 uint8_t info[10] = { 0 };
1859 char extra[10] = "extra";
1860 DRM_EventType eventType = EVENT_DRM_BASE;
1861 int32_t infoLen = sizeof(info);
1862 g_adapter->RegistDrmCallback(mockCallback_);
1863 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1864 if (g_isSupportDrm) {
1865 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1866 auto ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1867 EXPECT_EQ(ret, DRM_ERR_OK);
1868 g_adapter->ReleaseMediaKeySession();
1869 g_adapter->ReleaseMediaKeySystem();
1870 } else {
1871 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1872 }
1873 }
1874
1875 /**
1876 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_066.
1877 * @tc.desc: test of DrmAdapterImpl :: SessionKeyChangeCallBackWithObj
1878 * @tc.type: FUNC.
1879 * @tc.require:
1880 */
1881 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_066, TestSize.Level1)
1882 {
1883 bool newKeysAvailable = true;
1884 DRM_KeysInfo keysInfo;
1885 keysInfo.keysInfoCount = 2;
1886 (void)memset_s(keysInfo.keyId[0], MAX_KEY_ID_LEN, 0x00, MAX_KEY_ID_LEN);
1887 (void)memset_s(keysInfo.keyId[1], MAX_KEY_ID_LEN, 0x00, MAX_KEY_ID_LEN);
1888 std::string keyStatus = "USABLE";
1889 uint32_t statusSize = keyStatus.size();
1890 (void)memset_s(keysInfo.statusValue[0], MAX_KEY_STATUS_VALUE_LEN, 0x00, MAX_KEY_STATUS_VALUE_LEN);
1891 errno_t ret = memcpy_s(keysInfo.statusValue[0], statusSize, keyStatus.data(), statusSize);
1892 EXPECT_EQ(ret, EOK);
1893
1894 std::string keyStatus2 = "XXXX";
1895 uint32_t statusSize2 = keyStatus2.size();
1896 (void)memset_s(keysInfo.statusValue[1], MAX_KEY_STATUS_VALUE_LEN, 0x00, MAX_KEY_STATUS_VALUE_LEN);
1897 ret = memcpy_s(keysInfo.statusValue[1], statusSize2, keyStatus2.data(), statusSize2);
1898 EXPECT_EQ(ret, EOK);
1899
1900 g_adapter->RegistDrmCallback(mockCallback_);
1901 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1902 if (g_isSupportDrm) {
1903 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1904
1905 int32_t certStatus = -1;
1906 int32_t certResult = g_adapter->GetCertificateStatus(certStatus);
1907 EXPECT_EQ(certResult, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1908
1909 if (certStatus == 0) {
1910 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1911 auto result =
1912 g_adapter->SessionKeyChangeCallBackWithObj(g_adapter->drmKeySession_, &keysInfo, newKeysAvailable);
1913 EXPECT_EQ(result, DRM_ERR_OK);
1914
1915 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
1916 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
1917 auto sessionInfo = std::make_shared<SessionInfo>(
1918 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1919 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo);
1920
1921 result =
1922 g_adapter->SessionKeyChangeCallBackWithObj(g_adapter->drmKeySession_, &keysInfo, newKeysAvailable);
1923 EXPECT_EQ(result, DRM_ERR_OK);
1924
1925 auto sessionInfo2 = std::make_shared<SessionInfo>(
1926 nullptr, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1927 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo2);
1928 result =
1929 g_adapter->SessionKeyChangeCallBackWithObj(g_adapter->drmKeySession_, &keysInfo, newKeysAvailable);
1930 EXPECT_EQ(result, DRM_ERR_OK);
1931 }
1932 g_adapter->ReleaseMediaKeySession();
1933 g_adapter->ReleaseMediaKeySystem();
1934 } else {
1935 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1936 }
1937 }
1938
1939 /**
1940 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_067.
1941 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1942 * @tc.type: FUNC.
1943 * @tc.require:
1944 */
1945 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_067, TestSize.Level1)
1946 {
1947 g_adapter->callback_ = nullptr;
1948 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1949 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1950 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1951
1952 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1953 if (g_isSupportDrm) {
1954 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1955 g_adapter->releaseEmeId_ = "testId_067";
1956 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1957
1958 g_adapter->RegistDrmCallback(mockCallback_);
1959 EXPECT_NE(g_adapter->callback_, nullptr);
1960
1961 int32_t certStatus = -1;
1962 g_adapter->GetCertificateStatus(certStatus);
1963 if (certStatus == 0) {
1964 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1965 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1966 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
1967
1968 auto sessionId = SessionId::CreateSessionId("tempSessionId067");
1969 std::string mimeType = "video/mp4";
1970 int32_t sessionType = 1;
1971 g_adapter->PutSessionInfo(sessionId, mimeType, sessionType);
1972 g_adapter->releaseEmeId_ = "tempSessionId067";
1973 g_adapter->ReleaseMediaKeySession();
1974 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1975 } else {
1976 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
1977 }
1978 g_adapter->ReleaseMediaKeySession();
1979 g_adapter->ReleaseMediaKeySystem();
1980 } else {
1981 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1982 }
1983 }
1984
1985 /**
1986 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_068.
1987 * @tc.desc: test of DrmAdapterImpl::UpdateSessionResult
1988 * @tc.type: FUNC.
1989 * @tc.require:
1990 */
1991 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_068, TestSize.Level1)
1992 {
1993 g_adapter->UpdateSessionResult(false, nullptr, nullptr, 0);
1994 auto sessionId = SessionId::CreateSessionId("tempSessionId068");
1995 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
1996
1997 std::string mimeType = "video/mp4";
1998 int32_t sessionType = 1;
1999
2000 g_adapter->callback_ = nullptr;
2001 g_adapter->PutSessionInfo(sessionId, mimeType, sessionType);
2002
2003 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
2004 g_adapter->UpdateSessionResult(true, sessionId, nullptr, 0);
2005 g_adapter->RegistDrmCallback(mockCallback_);
2006 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
2007 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
2008 EXPECT_NE(g_adapter->callback_, nullptr);
2009 }
2010
2011 /**
2012 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_069.
2013 * @tc.desc: test of DrmAdapterImpl::OnSessionExpirationUpdate
2014 * @tc.type: FUNC.
2015 * @tc.require:
2016 */
2017 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_069, TestSize.Level1)
2018 {
2019 g_adapter->RegistDrmCallback(mockCallback_);
2020 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
2021 if (g_isSupportDrm) {
2022 int32_t certStatus = -1;
2023 int32_t result = g_adapter->GetCertificateStatus(certStatus);
2024 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
2025 if (certStatus == 0) {
2026 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
2027
2028 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
2029 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
2030 auto sessionInfo = std::make_shared<SessionInfo>(
2031 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
2032 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo);
2033
2034 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(_, _)).Times(4);
2035 std::string infoString = "123456ms";
2036 uint8_t info[32] = { 0 };
2037 errno_t ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2038 EXPECT_EQ(ret, EOK);
2039 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, 0);
2040 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, nullptr, 0);
2041 infoString = "12ms";
2042 (void)memset_s(info, 32, 0x00, 32);
2043 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2044 EXPECT_EQ(ret, EOK);
2045 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2046 infoString = "1";
2047 (void)memset_s(info, 32, 0x00, 32);
2048 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2049 EXPECT_EQ(ret, EOK);
2050 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2051 g_adapter->callback_->RemoveMediaKeySessionInfo(g_adapter->drmKeySession_);
2052 } else {
2053 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
2054 }
2055 g_adapter->ReleaseMediaKeySession();
2056 g_adapter->ReleaseMediaKeySystem();
2057 } else {
2058 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
2059 }
2060 }
2061
2062 /**
2063 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_070.
2064 * @tc.desc: test of DrmAdapterImpl::StorageClearInfoResult
2065 * @tc.type: FUNC.
2066 * @tc.require:
2067 */
2068 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_070, TestSize.Level1)
2069 {
2070 g_adapter->RegistDrmCallback(mockCallback_);
2071 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
2072 g_adapter->StorageClearInfoResult(true, static_cast<int32_t>(ClearInfoType::KEY_RELEASE));
2073
2074 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
2075 g_adapter->StorageClearInfoResult(false, static_cast<int32_t>(ClearInfoType::KEY_RELEASE));
2076
2077 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(2);
2078 g_adapter->StorageClearInfoResult(false, static_cast<int32_t>(ClearInfoType::LOAD_FAIL));
2079 g_adapter->StorageClearInfoResult(true, static_cast<int32_t>(ClearInfoType::LOAD_FAIL));
2080 EXPECT_NE(g_adapter->callback_, nullptr);
2081 g_adapter->callback_ = nullptr;
2082 g_adapter->StorageClearInfoResult(true, static_cast<int32_t>(ClearInfoType::LOAD_FAIL));
2083 }
2084
2085 /**
2086 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_071.
2087 * @tc.desc: test of DrmAdapterImpl::UpdateSessionResult
2088 * @tc.type: FUNC.
2089 * @tc.require:
2090 */
2091 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_071, TestSize.Level1)
2092 {
2093 auto sessionId = SessionId::CreateSessionId("tempSessionId071");
2094 std::string mimeType = "video/mp4";
2095 int32_t sessionType = 0;
2096 int32_t mediaKeyIdLen = MAX_KEY_SET_ID_LEN;
2097 uint8_t mediaKeyId[MAX_KEY_SET_ID_LEN] = { 0x00 };
2098 g_adapter->PutSessionInfo(sessionId, mimeType, sessionType);
2099 g_adapter->UpdateSessionResult(false, sessionId, mediaKeyId, mediaKeyIdLen);
2100 g_adapter->RegistDrmCallback(mockCallback_);
2101 g_adapter->UpdateSessionResult(false, sessionId, mediaKeyId, mediaKeyIdLen);
2102 EXPECT_NE(g_adapter->callback_, nullptr);
2103 }
2104
2105 /**
2106 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_072.
2107 * @tc.desc: test of DrmAdapterImpl :: CloseSession
2108 * @tc.type: FUNC.
2109 * @tc.require:
2110 */
2111 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_072, TestSize.Level1)
2112 {
2113 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
2114 uint32_t promiseId = 1;
2115 std::string emeId = "test_eme_id";
2116 int32_t result = g_adapter->CloseSession(promiseId, emeId);
2117 EXPECT_EQ(result, -1);
2118 if (g_isSupportDrm) {
2119 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
2120 result = g_adapter->CloseSession(promiseId, emeId);
2121 EXPECT_EQ(result, -1);
2122 std::string mimeType = "video/mp4";
2123 int32_t sessionType = 1;
2124 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
2125 result = g_adapter->CloseSession(promiseId, emeId);
2126 EXPECT_EQ(result, 0);
2127 g_adapter->RemoveSessionInfo(validSessionId);
2128
2129 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
2130 g_adapter->keySystemType_ = KeySystemType::WIDEVINE;
2131 result = g_adapter->CloseSession(promiseId, emeId);
2132 EXPECT_NE(result, 0);
2133 g_adapter->ReleaseMediaKeySession();
2134 g_adapter->ReleaseMediaKeySystem();
2135 }
2136 }
2137
2138 /**
2139 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_073.
2140 * @tc.desc: test of DrmAdapterImpl::OnSessionExpirationUpdate
2141 * @tc.type: FUNC.
2142 * @tc.require:
2143 */
2144 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_073, TestSize.Level1)
2145 {
2146 g_adapter->RegistDrmCallback(mockCallback_);
2147 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
2148 if (g_isSupportDrm) {
2149 int32_t certStatus = -1;
2150 int32_t result = g_adapter->GetCertificateStatus(certStatus);
2151 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
2152 if (certStatus == 0) {
2153 EXPECT_NE(g_adapter->drmKeySession_, nullptr);
2154
2155 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
2156 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
2157 auto sessionInfo = std::make_shared<SessionInfo>(
2158 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
2159 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo);
2160
2161 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(_, _)).Times(3);
2162 std::string infoString = "abcdms";
2163 uint8_t info[32] = { 0 };
2164 errno_t ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2165 EXPECT_EQ(ret, EOK);
2166 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2167 infoString = "123456";
2168 (void)memset_s(info, 32, 0x00, 32);
2169 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2170 EXPECT_EQ(ret, EOK);
2171 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2172 infoString = "123456789123456789123456789ms";
2173 (void)memset_s(info, 32, 0x00, 32);
2174 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
2175 EXPECT_EQ(ret, EOK);
2176 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2177
2178 g_adapter->callback_->RemoveMediaKeySessionInfo(g_adapter->drmKeySession_);
2179 auto sessionInfo2 = std::make_shared<SessionInfo>(
2180 nullptr, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
2181 g_adapter->callback_->UpdateMediaKeySessionInfoMap(g_adapter->drmKeySession_, sessionInfo2);
2182 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2183
2184 g_adapter->callback_->RemoveMediaKeySessionInfo(g_adapter->drmKeySession_);
2185 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySession_, info, infoString.size());
2186 } else {
2187 EXPECT_EQ(g_adapter->drmKeySession_, nullptr);
2188 }
2189 g_adapter->ReleaseMediaKeySession();
2190 g_adapter->ReleaseMediaKeySystem();
2191 } else {
2192 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
2193 }
2194 }
2195 } // namespace OHOS::NWeb
2196