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_info.h"
19 #include "avsession_errors.h"
20 #include "avsession_log.h"
21 #include "avsession_service.h"
22 #include "cast_engine_common.h"
23 #include "hw_cast_stream_player.h"
24 #include "hw_cast_provider.h"
25 #include "i_cast_session.h"
26
27 using namespace testing::ext;
28 using namespace OHOS::CastEngine;
29 namespace OHOS::AVSession {
30
31 static std::shared_ptr<AVSessionService> g_AVSessionService;
32
33 class HwCastSupplementTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void HwCastSupplementTest::SetUpTestCase()
42 {
43 SLOGI("set up AVSessionServiceTest");
44 system("killall -9 com.example.hiMusicDemo");
45 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID);
46 }
47
TearDownTestCase()48 void HwCastSupplementTest::TearDownTestCase()
49 {}
50
SetUp()51 void HwCastSupplementTest::SetUp()
52 {}
53
TearDown()54 void HwCastSupplementTest::TearDown()
55 {}
56
57 class AVCastControllerProxyDemo : public IAVCastControllerProxy {
58 public:
59
Release()60 void Release() {};
61
RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)62 int32_t RegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
63 iAVCastControllerProxyListener) {return 0;}
64
UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener> iAVCastControllerProxyListener)65 int32_t UnRegisterControllerListener(const std::shared_ptr<IAVCastControllerProxyListener>
66 iAVCastControllerProxyListener) {return 0;}
67
GetCurrentItem()68 AVQueueItem GetCurrentItem() {return AVQueueItem();}
69
Start(const AVQueueItem & avQueueItem)70 int32_t Start(const AVQueueItem& avQueueItem) {return 0;}
71
Prepare(const AVQueueItem & avQueueItem)72 int32_t Prepare(const AVQueueItem& avQueueItem) {return 0;}
73
SendControlCommand(const AVCastControlCommand cmd)74 void SendControlCommand(const AVCastControlCommand cmd) {}
75
GetDuration(int32_t & duration)76 int32_t GetDuration(int32_t& duration) {return 0;}
77
GetCastAVPlaybackState(AVPlaybackState & avPlaybackState)78 int32_t GetCastAVPlaybackState(AVPlaybackState& avPlaybackState) {return 0;}
79
SetValidAbility(const std::vector<int32_t> & validAbilityList)80 int32_t SetValidAbility(const std::vector<int32_t>& validAbilityList) {return 0;}
81
GetValidAbility(std::vector<int32_t> & validAbilityList)82 int32_t GetValidAbility(std::vector<int32_t> &validAbilityList) {return 0;}
83
SetDisplaySurface(std::string & surfaceId)84 int32_t SetDisplaySurface(std::string& surfaceId) {return 0;}
85
ProcessMediaKeyResponse(const std::string & assetId,const std::vector<uint8_t> & response)86 int32_t ProcessMediaKeyResponse(const std::string& assetId, const std::vector<uint8_t>& response) {return 0;}
87
RefreshCurrentAVQueueItem(const AVQueueItem & avQueueItem)88 int32_t RefreshCurrentAVQueueItem(const AVQueueItem& avQueueItem) {return 0;}
89
SetSessionCallbackForCastCap(const std::function<void (bool,bool)> & callback)90 void SetSessionCallbackForCastCap(const std::function<void(bool, bool)>& callback) {}
91 };
92
93 class AVCastSessionStateListenerDemo : public IAVCastSessionStateListener {
94 public:
OnCastStateChange(int32_t castState,DeviceInfo deviceInfo)95 void OnCastStateChange(int32_t castState, DeviceInfo deviceInfo) {}
96
OnCastEventRecv(int32_t errorCode,std::string & errorMsg)97 void OnCastEventRecv(int32_t errorCode, std::string& errorMsg) {}
98 };
99
100 class ICastSessionMock : public CastEngine::ICastSession {
101 public:
ICastSessionMock()102 ICastSessionMock() {};
~ICastSessionMock()103 virtual ~ICastSessionMock() {};
RegisterListener(std::shared_ptr<ICastSessionListener> listener)104 virtual int32_t RegisterListener(std::shared_ptr<ICastSessionListener> listener) { return 0; }
UnregisterListener()105 virtual int32_t UnregisterListener() { return 0; }
AddDevice(const CastRemoteDevice & remoteDevice)106 virtual int32_t AddDevice(const CastRemoteDevice &remoteDevice) { return 0; }
RemoveDevice(const std::string & deviceId,const DeviceRemoveAction & actionType=DeviceRemoveAction::ACTION_DISCONNECT)107 virtual int32_t RemoveDevice(const std::string &deviceId,
108 const DeviceRemoveAction &actionType = DeviceRemoveAction::ACTION_DISCONNECT) { return 0; }
StartAuth(const AuthInfo & authInfo)109 virtual int32_t StartAuth(const AuthInfo &authInfo) { return 0; }
GetSessionId(std::string & sessionId)110 virtual int32_t GetSessionId(std::string &sessionId) { return 0; }
SetSessionProperty(const CastSessionProperty & property)111 virtual int32_t SetSessionProperty(const CastSessionProperty &property) { return 0; }
CreateMirrorPlayer(std::shared_ptr<IMirrorPlayer> & mirrorPlayer)112 virtual int32_t CreateMirrorPlayer(std::shared_ptr<IMirrorPlayer> &mirrorPlayer) { return 0; }
CreateStreamPlayer(std::shared_ptr<IStreamPlayer> & streamPlayer)113 virtual int32_t CreateStreamPlayer(std::shared_ptr<IStreamPlayer> &streamPlayer) { return 0; }
NotifyEvent(EventId eventId,std::string & jsonParam)114 virtual int32_t NotifyEvent(EventId eventId, std::string &jsonParam) { return 0; }
SetCastMode(CastMode mode,std::string & jsonParam)115 virtual int32_t SetCastMode(CastMode mode, std::string &jsonParam) { return 0; }
Release()116 virtual int32_t Release() { return 0; }
GetRemoteDeviceInfo(std::string deviceId,CastRemoteDevice & remoteDevice)117 virtual int32_t GetRemoteDeviceInfo(std::string deviceId, CastRemoteDevice &remoteDevice) { return 1; }
118 };
119
120 /**
121 * @tc.name: StopCastSession001
122 * @tc.desc: test StopCastSession
123 * @tc.type: FUNC
124 */
125 static HWTEST(HwCastSupplementTest, StopCastSession001, TestSize.Level0)
126 {
127 SLOGI("StopCastSession001 begin!");
128 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
129 EXPECT_EQ(hwCastProvider != nullptr, true);
130 hwCastProvider->Init();
131
132 int32_t castId = 0;
133 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
134 hwCastProvider->StopCastSession(castId);
135 SLOGI("StopCastSession001 end!");
136 }
137
138 /**
139 * @tc.name: StopCastSession002
140 * @tc.desc: test StopCastSession
141 * @tc.type: FUNC
142 */
143 static HWTEST(HwCastSupplementTest, StopCastSession002, TestSize.Level0)
144 {
145 SLOGI("StopCastSession002 begin!");
146 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
147 EXPECT_EQ(hwCastProvider != nullptr, true);
148 hwCastProvider->Init();
149
150 int32_t castId = 0;
151 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
152 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
153 hwCastProvider->StopCastSession(castId);
154 SLOGI("StopCastSession002 end!");
155 }
156
157 /**
158 * @tc.name: StopCastSession003
159 * @tc.desc: test StopCastSession
160 * @tc.type: FUNC
161 */
162 static HWTEST(HwCastSupplementTest, StopCastSession003, TestSize.Level0)
163 {
164 SLOGI("StopCastSession003 begin!");
165 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
166 EXPECT_EQ(hwCastProvider != nullptr, true);
167 hwCastProvider->Init();
168
169 int32_t castId = -1;
170 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
171 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
172 hwCastProvider->StopCastSession(castId);
173 SLOGI("StopCastSession003 end!");
174 }
175
176 /**
177 * @tc.name: AddCastDevice001
178 * @tc.desc: test AddCastDevice
179 * @tc.type: FUNC
180 */
181 static HWTEST(HwCastSupplementTest, AddCastDevice001, TestSize.Level0)
182 {
183 SLOGI("AddCastDevice001 begin!");
184 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
185 EXPECT_EQ(hwCastProvider != nullptr, true);
186 hwCastProvider->Init();
187
188 int32_t castId = 0;
189 uint32_t spid = 33;
190 DeviceInfo deviceInfo;
191 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo, spid);
192 EXPECT_EQ(ret, false);
193 SLOGI("AddCastDevice001 end!");
194 }
195
196 /**
197 * @tc.name: AddCastDevice002
198 * @tc.desc: test AddCastDevice
199 * @tc.type: FUNC
200 */
201 static HWTEST(HwCastSupplementTest, AddCastDevice002, TestSize.Level0)
202 {
203 SLOGI("AddCastDevice002 begin!");
204 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
205 EXPECT_EQ(hwCastProvider != nullptr, true);
206 hwCastProvider->Init();
207
208 int32_t castId = 0;
209 uint32_t spid = 33;
210 DeviceInfo deviceInfo;
211 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
212 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo, spid);
213 EXPECT_EQ(ret, false);
214 SLOGI("AddCastDevice002 end!");
215 }
216
217 /**
218 * @tc.name: AddCastDevice003
219 * @tc.desc: test AddCastDevice
220 * @tc.type: FUNC
221 */
222 static HWTEST(HwCastSupplementTest, AddCastDevice003, TestSize.Level0)
223 {
224 SLOGI("AddCastDevice003 begin!");
225 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
226 EXPECT_EQ(hwCastProvider != nullptr, true);
227 hwCastProvider->Init();
228
229 int32_t castId = 0;
230 uint32_t spid = 33;
231 DeviceInfo deviceInfo;
232 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
233 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
234 bool ret = hwCastProvider->AddCastDevice(castId, deviceInfo, spid);
235 EXPECT_EQ(ret, false);
236 SLOGI("AddCastDevice003 end!");
237 }
238
239 /**
240 * @tc.name: RemoveCastDevice001
241 * @tc.desc: test RemoveCastDevice
242 * @tc.type: FUNC
243 */
244 static HWTEST(HwCastSupplementTest, RemoveCastDevice001, TestSize.Level0)
245 {
246 SLOGI("RemoveCastDevice001 begin!");
247 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
248 EXPECT_EQ(hwCastProvider != nullptr, true);
249 hwCastProvider->Init();
250
251 int32_t castId = 0;
252 DeviceInfo deviceInfo;
253 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
254 EXPECT_EQ(ret, false);
255 SLOGI("RemoveCastDevice001 end!");
256 }
257
258 /**
259 * @tc.name: RemoveCastDevice002
260 * @tc.desc: test RemoveCastDevice
261 * @tc.type: FUNC
262 */
263 static HWTEST(HwCastSupplementTest, RemoveCastDevice002, TestSize.Level0)
264 {
265 SLOGI("RemoveCastDevice002 begin!");
266 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
267 EXPECT_EQ(hwCastProvider != nullptr, true);
268 hwCastProvider->Init();
269
270 int32_t castId = 0;
271 DeviceInfo deviceInfo;
272 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
273 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
274 EXPECT_EQ(ret, false);
275 SLOGI("RemoveCastDevice002 end!");
276 }
277
278 /**
279 * @tc.name: RemoveCastDevice003
280 * @tc.desc: test RemoveCastDevice
281 * @tc.type: FUNC
282 */
283 static HWTEST(HwCastSupplementTest, RemoveCastDevice003, TestSize.Level0)
284 {
285 SLOGI("RemoveCastDevice003 begin!");
286 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
287 EXPECT_EQ(hwCastProvider != nullptr, true);
288 hwCastProvider->Init();
289
290 int32_t castId = 0;
291 DeviceInfo deviceInfo;
292 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
293 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
294 bool ret = hwCastProvider->RemoveCastDevice(castId, deviceInfo);
295 EXPECT_EQ(ret, false);
296 SLOGI("RemoveCastDevice003 end!");
297 }
298
299 /**
300 * @tc.name: RegisterCastStateListener001
301 * @tc.desc: test RegisterCastStateListener
302 * @tc.type: FUNC
303 */
304 static HWTEST(HwCastSupplementTest, RegisterCastStateListener001, TestSize.Level0)
305 {
306 SLOGI("RegisterCastStateListener001 begin!");
307 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
308 EXPECT_EQ(hwCastProvider != nullptr, true);
309 hwCastProvider->Init();
310
311 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
312 std::make_shared<AVCastProviderManager>();
313 bool ret = hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
314 EXPECT_EQ(ret, true);
315 SLOGI("RegisterCastStateListener001 end!");
316 }
317
318 /**
319 * @tc.name: UnRegisterCastStateListener001
320 * @tc.desc: test UnRegisterCastStateListener
321 * @tc.type: FUNC
322 */
323 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener001, TestSize.Level0)
324 {
325 SLOGI("UnRegisterCastStateListener001 begin!");
326 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
327 EXPECT_EQ(hwCastProvider != nullptr, true);
328 hwCastProvider->Init();
329
330 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
331 std::make_shared<AVCastProviderManager>();
332 hwCastProvider->RegisterCastStateListener(avCastStateListenerDemo);
333 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
334 EXPECT_EQ(ret, true);
335 SLOGI("UnRegisterCastStateListener001 end!");
336 }
337
338 /**
339 * @tc.name: UnRegisterCastStateListener002
340 * @tc.desc: test UnRegisterCastStateListener
341 * @tc.type: FUNC
342 */
343 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener002, TestSize.Level0)
344 {
345 SLOGI("UnRegisterCastStateListener002 begin!");
346 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
347 EXPECT_EQ(hwCastProvider != nullptr, true);
348 hwCastProvider->Init();
349
350 std::shared_ptr<AVCastProviderManager> avCastStateListenerDemo =
351 std::make_shared<AVCastProviderManager>();
352 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
353 EXPECT_EQ(ret, false);
354 SLOGI("UnRegisterCastStateListener002 end!");
355 }
356
357 /**
358 * @tc.name: UnRegisterCastStateListener003
359 * @tc.desc: test UnRegisterCastStateListener
360 * @tc.type: FUNC
361 */
362 static HWTEST(HwCastSupplementTest, UnRegisterCastStateListener003, TestSize.Level0)
363 {
364 SLOGI("UnRegisterCastStateListener003 begin!");
365 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
366 EXPECT_EQ(hwCastProvider != nullptr, true);
367 hwCastProvider->Init();
368
369 std::shared_ptr<IAVCastStateListener> avCastStateListenerDemo = nullptr;
370 bool ret = hwCastProvider->UnRegisterCastStateListener(avCastStateListenerDemo);
371 EXPECT_EQ(ret, false);
372 SLOGI("UnRegisterCastStateListener003 end!");
373 }
374
375 /**
376 * @tc.name: RegisterCastSessionStateListener001
377 * @tc.desc: test RegisterCastSessionStateListener
378 * @tc.type: FUNC
379 */
380 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener001, TestSize.Level0)
381 {
382 SLOGI("RegisterCastSessionStateListener001 begin!");
383 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
384 EXPECT_EQ(hwCastProvider != nullptr, true);
385 hwCastProvider->Init();
386
387 int castId = 0;
388 std::shared_ptr<IAVCastSessionStateListener> listener =
389 std::make_shared<AVCastSessionStateListenerDemo>();
390 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
391 EXPECT_EQ(ret, false);
392 SLOGI("RegisterCastSessionStateListener001 end!");
393 }
394
395 /**
396 * @tc.name: RegisterCastSessionStateListener002
397 * @tc.desc: test RegisterCastSessionStateListener
398 * @tc.type: FUNC
399 */
400 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener002, TestSize.Level0)
401 {
402 SLOGI("RegisterCastSessionStateListener002 begin!");
403 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
404 EXPECT_EQ(hwCastProvider != nullptr, true);
405 hwCastProvider->Init();
406
407 int castId = 0;
408 std::shared_ptr<IAVCastSessionStateListener> listener =
409 std::make_shared<AVCastSessionStateListenerDemo>();
410 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
411 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
412 EXPECT_EQ(ret, false);
413 SLOGI("RegisterCastSessionStateListener002 end!");
414 }
415
416 /**
417 * @tc.name: RegisterCastSessionStateListener003
418 * @tc.desc: test RegisterCastSessionStateListener
419 * @tc.type: FUNC
420 */
421 static HWTEST(HwCastSupplementTest, RegisterCastSessionStateListener003, TestSize.Level0)
422 {
423 SLOGI("RegisterCastSessionStateListener003 begin!");
424 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
425 EXPECT_EQ(hwCastProvider != nullptr, true);
426 hwCastProvider->Init();
427
428 int castId = 0;
429 std::shared_ptr<IAVCastSessionStateListener> listener =
430 std::make_shared<AVCastSessionStateListenerDemo>();
431 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
432 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
433 bool ret = hwCastProvider->RegisterCastSessionStateListener(castId, listener);
434 EXPECT_EQ(ret, true);
435 SLOGI("RegisterCastSessionStateListener003 end!");
436 }
437
438 /**
439 * @tc.name: UnRegisterCastSessionStateListener001
440 * @tc.desc: test UnRegisterCastSessionStateListener
441 * @tc.type: FUNC
442 */
443 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener001, TestSize.Level0)
444 {
445 SLOGI("UnRegisterCastSessionStateListener001 begin!");
446 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
447 EXPECT_EQ(hwCastProvider != nullptr, true);
448 hwCastProvider->Init();
449
450 int castId = 0;
451 std::shared_ptr<IAVCastSessionStateListener> listener =
452 std::make_shared<AVCastSessionStateListenerDemo>();
453 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
454 EXPECT_EQ(ret, false);
455 SLOGI("UnRegisterCastSessionStateListener001 end!");
456 }
457
458 /**
459 * @tc.name: UnRegisterCastSessionStateListener002
460 * @tc.desc: test UnRegisterCastSessionStateListener
461 * @tc.type: FUNC
462 */
463 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener002, TestSize.Level0)
464 {
465 SLOGI("UnRegisterCastSessionStateListener002 begin!");
466 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
467 EXPECT_EQ(hwCastProvider != nullptr, true);
468 hwCastProvider->Init();
469
470 int castId = 0;
471 std::shared_ptr<IAVCastSessionStateListener> listener =
472 std::make_shared<AVCastSessionStateListenerDemo>();
473 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
474 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
475 EXPECT_EQ(ret, false);
476 SLOGI("UnRegisterCastSessionStateListener002 end!");
477 }
478
479 /**
480 * @tc.name: UnRegisterCastSessionStateListener003
481 * @tc.desc: test UnRegisterCastSessionStateListener
482 * @tc.type: FUNC
483 */
484 static HWTEST(HwCastSupplementTest, UnRegisterCastSessionStateListener003, TestSize.Level0)
485 {
486 SLOGI("UnRegisterCastSessionStateListener003 begin!");
487 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
488 EXPECT_EQ(hwCastProvider != nullptr, true);
489 hwCastProvider->Init();
490
491 int castId = 0;
492 std::shared_ptr<IAVCastSessionStateListener> listener =
493 std::make_shared<AVCastSessionStateListenerDemo>();
494 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
495 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
496 bool ret = hwCastProvider->UnRegisterCastSessionStateListener(castId, listener);
497 EXPECT_EQ(ret, false);
498 SLOGI("UnRegisterCastSessionStateListener003 end!");
499 }
500
501 /**
502 * @tc.name: GetRemoteController001
503 * @tc.desc: test GetRemoteController
504 * @tc.type: FUNC
505 */
506 static HWTEST(HwCastSupplementTest, GetRemoteController001, TestSize.Level0)
507 {
508 SLOGI("GetRemoteController001 begin!");
509 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
510 EXPECT_EQ(hwCastProvider != nullptr, true);
511 hwCastProvider->Init();
512
513 int castId = 0;
514 auto ret = hwCastProvider->GetRemoteController(castId);
515 EXPECT_EQ(ret, nullptr);
516 SLOGI("GetRemoteController001 end!");
517 }
518
519 /**
520 * @tc.name: GetRemoteController002
521 * @tc.desc: test GetRemoteController
522 * @tc.type: FUNC
523 */
524 static HWTEST(HwCastSupplementTest, GetRemoteController002, TestSize.Level0)
525 {
526 SLOGI("GetRemoteController002 begin!");
527 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
528 EXPECT_EQ(hwCastProvider != nullptr, true);
529 hwCastProvider->Init();
530
531 int castId = 0;
532 hwCastProvider->avCastControllerMap_[castId] = nullptr;
533 auto ret = hwCastProvider->GetRemoteController(castId);
534 EXPECT_EQ(ret, nullptr);
535 SLOGI("GetRemoteController002 end!");
536 }
537
538 /**
539 * @tc.name: GetRemoteController003
540 * @tc.desc: test GetRemoteController
541 * @tc.type: FUNC
542 */
543 static HWTEST(HwCastSupplementTest, GetRemoteController003, TestSize.Level0)
544 {
545 SLOGI("GetRemoteController003 begin!");
546 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
547 EXPECT_EQ(hwCastProvider != nullptr, true);
548 hwCastProvider->Init();
549
550 int castId = 0;
551 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
552 auto ret = hwCastProvider->GetRemoteController(castId);
553 EXPECT_EQ(ret, nullptr);
554 SLOGI("GetRemoteController003 end!");
555 }
556
557 /**
558 * @tc.name: GetRemoteController004
559 * @tc.desc: test GetRemoteController
560 * @tc.type: FUNC
561 */
562 static HWTEST(HwCastSupplementTest, GetRemoteController004, TestSize.Level0)
563 {
564 SLOGI("GetRemoteController004 begin!");
565 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
566 EXPECT_EQ(hwCastProvider != nullptr, true);
567 hwCastProvider->Init();
568
569 int castId = 0;
570 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
571 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
572 auto ret = hwCastProvider->GetRemoteController(castId);
573 // HwCastProviderSession construct with null can not CreateStreamPlayer
574 EXPECT_EQ(ret, nullptr);
575 SLOGI("GetRemoteController004 end!");
576 }
577
578 /**
579 * @tc.name: SetStreamState001
580 * @tc.desc: test SetStreamState
581 * @tc.type: FUNC
582 */
583 static HWTEST(HwCastSupplementTest, SetStreamState001, TestSize.Level0)
584 {
585 SLOGI("SetStreamState001 begin!");
586 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
587 EXPECT_EQ(hwCastProvider != nullptr, true);
588 hwCastProvider->Init();
589
590 int castId = 0;
591 DeviceInfo deviceInfo;
592 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
593 EXPECT_EQ(ret, false);
594 SLOGI("SetStreamState001 end!");
595 }
596
597 /**
598 * @tc.name: SetStreamState002
599 * @tc.desc: test SetStreamState
600 * @tc.type: FUNC
601 */
602 static HWTEST(HwCastSupplementTest, SetStreamState002, TestSize.Level0)
603 {
604 SLOGI("SetStreamState002 begin!");
605 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
606 EXPECT_EQ(hwCastProvider != nullptr, true);
607 hwCastProvider->Init();
608
609 int castId = 0;
610 DeviceInfo deviceInfo;
611 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
612 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
613 EXPECT_EQ(ret, false);
614 SLOGI("SetStreamState002 end!");
615 }
616
617 /**
618 * @tc.name: SetStreamState003
619 * @tc.desc: test SetStreamState
620 * @tc.type: FUNC
621 */
622 static HWTEST(HwCastSupplementTest, SetStreamState003, TestSize.Level0)
623 {
624 SLOGI("SetStreamState003 begin!");
625 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
626 EXPECT_EQ(hwCastProvider != nullptr, true);
627 hwCastProvider->Init();
628
629 int castId = 0;
630 DeviceInfo deviceInfo;
631 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
632 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
633 bool ret = hwCastProvider->SetStreamState(castId, deviceInfo);
634 EXPECT_EQ(ret, true);
635 SLOGI("SetStreamState003 end!");
636 }
637
638 /**
639 * @tc.name: GetRemoteNetWorkId001
640 * @tc.desc: test GetRemoteNetWorkId
641 * @tc.type: FUNC
642 */
643 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId001, TestSize.Level0)
644 {
645 SLOGI("GetRemoteNetWorkId001 begin!");
646 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
647 EXPECT_EQ(hwCastProvider != nullptr, true);
648 hwCastProvider->Init();
649
650 int castId = 0;
651 std::string deviceId;
652 std::string networkId;
653 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
654 EXPECT_EQ(ret, false);
655 SLOGI("GetRemoteNetWorkId001 end!");
656 }
657
658 /**
659 * @tc.name: GetRemoteNetWorkId002
660 * @tc.desc: test GetRemoteNetWorkId
661 * @tc.type: FUNC
662 */
663 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId002, TestSize.Level0)
664 {
665 SLOGI("GetRemoteNetWorkId002 begin!");
666 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
667 EXPECT_EQ(hwCastProvider != nullptr, true);
668 hwCastProvider->Init();
669
670 int castId = 0;
671 std::string deviceId;
672 std::string networkId;
673 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
674 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
675 EXPECT_EQ(ret, false);
676 SLOGI("GetRemoteNetWorkId002 end!");
677 }
678
679 /**
680 * @tc.name: GetRemoteNetWorkId003
681 * @tc.desc: test GetRemoteNetWorkId
682 * @tc.type: FUNC
683 */
684 static HWTEST(HwCastSupplementTest, GetRemoteNetWorkId003, TestSize.Level0)
685 {
686 SLOGI("GetRemoteNetWorkId003 begin!");
687 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
688 EXPECT_EQ(hwCastProvider != nullptr, true);
689 hwCastProvider->Init();
690
691 int castId = 0;
692 std::string deviceId;
693 std::string networkId;
694 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
695 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
696 bool ret = hwCastProvider->GetRemoteNetWorkId(castId, deviceId, networkId);
697 EXPECT_EQ(ret, false);
698 SLOGI("GetRemoteNetWorkId003 end!");
699 }
700
701 /**
702 * @tc.name: GetRemoteDrmCapabilities001
703 * @tc.desc: test GetRemoteDrmCapabilities
704 * @tc.type: FUNC
705 */
706 static HWTEST(HwCastSupplementTest, GetRemoteDrmCapabilities001, TestSize.Level0)
707 {
708 SLOGI("GetRemoteDrmCapabilities001 begin!");
709 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
710 EXPECT_EQ(hwCastProvider != nullptr, true);
711 hwCastProvider->Init();
712
713 int castId = 0;
714 std::string deviceId;
715 std::vector<std::string> drmCapabilities;
716 bool ret = hwCastProvider->GetRemoteDrmCapabilities(castId, deviceId, drmCapabilities);
717 EXPECT_EQ(ret, false);
718 SLOGI("GetRemoteDrmCapabilities001 end!");
719 }
720
721 /**
722 * @tc.name: GetRemoteDrmCapabilities002
723 * @tc.desc: test GetRemoteDrmCapabilities
724 * @tc.type: FUNC
725 */
726 static HWTEST(HwCastSupplementTest, GetRemoteDrmCapabilities002, TestSize.Level0)
727 {
728 SLOGI("GetRemoteDrmCapabilities002 begin!");
729 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
730 EXPECT_EQ(hwCastProvider != nullptr, true);
731 hwCastProvider->Init();
732
733 int castId = 0;
734 std::string deviceId;
735 std::vector<std::string> drmCapabilities;
736 hwCastProvider->hwCastProviderSessionMap_[castId] = nullptr;
737 bool ret = hwCastProvider->GetRemoteDrmCapabilities(castId, deviceId, drmCapabilities);
738 EXPECT_EQ(ret, false);
739 SLOGI("GetRemoteDrmCapabilities002 end!");
740 }
741
742 /**
743 * @tc.name: GetRemoteDrmCapabilities003
744 * @tc.desc: test GetRemoteDrmCapabilities
745 * @tc.type: FUNC
746 */
747 static HWTEST(HwCastSupplementTest, GetRemoteDrmCapabilities003, TestSize.Level0)
748 {
749 SLOGI("GetRemoteDrmCapabilities003 begin!");
750 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
751 EXPECT_EQ(hwCastProvider != nullptr, true);
752 hwCastProvider->Init();
753
754 int castId = 0;
755 std::string deviceId;
756 std::vector<std::string> drmCapabilities = {"testDrmCapabilities"};
757 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
758 hwCastProvider->hwCastProviderSessionMap_[castId] = hwCastProviderSession;
759 bool ret = hwCastProvider->GetRemoteDrmCapabilities(castId, deviceId, drmCapabilities);
760 EXPECT_EQ(ret, false);
761 SLOGI("GetRemoteDrmCapabilities003 end!");
762 }
763
764 /**
765 * @tc.name: OnDeviceFound001
766 * @tc.desc: test OnDeviceFound
767 * @tc.type: FUNC
768 */
769 static HWTEST(HwCastSupplementTest, OnDeviceFound001, TestSize.Level0)
770 {
771 SLOGI("OnDeviceFound001 begin!");
772 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
773 EXPECT_EQ(hwCastProvider != nullptr, true);
774 hwCastProvider->Init();
775
776 CastEngine::CastRemoteDevice castRemoteDevice;
777 std::vector<CastEngine::CastRemoteDevice> deviceList;
778 deviceList.push_back(castRemoteDevice);
779
780 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
781 hwCastProvider->castStateListenerList_.push_back(ptr);
782
783 hwCastProvider->OnDeviceFound(deviceList);
784 SLOGI("OnDeviceFound001 end!");
785 }
786
787 /**
788 * @tc.name: OnDeviceFound002
789 * @tc.desc: test OnDeviceFound
790 * @tc.type: FUNC
791 */
792 static HWTEST(HwCastSupplementTest, OnDeviceFound002, TestSize.Level0)
793 {
794 SLOGI("OnDeviceFound002 begin!");
795 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
796 EXPECT_EQ(hwCastProvider != nullptr, true);
797 hwCastProvider->Init();
798
799 CastEngine::CastRemoteDevice castRemoteDevice;
800 std::vector<CastEngine::CastRemoteDevice> deviceList;
801 deviceList.push_back(castRemoteDevice);
802
803 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
804 hwCastProvider->castStateListenerList_.push_back(ptr);
805
806 hwCastProvider->OnDeviceFound(deviceList);
807 SLOGI("OnDeviceFound002 end!");
808 }
809
810 /**
811 * @tc.name: OnLogEvent001
812 * @tc.desc: test OnLogEvent
813 * @tc.type: FUNC
814 */
815 static HWTEST(HwCastSupplementTest, OnLogEvent001, TestSize.Level0)
816 {
817 SLOGI("OnLogEvent001 begin!");
818 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
819 EXPECT_EQ(hwCastProvider != nullptr, true);
820 hwCastProvider->Init();
821
822 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
823 hwCastProvider->castStateListenerList_.push_back(ptr);
824
825 int32_t eventId = 0;
826 int64_t param = 0;
827 hwCastProvider->OnLogEvent(eventId, param);
828 SLOGI("OnLogEvent001 end!");
829 }
830
831 /**
832 * @tc.name: OnLogEvent002
833 * @tc.desc: test OnLogEvent
834 * @tc.type: FUNC
835 */
836 static HWTEST(HwCastSupplementTest, OnLogEvent002, TestSize.Level0)
837 {
838 SLOGI("OnLogEvent002 begin!");
839 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
840 EXPECT_EQ(hwCastProvider != nullptr, true);
841 hwCastProvider->Init();
842
843 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
844 hwCastProvider->castStateListenerList_.push_back(ptr);
845
846 int32_t eventId = 0;
847 int64_t param = 0;
848 hwCastProvider->OnLogEvent(eventId, param);
849 SLOGI("OnLogEvent002 end!");
850 }
851
852 /**
853 * @tc.name: OnLogEvent003
854 * @tc.desc: test OnLogEvent
855 * @tc.type: FUNC
856 */
857 static HWTEST(HwCastSupplementTest, OnLogEvent003, TestSize.Level0)
858 {
859 SLOGI("OnLogEvent003 begin!");
860 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
861 EXPECT_EQ(hwCastProvider != nullptr, true);
862 hwCastProvider->Init();
863
864 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
865 hwCastProvider->castStateListenerList_.push_back(ptr);
866
867 int32_t eventId = 1;
868 int64_t param = 0;
869 hwCastProvider->OnLogEvent(eventId, param);
870 SLOGI("OnLogEvent003 end!");
871 }
872
873 /**
874 * @tc.name: OnDeviceOffline001
875 * @tc.desc: test OnDeviceOffline
876 * @tc.type: FUNC
877 */
878 static HWTEST(HwCastSupplementTest, OnDeviceOffline001, TestSize.Level0)
879 {
880 SLOGI("OnDeviceOffline001 begin!");
881 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
882 EXPECT_EQ(hwCastProvider != nullptr, true);
883 hwCastProvider->Init();
884
885 std::shared_ptr<IAVCastStateListener> ptr = nullptr;
886 hwCastProvider->castStateListenerList_.push_back(ptr);
887
888 std::string deviceId = "111";
889 hwCastProvider->OnDeviceOffline(deviceId);
890 SLOGI("OnDeviceOffline001 end!");
891 }
892
893 /**
894 * @tc.name: OnDeviceOffline002
895 * @tc.desc: test OnDeviceOffline
896 * @tc.type: FUNC
897 */
898 static HWTEST(HwCastSupplementTest, OnDeviceOffline002, TestSize.Level0)
899 {
900 SLOGI("OnLogEvent002 begin!");
901 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
902 EXPECT_EQ(hwCastProvider != nullptr, true);
903 hwCastProvider->Init();
904
905 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
906 hwCastProvider->castStateListenerList_.push_back(ptr);
907
908 std::string deviceId = "111";
909 hwCastProvider->OnDeviceOffline(deviceId);
910 SLOGI("OnDeviceOffline002 end!");
911 }
912
913 /**
914 * @tc.name: OnServiceDied001
915 * @tc.desc: test OnServiceDied
916 * @tc.type: FUNC
917 * @tc.require:
918 */
919 static HWTEST(HwCastSupplementTest, OnServiceDied001, TestSize.Level0)
920 {
921 SLOGI("OnServiceDied001 begin!");
922 std::shared_ptr<HwCastProvider> hwCastProvider = std::make_shared<HwCastProvider>();
923 EXPECT_EQ(hwCastProvider != nullptr, true);
924 hwCastProvider->Init();
925
926 std::shared_ptr<AVCastProviderManager> ptr = std::make_shared<AVCastProviderManager>();
927 hwCastProvider->castStateListenerList_.push_back(ptr);
928 hwCastProvider->OnServiceDied();
929 SLOGI("OnServiceDied001 end!");
930 }
931
932 /**
933 * @tc.name: HwCastProviderSession_HwCastProviderSessionRemoveDevice_001
934 * @tc.desc: create session and set continuePlay to true
935 * @tc.type: FUNC
936 * @tc.require:
937 */
938 static HWTEST(HwCastSupplementTest, HwCastProviderSession_HwCastProviderSessionRemoveDevice_001, TestSize.Level0)
939 {
940 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_001 begin!");
941 auto session = std::make_shared<ICastSessionMock>();
942 auto provideSession = std::make_shared<HwCastProviderSession>(session);
943 EXPECT_EQ(provideSession != nullptr, true);
944 provideSession->Init();
945 std::string deviceId = "test";
946 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
947 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_001 end!");
948 }
949
950 /**
951 * @tc.name: HwCastProviderSession_HwCastProviderSessionRemoveDevice_002
952 * @tc.desc: create session and set continuePlay to false
953 * @tc.type: FUNC
954 * @tc.require:
955 */
956 static HWTEST(HwCastSupplementTest, HwCastProviderSession_HwCastProviderSessionRemoveDevice_002, TestSize.Level0)
957 {
958 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_002 begin!");
959 auto session = std::make_shared<ICastSessionMock>();
960 auto provideSession = std::make_shared<HwCastProviderSession>(session);
961 EXPECT_EQ(provideSession != nullptr, true);
962 provideSession->Init();
963 std::string deviceId = "test";
964 EXPECT_EQ(provideSession->RemoveDevice(deviceId), false);
965 SLOGI("HwCastProviderSession_HwCastProviderSessionRemoveDevice_002 end!");
966 }
967
968 /**
969 * @tc.name: HwCastProviderSession_GetRemoteDrmCapabilities_001
970 * @tc.desc: set sesion to not nullptr
971 * @tc.type: FUNC
972 * @tc.require:
973 */
974 static HWTEST(HwCastSupplementTest, HwCastProviderSession_GetRemoteDrmCapabilities_001, TestSize.Level0)
975 {
976 SLOGI("HwCastProviderSession_GetRemoteDrmCapabilities_001 begin!");
977 auto session = std::make_shared<ICastSessionMock>();
978 auto provideSession = std::make_shared<HwCastProviderSession>(session);
979 EXPECT_EQ(provideSession != nullptr, true);
980 provideSession->Init();
981 std::string deviceId = "001";
982 std::vector<std::string> drmCapabilities = {"testDrmCapabilities"};
983 bool ret = provideSession->GetRemoteDrmCapabilities(deviceId, drmCapabilities);
984 EXPECT_EQ(ret, true);
985 SLOGI("HwCastProviderSession_GetRemoteDrmCapabilities_001 end!");
986 }
987
988 /**
989 * @tc.name: HwCastProviderSession_GetRemoteNetWorkId_001
990 * @tc.desc: set sesion to not nullptr
991 * @tc.type: FUNC
992 * @tc.require:
993 */
994 static HWTEST(HwCastSupplementTest, HwCastProviderSession_GetRemoteNetWorkId_001, TestSize.Level0)
995 {
996 SLOGI("HwCastProviderSession_GetRemoteNetWorkId_001 begin!");
997 auto session = std::make_shared<ICastSessionMock>();
998 auto provideSession = std::make_shared<HwCastProviderSession>(session);
999 EXPECT_EQ(provideSession != nullptr, true);
1000 provideSession->Init();
1001 std::string deviceId = "001";
1002 std::string networkId = "0.0.0.0";
1003 bool ret = provideSession->GetRemoteNetWorkId(deviceId, networkId);
1004 EXPECT_EQ(ret, true);
1005 SLOGI("HwCastProviderSession_GetRemoteNetWorkId_001 end!");
1006 }
1007
1008 /**
1009 * @tc.name: HwCastProviderSession_RegisterCastSessionStateListener_001
1010 * @tc.desc: set nullptr listener
1011 * @tc.type: FUNC
1012 * @tc.require:
1013 */
1014 static HWTEST(HwCastSupplementTest, HwCastProviderSession_RegisterCastSessionStateListener_001, TestSize.Level0)
1015 {
1016 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_001 begin!");
1017 auto session = std::make_shared<ICastSessionMock>();
1018 auto provideSession = std::make_shared<HwCastProviderSession>(session);
1019 EXPECT_EQ(provideSession != nullptr, true);
1020 provideSession->Init();
1021 bool ret = provideSession->RegisterCastSessionStateListener(nullptr);
1022 EXPECT_EQ(ret, false);
1023 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_001 end!");
1024 }
1025
1026 /**
1027 * @tc.name: HwCastProviderSession_RegisterCastSessionStateListener_002
1028 * @tc.desc: set not nullptr listener
1029 * @tc.type: FUNC
1030 * @tc.require:
1031 */
1032 static HWTEST(HwCastSupplementTest, HwCastProviderSession_RegisterCastSessionStateListener_002, TestSize.Level0)
1033 {
1034 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_002 begin!");
1035 auto session = std::make_shared<ICastSessionMock>();
1036 auto provideSession = std::make_shared<HwCastProviderSession>(session);
1037 EXPECT_EQ(provideSession != nullptr, true);
1038 provideSession->Init();
1039 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
1040 bool ret = provideSession->RegisterCastSessionStateListener(listener);
1041 EXPECT_EQ(ret, true);
1042 SLOGI("HwCastProviderSession_RegisterCastSessionStateListener_002 end!");
1043 }
1044
1045 /**
1046 * @tc.name: HwCastProviderSession_UnRegisterCastSessionStateListener_001
1047 * @tc.desc: have no to push listener ptr
1048 * @tc.type: FUNC
1049 * @tc.require:
1050 */
1051 static HWTEST(HwCastSupplementTest, HwCastProviderSession_UnRegisterCastSessionStateListener_001, TestSize.Level0)
1052 {
1053 SLOGI("HwCastProviderSession_UnRegisterCastSessionStateListener_001 begin!");
1054 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
1055 bool ret = hwCastProviderSession->UnRegisterCastSessionStateListener(nullptr);
1056 EXPECT_EQ(ret, false);
1057 }
1058
1059 /**
1060 * @tc.name: HwCastProviderSession_UnRegisterCastSessionStateListener_002
1061 * @tc.desc: push a nullptr listener ptr
1062 * @tc.type: FUNC
1063 * @tc.require:
1064 */
1065 static HWTEST(HwCastSupplementTest, HwCastProviderSession_UnRegisterCastSessionStateListener_002, TestSize.Level0)
1066 {
1067 SLOGI("HwCastProviderSession_UnRegisterCastSessionStateListener_002 begin!");
1068 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
1069 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
1070 bool ret = hwCastProviderSession->UnRegisterCastSessionStateListener(listener);
1071 EXPECT_EQ(ret, false);
1072 }
1073
1074 /**
1075 * @tc.name: HwCastProviderSession_UnRegisterCastSessionStateListener_003
1076 * @tc.desc: push a not nullptr listener ptr
1077 * @tc.type: FUNC
1078 * @tc.require:
1079 */
1080 static HWTEST(HwCastSupplementTest, HwCastProviderSession_UnRegisterCastSessionStateListener_003, TestSize.Level0)
1081 {
1082 SLOGI("HwCastProviderSession_UnRegisterCastSessionStateListener_003 begin!");
1083 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
1084 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
1085 hwCastProviderSession->castSessionStateListenerList_.push_back(listener);
1086 bool ret = hwCastProviderSession->UnRegisterCastSessionStateListener(listener);
1087 EXPECT_EQ(ret, true);
1088 }
1089
1090 /**
1091 * @tc.name: HwCastProviderSession_RegisterCastSessionStateListener_003
1092 * @tc.desc: listener is already in castSessionStateListenerList_
1093 * @tc.type: FUNC
1094 * @tc.require:
1095 */
1096 static HWTEST(HwCastSupplementTest, HwCastProviderSession_RegisterCastSessionStateListener_003, TestSize.Level0)
1097 {
1098 SLOGI("HwCastProviderSession_UnRegisterCastSessionStateListener_003 begin!");
1099 auto hwCastProviderSession = std::make_shared<HwCastProviderSession>(nullptr);
1100 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
1101 hwCastProviderSession->stashDeviceState_ = 1;
1102 hwCastProviderSession->castSessionStateListenerList_.push_back(listener);
1103 bool ret = hwCastProviderSession->RegisterCastSessionStateListener(listener);
1104 EXPECT_EQ(ret, false);
1105 }
1106
1107 /**
1108 * @tc.name: HwCastProviderSession_OnDeviceState_001
1109 * @tc.desc: duplicate devicestate
1110 * @tc.type: FUNC
1111 * @tc.require:
1112 */
1113 static HWTEST(HwCastSupplementTest, HwCastProviderSession_OnDeviceState_001, TestSize.Level0)
1114 {
1115 SLOGI("HwCastProviderSession_OnDeviceState_001 begin!");
1116 auto provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1117 EXPECT_EQ(provideSession != nullptr, true);
1118 provideSession->Init();
1119 OHOS::CastEngine::DeviceStateInfo stateInfo;
1120 stateInfo.deviceId = "testDeviceId";
1121 stateInfo.deviceState = static_cast<OHOS::CastEngine::DeviceState>(1);
1122 provideSession->stashDeviceState_ = 1;
1123 provideSession->OnDeviceState(stateInfo);
1124 SLOGI("HwCastProviderSession_OnDeviceState_001 end!");
1125 }
1126
1127 /**
1128 * @tc.name: HwCastProviderSession_OnDeviceState_002
1129 * @tc.desc: duplicate devicestate
1130 * @tc.type: FUNC
1131 * @tc.require:
1132 */
1133 static HWTEST(HwCastSupplementTest, HwCastProviderSession_OnDeviceState_002, TestSize.Level0)
1134 {
1135 SLOGI("HwCastProviderSession_OnDeviceState_002 begin!");
1136 auto provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1137 EXPECT_EQ(provideSession != nullptr, true);
1138 provideSession->Init();
1139 OHOS::CastEngine::DeviceStateInfo stateInfo;
1140 stateInfo.deviceId = "testDeviceId";
1141 stateInfo.deviceState = static_cast<OHOS::CastEngine::DeviceState>(1);
1142 auto listener = std::make_shared<AVCastSessionStateListenerDemo>();
1143 provideSession->stashDeviceState_ = 2;
1144 provideSession->castSessionStateListenerList_.push_back(listener);
1145 provideSession->OnDeviceState(stateInfo);
1146 SLOGI("HwCastProviderSession_OnDeviceState_002 end!");
1147 }
1148
1149 /**
1150 * @tc.name: HwCastProviderSession_OnEvent_001
1151 * @tc.desc: eventId is invalid
1152 * @tc.type: FUNC
1153 * @tc.require:
1154 */
1155 static HWTEST(HwCastSupplementTest, HwCastProviderSession_OnEvent_001, TestSize.Level0)
1156 {
1157 SLOGI("HwCastProviderSession_OnEvent_001 begin!");
1158 auto provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1159 EXPECT_EQ(provideSession != nullptr, true);
1160 provideSession->Init();
1161 OHOS::CastEngine::EventId eventId = static_cast<OHOS::CastEngine::EventId>(1);
1162 std::string jsonParam = "test";
1163 provideSession->OnEvent(eventId, jsonParam);
1164 SLOGI("HwCastProviderSession_OnEvent_001 end!");
1165 }
1166
1167 /**
1168 * @tc.name: HwCastProviderSession_OnEvent_002
1169 * @tc.desc: eventId is invalid
1170 * @tc.type: FUNC
1171 * @tc.require:
1172 */
1173 static HWTEST(HwCastSupplementTest, HwCastProviderSession_OnEvent_002, TestSize.Level0)
1174 {
1175 SLOGI("HwCastProviderSession_OnEvent_002 begin!");
1176 auto provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1177 EXPECT_EQ(provideSession != nullptr, true);
1178 provideSession->Init();
1179 OHOS::CastEngine::EventId eventId = static_cast<OHOS::CastEngine::EventId>(10000);
1180 std::string jsonParam = "test";
1181 provideSession->OnEvent(eventId, jsonParam);
1182 SLOGI("HwCastProviderSession_OnEvent_002 end!");
1183 }
1184
1185 /**
1186 * @tc.name: HwCastProviderSession_OnEvent_003
1187 * @tc.desc: eventId is valid
1188 * @tc.type: FUNC
1189 * @tc.require:
1190 */
1191 static HWTEST(HwCastSupplementTest, HwCastProviderSession_OnEvent_003, TestSize.Level0)
1192 {
1193 SLOGI("HwCastProviderSession_OnEvent_003 begin!");
1194 auto provideSession = std::make_shared<HwCastProviderSession>(nullptr);
1195 EXPECT_EQ(provideSession != nullptr, true);
1196 provideSession->Init();
1197 OHOS::CastEngine::EventId eventId = static_cast<OHOS::CastEngine::EventId>(2500);
1198 std::string jsonParam = "test";
1199 provideSession->OnEvent(eventId, jsonParam);
1200 SLOGI("HwCastProviderSession_OnEvent_003 end!");
1201 }
1202
1203 /**
1204 * @tc.name: HwCastSessonToast001
1205 * @tc.desc:
1206 * @tc.type: FUNC
1207 * @tc.require:
1208 */
1209 static HWTEST(HwCastTest, HwCastSessonToast001, TestSize.Level1)
1210 {
1211 SLOGI("HwCastSessonToast001 begin!");
1212 auto session = std::make_shared<ICastSessionMock>();
1213 auto provideSession = std::make_shared<HwCastProviderSession>(session);
1214 EXPECT_EQ(provideSession != nullptr, true);
1215 OHOS::CastEngine::DeviceStateInfo stateInfo;
1216 stateInfo.deviceId = "testDeviceId";
1217 stateInfo.deviceState = OHOS::CastEngine::DeviceState::DISCONNECTED;
1218 provideSession->OnDeviceState(stateInfo);
1219 stateInfo.deviceState = OHOS::CastEngine::DeviceState::AUTHING;
1220 provideSession->OnDeviceState(stateInfo);
1221 provideSession->AddDevice("testDeviceId", 0);
1222 stateInfo.deviceState = OHOS::CastEngine::DeviceState::DISCONNECTED;
1223 provideSession->OnDeviceState(stateInfo);
1224 stateInfo.deviceState = OHOS::CastEngine::DeviceState::STREAM;
1225 provideSession->OnDeviceState(stateInfo);
1226 stateInfo.deviceState = OHOS::CastEngine::DeviceState::DISCONNECTED;
1227 provideSession->OnDeviceState(stateInfo);
1228 provideSession->RemoveDevice("testDeviceId");
1229 provideSession->OnDeviceState(stateInfo);
1230 stateInfo.deviceState = OHOS::CastEngine::DeviceState::STREAM_TO_MIRROR;
1231 provideSession->OnDeviceState(stateInfo);
1232 EXPECT_EQ(provideSession != nullptr, true);
1233 SLOGI("HwCastSessonToast001 end!");
1234 }
1235
1236 } // OHOS::AVSession