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