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