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