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