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 HapInfoParams g_info = {
36     .userID = 100,
37     .bundleName = "ohos.permission_test.demo",
38     .instIndex = 0,
39     .appIDDesc = "ohos.permission_test.demo",
40     .isSystemApp = true
41 };
42 
43 static HapPolicyParams g_policy = {
44     .apl = APL_NORMAL,
45     .domain = "test.domain",
46     .permList = {
47         {
48             .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
49             .bundleName = "ohos.permission_test.demo",
50             .grantMode = 1,
51             .availableLevel = APL_NORMAL,
52             .label = "label",
53             .labelId = 1,
54             .description = "test",
55             .descriptionId = 1
56         }
57     },
58     .permStateList = {
59         {
60             .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
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 AVSessionServiceStubDemo : 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; };
GetAllSessionDescriptors(std::vector<AVSessionDescriptor> & descriptors)106     int32_t GetAllSessionDescriptors(std::vector<AVSessionDescriptor> &descriptors) override { return 0; };
GetSessionDescriptorsBySessionId(const std::string & sessionId,AVSessionDescriptor & descriptor)107     int32_t GetSessionDescriptorsBySessionId(const std::string &sessionId,
108         AVSessionDescriptor &descriptor) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetHistoricalSessionDescriptors(int32_t maxSize,std::vector<AVSessionDescriptor> & descriptors)109     int32_t GetHistoricalSessionDescriptors(int32_t maxSize, std::vector<AVSessionDescriptor> &descriptors) override
110     {
111         return 0;
112     };
GetHistoricalAVQueueInfos(int32_t maxSize,int32_t maxAppSize,std::vector<AVQueueInfo> & avQueueInfos)113     int32_t GetHistoricalAVQueueInfos(int32_t maxSize, int32_t maxAppSize,
114         std::vector<AVQueueInfo> &avQueueInfos) override { return 0; };
StartAVPlayback(const std::string & bundleName,const std::string & assetId)115     int32_t StartAVPlayback(const std::string &bundleName, const std::string &assetId) override { return 0; };
CreateControllerInner(const std::string & sessionId,OHOS::sptr<IRemoteObject> & object)116     int32_t CreateControllerInner(const std::string &sessionId, OHOS::sptr<IRemoteObject> &object) override
117     {
118         return isSuccess ? AVSESSION_SUCCESS : 0;
119     };
RegisterSessionListener(const OHOS::sptr<ISessionListener> & listener)120     int32_t RegisterSessionListener(const OHOS::sptr<ISessionListener> &listener) override { return 0; };
RegisterSessionListenerForAllUsers(const OHOS::sptr<ISessionListener> & listener)121     int32_t RegisterSessionListenerForAllUsers(const OHOS::sptr<ISessionListener> &listener) override { return 0; };
SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)122     int32_t SendSystemAVKeyEvent(const OHOS::MMI::KeyEvent &keyEvent) override { return 0; };
SendSystemControlCommand(const AVControlCommand & command)123     int32_t SendSystemControlCommand(const AVControlCommand &command) override { return 0; };
RegisterClientDeathObserver(const OHOS::sptr<IClientDeath> & observer)124     int32_t RegisterClientDeathObserver(const OHOS::sptr<IClientDeath> &observer) override { return 0; };
CastAudio(const SessionToken & token,const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> & descriptors)125     int32_t CastAudio(const SessionToken &token,
126         const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> &descriptors) override { return 0; };
CastAudioForAll(const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> & descriptors)127     int32_t CastAudioForAll(const std::vector<OHOS::AudioStandard::AudioDeviceDescriptor> &descriptors) override
128     {
129         return 0;
130     };
ProcessCastAudioCommand(const RemoteServiceCommand command,const std::string & input,std::string & output)131     int32_t ProcessCastAudioCommand(const RemoteServiceCommand command, const std::string &input,
132                                     std::string &output) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
133 #ifdef CASTPLUS_CAST_ENGINE_ENABLE
GetAVCastControllerInner(const std::string & sessionId,OHOS::sptr<IRemoteObject> & object)134     int32_t GetAVCastControllerInner(const std::string &sessionId, OHOS::sptr<IRemoteObject> &object) override
135     {
136         return 0;
137     };
StartCast(const SessionToken & sessionToken,const OutputDeviceInfo & outputDeviceInfo)138     int32_t StartCast(const SessionToken &sessionToken, const OutputDeviceInfo &outputDeviceInfo) override
139     {
140         return 0;
141     };
StopCast(const SessionToken & sessionToken)142     int32_t StopCast(const SessionToken &sessionToken) override { return 0; };
checkEnableCast(bool enable)143     int32_t checkEnableCast(bool enable) override { return 0; };
144 #endif
145 
Close()146     int32_t Close() override { return 0; };
147     bool isSuccess = true;
148 };
149 
150 /**
151  * @tc.name: OnRemoteRequest001
152  * @tc.desc: Test OnRemoteRequest
153  * @tc.type: FUNC
154  */
155 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest001, TestSize.Level1)
156 {
157     SLOGI("OnRemoteRequest001 begin!");
158     uint32_t code = 0;
159     AVSessionServiceStubDemo avsessionservicestub;
160     OHOS::MessageParcel data;
161     OHOS::MessageParcel reply;
162     OHOS::MessageOption option;
163     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
164     EXPECT_EQ(ret, OHOS::AVSession::AVSESSION_ERROR);
165     SLOGI("OnRemoteRequest001 end!");
166 }
167 
168 /**
169  * @tc.name: OnRemoteRequest002
170  * @tc.desc: Test OnRemoteRequest
171  * @tc.type: FUNC
172  */
173 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest002, TestSize.Level1)
174 {
175     SLOGI("OnRemoteRequest002 begin!");
176     uint32_t code = 0;
177     AVSessionServiceStubDemo avsessionservicestub;
178     OHOS::MessageParcel data;
179     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
180     OHOS::MessageParcel reply;
181     OHOS::MessageOption option;
182     OHOS::AAFwk::Want want;
183     OHOS::AppExecFwk::ElementName element;
184     want.SetElement(element);
185     data.WriteParcelable(&want);
186     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
187     EXPECT_EQ(ret, OHOS::ERR_NONE);
188     SLOGI("OnRemoteRequest002 end!");
189 }
190 
191 /**
192  * @tc.name: OnRemoteRequest003
193  * @tc.desc: Test OnRemoteRequest
194  * @tc.type: FUNC
195  */
196 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest003, TestSize.Level1)
197 {
198     SLOGI("OnRemoteRequest003 begin!");
199     uint32_t code = 0;
200     AVSessionServiceStubDemo avsessionservicestub;
201     OHOS::MessageParcel data;
202     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
203     OHOS::MessageParcel reply;
204     OHOS::MessageOption option;
205     OHOS::AAFwk::Want want;
206     OHOS::AppExecFwk::ElementName element("", "12345", "12345");
207     want.SetElement(element);
208     data.WriteParcelable(&want);
209     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
210     EXPECT_EQ(ret, OHOS::ERR_NONE);
211     SLOGI("OnRemoteRequest003 end!");
212 }
213 
214 /**
215  * @tc.name: OnRemoteRequest004
216  * @tc.desc: Test OnRemoteRequest
217  * @tc.type: FUNC
218  */
219 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest004, TestSize.Level1)
220 {
221     SLOGI("OnRemoteRequest004 begin!");
222     uint32_t code = 0;
223     AVSessionServiceStubDemo avsessionservicestub;
224     OHOS::MessageParcel data;
225     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
226     data.WriteString("test");
227     OHOS::MessageParcel reply;
228     OHOS::MessageOption option;
229     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
230     EXPECT_EQ(ret, OHOS::ERR_NONE);
231     SLOGI("OnRemoteRequest004 end!");
232 }
233 
234 /**
235  * @tc.name: OnRemoteRequest005
236  * @tc.desc: Test OnRemoteRequest
237  * @tc.type: FUNC
238  */
239 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest005, TestSize.Level1)
240 {
241     SLOGI("OnRemoteRequest005 begin!");
242     uint32_t code = 0;
243     AVSessionServiceStubDemo avsessionservicestub;
244     avsessionservicestub.isSuccess = false;
245     OHOS::MessageParcel data;
246     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
247     OHOS::MessageParcel reply;
248     OHOS::MessageOption option;
249     OHOS::AAFwk::Want want;
250     OHOS::AppExecFwk::ElementName element("", "12345", "12345");
251     want.SetElement(element);
252     data.WriteParcelable(&want);
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.Level1)
264 {
265     SLOGI("OnRemoteRequest006 begin!");
266     uint32_t code = 1;
267     AVSessionServiceStubDemo 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.Level1)
284 {
285     SLOGI("OnRemoteRequest007 begin!");
286     uint32_t code = 2;
287     AVSessionServiceStubDemo 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.Level1)
304 {
305     SLOGI("OnRemoteRequest008 begin!");
306     uint32_t code = 3;
307     AVSessionServiceStubDemo 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.Level1)
324 {
325     SLOGI("OnRemoteRequest009 begin!");
326     uint32_t code = 4;
327     AVSessionServiceStubDemo 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.Level1)
344 {
345     SLOGI("OnRemoteRequest010 begin!");
346     uint32_t code = 5;
347     AVSessionServiceStubDemo 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.Level1)
364 {
365     SLOGI("OnRemoteRequest011 begin!");
366     uint32_t code = 6;
367     AVSessionServiceStubDemo 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.Level1)
384 {
385     SLOGI("OnRemoteRequest012 begin!");
386     uint32_t code = 7;
387     AVSessionServiceStubDemo avsessionservicestub;
388     OHOS::MessageParcel data;
389     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
390     data.WriteString("test");
391     OHOS::MessageParcel reply;
392     OHOS::MessageOption option;
393     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
394     EXPECT_EQ(ret, OHOS::ERR_NONE);
395     SLOGI("OnRemoteRequest012 end!");
396 }
397 
398 /**
399  * @tc.name: OnRemoteRequest013
400  * @tc.desc: Test OnRemoteRequest
401  * @tc.type: FUNC
402  */
403 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest013, TestSize.Level1)
404 {
405     SLOGI("OnRemoteRequest013 begin!");
406     uint32_t code = 8;
407     AVSessionServiceStubDemo avsessionservicestub;
408     OHOS::MessageParcel data;
409     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
410     data.WriteString("test");
411     OHOS::MessageParcel reply;
412     OHOS::MessageOption option;
413     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
414     EXPECT_EQ(ret, OHOS::ERR_NONE);
415     SLOGI("OnRemoteRequest013 end!");
416 }
417 
418 /**
419  * @tc.name: OnRemoteRequest014
420  * @tc.desc: Test OnRemoteRequest
421  * @tc.type: FUNC
422  */
423 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest014, TestSize.Level1)
424 {
425     SLOGI("OnRemoteRequest014 begin!");
426     uint32_t code = 9;
427     AVSessionServiceStubDemo avsessionservicestub;
428     OHOS::MessageParcel data;
429     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
430     data.WriteString("test");
431     OHOS::MessageParcel reply;
432     OHOS::MessageOption option;
433     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
434     EXPECT_EQ(ret, OHOS::ERR_NONE);
435     SLOGI("OnRemoteRequest014 end!");
436 }
437 
438 /**
439  * @tc.name: OnRemoteRequest015
440  * @tc.desc: Test OnRemoteRequest
441  * @tc.type: FUNC
442  */
443 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest015, TestSize.Level1)
444 {
445     SLOGI("OnRemoteRequest015 begin!");
446     uint32_t code = 10;
447     AVSessionServiceStubDemo avsessionservicestub;
448     OHOS::MessageParcel data;
449     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
450     data.WriteString("test");
451     OHOS::MessageParcel reply;
452     OHOS::MessageOption option;
453     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
454     EXPECT_EQ(ret, OHOS::ERR_NONE);
455     SLOGI("OnRemoteRequest015 end!");
456 }
457 
458 /**
459  * @tc.name: OnRemoteRequest016
460  * @tc.desc: Test OnRemoteRequest
461  * @tc.type: FUNC
462  */
463 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest016, TestSize.Level1)
464 {
465     SLOGI("OnRemoteRequest016 begin!");
466     uint32_t code = 11;
467     AVSessionServiceStubDemo avsessionservicestub;
468     OHOS::MessageParcel data;
469     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
470     data.WriteString("test");
471     OHOS::MessageParcel reply;
472     OHOS::MessageOption option;
473     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
474     EXPECT_EQ(ret, OHOS::ERR_NONE);
475     SLOGI("OnRemoteRequest016 end!");
476 }
477 
478 /**
479  * @tc.name: OnRemoteRequest017
480  * @tc.desc: Test OnRemoteRequest
481  * @tc.type: FUNC
482  */
483 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest017, TestSize.Level1)
484 {
485     SLOGI("OnRemoteRequest017 begin!");
486     uint32_t code = 12;
487     AVSessionServiceStubDemo avsessionservicestub;
488     OHOS::MessageParcel data;
489     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
490     data.WriteString("test");
491     OHOS::MessageParcel reply;
492     OHOS::MessageOption option;
493     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
494     EXPECT_EQ(ret, OHOS::ERR_NONE);
495     SLOGI("OnRemoteRequest017 end!");
496 }
497 
498 /**
499  * @tc.name: OnRemoteRequest018
500  * @tc.desc: Test OnRemoteRequest
501  * @tc.type: FUNC
502  */
503 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest018, TestSize.Level1)
504 {
505     SLOGI("OnRemoteRequest018 begin!");
506     uint32_t code = 13;
507     AVSessionServiceStubDemo avsessionservicestub;
508     OHOS::MessageParcel data;
509     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
510     data.WriteString("test");
511     OHOS::MessageParcel reply;
512     OHOS::MessageOption option;
513     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
514     EXPECT_EQ(ret, OHOS::ERR_NONE);
515     SLOGI("OnRemoteRequest018 end!");
516 }
517 
518 /**
519  * @tc.name: OnRemoteRequest019
520  * @tc.desc: Test OnRemoteRequest
521  * @tc.type: FUNC
522  */
523 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest019, TestSize.Level1)
524 {
525     SLOGI("OnRemoteRequest019 begin!");
526     uint32_t code = 14;
527     AVSessionServiceStubDemo avsessionservicestub;
528     OHOS::MessageParcel data;
529     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
530     data.WriteString("test");
531     OHOS::MessageParcel reply;
532     OHOS::MessageOption option;
533     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
534     EXPECT_EQ(ret, OHOS::ERR_NONE);
535     SLOGI("OnRemoteRequest019 end!");
536 }
537 
538 /**
539  * @tc.name: OnRemoteRequest020
540  * @tc.desc: Test OnRemoteRequest
541  * @tc.type: FUNC
542  */
543 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest020, TestSize.Level1)
544 {
545     SLOGI("OnRemoteRequest020 begin!");
546     uint32_t code = 15;
547     AVSessionServiceStubDemo avsessionservicestub;
548     OHOS::MessageParcel data;
549     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
550     data.WriteString("test");
551     OHOS::MessageParcel reply;
552     OHOS::MessageOption option;
553     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
554     EXPECT_EQ(ret, OHOS::ERR_NONE);
555     SLOGI("OnRemoteRequest020 end!");
556 }
557 
558 /**
559  * @tc.name: OnRemoteRequest021
560  * @tc.desc: Test OnRemoteRequest
561  * @tc.type: FUNC
562  */
563 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest021, TestSize.Level1)
564 {
565     SLOGI("OnRemoteRequest021 begin!");
566     uint32_t code = 16;
567     AVSessionServiceStubDemo avsessionservicestub;
568     OHOS::MessageParcel data;
569     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
570     data.WriteString("test");
571     OHOS::MessageParcel reply;
572     OHOS::MessageOption option;
573     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
574     EXPECT_EQ(ret, OHOS::ERR_NONE);
575     SLOGI("OnRemoteRequest021 end!");
576 }
577 
578 /**
579  * @tc.name: OnRemoteRequest022
580  * @tc.desc: Test OnRemoteRequest
581  * @tc.type: FUNC
582  */
583 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest022, TestSize.Level1)
584 {
585     SLOGI("OnRemoteRequest022 begin!");
586     uint32_t code = 17;
587     AVSessionServiceStubDemo avsessionservicestub;
588     OHOS::MessageParcel data;
589     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
590     data.WriteString("test");
591     OHOS::MessageParcel reply;
592     OHOS::MessageOption option;
593     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
594     EXPECT_EQ(ret, OHOS::ERR_NONE);
595     SLOGI("OnRemoteRequest022 end!");
596 }
597 
598 /**
599  * @tc.name: OnRemoteRequest023
600  * @tc.desc: Test OnRemoteRequest
601  * @tc.type: FUNC
602  */
603 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest023, TestSize.Level1)
604 {
605     SLOGI("OnRemoteRequest023 begin!");
606     uint32_t code = 18;
607     AVSessionServiceStubDemo avsessionservicestub;
608     OHOS::MessageParcel data;
609     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
610     data.WriteString("test");
611     OHOS::MessageParcel reply;
612     OHOS::MessageOption option;
613     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
614     EXPECT_EQ(ret, OHOS::ERR_NONE);
615     SLOGI("OnRemoteRequest023 end!");
616 }
617 
618 /**
619  * @tc.name: OnRemoteRequest024
620  * @tc.desc: Test OnRemoteRequest
621  * @tc.type: FUNC
622  */
623 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest024, TestSize.Level1)
624 {
625     SLOGI("OnRemoteRequest024 begin!");
626     uint32_t code = 19;
627     AVSessionServiceStubDemo avsessionservicestub;
628     OHOS::MessageParcel data;
629     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
630     data.WriteString("test");
631     OHOS::MessageParcel reply;
632     OHOS::MessageOption option;
633     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
634     EXPECT_EQ(ret, OHOS::ERR_NONE);
635     SLOGI("OnRemoteRequest024 end!");
636 }
637 
638 /**
639  * @tc.name: OnRemoteRequest025
640  * @tc.desc: Test OnRemoteRequest
641  * @tc.type: FUNC
642  */
643 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest025, TestSize.Level1)
644 {
645     SLOGI("OnRemoteRequest025 begin!");
646     uint32_t code = 20;
647     AVSessionServiceStubDemo avsessionservicestub;
648     OHOS::MessageParcel data;
649     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
650     data.WriteString("test");
651     OHOS::MessageParcel reply;
652     OHOS::MessageOption option;
653     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
654     EXPECT_EQ(ret, OHOS::ERR_NONE);
655     SLOGI("OnRemoteRequest025 end!");
656 }
657 
658 /**
659  * @tc.name: OnRemoteRequest026
660  * @tc.desc: Test OnRemoteRequest
661  * @tc.type: FUNC
662  */
663 static HWTEST_F(AVSessionServiceStubTest, OnRemoteRequest026, TestSize.Level1)
664 {
665     SLOGI("OnRemoteRequest026 begin!");
666     uint32_t code = 25;
667     AVSessionServiceStubDemo avsessionservicestub;
668     OHOS::MessageParcel data;
669     data.WriteInterfaceToken(IAVSessionService::GetDescriptor());
670     data.WriteString("test");
671     OHOS::MessageParcel reply;
672     OHOS::MessageOption option;
673     int ret = avsessionservicestub.OnRemoteRequest(code, data, reply, option);
674     EXPECT_EQ(ret, 305);
675     SLOGI("OnRemoteRequest026 end!");
676 }
677 
678 /**
679  * @tc.name: MarshallingAVQueueInfos001
680  * @tc.desc: Test MarshallingAVQueueInfos
681  * @tc.type: FUNC
682  */
683 static HWTEST_F(AVSessionServiceStubTest, MarshallingAVQueueInfos001, TestSize.Level1)
684 {
685     SLOGI("MarshallingAVQueueInfos001 begin!");
686     AVSessionServiceStubDemo avsessionservicestub;
687     OHOS::MessageParcel reply;
688     AVQueueInfo aVQueueInfo;
689     std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
690     avsessionservicestub.MarshallingAVQueueInfos(reply, avQueueInfos);
691     SLOGI("MarshallingAVQueueInfos001 end!");
692 }
693 
694 /**
695  * @tc.name: GetAVQueueInfosImgLength002
696  * @tc.desc: Test GetAVQueueInfosImgLength
697  * @tc.type: FUNC
698  */
699 static HWTEST_F(AVSessionServiceStubTest, GetAVQueueInfosImgLength002, TestSize.Level1)
700 {
701     SLOGI("GetAVQueueInfosImgLength002 begin!");
702     AVSessionServiceStubDemo avsessionservicestub;
703     AVQueueInfo aVQueueInfo;
704     std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
705     std::vector<uint8_t> imgBuffer = {1, 2, 3};
706     mediaPixelMap->SetInnerImgBuffer(imgBuffer);
707     aVQueueInfo.SetAVQueueImage(mediaPixelMap);
708     std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
709     int ret = avsessionservicestub.GetAVQueueInfosImgLength(avQueueInfos);
710     EXPECT_EQ(ret, 3);
711     SLOGI("GetAVQueueInfosImgLength002 end!");
712 }
713 
714 /**
715  * @tc.name: AVQueueInfoImgToBuffer001
716  * @tc.desc: Test AVQueueInfoImgToBuffer
717  * @tc.type: FUNC
718  */
719 static HWTEST_F(AVSessionServiceStubTest, AVQueueInfoImgToBuffer001, TestSize.Level1)
720 {
721     SLOGI("AVQueueInfoImgToBuffer001 begin!");
722     AVSessionServiceStubDemo avsessionservicestub;
723     AVQueueInfo aVQueueInfo;
724     std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
725     unsigned char *buffer = new unsigned char[255];
726     avsessionservicestub.AVQueueInfoImgToBuffer(avQueueInfos, buffer);
727     SLOGI("AVQueueInfoImgToBuffer001 end!");
728 }
729 
730 /**
731  * @tc.name: AVQueueInfoImgToBuffer002
732  * @tc.desc: Test AVQueueInfoImgToBuffer
733  * @tc.type: FUNC
734  */
735 static HWTEST_F(AVSessionServiceStubTest, AVQueueInfoImgToBuffer002, TestSize.Level1)
736 {
737     SLOGI("AVQueueInfoImgToBuffer002 begin!");
738     AVSessionServiceStubDemo avsessionservicestub;
739     AVQueueInfo aVQueueInfo;
740     std::shared_ptr<AVSessionPixelMap> mediaPixelMap = std::make_shared<AVSessionPixelMap>();
741     std::vector<uint8_t> imgBuffer = {1, 2, 3};
742     mediaPixelMap->SetInnerImgBuffer(imgBuffer);
743     aVQueueInfo.SetAVQueueImage(mediaPixelMap);
744     std::vector<AVQueueInfo> avQueueInfos = {aVQueueInfo};
745     unsigned char *buffer = new unsigned char[255];
746     avsessionservicestub.AVQueueInfoImgToBuffer(avQueueInfos, buffer);
747     SLOGI("AVQueueInfoImgToBuffer002 end!");
748 }