1 /*
2 * Copyright (c) 2024-2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include <gtest/gtest.h>
17 #include "avcast_provider_manager.h"
18 #include "avsession_errors.h"
19 #include "avsession_log.h"
20 #include "avsession_service.h"
21 #include "cast_engine_common.h"
22 #include "hw_cast_stream_player.h"
23 #include "hw_cast_provider.h"
24 #include "i_cast_session.h"
25
26 using namespace testing::ext;
27 using namespace OHOS::CastEngine;
28 namespace OHOS::AVSession {
29
30 static std::shared_ptr<AVSessionService> g_AVSessionService;
31
32 class HwCastSupplementTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase()40 void HwCastSupplementTest::SetUpTestCase()
41 {
42 SLOGI("set up AVSessionServiceTest");
43 system("killall -9 com.example.hiMusicDemo");
44 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
45 }
46
TearDownTestCase()47 void HwCastSupplementTest::TearDownTestCase()
48 {}
49
SetUp()50 void HwCastSupplementTest::SetUp()
51 {}
52
TearDown()53 void HwCastSupplementTest::TearDown()
54 {}
55
56 class AVCastControllerProxyDemo : public IAVCastControllerProxy {
57 public:
58
Release()59 void Release() {};
60
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)61 int32_t RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
62 iAVCastControllerProxyListener) {return 0;}
63
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)64 int32_t UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
65 iAVCastControllerProxyListener) {return 0;}
66
GetCurrentItem()67 AVQueueItem GetCurrentItem() {return AVQueueItem();}
68
Start(const AVQueueItem & avQueueItem)69 int32_t Start(const AVQueueItem& avQueueItem) {return 0;}
70
Prepare(const AVQueueItem & avQueueItem)71 int32_t Prepare(const AVQueueItem& avQueueItem) {return 0;}
72
SendControlCommand(const AVCastControlCommand cmd)73 void SendControlCommand(const AVCastControlCommand cmd) {}
74
GetDuration(int32_t & duration)75 int32_t GetDuration(int32_t& duration) {return 0;}
76
GetCastAVPlaybackState(AVPlaybackState & avPlaybackState)77 int32_t GetCastAVPlaybackState(AVPlaybackState& avPlaybackState) {return 0;}
78
SetValidAbility(const std::vector<int32_t> & validAbilityList)79 int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) {return 0;}
80
GetValidAbility(std::vector<int32_t> & validAbilityList)81 int32_t GetValidAbility(std::vector<int32_t> &validAbilityList) {return 0;}
82
SetDisplaySurface(std::string & surfaceId)83 int32_t SetDisplaySurface(std::string& surfaceId) {return 0;}
84
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)85 int32_t ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response) {return 0;}
86
RefreshCurrentAVQueueItem(const AVQueueItem & avQueueItem)87 int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) {return 0;}
88 };
89
90 class AVCastSessionStateListenerDemo : public IAVCastSessionStateListener {
91 public:
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo)92 void OnCastStateChange(int32_t castState, DeviceInfo deviceInfo) {}
93
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)94 void OnCastEventRecv(int32_t errorCode, std::string& errorMsg) {}
95 };
96
97 class ICastSessionMock : public CastEngine::ICastSession {
98 public:
ICastSessionMock()99 ICastSessionMock() {};
~ICastSessionMock()100 virtual ~ICastSessionMock() {};
RegisterListener(std::shared_ptr<ICastSessionListener> listener)101 virtual int32_t RegisterListener(std::shared_ptr<ICastSessionListener> listener) { return 0; }
UnregisterListener()102 virtual int32_t UnregisterListener() { return 0; }
AddDevice(const CastRemoteDevice & remoteDevice)103 virtual int32_t AddDevice(const CastRemoteDevice &remoteDevice) { return 0; }
RemoveDevice(const std::string & deviceId,const DeviceRemoveAction & actionType=DeviceRemoveAction::ACTION_DISCONNECT)104 virtual int32_t RemoveDevice(const std::string &deviceId,
105 const DeviceRemoveAction &actionType = DeviceRemoveAction::ACTION_DISCONNECT) { return 0; }
StartAuth(const AuthInfo & authInfo)106 virtual int32_t StartAuth(const AuthInfo &authInfo) { return 0; }
GetSessionId(std::string & sessionId)107 virtual int32_t GetSessionId(std::string &sessionId) { return 0; }
SetSessionProperty(const CastSessionProperty & property)108 virtual int32_t SetSessionProperty(const CastSessionProperty &property) { return 0; }
CreateMirrorPlayer(std::shared_ptr<IMirrorPlayer> & mirrorPlayer)109 virtual int32_t CreateMirrorPlayer(std::shared_ptr<IMirrorPlayer> &mirrorPlayer) { return 0; }
CreateStreamPlayer(std::shared_ptr<IStreamPlayer> & streamPlayer)110 virtual int32_t CreateStreamPlayer(std::shared_ptr<IStreamPlayer> &streamPlayer) { return 0; }
NotifyEvent(EventId eventId,std::string & jsonParam)111 virtual int32_t NotifyEvent(EventId eventId, std::string &jsonParam) { return 0; }
SetCastMode(CastMode mode,std::string & jsonParam)112 virtual int32_t SetCastMode(CastMode mode, std::string &jsonParam) { return 0; }
Release()113 virtual int32_t Release() { return 0; }
GetRemoteDeviceInfo(std::string deviceId,CastRemoteDevice & remoteDevice)114 virtual int32_t GetRemoteDeviceInfo(std::string deviceId, CastRemoteDevice &remoteDevice) { return 0; }
115 };
116
117 /**
118 * @tc.name: StopCastSession001
119 * @tc.desc: test StopCastSession
120 * @tc.type: FUNC
121 */
122 static HWTEST(HwCastSupplementTest, StopCastSession001, TestSize.Level1)
123 {
124 SLOGI("StopCastSession001 begin!");
125 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
126 EXPECT_EQ(hwCastProvider != nullptr, true);
127 hwCastProvider->Init();
128
129 int32_t castId = 0;
130 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
131 hwCastProvider->StopCastSession(castId);
132 SLOGI("StopCastSession001 end!");
133 }
134
135 /**
136 * @tc.name: StopCastSession002
137 * @tc.desc: test StopCastSession
138 * @tc.type: FUNC
139 */
140 static HWTEST(HwCastSupplementTest, StopCastSession002, TestSize.Level1)
141 {
142 SLOGI("StopCastSession002 begin!");
143 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
144 EXPECT_EQ(hwCastProvider != nullptr, true);
145 hwCastProvider->Init();
146
147 int32_t castId = 0;
148 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
149 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
150 hwCastProvider->StopCastSession(castId);
151 SLOGI("StopCastSession002 end!");
152 }
153
154 /**
155 * @tc.name: StopCastSession003
156 * @tc.desc: test StopCastSession
157 * @tc.type: FUNC
158 */
159 static HWTEST(HwCastSupplementTest, StopCastSession003, TestSize.Level1)
160 {
161 SLOGI("StopCastSession003 begin!");
162 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
163 EXPECT_EQ(hwCastProvider != nullptr, true);
164 hwCastProvider->Init();
165
166 int32_t castId = -1;
167 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
168 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
169 hwCastProvider->StopCastSession(castId);
170 SLOGI("StopCastSession003 end!");
171 }
172
173 /**
174 * @tc.name: AddCastDevice001
175 * @tc.desc: test AddCastDevice
176 * @tc.type: FUNC
177 */
178 static HWTEST(HwCastSupplementTest, AddCastDevice001, TestSize.Level1)
179 {
180 SLOGI("AddCastDevice001 begin!");
181 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
182 EXPECT_EQ(hwCastProvider != nullptr, true);
183 hwCastProvider->Init();
184
185 int32_t castId = 0;
186 DeviceInfo deviceInfo;
187 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
188 EXPECT_EQ(ret, false);
189 SLOGI("AddCastDevice001 end!");
190 }
191
192 /**
193 * @tc.name: AddCastDevice002
194 * @tc.desc: test AddCastDevice
195 * @tc.type: FUNC
196 */
197 static HWTEST(HwCastSupplementTest, AddCastDevice002, TestSize.Level1)
198 {
199 SLOGI("AddCastDevice002 begin!");
200 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
201 EXPECT_EQ(hwCastProvider != nullptr, true);
202 hwCastProvider->Init();
203
204 int32_t castId = 0;
205 DeviceInfo deviceInfo;
206 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
207 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
208 EXPECT_EQ(ret, false);
209 SLOGI("AddCastDevice002 end!");
210 }
211
212 /**
213 * @tc.name: AddCastDevice003
214 * @tc.desc: test AddCastDevice
215 * @tc.type: FUNC
216 */
217 static HWTEST(HwCastSupplementTest, AddCastDevice003, TestSize.Level1)
218 {
219 SLOGI("AddCastDevice003 begin!");
220 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
221 EXPECT_EQ(hwCastProvider != nullptr, true);
222 hwCastProvider->Init();
223
224 int32_t castId = 0;
225 DeviceInfo deviceInfo;
226 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
227 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
228 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo);
229 EXPECT_EQ(ret, false);
230 SLOGI("AddCastDevice003 end!");
231 }
232
233 /**
234 * @tc.name: RemoveCastDevice001
235 * @tc.desc: test RemoveCastDevice
236 * @tc.type: FUNC
237 */
238 static HWTEST(HwCastSupplementTest, RemoveCastDevice001, TestSize.Level1)
239 {
240 SLOGI("RemoveCastDevice001 begin!");
241 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
242 EXPECT_EQ(hwCastProvider != nullptr, true);
243 hwCastProvider->Init();
244
245 int32_t castId = 0;
246 DeviceInfo deviceInfo;
247 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
248 EXPECT_EQ(ret, false);
249 SLOGI("RemoveCastDevice001 end!");
250 }
251
252 /**
253 * @tc.name: RemoveCastDevice002
254 * @tc.desc: test RemoveCastDevice
255 * @tc.type: FUNC
256 */
257 static HWTEST(HwCastSupplementTest, RemoveCastDevice002, TestSize.Level1)
258 {
259 SLOGI("RemoveCastDevice002 begin!");
260 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
261 EXPECT_EQ(hwCastProvider != nullptr, true);
262 hwCastProvider->Init();
263
264 int32_t castId = 0;
265 DeviceInfo deviceInfo;
266 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
267 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
268 EXPECT_EQ(ret, false);
269 SLOGI("RemoveCastDevice002 end!");
270 }
271
272 /**
273 * @tc.name: RemoveCastDevice003
274 * @tc.desc: test RemoveCastDevice
275 * @tc.type: FUNC
276 */
277 static HWTEST(HwCastSupplementTest, RemoveCastDevice003, TestSize.Level1)
278 {
279 SLOGI("RemoveCastDevice003 begin!");
280 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
281 EXPECT_EQ(hwCastProvider != nullptr, true);
282 hwCastProvider->Init();
283
284 int32_t castId = 0;
285 DeviceInfo deviceInfo;
286 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
287 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
288 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
289 EXPECT_EQ(ret, false);
290 SLOGI("RemoveCastDevice003 end!");
291 }
292
293 /**
294 * @tc.name: RegisterCastStateListener001
295 * @tc.desc: test RegisterCastStateListener
296 * @tc.type: FUNC
297 */
298 static HWTEST(HwCastSupplementTest, RegisterCastStateListener001, TestSize.Level1)
299 {
300 SLOGI("RegisterCastStateListener001 begin!");
301 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
302 EXPECT_EQ(hwCastProvider != nullptr, true);
303 hwCastProvider->Init();
304
305 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
306 std::make_shared<AVCastProviderManager>();
307 bool ret = hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
308 EXPECT_EQ(ret, true);
309 SLOGI("RegisterCastStateListener001 end!");
310 }
311
312 /**
313 * @tc.name: UnRegisterCastStateListener001
314 * @tc.desc: test UnRegisterCastStateListener
315 * @tc.type: FUNC
316 */
317 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener001, TestSize.Level1)
318 {
319 SLOGI("UnRegisterCastStateListener001 begin!");
320 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
321 EXPECT_EQ(hwCastProvider != nullptr, true);
322 hwCastProvider->Init();
323
324 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
325 std::make_shared<AVCastProviderManager>();
326 hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
327 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
328 EXPECT_EQ(ret, true);
329 SLOGI("UnRegisterCastStateListener001 end!");
330 }
331
332 /**
333 * @tc.name: UnRegisterCastStateListener002
334 * @tc.desc: test UnRegisterCastStateListener
335 * @tc.type: FUNC
336 */
337 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener002, TestSize.Level1)
338 {
339 SLOGI("UnRegisterCastStateListener002 begin!");
340 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
341 EXPECT_EQ(hwCastProvider != nullptr, true);
342 hwCastProvider->Init();
343
344 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
345 std::make_shared<AVCastProviderManager>();
346 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
347 EXPECT_EQ(ret, false);
348 SLOGI("UnRegisterCastStateListener002 end!");
349 }
350
351 /**
352 * @tc.name: UnRegisterCastStateListener003
353 * @tc.desc: test UnRegisterCastStateListener
354 * @tc.type: FUNC
355 */
356 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener003, TestSize.Level1)
357 {
358 SLOGI("UnRegisterCastStateListener003 begin!");
359 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
360 EXPECT_EQ(hwCastProvider != nullptr, true);
361 hwCastProvider->Init();
362
363 std::shared_ptr<IAVCastStateListener> avCastStateListenerDemo = nullptr;
364 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
365 EXPECT_EQ(ret, false);
366 SLOGI("UnRegisterCastStateListener003 end!");
367 }
368
369 /**
370 * @tc.name: RegisterCastSessionStateListener001
371 * @tc.desc: test RegisterCastSessionStateListener
372 * @tc.type: FUNC
373 */
374 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener001, TestSize.Level1)
375 {
376 SLOGI("RegisterCastSessionStateListener001 begin!");
377 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
378 EXPECT_EQ(hwCastProvider != nullptr, true);
379 hwCastProvider->Init();
380
381 int castId = 0;
382 std::shared_ptr<IAVCastSessionStateListener> listener =
383 std::make_shared<AVCastSessionStateListenerDemo>();
384 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
385 EXPECT_EQ(ret, false);
386 SLOGI("RegisterCastSessionStateListener001 end!");
387 }
388
389 /**
390 * @tc.name: RegisterCastSessionStateListener002
391 * @tc.desc: test RegisterCastSessionStateListener
392 * @tc.type: FUNC
393 */
394 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener002, TestSize.Level1)
395 {
396 SLOGI("RegisterCastSessionStateListener002 begin!");
397 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
398 EXPECT_EQ(hwCastProvider != nullptr, true);
399 hwCastProvider->Init();
400
401 int castId = 0;
402 std::shared_ptr<IAVCastSessionStateListener> listener =
403 std::make_shared<AVCastSessionStateListenerDemo>();
404 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
405 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
406 EXPECT_EQ(ret, false);
407 SLOGI("RegisterCastSessionStateListener002 end!");
408 }
409
410 /**
411 * @tc.name: RegisterCastSessionStateListener003
412 * @tc.desc: test RegisterCastSessionStateListener
413 * @tc.type: FUNC
414 */
415 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener003, TestSize.Level1)
416 {
417 SLOGI("RegisterCastSessionStateListener003 begin!");
418 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
419 EXPECT_EQ(hwCastProvider != nullptr, true);
420 hwCastProvider->Init();
421
422 int castId = 0;
423 std::shared_ptr<IAVCastSessionStateListener> listener =
424 std::make_shared<AVCastSessionStateListenerDemo>();
425 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
426 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
427 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
428 EXPECT_EQ(ret, true);
429 SLOGI("RegisterCastSessionStateListener003 end!");
430 }
431
432 /**
433 * @tc.name: UnRegisterCastSessionStateListener001
434 * @tc.desc: test UnRegisterCastSessionStateListener
435 * @tc.type: FUNC
436 */
437 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener001, TestSize.Level1)
438 {
439 SLOGI("UnRegisterCastSessionStateListener001 begin!");
440 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
441 EXPECT_EQ(hwCastProvider != nullptr, true);
442 hwCastProvider->Init();
443
444 int castId = 0;
445 std::shared_ptr<IAVCastSessionStateListener> listener =
446 std::make_shared<AVCastSessionStateListenerDemo>();
447 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
448 EXPECT_EQ(ret, false);
449 SLOGI("UnRegisterCastSessionStateListener001 end!");
450 }
451
452 /**
453 * @tc.name: UnRegisterCastSessionStateListener002
454 * @tc.desc: test UnRegisterCastSessionStateListener
455 * @tc.type: FUNC
456 */
457 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener002, TestSize.Level1)
458 {
459 SLOGI("UnRegisterCastSessionStateListener002 begin!");
460 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
461 EXPECT_EQ(hwCastProvider != nullptr, true);
462 hwCastProvider->Init();
463
464 int castId = 0;
465 std::shared_ptr<IAVCastSessionStateListener> listener =
466 std::make_shared<AVCastSessionStateListenerDemo>();
467 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
468 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
469 EXPECT_EQ(ret, false);
470 SLOGI("UnRegisterCastSessionStateListener002 end!");
471 }
472
473 /**
474 * @tc.name: UnRegisterCastSessionStateListener003
475 * @tc.desc: test UnRegisterCastSessionStateListener
476 * @tc.type: FUNC
477 */
478 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener003, TestSize.Level1)
479 {
480 SLOGI("UnRegisterCastSessionStateListener003 begin!");
481 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
482 EXPECT_EQ(hwCastProvider != nullptr, true);
483 hwCastProvider->Init();
484
485 int castId = 0;
486 std::shared_ptr<IAVCastSessionStateListener> listener =
487 std::make_shared<AVCastSessionStateListenerDemo>();
488 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
489 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
490 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
491 EXPECT_EQ(ret, false);
492 SLOGI("UnRegisterCastSessionStateListener003 end!");
493 }
494
495 /**
496 * @tc.name: GetRemoteController001
497 * @tc.desc: test GetRemoteController
498 * @tc.type: FUNC
499 */
500 static HWTEST(HwCastSupplementTest, GetRemoteController001, TestSize.Level1)
501 {
502 SLOGI("GetRemoteController001 begin!");
503 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
504 EXPECT_EQ(hwCastProvider != nullptr, true);
505 hwCastProvider->Init();
506
507 int castId = 0;
508 auto ret = hwCastProvider->GetRemoteController(castId);
509 EXPECT_EQ(ret, nullptr);
510 SLOGI("GetRemoteController001 end!");
511 }
512
513 /**
514 * @tc.name: GetRemoteController002
515 * @tc.desc: test GetRemoteController
516 * @tc.type: FUNC
517 */
518 static HWTEST(HwCastSupplementTest, GetRemoteController002, TestSize.Level1)
519 {
520 SLOGI("GetRemoteController002 begin!");
521 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
522 EXPECT_EQ(hwCastProvider != nullptr, true);
523 hwCastProvider->Init();
524
525 int castId = 0;
526 hwCastProvider->avCastControllerMap_[castId] = nullptr;
527 auto ret = hwCastProvider->GetRemoteController(castId);
528 EXPECT_EQ(ret, nullptr);
529 SLOGI("GetRemoteController002 end!");
530 }
531
532 /**
533 * @tc.name: GetRemoteController003
534 * @tc.desc: test GetRemoteController
535 * @tc.type: FUNC
536 */
537 static HWTEST(HwCastSupplementTest, GetRemoteController003, TestSize.Level1)
538 {
539 SLOGI("GetRemoteController003 begin!");
540 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
541 EXPECT_EQ(hwCastProvider != nullptr, true);
542 hwCastProvider->Init();
543
544 int castId = 0;
545 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
546 auto ret = hwCastProvider->GetRemoteController(castId);
547 EXPECT_EQ(ret, nullptr);
548 SLOGI("GetRemoteController003 end!");
549 }
550
551 /**
552 * @tc.name: GetRemoteController004
553 * @tc.desc: test GetRemoteController
554 * @tc.type: FUNC
555 */
556 static HWTEST(HwCastSupplementTest, GetRemoteController004, TestSize.Level1)
557 {
558 SLOGI("GetRemoteController004 begin!");
559 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
560 EXPECT_EQ(hwCastProvider != nullptr, true);
561 hwCastProvider->Init();
562
563 int castId = 0;
564 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
565 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
566 auto ret = hwCastProvider->GetRemoteController(castId);
567 // HwCastProviderSession construct with null can not CreateStreamPlayer
568 EXPECT_EQ(ret, nullptr);
569 SLOGI("GetRemoteController004 end!");
570 }
571
572 /**
573 * @tc.name: SetStreamState001
574 * @tc.desc: test SetStreamState
575 * @tc.type: FUNC
576 */
577 static HWTEST(HwCastSupplementTest, SetStreamState001, TestSize.Level1)
578 {
579 SLOGI("SetStreamState001 begin!");
580 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
581 EXPECT_EQ(hwCastProvider != nullptr, true);
582 hwCastProvider->Init();
583
584 int castId = 0;
585 DeviceInfo deviceInfo;
586 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
587 EXPECT_EQ(ret, false);
588 SLOGI("SetStreamState001 end!");
589 }
590
591 /**
592 * @tc.name: SetStreamState002
593 * @tc.desc: test SetStreamState
594 * @tc.type: FUNC
595 */
596 static HWTEST(HwCastSupplementTest, SetStreamState002, TestSize.Level1)
597 {
598 SLOGI("SetStreamState002 begin!");
599 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
600 EXPECT_EQ(hwCastProvider != nullptr, true);
601 hwCastProvider->Init();
602
603 int castId = 0;
604 DeviceInfo deviceInfo;
605 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
606 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
607 EXPECT_EQ(ret, false);
608 SLOGI("SetStreamState002 end!");
609 }
610
611 /**
612 * @tc.name: SetStreamState003
613 * @tc.desc: test SetStreamState
614 * @tc.type: FUNC
615 */
616 static HWTEST(HwCastSupplementTest, SetStreamState003, TestSize.Level1)
617 {
618 SLOGI("SetStreamState003 begin!");
619 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
620 EXPECT_EQ(hwCastProvider != nullptr, true);
621 hwCastProvider->Init();
622
623 int castId = 0;
624 DeviceInfo deviceInfo;
625 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
626 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
627 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
628 EXPECT_EQ(ret, true);
629 SLOGI("SetStreamState003 end!");
630 }
631
632 /**
633 * @tc.name: GetRemoteNetWorkId001
634 * @tc.desc: test GetRemoteNetWorkId
635 * @tc.type: FUNC
636 */
637 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId001, TestSize.Level1)
638 {
639 SLOGI("GetRemoteNetWorkId001 begin!");
640 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
641 EXPECT_EQ(hwCastProvider != nullptr, true);
642 hwCastProvider->Init();
643
644 int castId = 0;
645 std::string deviceId;
646 std::string networkId;
647 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
648 EXPECT_EQ(ret, false);
649 SLOGI("GetRemoteNetWorkId001 end!");
650 }
651
652 /**
653 * @tc.name: GetRemoteNetWorkId002
654 * @tc.desc: test GetRemoteNetWorkId
655 * @tc.type: FUNC
656 */
657 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId002, TestSize.Level1)
658 {
659 SLOGI("GetRemoteNetWorkId002 begin!");
660 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
661 EXPECT_EQ(hwCastProvider != nullptr, true);
662 hwCastProvider->Init();
663
664 int castId = 0;
665 std::string deviceId;
666 std::string networkId;
667 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
668 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
669 EXPECT_EQ(ret, false);
670 SLOGI("GetRemoteNetWorkId002 end!");
671 }
672
673 /**
674 * @tc.name: GetRemoteNetWorkId003
675 * @tc.desc: test GetRemoteNetWorkId
676 * @tc.type: FUNC
677 */
678 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId003, TestSize.Level1)
679 {
680 SLOGI("GetRemoteNetWorkId003 begin!");
681 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
682 EXPECT_EQ(hwCastProvider != nullptr, true);
683 hwCastProvider->Init();
684
685 int castId = 0;
686 std::string deviceId;
687 std::string networkId;
688 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
689 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
690 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
691 EXPECT_EQ(ret, false);
692 SLOGI("GetRemoteNetWorkId003 end!");
693 }
694
695 /**
696 * @tc.name: OnDeviceFound001
697 * @tc.desc: test OnDeviceFound
698 * @tc.type: FUNC
699 */
700 static HWTEST(HwCastSupplementTest, OnDeviceFound001, TestSize.Level1)
701 {
702 SLOGI("OnDeviceFound001 begin!");
703 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
704 EXPECT_EQ(hwCastProvider != nullptr, true);
705 hwCastProvider->Init();
706
707 CastEngine::CastRemoteDevice castRemoteDevice;
708 std::vector<CastEngine::CastRemoteDevice> deviceList;
709 deviceList.push_back(castRemoteDevice);
710
711 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
712 hwCastProvider->castStateListenerList_.push_back(ptr);
713
714 hwCastProvider->OnDeviceFound(deviceList);
715 SLOGI("OnDeviceFound001 end!");
716 }
717
718 /**
719 * @tc.name: OnDeviceFound002
720 * @tc.desc: test OnDeviceFound
721 * @tc.type: FUNC
722 */
723 static HWTEST(HwCastSupplementTest, OnDeviceFound002, TestSize.Level1)
724 {
725 SLOGI("OnDeviceFound002 begin!");
726 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
727 EXPECT_EQ(hwCastProvider != nullptr, true);
728 hwCastProvider->Init();
729
730 CastEngine::CastRemoteDevice castRemoteDevice;
731 std::vector<CastEngine::CastRemoteDevice> deviceList;
732 deviceList.push_back(castRemoteDevice);
733
734 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
735 hwCastProvider->castStateListenerList_.push_back(ptr);
736
737 hwCastProvider->OnDeviceFound(deviceList);
738 SLOGI("OnDeviceFound002 end!");
739 }
740
741 /**
742 * @tc.name: OnLogEvent001
743 * @tc.desc: test OnLogEvent
744 * @tc.type: FUNC
745 */
746 static HWTEST(HwCastSupplementTest, OnLogEvent001, TestSize.Level1)
747 {
748 SLOGI("OnLogEvent001 begin!");
749 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
750 EXPECT_EQ(hwCastProvider != nullptr, true);
751 hwCastProvider->Init();
752
753 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
754 hwCastProvider->castStateListenerList_.push_back(ptr);
755
756 int32_t eventId = 0;
757 int64_t param = 0;
758 hwCastProvider->OnLogEvent(eventId, param);
759 SLOGI("OnLogEvent001 end!");
760 }
761
762 /**
763 * @tc.name: OnLogEvent002
764 * @tc.desc: test OnLogEvent
765 * @tc.type: FUNC
766 */
767 static HWTEST(HwCastSupplementTest, OnLogEvent002, TestSize.Level1)
768 {
769 SLOGI("OnLogEvent002 begin!");
770 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
771 EXPECT_EQ(hwCastProvider != nullptr, true);
772 hwCastProvider->Init();
773
774 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
775 hwCastProvider->castStateListenerList_.push_back(ptr);
776
777 int32_t eventId = 0;
778 int64_t param = 0;
779 hwCastProvider->OnLogEvent(eventId, param);
780 SLOGI("OnLogEvent002 end!");
781 }
782
783 /**
784 * @tc.name: OnLogEvent003
785 * @tc.desc: test OnLogEvent
786 * @tc.type: FUNC
787 */
788 static HWTEST(HwCastSupplementTest, OnLogEvent003, TestSize.Level1)
789 {
790 SLOGI("OnLogEvent003 begin!");
791 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
792 EXPECT_EQ(hwCastProvider != nullptr, true);
793 hwCastProvider->Init();
794
795 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
796 hwCastProvider->castStateListenerList_.push_back(ptr);
797
798 int32_t eventId = 1;
799 int64_t param = 0;
800 hwCastProvider->OnLogEvent(eventId, param);
801 SLOGI("OnLogEvent003 end!");
802 }
803
804 /**
805 * @tc.name: OnDeviceOffline001
806 * @tc.desc: test OnDeviceOffline
807 * @tc.type: FUNC
808 */
809 static HWTEST(HwCastSupplementTest, OnDeviceOffline001, TestSize.Level1)
810 {
811 SLOGI("OnDeviceOffline001 begin!");
812 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
813 EXPECT_EQ(hwCastProvider != nullptr, true);
814 hwCastProvider->Init();
815
816 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
817 hwCastProvider->castStateListenerList_.push_back(ptr);
818
819 std::string deviceId = "111";
820 hwCastProvider->OnDeviceOffline(deviceId);
821 SLOGI("OnDeviceOffline001 end!");
822 }
823
824 /**
825 * @tc.name: OnDeviceOffline002
826 * @tc.desc: test OnDeviceOffline
827 * @tc.type: FUNC
828 */
829 static HWTEST(HwCastSupplementTest, OnDeviceOffline002, TestSize.Level1)
830 {
831 SLOGI("OnLogEvent002 begin!");
832 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
833 EXPECT_EQ(hwCastProvider != nullptr, true);
834 hwCastProvider->Init();
835
836 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
837 hwCastProvider->castStateListenerList_.push_back(ptr);
838
839 std::string deviceId = "111";
840 hwCastProvider->OnDeviceOffline(deviceId);
841 SLOGI("OnDeviceOffline002 end!");
842 }
843
844 /**
845 * @tc.name: OnServiceDied001
846 * @tc.desc: test OnServiceDied
847 * @tc.type: FUNC
848 * @tc.require:
849 */
850 static HWTEST(HwCastSupplementTest, OnServiceDied001, TestSize.Level1)
851 {
852 SLOGI("OnServiceDied001 begin!");
853 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
854 EXPECT_EQ(hwCastProvider != nullptr, true);
855 hwCastProvider->Init();
856
857 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
858 hwCastProvider->castStateListenerList_.push_back(ptr);
859 hwCastProvider->OnServiceDied();
860 SLOGI("OnServiceDied001 end!");
861 }
862
863 /**
864 * @tc.name: HwCastProviderSession_HwCastProviderSessionRemoveDevice_001
865 * @tc.desc: create session and set continuePlay to true
866 * @tc.type: FUNC
867 * @tc.require:
868 */
869 static HWTEST(HwCastSupplementTest, HwCastProviderSession_HwCastProviderSessionRemoveDevice_001, TestSize.Level1)
870 {
871 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_001 begin!");
872 auto session = std::make_shared<ICastSessionMock>();
873 auto provideSession = std::make_shared<HwCastProviderSession>(session);
874 EXPECT_EQ(provideSession != nullptr, true);
875 provideSession->Init();
876 std::string deviceId = "test";
877 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
878 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_001 end!");
879 }
880
881 /**
882 * @tc.name: HwCastProviderSession_HwCastProviderSessionRemoveDevice_002
883 * @tc.desc: create session and set continuePlay to false
884 * @tc.type: FUNC
885 * @tc.require:
886 */
887 static HWTEST(HwCastSupplementTest, HwCastProviderSession_HwCastProviderSessionRemoveDevice_002, TestSize.Level1)
888 {
889 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_002 begin!");
890 auto session = std::make_shared<ICastSessionMock>();
891 auto provideSession = std::make_shared<HwCastProviderSession>(session);
892 EXPECT_EQ(provideSession != nullptr, true);
893 provideSession->Init();
894 std::string deviceId = "test";
895 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
896 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_002 end!");
897 }
898
899 /**
900 * @tc.name: HwCastProviderSession_GetRemoteNetWorkId_001
901 * @tc.desc: set sesion to not nullptr
902 * @tc.type: FUNC
903 * @tc.require:
904 */
905 static HWTEST(HwCastSupplementTest, HwCastProviderSession_GetRemoteNetWorkId_001, TestSize.Level1)
906 {
907 SLOGI("HwCastProviderSession_GetRemoteNetWorkId_001 begin!");
908 auto session = std::make_shared<ICastSessionMock>();
909 auto provideSession = std::make_shared<HwCastProviderSession>(session);
910 EXPECT_EQ(provideSession != nullptr, true);
911 provideSession->Init();
912 std::string deviceId = "001";
913 std::string networkId = "0.0.0.0";
914 bool ret = provideSession->GetRemoteNetWorkId(deviceId, networkId);
915 EXPECT_EQ(ret, true);
916 SLOGI("HwCastProviderSession_GetRemoteNetWorkId_001 end!");
917 }
918
919 /**
920 * @tc.name: HwCastProviderSession_RegisterCastSessionStateListener_001
921 * @tc.desc: set nullptr listener
922 * @tc.type: FUNC
923 * @tc.require:
924 */
925 static HWTEST(HwCastSupplementTest, HwCastProviderSession_RegisterCastSessionStateListener_001, TestSize.Level1)
926 {
927 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_001 begin!");
928 auto session = std::make_shared<ICastSessionMock>();
929 auto provideSession = std::make_shared<HwCastProviderSession>(session);
930 EXPECT_EQ(provideSession != nullptr, true);
931 provideSession->Init();
932 bool ret = provideSession->RegisterCastSessionStateListener(nullptr);
933 EXPECT_EQ(ret, false);
934 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_001 end!");
935 }
936
937 /**
938 * @tc.name: HwCastProviderSession_RegisterCastSessionStateListener_002
939 * @tc.desc: set not nullptr listener
940 * @tc.type: FUNC
941 * @tc.require:
942 */
943 static HWTEST(HwCastSupplementTest, HwCastProviderSession_RegisterCastSessionStateListener_002, TestSize.Level1)
944 {
945 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_002 begin!");
946 auto session = std::make_shared<ICastSessionMock>();
947 auto provideSession = std::make_shared<HwCastProviderSession>(session);
948 EXPECT_EQ(provideSession != nullptr, true);
949 provideSession->Init();
950 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
951 bool ret = provideSession->RegisterCastSessionStateListener(listener);
952 EXPECT_EQ(ret, true);
953 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_002 end!");
954 }
955
956 } // OHOS::AVSession