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 "avsession_pixel_map.h"
23 #include "avsession_pixel_map_adapter.h"
24
25 #define private public
26 #define protected public
27 #include "avsession_controller_stub.h"
28 #undef protected
29 #undef private
30
31 using namespace testing::ext;
32 using namespace OHOS::Security::AccessToken;
33 using namespace OHOS::AVSession;
34 using namespace OHOS::Media;
35 static uint64_t g_selfTokenId = 0;
36 static std::string g_errLog;
37
MyLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)38 static void MyLogCallback(const LogType type, const LogLevel level,
39 const unsigned int domain, const char *tag, const char *msg)
40 {
41 if (msg != nullptr) {
42 g_errLog.assign(g_errLog, 0, strlen(msg));
43 }
44 }
45
46 static HapInfoParams g_info = {
47 .userID = 100,
48 .bundleName = "ohos.permission_test.demo",
49 .instIndex = 0,
50 .appIDDesc = "ohos.permission_test.demo",
51 .isSystemApp = true
52 };
53
54 static HapPolicyParams g_policy = {
55 .apl = APL_NORMAL,
56 .domain = "test.domain",
57 .permList = {
58 {
59 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
60 .bundleName = "ohos.permission_test.demo",
61 .grantMode = 1,
62 .availableLevel = APL_NORMAL,
63 .label = "label",
64 .labelId = 1,
65 .description = "test",
66 .descriptionId = 1
67 }
68 },
69 .permStateList = {
70 {
71 .permissionName = "ohos.permission.MANAGE_MEDIA_RESOURCES",
72 .isGeneral = true,
73 .resDeviceID = {"local"},
74 .grantStatus = {PermissionState::PERMISSION_GRANTED},
75 .grantFlags = {1}
76 }
77 }
78 };
79
CreatePixelMap()80 static std::shared_ptr<PixelMap> CreatePixelMap()
81 {
82 int32_t pixelMapWidth = 4;
83 int32_t pixelMapHeight = 3;
84 const std::shared_ptr<PixelMap> &pixelMap = std::make_shared<PixelMap>();
85 ImageInfo info;
86 info.size.width = pixelMapWidth;
87 info.size.height = pixelMapHeight;
88 info.pixelFormat = PixelFormat::RGB_888;
89 info.colorSpace = ColorSpace::SRGB;
90 pixelMap->SetImageInfo(info);
91 int32_t rowDataSize = pixelMapWidth;
92 uint32_t bufferSize = rowDataSize * pixelMapHeight;
93 if (bufferSize <= 0) {
94 return pixelMap;
95 }
96
97 std::vector<std::uint8_t> buffer(bufferSize, 0x03);
98 pixelMap->SetPixelsAddr(buffer.data(), nullptr, bufferSize, AllocatorType::CUSTOM_ALLOC, nullptr);
99
100 return pixelMap;
101 }
102
103 static const int32_t DURATION_TIME = 40000;
GetAVMetaData()104 static AVMetaData GetAVMetaData()
105 {
106 AVMetaData g_metaData;
107 g_metaData.Reset();
108 g_metaData.SetAssetId("123");
109 g_metaData.SetTitle("Black Humor");
110 g_metaData.SetArtist("zhoujielun");
111 g_metaData.SetAuthor("zhoujielun");
112 g_metaData.SetAlbum("Jay");
113 g_metaData.SetWriter("zhoujielun");
114 g_metaData.SetComposer("zhoujielun");
115 g_metaData.SetDuration(DURATION_TIME);
116 g_metaData.SetMediaImageUri("xxxxx");
117 g_metaData.SetSubTitle("fac");
118 g_metaData.SetDescription("for friends");
119 g_metaData.SetLyric("xxxxx");
120 g_metaData.SetMediaImage(AVSessionPixelMapAdapter::ConvertToInner(CreatePixelMap()));
121 return g_metaData;
122 }
123
124 class AVSessionControllerStubTest : public testing::Test {
125 public:
126 static void SetUpTestCase();
127 static void TearDownTestCase();
128 void SetUp() override;
129 void TearDown() override;
130 };
131
SetUpTestCase()132 void AVSessionControllerStubTest::SetUpTestCase()
133 {
134 g_selfTokenId = GetSelfTokenID();
135 AccessTokenKit::AllocHapToken(g_info, g_policy);
136 AccessTokenIDEx tokenID = AccessTokenKit::GetHapTokenIDEx(g_info.userID, g_info.bundleName, g_info.instIndex);
137 SetSelfTokenID(tokenID.tokenIDEx);
138 }
139
TearDownTestCase()140 void AVSessionControllerStubTest::TearDownTestCase()
141 {
142 SetSelfTokenID(g_selfTokenId);
143 auto tokenId = AccessTokenKit::GetHapTokenID(g_info.userID, g_info.bundleName, g_info.instIndex);
144 AccessTokenKit::DeleteToken(tokenId);
145 }
146
SetUp()147 void AVSessionControllerStubTest::SetUp()
148 {
149 }
150
TearDown()151 void AVSessionControllerStubTest::TearDown()
152 {
153 }
154
155 class AVSessionControllerStubDemo : public AVSessionControllerStub {
156 public:
GetAVCallState(AVCallState & avCallState)157 int32_t GetAVCallState(AVCallState &avCallState) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetAVCallMetaData(AVCallMetaData & avCallMetaData)158 int32_t GetAVCallMetaData(AVCallMetaData &avCallMetaData) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetAVPlaybackState(AVPlaybackState & state)159 int32_t GetAVPlaybackState(AVPlaybackState &state) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetAVMetaData(AVMetaData & data)160 int32_t GetAVMetaData(AVMetaData &data) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
SendAVKeyEvent(const OHOS::MMI::KeyEvent & keyEvent)161 int32_t SendAVKeyEvent(const OHOS::MMI::KeyEvent &keyEvent) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetLaunchAbility(OHOS::AbilityRuntime::WantAgent::WantAgent & ability)162 int32_t GetLaunchAbility(OHOS::AbilityRuntime::WantAgent::WantAgent &ability) override
163 {
164 return isSuccess ? AVSESSION_SUCCESS : 0;
165 };
GetValidCommands(std::vector<int32_t> & cmds)166 int32_t GetValidCommands(std::vector<int32_t> &cmds) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
IsSessionActive(bool & isActive)167 int32_t IsSessionActive(bool &isActive) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
SendControlCommand(const AVControlCommand & cmd)168 int32_t SendControlCommand(const AVControlCommand &cmd) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
SendCommonCommand(const std::string & commonCommand,const OHOS::AAFwk::WantParams & commandArgs)169 int32_t SendCommonCommand(const std::string &commonCommand, const OHOS::AAFwk::WantParams &commandArgs) override
170 {
171 return isSuccess ? AVSESSION_SUCCESS : 0;
172 };
RegisterCallback(const std::shared_ptr<AVControllerCallback> & callback)173 int32_t RegisterCallback(const std::shared_ptr<AVControllerCallback> &callback) override
174 {
175 return isSuccess ? AVSESSION_SUCCESS : 0;
176 };
SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType & filter)177 int32_t SetAVCallMetaFilter(const AVCallMetaData::AVCallMetaMaskType &filter) override
178 {
179 return isSuccess ? AVSESSION_SUCCESS : 0;
180 };
SetAVCallStateFilter(const AVCallState::AVCallStateMaskType & filter)181 int32_t SetAVCallStateFilter(const AVCallState::AVCallStateMaskType &filter) override
182 {
183 return isSuccess ? AVSESSION_SUCCESS : 0;
184 };
SetMetaFilter(const AVMetaData::MetaMaskType & filter)185 int32_t SetMetaFilter(const AVMetaData::MetaMaskType &filter) override
186 {
187 return isSuccess ? AVSESSION_SUCCESS : 0;
188 };
SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType & filter)189 int32_t SetPlaybackFilter(const AVPlaybackState::PlaybackStateMaskType &filter) override
190 {
191 return isSuccess ? AVSESSION_SUCCESS : 0;
192 };
GetAVQueueItems(std::vector<AVQueueItem> & items)193 int32_t GetAVQueueItems(std::vector<AVQueueItem> &items) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetAVQueueTitle(std::string & title)194 int32_t GetAVQueueTitle(std::string &title) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
SkipToQueueItem(int32_t & itemId)195 int32_t SkipToQueueItem(int32_t &itemId) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetExtras(OHOS::AAFwk::WantParams & extras)196 int32_t GetExtras(OHOS::AAFwk::WantParams &extras) override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetExtrasWithEvent(const std::string & extraEvent,OHOS::AAFwk::WantParams & extras)197 int32_t GetExtrasWithEvent(const std::string &extraEvent, OHOS::AAFwk::WantParams &extras) override
198 {
199 return isSuccess ? AVSESSION_SUCCESS : 0;
200 };
Destroy()201 int32_t Destroy() override { return isSuccess ? AVSESSION_SUCCESS : 0; };
GetSessionId()202 std::string GetSessionId() override { return ""; };
GetRealPlaybackPosition()203 int64_t GetRealPlaybackPosition() override { return isSuccess ? AVSESSION_SUCCESS : 0; };
IsDestroy()204 bool IsDestroy() override { return true; };
RegisterCallbackInner(const OHOS::sptr<IRemoteObject> & callback)205 int32_t RegisterCallbackInner(const OHOS::sptr<IRemoteObject> &callback) override
206 {
207 return isSuccess ? AVSESSION_SUCCESS : 0;
208 };
DoMetadataImgClean(AVMetaData & data)209 void DoMetadataImgClean(AVMetaData& data) override
210 {
211 std::shared_ptr<AVSessionPixelMap> innerQueuePixelMap = data.GetAVQueueImage();
212 if (innerQueuePixelMap != nullptr) {
213 innerQueuePixelMap->Clear();
214 }
215 std::shared_ptr<AVSessionPixelMap> innerMediaPixelMap = data.GetMediaImage();
216 if (innerMediaPixelMap != nullptr) {
217 innerMediaPixelMap->Clear();
218 }
219 };
220 bool isSuccess = true;
221 };
222
223 /**
224 * @tc.name: OnRemoteRequest001
225 * @tc.desc: Test OnRemoteRequest
226 * @tc.type: FUNC
227 */
228 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest001, TestSize.Level1)
229 {
230 SLOGI("OnRemoteRequest001 begin!");
231 uint32_t code = 0;
232 AVSessionControllerStubDemo avSessionControllerStub;
233 OHOS::MessageParcel data;
234 OHOS::MessageParcel reply;
235 OHOS::MessageOption option;
236 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
237 EXPECT_EQ(ret, AVSESSION_ERROR);
238 SLOGI("OnRemoteRequest001 end!");
239 }
240
241 /**
242 * @tc.name: OnRemoteRequest002
243 * @tc.desc: Test OnRemoteRequest
244 * @tc.type: FUNC
245 */
246 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest002, TestSize.Level1)
247 {
248 SLOGI("OnRemoteRequest002 begin!");
249 uint32_t code = 0;
250 AVSessionControllerStubDemo avSessionControllerStub;
251 OHOS::MessageParcel data;
252 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
253 data.WriteString("test");
254 OHOS::MessageParcel reply;
255 OHOS::MessageOption option;
256 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
257 EXPECT_EQ(ret, OHOS::ERR_NONE);
258 SLOGI("OnRemoteRequest002 end!");
259 }
260
261 /**
262 * @tc.name: OnRemoteRequest003
263 * @tc.desc: Test OnRemoteRequest
264 * @tc.type: FUNC
265 */
266 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest003, TestSize.Level1)
267 {
268 SLOGI("OnRemoteRequest003 begin!");
269 uint32_t code = 0;
270 AVSessionControllerStubDemo avSessionControllerStub;
271 avSessionControllerStub.isSuccess = false;
272 OHOS::MessageParcel data;
273 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
274 data.WriteString("test");
275 OHOS::MessageParcel reply;
276 OHOS::MessageOption option;
277 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
278 EXPECT_EQ(ret, OHOS::ERR_NONE);
279 SLOGI("OnRemoteRequest003 end!");
280 }
281
282 /**
283 * @tc.name: OnRemoteRequest004
284 * @tc.desc: Test OnRemoteRequest
285 * @tc.type: FUNC
286 */
287 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest004, TestSize.Level1)
288 {
289 SLOGI("OnRemoteRequest004 begin!");
290 uint32_t code = 2;
291 AVSessionControllerStubDemo avSessionControllerStub;
292 OHOS::MessageParcel data;
293 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
294 data.WriteString("test");
295 OHOS::MessageParcel reply;
296 OHOS::MessageOption option;
297 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
298 EXPECT_EQ(ret, OHOS::ERR_NONE);
299 SLOGI("OnRemoteRequest004 end!");
300 }
301
302 /**
303 * @tc.name: OnRemoteRequest005
304 * @tc.desc: Test OnRemoteRequest
305 * @tc.type: FUNC
306 */
307 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest005, TestSize.Level1)
308 {
309 SLOGI("OnRemoteRequest005 begin!");
310 uint32_t code = 2;
311 AVSessionControllerStubDemo avSessionControllerStub;
312 avSessionControllerStub.isSuccess = false;
313 OHOS::MessageParcel data;
314 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
315 data.WriteString("test");
316 OHOS::MessageParcel reply;
317 OHOS::MessageOption option;
318 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
319 EXPECT_EQ(ret, OHOS::ERR_NONE);
320 SLOGI("OnRemoteRequest005 end!");
321 }
322
323 /**
324 * @tc.name: OnRemoteRequest006
325 * @tc.desc: Test OnRemoteRequest
326 * @tc.type: FUNC
327 */
328 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest006, TestSize.Level1)
329 {
330 SLOGI("OnRemoteRequest006 begin!");
331 uint32_t code = 3;
332 AVSessionControllerStubDemo avSessionControllerStub;
333 OHOS::MessageParcel data;
334 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
335 data.WriteString("test");
336 OHOS::MessageParcel reply;
337 OHOS::MessageOption option;
338 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
339 EXPECT_EQ(ret, OHOS::ERR_NONE);
340 SLOGI("OnRemoteRequest006 end!");
341 }
342
343 /**
344 * @tc.name: OnRemoteRequest007
345 * @tc.desc: Test OnRemoteRequest
346 * @tc.type: FUNC
347 */
348 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest007, TestSize.Level1)
349 {
350 SLOGI("OnRemoteRequest007 begin!");
351 uint32_t code = 3;
352 AVSessionControllerStubDemo avSessionControllerStub;
353 avSessionControllerStub.isSuccess = false;
354 OHOS::MessageParcel data;
355 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
356 data.WriteString("test");
357 OHOS::MessageParcel reply;
358 OHOS::MessageOption option;
359 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
360 EXPECT_EQ(ret, OHOS::ERR_NONE);
361 SLOGI("OnRemoteRequest007 end!");
362 }
363
364 /**
365 * @tc.name: OnRemoteRequest008
366 * @tc.desc: Test OnRemoteRequest
367 * @tc.type: FUNC
368 */
369 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest008, TestSize.Level1)
370 {
371 SLOGI("OnRemoteRequest008 begin!");
372 uint32_t code = 4;
373 AVSessionControllerStubDemo avSessionControllerStub;
374 OHOS::MessageParcel data;
375 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
376 data.WriteString("test");
377 OHOS::MessageParcel reply;
378 OHOS::MessageOption option;
379 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
380 EXPECT_EQ(ret, OHOS::ERR_NONE);
381 SLOGI("OnRemoteRequest008 end!");
382 }
383
384 /**
385 * @tc.name: OnRemoteRequest009
386 * @tc.desc: Test OnRemoteRequest
387 * @tc.type: FUNC
388 */
389 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest009, TestSize.Level1)
390 {
391 SLOGI("OnRemoteRequest009 begin!");
392 uint32_t code = 4;
393 AVSessionControllerStubDemo avSessionControllerStub;
394 avSessionControllerStub.isSuccess = false;
395 OHOS::MessageParcel data;
396 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
397 data.WriteString("test");
398 OHOS::MessageParcel reply;
399 OHOS::MessageOption option;
400 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
401 EXPECT_EQ(ret, OHOS::ERR_NONE);
402 SLOGI("OnRemoteRequest009 end!");
403 }
404
405 /**
406 * @tc.name: OnRemoteRequest010
407 * @tc.desc: Test OnRemoteRequest
408 * @tc.type: FUNC
409 */
410 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest010, TestSize.Level1)
411 {
412 SLOGI("OnRemoteRequest010 begin!");
413 uint32_t code = 5;
414 AVSessionControllerStubDemo avSessionControllerStub;
415 OHOS::MessageParcel data;
416 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
417 data.WriteString("test");
418 OHOS::MessageParcel reply;
419 OHOS::MessageOption option;
420 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
421 EXPECT_EQ(ret, OHOS::ERR_NONE);
422 SLOGI("OnRemoteRequest010 end!");
423 }
424
425 /**
426 * @tc.name: OnRemoteRequest011
427 * @tc.desc: Test OnRemoteRequest
428 * @tc.type: FUNC
429 */
430 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest011, TestSize.Level1)
431 {
432 SLOGI("OnRemoteRequest011 begin!");
433 uint32_t code = 5;
434 AVSessionControllerStubDemo avSessionControllerStub;
435 avSessionControllerStub.isSuccess = false;
436 OHOS::MessageParcel data;
437 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
438 data.WriteString("test");
439 OHOS::MessageParcel reply;
440 OHOS::MessageOption option;
441 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
442 EXPECT_EQ(ret, OHOS::ERR_NONE);
443 SLOGI("OnRemoteRequest011 end!");
444 }
445
446 /**
447 * @tc.name: OnRemoteRequest012
448 * @tc.desc: Test OnRemoteRequest
449 * @tc.type: FUNC
450 */
451 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest012, TestSize.Level1)
452 {
453 SLOGI("OnRemoteRequest012 begin!");
454 uint32_t code = 6;
455 AVSessionControllerStubDemo avSessionControllerStub;
456 OHOS::MessageParcel data;
457 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
458 data.WriteString("test");
459 OHOS::MessageParcel reply;
460 OHOS::MessageOption option;
461 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
462 EXPECT_EQ(ret, OHOS::ERR_NONE);
463 SLOGI("OnRemoteRequest012 end!");
464 }
465
466 /**
467 * @tc.name: OnRemoteRequest013
468 * @tc.desc: Test OnRemoteRequest
469 * @tc.type: FUNC
470 */
471 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest013, TestSize.Level1)
472 {
473 SLOGI("OnRemoteRequest013 begin!");
474 uint32_t code = 6;
475 AVSessionControllerStubDemo avSessionControllerStub;
476 avSessionControllerStub.isSuccess = false;
477 OHOS::MessageParcel data;
478 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
479 data.WriteString("test");
480 OHOS::MessageParcel reply;
481 OHOS::MessageOption option;
482 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
483 EXPECT_EQ(ret, OHOS::ERR_NONE);
484 SLOGI("OnRemoteRequest013 end!");
485 }
486
487 /**
488 * @tc.name: OnRemoteRequest014
489 * @tc.desc: Test OnRemoteRequest
490 * @tc.type: FUNC
491 */
492 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest014, TestSize.Level1)
493 {
494 SLOGI("OnRemoteRequest014 begin!");
495 uint32_t code = 7;
496 AVSessionControllerStubDemo avSessionControllerStub;
497 OHOS::MessageParcel data;
498 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
499 data.WriteString("test");
500 OHOS::MessageParcel reply;
501 OHOS::MessageOption option;
502 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
503 EXPECT_EQ(ret, OHOS::ERR_NONE);
504 SLOGI("OnRemoteRequest014 end!");
505 }
506
507 /**
508 * @tc.name: OnRemoteRequest015
509 * @tc.desc: Test OnRemoteRequest
510 * @tc.type: FUNC
511 */
512 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest015, TestSize.Level1)
513 {
514 SLOGI("OnRemoteRequest015 begin!");
515 uint32_t code = 7;
516 AVSessionControllerStubDemo avSessionControllerStub;
517 avSessionControllerStub.isSuccess = false;
518 OHOS::MessageParcel data;
519 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
520 data.WriteString("test");
521 OHOS::MessageParcel reply;
522 OHOS::MessageOption option;
523 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
524 EXPECT_EQ(ret, OHOS::ERR_NONE);
525 SLOGI("OnRemoteRequest015 end!");
526 }
527
528 /**
529 * @tc.name: OnRemoteRequest016
530 * @tc.desc: Test OnRemoteRequest
531 * @tc.type: FUNC
532 */
533 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest016, TestSize.Level1)
534 {
535 SLOGI("OnRemoteRequest016 begin!");
536 uint32_t code = 8;
537 AVSessionControllerStubDemo avSessionControllerStub;
538 OHOS::MessageParcel data;
539 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
540 data.WriteString("test");
541 OHOS::MessageParcel reply;
542 OHOS::MessageOption option;
543 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
544 EXPECT_EQ(ret, OHOS::ERR_NONE);
545 SLOGI("OnRemoteRequest016 end!");
546 }
547
548 /**
549 * @tc.name: OnRemoteRequest017
550 * @tc.desc: Test OnRemoteRequest
551 * @tc.type: FUNC
552 */
553 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest017, TestSize.Level1)
554 {
555 SLOGI("OnRemoteRequest017 begin!");
556 uint32_t code = 8;
557 AVSessionControllerStubDemo avSessionControllerStub;
558 avSessionControllerStub.isSuccess = false;
559 OHOS::MessageParcel data;
560 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
561 data.WriteString("test");
562 OHOS::MessageParcel reply;
563 OHOS::MessageOption option;
564 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
565 EXPECT_EQ(ret, OHOS::ERR_NONE);
566 SLOGI("OnRemoteRequest017 end!");
567 }
568
569 /**
570 * @tc.name: OnRemoteRequest018
571 * @tc.desc: Test OnRemoteRequest
572 * @tc.type: FUNC
573 */
574 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest018, TestSize.Level1)
575 {
576 SLOGI("OnRemoteRequest018 begin!");
577 uint32_t code = 9;
578 AVSessionControllerStubDemo avSessionControllerStub;
579 OHOS::MessageParcel data;
580 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
581 data.WriteString("test");
582 OHOS::MessageParcel reply;
583 OHOS::MessageOption option;
584 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
585 EXPECT_EQ(ret, OHOS::ERR_NONE);
586 SLOGI("OnRemoteRequest018 end!");
587 }
588
589 /**
590 * @tc.name: OnRemoteRequest019
591 * @tc.desc: Test OnRemoteRequest
592 * @tc.type: FUNC
593 */
594 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest019, TestSize.Level1)
595 {
596 SLOGI("OnRemoteRequest019 begin!");
597 uint32_t code = 9;
598 AVSessionControllerStubDemo avSessionControllerStub;
599 avSessionControllerStub.isSuccess = false;
600 OHOS::MessageParcel data;
601 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
602 data.WriteString("test");
603 OHOS::MessageParcel reply;
604 OHOS::MessageOption option;
605 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
606 EXPECT_EQ(ret, OHOS::ERR_NONE);
607 SLOGI("OnRemoteRequest019 end!");
608 }
609
610 /**
611 * @tc.name: OnRemoteRequest019_1
612 * @tc.desc: Test OnRemoteRequest
613 * @tc.type: FUNC
614 */
615 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest019_1, TestSize.Level1)
616 {
617 SLOGI("OnRemoteRequest019_1 begin!");
618 uint32_t code = 9;
619 AVSessionControllerStubDemo avSessionControllerStub;
620 OHOS::MessageParcel data;
621 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
622 data.WriteString("222222");
623 OHOS::MessageParcel reply;
624 OHOS::MessageOption option;
625 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
626 EXPECT_EQ(ret, OHOS::ERR_NONE);
627 SLOGI("OnRemoteRequest019_1 end!");
628 }
629
630 /**
631 * @tc.name: OnRemoteRequest019_2
632 * @tc.desc: Test OnRemoteRequest
633 * @tc.type: FUNC
634 */
635 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest019_2, TestSize.Level1)
636 {
637 SLOGI("OnRemoteRequest019_2 begin!");
638 uint32_t code = 9;
639 AVSessionControllerStubDemo avSessionControllerStub;
640 OHOS::MessageParcel data;
641 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
642 data.WriteString("01010101");
643 OHOS::MessageParcel reply;
644 OHOS::MessageOption option;
645 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
646 EXPECT_EQ(ret, OHOS::ERR_NONE);
647 SLOGI("OnRemoteRequest019_2 end!");
648 }
649
650 /**
651 * @tc.name: OnRemoteRequest020
652 * @tc.desc: Test OnRemoteRequest
653 * @tc.type: FUNC
654 */
655 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest020, TestSize.Level1)
656 {
657 SLOGI("OnRemoteRequest020 begin!");
658 uint32_t code = 10;
659 AVSessionControllerStubDemo avSessionControllerStub;
660 OHOS::MessageParcel data;
661 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
662 data.WriteString("test");
663 OHOS::MessageParcel reply;
664 OHOS::MessageOption option;
665 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
666 EXPECT_EQ(ret, OHOS::ERR_NONE);
667 SLOGI("OnRemoteRequest020 end!");
668 }
669
670 /**
671 * @tc.name: OnRemoteRequest021
672 * @tc.desc: Test OnRemoteRequest
673 * @tc.type: FUNC
674 */
675 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest021, TestSize.Level1)
676 {
677 SLOGI("OnRemoteRequest021 begin!");
678 uint32_t code = 10;
679 AVSessionControllerStubDemo avSessionControllerStub;
680 avSessionControllerStub.isSuccess = false;
681 OHOS::MessageParcel data;
682 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
683 data.WriteString("test");
684 OHOS::MessageParcel reply;
685 OHOS::MessageOption option;
686 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
687 EXPECT_EQ(ret, OHOS::ERR_NONE);
688 SLOGI("OnRemoteRequest021 end!");
689 }
690
691 /**
692 * @tc.name: OnRemoteRequest021_1
693 * @tc.desc: Test OnRemoteRequest
694 * @tc.type: FUNC
695 */
696 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest021_1, TestSize.Level1)
697 {
698 SLOGI("OnRemoteRequest021_1 begin!");
699 uint32_t code = 10;
700 AVSessionControllerStubDemo avSessionControllerStub;
701 OHOS::MessageParcel data;
702 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
703 data.WriteString("222222");
704 OHOS::MessageParcel reply;
705 OHOS::MessageOption option;
706 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
707 EXPECT_EQ(ret, OHOS::ERR_NONE);
708 SLOGI("OnRemoteRequest021_1 end!");
709 }
710
711 /**
712 * @tc.name: OnRemoteRequest021_2
713 * @tc.desc: Test OnRemoteRequest
714 * @tc.type: FUNC
715 */
716 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest021_2, TestSize.Level1)
717 {
718 SLOGI("OnRemoteRequest021_2 begin!");
719 uint32_t code = 10;
720 AVSessionControllerStubDemo avSessionControllerStub;
721 OHOS::MessageParcel data;
722 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
723 data.WriteString("01010101");
724 OHOS::MessageParcel reply;
725 OHOS::MessageOption option;
726 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
727 EXPECT_EQ(ret, OHOS::ERR_NONE);
728 SLOGI("OnRemoteRequest021_2 end!");
729 }
730
731 /**
732 * @tc.name: OnRemoteRequest022
733 * @tc.desc: Test OnRemoteRequest
734 * @tc.type: FUNC
735 */
736 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest022, TestSize.Level1)
737 {
738 SLOGI("OnRemoteRequest022 begin!");
739 uint32_t code = 11;
740 AVSessionControllerStubDemo avSessionControllerStub;
741 OHOS::MessageParcel data;
742 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
743 data.WriteString("test");
744 OHOS::MessageParcel reply;
745 OHOS::MessageOption option;
746 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
747 EXPECT_EQ(ret, OHOS::ERR_NONE);
748 SLOGI("OnRemoteRequest022 end!");
749 }
750
751 /**
752 * @tc.name: OnRemoteRequest023
753 * @tc.desc: Test OnRemoteRequest
754 * @tc.type: FUNC
755 */
756 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest023, TestSize.Level1)
757 {
758 SLOGI("OnRemoteRequest023 begin!");
759 uint32_t code = 11;
760 AVSessionControllerStubDemo avSessionControllerStub;
761 avSessionControllerStub.isSuccess = false;
762 OHOS::MessageParcel data;
763 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
764 data.WriteString("test");
765 OHOS::MessageParcel reply;
766 OHOS::MessageOption option;
767 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
768 EXPECT_EQ(ret, OHOS::ERR_NONE);
769 SLOGI("OnRemoteRequest023 end!");
770 }
771
772 /**
773 * @tc.name: OnRemoteRequest024
774 * @tc.desc: Test OnRemoteRequest
775 * @tc.type: FUNC
776 */
777 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest024, TestSize.Level1)
778 {
779 SLOGI("OnRemoteRequest024 begin!");
780 uint32_t code = 13;
781 AVSessionControllerStubDemo avSessionControllerStub;
782 OHOS::MessageParcel data;
783 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
784 data.WriteString("test");
785 OHOS::MessageParcel reply;
786 OHOS::MessageOption option;
787 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
788 EXPECT_EQ(ret, OHOS::ERR_NONE);
789 SLOGI("OnRemoteRequest024 end!");
790 }
791
792 /**
793 * @tc.name: OnRemoteRequest025
794 * @tc.desc: Test OnRemoteRequest
795 * @tc.type: FUNC
796 */
797 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest025, TestSize.Level1)
798 {
799 SLOGI("OnRemoteRequest025 begin!");
800 uint32_t code = 13;
801 AVSessionControllerStubDemo avSessionControllerStub;
802 avSessionControllerStub.isSuccess = false;
803 OHOS::MessageParcel data;
804 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
805 data.WriteString("test");
806 OHOS::MessageParcel reply;
807 OHOS::MessageOption option;
808 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
809 EXPECT_EQ(ret, OHOS::ERR_NONE);
810 SLOGI("OnRemoteRequest025 end!");
811 }
812
813 /**
814 * @tc.name: OnRemoteRequest026
815 * @tc.desc: Test OnRemoteRequest
816 * @tc.type: FUNC
817 */
818 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest026, TestSize.Level1)
819 {
820 SLOGI("OnRemoteRequest026 begin!");
821 uint32_t code = 14;
822 AVSessionControllerStubDemo avSessionControllerStub;
823 OHOS::MessageParcel data;
824 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
825 data.WriteString("test");
826 OHOS::MessageParcel reply;
827 OHOS::MessageOption option;
828 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
829 EXPECT_EQ(ret, OHOS::ERR_NONE);
830 SLOGI("OnRemoteRequest026 end!");
831 }
832
833 /**
834 * @tc.name: OnRemoteRequest027
835 * @tc.desc: Test OnRemoteRequest
836 * @tc.type: FUNC
837 */
838 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest027, TestSize.Level1)
839 {
840 SLOGI("OnRemoteRequest027 begin!");
841 uint32_t code = 14;
842 AVSessionControllerStubDemo avSessionControllerStub;
843 avSessionControllerStub.isSuccess = false;
844 OHOS::MessageParcel data;
845 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
846 data.WriteString("test");
847 OHOS::MessageParcel reply;
848 OHOS::MessageOption option;
849 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
850 EXPECT_EQ(ret, OHOS::ERR_NONE);
851 SLOGI("OnRemoteRequest027 end!");
852 }
853
854 /**
855 * @tc.name: OnRemoteRequest028
856 * @tc.desc: Test OnRemoteRequest
857 * @tc.type: FUNC
858 */
859 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest028, TestSize.Level1)
860 {
861 SLOGI("OnRemoteRequest028 begin!");
862 uint32_t code = 15;
863 AVSessionControllerStubDemo avSessionControllerStub;
864 OHOS::MessageParcel data;
865 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
866 data.WriteString("test");
867 OHOS::MessageParcel reply;
868 OHOS::MessageOption option;
869 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
870 EXPECT_EQ(ret, OHOS::ERR_NONE);
871 SLOGI("OnRemoteRequest028 end!");
872 }
873
874 /**
875 * @tc.name: OnRemoteRequest029
876 * @tc.desc: Test OnRemoteRequest
877 * @tc.type: FUNC
878 */
879 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest029, TestSize.Level1)
880 {
881 SLOGI("OnRemoteRequest029 begin!");
882 uint32_t code = 15;
883 AVSessionControllerStubDemo avSessionControllerStub;
884 avSessionControllerStub.isSuccess = false;
885 OHOS::MessageParcel data;
886 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
887 data.WriteString("test");
888 OHOS::MessageParcel reply;
889 OHOS::MessageOption option;
890 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
891 EXPECT_EQ(ret, OHOS::ERR_NONE);
892 SLOGI("OnRemoteRequest029 end!");
893 }
894
895 /**
896 * @tc.name: OnRemoteRequest030
897 * @tc.desc: Test OnRemoteRequest
898 * @tc.type: FUNC
899 */
900 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest030, TestSize.Level1)
901 {
902 SLOGI("OnRemoteRequest030 begin!");
903 uint32_t code = 16;
904 AVSessionControllerStubDemo avSessionControllerStub;
905 OHOS::MessageParcel data;
906 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
907 data.WriteString("test");
908 OHOS::MessageParcel reply;
909 OHOS::MessageOption option;
910 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
911 EXPECT_EQ(ret, OHOS::ERR_NONE);
912 SLOGI("OnRemoteRequest030 end!");
913 }
914
915 /**
916 * @tc.name: OnRemoteRequest031
917 * @tc.desc: Test OnRemoteRequest
918 * @tc.type: FUNC
919 */
920 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest031, TestSize.Level1)
921 {
922 SLOGI("OnRemoteRequest031 begin!");
923 uint32_t code = 16;
924 AVSessionControllerStubDemo avSessionControllerStub;
925 avSessionControllerStub.isSuccess = false;
926 OHOS::MessageParcel data;
927 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
928 data.WriteString("test");
929 OHOS::MessageParcel reply;
930 OHOS::MessageOption option;
931 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
932 EXPECT_EQ(ret, OHOS::ERR_NONE);
933 SLOGI("OnRemoteRequest031 end!");
934 }
935
936 /**
937 * @tc.name: OnRemoteRequest032
938 * @tc.desc: Test OnRemoteRequest
939 * @tc.type: FUNC
940 */
941 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest032, TestSize.Level1)
942 {
943 SLOGI("OnRemoteRequest032 begin!");
944 uint32_t code = 17;
945 AVSessionControllerStubDemo avSessionControllerStub;
946 OHOS::MessageParcel data;
947 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
948 data.WriteString("test");
949 OHOS::MessageParcel reply;
950 OHOS::MessageOption option;
951 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
952 EXPECT_EQ(ret, OHOS::ERR_NONE);
953 SLOGI("OnRemoteRequest032 end!");
954 }
955
956 /**
957 * @tc.name: OnRemoteRequest033
958 * @tc.desc: Test OnRemoteRequest
959 * @tc.type: FUNC
960 */
961 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest033, TestSize.Level1)
962 {
963 SLOGI("OnRemoteRequest033 begin!");
964 uint32_t code = 17;
965 AVSessionControllerStubDemo avSessionControllerStub;
966 avSessionControllerStub.isSuccess = false;
967 OHOS::MessageParcel data;
968 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
969 data.WriteString("test");
970 OHOS::MessageParcel reply;
971 OHOS::MessageOption option;
972 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
973 EXPECT_EQ(ret, OHOS::ERR_NONE);
974 SLOGI("OnRemoteRequest033 end!");
975 }
976
977 /**
978 * @tc.name: OnRemoteRequest034
979 * @tc.desc: Test OnRemoteRequest
980 * @tc.type: FUNC
981 */
982 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest034, TestSize.Level1)
983 {
984 SLOGI("OnRemoteRequest034 begin!");
985 uint32_t code = 18;
986 AVSessionControllerStubDemo avSessionControllerStub;
987 OHOS::MessageParcel data;
988 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
989 data.WriteString("test");
990 OHOS::MessageParcel reply;
991 OHOS::MessageOption option;
992 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
993 EXPECT_EQ(ret, OHOS::ERR_NONE);
994 SLOGI("OnRemoteRequest034 end!");
995 }
996
997 /**
998 * @tc.name: OnRemoteRequest035
999 * @tc.desc: Test OnRemoteRequest
1000 * @tc.type: FUNC
1001 */
1002 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest035, TestSize.Level1)
1003 {
1004 SLOGI("OnRemoteRequest035 begin!");
1005 uint32_t code = 18;
1006 AVSessionControllerStubDemo avSessionControllerStub;
1007 avSessionControllerStub.isSuccess = false;
1008 OHOS::MessageParcel data;
1009 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1010 data.WriteString("test");
1011 OHOS::MessageParcel reply;
1012 OHOS::MessageOption option;
1013 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1014 EXPECT_EQ(ret, OHOS::ERR_NONE);
1015 SLOGI("OnRemoteRequest035 end!");
1016 }
1017
1018 /**
1019 * @tc.name: OnRemoteRequest035_1
1020 * @tc.desc: Test OnRemoteRequest
1021 * @tc.type: FUNC
1022 */
1023 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest035_1, TestSize.Level1)
1024 {
1025 SLOGI("OnRemoteRequest035_1 begin!");
1026 uint32_t code = 18;
1027 AVSessionControllerStubDemo avSessionControllerStub;
1028 OHOS::MessageParcel data;
1029 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1030 data.WriteString("222222");
1031 OHOS::MessageParcel reply;
1032 OHOS::MessageOption option;
1033 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1034 EXPECT_EQ(ret, OHOS::ERR_NONE);
1035 SLOGI("OnRemoteRequest035_1 end!");
1036 }
1037
1038 /**
1039 * @tc.name: OnRemoteRequest035_2
1040 * @tc.desc: Test OnRemoteRequest
1041 * @tc.type: FUNC
1042 */
1043 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest035_2, TestSize.Level1)
1044 {
1045 SLOGI("OnRemoteRequest035_2 begin!");
1046 uint32_t code = 18;
1047 AVSessionControllerStubDemo avSessionControllerStub;
1048 OHOS::MessageParcel data;
1049 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1050 data.WriteString("0101010");
1051 OHOS::MessageParcel reply;
1052 OHOS::MessageOption option;
1053 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1054 EXPECT_EQ(ret, OHOS::ERR_NONE);
1055 SLOGI("OnRemoteRequest035_2 end!");
1056 }
1057
1058 /**
1059 * @tc.name: OnRemoteRequest036
1060 * @tc.desc: Test OnRemoteRequest
1061 * @tc.type: FUNC
1062 */
1063 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest036, TestSize.Level1)
1064 {
1065 SLOGI("OnRemoteRequest036 begin!");
1066 uint32_t code = 19;
1067 AVSessionControllerStubDemo avSessionControllerStub;
1068 OHOS::MessageParcel data;
1069 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1070 data.WriteString("test");
1071 OHOS::MessageParcel reply;
1072 OHOS::MessageOption option;
1073 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1074 EXPECT_EQ(ret, OHOS::ERR_NONE);
1075 SLOGI("OnRemoteRequest036 end!");
1076 }
1077
1078 /**
1079 * @tc.name: OnRemoteRequest037
1080 * @tc.desc: Test OnRemoteRequest
1081 * @tc.type: FUNC
1082 */
1083 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest037, TestSize.Level1)
1084 {
1085 SLOGI("OnRemoteRequest037 begin!");
1086 uint32_t code = 19;
1087 AVSessionControllerStubDemo avSessionControllerStub;
1088 avSessionControllerStub.isSuccess = false;
1089 OHOS::MessageParcel data;
1090 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1091 data.WriteString("test");
1092 OHOS::MessageParcel reply;
1093 OHOS::MessageOption option;
1094 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1095 EXPECT_EQ(ret, OHOS::ERR_NONE);
1096 SLOGI("OnRemoteRequest037 end!");
1097 }
1098
1099 /**
1100 * @tc.name: OnRemoteRequest038
1101 * @tc.desc: Test OnRemoteRequest
1102 * @tc.type: FUNC
1103 */
1104 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest038, TestSize.Level1)
1105 {
1106 SLOGI("OnRemoteRequest038 begin!");
1107 uint32_t code = 20;
1108 AVSessionControllerStubDemo avSessionControllerStub;
1109 OHOS::MessageParcel data;
1110 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1111 data.WriteString("test");
1112 OHOS::MessageParcel reply;
1113 OHOS::MessageOption option;
1114 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1115 EXPECT_EQ(ret, OHOS::ERR_NONE);
1116 SLOGI("OnRemoteRequest038 end!");
1117 }
1118
1119 /**
1120 * @tc.name: OnRemoteRequest039
1121 * @tc.desc: Test OnRemoteRequest
1122 * @tc.type: FUNC
1123 */
1124 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest039, TestSize.Level1)
1125 {
1126 SLOGI("OnRemoteRequest039 begin!");
1127 uint32_t code = 20;
1128 AVSessionControllerStubDemo avSessionControllerStub;
1129 avSessionControllerStub.isSuccess = false;
1130 OHOS::MessageParcel data;
1131 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1132 data.WriteString("test");
1133 OHOS::MessageParcel reply;
1134 OHOS::MessageOption option;
1135 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1136 EXPECT_EQ(ret, OHOS::ERR_NONE);
1137 SLOGI("OnRemoteRequest039 end!");
1138 }
1139
1140 /**
1141 * @tc.name: OnRemoteRequest039_1
1142 * @tc.desc: Test OnRemoteRequest
1143 * @tc.type: FUNC
1144 */
1145 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest039_1, TestSize.Level1)
1146 {
1147 SLOGI("OnRemoteRequest039_1 begin!");
1148 uint32_t code = 20;
1149 AVSessionControllerStubDemo avSessionControllerStub;
1150 OHOS::MessageParcel data;
1151 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1152 data.WriteString("222222");
1153 OHOS::MessageParcel reply;
1154 OHOS::MessageOption option;
1155 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1156 EXPECT_EQ(ret, OHOS::ERR_NONE);
1157 SLOGI("OnRemoteRequest039_1 end!");
1158 }
1159
1160 /**
1161 * @tc.name: OnRemoteRequest039_2
1162 * @tc.desc: Test OnRemoteRequest
1163 * @tc.type: FUNC
1164 */
1165 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest039_2, TestSize.Level1)
1166 {
1167 SLOGI("OnRemoteRequest039_2 begin!");
1168 uint32_t code = 20;
1169 AVSessionControllerStubDemo avSessionControllerStub;
1170 OHOS::MessageParcel data;
1171 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1172 data.WriteString("01010101");
1173 OHOS::MessageParcel reply;
1174 OHOS::MessageOption option;
1175 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1176 EXPECT_EQ(ret, OHOS::ERR_NONE);
1177 SLOGI("OnRemoteRequest039_2 end!");
1178 }
1179
1180 /**
1181 * @tc.name: OnRemoteRequest040
1182 * @tc.desc: Test OnRemoteRequest
1183 * @tc.type: FUNC
1184 */
1185 static HWTEST_F(AVSessionControllerStubTest, OnRemoteRequest040, TestSize.Level1)
1186 {
1187 SLOGI("OnRemoteRequest040 begin!");
1188 uint32_t code = 25;
1189 AVSessionControllerStubDemo avSessionControllerStub;
1190 avSessionControllerStub.isSuccess = false;
1191 OHOS::MessageParcel data;
1192 data.WriteInterfaceToken(IAVSessionController::GetDescriptor());
1193 data.WriteString("test");
1194 OHOS::MessageParcel reply;
1195 OHOS::MessageOption option;
1196 int ret = avSessionControllerStub.OnRemoteRequest(code, data, reply, option);
1197 EXPECT_EQ(ret, 305);
1198 SLOGI("OnRemoteRequest040 end!");
1199 }
1200
1201 /**
1202 * @tc.name: DoMetadataGetReplyInStub001
1203 * @tc.desc: Test OnRemoteRequest
1204 * @tc.type: FUNC
1205 */
1206 static HWTEST_F(AVSessionControllerStubTest, DoMetadataGetReplyInStub001, TestSize.Level1)
1207 {
1208 SLOGI("DoMetadataGetReplyInStub001 begin!");
1209 AVSessionControllerStubDemo avSessionControllerStub;
1210 AVMetaData data;
1211 OHOS::MessageParcel reply;
1212 int ret = avSessionControllerStub.DoMetadataGetReplyInStub(data, reply);
1213 EXPECT_EQ(ret, OHOS::ERR_NONE);
1214 SLOGI("DoMetadataGetReplyInStub001 end!");
1215 }
1216
1217 /**
1218 * @tc.name: DoMetadataGetReplyInStub002
1219 * @tc.desc: Test OnRemoteRequest
1220 * @tc.type: FUNC
1221 */
1222 static HWTEST_F(AVSessionControllerStubTest, DoMetadataGetReplyInStub002, TestSize.Level1)
1223 {
1224 SLOGI("DoMetadataGetReplyInStub002 begin!");
1225 AVSessionControllerStubDemo avSessionControllerStub;
1226 AVMetaData data = GetAVMetaData();
1227 OHOS::MessageParcel reply;
1228 int ret = avSessionControllerStub.DoMetadataGetReplyInStub(data, reply);
1229 EXPECT_NE(ret, AVSESSION_ERROR);
1230 SLOGI("DoMetadataGetReplyInStub002 end!");
1231 }
1232
1233 /**
1234 * @tc.name: DoMetadataImgClean001
1235 * @tc.desc: Test OnRemoteRequest
1236 * @tc.type: FUNC
1237 */
1238 static HWTEST_F(AVSessionControllerStubTest, DoMetadataImgClean001, TestSize.Level1)
1239 {
1240 SLOGI("DoMetadataImgClean001 begin!");
1241 LOG_SetCallback(MyLogCallback);
1242 AVSessionControllerStubDemo avSessionControllerStub;
1243 AVMetaData data = GetAVMetaData();
1244 avSessionControllerStub.DoMetadataImgClean(data);
1245 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
1246 SLOGI("DoMetadataImgClean001 end!");
1247 }
1248
1249 /**
1250 * @tc.name: DoMetadataImgClean002
1251 * @tc.desc: Test OnRemoteRequest
1252 * @tc.type: FUNC
1253 */
1254 static HWTEST_F(AVSessionControllerStubTest, DoMetadataImgClean002, TestSize.Level1)
1255 {
1256 SLOGI("DoMetadataImgClean002 begin!");
1257 LOG_SetCallback(MyLogCallback);
1258 AVSessionControllerStubDemo avSessionControllerStub;
1259 AVMetaData data = GetAVMetaData();
1260 avSessionControllerStub.DoMetadataImgClean(data);
1261 EXPECT_TRUE(g_errLog.find("xxx") == std::string::npos);
1262 SLOGI("DoMetadataImgClean002 end!");
1263 }
1264
1265 /**
1266 * @tc.name: HandleSetAVCallMetaFilter001
1267 * @tc.desc: Test HandleSetAVCallMetaFilter
1268 * @tc.type: FUNC
1269 */
1270 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallMetaFilter001, TestSize.Level1)
1271 {
1272 SLOGI("HandleSetAVCallMetaFilter001 begin!");
1273 AVSessionControllerStubDemo avSessionControllerStub;
1274 OHOS::MessageParcel data;
1275 OHOS::MessageParcel reply;
1276 data.WriteString("1111111");
1277 int ret = avSessionControllerStub.HandleSetAVCallMetaFilter(data, reply);
1278 EXPECT_EQ(ret, OHOS::ERR_NONE);
1279 SLOGI("HandleSetAVCallMetaFilter001 end!");
1280 }
1281
1282 /**
1283 * @tc.name: HandleSetAVCallMetaFilter002
1284 * @tc.desc: Test HandleSetAVCallMetaFilter
1285 * @tc.type: FUNC
1286 */
1287 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallMetaFilter002, TestSize.Level1)
1288 {
1289 SLOGI("HandleSetAVCallMetaFilter002 begin!");
1290 AVSessionControllerStubDemo avSessionControllerStub;
1291 OHOS::MessageParcel data;
1292 OHOS::MessageParcel reply;
1293 data.WriteString("2222");
1294 int ret = avSessionControllerStub.HandleSetAVCallMetaFilter(data, reply);
1295 EXPECT_EQ(ret, OHOS::ERR_NONE);
1296 SLOGI("HandleSetAVCallMetaFilter002 end!");
1297 }
1298
1299 /**
1300 * @tc.name: HandleSetAVCallMetaFilter003
1301 * @tc.desc: Test HandleSetAVCallMetaFilter
1302 * @tc.type: FUNC
1303 */
1304 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallMetaFilter003, TestSize.Level1)
1305 {
1306 SLOGI("HandleSetAVCallMetaFilter003 begin!");
1307 AVSessionControllerStubDemo avSessionControllerStub;
1308 OHOS::MessageParcel data;
1309 OHOS::MessageParcel reply;
1310 data.WriteString("1010");
1311 int ret = avSessionControllerStub.HandleSetAVCallMetaFilter(data, reply);
1312 EXPECT_EQ(ret, OHOS::ERR_NONE);
1313 SLOGI("HandleSetAVCallMetaFilter003 end!");
1314 }
1315
1316 /**
1317 * @tc.name: HandleSetAVCallStateFilter001
1318 * @tc.desc: Test HandleSetAVCallStateFilter
1319 * @tc.type: FUNC
1320 */
1321 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallStateFilter001, TestSize.Level1)
1322 {
1323 SLOGI("HandleSetAVCallStateFilter001 begin!");
1324 AVSessionControllerStubDemo avSessionControllerStub;
1325 OHOS::MessageParcel data;
1326 OHOS::MessageParcel reply;
1327 data.WriteString("1111111");
1328 int ret = avSessionControllerStub.HandleSetAVCallStateFilter(data, reply);
1329 EXPECT_EQ(ret, OHOS::ERR_NONE);
1330 SLOGI("HandleSetAVCallStateFilter001 end!");
1331 }
1332
1333 /**
1334 * @tc.name: HandleSetAVCallStateFilter002
1335 * @tc.desc: Test HandleSetAVCallStateFilter
1336 * @tc.type: FUNC
1337 */
1338 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallStateFilter002, TestSize.Level1)
1339 {
1340 SLOGI("HandleSetAVCallStateFilter002 begin!");
1341 AVSessionControllerStubDemo avSessionControllerStub;
1342 OHOS::MessageParcel data;
1343 OHOS::MessageParcel reply;
1344 data.WriteString("2222");
1345 int ret = avSessionControllerStub.HandleSetAVCallStateFilter(data, reply);
1346 EXPECT_EQ(ret, OHOS::ERR_NONE);
1347 SLOGI("HandleSetAVCallStateFilter002 end!");
1348 }
1349
1350 /**
1351 * @tc.name: HandleSetAVCallStateFilter003
1352 * @tc.desc: Test HandleSetAVCallStateFilter
1353 * @tc.type: FUNC
1354 */
1355 static HWTEST_F(AVSessionControllerStubTest, HandleSetAVCallStateFilter003, TestSize.Level1)
1356 {
1357 SLOGI("HandleSetAVCallStateFilter003 begin!");
1358 AVSessionControllerStubDemo avSessionControllerStub;
1359 OHOS::MessageParcel data;
1360 OHOS::MessageParcel reply;
1361 data.WriteString("1010");
1362 int ret = avSessionControllerStub.HandleSetAVCallStateFilter(data, reply);
1363 EXPECT_EQ(ret, OHOS::ERR_NONE);
1364 SLOGI("HandleSetAVCallStateFilter003 end!");
1365 }
1366
1367 /**
1368 * @tc.name: HandleSetMetaFilter001
1369 * @tc.desc: Test HandleSetMetaFilter
1370 * @tc.type: FUNC
1371 */
1372 static HWTEST_F(AVSessionControllerStubTest, HandleSetMetaFilter001, TestSize.Level1)
1373 {
1374 SLOGI("HandleSetMetaFilter001 begin!");
1375 AVSessionControllerStubDemo avSessionControllerStub;
1376 OHOS::MessageParcel data;
1377 OHOS::MessageParcel reply;
1378 data.WriteString("1111111");
1379 int ret = avSessionControllerStub.HandleSetMetaFilter(data, reply);
1380 EXPECT_EQ(ret, OHOS::ERR_NONE);
1381 SLOGI("HandleSetMetaFilter001 end!");
1382 }
1383
1384 /**
1385 * @tc.name: HandleSetMetaFilter002
1386 * @tc.desc: Test HandleSetMetaFilter
1387 * @tc.type: FUNC
1388 */
1389 static HWTEST_F(AVSessionControllerStubTest, HandleSetMetaFilter002, TestSize.Level1)
1390 {
1391 SLOGI("HandleSetMetaFilter002 begin!");
1392 AVSessionControllerStubDemo avSessionControllerStub;
1393 OHOS::MessageParcel data;
1394 OHOS::MessageParcel reply;
1395 data.WriteString("2222");
1396 int ret = avSessionControllerStub.HandleSetMetaFilter(data, reply);
1397 EXPECT_EQ(ret, OHOS::ERR_NONE);
1398 SLOGI("HandleSetMetaFilter002 end!");
1399 }
1400
1401 /**
1402 * @tc.name: HandleSetMetaFilter003
1403 * @tc.desc: Test HandleSetMetaFilter
1404 * @tc.type: FUNC
1405 */
1406 static HWTEST_F(AVSessionControllerStubTest, HandleSetMetaFilter003, TestSize.Level1)
1407 {
1408 SLOGI("HandleSetMetaFilter003 begin!");
1409 AVSessionControllerStubDemo avSessionControllerStub;
1410 OHOS::MessageParcel data;
1411 OHOS::MessageParcel reply;
1412 data.WriteString("1010");
1413 int ret = avSessionControllerStub.HandleSetMetaFilter(data, reply);
1414 EXPECT_EQ(ret, OHOS::ERR_NONE);
1415 SLOGI("HandleSetMetaFilter003 end!");
1416 }
1417
1418 /**
1419 * @tc.name: HandleSetPlaybackFilter001
1420 * @tc.desc: Test HandleSetPlaybackFilter
1421 * @tc.type: FUNC
1422 */
1423 static HWTEST_F(AVSessionControllerStubTest, HandleSetPlaybackFilter001, TestSize.Level1)
1424 {
1425 SLOGI("HandleSetPlaybackFilter001 begin!");
1426 AVSessionControllerStubDemo avSessionControllerStub;
1427 OHOS::MessageParcel data;
1428 OHOS::MessageParcel reply;
1429 data.WriteString("1111111");
1430 int ret = avSessionControllerStub.HandleSetPlaybackFilter(data, reply);
1431 EXPECT_EQ(ret, OHOS::ERR_NONE);
1432 SLOGI("HandleSetPlaybackFilter001 end!");
1433 }
1434
1435 /**
1436 * @tc.name: HandleSetPlaybackFilter002
1437 * @tc.desc: Test HandleSetPlaybackFilter
1438 * @tc.type: FUNC
1439 */
1440 static HWTEST_F(AVSessionControllerStubTest, HandleSetPlaybackFilter002, TestSize.Level1)
1441 {
1442 SLOGI("HandleSetPlaybackFilter002 begin!");
1443 AVSessionControllerStubDemo avSessionControllerStub;
1444 OHOS::MessageParcel data;
1445 OHOS::MessageParcel reply;
1446 data.WriteString("2222");
1447 int ret = avSessionControllerStub.HandleSetPlaybackFilter(data, reply);
1448 EXPECT_EQ(ret, OHOS::ERR_NONE);
1449 SLOGI("HandleSetPlaybackFilter002 end!");
1450 }
1451
1452 /**
1453 * @tc.name: HandleSetPlaybackFilter003
1454 * @tc.desc: Test HandleSetPlaybackFilter
1455 * @tc.type: FUNC
1456 */
1457 static HWTEST_F(AVSessionControllerStubTest, HandleSetPlaybackFilter003, TestSize.Level1)
1458 {
1459 SLOGI("HandleSetPlaybackFilter003 begin!");
1460 AVSessionControllerStubDemo avSessionControllerStub;
1461 OHOS::MessageParcel data;
1462 OHOS::MessageParcel reply;
1463 data.WriteString("1010");
1464 int ret = avSessionControllerStub.HandleSetPlaybackFilter(data, reply);
1465 EXPECT_EQ(ret, OHOS::ERR_NONE);
1466 SLOGI("HandleSetPlaybackFilter003 end!");
1467 }
1468