1 /*
2 * Copyright (c) 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 <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 #include "avsession_service.h"
31 #include "migrate_avsession_manager.h"
32 #include "migrate_avsession_server.h"
33 #include "softbus/softbus_session_utils.h"
34
35 using namespace testing::ext;
36 using namespace OHOS::AVSession;
37
38 static char g_testSessionTag[] = "test";
39 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
40 static char g_testAnotherAbilityName[] = "testAnother.ability";
41 static std::shared_ptr<MigrateAVSessionServer> g_MigrateAVSessionServer {nullptr};
42 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
43 static OHOS::sptr<AVSessionItem> g_AVSessionItem {nullptr};
44 static OHOS::sptr<AVControllerItem> g_AVControllerItem {nullptr};
45
46 class MigrateAVSessionServerForNextTest : public testing::Test {
47 public:
48 static void SetUpTestCase();
49 static void TearDownTestCase();
50 void SetUp();
51 void TearDown();
52 };
53
SetUpTestCase()54 void MigrateAVSessionServerForNextTest::SetUpTestCase()
55 {
56 SLOGI("MigrateAVSessionServerForNextTest SetUpTestCase");
57 g_MigrateAVSessionServer = std::make_shared<MigrateAVSessionServer>();
58 OHOS::AppExecFwk::ElementName elementName;
59 elementName.SetBundleName(g_testAnotherBundleName);
60 elementName.SetAbilityName(g_testAnotherAbilityName);
61 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID, true);
62 g_AVSessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
63 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
64 g_AVControllerItem = g_AVSessionService->CreateNewControllerForSession(
65 g_AVSessionItem->GetPid(), g_AVSessionItem);
66 }
67
TearDownTestCase()68 void MigrateAVSessionServerForNextTest::TearDownTestCase()
69 {
70 SLOGI("MigrateAVSessionServerForNextTest TearDownTestCase");
71 g_AVSessionService->HandleSessionRelease(g_AVSessionItem->GetSessionId());
72 g_AVControllerItem->Destroy();
73 g_AVSessionItem->Destroy();
74 }
75
SetUp()76 void MigrateAVSessionServerForNextTest::SetUp()
77 {
78 SLOGI("MigrateAVSessionServerForNextTest SetUp");
79 }
80
TearDown()81 void MigrateAVSessionServerForNextTest::TearDown()
82 {
83 SLOGI("MigrateAVSessionServerForNextTest TearDown");
84 }
85
86 /**
87 * @tc.name: LocalFrontSessionArrive001
88 * @tc.desc: input sessionId to LocalFrontSessionArrive
89 * @tc.type: FUNC
90 * @tc.require:
91 */
92 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive001, TestSize.Level0)
93 {
94 std::string sessionId = "";
95 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
96 sleep(1);
97 EXPECT_EQ(sessionId.size(), 0);
98 }
99
100 /**
101 * @tc.name: LocalFrontSessionArrive002
102 * @tc.desc: input sessionId to LocalFrontSessionArrive
103 * @tc.type: FUNC
104 * @tc.require:
105 */
106 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive002, TestSize.Level0)
107 {
108 std::string sessionId = "test";
109 auto observer = std::make_shared<AVControllerObserver>(sessionId);
110 g_MigrateAVSessionServer->playerIdToControllerCallbackMap_.insert({sessionId, observer});
111 g_MigrateAVSessionServer->playerIdToControllerMap_.insert({sessionId, g_AVControllerItem});
112 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
113 sleep(1);
114 EXPECT_EQ(sessionId.size(), 4);
115 }
116
117 /**
118 * @tc.name: LocalFrontSessionArrive003
119 * @tc.desc: input sessionId to LocalFrontSessionArrive
120 * @tc.type: FUNC
121 * @tc.require:
122 */
123 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive003, TestSize.Level0)
124 {
125 std::string sessionId = "test";
126 auto observer = std::make_shared<AVControllerObserver>(sessionId);
127 g_MigrateAVSessionServer->playerIdToControllerCallbackMap_.insert({sessionId, observer});
128 g_MigrateAVSessionServer->playerIdToControllerMap_.insert({sessionId, g_AVControllerItem});
129 g_MigrateAVSessionServer->isSoftbusConnecting_ = true;
130 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
131 sleep(1);
132 EXPECT_EQ(sessionId.size(), 4);
133 }
134
135 /**
136 * @tc.name: LocalFrontSessionArrive004
137 * @tc.desc: input sessionId to LocalFrontSessionArrive
138 * @tc.type: FUNC
139 * @tc.require:
140 */
141 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive004, TestSize.Level0)
142 {
143 std::string sessionId = "test";
144 auto observer = std::make_shared<AVControllerObserver>(sessionId);
145 g_MigrateAVSessionServer->playerIdToControllerCallbackMap_.insert({sessionId, observer});
146 g_MigrateAVSessionServer->playerIdToControllerMap_.insert({sessionId, g_AVControllerItem});
147 g_MigrateAVSessionServer->isSoftbusConnecting_ = false;
148 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
149 sleep(1);
150 EXPECT_EQ(sessionId.size(), 4);
151 }
152
153 /**
154 * @tc.name: LocalFrontSessionLeave001
155 * @tc.desc: input sessionId to LocalFrontSessionLeave
156 * @tc.type: FUNC
157 * @tc.require:
158 */
159 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionLeave001, TestSize.Level0)
160 {
161 std::string sessionId = "";
162 g_MigrateAVSessionServer->LocalFrontSessionLeave(sessionId);
163 EXPECT_EQ(sessionId.size(), 0);
164 }
165
166 /**
167 * @tc.name: LocalFrontSessionLeave002
168 * @tc.desc: input sessionId to LocalFrontSessionLeave
169 * @tc.type: FUNC
170 * @tc.require:
171 */
172 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionLeave002, TestSize.Level0)
173 {
174 std::string sessionId = "test";
175 g_MigrateAVSessionServer->LocalFrontSessionLeave(sessionId);
176 EXPECT_EQ(sessionId.size(), 4);
177 }
178
179 /**
180 * @tc.name: DoMetaDataSyncToRemote001
181 * @tc.desc: input metadate to DoMetaDataSyncToRemote
182 * @tc.type: FUNC
183 * @tc.require:
184 */
185 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote001, TestSize.Level0)
186 {
187 AVMetaData data;
188 data.SetAssetId("test");
189 data.SetTitle("test");
190 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
191 EXPECT_EQ(data.GetAssetId(), "test");
192 }
193
194 /**
195 * @tc.name: DoMetaDataSyncToRemote002
196 * @tc.desc: input metadate to DoMetaDataSyncToRemote
197 * @tc.type: FUNC
198 * @tc.require:
199 */
200 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote002, TestSize.Level0)
201 {
202 AVMetaData data;
203 data.SetAssetId("test");
204 data.SetArtist("test");
205 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
206 EXPECT_EQ(data.GetAssetId(), "test");
207 }
208
209 /**
210 * @tc.name: DoMetaDataSyncToRemote003
211 * @tc.desc: input metadate to DoMetaDataSyncToRemote
212 * @tc.type: FUNC
213 * @tc.require:
214 */
215 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote003, TestSize.Level0)
216 {
217 AVMetaData data;
218 data.SetAssetId("test");
219 data.SetAuthor("test");
220 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
221 EXPECT_EQ(data.GetAssetId(), "test");
222 }
223
224 /**
225 * @tc.name: DoMediaImageSyncToRemote001
226 * @tc.desc: input innerPixelMap to DoMediaImageSyncToRemote
227 * @tc.type: FUNC
228 * @tc.require:
229 */
230 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMediaImageSyncToRemote001, TestSize.Level0)
231 {
232 std::shared_ptr<AVSessionPixelMap> ptr = std::make_shared<AVSessionPixelMap>();
233 std::vector<uint8_t> vec = {0, 1, 0, 1};
234 ptr->SetInnerImgBuffer(vec);
235 g_MigrateAVSessionServer->DoMediaImageSyncToRemote(ptr);
236 EXPECT_EQ(vec.size() > 0, true);
237 }
238
239 /**
240 * @tc.name: DoMediaImageSyncToRemote002
241 * @tc.desc: input innerPixelMap to DoMediaImageSyncToRemote
242 * @tc.type: FUNC
243 * @tc.require:
244 */
245 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMediaImageSyncToRemote002, TestSize.Level0)
246 {
247 std::shared_ptr<AVSessionPixelMap> ptr = std::make_shared<AVSessionPixelMap>();
248 std::vector<uint8_t> vec = {};
249 ptr->SetInnerImgBuffer(vec);
250 g_MigrateAVSessionServer->DoMediaImageSyncToRemote(ptr);
251 EXPECT_EQ(vec.size() == 0, true);
252 }
253
254 /**
255 * @tc.name: DoPlaybackStateSyncToRemote001
256 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
257 * @tc.type: FUNC
258 * @tc.require:
259 */
260 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote001, TestSize.Level0)
261 {
262 AVPlaybackState data;
263 data.SetState(1);
264 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
265 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_STATE), 1);
266 }
267
268 /**
269 * @tc.name: DoPlaybackStateSyncToRemote002
270 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
271 * @tc.type: FUNC
272 * @tc.require:
273 */
274 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote002, TestSize.Level0)
275 {
276 AVPlaybackState data;
277 data.SetFavorite(true);
278 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
279 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_IS_FAVORITE), 1);
280 }
281
282 /**
283 * @tc.name: DoPlaybackStateSyncToRemote003
284 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
285 * @tc.type: FUNC
286 * @tc.require:
287 */
288 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote003, TestSize.Level0)
289 {
290 AVPlaybackState data;
291 data.SetActiveItemId(1);
292 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
293 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_IS_FAVORITE), 0);
294 }
295
296 /**
297 * @tc.name: DoBundleInfoSyncToRemote001
298 * @tc.desc: input AVControllerItem to DoBundleInfoSyncToRemote
299 * @tc.type: FUNC
300 * @tc.require:
301 */
302 static HWTEST_F(MigrateAVSessionServerForNextTest, DoBundleInfoSyncToRemote001, TestSize.Level0)
303 {
304 g_MigrateAVSessionServer->DoBundleInfoSyncToRemote(g_AVControllerItem);
305 EXPECT_EQ(g_AVControllerItem != nullptr, true);
306 }
307
308 /**
309 * @tc.name: UpdateFrontSessionInfoToRemote001
310 * @tc.desc: input AVControllerItem to UpdateFrontSessionInfoToRemote
311 * @tc.type: FUNC
312 * @tc.require:
313 */
314 static HWTEST_F(MigrateAVSessionServerForNextTest, UpdateFrontSessionInfoToRemote001, TestSize.Level0)
315 {
316 g_MigrateAVSessionServer->UpdateFrontSessionInfoToRemote(g_AVControllerItem);
317 EXPECT_EQ(g_AVControllerItem != nullptr, true);
318 }
319
320 /**
321 * @tc.name: UpdateFrontSessionInfoToRemote002
322 * @tc.desc: input AVControllerItem to UpdateFrontSessionInfoToRemote
323 * @tc.type: FUNC
324 * @tc.require:
325 */
326 static HWTEST_F(MigrateAVSessionServerForNextTest, UpdateFrontSessionInfoToRemote002, TestSize.Level0)
327 {
328 AVMetaData metaData;
329 g_AVSessionItem->SetAVMetaData(metaData);
330 AVPlaybackState playbackState;
331 g_AVSessionItem->SetAVPlaybackState(playbackState);
332 g_MigrateAVSessionServer->UpdateFrontSessionInfoToRemote(g_AVControllerItem);
333 EXPECT_EQ(g_AVControllerItem != nullptr, true);
334 }
335
336 /**
337 * @tc.name: ProcFromNext001
338 * @tc.desc: input string to ProcFromNext
339 * @tc.type: FUNC
340 * @tc.require:
341 */
342 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext001, TestSize.Level0)
343 {
344 std::string deviceId = "";
345 std::string data = "";
346 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
347 EXPECT_EQ(data.size() == 0, true);
348 }
349
350 /**
351 * @tc.name: ProcFromNext002
352 * @tc.desc: input string to ProcFromNext
353 * @tc.type: FUNC
354 * @tc.require:
355 */
356 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext002, TestSize.Level0)
357 {
358 std::string deviceId = "0000";
359 std::string str1(2, char(SYNC_COMMAND));
360 std::string str2 = R"(
361 {"test":1}
362 )";
363 std::string data = str1 + str2;
364 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
365 EXPECT_EQ(data.size() > 2, true);
366 }
367
368 /**
369 * @tc.name: ProcFromNext003
370 * @tc.desc: input string to ProcFromNext
371 * @tc.type: FUNC
372 * @tc.require:
373 */
374 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext003, TestSize.Level0)
375 {
376 std::string deviceId = "0000";
377 std::string str1(2, char(SYNC_SET_VOLUME_COMMAND));
378 std::string str2 = R"(
379 {"test":1}
380 )";
381 std::string data = str1 + str2;
382 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
383 EXPECT_EQ(data.size() > 2, true);
384 }
385
386 /**
387 * @tc.name: ProcFromNext004
388 * @tc.desc: input string to ProcFromNext
389 * @tc.type: FUNC
390 * @tc.require:
391 */
392 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext004, TestSize.Level0)
393 {
394 std::string deviceId = "0000";
395 std::string str1(2, char(SYNC_SWITCH_AUDIO_DEVICE_COMMAND));
396 std::string str2 = R"(
397 {"test":1}
398 )";
399 std::string data = str1 + str2;
400 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
401 EXPECT_EQ(data.size() > 2, true);
402 }
403
404 /**
405 * @tc.name: ProcFromNext005
406 * @tc.desc: input string to ProcFromNext
407 * @tc.type: FUNC
408 * @tc.require:
409 */
410 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext005, TestSize.Level0)
411 {
412 std::string deviceId = "0000";
413 std::string str1(2, char(COLD_START));
414 std::string str2 = R"(
415 {"test":1}
416 )";
417 std::string data = str1 + str2;
418 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
419 EXPECT_EQ(data.size() > 2, true);
420 }
421
422 /**
423 * @tc.name: ProcFromNext006
424 * @tc.desc: input string to ProcFromNext
425 * @tc.type: FUNC
426 * @tc.require:
427 */
428 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext006, TestSize.Level0)
429 {
430 std::string deviceId = "0000";
431 std::string str1(2, char(0));
432 std::string str2 = R"(
433 {"test":1}
434 )";
435 std::string data = str1 + str2;
436 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
437 EXPECT_EQ(data.size() > 2, true);
438 }
439
440 /**
441 * @tc.name: ProcControlCommandFromNext001
442 * @tc.desc: tset the member of ProcControlCommandFromNext
443 * @tc.type: FUNC
444 * @tc.require:
445 */
446 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext001, TestSize.Level0)
447 {
448 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
449 EXPECT_NE(jsonValue, nullptr);
450 if (jsonValue == nullptr) {
451 SLOGE("create jsonvalue nullptr");
452 FAIL();
453 }
454 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_CODE, 1)) {
455 SLOGE("AddIntToJson fail");
456 cJSON_Delete(jsonValue);
457 jsonValue = nullptr;
458 FAIL();
459 }
460
461 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
462 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_CODE), true);
463 cJSON_Delete(jsonValue);
464 }
465
466 /**
467 * @tc.name: ProcControlCommandFromNext002
468 * @tc.desc: tset the member of ProcControlCommandFromNext
469 * @tc.type: FUNC
470 * @tc.require:
471 */
472 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext002, TestSize.Level0)
473 {
474 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
475 EXPECT_NE(jsonValue, nullptr);
476 if (jsonValue == nullptr) {
477 SLOGE("create jsonvalue nullptr");
478 FAIL();
479 }
480 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_ARGS, 1)) {
481 SLOGE("AddIntToJson fail");
482 cJSON_Delete(jsonValue);
483 jsonValue = nullptr;
484 FAIL();
485 }
486
487 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
488 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_ARGS), true);
489 cJSON_Delete(jsonValue);
490 }
491
492 /**
493 * @tc.name: ProcControlCommandFromNext003
494 * @tc.desc: tset the member of ProcControlCommandFromNext
495 * @tc.type: FUNC
496 * @tc.require:
497 */
498 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext003, TestSize.Level0)
499 {
500 std::string id = "001";
501 g_MigrateAVSessionServer->lastSessionId_ = id;
502 g_MigrateAVSessionServer->playerIdToControllerMap_[id] = g_AVControllerItem;
503
504 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
505 EXPECT_NE(jsonValue, nullptr);
506 if (jsonValue == nullptr) {
507 SLOGE("create jsonvalue nullptr");
508 FAIL();
509 }
510 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_CODE, 10)) {
511 SLOGE("AddIntToJson fail");
512 cJSON_Delete(jsonValue);
513 jsonValue = nullptr;
514 FAIL();
515 }
516
517 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
518 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_CODE), true);
519 cJSON_Delete(jsonValue);
520 }
521
522 /**
523 * @tc.name: ProcControlCommandFromNext003
524 * @tc.desc: tset the member of ProcControlCommandFromNext
525 * @tc.type: FUNC
526 * @tc.require:
527 */
528 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext004, TestSize.Level0)
529 {
530 std::string id = "001";
531 g_MigrateAVSessionServer->lastSessionId_ = id;
532 g_MigrateAVSessionServer->playerIdToControllerMap_[id] = g_AVControllerItem;
533
534 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
535 EXPECT_NE(jsonValue, nullptr);
536 if (jsonValue == nullptr) {
537 SLOGE("create jsonvalue nullptr");
538 FAIL();
539 }
540 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_CODE, 0)) {
541 SLOGE("AddIntToJson fail");
542 cJSON_Delete(jsonValue);
543 jsonValue = nullptr;
544 FAIL();
545 }
546
547 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
548 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_CODE), true);
549 cJSON_Delete(jsonValue);
550 }
551
552 /**
553 * @tc.name: ProcessColdStartFromNext001
554 * @tc.desc: tset the member of ProcessColdStartFromNext
555 * @tc.type: FUNC
556 * @tc.require:
557 */
558 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcessColdStartFromNext001, TestSize.Level0)
559 {
560 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
561 EXPECT_NE(jsonValue, nullptr);
562 if (jsonValue == nullptr) {
563 SLOGE("create jsonvalue nullptr");
564 FAIL();
565 }
566 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_CODE, 1)) {
567 SLOGE("AddIntToJson fail");
568 cJSON_Delete(jsonValue);
569 jsonValue = nullptr;
570 FAIL();
571 }
572
573 g_MigrateAVSessionServer->ProcessColdStartFromNext(jsonValue);
574 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_CODE), true);
575 cJSON_Delete(jsonValue);
576 }
577
578 /**
579 * @tc.name: ProcessColdStartFromNext002
580 * @tc.desc: tset the member of ProcessColdStartFromNext
581 * @tc.type: FUNC
582 * @tc.require:
583 */
584 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcessColdStartFromNext002, TestSize.Level0)
585 {
586 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
587 EXPECT_NE(jsonValue, nullptr);
588 if (jsonValue == nullptr) {
589 SLOGE("create jsonvalue nullptr");
590 FAIL();
591 }
592 if (!SoftbusSessionUtils::AddStringToJson(jsonValue, MIGRATE_BUNDLE_NAME, "1")) {
593 SLOGE("AddStringToJson fail");
594 cJSON_Delete(jsonValue);
595 jsonValue = nullptr;
596 FAIL();
597 }
598
599 g_MigrateAVSessionServer->ProcessColdStartFromNext(jsonValue);
600 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, MIGRATE_BUNDLE_NAME), true);
601 cJSON_Delete(jsonValue);
602 }
603
604 /**
605 * @tc.name: ConvertAudioDeviceDescriptorsToJson001
606 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorsToJson
607 * @tc.type: FUNC
608 * @tc.require:
609 */
610 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorsToJson001, TestSize.Level0)
611 {
612 AudioDeviceDescriptors ptrs;
613 AudioDeviceDescriptorWithSptr ptr {new AudioDeviceDescriptor()};
614 ptrs.push_back(ptr);
615 EXPECT_EQ(ptrs.size() > 0, true);
616 g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorsToJson(ptrs);
617 }
618
619 /**
620 * @tc.name: ConvertAudioDeviceDescriptorsToJson002
621 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorsToJson
622 * @tc.type: FUNC
623 * @tc.require:
624 */
625 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorsToJson002, TestSize.Level0)
626 {
627 AudioDeviceDescriptors ptrs;
628 ptrs.push_back(nullptr);
629 EXPECT_EQ(ptrs.size() > 0, true);
630 g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorsToJson(ptrs);
631 }
632
633 /**
634 * @tc.name: VolumeControlCommand001
635 * @tc.desc: tset the member of VolumeControlCommand
636 * @tc.type: FUNC
637 * @tc.require:
638 */
639 static HWTEST_F(MigrateAVSessionServerForNextTest, VolumeControlCommand001, TestSize.Level0)
640 {
641 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
642 EXPECT_NE(jsonValue, nullptr);
643 if (jsonValue == nullptr) {
644 SLOGE("create jsonvalue nullptr");
645 FAIL();
646 }
647 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, COMMAND_CODE, 1)) {
648 SLOGE("AddIntToJson fail");
649 cJSON_Delete(jsonValue);
650 jsonValue = nullptr;
651 FAIL();
652 }
653
654 g_MigrateAVSessionServer->ProcessColdStartFromNext(jsonValue);
655 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, MIGRATE_BUNDLE_NAME), false);
656
657 g_MigrateAVSessionServer->VolumeControlCommand(jsonValue);
658 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, COMMAND_CODE), true);
659 cJSON_Delete(jsonValue);
660 }
661
662 /**
663 * @tc.name: VolumeControlCommand002
664 * @tc.desc: tset the member of VolumeControlCommand
665 * @tc.type: FUNC
666 * @tc.require:
667 */
668 static HWTEST_F(MigrateAVSessionServerForNextTest, VolumeControlCommand002, TestSize.Level0)
669 {
670 cJSON* jsonValue = SoftbusSessionUtils::GetNewCJSONObject();
671 EXPECT_NE(jsonValue, nullptr);
672 if (jsonValue == nullptr) {
673 SLOGE("create jsonvalue nullptr");
674 FAIL();
675 }
676 if (!SoftbusSessionUtils::AddIntToJson(jsonValue, AUDIO_VOLUME, 1)) {
677 SLOGE("AddIntToJson fail");
678 cJSON_Delete(jsonValue);
679 jsonValue = nullptr;
680 FAIL();
681 }
682
683 g_MigrateAVSessionServer->VolumeControlCommand(jsonValue);
684 EXPECT_EQ(cJSON_HasObjectItem(jsonValue, AUDIO_VOLUME), true);
685 cJSON_Delete(jsonValue);
686 }
687
688 /**
689 * @tc.name: ConvertAudioDeviceDescriptorToJson001
690 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorToJson
691 * @tc.type: FUNC
692 * @tc.require:
693 */
694 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorToJson001, TestSize.Level0)
695 {
696 SLOGE("ConvertAudioDeviceDescriptorToJson001 in");
697 AudioDeviceDescriptorWithSptr ptr {new AudioDeviceDescriptor()};
698 EXPECT_EQ(ptr != nullptr, true);
699 cJSON* audioDevJson = g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorToJson(ptr);
700 EXPECT_EQ(audioDevJson != nullptr, true);
701 SLOGE("ConvertAudioDeviceDescriptorToJson001 out");
702 }
703
704 /**
705 * @tc.name: ConvertAudioDeviceDescriptorToJson002
706 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorToJson
707 * @tc.type: FUNC
708 * @tc.require:
709 */
710 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorToJson002, TestSize.Level0)
711 {
712 SLOGE("ConvertAudioDeviceDescriptorToJson002 in");
713 AudioDeviceDescriptorWithSptr ptr = nullptr;
714 cJSON* audioDevJson = g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorToJson(ptr);
715 EXPECT_EQ(audioDevJson == nullptr, true);
716 SLOGE("ConvertAudioDeviceDescriptorToJson002 out");
717 }
718