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_descriptor.h"
19 #include "avsession_errors.h"
20 #include "accesstoken_kit.h"
21 #include "token_setproc.h"
22 #include "audio_system_manager.h"
23
24 #define private public
25 #define protected public
26 #include "avsession_service_stub.h"
27 #undef protected
28 #undef private
29
30 using namespace testing::ext;
31 using namespace OHOS::Security::AccessToken;
32 using namespace OHOS::AVSession;
33
34 static uint64_t g_selfTokenId = 0;
35 static std::string g_errLog;
36
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)37 static void MyLogCallback(const LogType type, const LogLevel level,
38 const unsigned int domain, const char *tag, const char *msg)
39 {
40 g_errLog = msg;
41 }
42
43 static HapInfoParams g_info = {
44 .userID = 100,
45 .bundleName = "ohos.permission_test.demo",
46 .instIndex = 0,
47 .appIDDesc = "ohos.permission_test.demo",
48 .isSystemApp = true
49 };
50
51 static HapPolicyParams g_policy = {
52 .apl = APL_NORMAL,
53 .domain = "test.domain",
54 .permList = {
55 {
56 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
57 .bundleName = "ohos.permission_test.demo",
58 .grantMode = 1,
59 .availableLevel = APL_NORMAL,
60 .label = "label",
61 .labelId = 1,
62 .description = "test",
63 .descriptionId = 1
64 }
65 },
66 .permStateList = {
67 {
68 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
69 .isGeneral = true,
70 .resDeviceID = {"local"},
71 .grantStatus = {PermissionState::PERMISSION_GRANTED},
72 .grantFlags = {1}
73 }
74 }
75 };
76
77 class AVSessionServiceStubPermissionTest : public testing::Test {
78 public:
79 static void SetUpTestCase();
80 static void TearDownTestCase();
81 void SetUp() override;
82 void TearDown() override;
83 };
84
SetUpTestCase()85 void AVSessionServiceStubPermissionTest::SetUpTestCase()
86 {
87 g_selfTokenId = OHOS::IPCSkeleton::GetSelfTokenID();
88 AccessTokenKit::AllocHapToken(g_info, g_policy);
89 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
90 SetSelfTokenID(tokenID.tokenIDEx);
91 }
92
TearDownTestCase()93 void AVSessionServiceStubPermissionTest::TearDownTestCase()
94 {
95 SetSelfTokenID(g_selfTokenId);
96 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
97 AccessTokenKit::DeleteToken(tokenId);
98 }
99
SetUp()100 void AVSessionServiceStubPermissionTest::SetUp()
101 {
102 }
103
TearDown()104 void AVSessionServiceStubPermissionTest::TearDown()
105 {
106 }
107
108 class AVSessionServiceStubDemo : public AVSessionServiceStub {
109 public:
CreateSessionInner(const std::string & tag,int32_t type,const OHOS::AppExecFwk::ElementName & elementName)110 OHOS::sptr<IRemoteObject> CreateSessionInner(const std::string &tag, int32_t type,
111 const OHOS::AppExecFwk::ElementName &elementName) override { return nullptr; };
CreateSessionInner(const std::string & tag,int32_t type,const OHOS::AppExecFwk::ElementName & elementName,OHOS::sptr<IRemoteObject> & session)112 int32_t CreateSessionInner(const std::string &tag, int32_t type, const OHOS::AppExecFwk::ElementName &elementName,
113 OHOS::sptr<IRemoteObject> &session) override { return 0; };
GetAllSessionDescriptors(std::vector<AVSessionDescriptor> & descriptors)114 int32_t GetAllSessionDescriptors(std::vector<AVSessionDescriptor> &descriptors) override { return 0; };
GetSessionDescriptorsBySessionId(const std::string & sessionId,AVSessionDescriptor & descriptor)115 int32_t GetSessionDescriptorsBySessionId(const std::string &sessionId,
116 AVSessionDescriptor &descriptor) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetHistoricalSessionDescriptors(int32_t maxSize,std::vector<AVSessionDescriptor> & descriptors)117 int32_t GetHistoricalSessionDescriptors(int32_t maxSize, std::vector<AVSessionDescriptor> &descriptors) override
118 {
119 return 0;
120 };
SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent & keyEvent,const OHOS::AAFwk::Want & wantParam)121 int32_t SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent& keyEvent, const OHOS::AAFwk::Want &wantParam) override
122 {
123 return 0;
124 };
GetHistoricalAVQueueInfos(int32_t maxSize,int32_t maxAppSize,std::vector<AVQueueInfo> & avQueueInfos)125 int32_t GetHistoricalAVQueueInfos(int32_t maxSize, int32_t maxAppSize,
126 std::vector<AVQueueInfo> &avQueueInfos) override { return 0; };
StartAVPlayback(const std::string & bundleName,const std::string & assetId)127 int32_t StartAVPlayback(const std::string &bundleName, const std::string &assetId) override { return 0; };
CreateControllerInner(const std::string & sessionId,OHOS::sptr<IRemoteObject> & object)128 int32_t CreateControllerInner(const std::string &sessionId, OHOS::sptr<IRemoteObject> &object) override
129 {
130 return isSuccess ? AVSESSION_SUCCESS : 0;
131 };
RegisterSessionListener(const OHOS::sptr<ISessionListener> & listener)132 int32_t RegisterSessionListener(const OHOS::sptr<ISessionListener> &listener) override { return 0; };
RegisterSessionListenerForAllUsers(const OHOS::sptr<ISessionListener> & listener)133 int32_t RegisterSessionListenerForAllUsers(const OHOS::sptr<ISessionListener> &listener) override { return 0; };
SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)134 int32_t SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent &keyEvent) override { return 0; };
SendSystemControlCommand(const AVControlCommand & command)135 int32_t SendSystemControlCommand(const AVControlCommand &command) override { return 0; };
RegisterClientDeathObserver(const OHOS::sptr<IClientDeath> & observer)136 int32_t RegisterClientDeathObserver(const OHOS::sptr<IClientDeath> &observer) override { return 0; };
CastAudio(const SessionToken & token,const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> & descriptors)137 int32_t CastAudio(const SessionToken &token,
138 const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> &descriptors) override { return 0; };
CastAudioForAll(const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> & descriptors)139 int32_t CastAudioForAll(const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> &descriptors) override
140 {
141 return 0;
142 };
ProcessCastAudioCommand(const RemoteServiceCommand command,const std::string & input,std::string & output)143 int32_t ProcessCastAudioCommand(const RemoteServiceCommand command, const std::string &input,
144 std::string &output) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
145 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
GetAVCastControllerInner(const std::string & sessionId,OHOS::sptr<IRemoteObject> & object)146 int32_t GetAVCastControllerInner(const std::string &sessionId, OHOS::sptr<IRemoteObject> &object) override
147 {
148 return 0;
149 };
StartCast(const SessionToken & sessionToken,const OutputDeviceInfo & outputDeviceInfo)150 int32_t StartCast(const SessionToken &sessionToken, const OutputDeviceInfo &outputDeviceInfo) override
151 {
152 return 0;
153 };
StopCast(const SessionToken & sessionToken)154 int32_t StopCast(const SessionToken &sessionToken) override { return 0; };
checkEnableCast(bool enable)155 int32_t checkEnableCast(bool enable) override { return 0; };
156 #endif
157
Close()158 int32_t Close() override { return 0; };
159
GetDistributedSessionControllersInner(const DistributedSessionType & sessionType,std::vector<OHOS::sptr<IRemoteObject>> & sessionControllers)160 int32_t GetDistributedSessionControllersInner(const DistributedSessionType& sessionType,
161 std::vector<OHOS::sptr<IRemoteObject>>& sessionControllers) override { return 0; };
162 bool isSuccess = true;
163 };
164
165 /**
166 * @tc.name: OnRemoteRequest001
167 * @tc.desc: Test OnRemoteRequest
168 * @tc.type: FUNC
169 */
170 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest001, TestSize.Level1)
171 {
172 SLOGI("OnRemoteRequest001 begin!");
173 uint32_t code = 0;
174 AVSessionServiceStubDemo avsessionservicestub;
175 OHOS::MessageParcel data;
176 OHOS::MessageParcel reply;
177 OHOS::MessageOption option;
178 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
179 EXPECT_EQ(ret, OHOS::AVSession::AVSESSION_ERROR);
180 SLOGI("OnRemoteRequest001 end!");
181 }
182
183 /**
184 * @tc.name: OnRemoteRequest002
185 * @tc.desc: Test OnRemoteRequest
186 * @tc.type: FUNC
187 */
188 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest002, TestSize.Level1)
189 {
190 SLOGI("OnRemoteRequest002 begin!");
191 uint32_t code = 0;
192 AVSessionServiceStubDemo avsessionservicestub;
193 OHOS::MessageParcel data;
194 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
195 OHOS::MessageParcel reply;
196 OHOS::MessageOption option;
197 OHOS::AAFwk::Want want;
198 OHOS::AppExecFwk::ElementName element;
199 want.SetElement(element);
200 data.WriteParcelable(&want);
201 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
202 EXPECT_EQ(ret, OHOS::ERR_NONE);
203 SLOGI("OnRemoteRequest002 end!");
204 }
205
206 /**
207 * @tc.name: OnRemoteRequest003
208 * @tc.desc: Test OnRemoteRequest
209 * @tc.type: FUNC
210 */
211 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest003, TestSize.Level1)
212 {
213 SLOGI("OnRemoteRequest003 begin!");
214 uint32_t code = 0;
215 AVSessionServiceStubDemo avsessionservicestub;
216 OHOS::MessageParcel data;
217 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
218 OHOS::MessageParcel reply;
219 OHOS::MessageOption option;
220 OHOS::AAFwk::Want want;
221 OHOS::AppExecFwk::ElementName element("", "12345", "12345");
222 want.SetElement(element);
223 data.WriteParcelable(&want);
224 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
225 EXPECT_EQ(ret, OHOS::ERR_NONE);
226 SLOGI("OnRemoteRequest003 end!");
227 }
228
229 /**
230 * @tc.name: OnRemoteRequest004
231 * @tc.desc: Test OnRemoteRequest
232 * @tc.type: FUNC
233 */
234 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest004, TestSize.Level1)
235 {
236 SLOGI("OnRemoteRequest004 begin!");
237 uint32_t code = 0;
238 AVSessionServiceStubDemo avsessionservicestub;
239 OHOS::MessageParcel data;
240 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
241 data.WriteString("test");
242 OHOS::MessageParcel reply;
243 OHOS::MessageOption option;
244 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
245 EXPECT_EQ(ret, OHOS::ERR_NONE);
246 SLOGI("OnRemoteRequest004 end!");
247 }
248
249 /**
250 * @tc.name: OnRemoteRequest005
251 * @tc.desc: Test OnRemoteRequest
252 * @tc.type: FUNC
253 */
254 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest005, TestSize.Level1)
255 {
256 SLOGI("OnRemoteRequest005 begin!");
257 uint32_t code = 0;
258 AVSessionServiceStubDemo avsessionservicestub;
259 avsessionservicestub.isSuccess = false;
260 OHOS::MessageParcel data;
261 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
262 OHOS::MessageParcel reply;
263 OHOS::MessageOption option;
264 OHOS::AAFwk::Want want;
265 OHOS::AppExecFwk::ElementName element("", "12345", "12345");
266 want.SetElement(element);
267 data.WriteParcelable(&want);
268 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
269 EXPECT_EQ(ret, OHOS::ERR_NONE);
270 SLOGI("OnRemoteRequest005 end!");
271 }
272
273 /**
274 * @tc.name: OnRemoteRequest006
275 * @tc.desc: Test OnRemoteRequest
276 * @tc.type: FUNC
277 */
278 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest006, TestSize.Level1)
279 {
280 SLOGI("OnRemoteRequest006 begin!");
281 uint32_t code = 1;
282 AVSessionServiceStubDemo avsessionservicestub;
283 OHOS::MessageParcel data;
284 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
285 data.WriteString("test");
286 OHOS::MessageParcel reply;
287 OHOS::MessageOption option;
288 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
289 EXPECT_EQ(ret, OHOS::ERR_NONE);
290 SLOGI("OnRemoteRequest006 end!");
291 }
292
293 /**
294 * @tc.name: OnRemoteRequest007
295 * @tc.desc: Test OnRemoteRequest
296 * @tc.type: FUNC
297 */
298 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest007, TestSize.Level1)
299 {
300 SLOGI("OnRemoteRequest007 begin!");
301 uint32_t code = 2;
302 AVSessionServiceStubDemo avsessionservicestub;
303 OHOS::MessageParcel data;
304 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
305 data.WriteString("test");
306 OHOS::MessageParcel reply;
307 OHOS::MessageOption option;
308 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
309 EXPECT_EQ(ret, OHOS::ERR_NONE);
310 SLOGI("OnRemoteRequest007 end!");
311 }
312
313 /**
314 * @tc.name: OnRemoteRequest008
315 * @tc.desc: Test OnRemoteRequest
316 * @tc.type: FUNC
317 */
318 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest008, TestSize.Level1)
319 {
320 SLOGI("OnRemoteRequest008 begin!");
321 uint32_t code = 3;
322 AVSessionServiceStubDemo avsessionservicestub;
323 OHOS::MessageParcel data;
324 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
325 data.WriteString("test");
326 OHOS::MessageParcel reply;
327 OHOS::MessageOption option;
328 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
329 EXPECT_EQ(ret, OHOS::ERR_NONE);
330 SLOGI("OnRemoteRequest008 end!");
331 }
332
333 /**
334 * @tc.name: OnRemoteRequest009
335 * @tc.desc: Test OnRemoteRequest
336 * @tc.type: FUNC
337 */
338 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest009, TestSize.Level1)
339 {
340 SLOGI("OnRemoteRequest009 begin!");
341 uint32_t code = 4;
342 AVSessionServiceStubDemo avsessionservicestub;
343 OHOS::MessageParcel data;
344 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
345 data.WriteString("test");
346 OHOS::MessageParcel reply;
347 OHOS::MessageOption option;
348 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
349 EXPECT_EQ(ret, OHOS::ERR_NONE);
350 SLOGI("OnRemoteRequest009 end!");
351 }
352
353 /**
354 * @tc.name: OnRemoteRequest010
355 * @tc.desc: Test OnRemoteRequest
356 * @tc.type: FUNC
357 */
358 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest010, TestSize.Level1)
359 {
360 SLOGI("OnRemoteRequest010 begin!");
361 uint32_t code = 5;
362 AVSessionServiceStubDemo avsessionservicestub;
363 OHOS::MessageParcel data;
364 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
365 data.WriteString("test");
366 OHOS::MessageParcel reply;
367 OHOS::MessageOption option;
368 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
369 EXPECT_EQ(ret, OHOS::ERR_NONE);
370 SLOGI("OnRemoteRequest010 end!");
371 }
372
373 /**
374 * @tc.name: OnRemoteRequest011
375 * @tc.desc: Test OnRemoteRequest
376 * @tc.type: FUNC
377 */
378 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest011, TestSize.Level1)
379 {
380 SLOGI("OnRemoteRequest011 begin!");
381 uint32_t code = 6;
382 AVSessionServiceStubDemo avsessionservicestub;
383 OHOS::MessageParcel data;
384 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
385 data.WriteString("test");
386 OHOS::MessageParcel reply;
387 OHOS::MessageOption option;
388 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
389 EXPECT_EQ(ret, OHOS::ERR_NONE);
390 SLOGI("OnRemoteRequest011 end!");
391 }
392
393 /**
394 * @tc.name: OnRemoteRequest012
395 * @tc.desc: Test OnRemoteRequest
396 * @tc.type: FUNC
397 */
398 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest012, TestSize.Level1)
399 {
400 SLOGI("OnRemoteRequest012 begin!");
401 uint32_t code = 7;
402 AVSessionServiceStubDemo avsessionservicestub;
403 OHOS::MessageParcel data;
404 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
405 data.WriteString("test");
406 OHOS::MessageParcel reply;
407 OHOS::MessageOption option;
408 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
409 EXPECT_EQ(ret, OHOS::ERR_NONE);
410 SLOGI("OnRemoteRequest012 end!");
411 }
412
413 /**
414 * @tc.name: OnRemoteRequest013
415 * @tc.desc: Test OnRemoteRequest
416 * @tc.type: FUNC
417 */
418 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest013, TestSize.Level1)
419 {
420 SLOGI("OnRemoteRequest013 begin!");
421 uint32_t code = 8;
422 AVSessionServiceStubDemo avsessionservicestub;
423 OHOS::MessageParcel data;
424 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
425 data.WriteString("test");
426 OHOS::MessageParcel reply;
427 OHOS::MessageOption option;
428 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
429 EXPECT_EQ(ret, OHOS::ERR_NONE);
430 SLOGI("OnRemoteRequest013 end!");
431 }
432
433 /**
434 * @tc.name: OnRemoteRequest014
435 * @tc.desc: Test OnRemoteRequest
436 * @tc.type: FUNC
437 */
438 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest014, TestSize.Level1)
439 {
440 SLOGI("OnRemoteRequest014 begin!");
441 uint32_t code = 9;
442 AVSessionServiceStubDemo avsessionservicestub;
443 OHOS::MessageParcel data;
444 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
445 data.WriteString("test");
446 OHOS::MessageParcel reply;
447 OHOS::MessageOption option;
448 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
449 EXPECT_EQ(ret, OHOS::ERR_NONE);
450 SLOGI("OnRemoteRequest014 end!");
451 }
452
453 /**
454 * @tc.name: OnRemoteRequest015
455 * @tc.desc: Test OnRemoteRequest
456 * @tc.type: FUNC
457 */
458 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest015, TestSize.Level1)
459 {
460 SLOGI("OnRemoteRequest015 begin!");
461 uint32_t code = 10;
462 AVSessionServiceStubDemo avsessionservicestub;
463 OHOS::MessageParcel data;
464 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
465 data.WriteString("test");
466 OHOS::MessageParcel reply;
467 OHOS::MessageOption option;
468 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
469 EXPECT_EQ(ret, OHOS::ERR_NONE);
470 SLOGI("OnRemoteRequest015 end!");
471 }
472
473 /**
474 * @tc.name: OnRemoteRequest016
475 * @tc.desc: Test OnRemoteRequest
476 * @tc.type: FUNC
477 */
478 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest016, TestSize.Level1)
479 {
480 SLOGI("OnRemoteRequest016 begin!");
481 uint32_t code = 11;
482 AVSessionServiceStubDemo avsessionservicestub;
483 OHOS::MessageParcel data;
484 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
485 data.WriteString("test");
486 OHOS::MessageParcel reply;
487 OHOS::MessageOption option;
488 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
489 EXPECT_EQ(ret, OHOS::ERR_NONE);
490 SLOGI("OnRemoteRequest016 end!");
491 }
492
493 /**
494 * @tc.name: OnRemoteRequest017
495 * @tc.desc: Test OnRemoteRequest
496 * @tc.type: FUNC
497 */
498 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest017, TestSize.Level1)
499 {
500 SLOGI("OnRemoteRequest017 begin!");
501 uint32_t code = 12;
502 AVSessionServiceStubDemo avsessionservicestub;
503 OHOS::MessageParcel data;
504 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
505 data.WriteString("test");
506 OHOS::MessageParcel reply;
507 OHOS::MessageOption option;
508 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
509 EXPECT_EQ(ret, OHOS::ERR_NONE);
510 SLOGI("OnRemoteRequest017 end!");
511 }
512
513 /**
514 * @tc.name: OnRemoteRequest018
515 * @tc.desc: Test OnRemoteRequest
516 * @tc.type: FUNC
517 */
518 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest018, TestSize.Level1)
519 {
520 SLOGI("OnRemoteRequest018 begin!");
521 uint32_t code = 13;
522 AVSessionServiceStubDemo avsessionservicestub;
523 OHOS::MessageParcel data;
524 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
525 data.WriteString("test");
526 OHOS::MessageParcel reply;
527 OHOS::MessageOption option;
528 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
529 EXPECT_EQ(ret, OHOS::ERR_NONE);
530 SLOGI("OnRemoteRequest018 end!");
531 }
532
533 /**
534 * @tc.name: OnRemoteRequest019
535 * @tc.desc: Test OnRemoteRequest
536 * @tc.type: FUNC
537 */
538 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest019, TestSize.Level1)
539 {
540 SLOGI("OnRemoteRequest019 begin!");
541 uint32_t code = 14;
542 AVSessionServiceStubDemo avsessionservicestub;
543 OHOS::MessageParcel data;
544 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
545 data.WriteString("test");
546 OHOS::MessageParcel reply;
547 OHOS::MessageOption option;
548 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
549 EXPECT_EQ(ret, OHOS::ERR_NONE);
550 SLOGI("OnRemoteRequest019 end!");
551 }
552
553 /**
554 * @tc.name: OnRemoteRequest020
555 * @tc.desc: Test OnRemoteRequest
556 * @tc.type: FUNC
557 */
558 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest020, TestSize.Level1)
559 {
560 SLOGI("OnRemoteRequest020 begin!");
561 uint32_t code = 15;
562 AVSessionServiceStubDemo avsessionservicestub;
563 OHOS::MessageParcel data;
564 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
565 data.WriteString("test");
566 OHOS::MessageParcel reply;
567 OHOS::MessageOption option;
568 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
569 EXPECT_EQ(ret, OHOS::ERR_NONE);
570 SLOGI("OnRemoteRequest020 end!");
571 }
572
573 /**
574 * @tc.name: OnRemoteRequest021
575 * @tc.desc: Test OnRemoteRequest
576 * @tc.type: FUNC
577 */
578 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest021, TestSize.Level1)
579 {
580 SLOGI("OnRemoteRequest021 begin!");
581 uint32_t code = 16;
582 AVSessionServiceStubDemo avsessionservicestub;
583 OHOS::MessageParcel data;
584 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
585 data.WriteString("test");
586 OHOS::MessageParcel reply;
587 OHOS::MessageOption option;
588 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
589 EXPECT_EQ(ret, OHOS::ERR_NONE);
590 SLOGI("OnRemoteRequest021 end!");
591 }
592
593 #ifndef CASTPLUS_CAST_ENGINE_ENABLE
594 /**
595 * @tc.name: OnRemoteRequest022
596 * @tc.desc: Test OnRemoteRequest
597 * @tc.type: FUNC
598 */
599 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest022, TestSize.Level1)
600 {
601 SLOGI("OnRemoteRequest022 begin!");
602 uint32_t code = 17;
603 AVSessionServiceStubDemo avsessionservicestub;
604 OHOS::MessageParcel data;
605 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
606 data.WriteString("test");
607 OHOS::MessageParcel reply;
608 OHOS::MessageOption option;
609 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
610 EXPECT_EQ(ret, OHOS::ERR_NONE);
611 SLOGI("OnRemoteRequest022 end!");
612 }
613
614 /**
615 * @tc.name: OnRemoteRequest023
616 * @tc.desc: Test OnRemoteRequest
617 * @tc.type: FUNC
618 */
619 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest023, TestSize.Level1)
620 {
621 SLOGI("OnRemoteRequest023 begin!");
622 uint32_t code = 18;
623 AVSessionServiceStubDemo avsessionservicestub;
624 OHOS::MessageParcel data;
625 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
626 data.WriteString("test");
627 OHOS::MessageParcel reply;
628 OHOS::MessageOption option;
629 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
630 EXPECT_EQ(ret, OHOS::ERR_NONE);
631 SLOGI("OnRemoteRequest023 end!");
632 }
633
634 /**
635 * @tc.name: OnRemoteRequest024
636 * @tc.desc: Test OnRemoteRequest
637 * @tc.type: FUNC
638 */
639 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest024, TestSize.Level1)
640 {
641 SLOGI("OnRemoteRequest024 begin!");
642 uint32_t code = 19;
643 AVSessionServiceStubDemo avsessionservicestub;
644 OHOS::MessageParcel data;
645 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
646 data.WriteString("test");
647 OHOS::MessageParcel reply;
648 OHOS::MessageOption option;
649 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
650 EXPECT_EQ(ret, OHOS::ERR_NONE);
651 SLOGI("OnRemoteRequest024 end!");
652 }
653 #endif
654
655 /**
656 * @tc.name: OnRemoteRequest025
657 * @tc.desc: Test OnRemoteRequest
658 * @tc.type: FUNC
659 */
660 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest025, TestSize.Level1)
661 {
662 SLOGI("OnRemoteRequest025 begin!");
663 uint32_t code = 20;
664 AVSessionServiceStubDemo avsessionservicestub;
665 OHOS::MessageParcel data;
666 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
667 data.WriteString("test");
668 OHOS::MessageParcel reply;
669 OHOS::MessageOption option;
670 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
671 EXPECT_EQ(ret, OHOS::ERR_NONE);
672 SLOGI("OnRemoteRequest025 end!");
673 }
674
675 /**
676 * @tc.name: OnRemoteRequest026
677 * @tc.desc: Test OnRemoteRequest
678 * @tc.type: FUNC
679 */
680 static HWTEST_F(AVSessionServiceStubPermissionTest, OnRemoteRequest026, TestSize.Level1)
681 {
682 SLOGI("OnRemoteRequest026 begin!");
683 uint32_t code = 25;
684 AVSessionServiceStubDemo avsessionservicestub;
685 OHOS::MessageParcel data;
686 data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
687 data.WriteString("test");
688 OHOS::MessageParcel reply;
689 OHOS::MessageOption option;
690 int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
691 EXPECT_EQ(ret, OHOS::IPC_STUB_UNKNOW_TRANS_ERR);
692 SLOGI("OnRemoteRequest026 end!");
693 }
694
695 /**
696 * @tc.name: HandleStartDeviceLogging001
697 * @tc.desc: Test HandleStartDeviceLogging
698 * @tc.type: FUNC
699 */
700 static HWTEST_F(AVSessionServiceStubPermissionTest, HandleStartDeviceLogging001, TestSize.Level1)
701 {
702 SLOGI("HandleStartDeviceLogging001 begin!");
703 AVSessionServiceStubDemo avsessionservicestub;
704 OHOS::MessageParcel data;
705 OHOS::MessageParcel reply;
706 int ret = avsessionservicestub.HandleStartDeviceLogging(data, reply);
707 EXPECT_EQ(ret, OHOS::ERR_NONE);
708
709 ret = avsessionservicestub.HandleStopDeviceLogging(data, reply);
710 EXPECT_EQ(ret, OHOS::ERR_NONE);
711 SLOGI("HandleStartDeviceLogging001 end!");
712 }
713
714 /**
715 * @tc.name: MarshallingAVQueueInfos001
716 * @tc.desc: Test MarshallingAVQueueInfos
717 * @tc.type: FUNC
718 */
719 static HWTEST_F(AVSessionServiceStubPermissionTest, MarshallingAVQueueInfos001, TestSize.Level1)
720 {
721 SLOGI("MarshallingAVQueueInfos001 begin!");
722 LOG_SetCallback(MyLogCallback);
723 AVSessionServiceStubDemo avsessionservicestub;
724 OHOS::MessageParcel reply;
725 AVQueueInfo aVQueueInfo;
726 std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
727 avsessionservicestub.MarshallingAVQueueInfos(reply, avQueueInfos);
728 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
729 SLOGI("MarshallingAVQueueInfos001 end!");
730 }
731
732 /**
733 * @tc.name: GetAVQueueInfosImgLength002
734 * @tc.desc: Test GetAVQueueInfosImgLength
735 * @tc.type: FUNC
736 */
737 static HWTEST_F(AVSessionServiceStubPermissionTest, GetAVQueueInfosImgLength002, TestSize.Level1)
738 {
739 SLOGI("GetAVQueueInfosImgLength002 begin!");
740 AVSessionServiceStubDemo avsessionservicestub;
741 AVQueueInfo aVQueueInfo;
742 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
743 std::vector<uint8_t> imgBuffer = {1, 2, 3};
744 mediaPixelMap->SetInnerImgBuffer(imgBuffer);
745 aVQueueInfo.SetAVQueueImage(mediaPixelMap);
746 std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
747 int ret = avsessionservicestub.GetAVQueueInfosImgLength(avQueueInfos);
748 EXPECT_EQ(ret, 3);
749 SLOGI("GetAVQueueInfosImgLength002 end!");
750 }
751
752 /**
753 * @tc.name: AVQueueInfoImgToBuffer001
754 * @tc.desc: Test AVQueueInfoImgToBuffer
755 * @tc.type: FUNC
756 */
757 static HWTEST_F(AVSessionServiceStubPermissionTest, AVQueueInfoImgToBuffer001, TestSize.Level1)
758 {
759 SLOGI("AVQueueInfoImgToBuffer001 begin!");
760 LOG_SetCallback(MyLogCallback);
761 AVSessionServiceStubDemo avsessionservicestub;
762 AVQueueInfo aVQueueInfo;
763 std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
764 unsigned char *buffer = new unsigned char[255];
765 avsessionservicestub.AVQueueInfoImgToBuffer(avQueueInfos, buffer);
766 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
767 SLOGI("AVQueueInfoImgToBuffer001 end!");
768 }
769
770 /**
771 * @tc.name: AVQueueInfoImgToBuffer002
772 * @tc.desc: Test AVQueueInfoImgToBuffer
773 * @tc.type: FUNC
774 */
775 static HWTEST_F(AVSessionServiceStubPermissionTest, AVQueueInfoImgToBuffer002, TestSize.Level1)
776 {
777 SLOGI("AVQueueInfoImgToBuffer002 begin!");
778 LOG_SetCallback(MyLogCallback);
779 AVSessionServiceStubDemo avsessionservicestub;
780 AVQueueInfo aVQueueInfo;
781 std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
782 std::vector<uint8_t> imgBuffer = {1, 2, 3};
783 mediaPixelMap->SetInnerImgBuffer(imgBuffer);
784 aVQueueInfo.SetAVQueueImage(mediaPixelMap);
785 std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
786 unsigned char *buffer = new unsigned char[255];
787 avsessionservicestub.AVQueueInfoImgToBuffer(avQueueInfos, buffer);
788 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
789 SLOGI("AVQueueInfoImgToBuffer002 end!");
790 }
791
792 /**
793 * @tc.name: HandleClose001
794 * @tc.desc: Test HandleClose
795 * @tc.type: FUNC
796 */
797 static HWTEST_F(AVSessionServiceStubPermissionTest, HandleClose001, TestSize.Level1)
798 {
799 SLOGI("HandleClose001 begin!");
800 AVSessionServiceStubDemo avsessionservicestub;
801 OHOS::MessageParcel data;
802 OHOS::MessageParcel reply;
803 int ret = avsessionservicestub.HandleClose(data, reply);
804 EXPECT_EQ(ret, OHOS::ERR_NONE);
805 SLOGI("HandleClose001 end!");
806 }