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 :: OnStorageLoadInfo
519 * @tc.type: FUNC.
520 * @tc.require:
521 */
522 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_017, TestSize.Level1)
523 {
524 std::string emeId = "emeId";
525 bool isRelease = true;
526 g_callback->UpdateEmeId(emeId, isRelease);
527 EXPECT_EQ(emeId, g_callback->EmeId());
528 EXPECT_EQ(isRelease, g_callback->IsRelease());
529 }
530
531 /**
532 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_018.
533 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
534 * @tc.type: FUNC.
535 * @tc.require:
536 */
537 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_018, TestSize.Level1)
538 {
539 std::string mimeType = "video/mp4";
540 int32_t type = 0;
541
542 g_callback->UpdateMimeType(mimeType, type);
543 EXPECT_EQ(mimeType, g_callback->MimeType());
544 EXPECT_EQ(type, g_callback->Type());
545 }
546
547 /**
548 * @tc.name: DrmCallbackImplTest_DrmCallbackImpl_019.
549 * @tc.desc: test of DrmCallbackImpl :: OnStorageLoadInfo
550 * @tc.type: FUNC.
551 * @tc.require:
552 */
553 HWTEST_F(DrmCallbackImplTest, DrmCallbackImplTest_DrmCallbackImpl_019, TestSize.Level1)
554 {
555 EXPECT_CALL(*mockCallback_, OnMediaLicenseReady(true)).Times(1);
556 g_callback->OnMediaLicenseReady(true);
557 EXPECT_NE(g_callback->callbackAdapter_, nullptr);
558 g_callback->callbackAdapter_ = nullptr;
559 g_callback->OnMediaLicenseReady(true);
560 }
561
SetUpTestCase(void)562 void DrmAdapterImplTest::SetUpTestCase(void) {}
563
TearDownTestCase(void)564 void DrmAdapterImplTest::TearDownTestCase(void) {}
565
SetUp(void)566 void DrmAdapterImplTest::SetUp(void)
567 {
568 g_adapter = std::make_shared<DrmAdapterImpl>();
569 mockCallback_ = std::make_shared<NiceMock<DrmCallbackAdapterMock>>();
570 }
571
TearDown(void)572 void DrmAdapterImplTest::TearDown(void)
573 {
574 g_adapter = nullptr;
575 }
576
577 /**
578 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_001.
579 * @tc.desc: test of DrmAdapterImpl :: IsSupported
580 * @tc.type: FUNC.
581 * @tc.require:
582 */
583 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_001, TestSize.Level1)
584 {
585 EXPECT_FALSE(g_adapter->IsSupported(""));
586 GetKeySystemName();
587 if (g_isSupportDrm) {
588 EXPECT_TRUE(g_adapter->IsSupported(GetKeySystemName()));
589 } else {
590 EXPECT_FALSE(g_adapter->IsSupported(GetKeySystemName()));
591 }
592 }
593
594 /**
595 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_002.
596 * @tc.desc: test of DrmAdapterImpl :: IsSupported2
597 * @tc.type: FUNC.
598 * @tc.require:
599 */
600 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_002, TestSize.Level1)
601 {
602 EXPECT_FALSE(g_adapter->IsSupported2("", ""));
603 EXPECT_FALSE(g_adapter->IsSupported2("example", ""));
604
605 bool isSupported = g_adapter->IsSupported2(GetKeySystemName(), "video/mp4");
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_003.
615 * @tc.desc: test of DrmAdapterImpl :: IsSupported3
616 * @tc.type: FUNC.
617 * @tc.require:
618 */
619 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_003, TestSize.Level1)
620 {
621 EXPECT_FALSE(g_adapter->IsSupported3("", "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
622 EXPECT_FALSE(g_adapter->IsSupported3("example", "", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
623 EXPECT_FALSE(g_adapter->IsSupported3("example", "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO));
624 bool isSupported = g_adapter->IsSupported3(GetKeySystemName(), "video/mp4", CONTENT_PROTECTION_LEVEL_HW_CRYPTO);
625 if (g_isSupportDrm) {
626 EXPECT_EQ(isSupported, true);
627 } else {
628 EXPECT_EQ(isSupported, false);
629 }
630 }
631
632 /**
633 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_004.
634 * @tc.desc: test of DrmAdapterImpl :: CreateKeySystem
635 * @tc.type: FUNC.
636 * @tc.require:
637 */
638 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_004, TestSize.Level1)
639 {
640 g_adapter->RegistDrmCallback(mockCallback_);
641
642 auto result = g_adapter->CreateKeySystem("", "", SECURITY_LEVEL_3);
643 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
644
645 result = g_adapter->CreateKeySystem("com.test.drm", "", SECURITY_LEVEL_3);
646 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
647
648 result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
649 if (g_isSupportDrm) {
650 int32_t certStatus = -1;
651 g_adapter->GetCertificateStatus(certStatus);
652 if (certStatus == 0) {
653 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
654 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
655 g_adapter->ReleaseMediaKeySession();
656 g_adapter->ReleaseMediaKeySystem();
657
658 result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_1);
659 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
660 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
661 g_adapter->ReleaseMediaKeySession();
662 g_adapter->ReleaseMediaKeySystem();
663 } else {
664 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
665 }
666
667 EXPECT_EQ(g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_UNKNOWN),
668 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
669 g_adapter->ReleaseMediaKeySession();
670 g_adapter->ReleaseMediaKeySystem();
671
672 EXPECT_EQ(g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", -1),
673 static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
674 g_adapter->ReleaseMediaKeySession();
675 g_adapter->ReleaseMediaKeySystem();
676 } else {
677 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
678 }
679 }
680
681 /**
682 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_005.
683 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySystem
684 * @tc.type: FUNC.
685 * @tc.require:
686 */
687 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_005, TestSize.Level1)
688 {
689 g_adapter->RegistDrmCallback(mockCallback_);
690 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
691 if (g_isSupportDrm) {
692 g_adapter->ReleaseMediaKeySession();
693 int32_t result = g_adapter->ReleaseMediaKeySystem();
694 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
695
696 result = g_adapter->ReleaseMediaKeySystem();
697 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
698 } else {
699 int32_t result = g_adapter->ReleaseMediaKeySystem();
700 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
701 }
702 }
703
704 /**
705 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_006.
706 * @tc.desc: test of DrmAdapterImpl :: CreateMediaKeySession
707 * @tc.type: FUNC.
708 * @tc.require:
709 */
710 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_006, TestSize.Level1)
711 {
712 g_adapter->RegistDrmCallback(mockCallback_);
713 EXPECT_EQ(g_adapter->CreateMediaKeySession(), -1);
714
715 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
716 if (g_isSupportDrm) {
717 int32_t certStatus = -1;
718 g_adapter->GetCertificateStatus(certStatus);
719 if (certStatus == 0) {
720 EXPECT_EQ(g_adapter->CreateMediaKeySession(), 0);
721 g_adapter->ReleaseMediaKeySession();
722 g_adapter->ReleaseMediaKeySystem();
723 } else {
724 EXPECT_NE(g_adapter->CreateMediaKeySession(), 0);
725 }
726 } else {
727 EXPECT_NE(g_adapter->CreateMediaKeySession(), 0);
728 }
729 }
730
731 /**
732 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_007.
733 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySession
734 * @tc.type: FUNC.
735 * @tc.require:
736 */
737 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_007, TestSize.Level1)
738 {
739 int32_t result = g_adapter->ReleaseMediaKeySession();
740 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
741 g_adapter->RegistDrmCallback(mockCallback_);
742 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
743 if (g_isSupportDrm) {
744 int32_t certStatus = -1;
745 g_adapter->GetCertificateStatus(certStatus);
746 result = g_adapter->ReleaseMediaKeySession();
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 g_adapter->ReleaseMediaKeySystem();
753 } else {
754 result = g_adapter->ReleaseMediaKeySession();
755 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
756 }
757 }
758
759 /**
760 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_008.
761 * @tc.desc: test of DrmAdapterImpl :: ReleaseMediaKeySession
762 * @tc.type: FUNC.
763 * @tc.require:
764 */
765 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_008, TestSize.Level1)
766 {
767 g_adapter->callback_ = nullptr;
768 int32_t result = g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
769 int32_t certStatus = -1;
770 g_adapter->GetCertificateStatus(certStatus);
771 if (certStatus == 0) {
772 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
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
951 /**
952 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_017.
953 * @tc.desc: test of DrmAdapterImpl :: ClearMediaKeys
954 * @tc.type: FUNC.
955 * @tc.require:
956 */
957 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_017, TestSize.Level1)
958 {
959 EXPECT_EQ(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
960
961 if (g_isSupportDrm) {
962 g_adapter->RegistDrmCallback(mockCallback_);
963 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
964 int32_t certStatus = -1;
965 g_adapter->GetCertificateStatus(certStatus);
966 if (certStatus == 0) {
967 EXPECT_EQ(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
968 } else {
969 EXPECT_NE(g_adapter->ClearMediaKeys(), static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
970 }
971 g_adapter->ReleaseMediaKeySession();
972 g_adapter->ReleaseMediaKeySystem();
973 }
974 }
975
976 /**
977 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_019.
978 * @tc.desc: test of DrmAdapterImpl :: GetCertificateStatus
979 * @tc.type: FUNC.
980 * @tc.require:
981 */
982 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_019, TestSize.Level1)
983 {
984 int32_t certStatus;
985 int32_t result = g_adapter->GetCertificateStatus(certStatus);
986 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
987 if (g_isSupportDrm) {
988 g_adapter->RegistDrmCallback(mockCallback_);
989 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
990 result = g_adapter->GetCertificateStatus(certStatus);
991 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
992 g_adapter->ReleaseMediaKeySession();
993 g_adapter->ReleaseMediaKeySystem();
994 }
995 }
996
997 /**
998 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_020.
999 * @tc.desc: test of DrmAdapterImpl :: PutSessionInfo & GetSessionInfo
1000 * @tc.type: FUNC.
1001 * @tc.require:
1002 */
1003 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_020, TestSize.Level1)
1004 {
1005 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1006 std::string mimeType = "video/mp4";
1007 int32_t sessionType = 1; // Assume valid session type
1008 auto sessionInfo = g_adapter->GetSessionInfo(nullptr);
1009 EXPECT_EQ(sessionInfo, nullptr);
1010 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1011 EXPECT_EQ(sessionInfo, nullptr);
1012 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1013
1014 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1015 ASSERT_NE(sessionInfo, nullptr);
1016 }
1017
1018 /**
1019 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_022.
1020 * @tc.desc: test of DrmAdapterImpl :: RegistDrmCallback
1021 * @tc.type: FUNC.
1022 * @tc.require:
1023 */
1024 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_022, TestSize.Level1)
1025 {
1026 int32_t result = g_adapter->RegistDrmCallback(mockCallback_);
1027 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1028
1029 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK)); // Check that the return value is as expected
1030 g_adapter->ReleaseMediaKeySession();
1031 g_adapter->ReleaseMediaKeySystem();
1032 }
1033
1034 /**
1035 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_023.
1036 * @tc.desc: test of DrmAdapterImpl :: GetSessionIdByEmeId
1037 * @tc.type: FUNC.
1038 * @tc.require:
1039 */
1040 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_023, TestSize.Level1)
1041 {
1042 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1043 std::string mimeType = "video/mp4";
1044 int32_t sessionType = 1;
1045
1046 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1047 auto sessionId = g_adapter->GetSessionIdByEmeId(validSessionId->EmeId());
1048
1049 EXPECT_NE(sessionId, nullptr);
1050 EXPECT_EQ(sessionId->EmeId(), validSessionId->EmeId());
1051
1052 sessionId = g_adapter->GetSessionIdByEmeId("invalid_eme_id");
1053 EXPECT_EQ(sessionId, nullptr);
1054 }
1055
1056 /**
1057 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_024.
1058 * @tc.desc: test of DrmAdapterImpl :: RemoveSessionInfo
1059 * @tc.type: FUNC.
1060 * @tc.require:
1061 */
1062 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_024, TestSize.Level1)
1063 {
1064 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1065 std::string mimeType = "video/mp4";
1066 int32_t sessionType = 1;
1067
1068 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1069 auto sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1070 ASSERT_NE(sessionInfo, nullptr);
1071
1072 g_adapter->RemoveSessionInfo(validSessionId);
1073 sessionInfo = g_adapter->GetSessionInfo(validSessionId);
1074 EXPECT_EQ(sessionInfo, nullptr);
1075 }
1076
1077 /**
1078 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_026.
1079 * @tc.desc: test of DrmAdapterImpl :: SetKeyType
1080 * @tc.type: FUNC.
1081 * @tc.require:
1082 */
1083 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_026, TestSize.Level1)
1084 {
1085 std::vector<uint8_t> keySetId = { 0x01, 0x02, 0x03 };
1086 auto sessionId = std::make_shared<SessionId>("sessionId", keySetId.data(), keySetId.size());
1087 auto sessionInfo = std::make_shared<SessionInfo>(
1088 sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1089 g_adapter->SetKeyType(nullptr, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1090 g_adapter->RegistDrmCallback(mockCallback_);
1091 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1092 g_adapter->RegistDrmCallback(mockCallback_);
1093 g_adapter->PutSessionInfo(sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1094 EXPECT_CALL(*mockCallback_, OnStorageSaveInfo(_, _, _, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE)))
1095 .Times(1);
1096 g_adapter->SetKeyType(sessionId, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1097 g_adapter->RemoveSessionInfo(sessionId);
1098 g_adapter->ReleaseMediaKeySession();
1099 g_adapter->ReleaseMediaKeySystem();
1100 }
1101
1102 /**
1103 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_027.
1104 * @tc.desc: test of DrmAdapterImpl :: SetKeySetId
1105 * @tc.type: FUNC.
1106 * @tc.require:
1107 */
1108 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_027, TestSize.Level1)
1109 {
1110 auto sessionId = std::make_shared<SessionId>("sessionId", nullptr, 0);
1111 unsigned char mediaKeyId[] = { 0x01, 0x02, 0x03 };
1112 g_adapter->SetKeySetId(sessionId, mediaKeyId, sizeof(mediaKeyId));
1113 g_adapter->RegistDrmCallback(mockCallback_);
1114 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1115 g_adapter->RegistDrmCallback(mockCallback_);
1116 g_adapter->PutSessionInfo(sessionId, "mimeType", static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1117 EXPECT_CALL(*mockCallback_, OnStorageSaveInfo(_, _, _, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE)))
1118 .Times(1);
1119 g_adapter->SetKeySetId(sessionId, mediaKeyId, sizeof(mediaKeyId));
1120 g_adapter->RemoveSessionInfo(sessionId);
1121 g_adapter->ReleaseMediaKeySession();
1122 g_adapter->ReleaseMediaKeySystem();
1123 }
1124
1125 /**
1126 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_028.
1127 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1128 * @tc.type: FUNC.
1129 * @tc.require:
1130 */
1131 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_028, TestSize.Level1)
1132 {
1133 auto sessionId = std::make_shared<SessionId>("sessionId", nullptr, 0);
1134 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, "sessionId")).Times(0);
1135 g_adapter->LoadSessionWithLoadedStorage(sessionId, 1);
1136 }
1137
1138 /**
1139 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_029.
1140 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1141 * @tc.type: FUNC.
1142 * @tc.require:
1143 */
1144 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_029, TestSize.Level1)
1145 {
1146 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1147 std::string mimeType = "video/mp4";
1148 uint32_t promiseId = 1;
1149 g_adapter->RegistDrmCallback(mockCallback_);
1150 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1151 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1152 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(1);
1153 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1154 g_adapter->RemoveSessionInfo(validSessionId);
1155 g_adapter->ReleaseMediaKeySession();
1156 g_adapter->ReleaseMediaKeySystem();
1157 }
1158
1159 /**
1160 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_030.
1161 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1162 * @tc.type: FUNC.
1163 * @tc.require:
1164 */
1165 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_030, TestSize.Level1)
1166 {
1167 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1168 std::string mimeType = "video/mp4";
1169 uint32_t promiseId = 1; // Example promiseId
1170 g_adapter->RegistDrmCallback(mockCallback_);
1171 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1172 g_adapter->RegistDrmCallback(mockCallback_);
1173 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_ONLINE));
1174
1175 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, "sessionId")).Times(0);
1176 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1177 g_adapter->RemoveSessionInfo(validSessionId);
1178 g_adapter->ReleaseMediaKeySession();
1179 g_adapter->ReleaseMediaKeySystem();
1180 }
1181
1182 /**
1183 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_031.
1184 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1185 * @tc.type: FUNC.
1186 * @tc.require:
1187 */
1188 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_031, TestSize.Level1)
1189 {
1190 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1191 std::string mimeType = "video/mp4";
1192 uint32_t promiseId = 1;
1193 g_adapter->RegistDrmCallback(mockCallback_);
1194 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1195 g_adapter->RegistDrmCallback(mockCallback_);
1196 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1197 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1198 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, "sessionId")).Times(0);
1199 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1200 g_adapter->ReleaseMediaKeySession();
1201 g_adapter->ReleaseMediaKeySystem();
1202 }
1203
1204 /**
1205 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_032.
1206 * @tc.desc: test of DrmAdapterImpl :: LoadSessionWithLoadedStorage
1207 * @tc.type: FUNC.
1208 * @tc.require:
1209 */
1210 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_032, TestSize.Level1)
1211 {
1212 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1213 std::string mimeType = "video/mp4";
1214 uint32_t promiseId = 1; // Example promiseId
1215 g_adapter->RegistDrmCallback(mockCallback_);
1216 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1217 g_adapter->RegistDrmCallback(mockCallback_);
1218 int32_t certStatus = -1;
1219 g_adapter->GetCertificateStatus(certStatus);
1220 if (certStatus == 0) {
1221 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_OFFLINE));
1222 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1223 EXPECT_CALL(*mockCallback_, OnStorageClearInfoForLoadFail(_)).Times(1);
1224 g_adapter->LoadSessionWithLoadedStorage(validSessionId, promiseId);
1225 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1226 } else {
1227 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1228 }
1229 g_adapter->ReleaseMediaKeySession();
1230 g_adapter->ReleaseMediaKeySystem();
1231 }
1232
1233 /**
1234 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_033.
1235 * @tc.desc: test of DrmAdapterImpl :: HandleKeyUpdatedCallback
1236 * @tc.type: FUNC.
1237 * @tc.require:
1238 */
1239 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_033, TestSize.Level1)
1240 {
1241 uint32_t promiseId = 2;
1242 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
1243 g_adapter->RegistDrmCallback(mockCallback_);
1244 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1245 g_adapter->HandleKeyUpdatedCallback(promiseId, true);
1246
1247 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1248
1249 g_adapter->HandleKeyUpdatedCallback(promiseId, false);
1250 g_adapter->ReleaseMediaKeySession();
1251 g_adapter->ReleaseMediaKeySystem();
1252 }
1253
1254 /**
1255 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_035.
1256 * @tc.desc: test of DrmAdapterImpl :: ProcessKeySystemResponse
1257 * @tc.type: FUNC.
1258 * @tc.require:
1259 */
1260 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_035, TestSize.Level1)
1261 {
1262 std::string response = "valid_response";
1263 int32_t result = g_adapter->ProcessKeySystemResponse(response, true);
1264 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1265 g_adapter->RegistDrmCallback(mockCallback_);
1266 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1267 result = g_adapter->ProcessKeySystemResponse(response, false);
1268 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1269 g_adapter->ReleaseMediaKeySession();
1270 g_adapter->ReleaseMediaKeySystem();
1271 }
1272
1273 /**
1274 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_039.
1275 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1276 * @tc.type: FUNC.
1277 * @tc.require:
1278 */
1279 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_039, TestSize.Level1)
1280 {
1281 DRM_EventType eventType = EVENT_DRM_BASE;
1282 uint8_t info[] = { 0 };
1283 int32_t infoLen = sizeof(info);
1284 char extra[] = "extra";
1285
1286 EXPECT_CALL(*mockCallback_, OnProvisionRequest(testing::_, testing::_)).Times(0);
1287
1288 MediaKeySystem* drmKeySystem = nullptr;
1289 auto result = g_adapter->SystemCallBackWithObj(drmKeySystem, eventType, info, infoLen, extra);
1290 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1291 }
1292
1293 /**
1294 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_040.
1295 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1296 * @tc.type: FUNC.
1297 * @tc.require:
1298 */
1299 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_040, TestSize.Level1)
1300 {
1301 uint8_t info[10] = { 0 };
1302 char extra[10] = "extra";
1303 DRM_EventType eventType = EVENT_DRM_BASE;
1304 int32_t infoLen = sizeof(info);
1305 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1306
1307 Drm_ErrCode ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1308 EXPECT_EQ(ret, DRM_ERR_INVALID_VAL);
1309
1310 g_adapter->mediaKeySystemCallbackMap_.clear();
1311 ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1312 EXPECT_EQ(ret, DRM_ERR_INVALID_VAL);
1313
1314 g_adapter->ReleaseMediaKeySession();
1315 g_adapter->ReleaseMediaKeySystem();
1316 }
1317
1318 /**
1319 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_041.
1320 * @tc.desc: test of DrmAdapterImpl :: SessoinEventCallBackWithObj
1321 * @tc.type: FUNC.
1322 * @tc.require:
1323 */
1324 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_041, TestSize.Level1)
1325 {
1326 DRM_EventType eventType = EVENT_DRM_BASE;
1327 uint8_t info[] = { 0 };
1328 int32_t infoLen = sizeof(info);
1329 char extra[] = "extra";
1330 MediaKeySession* mediaKeySession = nullptr;
1331
1332 Drm_ErrCode result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1333 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1334 }
1335
1336 /**
1337 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_042.
1338 * @tc.desc: test of DrmAdapterImpl :: SessoinKeyChangeCallBackWithObj
1339 * @tc.type: FUNC.
1340 * @tc.require:
1341 */
1342 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_042, TestSize.Level1)
1343 {
1344 bool newKeysAvailable = true;
1345 DRM_KeysInfo keysInfo;
1346 MediaKeySession* mediaKeySession = nullptr;
1347
1348 Drm_ErrCode result = g_adapter->SessoinKeyChangeCallBackWithObj(mediaKeySession, &keysInfo, newKeysAvailable);
1349
1350 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1351 }
1352
1353 /**
1354 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_043.
1355 * @tc.desc: test of DrmAdapterImpl :: GetSecurityLevel
1356 * @tc.type: FUNC.
1357 * @tc.require:
1358 */
1359 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_043, TestSize.Level1)
1360 {
1361 EXPECT_EQ(g_adapter->GetSecurityLevel(), -1);
1362 if (g_isSupportDrm) {
1363 g_adapter->RegistDrmCallback(mockCallback_);
1364 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1365 int32_t certStatus = -1;
1366 g_adapter->GetCertificateStatus(certStatus);
1367 if (certStatus == 0) {
1368 EXPECT_NE(g_adapter->GetSecurityLevel(), -1);
1369 } else {
1370 EXPECT_EQ(g_adapter->GetSecurityLevel(), -1);
1371 }
1372 g_adapter->ReleaseMediaKeySession();
1373 g_adapter->ReleaseMediaKeySystem();
1374 }
1375 }
1376
1377 /**
1378 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_044.
1379 * @tc.desc: test of DrmAdapterImpl :: RequireSecureDecoderModule
1380 * @tc.type: FUNC.
1381 * @tc.require:
1382 */
1383 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_044, TestSize.Level1)
1384 {
1385 std::string mimeType = "video/avc";
1386 bool status = false;
1387 int32_t result = g_adapter->RequireSecureDecoderModule(mimeType, status);
1388 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1389 result = g_adapter->RequireSecureDecoderModule("", status);
1390 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_ERROR));
1391 if (g_isSupportDrm) {
1392 g_adapter->RegistDrmCallback(mockCallback_);
1393 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1394 result = g_adapter->RequireSecureDecoderModule(mimeType, status);
1395 int32_t certStatus = -1;
1396 g_adapter->GetCertificateStatus(certStatus);
1397 if (certStatus == 0) {
1398 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1399 } else {
1400 EXPECT_NE(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1401 }
1402 g_adapter->ReleaseMediaKeySession();
1403 g_adapter->ReleaseMediaKeySystem();
1404 }
1405 }
1406
1407 /**
1408 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_045.
1409 * @tc.desc: test of DrmAdapterImpl :: GetUUID
1410 * @tc.type: FUNC.
1411 * @tc.require:
1412 */
1413 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_045, TestSize.Level1)
1414 {
1415 if (g_isSupportDrm) {
1416 std::string name = GetKeySystemName();
1417 auto result = g_adapter->GetUUID(name);
1418 EXPECT_EQ(result.empty(), false);
1419
1420 result = g_adapter->GetUUID("com.test.drm");
1421 EXPECT_NE(result.empty(), false);
1422 } else {
1423 std::string name = GetKeySystemName();
1424 auto result = g_adapter->GetUUID(name);
1425 EXPECT_NE(result.empty(), false);
1426 }
1427 }
1428
1429 /**
1430 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_046.
1431 * @tc.desc: test of DrmAdapterImpl :: StorageProvisionedResult
1432 * @tc.type: FUNC.
1433 * @tc.require:
1434 */
1435 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_046, TestSize.Level1)
1436 {
1437 g_adapter->StorageProvisionedResult(false);
1438 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1439
1440 if (g_isSupportDrm) {
1441 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1442 g_adapter->RegistDrmCallback(mockCallback_);
1443 g_adapter->contentProtectionLevel_ = CONTENT_PROTECTION_LEVEL_SW_CRYPTO;
1444
1445 int32_t certStatus = -1;
1446 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1447 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1448 if (certStatus == 0) {
1449 g_adapter->ReleaseMediaKeySession();
1450 g_adapter->StorageProvisionedResult(true);
1451 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1452 }
1453 g_adapter->ReleaseMediaKeySession();
1454 g_adapter->ReleaseMediaKeySystem();
1455 }
1456 }
1457
1458 /**
1459 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_047.
1460 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1461 * @tc.type: FUNC.
1462 * @tc.require:
1463 */
1464 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_047, TestSize.Level1)
1465 {
1466 g_adapter->StorageSaveInfoResult(true, 1);
1467 g_adapter->RegistDrmCallback(mockCallback_);
1468 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
1469 g_adapter->StorageSaveInfoResult(true, 1);
1470 }
1471
1472 /**
1473 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_048.
1474 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1475 * @tc.type: FUNC.
1476 * @tc.require:
1477 */
1478 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_048, TestSize.Level1)
1479 {
1480 g_adapter->StorageSaveInfoResult(false, 1);
1481 g_adapter->RegistDrmCallback(mockCallback_);
1482 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1483 g_adapter->StorageSaveInfoResult(false, 1);
1484 }
1485
1486 /**
1487 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_055.
1488 * @tc.desc: test of DrmAdapterImpl :: CloseSession
1489 * @tc.type: FUNC.
1490 * @tc.require:
1491 */
1492 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_055, TestSize.Level1)
1493 {
1494 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0);
1495 uint32_t promiseId = 1;
1496 std::string emeId = "test_eme_id";
1497 g_adapter->RegistDrmCallback(mockCallback_);
1498 int32_t result = g_adapter->CloseSession(promiseId, emeId);
1499 EXPECT_EQ(result, -1);
1500 if (g_isSupportDrm) {
1501 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1502 result = g_adapter->CloseSession(promiseId, emeId);
1503 EXPECT_EQ(result, -1);
1504 std::string mimeType = "video/mp4";
1505 int32_t sessionType = 1; // Assume valid session type
1506 g_adapter->PutSessionInfo(validSessionId, mimeType, sessionType);
1507 result = g_adapter->CloseSession(promiseId, emeId);
1508 EXPECT_EQ(result, 0);
1509 g_adapter->RemoveSessionInfo(validSessionId);
1510 g_adapter->ReleaseMediaKeySession();
1511 g_adapter->ReleaseMediaKeySystem();
1512 }
1513 }
1514
1515 /**
1516 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_056.
1517 * @tc.desc: test of DrmAdapterImpl :: RemoveSession
1518 * @tc.type: FUNC.
1519 * @tc.require:
1520 */
1521 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_056, TestSize.Level1)
1522 {
1523 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1524 std::string mimeType = "video/mp4";
1525 uint32_t promiseId = 1;
1526 std::string emeId = "test_eme_id";
1527 g_adapter->RegistDrmCallback(mockCallback_);
1528 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1529 g_adapter->PutSessionInfo(validSessionId, mimeType, MEDIA_KEY_TYPE_ONLINE);
1530 int32_t result = g_adapter->RemoveSession(promiseId, "invalid_eme_id");
1531 EXPECT_EQ(result, -1);
1532
1533 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1534 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1535 result = g_adapter->RemoveSession(promiseId, emeId);
1536 EXPECT_EQ(result, 0);
1537 g_adapter->ReleaseMediaKeySession();
1538 g_adapter->ReleaseMediaKeySystem();
1539 }
1540
1541 /**
1542 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_057.
1543 * @tc.desc: test of DrmAdapterImpl :: LoadSession
1544 * @tc.type: FUNC.
1545 * @tc.require:
1546 */
1547 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_057, TestSize.Level1)
1548 {
1549 uint32_t promiseId = 1;
1550 std::string sessionId = "sessionId";
1551 int32_t result = g_adapter->LoadSession(promiseId, sessionId);
1552 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1553
1554 g_adapter->RegistDrmCallback(mockCallback_);
1555 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1556
1557 result = g_adapter->LoadSession(promiseId, sessionId);
1558 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1559 g_adapter->ReleaseMediaKeySession();
1560 g_adapter->ReleaseMediaKeySystem();
1561 }
1562
1563 /**
1564 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_058.
1565 * @tc.desc: test of DrmAdapterImpl :: UpdateSession
1566 * @tc.type: FUNC.
1567 * @tc.require:
1568 */
1569 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_058, TestSize.Level1)
1570 {
1571 uint32_t promiseId = 1;
1572 std::string emeId = "test_eme_id";
1573 std::vector<uint8_t> response = { 0x01, 0x02, 0x03 }; // Example response data
1574 auto validSessionId = std::make_shared<SessionId>("test_eme_id", nullptr, 0); // Assume this constructor exists
1575 std::string mimeType = "video/mp4";
1576 int32_t result = g_adapter->UpdateSession(promiseId, emeId, response);
1577 EXPECT_EQ(result, -1);
1578 g_adapter->RegistDrmCallback(mockCallback_);
1579 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1580
1581 g_adapter->PutSessionInfo(validSessionId, mimeType, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1582 result = g_adapter->UpdateSession(promiseId, emeId, response);
1583 EXPECT_EQ(result, -1);
1584 g_adapter->RemoveSessionInfo(validSessionId);
1585 g_adapter->ReleaseMediaKeySession();
1586 g_adapter->ReleaseMediaKeySystem();
1587 }
1588
1589 /**
1590 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_059.
1591 * @tc.desc: test of DrmAdapterImpl::OnSessionExpirationUpdate
1592 * @tc.type: FUNC.
1593 * @tc.require:
1594 */
1595 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_059, TestSize.Level1)
1596 {
1597 g_adapter->callback_ = nullptr;
1598 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1599 if (g_isSupportDrm) {
1600 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1601 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, nullptr, 0);
1602 g_adapter->ReleaseMediaKeySession();
1603 g_adapter->ReleaseMediaKeySystem();
1604 g_adapter->RegistDrmCallback(mockCallback_);
1605 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1606 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1607 int32_t certStatus = -1;
1608 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1609 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1610 if (certStatus == 0) {
1611 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1612 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(_, _)).Times(1);
1613 std::string infoString = "123456ms";
1614 uint32_t infoSize = infoString.size();
1615 uint8_t info[32] = { 0 };
1616 errno_t ret = memcpy_s(info, infoSize, infoString.data(), infoSize);
1617 EXPECT_EQ(ret, EOK);
1618 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, infoSize);
1619 } else {
1620 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1621 }
1622 g_adapter->ReleaseMediaKeySession();
1623 g_adapter->ReleaseMediaKeySystem();
1624 } else {
1625 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1626 }
1627 }
1628
1629 /**
1630 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_060.
1631 * @tc.desc: test of DrmAdapterImpl::GetKeyRequest
1632 * @tc.type: FUNC.
1633 * @tc.require:
1634 */
1635 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_060, TestSize.Level1)
1636 {
1637 uint8_t info[10] = { 0 };
1638 int32_t infoLen = sizeof(info);
1639 g_adapter->GetKeyRequest(nullptr, info, infoLen);
1640 g_adapter->RegistDrmCallback(mockCallback_);
1641 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1642 if (g_isSupportDrm) {
1643 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1644
1645 int32_t certStatus = -1;
1646 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1647 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1648
1649 if (certStatus == 0 && g_isWisePlay) {
1650 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1651 g_adapter->GetKeyRequest(g_adapter->drmKeySessoin_, info, infoLen);
1652
1653 g_adapter->callback_ = nullptr;
1654 g_adapter->GetKeyRequest(g_adapter->drmKeySessoin_, info, infoLen);
1655 }
1656 g_adapter->ReleaseMediaKeySession();
1657 g_adapter->ReleaseMediaKeySystem();
1658 } else {
1659 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1660 }
1661 }
1662
1663 /**
1664 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_061.
1665 * @tc.desc: test of DrmAdapterImpl :: SessoinEventCallBackWithObj
1666 * @tc.type: FUNC.
1667 * @tc.require:
1668 */
1669 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_061, TestSize.Level1)
1670 {
1671 DRM_EventType eventType = EVENT_KEY_REQUIRED;
1672 uint8_t info[] = { 0 };
1673 int32_t infoLen = sizeof(info);
1674 char extra[] = "extra";
1675 MediaKeySession* mediaKeySession = nullptr;
1676
1677 Drm_ErrCode result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1678 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1679
1680 eventType = EVENT_EXPIRATION_UPDATE;
1681 result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1682 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1683
1684 eventType = EVENT_PROVISION_REQUIRED;
1685 result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1686 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1687
1688 eventType = EVENT_KEY_EXPIRED;
1689 result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1690 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1691
1692 eventType = EVENT_VENDOR_DEFINED;
1693 result = g_adapter->SessoinEventCallBackWithObj(mediaKeySession, eventType, info, infoLen, extra);
1694 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1695
1696 result =
1697 g_adapter->SessoinEventCallBackWithObj(mediaKeySession, static_cast<DRM_EventType>(0), info, infoLen, extra);
1698 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1699 }
1700
1701 /**
1702 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_062.
1703 * @tc.desc: test of DrmAdapterImpl :: SessoinKeyChangeCallBackWithObj
1704 * @tc.type: FUNC.
1705 * @tc.require:
1706 */
1707 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_062, TestSize.Level1)
1708 {
1709 bool newKeysAvailable = true;
1710 DRM_KeysInfo keysInfo;
1711 keysInfo.keysInfoCount = 0;
1712
1713 Drm_ErrCode result =
1714 g_adapter->SessoinKeyChangeCallBackWithObj(g_adapter->drmKeySessoin_, nullptr, newKeysAvailable);
1715 EXPECT_EQ(result, DRM_ERR_INVALID_VAL);
1716
1717 if (g_isSupportDrm) {
1718 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1719 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1720
1721 int32_t certStatus = -1;
1722 int32_t certResult = g_adapter->GetCertificateStatus(certStatus);
1723 EXPECT_EQ(certResult, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1724
1725 if (certStatus == 0) {
1726 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1727 g_adapter->RegistDrmCallback(mockCallback_);
1728 result = g_adapter->SessoinKeyChangeCallBackWithObj(g_adapter->drmKeySessoin_, &keysInfo, newKeysAvailable);
1729 EXPECT_EQ(result, DRM_ERR_OK);
1730 }
1731 g_adapter->ReleaseMediaKeySession();
1732 g_adapter->ReleaseMediaKeySystem();
1733 } else {
1734 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1735 }
1736 }
1737
1738 /**
1739 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_063.
1740 * @tc.desc: test of DrmAdapterImpl::StorageLoadInfoResult
1741 * @tc.type: FUNC.
1742 * @tc.require:
1743 */
1744 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_063, TestSize.Level1)
1745 {
1746 std::vector<uint8_t> keySetId;
1747 keySetId.clear();
1748 g_adapter->callback_ = nullptr;
1749 g_adapter->StorageLoadInfoResult("", keySetId, "", 0);
1750
1751 g_adapter->RegistDrmCallback(mockCallback_);
1752 EXPECT_CALL(*mockCallback_, OnPromiseResolvedWithSession(_, _)).Times(1);
1753 g_adapter->StorageLoadInfoResult("", keySetId, "", 0);
1754 EXPECT_NE(g_adapter->callback_, nullptr);
1755 g_adapter->callback_ = nullptr;
1756 }
1757
1758 /**
1759 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_064.
1760 * @tc.desc: test of DrmAdapterImpl::ClearPersistentSessionInfoFroKeyRelease
1761 * @tc.type: FUNC.
1762 * @tc.require:
1763 */
1764 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_064, TestSize.Level1)
1765 {
1766 g_adapter->ClearPersistentSessionInfoFroKeyRelease(nullptr);
1767
1768 auto sessionId = SessionId::CreateSessionId("testSessionId");
1769 g_adapter->RegistDrmCallback(mockCallback_);
1770 EXPECT_CALL(*mockCallback_, OnStorageClearInfoForKeyRelease(_)).Times(1);
1771 g_adapter->ClearPersistentSessionInfoFroKeyRelease(sessionId);
1772 }
1773
1774 /**
1775 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_065.
1776 * @tc.desc: test of DrmAdapterImpl :: SystemCallBackWithObj
1777 * @tc.type: FUNC.
1778 * @tc.require:
1779 */
1780 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_065, TestSize.Level1)
1781 {
1782 uint8_t info[10] = { 0 };
1783 char extra[10] = "extra";
1784 DRM_EventType eventType = EVENT_DRM_BASE;
1785 int32_t infoLen = sizeof(info);
1786 g_adapter->RegistDrmCallback(mockCallback_);
1787 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1788 if (g_isSupportDrm) {
1789 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1790 auto ret = g_adapter->SystemCallBackWithObj(g_adapter->drmKeySystem_, eventType, info, infoLen, extra);
1791 EXPECT_EQ(ret, DRM_ERR_OK);
1792 g_adapter->ReleaseMediaKeySession();
1793 g_adapter->ReleaseMediaKeySystem();
1794 } else {
1795 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1796 }
1797 }
1798
1799 /**
1800 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_066.
1801 * @tc.desc: test of DrmAdapterImpl :: SessoinKeyChangeCallBackWithObj
1802 * @tc.type: FUNC.
1803 * @tc.require:
1804 */
1805 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_066, TestSize.Level1)
1806 {
1807 bool newKeysAvailable = true;
1808 DRM_KeysInfo keysInfo;
1809 keysInfo.keysInfoCount = 2;
1810 (void)memset_s(keysInfo.keyId[0], MAX_KEY_ID_LEN, 0x00, MAX_KEY_ID_LEN);
1811 (void)memset_s(keysInfo.keyId[1], MAX_KEY_ID_LEN, 0x00, MAX_KEY_ID_LEN);
1812 std::string keyStatus = "USABLE";
1813 uint32_t statusSize = keyStatus.size();
1814 (void)memset_s(keysInfo.statusValue[0], MAX_KEY_STATUS_VALUE_LEN, 0x00, MAX_KEY_STATUS_VALUE_LEN);
1815 errno_t ret = memcpy_s(keysInfo.statusValue[0], statusSize, keyStatus.data(), statusSize);
1816 EXPECT_EQ(ret, EOK);
1817
1818 std::string keyStatus2 = "XXXX";
1819 uint32_t statusSize2 = keyStatus2.size();
1820 (void)memset_s(keysInfo.statusValue[1], MAX_KEY_STATUS_VALUE_LEN, 0x00, MAX_KEY_STATUS_VALUE_LEN);
1821 ret = memcpy_s(keysInfo.statusValue[1], statusSize2, keyStatus2.data(), statusSize2);
1822 EXPECT_EQ(ret, EOK);
1823
1824 g_adapter->RegistDrmCallback(mockCallback_);
1825 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1826 if (g_isSupportDrm) {
1827 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1828
1829 int32_t certStatus = -1;
1830 int32_t certResult = g_adapter->GetCertificateStatus(certStatus);
1831 EXPECT_EQ(certResult, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1832
1833 if (certStatus == 0) {
1834 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1835 auto result =
1836 g_adapter->SessoinKeyChangeCallBackWithObj(g_adapter->drmKeySessoin_, &keysInfo, newKeysAvailable);
1837 EXPECT_EQ(result, DRM_ERR_OK);
1838 }
1839 g_adapter->ReleaseMediaKeySession();
1840 g_adapter->ReleaseMediaKeySystem();
1841 } else {
1842 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1843 }
1844 }
1845
1846 /**
1847 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_067.
1848 * @tc.desc: test of DrmAdapterImpl :: StorageSaveInfoResult
1849 * @tc.type: FUNC.
1850 * @tc.require:
1851 */
1852 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_067, TestSize.Level1)
1853 {
1854 g_adapter->callback_ = nullptr;
1855 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1856 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1857 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1858
1859 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1860 if (g_isSupportDrm) {
1861 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1862 g_adapter->releaseEmeId_ = "testId_067";
1863 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1864
1865 g_adapter->RegistDrmCallback(mockCallback_);
1866 EXPECT_NE(g_adapter->callback_, nullptr);
1867
1868 int32_t certStatus = -1;
1869 g_adapter->GetCertificateStatus(certStatus);
1870 if (certStatus == 0) {
1871 EXPECT_CALL(*mockCallback_, OnPromiseRejected(_, _)).Times(1);
1872 g_adapter->StorageSaveInfoResult(true, static_cast<int32_t>(MediaKeyType::MEDIA_KEY_TYPE_RELEASE));
1873 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1874 } else {
1875 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1876 }
1877 g_adapter->ReleaseMediaKeySession();
1878 g_adapter->ReleaseMediaKeySystem();
1879 } else {
1880 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1881 }
1882 }
1883
1884 /**
1885 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_068.
1886 * @tc.desc: test of DrmAdapterImpl::UpdateSessionResult
1887 * @tc.type: FUNC.
1888 * @tc.require:
1889 */
1890 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_068, TestSize.Level1)
1891 {
1892 g_adapter->UpdateSessionResult(false, nullptr, nullptr, 0);
1893 auto sessionId = SessionId::CreateSessionId("tempSessionId068");
1894 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
1895
1896 std::string mimeType = "video/mp4";
1897 int32_t sessionType = 1;
1898
1899 g_adapter->callback_ = nullptr;
1900 g_adapter->PutSessionInfo(sessionId, mimeType, sessionType);
1901
1902 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
1903 g_adapter->RegistDrmCallback(mockCallback_);
1904 EXPECT_CALL(*mockCallback_, OnPromiseResolved(_)).Times(1);
1905 g_adapter->UpdateSessionResult(false, sessionId, nullptr, 0);
1906 EXPECT_NE(g_adapter->callback_, nullptr);
1907 EXPECT_EQ(g_adapter->callback_->EmeId(), "tempSessionId068");
1908 }
1909
1910 /**
1911 * @tc.name: DrmAdapterImplTest_DrmAdapterImpl_069.
1912 * @tc.desc: test of DrmAdapterImpl::OnSessionExpirationUpdate
1913 * @tc.type: FUNC.
1914 * @tc.require:
1915 */
1916 HWTEST_F(DrmAdapterImplTest, DrmAdapterImplTest_DrmAdapterImpl_069, TestSize.Level1)
1917 {
1918 g_adapter->RegistDrmCallback(mockCallback_);
1919 g_adapter->CreateKeySystem(GetKeySystemName(), "origin_id", SECURITY_LEVEL_3);
1920 if (g_isSupportDrm) {
1921 EXPECT_NE(g_adapter->drmKeySystem_, nullptr);
1922 int32_t certStatus = -1;
1923 int32_t result = g_adapter->GetCertificateStatus(certStatus);
1924 EXPECT_EQ(result, static_cast<int32_t>(DrmResult::DRM_RESULT_OK));
1925 if (certStatus == 0) {
1926 EXPECT_NE(g_adapter->drmKeySessoin_, nullptr);
1927 EXPECT_CALL(*mockCallback_, OnSessionExpirationUpdate(_, _)).Times(6);
1928 std::string infoString = "123456ms";
1929 uint8_t info[32] = { 0 };
1930 errno_t ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
1931 EXPECT_EQ(ret, EOK);
1932 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, 0);
1933 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, nullptr, 0);
1934 infoString = "12ms";
1935 (void)memset_s(info, 32, 0x00, 32);
1936 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
1937 EXPECT_EQ(ret, EOK);
1938 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, infoString.size());
1939 infoString = "1";
1940 (void)memset_s(info, 32, 0x00, 32);
1941 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
1942 EXPECT_EQ(ret, EOK);
1943 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, infoString.size());
1944 infoString = "abcdms";
1945 (void)memset_s(info, 32, 0x00, 32);
1946 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
1947 EXPECT_EQ(ret, EOK);
1948 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, infoString.size());
1949 infoString = "123456";
1950 (void)memset_s(info, 32, 0x00, 32);
1951 ret = memcpy_s(info, infoString.size(), infoString.data(), infoString.size());
1952 EXPECT_EQ(ret, EOK);
1953 g_adapter->OnSessionExpirationUpdate(g_adapter->drmKeySessoin_, info, infoString.size());
1954 } else {
1955 EXPECT_EQ(g_adapter->drmKeySessoin_, nullptr);
1956 }
1957 g_adapter->ReleaseMediaKeySession();
1958 g_adapter->ReleaseMediaKeySystem();
1959 } else {
1960 EXPECT_EQ(g_adapter->drmKeySystem_, nullptr);
1961 }
1962 }
1963 } // namespace OHOS::NWeb
1964