1 /*
2  * Copyright (c) 2024 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 #define private public
20 #include "media_avsession_adapter.h"
21 #include "media_avsession_adapter_impl.h"
22 
23 using namespace testing;
24 using namespace testing::ext;
25 using namespace OHOS::AVSession;
26 
27 constexpr int32_t RET_ERROR = -1;
28 constexpr int32_t RET_SUCCESS = 0;
29 
30 namespace OHOS::NWeb {
31 namespace {
32 std::shared_ptr<MediaAVSessionCallbackImpl> g_callback;
33 std::shared_ptr<MediaAVSessionKey> g_key;
34 std::shared_ptr<MediaAVSessionAdapterImpl> g_adapter;
35 } // namespace
36 
37 class AVSessionMock : public AVSession::AVSession {
38 public:
39     AVSessionMock() = default;
40     MOCK_METHOD0(GetSessionId, std::string());
41     MOCK_METHOD0(GetSessionType, std::string());
42     MOCK_METHOD1(GetAVMetaData, int32_t(AVMetaData&));
43     MOCK_METHOD1(SetAVMetaData, int32_t(const AVMetaData&));
44     MOCK_METHOD1(SetAVCallMetaData, int32_t(const AVCallMetaData& meta));
45     MOCK_METHOD1(SetAVCallState, int32_t(const AVCallState& avCallState));
46     MOCK_METHOD1(GetAVPlaybackState, int32_t(AVPlaybackState& state));
47     MOCK_METHOD1(SetAVPlaybackState, int32_t(const AVPlaybackState& state));
48     MOCK_METHOD1(GetAVQueueItems, int32_t(std::vector<AVQueueItem>&));
49     MOCK_METHOD1(SetAVQueueItems, int32_t(const std::vector<AVQueueItem>&));
50     MOCK_METHOD1(GetAVQueueTitle, int32_t(std::string&));
51     MOCK_METHOD1(SetAVQueueTitle, int32_t(const std::string&));
52     MOCK_METHOD1(SetLaunchAbility, int32_t(const AbilityRuntime::WantAgent::WantAgent&));
53     MOCK_METHOD1(GetExtras, int32_t(AAFwk::WantParams&));
54     MOCK_METHOD1(SetExtras, int32_t(const AAFwk::WantParams&));
55     MOCK_METHOD0(GetController, std::shared_ptr<AVSessionController>());
56     MOCK_METHOD1(RegisterCallback, int32_t(const std::shared_ptr<AVSessionCallback>&));
57     MOCK_METHOD0(Activate, int32_t());
58     MOCK_METHOD0(Deactivate, int32_t());
59     MOCK_METHOD0(IsActive, bool());
60     MOCK_METHOD0(Destroy, int32_t());
61     MOCK_METHOD1(AddSupportCommand, int32_t(const int32_t));
62     MOCK_METHOD1(DeleteSupportCommand, int32_t(const int32_t));
63     MOCK_METHOD2(SetSessionEvent, int32_t(const std::string&, const AAFwk::WantParams&));
64 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
65     MOCK_METHOD0(GetAVCastController, std::shared_ptr<AVCastController>());
66     MOCK_METHOD0(ReleaseCast, int32_t());
67     MOCK_METHOD0(StartCastDisplayListener, int32_t());
68     MOCK_METHOD0(StopCastDisplayListener, int32_t());
69     MOCK_METHOD1(GetAllCastDisplays, int32_t(std::vector<CastDisplayInfo>&));
70 #endif
71 };
72 
73 class MediaAVSessionCallbackAdapterMock : public MediaAVSessionCallbackAdapter {
74 public:
75     MediaAVSessionCallbackAdapterMock() = default;
Play()76     void Play() {};
Pause()77     void Pause() {};
Stop()78     void Stop() {};
SeekTo(int64_t millisTime)79     void SeekTo(int64_t millisTime) {};
80 };
81 
82 class MediaAVSessionAdapterImplMock : public MediaAVSessionAdapterImpl {
83 public:
84     MediaAVSessionAdapterImplMock() = default;
85     ~MediaAVSessionAdapterImplMock() = default;
86     MOCK_METHOD0(Activate, bool());
87 };
88 
89 class MetaDataMock : public OHOS::NWeb::MediaAVSessionMetadataAdapter {
90 public:
91     MOCK_METHOD0(GetTitle, std::string());
92     MOCK_METHOD1(SetTitle, void(const std::string& title));
93     MOCK_METHOD0(GetArtist, std::string());
94     MOCK_METHOD1(SetArtist, void(const std::string& artist));
95     MOCK_METHOD0(GetAlbum, std::string());
96     MOCK_METHOD1(SetAlbum, void(const std::string& album));
97 };
98 class PositionMock : public OHOS::NWeb::MediaAVSessionPositionAdapter {
99 public:
100     MOCK_METHOD0(GetDuration, int64_t());
101     MOCK_METHOD1(SetDuration, void(int64_t duration));
102     MOCK_METHOD0(GetElapsedTime, int64_t());
103     MOCK_METHOD1(SetElapsedTime, void(int64_t elapsedTime));
104     MOCK_METHOD0(GetUpdateTime, int64_t());
105     MOCK_METHOD1(SetUpdateTime, void(int64_t updateTime));
106 };
107 
108 class MediaAVSessionMetadataAdapterMock : public MediaAVSessionMetadataAdapter {
109 public:
110     MediaAVSessionMetadataAdapterMock() = default;
111 
112     ~MediaAVSessionMetadataAdapterMock() = default;
113 
114     MOCK_METHOD1(SetTitle, void(const std::string& title));
115     MOCK_METHOD0(GetTitle, std::string());
116     MOCK_METHOD1(SetArtist, void(const std::string& artist));
117     MOCK_METHOD0(GetArtist, std::string());
118     MOCK_METHOD1(SetAlbum, void(const std::string& album));
119     MOCK_METHOD0(GetAlbum, std::string());
120 };
121 
122 class AVPlaybackStateMock : public AVPlaybackState {
123 public:
124     AVPlaybackStateMock() = default;
125     ~AVPlaybackStateMock() = default;
126     MOCK_METHOD0(GetState, int32_t());
127     MOCK_METHOD1(SetState, void(int32_t));
128 };
129 
130 class AVMetaDataMock : public AVMetaData {
131 public:
132     AVMetaDataMock() = default;
133 
134     ~AVMetaDataMock() = default;
135 
136     MOCK_METHOD1(SetTitle, void(const std::string& title));
137     MOCK_METHOD0(GetTitle, std::string());
138 
139     MOCK_METHOD1(SetArtist, void(const std::string& artist));
140     MOCK_METHOD0(GetArtist, std::string());
141 
142     MOCK_METHOD1(SetAlbum, void(const std::string& album));
143     MOCK_METHOD0(GetAlbum, std::string());
144 
145     MOCK_METHOD1(SetDuration, void(const int64_t& duration));
146     MOCK_METHOD0(GetDuration, int64_t());
147 };
148 
149 class MediaAVSessionPositionAdapterMock : public MediaAVSessionPositionAdapter {
150 public:
151     MediaAVSessionPositionAdapterMock() = default;
152 
153     ~MediaAVSessionPositionAdapterMock() = default;
154 
155     MOCK_METHOD1(SetDuration, void(int64_t duration));
156     MOCK_METHOD0(GetDuration, int64_t());
157 
158     MOCK_METHOD1(SetElapsedTime, void(int64_t elapsedTime));
159     MOCK_METHOD0(GetElapsedTime, int64_t());
160 
161     MOCK_METHOD1(SetUpdateTime, void(int64_t updateTime));
162     MOCK_METHOD0(GetUpdateTime, int64_t());
163 };
164 
165 class MediaAVSessionKeyMock : public MediaAVSessionKey {
166 public:
167     MediaAVSessionKeyMock() = default;
168 
169     ~MediaAVSessionKeyMock() = default;
170 
171     MOCK_METHOD0(GetElement, std::shared_ptr<AppExecFwk::ElementName>());
172 };
173 
174 class MediaAVSessionCallbackImplTest : public testing::Test {
175 public:
176     static void SetUpTestCase(void);
177     static void TearDownTestCase(void);
178     void SetUp();
179     void TearDown();
180 };
181 
182 class MediaAVSessionKeyTest : public testing::Test {
183 public:
184     static void SetUpTestCase(void);
185     static void TearDownTestCase(void);
186     void SetUp();
187     void TearDown();
188 };
189 
190 class MediaAVSessionAdapterImplTest : public testing::Test {
191 public:
192     static void SetUpTestCase(void);
193     static void TearDownTestCase(void);
194     void SetUp();
195     void TearDown();
196 };
197 
SetUpTestCase(void)198 void MediaAVSessionCallbackImplTest::SetUpTestCase(void) {}
199 
TearDownTestCase(void)200 void MediaAVSessionCallbackImplTest::TearDownTestCase(void) {}
201 
SetUp(void)202 void MediaAVSessionCallbackImplTest::SetUp(void)
203 {
204     std::shared_ptr<MediaAVSessionCallbackAdapterMock> mediaAvSessionCB;
205     g_callback = std::make_shared<MediaAVSessionCallbackImpl>(mediaAvSessionCB);
206     ASSERT_NE(g_callback, nullptr);
207 }
208 
TearDown(void)209 void MediaAVSessionCallbackImplTest::TearDown(void)
210 {
211     g_callback = nullptr;
212 }
213 
SetUpTestCase(void)214 void MediaAVSessionKeyTest::SetUpTestCase(void) {}
215 
TearDownTestCase(void)216 void MediaAVSessionKeyTest::TearDownTestCase(void) {}
217 
SetUp(void)218 void MediaAVSessionKeyTest::SetUp(void)
219 {
220     g_key = std::make_shared<MediaAVSessionKey>();
221     ASSERT_NE(g_key, nullptr);
222 }
223 
TearDown(void)224 void MediaAVSessionKeyTest::TearDown(void)
225 {
226     g_key = nullptr;
227 }
228 
SetUpTestCase(void)229 void MediaAVSessionAdapterImplTest::SetUpTestCase(void) {}
230 
TearDownTestCase(void)231 void MediaAVSessionAdapterImplTest::TearDownTestCase(void) {}
232 
SetUp(void)233 void MediaAVSessionAdapterImplTest::SetUp(void)
234 {
235     g_adapter = std::make_shared<MediaAVSessionAdapterImpl>();
236     ASSERT_NE(g_adapter, nullptr);
237 }
238 
TearDown(void)239 void MediaAVSessionAdapterImplTest::TearDown(void)
240 {
241     g_adapter = nullptr;
242 }
243 
244 /**
245  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionCallbackImpl_001.
246  * @tc.desc: test of MediaAVSessionCallbackImpl :: Onplay()
247  * @tc.type: FUNC.
248  * @tc.require:
249  */
250 HWTEST_F(MediaAVSessionCallbackImplTest, NWebMediaAdapterTest_MediaAVSessionCallbackImpl_001, TestSize.Level1)
251 {
252     g_callback->callbackAdapter_ = nullptr;
253     g_callback->OnPlay();
254     EXPECT_EQ(g_callback->callbackAdapter_, nullptr);
255 
256     auto callbackMock = std::make_shared<MediaAVSessionCallbackAdapterMock>();
257     g_callback->callbackAdapter_ = callbackMock;
258     g_callback->OnPlay();
259     EXPECT_NE(g_callback->callbackAdapter_, nullptr);
260 }
261 
262 /**
263  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionCallbackImpl_002.
264  * @tc.desc: test of MediaAVSessionCallbackImpl :: OnPause()
265  * @tc.type: FUNC.
266  * @tc.require:
267  */
268 HWTEST_F(MediaAVSessionCallbackImplTest, NWebMediaAdapterTest_MediaAVSessionCallbackImpl_002, TestSize.Level1)
269 {
270     g_callback->callbackAdapter_ = nullptr;
271     g_callback->OnPause();
272     EXPECT_EQ(g_callback->callbackAdapter_, nullptr);
273 
274     auto callbackMock = std::make_shared<MediaAVSessionCallbackAdapterMock>();
275     g_callback->callbackAdapter_ = callbackMock;
276     g_callback->OnPause();
277     EXPECT_NE(g_callback->callbackAdapter_, nullptr);
278 }
279 
280 /**
281  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionCallbackImpl_003.
282  * @tc.desc: test of MediaAVSessionCallbackImpl :: OnStop()
283  * @tc.type: FUNC.
284  * @tc.require:
285  */
286 HWTEST_F(MediaAVSessionCallbackImplTest, NWebMediaAdapterTest_MediaAVSessionCallbackImpl_003, TestSize.Level1)
287 {
288     g_callback->callbackAdapter_ = nullptr;
289     g_callback->OnStop();
290     EXPECT_EQ(g_callback->callbackAdapter_, nullptr);
291 
292     auto callbackMock = std::make_shared<MediaAVSessionCallbackAdapterMock>();
293     g_callback->callbackAdapter_ = callbackMock;
294     g_callback->OnStop();
295     EXPECT_NE(g_callback->callbackAdapter_, nullptr);
296 }
297 /**
298  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionCallbackImpl_004s.
299  * @tc.desc: test of MediaAVSessionCallbackImpl :: OnSeek()
300  * @tc.type: FUNC.
301  * @tc.require:
302  */
303 
304 HWTEST_F(MediaAVSessionCallbackImplTest, NWebMediaAdapterTest_MediaAVSessionCallbackImpl_004, TestSize.Level1)
305 {
306     g_callback->callbackAdapter_ = nullptr;
307     g_callback->OnSeek(100);
308     EXPECT_EQ(g_callback->callbackAdapter_, nullptr);
309 
310     auto callbackMock = std::make_shared<MediaAVSessionCallbackAdapterMock>();
311     g_callback->callbackAdapter_ = callbackMock;
312     g_callback->OnSeek(100);
313     EXPECT_NE(g_callback->callbackAdapter_, nullptr);
314 }
315 
316 /**
317  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_001.
318  * @tc.desc: test of MediaAVSessionKey :: GetType()
319  * @tc.type: FUNC.
320  * @tc.require:
321  */
322 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_001, TestSize.Level1)
323 {
324     auto type = MediaAVSessionType::MEDIA_TYPE_AUDIO;
325     g_key->type_ = type;
326     EXPECT_EQ(g_key->GetType(), type);
327     g_key->Init();
328     EXPECT_NE(g_key->GetType(), type);
329 }
330 
331 /**
332  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_002.
333  * @tc.desc: test of MediaAVSessionKey :: GetPID()
334  * @tc.type: FUNC.
335  * @tc.require:
336  */
337 
338 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_002, TestSize.Level1)
339 {
340     auto pid = 100;
341     g_key->pid_ = pid;
342     auto ret = g_key->GetPID();
343     EXPECT_EQ(ret, pid);
344 }
345 
346 /**
347  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_003.
348  * @tc.desc: test of MediaAVSessionKey :: GetElement()
349  * @tc.type: FUNC.
350  * @tc.require:
351  */
352 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_003, TestSize.Level1)
353 {
354     OHOS::AppExecFwk::ElementName element;
355     g_key->element_ = element;
356     auto ret = g_key->GetElement();
357     EXPECT_EQ(ret, element);
358 }
359 
360 /**
361  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_004.
362  * @tc.desc: test of MediaAVSessionKey :: GetType()
363  * @tc.type: FUNC.
364  * @tc.require:
365  */
366 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_004, TestSize.Level1)
367 {
368     auto type = MediaAVSessionType::MEDIA_TYPE_INVALID;
369     g_key->type_ = type;
370     auto ret = g_key->GetType();
371     EXPECT_EQ(ret, type);
372 }
373 /**
374  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_005.
375  * @tc.desc: test of MediaAVSessionKey :: SetType()
376  * @tc.type: FUNC.
377  * @tc.require:
378  */
379 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_005, TestSize.Level1)
380 {
381     auto type = MediaAVSessionType::MEDIA_TYPE_INVALID;
382     g_key->SetType(type);
383     auto ret = g_key->GetType();
384     EXPECT_EQ(ret, type);
385 }
386 
387 /**
388  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionKey_006.
389  * @tc.desc: test of MediaAVSessionKey :: ToString()
390  * @tc.type: FUNC.
391  * @tc.require:
392  */
393 HWTEST_F(MediaAVSessionKeyTest, NWebMediaAdapterTest_MediaAVSessionKey_006, TestSize.Level1)
394 {
395     auto pid = 100;
396     OHOS::AppExecFwk::ElementName element;
397     auto type = MediaAVSessionType::MEDIA_TYPE_INVALID;
398     auto Str = (std::to_string(pid) + "_" + element.GetBundleName() + "_" + element.GetAbilityName());
399     g_key->pid_ = pid;
400     g_key->element_ = element;
401     g_key->type_ = type;
402     auto ret = g_key->ToString();
403     EXPECT_EQ(ret, Str);
404 }
405 /**
406  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_001.
407  * @tc.desc: test of MediaAVSessionAdapterImpl :: CreateAVSession()
408  * @tc.type: FUNC.
409  * @tc.require:
410  */
411 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_001, TestSize.Level1)
412 {
413     auto type = MediaAVSessionType::MEDIA_TYPE_INVALID;
414     auto avSessionKey = std::make_shared<MediaAVSessionKey>();
415     g_adapter->avSessionKey_ = avSessionKey;
416     g_adapter->avSessionKey_->Init();
417     auto avSessionMock = std::make_shared<AVSessionMock>();
418     auto avSessionMock_dummy = std::make_shared<AVSessionMock>();
419     g_adapter->avSession_ = avSessionMock;
420     g_adapter->avSessionMap.insert(
421         std::make_pair(g_adapter->avSessionKey_->ToString(),
422                        g_adapter->avSession_));
423 
424     bool ret = g_adapter->CreateAVSession(type);
425     EXPECT_EQ(ret, false);
426 
427     type = MediaAVSessionType::MEDIA_TYPE_AUDIO;
428     g_adapter->avSessionKey_->SetType(type);
429     ret = g_adapter->CreateAVSession(type);
430     EXPECT_EQ(ret, false);
431 
432     g_adapter->avSessionKey_->SetType(MediaAVSessionType::MEDIA_TYPE_INVALID);
433     ret = g_adapter->CreateAVSession(type);
434     EXPECT_EQ(ret, true);
435     g_adapter->avSessionKey_->SetType(MediaAVSessionType::MEDIA_TYPE_VIDEO);
436     ret = g_adapter->CreateAVSession(type);
437 
438     g_adapter->avSession_ = nullptr;
439     ret = g_adapter->CreateAVSession(type);
440     EXPECT_EQ(ret, true);
441 
442     g_adapter->avSession_ = avSessionMock;
443     type = MediaAVSessionType::MEDIA_TYPE_VIDEO;
444     g_adapter->avSessionMap.clear();
445     ret = g_adapter->CreateAVSession(type);
446     EXPECT_EQ(ret, true);
447 
448     g_adapter->avSession_ = avSessionMock;
449     g_adapter->avSessionMap.insert(
450         std::make_pair(g_adapter->avSessionKey_->ToString(),
451                        avSessionMock_dummy));
452     ret = g_adapter->CreateAVSession(type);
453     EXPECT_EQ(ret, true);
454 
455     g_adapter->avSessionMap.insert(
456         std::make_pair(g_adapter->avSessionKey_->ToString(),
457                        g_adapter->avSession_));
458     ret = g_adapter->CreateAVSession(type);
459     EXPECT_EQ(ret, false);
460 
461     g_adapter->avSession_ = avSessionMock;
462     g_adapter->avSessionMap.clear();
463     type = MediaAVSessionType::MEDIA_TYPE_VIDEO;
464     ret = g_adapter->CreateAVSession(type);
465     EXPECT_EQ(ret, true);
466 }
467 
468 /**
469  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_002.
470  * @tc.desc: test of MediaAVSessionAdapterImpl :: DestroyAVSession()
471  * @tc.type: FUNC.
472  * @tc.require:
473  */
474 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_002, TestSize.Level1)
475 {
476     g_adapter->avSession_ = nullptr;
477     g_adapter->DestroyAVSession();
478     EXPECT_EQ(g_adapter->avSession_, nullptr);
479 
480     auto avSessionMock = std::make_shared<AVSessionMock>();
481     g_adapter->avSession_ = avSessionMock;
482     EXPECT_CALL(*avSessionMock, Destroy()).WillOnce(::testing::Return(RET_ERROR));
483     g_adapter->DestroyAVSession();
484     EXPECT_EQ(g_adapter->avSession_, nullptr);
485 
486     g_adapter->avSession_ = avSessionMock;
487     EXPECT_CALL(*avSessionMock, Destroy()).WillOnce(::testing::Return(RET_SUCCESS));
488     g_adapter->DestroyAVSession();
489     EXPECT_EQ(g_adapter->avSession_, nullptr);
490 
491     g_adapter->avSession_ = nullptr;
492     g_adapter->avSessionMap.insert(
493         std::make_pair(g_adapter->avSessionKey_->ToString(),
494                        g_adapter->avSession_));
495     g_adapter->DestroyAVSession();
496 
497     g_adapter->avSessionMap.clear();
498     g_adapter->DestroyAVSession();
499 }
500 
501 /**
502  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_003.
503  * @tc.desc: test of MediaAVSessionAdapterImpl :: RegistCallback()
504  * @tc.type: FUNC.
505  * @tc.require:
506  */
507 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_003, TestSize.Level1)
508 {
509     auto mediaAVSessionCallbackAdapterMock = std::make_shared<MediaAVSessionCallbackAdapterMock>();
510     g_adapter->avSession_ = nullptr;
511     bool ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
512     EXPECT_EQ(ret, false);
513 
514     auto avSessionMock = std::make_shared<AVSessionMock>();
515     g_adapter->avSession_ = avSessionMock;
516     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(true));
517     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_ERROR));
518     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
519     EXPECT_EQ(ret, false);
520     g_adapter->avSession_ = nullptr;
521 
522     g_adapter->avSession_ = avSessionMock;
523     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(true));
524     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_SUCCESS));
525     EXPECT_CALL(*avSessionMock, AddSupportCommand(_)).WillRepeatedly(::testing::Return(RET_SUCCESS));
526     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
527     EXPECT_EQ(ret, true);
528     g_adapter->avSession_ = nullptr;
529 
530     g_adapter->avSession_ = avSessionMock;
531     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(true));
532     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_SUCCESS));
533     EXPECT_CALL(*avSessionMock, AddSupportCommand(_)).WillRepeatedly(::testing::Return(RET_ERROR));
534     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
535     EXPECT_EQ(ret, true);
536     g_adapter->avSession_ = nullptr;
537 
538     g_adapter->avSession_ = avSessionMock;
539     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
540     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_ERROR));
541     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
542     EXPECT_EQ(ret, false);
543     g_adapter->avSession_ = nullptr;
544 
545     g_adapter->avSession_ = avSessionMock;
546     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
547     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_SUCCESS));
548     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_ERROR));
549     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
550     EXPECT_EQ(ret, false);
551     g_adapter->avSession_ = nullptr;
552 
553     g_adapter->avSession_ = avSessionMock;
554     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
555     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_SUCCESS));
556     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_SUCCESS));
557     EXPECT_CALL(*avSessionMock, AddSupportCommand(_)).WillRepeatedly(::testing::Return(RET_SUCCESS));
558     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
559     EXPECT_EQ(ret, true);
560     g_adapter->avSession_ = nullptr;
561 
562     g_adapter->avSession_ = avSessionMock;
563     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
564     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_SUCCESS));
565     EXPECT_CALL(*avSessionMock, RegisterCallback(_)).WillOnce(::testing::Return(RET_SUCCESS));
566     EXPECT_CALL(*avSessionMock, AddSupportCommand(_)).WillRepeatedly(::testing::Return(RET_ERROR));
567     ret = g_adapter->RegistCallback(mediaAVSessionCallbackAdapterMock);
568     EXPECT_EQ(ret, true);
569     g_adapter->avSession_ = nullptr;
570 }
571 
572 /**
573  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_004.
574  * @tc.desc: test of MediaAVSessionAdapterImpl :: IsActivated()
575  * @tc.type: FUNC.
576  * @tc.require:
577  */
578 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_004, TestSize.Level1)
579 {
580     g_adapter->avSession_ = nullptr;
581     bool ret = g_adapter->IsActivated();
582     EXPECT_EQ(ret, false);
583 
584     auto avSessionMock = std::make_shared<AVSessionMock>();
585     g_adapter->avSession_ = avSessionMock;
586     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(true));
587     ret = g_adapter->IsActivated();
588     EXPECT_EQ(ret, true);
589     g_adapter->avSession_ = nullptr;
590 }
591 
592 /**
593  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_005.
594  * @tc.desc: test of MediaAVSessionAdapterImpl :: Activate()
595  * @tc.type: FUNC.
596  * @tc.require:
597  */
598 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_005, TestSize.Level1)
599 {
600     g_adapter->avSession_ = nullptr;
601     bool ret = g_adapter->Activate();
602     EXPECT_EQ(ret, false);
603 
604     auto avSessionMock = std::make_shared<AVSessionMock>();
605     g_adapter->avSession_ = avSessionMock;
606     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(true));
607     ret = g_adapter->Activate();
608     EXPECT_EQ(ret, true);
609 
610     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
611     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_SUCCESS));
612     ret = g_adapter->Activate();
613     EXPECT_EQ(ret, true);
614 
615     EXPECT_CALL(*avSessionMock, IsActive()).WillOnce(::testing::Return(false));
616     EXPECT_CALL(*avSessionMock, Activate()).WillOnce(::testing::Return(RET_ERROR));
617     ret = g_adapter->Activate();
618     EXPECT_EQ(ret, false);
619     g_adapter->avSession_ = nullptr;
620 }
621 
622 /**
623  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_006.
624  * @tc.desc: test of MediaAVSessionAdapterImpl :: DeActivate()
625  * @tc.type: FUNC.
626  * @tc.require:
627  */
628 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_006, TestSize.Level1)
629 {
630     g_adapter->avSession_ = nullptr;
631     g_adapter->DeActivate();
632     EXPECT_EQ(g_adapter->avSession_, nullptr);
633 
634     auto avSessionMock = std::make_shared<AVSessionMock>();
635     g_adapter->avSession_ = avSessionMock;
636     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(false));
637     g_adapter->DeActivate();
638     EXPECT_NE(g_adapter->avSession_, nullptr);
639 
640     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
641     EXPECT_CALL(*avSessionMock, Deactivate()).WillRepeatedly(::testing::Return(RET_SUCCESS));
642     g_adapter->DeActivate();
643     EXPECT_NE(g_adapter->avSession_, nullptr);
644 
645     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
646     EXPECT_CALL(*avSessionMock, Deactivate()).WillRepeatedly(::testing::Return(RET_ERROR));
647     g_adapter->DeActivate();
648     EXPECT_NE(g_adapter->avSession_, nullptr);
649     g_adapter->avSession_ = nullptr;
650 }
651 
652 /**
653  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_007.
654  * @tc.desc: test of MediaAVSessionAdapterImpl :: SetMetadata()
655  * @tc.type: FUNC.
656  * @tc.require:
657  */
658 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_007, TestSize.Level1)
659 {
660     auto avSessionMock = std::make_shared<AVSessionMock>();
661     auto metadataMock = std::make_shared<MetaDataMock>();
662     g_adapter->avSession_ = avSessionMock;
663 
664     EXPECT_CALL(*avSessionMock, SetAVMetaData(_)).WillOnce(
665         ::testing::Return(RET_ERROR));
666     g_adapter->SetMetadata(metadataMock);
667 
668     EXPECT_CALL(*avSessionMock, SetAVMetaData(_)).WillOnce(
669         ::testing::Return(RET_SUCCESS));
670     g_adapter->SetMetadata(metadataMock);
671 
672     g_adapter->avSession_ = nullptr;
673     g_adapter->SetMetadata(metadataMock);
674 }
675 
676 /**
677  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_008.
678  * @tc.desc: test of MediaAVSessionAdapterImpl :: SetPlaybackState()
679  * @tc.type: FUNC.
680  * @tc.require:
681  */
682 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_008, TestSize.Level1)
683 {
684     int32_t state = AVSession::AVPlaybackState::PLAYBACK_STATE_PLAY;
685     MediaAVSessionPlayState playState = static_cast<MediaAVSessionPlayState>(state);
686     auto avPlaybackState = std::make_shared<AVSession::AVPlaybackState>();
687     g_adapter->avSession_ = nullptr;
688     g_adapter->avPlaybackState_ = avPlaybackState;
689     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PAUSE);
690     g_adapter->SetPlaybackState(playState);
691     EXPECT_EQ(g_adapter->avSession_, nullptr);
692 
693     auto avSessionMock = std::make_shared<AVSessionMock>();
694     g_adapter->avSession_ = avSessionMock;
695     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PLAY);
696     g_adapter->SetPlaybackState(playState);
697     EXPECT_NE(g_adapter->avSession_, nullptr);
698 
699     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PAUSE);
700     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
701     EXPECT_CALL(*avSessionMock, SetAVPlaybackState(_)).WillOnce(::testing::Return(RET_SUCCESS));
702     g_adapter->SetPlaybackState(playState);
703     EXPECT_NE(g_adapter->avSession_, nullptr);
704 
705     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PAUSE);
706     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
707     EXPECT_CALL(*avSessionMock, SetAVPlaybackState(_)).WillOnce(::testing::Return(RET_ERROR));
708     g_adapter->SetPlaybackState(playState);
709     EXPECT_NE(g_adapter->avSession_, nullptr);
710     g_adapter->avSession_ = nullptr;
711 }
712 
713 /**
714  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_009.
715  * @tc.desc: test of MediaAVSessionAdapterImpl :: SetPlaybackPosition()_1
716  * @tc.type: FUNC.
717  * @tc.require:
718  */
719 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_009, TestSize.Level1)
720 {
721     int64_t temp1 = 1;
722     int64_t temp2 = 2;
723     auto positionMock = std::make_shared<PositionMock>();
724     auto avPlaybackState = std::make_shared<AVSession::AVPlaybackState>();
725     auto avmetadata = std::make_shared<AVSession::AVMetaData>();
726     g_adapter->avMetadata_ = avmetadata;
727     g_adapter->avPlaybackState_ = avPlaybackState;
728     g_adapter->avSession_ = nullptr;
729     g_adapter->avMetadata_->SetDuration(temp1);
730     g_adapter->avPlaybackState_->SetDuration(temp1);
731     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
732     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp2));
733     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp2));
734     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp2));
735     g_adapter->SetPlaybackPosition(positionMock);
736     EXPECT_EQ(g_adapter->avSession_, nullptr);
737 
738     g_adapter->avSession_ = nullptr;
739     g_adapter->avMetadata_->SetDuration(temp2);
740     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(
741         ::testing::Return(temp2));
742     g_adapter->SetPlaybackPosition(positionMock);
743 
744     auto avSessionMock = std::make_shared<AVSessionMock>();
745     g_adapter->avSession_ = avSessionMock;
746     g_adapter->avMetadata_->SetDuration(temp1);
747     g_adapter->avPlaybackState_->SetDuration(temp1);
748     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
749     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(
750         ::testing::Return(temp1));
751     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(
752         ::testing::Return(temp1));
753     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(
754         ::testing::Return(temp1));
755     g_adapter->SetPlaybackPosition(positionMock);
756     EXPECT_NE(g_adapter->avSession_, nullptr);
757 
758     g_adapter->avSession_ = avSessionMock;
759     g_adapter->avMetadata_->SetDuration(temp1);
760     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(
761         ::testing::Return(temp2));
762     g_adapter->SetPlaybackPosition(positionMock);
763 }
764 
765 /**
766  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_016.
767  * @tc.desc: test of MediaAVSessionAdapterImpl :: SetPlaybackPosition()_2
768  * @tc.type: FUNC.
769  * @tc.require:
770  */
771 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_016, TestSize.Level1)
772 {
773     int64_t temp1 = 1;
774     int64_t temp2 = 2;
775     auto positionMock = std::make_shared<PositionMock>();
776     auto avPlaybackState = std::make_shared<AVSession::AVPlaybackState>();
777     auto avmetadata = std::make_shared<AVSession::AVMetaData>();
778     g_adapter->avMetadata_ = avmetadata;
779     g_adapter->avPlaybackState_ = avPlaybackState;
780     auto avSessionMock = std::make_shared<AVSessionMock>();
781 
782     g_adapter->avMetadata_->SetDuration(temp1);
783     g_adapter->avSession_ = avSessionMock;
784     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
785     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp2));
786     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp2));
787     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp2));
788     EXPECT_CALL(*avSessionMock, SetAVMetaData(_)).WillOnce(::testing::Return(RET_SUCCESS));
789     EXPECT_CALL(*avSessionMock, SetAVPlaybackState(_)).WillOnce(::testing::Return(RET_SUCCESS));
790     g_adapter->SetPlaybackPosition(positionMock);
791     EXPECT_NE(g_adapter->avSession_, nullptr);
792 
793     g_adapter->avMetadata_->SetDuration(temp1);
794     g_adapter->avPlaybackState_->SetDuration(temp1);
795     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
796     g_adapter->avSession_ = avSessionMock;
797     EXPECT_CALL(*avSessionMock, IsActive()).WillRepeatedly(::testing::Return(true));
798     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp2));
799     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp2));
800     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp2));
801     EXPECT_CALL(*avSessionMock, SetAVMetaData(_)).WillOnce(::testing::Return(RET_ERROR));
802     EXPECT_CALL(*avSessionMock, SetAVPlaybackState(_)).WillOnce(::testing::Return(RET_ERROR));
803     g_adapter->SetPlaybackPosition(positionMock);
804     EXPECT_NE(g_adapter->avSession_, nullptr);
805     g_adapter->avSession_ = nullptr;
806 }
807 
808 /**
809  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0010.
810  * @tc.desc: test of MediaAVSessionAdapterImpl :: UpdateMetaDataCache()
811  * @tc.type: FUNC.
812  * @tc.require:
813  */
814 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0010, TestSize.Level1)
815 {
816     auto mediaAVSessionMetadataAdapterMock = std::make_shared<MediaAVSessionMetadataAdapterMock>();
817     auto avMetaDataMock = std::make_shared<AVMetaDataMock>();
818     g_adapter->avMetadata_ = avMetaDataMock;
819 
820     g_adapter->avMetadata_->SetTitle("1");
821     g_adapter->avMetadata_->SetAlbum("1");
822     g_adapter->avMetadata_->SetArtist("1");
823 
824     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetTitle()).WillOnce(::testing::Return("1"));
825     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetArtist()).WillOnce(::testing::Return("1"));
826     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetAlbum()).WillOnce(::testing::Return("1"));
827     bool ret = g_adapter->UpdateMetaDataCache(mediaAVSessionMetadataAdapterMock);
828     EXPECT_EQ(ret, false);
829 
830     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetTitle()).WillRepeatedly(::testing::Return("2"));
831     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetArtist()).WillRepeatedly(::testing::Return("2"));
832     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetAlbum()).WillRepeatedly(::testing::Return("2"));
833     ret = g_adapter->UpdateMetaDataCache(mediaAVSessionMetadataAdapterMock);
834     EXPECT_EQ(ret, true);
835 
836     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetTitle()).WillRepeatedly(::testing::Return("2"));
837     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetArtist()).WillRepeatedly(::testing::Return("1"));
838     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetAlbum()).WillRepeatedly(::testing::Return("1"));
839     ret = g_adapter->UpdateMetaDataCache(mediaAVSessionMetadataAdapterMock);
840     EXPECT_EQ(ret, true);
841 
842     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetTitle()).WillRepeatedly(::testing::Return("1"));
843     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetArtist()).WillRepeatedly(::testing::Return("2"));
844     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetAlbum()).WillRepeatedly(::testing::Return("1"));
845     ret = g_adapter->UpdateMetaDataCache(mediaAVSessionMetadataAdapterMock);
846     EXPECT_EQ(ret, true);
847 
848     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetTitle()).WillRepeatedly(::testing::Return("1"));
849     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetArtist()).WillRepeatedly(::testing::Return("1"));
850     EXPECT_CALL(*mediaAVSessionMetadataAdapterMock, GetAlbum()).WillRepeatedly(::testing::Return("2"));
851     ret = g_adapter->UpdateMetaDataCache(mediaAVSessionMetadataAdapterMock);
852     EXPECT_EQ(ret, true);
853 }
854 
855 /**
856  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0011.
857  * @tc.desc: test of MediaAVSessionAdapterImpl :: UpdateMetaDataCache()
858  * @tc.type: FUNC.
859  * @tc.require:
860  */
861 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0011, TestSize.Level1)
862 {
863     auto positionMock = std::make_shared<PositionMock>();
864     auto avmetadata = std::make_shared<AVSession::AVMetaData>();
865     g_adapter->avMetadata_ = avmetadata;
866     g_adapter->avMetadata_->SetDuration(1);
867 
868     EXPECT_CALL(*positionMock, GetDuration()).WillOnce(::testing::Return(1));
869     bool ret = g_adapter->UpdateMetaDataCache(positionMock);
870     EXPECT_EQ(ret, false);
871 
872     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(2));
873     ret = g_adapter->UpdateMetaDataCache(positionMock);
874     EXPECT_EQ(ret, true);
875 }
876 
877 /**
878  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0012.
879  * @tc.desc: test of MediaAVSessionAdapterImpl :: UpdatePlaybackStateCache()
880  * @tc.type: FUNC.
881  * @tc.require:
882  */
883 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0012, TestSize.Level1)
884 {
885     MediaAVSessionPlayState playState = MediaAVSessionPlayState::STATE_PLAY;
886     auto avPlaybackState = std::make_shared<AVSession::AVPlaybackState>();
887     g_adapter->avPlaybackState_ = avPlaybackState;
888     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PLAY);
889     bool ret = g_adapter->UpdatePlaybackStateCache(playState);
890     EXPECT_EQ(ret, false);
891 
892     playState = MediaAVSessionPlayState::STATE_PLAY;
893     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PAUSE);
894     ret = g_adapter->UpdatePlaybackStateCache(playState);
895     EXPECT_EQ(ret, true);
896 
897     playState = MediaAVSessionPlayState::STATE_PAUSE;
898     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PAUSE);
899     ret = g_adapter->UpdatePlaybackStateCache(playState);
900     EXPECT_EQ(ret, false);
901 
902     playState = MediaAVSessionPlayState::STATE_PAUSE;
903     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PLAY);
904     ret = g_adapter->UpdatePlaybackStateCache(playState);
905     EXPECT_EQ(ret, true);
906 
907     playState = MediaAVSessionPlayState::STATE_INITIAL;
908     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_INITIAL);
909     ret = g_adapter->UpdatePlaybackStateCache(playState);
910     EXPECT_EQ(ret, false);
911 
912     playState = MediaAVSessionPlayState::STATE_INITIAL;
913     g_adapter->avPlaybackState_->SetState(AVSession::AVPlaybackState::PLAYBACK_STATE_PLAY);
914     ret = g_adapter->UpdatePlaybackStateCache(playState);
915     EXPECT_EQ(ret, true);
916 }
917 
918 /**
919  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0013.
920  * @tc.desc: test of MediaAVSessionAdapterImpl :: UpdatePlaybackStateCache();
921  * @tc.type: FUNC.
922  * @tc.require:
923  */
924 HWTEST_F(MediaAVSessionAdapterImplTest, NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0013, TestSize.Level1)
925 {
926     int64_t temp1 = 1;
927     int64_t temp2 = 2;
928     auto positionMock = std::make_shared<PositionMock>();
929     auto avPlaybackState = std::make_shared<AVSession::AVPlaybackState>();
930     g_adapter->avPlaybackState_ = avPlaybackState;
931     g_adapter->avPlaybackState_->SetDuration(temp1);
932     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
933     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp1));
934     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp1));
935     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp1));
936     bool ret = g_adapter->UpdatePlaybackStateCache(positionMock);
937     EXPECT_EQ(ret, false);
938 
939     g_adapter->avPlaybackState_->SetDuration(temp1);
940     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
941     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp2));
942     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp1));
943     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp1));
944     ret = g_adapter->UpdatePlaybackStateCache(positionMock);
945     EXPECT_EQ(ret, true);
946 
947     g_adapter->avPlaybackState_->SetDuration(temp1);
948     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
949     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(::testing::Return(temp1));
950     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(::testing::Return(temp2));
951     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(::testing::Return(temp1));
952     ret = g_adapter->UpdatePlaybackStateCache(positionMock);
953     EXPECT_EQ(ret, true);
954 
955     g_adapter->avPlaybackState_->SetDuration(temp1);
956     g_adapter->avPlaybackState_->SetPosition({ temp1, temp1 });
957     EXPECT_CALL(*positionMock, GetDuration()).WillRepeatedly(
958         ::testing::Return(temp1));
959     EXPECT_CALL(*positionMock, GetElapsedTime()).WillRepeatedly(
960         ::testing::Return(temp1));
961     EXPECT_CALL(*positionMock, GetUpdateTime()).WillRepeatedly(
962         ::testing::Return(temp2));
963     ret = g_adapter->UpdatePlaybackStateCache(positionMock);
964     EXPECT_EQ(ret, true);
965 }
966 
967 /**
968  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0014.
969  * @tc.desc: test of MediaAVSessionAdapterImpl :: DestroyAndEraseSession();
970  * @tc.type: FUNC.
971  * @tc.require:
972  */
973 HWTEST_F(MediaAVSessionAdapterImplTest,
974          NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0014,
975          TestSize.Level1)
976 {
977     auto avSessionKey = std::make_shared<MediaAVSessionKey>();
978     g_adapter->avSessionKey_ = avSessionKey;
979     g_adapter->avSessionKey_->Init();
980     auto avSessionMock = std::make_shared<AVSessionMock>();
981     g_adapter->avSession_ = avSessionMock;
982 
983     g_adapter->avSessionMap.clear();
984     g_adapter->DestroyAndEraseSession();
985 
986     g_adapter->avSessionMap.insert(
987         std::make_pair(g_adapter->avSessionKey_->ToString(),
988                        nullptr));
989     g_adapter->DestroyAndEraseSession();
990 
991     g_adapter->avSessionMap.insert(
992         std::make_pair(g_adapter->avSessionKey_->ToString(),
993                        g_adapter->avSession_));
994     g_adapter->DestroyAndEraseSession();
995 
996     g_adapter->avSessionMap.insert(
997         std::make_pair(g_adapter->avSessionKey_->ToString(),
998                        g_adapter->avSession_));
999     EXPECT_CALL(*avSessionMock, Destroy()).WillRepeatedly(
1000         ::testing::Return(RET_ERROR));
1001     g_adapter->DestroyAndEraseSession();
1002 }
1003 
1004 /**
1005  * @tc.name: MediaAVSessionAdapterImplTest_MediaAVSessionAdapterImpl_0015.
1006  * @tc.desc: test of MediaAVSessionAdapterImpl :: CreateNewSession();
1007  * @tc.type: FUNC.
1008  * @tc.require:
1009  */
1010 HWTEST_F(MediaAVSessionAdapterImplTest,
1011         NWebMediaAdapterTest_MediaAVSessionAdapterImpl_0015,
1012         TestSize.Level1)
1013 {
1014     auto avSessionKeyMock = std::make_shared<MediaAVSessionKeyMock>();
1015     g_adapter->avSessionKey_ = avSessionKeyMock;
1016     g_adapter->avSessionKey_->Init();
1017     auto type = MediaAVSessionType::MEDIA_TYPE_AUDIO;
1018 
1019     bool ret = g_adapter->CreateNewSession(type);
1020     EXPECT_EQ(ret, true);
1021 
1022     EXPECT_CALL(*avSessionKeyMock, GetElement()).WillRepeatedly(
1023         ::testing::Return(nullptr));
1024     ret = g_adapter->CreateNewSession(type);
1025     EXPECT_EQ(ret, false);
1026 }
1027 } // namespace OHOS::NWeb