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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
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.Level0)
260 {
261 SLOGI("SendCommonCommand001, start");
262 std::string commonCommand;
263 OHOS::AAFwk::WantParams commandArgs;
264 int32_t ret = aVSessionControllerProxyEmpty->SendCommonCommand(commonCommand, commandArgs);
265 // return ERR_SERVICE_NOT_EXIST for remote not set
266 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
267 SLOGI("SendCommonCommand001, end");
268 }
269
270 /**
271 * @tc.name: RegisterCallback001
272 * @tc.desc: Test RegisterCallback
273 * @tc.type: FUNC
274 */
275 static HWTEST_F(AVSessionControllerProxyTest, RegisterCallback001, testing::ext::TestSize.Level0)
276 {
277 SLOGI("RegisterCallback001, start");
278 std::shared_ptr<AVControllerCallback> callback;
279 int32_t ret = aVSessionControllerProxyEmpty->RegisterCallback(callback);
280 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
281 SLOGI("RegisterCallback001, end");
282 }
283
284 /**
285 * @tc.name: SetAVCallMetaFilter001
286 * @tc.desc: Test SetAVCallMetaFilter
287 * @tc.type: FUNC
288 */
289 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallMetaFilter001, testing::ext::TestSize.Level0)
290 {
291 SLOGI("SetAVCallMetaFilter001, start");
292 AVCallMetaData::AVCallMetaMaskType filter;
293 int32_t ret = aVSessionControllerProxyEmpty->SetAVCallMetaFilter(filter);
294 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
295 SLOGI("SetAVCallMetaFilter001, end");
296 }
297
298 /**
299 * @tc.name: SetAVCallStateFilter001
300 * @tc.desc: Test SetAVCallStateFilter
301 * @tc.type: FUNC
302 */
303 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallStateFilter001, testing::ext::TestSize.Level0)
304 {
305 SLOGI("SetAVCallStateFilter001, start");
306 AVCallState::AVCallStateMaskType filter;
307 int32_t ret = aVSessionControllerProxyEmpty->SetAVCallStateFilter(filter);
308 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
309 SLOGI("SetAVCallStateFilter001, end");
310 }
311
312 /**
313 * @tc.name: SetMetaFilter001
314 * @tc.desc: Test SetMetaFilter
315 * @tc.type: FUNC
316 */
317 static HWTEST_F(AVSessionControllerProxyTest, SetMetaFilter001, testing::ext::TestSize.Level0)
318 {
319 SLOGI("SetMetaFilter001, start");
320 AVMetaData::MetaMaskType filter;
321 int32_t ret = aVSessionControllerProxyEmpty->SetMetaFilter(filter);
322 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
323 SLOGI("SetMetaFilter001, end");
324 }
325
326 /**
327 * @tc.name: SetPlaybackFilter001
328 * @tc.desc: Test SetPlaybackFilter
329 * @tc.type: FUNC
330 */
331 static HWTEST_F(AVSessionControllerProxyTest, SetPlaybackFilter001, testing::ext::TestSize.Level0)
332 {
333 SLOGI("SetPlaybackFilter001, start");
334 AVPlaybackState::PlaybackStateMaskType filter;
335 int32_t ret = aVSessionControllerProxyEmpty->SetPlaybackFilter(filter);
336 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
337 SLOGI("SetPlaybackFilter001, end");
338 }
339
340 /**
341 * @tc.name: GetAVQueueItems001
342 * @tc.desc: Test GetAVQueueItems
343 * @tc.type: FUNC
344 */
345 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueItems001, testing::ext::TestSize.Level0)
346 {
347 SLOGI("GetAVQueueItems001, start");
348 std::vector<AVQueueItem> items = {};
349 int32_t ret = aVSessionControllerProxyEmpty->GetAVQueueItems(items);
350 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
351 SLOGI("GetAVQueueItems001, end");
352 }
353
354 /**
355 * @tc.name: GetAVQueueTitle001
356 * @tc.desc: Test GetAVQueueTitle
357 * @tc.type: FUNC
358 */
359 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueTitle001, testing::ext::TestSize.Level0)
360 {
361 SLOGI("GetAVQueueTitle001, start");
362 std::string title = "title";
363 int32_t ret = aVSessionControllerProxyEmpty->GetAVQueueTitle(title);
364 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
365 SLOGI("GetAVQueueTitle001, end");
366 }
367
368 /**
369 * @tc.name: SkipToQueueItem001
370 * @tc.desc: Test SkipToQueueItem
371 * @tc.type: FUNC
372 */
373 static HWTEST_F(AVSessionControllerProxyTest, SkipToQueueItem001, testing::ext::TestSize.Level0)
374 {
375 SLOGI("SkipToQueueItem001, start");
376 int32_t itemId = 0;
377 int32_t ret = aVSessionControllerProxyEmpty->SkipToQueueItem(itemId);
378 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
379 SLOGI("SkipToQueueItem001, end");
380 }
381
382 /**
383 * @tc.name: GetExtras001
384 * @tc.desc: Test GetExtras
385 * @tc.type: FUNC
386 */
387 static HWTEST_F(AVSessionControllerProxyTest, GetExtras001, testing::ext::TestSize.Level0)
388 {
389 SLOGI("GetExtras001, start");
390 OHOS::AAFwk::WantParams extras;
391 int32_t ret = aVSessionControllerProxyEmpty->GetExtras(extras);
392 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
393 SLOGI("GetExtras001, end");
394 }
395
396 /**
397 * @tc.name: GetSessionId001
398 * @tc.desc: Test GetSessionId
399 * @tc.type: FUNC
400 */
401 static HWTEST_F(AVSessionControllerProxyTest, GetSessionId001, testing::ext::TestSize.Level0)
402 {
403 SLOGI("GetSessionId001, start");
404 std::string id = aVSessionControllerProxyEmpty->GetSessionId();
405 EXPECT_EQ(id, "");
406 SLOGI("GetSessionId001, end");
407 }
408
409 /**
410 * @tc.name: GetRealPlaybackPosition001
411 * @tc.desc: Test GetRealPlaybackPosition
412 * @tc.type: FUNC
413 */
414 static HWTEST_F(AVSessionControllerProxyTest, GetRealPlaybackPosition001, testing::ext::TestSize.Level0)
415 {
416 SLOGI("GetRealPlaybackPosition001, start");
417 int64_t ret = aVSessionControllerProxyEmpty->GetRealPlaybackPosition();
418 EXPECT_EQ(ret, 0);
419 SLOGI("GetRealPlaybackPosition001, end");
420 }
421
422 /**
423 * @tc.name: IsDestroy001
424 * @tc.desc: Test IsDestroy
425 * @tc.type: FUNC
426 */
427 static HWTEST_F(AVSessionControllerProxyTest, IsDestroy001, testing::ext::TestSize.Level0)
428 {
429 SLOGI("IsDestroy001, start");
430 bool ret = aVSessionControllerProxy->IsDestroy();
431 EXPECT_EQ(ret, false);
432 SLOGI("IsDestroy001, end");
433 }
434
435 /**
436 * @tc.name: Destroy001
437 * @tc.desc: Test Destroy
438 * @tc.type: FUNC
439 */
440 static HWTEST_F(AVSessionControllerProxyTest, Destroy001, testing::ext::TestSize.Level0)
441 {
442 SLOGI("Destroy001, start");
443 bool ret = aVSessionControllerProxy->Destroy();
444 EXPECT_EQ(ret, true);
445 SLOGI("Destroy001, end");
446 }
447
448 /**
449 * @tc.name: IsDestroy002
450 * @tc.desc: Test IsDestroy
451 * @tc.type: FUNC
452 */
453 static HWTEST_F(AVSessionControllerProxyTest, IsDestroy002, testing::ext::TestSize.Level0)
454 {
455 SLOGI("IsDestroy002, start");
456 bool ret = aVSessionControllerProxy->IsDestroy();
457 EXPECT_EQ(ret, false);
458 SLOGI("IsDestroy002, end");
459 }
460
461 /**
462 * @tc.name: GetAVCallState002
463 * @tc.desc: Test GetAVCallState
464 * @tc.type: FUNC
465 */
466 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallState002, testing::ext::TestSize.Level0)
467 {
468 SLOGI("GetAVCallState002, start");
469 AVCallState avCallState;
470 int32_t ret = aVSessionControllerProxy->GetAVCallState(avCallState);
471 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
472 SLOGI("GetAVCallState002, end");
473 }
474
475 /**
476 * @tc.name: GetAVCallMetaData002
477 * @tc.desc: Test GetAVCallMetaData
478 * @tc.type: FUNC
479 */
480 static HWTEST_F(AVSessionControllerProxyTest, GetAVCallMetaData002, testing::ext::TestSize.Level0)
481 {
482 SLOGI("GetAVCallMetaData002, start");
483 AVCallMetaData avCallMetaData;
484 int32_t ret = aVSessionControllerProxy->GetAVCallMetaData(avCallMetaData);
485 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
486 SLOGI("GetAVCallMetaData002, end");
487 }
488
489 /**
490 * @tc.name: GetAVPlaybackState002
491 * @tc.desc: Test GetAVPlaybackState
492 * @tc.type: FUNC
493 */
494 static HWTEST_F(AVSessionControllerProxyTest, GetAVPlaybackState002, testing::ext::TestSize.Level0)
495 {
496 SLOGI("GetAVPlaybackState002, start");
497 AVPlaybackState state;
498 int32_t ret = aVSessionControllerProxy->GetAVPlaybackState(state);
499 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
500 SLOGI("GetAVPlaybackState002, end");
501 }
502
503 /**
504 * @tc.name: GetAVMetaData002
505 * @tc.desc: Test GetAVMetaData
506 * @tc.type: FUNC
507 */
508 static HWTEST_F(AVSessionControllerProxyTest, GetAVMetaData002, testing::ext::TestSize.Level0)
509 {
510 SLOGI("GetAVMetaData002, start");
511 AVMetaData data;
512 int32_t ret = aVSessionControllerProxy->GetAVMetaData(data);
513 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
514 SLOGI("GetAVMetaData002, end");
515 }
516
517 /**
518 * @tc.name: SendAVKeyEvent002
519 * @tc.desc: Test SendAVKeyEvent
520 * @tc.type: FUNC
521 */
522 static HWTEST_F(AVSessionControllerProxyTest, SendAVKeyEvent002, testing::ext::TestSize.Level0)
523 {
524 SLOGI("SendAVKeyEvent002, start");
525 auto keyEvent = OHOS::MMI::KeyEvent::Create();
526 int32_t ret = aVSessionControllerProxy->SendAVKeyEvent(*keyEvent);
527 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
528 SLOGI("SendAVKeyEvent002, end");
529 }
530
531 /**
532 * @tc.name: GetLaunchAbility002
533 * @tc.desc: Test GetLaunchAbility
534 * @tc.type: FUNC
535 */
536 static HWTEST_F(AVSessionControllerProxyTest, GetLaunchAbility002, testing::ext::TestSize.Level0)
537 {
538 SLOGI("GetLaunchAbility002, start");
539 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
540 int32_t ret = aVSessionControllerProxy->GetLaunchAbility(ability);
541 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
542 SLOGI("GetLaunchAbility002, end");
543 }
544
545 /**
546 * @tc.name: GetValidCommands002
547 * @tc.desc: Test GetValidCommands
548 * @tc.type: FUNC
549 */
550 static HWTEST_F(AVSessionControllerProxyTest, GetValidCommands002, testing::ext::TestSize.Level0)
551 {
552 SLOGI("GetValidCommands002, start");
553 std::vector<int32_t> cmds = {0};
554 int32_t ret = aVSessionControllerProxy->GetValidCommands(cmds);
555 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
556 SLOGI("GetValidCommands002, end");
557 }
558
559 /**
560 * @tc.name: IsSessionActive003
561 * @tc.desc: Test IsSessionActive
562 * @tc.type: FUNC
563 */
564 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive003, testing::ext::TestSize.Level0)
565 {
566 SLOGI("IsSessionActive003, start");
567 bool isActive = true;
568 int32_t ret = aVSessionControllerProxy->IsSessionActive(isActive);
569 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
570 SLOGI("IsSessionActive003, end");
571 }
572
573 /**
574 * @tc.name: IsSessionActive004
575 * @tc.desc: Test IsSessionActive
576 * @tc.type: FUNC
577 */
578 static HWTEST_F(AVSessionControllerProxyTest, IsSessionActive004, testing::ext::TestSize.Level0)
579 {
580 SLOGI("IsSessionActive004, start");
581 bool isActive = false;
582 int32_t ret = aVSessionControllerProxy->IsSessionActive(isActive);
583 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
584 SLOGI("IsSessionActive004, end");
585 }
586
587 /**
588 * @tc.name: SendControlCommand002
589 * @tc.desc: Test SendControlCommand
590 * @tc.type: FUNC
591 */
592 static HWTEST_F(AVSessionControllerProxyTest, SendControlCommand002, testing::ext::TestSize.Level0)
593 {
594 SLOGI("SendControlCommand002, start");
595 AVControlCommand cmd;
596 int32_t ret = aVSessionControllerProxy->SendControlCommand(cmd);
597 EXPECT_EQ(ret, ERR_COMMAND_NOT_SUPPORT);
598 SLOGI("SendControlCommand002, end");
599 }
600
601 /**
602 * @tc.name: SendCommonCommand002
603 * @tc.desc: Test SendCommonCommand
604 * @tc.type: FUNC
605 */
606 static HWTEST_F(AVSessionControllerProxyTest, SendCommonCommand002, testing::ext::TestSize.Level0)
607 {
608 SLOGI("SendCommonCommand002, start");
609 std::string commonCommand;
610 OHOS::AAFwk::WantParams commandArgs;
611 int32_t ret = aVSessionControllerProxy->SendCommonCommand(commonCommand, commandArgs);
612 // return ERR_IPC_SEND_REQUEST for ipc disable when controller not init
613 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
614 SLOGI("SendCommonCommand002, end");
615 }
616
617 /**
618 * @tc.name: RegisterCallback002
619 * @tc.desc: Test RegisterCallback
620 * @tc.type: FUNC
621 */
622 static HWTEST_F(AVSessionControllerProxyTest, RegisterCallback002, testing::ext::TestSize.Level0)
623 {
624 SLOGI("RegisterCallback002, start");
625 std::shared_ptr<AVControllerCallback> callback;
626 int32_t ret = aVSessionControllerProxy->RegisterCallback(callback);
627 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
628 SLOGI("RegisterCallback002, end");
629 }
630
631 /**
632 * @tc.name: SetAVCallMetaFilter002
633 * @tc.desc: Test SetAVCallMetaFilter
634 * @tc.type: FUNC
635 */
636 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallMetaFilter002, testing::ext::TestSize.Level0)
637 {
638 SLOGI("SetAVCallMetaFilter002, start");
639 AVCallMetaData::AVCallMetaMaskType filter;
640 int32_t ret = aVSessionControllerProxy->SetAVCallMetaFilter(filter);
641 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
642 SLOGI("SetAVCallMetaFilter002, end");
643 }
644
645 /**
646 * @tc.name: SetAVCallStateFilter002
647 * @tc.desc: Test SetAVCallStateFilter
648 * @tc.type: FUNC
649 */
650 static HWTEST_F(AVSessionControllerProxyTest, SetAVCallStateFilter002, testing::ext::TestSize.Level0)
651 {
652 SLOGI("SetAVCallStateFilter002, start");
653 AVCallState::AVCallStateMaskType filter;
654 int32_t ret = aVSessionControllerProxy->SetAVCallStateFilter(filter);
655 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
656 SLOGI("SetAVCallStateFilter002, end");
657 }
658
659 /**
660 * @tc.name: SetMetaFilter002
661 * @tc.desc: Test SetMetaFilter
662 * @tc.type: FUNC
663 */
664 static HWTEST_F(AVSessionControllerProxyTest, SetMetaFilter002, testing::ext::TestSize.Level0)
665 {
666 SLOGI("SetMetaFilter002, start");
667 AVMetaData::MetaMaskType filter;
668 int32_t ret = aVSessionControllerProxy->SetMetaFilter(filter);
669 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
670 SLOGI("SetMetaFilter002, end");
671 }
672
673 /**
674 * @tc.name: SetPlaybackFilter002
675 * @tc.desc: Test SetPlaybackFilter
676 * @tc.type: FUNC
677 */
678 static HWTEST_F(AVSessionControllerProxyTest, SetPlaybackFilter002, testing::ext::TestSize.Level0)
679 {
680 SLOGI("SetPlaybackFilter002, start");
681 AVPlaybackState::PlaybackStateMaskType filter;
682 int32_t ret = aVSessionControllerProxy->SetPlaybackFilter(filter);
683 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
684 SLOGI("SetPlaybackFilter002, end");
685 }
686
687 /**
688 * @tc.name: GetAVQueueItems002
689 * @tc.desc: Test GetAVQueueItems
690 * @tc.type: FUNC
691 */
692 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueItems002, testing::ext::TestSize.Level0)
693 {
694 SLOGI("GetAVQueueItems002, start");
695 std::vector<AVQueueItem> items = {};
696 int32_t ret = aVSessionControllerProxy->GetAVQueueItems(items);
697 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
698 SLOGI("GetAVQueueItems002, end");
699 }
700
701 /**
702 * @tc.name: GetAVQueueTitle002
703 * @tc.desc: Test GetAVQueueTitle
704 * @tc.type: FUNC
705 */
706 static HWTEST_F(AVSessionControllerProxyTest, GetAVQueueTitle002, testing::ext::TestSize.Level0)
707 {
708 SLOGI("GetAVQueueTitle002, start");
709 std::string title = "title";
710 int32_t ret = aVSessionControllerProxy->GetAVQueueTitle(title);
711 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
712 SLOGI("GetAVQueueTitle002, end");
713 }
714
715 /**
716 * @tc.name: SkipToQueueItem002
717 * @tc.desc: Test SkipToQueueItem
718 * @tc.type: FUNC
719 */
720 static HWTEST_F(AVSessionControllerProxyTest, SkipToQueueItem002, testing::ext::TestSize.Level0)
721 {
722 SLOGI("SkipToQueueItem002, start");
723 int32_t itemId = 0;
724 int32_t ret = aVSessionControllerProxy->SkipToQueueItem(itemId);
725 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
726 SLOGI("SkipToQueueItem002, end");
727 }
728
729 /**
730 * @tc.name: GetExtras002
731 * @tc.desc: Test GetExtras
732 * @tc.type: FUNC
733 */
734 static HWTEST_F(AVSessionControllerProxyTest, GetExtras002, testing::ext::TestSize.Level0)
735 {
736 SLOGI("GetExtras002, start");
737 OHOS::AAFwk::WantParams extras;
738 int32_t ret = aVSessionControllerProxy->GetExtras(extras);
739 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
740 SLOGI("GetExtras002, end");
741 }
742
743 /**
744 * @tc.name: GetSessionId002
745 * @tc.desc: Test GetSessionId
746 * @tc.type: FUNC
747 */
748 static HWTEST_F(AVSessionControllerProxyTest, GetSessionId002, testing::ext::TestSize.Level0)
749 {
750 SLOGI("GetSessionId002, start");
751 std::string id = aVSessionControllerProxy->GetSessionId();
752 EXPECT_EQ(id, "");
753 SLOGI("GetSessionId002, end");
754 }
755
756 /**
757 * @tc.name: GetRealPlaybackPosition002
758 * @tc.desc: Test GetRealPlaybackPosition
759 * @tc.type: FUNC
760 */
761 static HWTEST_F(AVSessionControllerProxyTest, GetRealPlaybackPosition002, testing::ext::TestSize.Level0)
762 {
763 SLOGI("GetRealPlaybackPosition002, start");
764 int64_t ret = aVSessionControllerProxy->GetRealPlaybackPosition();
765 EXPECT_EQ(ret, 0);
766 SLOGI("GetRealPlaybackPosition002, end");
767 }
768
769 /**
770 * @tc.name: GetLaunchAbilityInner001
771 * @tc.desc: Test GetLaunchAbilityInner
772 * @tc.type: FUNC
773 */
774 static HWTEST_F(AVSessionControllerProxyTest, GetLaunchAbilityInner001, testing::ext::TestSize.Level0)
775 {
776 SLOGI("GetLaunchAbilityInner001, start");
777 OHOS::AbilityRuntime::WantAgent::WantAgent ability;
778 OHOS::AbilityRuntime::WantAgent::WantAgent * abilityPtr = &ability;
779 int64_t ret = aVSessionControllerProxy->GetLaunchAbilityInner(abilityPtr);
780 EXPECT_EQ(ret, ERR_IPC_SEND_REQUEST);
781 SLOGI("GetLaunchAbilityInner001, end");
782 }
783
784 /**
785 * @tc.name: GetLaunchAbilityInner_ServiceNotExist_Test
786 * @tc.desc: Test GetLaunchAbilityInner when abilityPtr equal nullptr
787 * @tc.type: FUNC
788 */
789 static HWTEST_F(AVSessionControllerProxyTest, GetLaunchAbilityInner_ServiceNotExist_Test, testing::ext::TestSize.Level1)
790 {
791 SLOGI("GetLaunchAbilityInner_ServiceNotExist_Test, start");
792 OHOS::AbilityRuntime::WantAgent::WantAgent * abilityPtr = nullptr;
793 int64_t ret = aVSessionControllerProxyEmpty->GetLaunchAbilityInner(abilityPtr);
794 EXPECT_EQ(ret, ERR_SERVICE_NOT_EXIST);
795 SLOGI("GetLaunchAbilityInner_ServiceNotExist_Test, end");
796 }