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
34 using namespace testing::ext;
35 using namespace OHOS::AVSession;
36
37 static char g_testSessionTag[] = "test";
38 static char g_testAnotherBundleName[] = "testAnother.ohos.avsession";
39 static char g_testAnotherAbilityName[] = "testAnother.ability";
40 static std::shared_ptr<MigrateAVSessionServer> g_MigrateAVSessionServer {nullptr};
41 static std::shared_ptr<AVSessionService> g_AVSessionService {nullptr};
42 static OHOS::sptr<AVSessionItem> g_AVSessionItem {nullptr};
43 static OHOS::sptr<AVControllerItem> g_AVControllerItem {nullptr};
44
45 class MigrateAVSessionServerForNextTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp();
50 void TearDown();
51 };
52
SetUpTestCase()53 void MigrateAVSessionServerForNextTest::SetUpTestCase()
54 {
55 SLOGI("MigrateAVSessionServerForNextTest SetUpTestCase");
56 g_MigrateAVSessionServer = std::make_shared<MigrateAVSessionServer>();
57 OHOS::AppExecFwk::ElementName elementName;
58 elementName.SetBundleName(g_testAnotherBundleName);
59 elementName.SetAbilityName(g_testAnotherAbilityName);
60 g_AVSessionService = std::make_shared<AVSessionService>(OHOS::AVSESSION_SERVICE_ID, true);
61 g_AVSessionItem = g_AVSessionService->CreateSessionInner(g_testSessionTag,
62 AVSession::SESSION_TYPE_VOICE_CALL, false, elementName);
63 g_AVControllerItem = g_AVSessionService->CreateNewControllerForSession(
64 g_AVSessionItem->GetPid(), g_AVSessionItem);
65 }
66
TearDownTestCase()67 void MigrateAVSessionServerForNextTest::TearDownTestCase()
68 {
69 SLOGI("MigrateAVSessionServerForNextTest TearDownTestCase");
70 g_AVSessionService->HandleSessionRelease(g_AVSessionItem->GetSessionId());
71 g_AVControllerItem->Destroy();
72 g_AVSessionItem->Destroy();
73 }
74
SetUp()75 void MigrateAVSessionServerForNextTest::SetUp()
76 {
77 SLOGI("MigrateAVSessionServerForNextTest SetUp");
78 }
79
TearDown()80 void MigrateAVSessionServerForNextTest::TearDown()
81 {
82 SLOGI("MigrateAVSessionServerForNextTest TearDown");
83 }
84
85 /**
86 * @tc.name: LocalFrontSessionArrive001
87 * @tc.desc: input sessionId to LocalFrontSessionArrive
88 * @tc.type: FUNC
89 * @tc.require:
90 */
91 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive001, TestSize.Level1)
92 {
93 std::string sessionId = "";
94 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
95 sleep(1);
96 EXPECT_EQ(sessionId.size(), 0);
97 sleep(1);
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.Level1)
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 sleep(1);
116 }
117
118 /**
119 * @tc.name: LocalFrontSessionArrive003
120 * @tc.desc: input sessionId to LocalFrontSessionArrive
121 * @tc.type: FUNC
122 * @tc.require:
123 */
124 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive003, TestSize.Level1)
125 {
126 std::string sessionId = "test";
127 auto observer = std::make_shared<AVControllerObserver>(sessionId);
128 g_MigrateAVSessionServer->playerIdToControllerCallbackMap_.insert({sessionId, observer});
129 g_MigrateAVSessionServer->playerIdToControllerMap_.insert({sessionId, g_AVControllerItem});
130 g_MigrateAVSessionServer->isSoftbusConnecting_ = true;
131 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
132 sleep(1);
133 EXPECT_EQ(sessionId.size(), 4);
134 sleep(1);
135 }
136
137 /**
138 * @tc.name: LocalFrontSessionArrive004
139 * @tc.desc: input sessionId to LocalFrontSessionArrive
140 * @tc.type: FUNC
141 * @tc.require:
142 */
143 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionArrive004, TestSize.Level1)
144 {
145 std::string sessionId = "test";
146 auto observer = std::make_shared<AVControllerObserver>(sessionId);
147 g_MigrateAVSessionServer->playerIdToControllerCallbackMap_.insert({sessionId, observer});
148 g_MigrateAVSessionServer->playerIdToControllerMap_.insert({sessionId, g_AVControllerItem});
149 g_MigrateAVSessionServer->isSoftbusConnecting_ = false;
150 g_MigrateAVSessionServer->LocalFrontSessionArrive(sessionId);
151 sleep(1);
152 EXPECT_EQ(sessionId.size(), 4);
153 sleep(1);
154 }
155
156 /**
157 * @tc.name: LocalFrontSessionLeave001
158 * @tc.desc: input sessionId to LocalFrontSessionLeave
159 * @tc.type: FUNC
160 * @tc.require:
161 */
162 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionLeave001, TestSize.Level1)
163 {
164 std::string sessionId = "";
165 g_MigrateAVSessionServer->LocalFrontSessionLeave(sessionId);
166 EXPECT_EQ(sessionId.size(), 0);
167 }
168
169 /**
170 * @tc.name: LocalFrontSessionLeave002
171 * @tc.desc: input sessionId to LocalFrontSessionLeave
172 * @tc.type: FUNC
173 * @tc.require:
174 */
175 static HWTEST_F(MigrateAVSessionServerForNextTest, LocalFrontSessionLeave002, TestSize.Level1)
176 {
177 std::string sessionId = "test";
178 g_MigrateAVSessionServer->LocalFrontSessionLeave(sessionId);
179 EXPECT_EQ(sessionId.size(), 4);
180 }
181
182 /**
183 * @tc.name: DoMetaDataSyncToRemote001
184 * @tc.desc: input metadate to DoMetaDataSyncToRemote
185 * @tc.type: FUNC
186 * @tc.require:
187 */
188 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote001, TestSize.Level1)
189 {
190 AVMetaData data;
191 data.SetAssetId("test");
192 data.SetTitle("test");
193 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
194 EXPECT_EQ(data.GetAssetId(), "test");
195 }
196
197 /**
198 * @tc.name: DoMetaDataSyncToRemote002
199 * @tc.desc: input metadate to DoMetaDataSyncToRemote
200 * @tc.type: FUNC
201 * @tc.require:
202 */
203 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote002, TestSize.Level1)
204 {
205 AVMetaData data;
206 data.SetAssetId("test");
207 data.SetArtist("test");
208 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
209 EXPECT_EQ(data.GetAssetId(), "test");
210 }
211
212 /**
213 * @tc.name: DoMetaDataSyncToRemote003
214 * @tc.desc: input metadate to DoMetaDataSyncToRemote
215 * @tc.type: FUNC
216 * @tc.require:
217 */
218 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMetaDataSyncToRemote003, TestSize.Level1)
219 {
220 AVMetaData data;
221 data.SetAssetId("test");
222 data.SetAuthor("test");
223 g_MigrateAVSessionServer->DoMetaDataSyncToRemote(data);
224 EXPECT_EQ(data.GetAssetId(), "test");
225 }
226
227 /**
228 * @tc.name: DoMediaImageSyncToRemote001
229 * @tc.desc: input innerPixelMap to DoMediaImageSyncToRemote
230 * @tc.type: FUNC
231 * @tc.require:
232 */
233 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMediaImageSyncToRemote001, TestSize.Level1)
234 {
235 std::shared_ptr<AVSessionPixelMap> ptr = std::make_shared<AVSessionPixelMap>();
236 std::vector<uint8_t> vec = {0, 1, 0, 1};
237 ptr->SetInnerImgBuffer(vec);
238 g_MigrateAVSessionServer->DoMediaImageSyncToRemote(ptr);
239 EXPECT_EQ(vec.size() > 0, true);
240 }
241
242 /**
243 * @tc.name: DoMediaImageSyncToRemote002
244 * @tc.desc: input innerPixelMap to DoMediaImageSyncToRemote
245 * @tc.type: FUNC
246 * @tc.require:
247 */
248 static HWTEST_F(MigrateAVSessionServerForNextTest, DoMediaImageSyncToRemote002, TestSize.Level1)
249 {
250 std::shared_ptr<AVSessionPixelMap> ptr = std::make_shared<AVSessionPixelMap>();
251 std::vector<uint8_t> vec = {};
252 ptr->SetInnerImgBuffer(vec);
253 g_MigrateAVSessionServer->DoMediaImageSyncToRemote(ptr);
254 EXPECT_EQ(vec.size() == 0, true);
255 }
256
257 /**
258 * @tc.name: DoPlaybackStateSyncToRemote001
259 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
260 * @tc.type: FUNC
261 * @tc.require:
262 */
263 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote001, TestSize.Level1)
264 {
265 AVPlaybackState data;
266 data.SetState(1);
267 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
268 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_STATE), 1);
269 }
270
271 /**
272 * @tc.name: DoPlaybackStateSyncToRemote002
273 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
274 * @tc.type: FUNC
275 * @tc.require:
276 */
277 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote002, TestSize.Level1)
278 {
279 AVPlaybackState data;
280 data.SetFavorite(true);
281 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
282 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_IS_FAVORITE), 1);
283 }
284
285 /**
286 * @tc.name: DoPlaybackStateSyncToRemote003
287 * @tc.desc: input metadate to DoPlaybackStateSyncToRemote
288 * @tc.type: FUNC
289 * @tc.require:
290 */
291 static HWTEST_F(MigrateAVSessionServerForNextTest, DoPlaybackStateSyncToRemote003, TestSize.Level1)
292 {
293 AVPlaybackState data;
294 data.SetActiveItemId(1);
295 g_MigrateAVSessionServer->DoPlaybackStateSyncToRemote(data);
296 EXPECT_EQ(data.GetMask().test(AVPlaybackState::PLAYBACK_KEY_IS_FAVORITE), 0);
297 }
298
299 /**
300 * @tc.name: DoBundleInfoSyncToRemote001
301 * @tc.desc: input AVControllerItem to DoBundleInfoSyncToRemote
302 * @tc.type: FUNC
303 * @tc.require:
304 */
305 static HWTEST_F(MigrateAVSessionServerForNextTest, DoBundleInfoSyncToRemote001, TestSize.Level1)
306 {
307 g_MigrateAVSessionServer->DoBundleInfoSyncToRemote(g_AVControllerItem);
308 EXPECT_EQ(g_AVControllerItem != nullptr, true);
309 }
310
311 /**
312 * @tc.name: UpdateFrontSessionInfoToRemote001
313 * @tc.desc: input AVControllerItem to UpdateFrontSessionInfoToRemote
314 * @tc.type: FUNC
315 * @tc.require:
316 */
317 static HWTEST_F(MigrateAVSessionServerForNextTest, UpdateFrontSessionInfoToRemote001, TestSize.Level1)
318 {
319 g_MigrateAVSessionServer->UpdateFrontSessionInfoToRemote(g_AVControllerItem);
320 EXPECT_EQ(g_AVControllerItem != nullptr, true);
321 }
322
323 /**
324 * @tc.name: UpdateFrontSessionInfoToRemote002
325 * @tc.desc: input AVControllerItem to UpdateFrontSessionInfoToRemote
326 * @tc.type: FUNC
327 * @tc.require:
328 */
329 static HWTEST_F(MigrateAVSessionServerForNextTest, UpdateFrontSessionInfoToRemote002, TestSize.Level1)
330 {
331 AVMetaData metaData;
332 g_AVSessionItem->SetAVMetaData(metaData);
333 AVPlaybackState playbackState;
334 g_AVSessionItem->SetAVPlaybackState(playbackState);
335 g_MigrateAVSessionServer->UpdateFrontSessionInfoToRemote(g_AVControllerItem);
336 EXPECT_EQ(g_AVControllerItem != nullptr, true);
337 }
338
339 /**
340 * @tc.name: ProcFromNext001
341 * @tc.desc: input string to ProcFromNext
342 * @tc.type: FUNC
343 * @tc.require:
344 */
345 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext001, TestSize.Level1)
346 {
347 std::string deviceId = "";
348 std::string data = "";
349 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
350 EXPECT_EQ(data.size() == 0, true);
351 }
352
353 /**
354 * @tc.name: ProcFromNext002
355 * @tc.desc: input string to ProcFromNext
356 * @tc.type: FUNC
357 * @tc.require:
358 */
359 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext002, TestSize.Level1)
360 {
361 std::string deviceId = "0000";
362 std::string str1(2, char(SYNC_COMMAND));
363 std::string str2 = R"(
364 {"test":1}
365 )";
366 std::string data = str1 + str2;
367 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
368 EXPECT_EQ(data.size() > 2, true);
369 }
370
371 /**
372 * @tc.name: ProcFromNext003
373 * @tc.desc: input string to ProcFromNext
374 * @tc.type: FUNC
375 * @tc.require:
376 */
377 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext003, TestSize.Level1)
378 {
379 std::string deviceId = "0000";
380 std::string str1(2, char(SYNC_SET_VOLUME_COMMAND));
381 std::string str2 = R"(
382 {"test":1}
383 )";
384 std::string data = str1 + str2;
385 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
386 EXPECT_EQ(data.size() > 2, true);
387 }
388
389 /**
390 * @tc.name: ProcFromNext004
391 * @tc.desc: input string to ProcFromNext
392 * @tc.type: FUNC
393 * @tc.require:
394 */
395 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext004, TestSize.Level1)
396 {
397 std::string deviceId = "0000";
398 std::string str1(2, char(SYNC_SWITCH_AUDIO_DEVICE_COMMAND));
399 std::string str2 = R"(
400 {"test":1}
401 )";
402 std::string data = str1 + str2;
403 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
404 EXPECT_EQ(data.size() > 2, true);
405 }
406
407 /**
408 * @tc.name: ProcFromNext005
409 * @tc.desc: input string to ProcFromNext
410 * @tc.type: FUNC
411 * @tc.require:
412 */
413 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext005, TestSize.Level1)
414 {
415 std::string deviceId = "0000";
416 std::string str1(2, char(COLD_START));
417 std::string str2 = R"(
418 {"test":1}
419 )";
420 std::string data = str1 + str2;
421 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
422 EXPECT_EQ(data.size() > 2, true);
423 }
424
425 /**
426 * @tc.name: ProcFromNext006
427 * @tc.desc: input string to ProcFromNext
428 * @tc.type: FUNC
429 * @tc.require:
430 */
431 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcFromNext006, TestSize.Level1)
432 {
433 std::string deviceId = "0000";
434 std::string str1(2, char(0));
435 std::string str2 = R"(
436 {"test":1}
437 )";
438 std::string data = str1 + str2;
439 g_MigrateAVSessionServer->ProcFromNext(deviceId, data);
440 EXPECT_EQ(data.size() > 2, true);
441 }
442
443 /**
444 * @tc.name: ProcControlCommandFromNext001
445 * @tc.desc: tset the member of ProcControlCommandFromNext
446 * @tc.type: FUNC
447 * @tc.require:
448 */
449 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext001, TestSize.Level1)
450 {
451 Json::Value jsonValue;
452 jsonValue[COMMAND_CODE] = 1;
453 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
454 EXPECT_EQ(jsonValue.isMember(COMMAND_CODE), true);
455 }
456
457 /**
458 * @tc.name: ProcControlCommandFromNext002
459 * @tc.desc: tset the member of ProcControlCommandFromNext
460 * @tc.type: FUNC
461 * @tc.require:
462 */
463 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext002, TestSize.Level1)
464 {
465 Json::Value jsonValue;
466 jsonValue[COMMAND_ARGS] = "1";
467 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
468 EXPECT_EQ(jsonValue.isMember(COMMAND_ARGS), true);
469 }
470
471 /**
472 * @tc.name: ProcControlCommandFromNext003
473 * @tc.desc: tset the member of ProcControlCommandFromNext
474 * @tc.type: FUNC
475 * @tc.require:
476 */
477 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext003, TestSize.Level1)
478 {
479 std::string id = "001";
480 g_MigrateAVSessionServer->lastSessionId_ = id;
481 g_MigrateAVSessionServer->playerIdToControllerMap_[id] = g_AVControllerItem;
482 Json::Value jsonValue;
483 jsonValue[COMMAND_CODE] = 10;
484 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
485 EXPECT_EQ(jsonValue.isMember(COMMAND_CODE), true);
486 }
487
488 /**
489 * @tc.name: ProcControlCommandFromNext003
490 * @tc.desc: tset the member of ProcControlCommandFromNext
491 * @tc.type: FUNC
492 * @tc.require:
493 */
494 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcControlCommandFromNext004, TestSize.Level1)
495 {
496 std::string id = "001";
497 g_MigrateAVSessionServer->lastSessionId_ = id;
498 g_MigrateAVSessionServer->playerIdToControllerMap_[id] = g_AVControllerItem;
499 Json::Value jsonValue;
500 jsonValue[COMMAND_CODE] = 0;
501 g_MigrateAVSessionServer->ProcControlCommandFromNext(jsonValue);
502 EXPECT_EQ(jsonValue.isMember(COMMAND_CODE), true);
503 }
504
505 /**
506 * @tc.name: ProcessColdStartFromNext001
507 * @tc.desc: tset the member of ProcessColdStartFromNext
508 * @tc.type: FUNC
509 * @tc.require:
510 */
511 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcessColdStartFromNext001, TestSize.Level1)
512 {
513 Json::Value jsonValue;
514 jsonValue[COMMAND_CODE] = 1;
515 g_MigrateAVSessionServer->ProcessColdStartFromNext(jsonValue);
516 EXPECT_EQ(jsonValue.isMember(COMMAND_CODE), true);
517 }
518
519 /**
520 * @tc.name: ProcessColdStartFromNext002
521 * @tc.desc: tset the member of ProcessColdStartFromNext
522 * @tc.type: FUNC
523 * @tc.require:
524 */
525 static HWTEST_F(MigrateAVSessionServerForNextTest, ProcessColdStartFromNext002, TestSize.Level1)
526 {
527 Json::Value jsonValue;
528 jsonValue[MIGRATE_BUNDLE_NAME] = "1";
529 g_MigrateAVSessionServer->ProcessColdStartFromNext(jsonValue);
530 EXPECT_EQ(jsonValue.isMember(MIGRATE_BUNDLE_NAME), true);
531 }
532
533 /**
534 * @tc.name: ConvertAudioDeviceDescriptorsToJson001
535 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorsToJson
536 * @tc.type: FUNC
537 * @tc.require:
538 */
539 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorsToJson001, TestSize.Level1)
540 {
541 AudioDeviceDescriptorsWithSptr ptrs;
542 AudioDeviceDescriptorWithSptr ptr {new AudioDeviceDescriptor()};
543 ptrs.push_back(ptr);
544 EXPECT_EQ(ptrs.size() > 0, true);
545 g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorsToJson(ptrs);
546 }
547
548 /**
549 * @tc.name: ConvertAudioDeviceDescriptorsToJson002
550 * @tc.desc: tset the member of ConvertAudioDeviceDescriptorsToJson
551 * @tc.type: FUNC
552 * @tc.require:
553 */
554 static HWTEST_F(MigrateAVSessionServerForNextTest, ConvertAudioDeviceDescriptorsToJson002, TestSize.Level1)
555 {
556 AudioDeviceDescriptorsWithSptr ptrs;
557 ptrs.push_back(nullptr);
558 EXPECT_EQ(ptrs.size() > 0, true);
559 g_MigrateAVSessionServer->ConvertAudioDeviceDescriptorsToJson(ptrs);
560 }
561
562 /**
563 * @tc.name: VolumeControlCommand001
564 * @tc.desc: tset the member of VolumeControlCommand
565 * @tc.type: FUNC
566 * @tc.require:
567 */
568 static HWTEST_F(MigrateAVSessionServerForNextTest, VolumeControlCommand001, TestSize.Level1)
569 {
570 Json::Value jsonValue;
571 jsonValue[COMMAND_CODE] = 1;
572 g_MigrateAVSessionServer->VolumeControlCommand(jsonValue);
573 EXPECT_EQ(jsonValue.isMember(COMMAND_CODE), true);
574 }
575
576 /**
577 * @tc.name: VolumeControlCommand002
578 * @tc.desc: tset the member of VolumeControlCommand
579 * @tc.type: FUNC
580 * @tc.require:
581 */
582 static HWTEST_F(MigrateAVSessionServerForNextTest, VolumeControlCommand002, TestSize.Level1)
583 {
584 Json::Value jsonValue;
585 jsonValue[AUDIO_VOLUME] = 1;
586 g_MigrateAVSessionServer->VolumeControlCommand(jsonValue);
587 EXPECT_EQ(jsonValue.isMember(AUDIO_VOLUME), true);
588 }