1 /*
2 * Copyright (c) 2023 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 <chrono>
18 #include <thread>
19
20 #include "accesstoken_kit.h"
21 #include "nativetoken_kit.h"
22 #include "token_setproc.h"
23 #include "avmeta_data.h"
24 #include "avplayback_state.h"
25 #include "avsession_errors.h"
26 #include "avsession_item.h"
27 #include "avsession_log.h"
28 #include "migrate_avsession_constant.h"
29 #include "system_ability_definition.h"
30 #define private public
31 #define protected public
32 #include "avsession_service.h"
33 #include "migrate_avsession_manager.h"
34 #undef protected
35 #undef private
36
37 using namespace testing::ext;
38 using namespace OHOS::AVSession;
39
40 static const char* g_perms[] = {"ohos.permission.DISTRIBUTED_SOFTBUS_CENTER", "ohos.permission.DISTRIBUTED_DATASYNC",
41 "ohos.permission.ACCESS_SERVICE_DM"};
42 static const int SIZE = 3;
43 static const int64_t TEST_DURATION = 40000;
44 static const double TEST_SPEED = 1.5;
45 static const int64_t TEST_BUFFERED_TIME = 60000;
46 static const int32_t TEST_LOOG_MODE = 2;
47 static std::shared_ptr<MigrateAVSessionServer> server_;
48 static AVSessionService *avservice_;
49
50 class MigrateAVSessionTest : public testing::Test {
51 public:
52 static void SetUpTestCase();
53 static void TearDownTestCase();
54 void SetUp();
55 void TearDown();
56 void NativeTokenGet(const char *perms[], int size);
57 };
58
SetUpTestCase()59 void MigrateAVSessionTest::SetUpTestCase()
60 {
61 SLOGI("MigrateAVSessionTest SetUpTestCase");
62 server_ = std::make_shared<MigrateAVSessionServer>();
63 avservice_ = new AVSessionService(OHOS::AVSESSION_SERVICE_ID);
64 }
65
TearDownTestCase()66 void MigrateAVSessionTest::TearDownTestCase()
67 {
68 SLOGI("MigrateAVSessionTest TearDownTestCase");
69 server_ = nullptr;
70 avservice_ = nullptr;
71 }
72
SetUp()73 void MigrateAVSessionTest::SetUp()
74 {
75 SLOGI("MigrateAVSessionTest SetUp");
76 NativeTokenGet(g_perms, SIZE);
77 }
78
TearDown()79 void MigrateAVSessionTest::TearDown()
80 {
81 SLOGI("MigrateAVSessionTest TearDown");
82 NativeTokenGet(nullptr, 0);
83 }
84
NativeTokenGet(const char * perms[],int size)85 void MigrateAVSessionTest::NativeTokenGet(const char *perms[], int size)
86 {
87 uint64_t tokenId;
88 NativeTokenInfoParams infoInstance = {
89 .dcapsNum = 0,
90 .permsNum = size,
91 .aclsNum = 0,
92 .dcaps = nullptr,
93 .perms = perms,
94 .acls = nullptr,
95 .aplStr = "system_basic",
96 };
97
98 infoInstance.processName = "migrate_softbus_test";
99 tokenId = GetAccessTokenId(&infoInstance);
100 SetSelfTokenID(tokenId);
101 OHOS::Security::AccessToken::AccessTokenKit::ReloadNativeTokenInfo();
102 }
103
104 /**
105 * @tc.name: GetCharacteristic001
106 * @tc.desc:
107 * @tc.type: FUNC
108 * @tc.require:
109 */
110 static HWTEST_F(MigrateAVSessionTest, GetCharacteristic001, TestSize.Level1)
111 {
112 SLOGI("GetCharacteristic001 begin");
113 int32_t ret = server_->GetCharacteristic();
114 EXPECT_EQ(ret, MSG_HEAD_MODE);
115 SLOGI("GetCharacteristic001 end");
116 }
117
118 /**
119 * @tc.name: ResetSupportCrossMediaPlay001
120 * @tc.desc:
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124 static HWTEST_F(MigrateAVSessionTest, ResetSupportCrossMediaPlay001, TestSize.Level1)
125 {
126 SLOGI("ResetSupportCrossMediaPlay001 begin");
127 server_->ResetSupportCrossMediaPlay("");
128 EXPECT_EQ(server_->supportCrossMediaPlay_, false);
129 SLOGI("ResetSupportCrossMediaPlay001 end");
130 }
131
SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)132 void SetMetaDataAndPlaybackState(OHOS::sptr<AVSessionItem> avsession_)
133 {
134 SLOGI("MigrateTest001 SetMetaDataAndPlaybackState");
135 AVMetaData metaData;
136 metaData.Reset();
137 metaData.SetAssetId("123");
138 metaData.SetTitle("Black Humor");
139 metaData.SetArtist("zhoujielun");
140 metaData.SetAuthor("zhoujielun");
141 metaData.SetAlbum("Jay");
142 metaData.SetWriter("zhoujielun");
143 metaData.SetComposer("zhoujielun");
144 metaData.SetDuration(TEST_DURATION);
145 metaData.SetMediaImageUri("xxxxx");
146 metaData.SetSubTitle("fac");
147 metaData.SetDescription("for friends");
148 metaData.SetLyric("xxxxx");
149 avsession_->SetAVMetaData(metaData);
150
151 AVPlaybackState playbackState;
152 playbackState.SetState(AVPlaybackState::PLAYBACK_STATE_PLAY);
153 playbackState.SetSpeed(TEST_SPEED);
154 playbackState.SetPosition({ 80000, 0 });
155 playbackState.SetBufferedTime(TEST_BUFFERED_TIME);
156 playbackState.SetLoopMode(TEST_LOOG_MODE);
157 playbackState.SetFavorite(true);
158 avsession_->SetAVPlaybackState(playbackState);
159 }
160
TestMigrateConnect(AVSessionService * avservice_,std::shared_ptr<MigrateAVSessionServer> server_,std::shared_ptr<MigrateAVSessionManager> migrateManager_,int32_t sessionId,std::string deviceId)161 void TestMigrateConnect(AVSessionService *avservice_, std::shared_ptr<MigrateAVSessionServer> server_,
162 std::shared_ptr<MigrateAVSessionManager> migrateManager_, int32_t sessionId, std::string deviceId)
163 {
164 SLOGI("MigrateTest001 TestMigrateConnect");
165 avservice_->SuperLauncher("", "SuperLauncher-Dual", "", "CONNECTING");
166 avservice_->AddInnerSessionListener(server_.get());
167
168 server_->Init(avservice_);
169 migrateManager_->CreateLocalSessionStub("SuperLauncher-Dual", server_);
170 EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher-Dual") != migrateManager_->serverMap_.end(), true);
171
172 char infoName[] = "testInfoName";
173 char infoNetworkId[] = "testInfoNetworkId";
174 char infoPkgName[] = "testInfoPkgName";
175 PeerSocketInfo info = {
176 .name = infoName,
177 .networkId = infoNetworkId,
178 .pkgName = infoPkgName,
179 .dataType = DATA_TYPE_BYTES,
180 };
181 migrateManager_->softBusDistributedDataMgr_->SessionOpened(sessionId, info);
182 migrateManager_->softBusDistributedDataMgr_->OnSessionServerOpened();
183 migrateManager_->softBusDistributedDataMgr_->MessageReceived(sessionId, "");
184 migrateManager_->softBusDistributedDataMgr_->OnMessageHandleReceived(sessionId, "");
185 server_->ConnectProxy(sessionId);
186 server_->OnConnectSession(sessionId);
187 server_->OnConnectProxy(deviceId);
188 EXPECT_EQ(server_->isSoftbusConnecting_, true);
189 }
190
TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_,std::shared_ptr<MigrateAVSessionServer> server_,std::string deviceId)191 void TestMigrateSendByte(OHOS::sptr<AVSessionItem> avsession_, std::shared_ptr<MigrateAVSessionServer> server_,
192 std::string deviceId)
193 {
194 SLOGI("MigrateTest001 TestMigrateSendByte");
195 AVSessionDescriptor descriptor = avsession_->GetDescriptor();
196 server_->OnSessionCreate(descriptor);
197 server_->OnTopSessionChange(descriptor);
198
199 server_->ObserveControllerChanged(deviceId);
200 server_->CreateController(descriptor.sessionId_);
201 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) !=
202 server_->playerIdToControllerCallbackMap_.end(), true);
203
204 OHOS::sptr<AVControllerItem> controller = nullptr;
205 int32_t ret = server_->GetControllerById(descriptor.sessionId_, controller);
206 EXPECT_EQ(ret, AVSESSION_SUCCESS);
207
208 server_->ResetSupportCrossMediaPlay("{\"mIsSupportSingleFrameMediaPlay\": true}");
209 EXPECT_EQ(server_->supportCrossMediaPlay_, true);
210
211 server_->SendSpecialKeepaliveData();
212 server_->SendRemoteControllerList(deviceId);
213 server_->SendRemoteHistorySessionList(deviceId);
214 server_->ClearRemoteControllerList(deviceId);
215 server_->ClearRemoteHistorySessionList(deviceId);
216
217 char header[] = {MSG_HEAD_MODE, SYNC_COMMAND};
218 const int commandList[] = {18, 30, 31, 36, 37, 38, 39, 41, 42, 43, 46, 48, 50};
219 for (int command : commandList) {
220 std::string data = std::string(header) + "{\"PlayerId\"" + descriptor.sessionId_ +
221 "\",\"MediaCommand\":" + std::to_string(command) + ",\"command\":\"\"}";
222 server_->OnBytesReceived(deviceId, data);
223 }
224
225 server_->OnMetaDataChange(descriptor.sessionId_, avsession_->GetMetaData());
226 server_->OnPlaybackStateChanged(descriptor.sessionId_, avsession_->GetPlaybackState());
227 }
228
229 /**
230 * @tc.name: MigrateTest001
231 * @tc.desc:
232 * @tc.type: FUNC
233 * @tc.require:
234 */
235 static HWTEST_F(MigrateAVSessionTest, MigrateTest001, TestSize.Level1)
236 {
237 SLOGI("MigrateTest001 begin");
238 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
239 int32_t sessionId = 1;
240 std::string deviceId = "538CF5694D736D03B42DAF483D5A8C8E432ADECFAD5A75270F70856028219C64";
241 TestMigrateConnect(avservice_, server_, migrateManager_, sessionId, deviceId);
242
243 OHOS::AppExecFwk::ElementName elementName;
244 elementName.SetBundleName("test.ohos.avsession");
245 elementName.SetAbilityName("test.ability");
246 OHOS::sptr<AVSessionItem> avsession_ =
247 avservice_->CreateSessionInner("test", AVSession::SESSION_TYPE_AUDIO, false, elementName);
248 SetMetaDataAndPlaybackState(avsession_);
249 AVSessionDescriptor descriptor = avsession_->GetDescriptor();
250 TestMigrateSendByte(avsession_, server_, deviceId);
251
252 // disconnect release
253 avservice_->SuperLauncher("", "SuperLauncher-Dual", "", "IDLE");
254 avservice_->RemoveInnerSessionListener(server_.get());
255 server_->OnSessionRelease(descriptor);
256 server_->ClearCacheBySessionId(descriptor.sessionId_);
257 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(descriptor.sessionId_) ==
258 server_->playerIdToControllerCallbackMap_.end(), true);
259 avsession_->Destroy();
260 server_->DisconnectAllProxy();
261 server_->DisconnectProxy(sessionId);
262 server_->OnDisConnectSession(sessionId);
263 server_->OnDisconnectProxy(deviceId);
264 EXPECT_EQ(server_->isSoftbusConnecting_, false);
265 migrateManager_->ReleaseLocalSessionStub("SuperLauncher-Dual");
266 EXPECT_EQ(migrateManager_->serverMap_.find("SuperLauncher-Dual") == migrateManager_->serverMap_.end(), true);
267 SLOGI("MigrateTest001 end");
268 }
269
270 /**
271 * @tc.name: CreateController001
272 * @tc.desc:
273 * @tc.type: FUNC
274 * @tc.require:
275 */
276 static HWTEST_F(MigrateAVSessionTest, CreateController001, TestSize.Level1)
277 {
278 SLOGI("CreateController001 begin");
279 const std::string sessionId = "1111";
280 server_->Init(avservice_);
281 server_->CreateController(sessionId);
282 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
283 server_->playerIdToControllerCallbackMap_.end(), true);
284 SLOGI("CreateController001 end");
285 }
286
287 /**
288 * @tc.name: ClearCacheBySessionId001
289 * @tc.desc:
290 * @tc.type: FUNC
291 * @tc.require:
292 */
293 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId001, TestSize.Level1)
294 {
295 SLOGI("ClearCacheBySessionId001 begin");
296 const std::string sessionId = "1111";
297 server_->ClearCacheBySessionId(sessionId);
298 EXPECT_EQ(server_->playerIdToControllerMap_.find(sessionId) == server_->playerIdToControllerMap_.end(), true);
299 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.find(sessionId) ==
300 server_->playerIdToControllerCallbackMap_.end(), true);
301 SLOGI("ClearCacheBySessionId001 end");
302 }
303
304 /**
305 * @tc.name: StopObserveControllerChanged001
306 * @tc.desc:
307 * @tc.type: FUNC
308 * @tc.require:
309 */
310 static HWTEST_F(MigrateAVSessionTest, StopObserveControllerChanged001, TestSize.Level1)
311 {
312 SLOGI("StopObserveControllerChanged001 begin");
313 const std::string deviceId = "1111";
314 server_->StopObserveControllerChanged(deviceId);
315 EXPECT_EQ(server_->playerIdToControllerMap_.size() == 0, true);
316 EXPECT_EQ(server_->sortControllerList_.size() == 0, true);
317 EXPECT_EQ(server_->playerIdToControllerCallbackMap_.size() == 0, true);
318 SLOGI("StopObserveControllerChanged001 end");
319 }
320
321 /**
322 * @tc.name: GetControllerById001
323 * @tc.desc:
324 * @tc.type: FUNC
325 * @tc.require:
326 */
327 static HWTEST_F(MigrateAVSessionTest, GetControllerById001, TestSize.Level1)
328 {
329 SLOGI("GetControllerById001 begin");
330 const std::string sessionId = "123";
331 OHOS::sptr<AVControllerItem> controller = nullptr;
332 int32_t ret = server_->GetControllerById(sessionId, controller);
333 EXPECT_EQ(ret, AVSESSION_ERROR);
334 SLOGI("GetControllerById001 end");
335 }
336
337 /**
338 * @tc.name: GetControllerById002
339 * @tc.desc:
340 * @tc.type: FUNC
341 * @tc.require:
342 */
343 static HWTEST_F(MigrateAVSessionTest, GetControllerById002, TestSize.Level1)
344 {
345 SLOGI("GetControllerById002 begin");
346 const std::string sessionId = "123";
347 OHOS::sptr<AVControllerItem> controller = nullptr;
348 server_->playerIdToControllerMap_[sessionId] = controller;
349 int32_t ret = server_->GetControllerById(sessionId, controller);
350 EXPECT_EQ(ret, AVSESSION_SUCCESS);
351 SLOGI("GetControllerById002 end");
352 }
353
354 /**
355 * @tc.name: ConvertStateFromSingleToDouble001
356 * @tc.desc:
357 * @tc.type: FUNC
358 * @tc.require:
359 */
360 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble001, TestSize.Level1)
361 {
362 SLOGI("ConvertStateFromSingleToDouble001 begin");
363 int32_t state = AVPlaybackState::PLAYBACK_STATE_PLAY;
364 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
365 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PLAY);
366 SLOGI("ConvertStateFromSingleToDouble001 end");
367 }
368
369 /**
370 * @tc.name: ConvertStateFromSingleToDouble002
371 * @tc.desc:
372 * @tc.type: FUNC
373 * @tc.require:
374 */
375 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble002, TestSize.Level1)
376 {
377 SLOGI("ConvertStateFromSingleToDouble002 begin");
378 int32_t state = AVPlaybackState::PLAYBACK_STATE_PAUSE;
379 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
380 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_PAUSE);
381 SLOGI("ConvertStateFromSingleToDouble002 end");
382 }
383
384 /**
385 * @tc.name: ConvertStateFromSingleToDouble003
386 * @tc.desc:
387 * @tc.type: FUNC
388 * @tc.require:
389 */
390 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble003, TestSize.Level1)
391 {
392 SLOGI("ConvertStateFromSingleToDouble003 begin");
393 int32_t state = AVPlaybackState::PLAYBACK_STATE_STOP;
394 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
395 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_STOP);
396 SLOGI("ConvertStateFromSingleToDouble003 end");
397 }
398
399 /**
400 * @tc.name: ConvertStateFromSingleToDouble004
401 * @tc.desc:
402 * @tc.type: FUNC
403 * @tc.require:
404 */
405 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble004, TestSize.Level1)
406 {
407 SLOGI("ConvertStateFromSingleToDouble004 begin");
408 int32_t state = AVPlaybackState::PLAYBACK_STATE_ERROR;
409 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
410 EXPECT_EQ(ret, MEDIA_SESSION_PLAYBACK_STATE_ERROR);
411 SLOGI("ConvertStateFromSingleToDouble004 end");
412 }
413
414 /**
415 * @tc.name: ConvertStateFromSingleToDouble005
416 * @tc.desc:
417 * @tc.type: FUNC
418 * @tc.require:
419 */
420 static HWTEST_F(MigrateAVSessionTest, ConvertStateFromSingleToDouble005, TestSize.Level1)
421 {
422 SLOGI("ConvertStateFromSingleToDouble005 begin");
423 int32_t state = 13;
424 int32_t ret = server_->ConvertStateFromSingleToDouble(state);
425 EXPECT_EQ(ret, state);
426 SLOGI("ConvertStateFromSingleToDouble005 end");
427 }
428
429 /**
430 * @tc.name: ConvertMetadataToJson001
431 * @tc.desc:
432 * @tc.type: FUNC
433 * @tc.require:
434 */
435 static HWTEST_F(MigrateAVSessionTest, ConvertMetadataToJson001, TestSize.Level1)
436 {
437 SLOGI("ConvertMetadataToJson001 begin");
438 AVMetaData metadata;
439 metadata.SetTitle("song");
440 metadata.SetArtist("sing");
441 Json::Value ret = server_->ConvertMetadataToJson(metadata);
442 EXPECT_EQ(ret[METADATA_TITLE], "song");
443 EXPECT_EQ(ret[METADATA_ARTIST], "sing");
444 SLOGI("ConvertMetadataToJson001 end");
445 }
446
447 /**
448 * @tc.name: ConvertMetadataInfoToStr001
449 * @tc.desc:
450 * @tc.type: FUNC
451 * @tc.require:
452 */
453 static HWTEST_F(MigrateAVSessionTest, ConvertMetadataInfoToStr001, TestSize.Level1)
454 {
455 SLOGI("ConvertMetadataInfoToStr001 begin");
456 const std::string playerId = "123";
457 int32_t controlCommand = 9;
458 AVMetaData metadata;
459 metadata.SetDuration(-2);
460 Json::Value result;
461 result[PLAYER_ID] = playerId;
462 result[MEDIA_INFO] = controlCommand;
463 result[METADATA_IMAGE] = "";
464 result[METADATA_ARTIST] = "";
465 result[METADATA_TITLE] = "";
466 Json::FastWriter writer;
467 std::string msg = "d\002" + writer.write(result);
468 std::string ret = server_->ConvertMetadataInfoToStr(playerId, controlCommand, metadata);
469 EXPECT_EQ(ret, msg);
470 SLOGI("ConvertMetadataInfoToStr001 end");
471 }
472
473 /**
474 * @tc.name: CreateLocalSessionStub001
475 * @tc.desc: test CreateLocalSessionStub
476 * @tc.type: FUNC
477 * @tc.require:
478 */
479 static HWTEST_F(MigrateAVSessionTest, CreateLocalSessionStub001, TestSize.Level1)
480 {
481 SLOGI("CreateLocalSessionStub001 begin");
482 std::string scene = "test";
483 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
484 EXPECT_TRUE(migrateManager_ != nullptr);
485 migrateManager_->CreateLocalSessionStub(scene, server_);
486 SLOGI("CreateLocalSessionStub001 end");
487 }
488
489 /**
490 * @tc.name: CreateLocalSessionStub002
491 * @tc.desc: test CreateLocalSessionStub
492 * @tc.type: FUNC
493 * @tc.require:
494 */
495 static HWTEST_F(MigrateAVSessionTest, CreateLocalSessionStub002, TestSize.Level1)
496 {
497 SLOGI("CreateLocalSessionStub002 begin");
498 std::string scene = "SuperLauncher-Dual";
499 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
500 EXPECT_TRUE(migrateManager_ != nullptr);
501 migrateManager_->CreateLocalSessionStub(scene, server_);
502 migrateManager_->CreateLocalSessionStub(scene, server_);
503 SLOGI("CreateLocalSessionStub002 end");
504 }
505
506 /**
507 * @tc.name: ReleaseLocalSessionStub001
508 * @tc.desc: test ReleaseLocalSessionStub
509 * @tc.type: FUNC
510 * @tc.require:
511 */
512 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub001, TestSize.Level1)
513 {
514 SLOGI("ReleaseLocalSessionStub001 begin");
515 std::string scene = "test";
516 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
517 EXPECT_TRUE(migrateManager_ != nullptr);
518 migrateManager_->ReleaseLocalSessionStub(scene);
519 SLOGI("ReleaseLocalSessionStub001 end");
520 }
521
522 /**
523 * @tc.name: ReleaseLocalSessionStub002
524 * @tc.desc: test ReleaseLocalSessionStub
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub002, TestSize.Level1)
529 {
530 SLOGI("ReleaseLocalSessionStub002 begin");
531 std::string scene = "SuperLauncher-Dual";
532 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
533 EXPECT_TRUE(migrateManager_ != nullptr);
534 migrateManager_->CreateLocalSessionStub(scene, server_);
535 migrateManager_->ReleaseLocalSessionStub(scene);
536 SLOGI("ReleaseLocalSessionStub002 end");
537 }
538
539 /**
540 * @tc.name: ReleaseLocalSessionStub003
541 * @tc.desc: test ReleaseLocalSessionStub
542 * @tc.type: FUNC
543 * @tc.require:
544 */
545 static HWTEST_F(MigrateAVSessionTest, ReleaseLocalSessionStub003, TestSize.Level1)
546 {
547 SLOGI("ReleaseLocalSessionStub003 begin");
548 std::string scene = "SuperLauncher-Dual";
549 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
550 EXPECT_TRUE(migrateManager_ != nullptr);
551 migrateManager_->ReleaseLocalSessionStub(scene);
552 SLOGI("ReleaseLocalSessionStub003 end");
553 }
554
555 /**
556 * @tc.name: IncSoftBusRef001
557 * @tc.desc: test IncSoftBusRef
558 * @tc.type: FUNC
559 * @tc.require:
560 */
561 static HWTEST_F(MigrateAVSessionTest, IncSoftBusRef001, TestSize.Level1)
562 {
563 SLOGI("IncSoftBusRef001 begin");
564 std::shared_ptr<MigrateAVSessionManager> migrateManager_ = std::make_shared<MigrateAVSessionManager>();
565 EXPECT_TRUE(migrateManager_ != nullptr);
566 migrateManager_->refs_ = 1;
567 migrateManager_->IncSoftBusRef();
568 SLOGI("IncSoftBusRef001 end");
569 }
570
571 /**
572 * @tc.name: ClearCacheBySessionId002
573 * @tc.desc: test ClearCacheBySessionId
574 * @tc.type: FUNC
575 * @tc.require:
576 */
577 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId002, TestSize.Level1)
578 {
579 SLOGI("ClearCacheBySessionId002 begin");
580 std::string sessionId = "#####";
581 EXPECT_TRUE(server_ != nullptr);
582 server_->ClearCacheBySessionId(sessionId);
583 SLOGI("ClearCacheBySessionId002 end");
584 }
585
586 /**
587 * @tc.name: ClearCacheBySessionId003
588 * @tc.desc: test ClearCacheBySessionId
589 * @tc.type: FUNC
590 * @tc.require:
591 */
592 static HWTEST_F(MigrateAVSessionTest, ClearCacheBySessionId003, TestSize.Level1)
593 {
594 SLOGI("ClearCacheBySessionId003 begin");
595 std::string sessionId = "12345";
596 OHOS::sptr<AVControllerItem> item = nullptr;
597 std::shared_ptr<AVControllerObserver> observer(nullptr);
598 EXPECT_TRUE(server_ != nullptr);
599 server_->playerIdToControllerMap_[sessionId] = item;
600 server_->playerIdToControllerCallbackMap_[sessionId] = observer;
601 server_->ClearCacheBySessionId(sessionId);
602 SLOGI("ClearCacheBySessionId003 end");
603 }
604
605 /**
606 * @tc.name: ProcControlCommand001
607 * @tc.desc: test ProcControlCommand
608 * @tc.type: FUNC
609 * @tc.require:
610 */
611 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand001, TestSize.Level1)
612 {
613 SLOGI("ProcControlCommand001 begin");
614 std::string data = R"(##{"PlayerId":"1","MediaCommand":"1"})";
615 EXPECT_TRUE(server_ != nullptr);
616 server_->ProcControlCommand(data);
617 SLOGI("ProcControlCommand001 end");
618 }
619
620 /**
621 * @tc.name: ProcControlCommand002
622 * @tc.desc: test ProcControlCommand
623 * @tc.type: FUNC
624 * @tc.require:
625 */
626 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand002, TestSize.Level1)
627 {
628 SLOGI("ProcControlCommand002 begin");
629 std::string data = R"(##{"PlayerId":"1","command":"1"})";
630 EXPECT_TRUE(server_ != nullptr);
631 server_->ProcControlCommand(data);
632 SLOGI("ProcControlCommand002 end");
633 }
634
635 /**
636 * @tc.name: ProcControlCommand003
637 * @tc.desc: test ProcControlCommand
638 * @tc.type: FUNC
639 * @tc.require:
640 */
641 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand003, TestSize.Level1)
642 {
643 SLOGI("ProcControlCommand003 begin");
644 std::string data = R"(##{"MediaCommand":"1","command":"1"})";
645 EXPECT_TRUE(server_ != nullptr);
646 server_->ProcControlCommand(data);
647 SLOGI("ProcControlCommand003 end");
648 }
649
650 /**
651 * @tc.name: ProcControlCommand004
652 * @tc.desc: test ProcControlCommand
653 * @tc.type: FUNC
654 * @tc.require:
655 */
656 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand004, TestSize.Level1)
657 {
658 SLOGI("ProcControlCommand004 begin");
659 std::string data = R"(##{"MediaCommand":"1"})";
660 EXPECT_TRUE(server_ != nullptr);
661 server_->ProcControlCommand(data);
662 SLOGI("ProcControlCommand004 end");
663 }
664
665 /**
666 * @tc.name: ProcControlCommand005
667 * @tc.desc: test ProcControlCommand
668 * @tc.type: FUNC
669 * @tc.require:
670 */
671 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand005, TestSize.Level1)
672 {
673 SLOGI("ProcControlCommand005 begin");
674 std::string data = R"(##{"command":"1"})";
675 EXPECT_TRUE(server_ != nullptr);
676 server_->ProcControlCommand(data);
677 SLOGI("ProcControlCommand005 end");
678 }
679
680 /**
681 * @tc.name: ProcControlCommand006
682 * @tc.desc: test ProcControlCommand
683 * @tc.type: FUNC
684 * @tc.require:
685 */
686 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand006, TestSize.Level1)
687 {
688 SLOGI("ProcControlCommand006 begin");
689 std::string data = R"(##{"PlayerId":"1"})";
690 EXPECT_TRUE(server_ != nullptr);
691 server_->ProcControlCommand(data);
692 SLOGI("ProcControlCommand006 end");
693 }
694
695 /**
696 * @tc.name: ProcControlCommand007
697 * @tc.desc: test ProcControlCommand
698 * @tc.type: FUNC
699 * @tc.require:
700 */
701 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand007, TestSize.Level1)
702 {
703 SLOGI("ProcControlCommand007 begin");
704 std::string data = R"(##{"PlayerId":"","MediaCommand":1,"command":"1"})";
705 EXPECT_TRUE(server_ != nullptr);
706 server_->ProcControlCommand(data);
707 SLOGI("ProcControlCommand007 end");
708 }
709
710 /**
711 * @tc.name: ProcControlCommand008
712 * @tc.desc: test ProcControlCommand
713 * @tc.type: FUNC
714 * @tc.require:
715 */
716 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand008, TestSize.Level1)
717 {
718 SLOGI("ProcControlCommand008 begin");
719 server_->CreateController("111");
720 std::string data = R"(##{"PlayerId":"111","MediaCommand":30,"command":"1"})";
721 EXPECT_TRUE(server_ != nullptr);
722 server_->ProcControlCommand(data);
723 SLOGI("ProcControlCommand008 end");
724 }
725
726 /**
727 * @tc.name: ProcControlCommand009
728 * @tc.desc: test ProcControlCommand
729 * @tc.type: FUNC
730 * @tc.require:
731 */
732 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand009, TestSize.Level1)
733 {
734 SLOGI("ProcControlCommand009 begin");
735 server_->CreateController("111");
736 std::string data = R"(##{"PlayerId":"111","MediaCommand":31,"command":"1","extras":11})";
737 EXPECT_TRUE(server_ != nullptr);
738 server_->ProcControlCommand(data);
739 SLOGI("ProcControlCommand009 end");
740 }
741
742 /**
743 * @tc.name: ProcControlCommand007
744 * @tc.desc: test ProcControlCommand
745 * @tc.type: FUNC
746 * @tc.require:
747 */
748 static HWTEST_F(MigrateAVSessionTest, ProcControlCommand010, TestSize.Level1)
749 {
750 SLOGI("ProcControlCommand007 begin");
751 server_->CreateController("111");
752 std::string data = R"(##{"PlayerId":"111","MediaCommand":50,"command":"1","extras":"124"})";
753 EXPECT_TRUE(server_ != nullptr);
754 server_->ProcControlCommand(data);
755 SLOGI("ProcControlCommand007 end");
756 }