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