1 /*
2 * Copyright (c) 2024 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 "avsession_log.h"
18 #include "avsession_errors.h"
19 #include "accesstoken_kit.h"
20 #include "nativetoken_kit.h"
21 #include "token_setproc.h"
22 #include "iservice_registry.h"
23 #include "avmedia_description.h"
24 #include "av_file_descriptor.h"
25 #include "system_ability_definition.h"
26 #include "avsession_controller_proxy.h"
27
28 using namespace OHOS::AVSession;
29 using namespace OHOS::Security::AccessToken;
30
31 static uint64_t g_selfTokenId = 0;
32 static HapInfoParams g_info = {
33 .userID = 100,
34 .bundleName = "ohos.permission_test.demo",
35 .instIndex = 0,
36 .appIDDesc = "ohos.permission_test.demo",
37 .isSystemApp = true
38 };
39
40 static HapPolicyParams g_policy = {
41 .apl = APL_NORMAL,
42 .domain = "test.domain",
43 .permList = {
44 {
45 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
46 .bundleName = "ohos.permission_test.demo",
47 .grantMode = 1,
48 .availableLevel = APL_NORMAL,
49 .label = "label",
50 .labelId = 1,
51 .description = "test",
52 .descriptionId = 1
53 }
54 },
55 .permStateList = {
56 {
57 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
58 .isGeneral = true,
59 .resDeviceID = {"local"},
60 .grantStatus = {PermissionState::PERMISSION_GRANTED},
61 .grantFlags = {1}
62 }
63 }
64 };
65
66 class AVSessionControllerProxyTest : public testing::Test {
67 public:
68 static void SetUpTestCase(void);
69 static void TearDownTestCase(void);
70 void SetUp();
71 void TearDown();
72
73 std::shared_ptr<AVSessionControllerProxy> aVSessionControllerProxyEmpty;
74 OHOS::sptr<AVSessionControllerProxy> aVSessionControllerProxy;
75 };
76
SetUpTestCase()77 void AVSessionControllerProxyTest::SetUpTestCase()
78 {
79 g_selfTokenId = GetSelfTokenID();
80 AccessTokenKit::AllocHapToken(g_info, g_policy);
81 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
82 SetSelfTokenID(tokenID.tokenIDEx);
83 }
84
TearDownTestCase()85 void AVSessionControllerProxyTest::TearDownTestCase()
86 {
87 SetSelfTokenID(g_selfTokenId);
88 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
89 AccessTokenKit::DeleteToken(tokenId);
90 }
91
SetUp()92 void AVSessionControllerProxyTest::SetUp()
93 {
94 OHOS::sptr<IRemoteObject> iRemoteObject;
95 aVSessionControllerProxyEmpty = std::make_shared<AVSessionControllerProxy>(iRemoteObject);
96
97 auto mgr = OHOS::SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager();
98 if (mgr == nullptr) {
99 SLOGI("failed to get sa mgr");
100 return;
101 }
102 auto object = mgr->GetSystemAbility(OHOS::AVSESSION_SERVICE_ID);
103 if (object == nullptr) {
104 SLOGI("failed to get service");
105 return;
106 }
107 aVSessionControllerProxy = OHOS::iface_cast<AVSessionControllerProxy>(object);
108 }
109
TearDown()110 void AVSessionControllerProxyTest::TearDown()
111 {
112 }
113
114 /**
115 * @tc.name: GetAVCallState001
116 * @tc.desc: Test GetAVCallState
117 * @tc.type: FUNC
118 */
119 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallState001, testing::ext::TestSize.Level1)
120 {
121 SLOGI("GetAVCallState001, start");
122 AVCallState avCallState;
123 int32_t ret = aVSessionControllerProxyEmpty->GetAVCallState(avCallState);
124 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
125 SLOGI("GetAVCallState001, end");
126 }
127
128 /**
129 * @tc.name: GetAVCallMetaData001
130 * @tc.desc: Test GetAVCallMetaData
131 * @tc.type: FUNC
132 */
133 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallMetaData001, testing::ext::TestSize.Level1)
134 {
135 SLOGI("GetAVCallMetaData001, start");
136 AVCallMetaData avCallMetaData;
137 int32_t ret = aVSessionControllerProxyEmpty->GetAVCallMetaData(avCallMetaData);
138 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
139 SLOGI("GetAVCallMetaData001, end");
140 }
141
142 /**
143 * @tc.name: GetAVPlaybackState001
144 * @tc.desc: Test GetAVPlaybackState
145 * @tc.type: FUNC
146 */
147 static HWTEST_F(AVSessionControllerProxyTest, GetAVPlaybackState001, testing::ext::TestSize.Level1)
148 {
149 SLOGI("GetAVPlaybackState001, start");
150 AVPlaybackState state;
151 int32_t ret = aVSessionControllerProxyEmpty->GetAVPlaybackState(state);
152 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
153 SLOGI("GetAVPlaybackState001, end");
154 }
155
156 /**
157 * @tc.name: GetAVMetaData001
158 * @tc.desc: Test GetAVMetaData
159 * @tc.type: FUNC
160 */
161 static HWTEST_F(AVSessionControllerProxyTest, GetAVMetaData001, testing::ext::TestSize.Level1)
162 {
163 SLOGI("GetAVMetaData001, start");
164 AVMetaData data;
165 int32_t ret = aVSessionControllerProxyEmpty->GetAVMetaData(data);
166 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
167 SLOGI("GetAVMetaData001, end");
168 }
169
170 /**
171 * @tc.name: SendAVKeyEvent001
172 * @tc.desc: Test SendAVKeyEvent
173 * @tc.type: FUNC
174 */
175 static HWTEST_F(AVSessionControllerProxyTest, SendAVKeyEvent001, testing::ext::TestSize.Level1)
176 {
177 SLOGI("SendAVKeyEvent001, start");
178 auto keyEvent = OHOS::MMI::KeyEvent::Create();
179 int32_t ret = aVSessionControllerProxyEmpty->SendAVKeyEvent(*keyEvent);
180 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
181 SLOGI("SendAVKeyEvent001, end");
182 }
183
184 /**
185 * @tc.name: GetLaunchAbility001
186 * @tc.desc: Test GetLaunchAbility
187 * @tc.type: FUNC
188 */
189 static HWTEST_F(AVSessionControllerProxyTest, GetLaunchAbility001, testing::ext::TestSize.Level1)
190 {
191 SLOGI("GetLaunchAbility001, start");
192 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
193 int32_t ret = aVSessionControllerProxyEmpty->GetLaunchAbility(ability);
194 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
195 SLOGI("GetLaunchAbility001, end");
196 }
197
198 /**
199 * @tc.name: GetValidCommands001
200 * @tc.desc: Test GetValidCommands
201 * @tc.type: FUNC
202 */
203 static HWTEST_F(AVSessionControllerProxyTest, GetValidCommands001, testing::ext::TestSize.Level1)
204 {
205 SLOGI("GetValidCommands001, start");
206 std::vector<int32_t> cmds = {0};
207 int32_t ret = aVSessionControllerProxyEmpty->GetValidCommands(cmds);
208 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
209 SLOGI("GetValidCommands001, end");
210 }
211
212 /**
213 * @tc.name: IsSessionActive001
214 * @tc.desc: Test IsSessionActive
215 * @tc.type: FUNC
216 */
217 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive001, testing::ext::TestSize.Level1)
218 {
219 SLOGI("IsSessionActive001, start");
220 bool isActive = true;
221 int32_t ret = aVSessionControllerProxyEmpty->IsSessionActive(isActive);
222 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
223 SLOGI("IsSessionActive001, end");
224 }
225
226 /**
227 * @tc.name: IsSessionActive002
228 * @tc.desc: Test IsSessionActive
229 * @tc.type: FUNC
230 */
231 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive002, testing::ext::TestSize.Level1)
232 {
233 SLOGI("IsSessionActive002, start");
234 bool isActive = false;
235 int32_t ret = aVSessionControllerProxyEmpty->IsSessionActive(isActive);
236 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
237 SLOGI("IsSessionActive002, end");
238 }
239
240 /**
241 * @tc.name: SendControlCommand001
242 * @tc.desc: Test SendControlCommand
243 * @tc.type: FUNC
244 */
245 static HWTEST_F(AVSessionControllerProxyTest, SendControlCommand001, testing::ext::TestSize.Level1)
246 {
247 SLOGI("SendControlCommand001, start");
248 AVControlCommand cmd;
249 int32_t ret = aVSessionControllerProxyEmpty->SendControlCommand(cmd);
250 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
251 SLOGI("SendControlCommand001, end");
252 }
253
254 /**
255 * @tc.name: SendCommonCommand001
256 * @tc.desc: Test SendCommonCommand
257 * @tc.type: FUNC
258 */
259 static HWTEST_F(AVSessionControllerProxyTest, SendCommonCommand001, testing::ext::TestSize.Level1)
260 {
261 SLOGI("SendCommonCommand001, start");
262 std::string commonCommand;
263 OHOS::AAFwk::WantParams commandArgs;
264 int32_t ret = aVSessionControllerProxyEmpty->SendCommonCommand(commonCommand, commandArgs);
265 EXPECT_EQ(ret, ERR_SESSION_DEACTIVE);
266 SLOGI("SendCommonCommand001, end");
267 }
268
269 /**
270 * @tc.name: RegisterCallback001
271 * @tc.desc: Test RegisterCallback
272 * @tc.type: FUNC
273 */
274 static HWTEST_F(AVSessionControllerProxyTest, RegisterCallback001, testing::ext::TestSize.Level1)
275 {
276 SLOGI("RegisterCallback001, start");
277 std::shared_ptr<AVControllerCallback> callback;
278 int32_t ret = aVSessionControllerProxyEmpty->RegisterCallback(callback);
279 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
280 SLOGI("RegisterCallback001, end");
281 }
282
283 /**
284 * @tc.name: SetAVCallMetaFilter001
285 * @tc.desc: Test SetAVCallMetaFilter
286 * @tc.type: FUNC
287 */
288 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallMetaFilter001, testing::ext::TestSize.Level1)
289 {
290 SLOGI("SetAVCallMetaFilter001, start");
291 AVCallMetaData::AVCallMetaMaskType filter;
292 int32_t ret = aVSessionControllerProxyEmpty->SetAVCallMetaFilter(filter);
293 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
294 SLOGI("SetAVCallMetaFilter001, end");
295 }
296
297 /**
298 * @tc.name: SetAVCallStateFilter001
299 * @tc.desc: Test SetAVCallStateFilter
300 * @tc.type: FUNC
301 */
302 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallStateFilter001, testing::ext::TestSize.Level1)
303 {
304 SLOGI("SetAVCallStateFilter001, start");
305 AVCallState::AVCallStateMaskType filter;
306 int32_t ret = aVSessionControllerProxyEmpty->SetAVCallStateFilter(filter);
307 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
308 SLOGI("SetAVCallStateFilter001, end");
309 }
310
311 /**
312 * @tc.name: SetMetaFilter001
313 * @tc.desc: Test SetMetaFilter
314 * @tc.type: FUNC
315 */
316 static HWTEST_F(AVSessionControllerProxyTest, SetMetaFilter001, testing::ext::TestSize.Level1)
317 {
318 SLOGI("SetMetaFilter001, start");
319 AVMetaData::MetaMaskType filter;
320 int32_t ret = aVSessionControllerProxyEmpty->SetMetaFilter(filter);
321 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
322 SLOGI("SetMetaFilter001, end");
323 }
324
325 /**
326 * @tc.name: SetPlaybackFilter001
327 * @tc.desc: Test SetPlaybackFilter
328 * @tc.type: FUNC
329 */
330 static HWTEST_F(AVSessionControllerProxyTest, SetPlaybackFilter001, testing::ext::TestSize.Level1)
331 {
332 SLOGI("SetPlaybackFilter001, start");
333 AVPlaybackState::PlaybackStateMaskType filter;
334 int32_t ret = aVSessionControllerProxyEmpty->SetPlaybackFilter(filter);
335 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
336 SLOGI("SetPlaybackFilter001, end");
337 }
338
339 /**
340 * @tc.name: GetAVQueueItems001
341 * @tc.desc: Test GetAVQueueItems
342 * @tc.type: FUNC
343 */
344 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueItems001, testing::ext::TestSize.Level1)
345 {
346 SLOGI("GetAVQueueItems001, start");
347 std::vector<AVQueueItem> items = {};
348 int32_t ret = aVSessionControllerProxyEmpty->GetAVQueueItems(items);
349 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
350 SLOGI("GetAVQueueItems001, end");
351 }
352
353 /**
354 * @tc.name: GetAVQueueTitle001
355 * @tc.desc: Test GetAVQueueTitle
356 * @tc.type: FUNC
357 */
358 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueTitle001, testing::ext::TestSize.Level1)
359 {
360 SLOGI("GetAVQueueTitle001, start");
361 std::string title = "title";
362 int32_t ret = aVSessionControllerProxyEmpty->GetAVQueueTitle(title);
363 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
364 SLOGI("GetAVQueueTitle001, end");
365 }
366
367 /**
368 * @tc.name: SkipToQueueItem001
369 * @tc.desc: Test SkipToQueueItem
370 * @tc.type: FUNC
371 */
372 static HWTEST_F(AVSessionControllerProxyTest, SkipToQueueItem001, testing::ext::TestSize.Level1)
373 {
374 SLOGI("SkipToQueueItem001, start");
375 int32_t itemId = 0;
376 int32_t ret = aVSessionControllerProxyEmpty->SkipToQueueItem(itemId);
377 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
378 SLOGI("SkipToQueueItem001, end");
379 }
380
381 /**
382 * @tc.name: GetExtras001
383 * @tc.desc: Test GetExtras
384 * @tc.type: FUNC
385 */
386 static HWTEST_F(AVSessionControllerProxyTest, GetExtras001, testing::ext::TestSize.Level1)
387 {
388 SLOGI("GetExtras001, start");
389 OHOS::AAFwk::WantParams extras;
390 int32_t ret = aVSessionControllerProxyEmpty->GetExtras(extras);
391 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
392 SLOGI("GetExtras001, end");
393 }
394
395 /**
396 * @tc.name: GetSessionId001
397 * @tc.desc: Test GetSessionId
398 * @tc.type: FUNC
399 */
400 static HWTEST_F(AVSessionControllerProxyTest, GetSessionId001, testing::ext::TestSize.Level1)
401 {
402 SLOGI("GetSessionId001, start");
403 std::string id = aVSessionControllerProxyEmpty->GetSessionId();
404 EXPECT_EQ(id, "");
405 SLOGI("GetSessionId001, end");
406 }
407
408 /**
409 * @tc.name: GetRealPlaybackPosition001
410 * @tc.desc: Test GetRealPlaybackPosition
411 * @tc.type: FUNC
412 */
413 static HWTEST_F(AVSessionControllerProxyTest, GetRealPlaybackPosition001, testing::ext::TestSize.Level1)
414 {
415 SLOGI("GetRealPlaybackPosition001, start");
416 int64_t ret = aVSessionControllerProxyEmpty->GetRealPlaybackPosition();
417 EXPECT_EQ(ret, 0);
418 SLOGI("GetRealPlaybackPosition001, end");
419 }
420
421 /**
422 * @tc.name: IsDestroy001
423 * @tc.desc: Test IsDestroy
424 * @tc.type: FUNC
425 */
426 static HWTEST_F(AVSessionControllerProxyTest, IsDestroy001, testing::ext::TestSize.Level1)
427 {
428 SLOGI("IsDestroy001, start");
429 bool ret = aVSessionControllerProxy->IsDestroy();
430 EXPECT_EQ(ret, false);
431 SLOGI("IsDestroy001, end");
432 }
433
434 /**
435 * @tc.name: Destroy001
436 * @tc.desc: Test Destroy
437 * @tc.type: FUNC
438 */
439 static HWTEST_F(AVSessionControllerProxyTest, Destroy001, testing::ext::TestSize.Level1)
440 {
441 SLOGI("Destroy001, start");
442 bool ret = aVSessionControllerProxy->Destroy();
443 EXPECT_EQ(ret, true);
444 SLOGI("Destroy001, end");
445 }
446
447 /**
448 * @tc.name: IsDestroy002
449 * @tc.desc: Test IsDestroy
450 * @tc.type: FUNC
451 */
452 static HWTEST_F(AVSessionControllerProxyTest, IsDestroy002, testing::ext::TestSize.Level1)
453 {
454 SLOGI("IsDestroy002, start");
455 bool ret = aVSessionControllerProxy->IsDestroy();
456 EXPECT_EQ(ret, false);
457 SLOGI("IsDestroy002, end");
458 }
459
460 /**
461 * @tc.name: GetAVCallState002
462 * @tc.desc: Test GetAVCallState
463 * @tc.type: FUNC
464 */
465 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallState002, testing::ext::TestSize.Level1)
466 {
467 SLOGI("GetAVCallState002, start");
468 AVCallState avCallState;
469 int32_t ret = aVSessionControllerProxy->GetAVCallState(avCallState);
470 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
471 SLOGI("GetAVCallState002, end");
472 }
473
474 /**
475 * @tc.name: GetAVCallMetaData002
476 * @tc.desc: Test GetAVCallMetaData
477 * @tc.type: FUNC
478 */
479 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallMetaData002, testing::ext::TestSize.Level1)
480 {
481 SLOGI("GetAVCallMetaData002, start");
482 AVCallMetaData avCallMetaData;
483 int32_t ret = aVSessionControllerProxy->GetAVCallMetaData(avCallMetaData);
484 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
485 SLOGI("GetAVCallMetaData002, end");
486 }
487
488 /**
489 * @tc.name: GetAVPlaybackState002
490 * @tc.desc: Test GetAVPlaybackState
491 * @tc.type: FUNC
492 */
493 static HWTEST_F(AVSessionControllerProxyTest, GetAVPlaybackState002, testing::ext::TestSize.Level1)
494 {
495 SLOGI("GetAVPlaybackState002, start");
496 AVPlaybackState state;
497 int32_t ret = aVSessionControllerProxy->GetAVPlaybackState(state);
498 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
499 SLOGI("GetAVPlaybackState002, end");
500 }
501
502 /**
503 * @tc.name: GetAVMetaData002
504 * @tc.desc: Test GetAVMetaData
505 * @tc.type: FUNC
506 */
507 static HWTEST_F(AVSessionControllerProxyTest, GetAVMetaData002, testing::ext::TestSize.Level1)
508 {
509 SLOGI("GetAVMetaData002, start");
510 AVMetaData data;
511 int32_t ret = aVSessionControllerProxy->GetAVMetaData(data);
512 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
513 SLOGI("GetAVMetaData002, end");
514 }
515
516 /**
517 * @tc.name: SendAVKeyEvent002
518 * @tc.desc: Test SendAVKeyEvent
519 * @tc.type: FUNC
520 */
521 static HWTEST_F(AVSessionControllerProxyTest, SendAVKeyEvent002, testing::ext::TestSize.Level1)
522 {
523 SLOGI("SendAVKeyEvent002, start");
524 auto keyEvent = OHOS::MMI::KeyEvent::Create();
525 int32_t ret = aVSessionControllerProxy->SendAVKeyEvent(*keyEvent);
526 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
527 SLOGI("SendAVKeyEvent002, end");
528 }
529
530 /**
531 * @tc.name: GetLaunchAbility002
532 * @tc.desc: Test GetLaunchAbility
533 * @tc.type: FUNC
534 */
535 static HWTEST_F(AVSessionControllerProxyTest, GetLaunchAbility002, testing::ext::TestSize.Level1)
536 {
537 SLOGI("GetLaunchAbility002, start");
538 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
539 int32_t ret = aVSessionControllerProxy->GetLaunchAbility(ability);
540 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
541 SLOGI("GetLaunchAbility002, end");
542 }
543
544 /**
545 * @tc.name: GetValidCommands002
546 * @tc.desc: Test GetValidCommands
547 * @tc.type: FUNC
548 */
549 static HWTEST_F(AVSessionControllerProxyTest, GetValidCommands002, testing::ext::TestSize.Level1)
550 {
551 SLOGI("GetValidCommands002, start");
552 std::vector<int32_t> cmds = {0};
553 int32_t ret = aVSessionControllerProxy->GetValidCommands(cmds);
554 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
555 SLOGI("GetValidCommands002, end");
556 }
557
558 /**
559 * @tc.name: IsSessionActive003
560 * @tc.desc: Test IsSessionActive
561 * @tc.type: FUNC
562 */
563 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive003, testing::ext::TestSize.Level1)
564 {
565 SLOGI("IsSessionActive003, start");
566 bool isActive = true;
567 int32_t ret = aVSessionControllerProxy->IsSessionActive(isActive);
568 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
569 SLOGI("IsSessionActive003, end");
570 }
571
572 /**
573 * @tc.name: IsSessionActive004
574 * @tc.desc: Test IsSessionActive
575 * @tc.type: FUNC
576 */
577 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive004, testing::ext::TestSize.Level1)
578 {
579 SLOGI("IsSessionActive004, start");
580 bool isActive = false;
581 int32_t ret = aVSessionControllerProxy->IsSessionActive(isActive);
582 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
583 SLOGI("IsSessionActive004, end");
584 }
585
586 /**
587 * @tc.name: SendControlCommand002
588 * @tc.desc: Test SendControlCommand
589 * @tc.type: FUNC
590 */
591 static HWTEST_F(AVSessionControllerProxyTest, SendControlCommand002, testing::ext::TestSize.Level1)
592 {
593 SLOGI("SendControlCommand002, start");
594 AVControlCommand cmd;
595 int32_t ret = aVSessionControllerProxy->SendControlCommand(cmd);
596 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
597 SLOGI("SendControlCommand002, end");
598 }
599
600 /**
601 * @tc.name: SendCommonCommand002
602 * @tc.desc: Test SendCommonCommand
603 * @tc.type: FUNC
604 */
605 static HWTEST_F(AVSessionControllerProxyTest, SendCommonCommand002, testing::ext::TestSize.Level1)
606 {
607 SLOGI("SendCommonCommand002, start");
608 std::string commonCommand;
609 OHOS::AAFwk::WantParams commandArgs;
610 int32_t ret = aVSessionControllerProxy->SendCommonCommand(commonCommand, commandArgs);
611 EXPECT_EQ(ret, ERR_SESSION_DEACTIVE);
612 SLOGI("SendCommonCommand002, end");
613 }
614
615 /**
616 * @tc.name: RegisterCallback002
617 * @tc.desc: Test RegisterCallback
618 * @tc.type: FUNC
619 */
620 static HWTEST_F(AVSessionControllerProxyTest, RegisterCallback002, testing::ext::TestSize.Level1)
621 {
622 SLOGI("RegisterCallback002, start");
623 std::shared_ptr<AVControllerCallback> callback;
624 int32_t ret = aVSessionControllerProxy->RegisterCallback(callback);
625 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
626 SLOGI("RegisterCallback002, end");
627 }
628
629 /**
630 * @tc.name: SetAVCallMetaFilter002
631 * @tc.desc: Test SetAVCallMetaFilter
632 * @tc.type: FUNC
633 */
634 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallMetaFilter002, testing::ext::TestSize.Level1)
635 {
636 SLOGI("SetAVCallMetaFilter002, start");
637 AVCallMetaData::AVCallMetaMaskType filter;
638 int32_t ret = aVSessionControllerProxy->SetAVCallMetaFilter(filter);
639 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
640 SLOGI("SetAVCallMetaFilter002, end");
641 }
642
643 /**
644 * @tc.name: SetAVCallStateFilter002
645 * @tc.desc: Test SetAVCallStateFilter
646 * @tc.type: FUNC
647 */
648 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallStateFilter002, testing::ext::TestSize.Level1)
649 {
650 SLOGI("SetAVCallStateFilter002, start");
651 AVCallState::AVCallStateMaskType filter;
652 int32_t ret = aVSessionControllerProxy->SetAVCallStateFilter(filter);
653 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
654 SLOGI("SetAVCallStateFilter002, end");
655 }
656
657 /**
658 * @tc.name: SetMetaFilter002
659 * @tc.desc: Test SetMetaFilter
660 * @tc.type: FUNC
661 */
662 static HWTEST_F(AVSessionControllerProxyTest, SetMetaFilter002, testing::ext::TestSize.Level1)
663 {
664 SLOGI("SetMetaFilter002, start");
665 AVMetaData::MetaMaskType filter;
666 int32_t ret = aVSessionControllerProxy->SetMetaFilter(filter);
667 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
668 SLOGI("SetMetaFilter002, end");
669 }
670
671 /**
672 * @tc.name: SetPlaybackFilter002
673 * @tc.desc: Test SetPlaybackFilter
674 * @tc.type: FUNC
675 */
676 static HWTEST_F(AVSessionControllerProxyTest, SetPlaybackFilter002, testing::ext::TestSize.Level1)
677 {
678 SLOGI("SetPlaybackFilter002, start");
679 AVPlaybackState::PlaybackStateMaskType filter;
680 int32_t ret = aVSessionControllerProxy->SetPlaybackFilter(filter);
681 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
682 SLOGI("SetPlaybackFilter002, end");
683 }
684
685 /**
686 * @tc.name: GetAVQueueItems002
687 * @tc.desc: Test GetAVQueueItems
688 * @tc.type: FUNC
689 */
690 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueItems002, testing::ext::TestSize.Level1)
691 {
692 SLOGI("GetAVQueueItems002, start");
693 std::vector<AVQueueItem> items = {};
694 int32_t ret = aVSessionControllerProxy->GetAVQueueItems(items);
695 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
696 SLOGI("GetAVQueueItems002, end");
697 }
698
699 /**
700 * @tc.name: GetAVQueueTitle002
701 * @tc.desc: Test GetAVQueueTitle
702 * @tc.type: FUNC
703 */
704 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueTitle002, testing::ext::TestSize.Level1)
705 {
706 SLOGI("GetAVQueueTitle002, start");
707 std::string title = "title";
708 int32_t ret = aVSessionControllerProxy->GetAVQueueTitle(title);
709 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
710 SLOGI("GetAVQueueTitle002, end");
711 }
712
713 /**
714 * @tc.name: SkipToQueueItem002
715 * @tc.desc: Test SkipToQueueItem
716 * @tc.type: FUNC
717 */
718 static HWTEST_F(AVSessionControllerProxyTest, SkipToQueueItem002, testing::ext::TestSize.Level1)
719 {
720 SLOGI("SkipToQueueItem002, start");
721 int32_t itemId = 0;
722 int32_t ret = aVSessionControllerProxy->SkipToQueueItem(itemId);
723 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
724 SLOGI("SkipToQueueItem002, end");
725 }
726
727 /**
728 * @tc.name: GetExtras002
729 * @tc.desc: Test GetExtras
730 * @tc.type: FUNC
731 */
732 static HWTEST_F(AVSessionControllerProxyTest, GetExtras002, testing::ext::TestSize.Level1)
733 {
734 SLOGI("GetExtras002, start");
735 OHOS::AAFwk::WantParams extras;
736 int32_t ret = aVSessionControllerProxy->GetExtras(extras);
737 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
738 SLOGI("GetExtras002, end");
739 }
740
741 /**
742 * @tc.name: GetSessionId002
743 * @tc.desc: Test GetSessionId
744 * @tc.type: FUNC
745 */
746 static HWTEST_F(AVSessionControllerProxyTest, GetSessionId002, testing::ext::TestSize.Level1)
747 {
748 SLOGI("GetSessionId002, start");
749 std::string id = aVSessionControllerProxy->GetSessionId();
750 EXPECT_EQ(id, "");
751 SLOGI("GetSessionId002, end");
752 }
753
754 /**
755 * @tc.name: GetRealPlaybackPosition002
756 * @tc.desc: Test GetRealPlaybackPosition
757 * @tc.type: FUNC
758 */
759 static HWTEST_F(AVSessionControllerProxyTest, GetRealPlaybackPosition002, testing::ext::TestSize.Level1)
760 {
761 SLOGI("GetRealPlaybackPosition002, start");
762 int64_t ret = aVSessionControllerProxy->GetRealPlaybackPosition();
763 EXPECT_EQ(ret, 0);
764 SLOGI("GetRealPlaybackPosition002, end");
765 }