1 /*
2 * Copyright (c) 2023 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 <gmock/gmock.h>
18 #include "ipc_stream_in_server.h"
19 #include <memory>
20 #include "ipc_stream_stub.h"
21 #include "audio_info.h"
22 #include "audio_process_config.h"
23 #include "renderer_in_server.h"
24 #include "capturer_in_server.h"
25 #include <cinttypes>
26 #include "audio_service_log.h"
27 #include "audio_errors.h"
28 #include "ipc_stream.h"
29 #include "message_parcel.h"
30 #include "parcel.h"
31
32 using namespace testing::ext;
33
34 namespace OHOS {
35 namespace AudioStandard {
36 class IpcStreamStubUnitTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
44 class RemoteObjectTestStub : public IRemoteObject {
45 public:
RemoteObjectTestStub()46 RemoteObjectTestStub() : IRemoteObject(u"IRemoteObject") {}
GetObjectRefCount()47 int32_t GetObjectRefCount() { return 0; };
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)48 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) { return 0; };
AddDeathRecipient(const sptr<DeathRecipient> & recipient)49 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)50 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) { return true; };
Dump(int fd,const std::vector<std::u16string> & args)51 int Dump(int fd, const std::vector<std::u16string> &args) { return 0; };
52
53 DECLARE_INTERFACE_DESCRIPTOR(u"RemoteObjectTestStub");
54 };
55
SetUpTestCase(void)56 void IpcStreamStubUnitTest::SetUpTestCase(void)
57 {
58 // input testsuit setup step，setup invoked before all testcases
59 }
60
TearDownTestCase(void)61 void IpcStreamStubUnitTest::TearDownTestCase(void)
62 {
63 // input testsuit teardown step，teardown invoked after all testcases
64 }
65
SetUp(void)66 void IpcStreamStubUnitTest::SetUp(void)
67 {
68 // input testcase setup step，setup invoked before each testcases
69 }
70
TearDown(void)71 void IpcStreamStubUnitTest::TearDown(void)
72 {
73 // input testcase teardown step，teardown invoked after each testcases
74 }
75
76 constexpr int32_t DEFAULT_STREAM_ID = 10;
77
InitProcessConfig()78 static AudioProcessConfig InitProcessConfig()
79 {
80 AudioProcessConfig config;
81 config.appInfo.appUid = DEFAULT_STREAM_ID;
82 config.appInfo.appPid = DEFAULT_STREAM_ID;
83 config.streamInfo.format = SAMPLE_S32LE;
84 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
85 config.streamInfo.channels = STEREO;
86 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
87 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
88 config.streamType = AudioStreamType::STREAM_MUSIC;
89 config.deviceType = DEVICE_TYPE_USB_HEADSET;
90 return config;
91 }
92
93 /**
94 * @tc.name : Test IpcStreamStub API
95 * @tc.type : FUNC
96 * @tc.number: IpcStreamStub_001
97 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
98 */
99 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_001, TestSize.Level1)
100 {
101 AudioProcessConfig config = InitProcessConfig();
102 int32_t ret = 0;
103 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
104
105 EXPECT_NE(ptrIpcStreamStub, nullptr);
106
107 MessageParcel data;
108 MessageParcel reply;
109 MessageOption option;
110
111 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_RATE,
112 data, reply, option);
113 EXPECT_EQ(result, AUDIO_OK);
114 }
115
116 /**
117 * @tc.name : Test IpcStreamStub API
118 * @tc.type : FUNC
119 * @tc.number: IpcStreamStub_002
120 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
121 */
122 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_002, TestSize.Level1)
123 {
124 AudioProcessConfig config = InitProcessConfig();
125 int32_t ret = 0;
126 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
127
128 EXPECT_NE(ptrIpcStreamStub, nullptr);
129
130 MessageParcel data;
131 MessageParcel reply;
132 MessageOption option;
133
134 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_LOWPOWER_VOLUME,
135 data, reply, option);
136 EXPECT_EQ(result, AUDIO_OK);
137 }
138
139 /**
140 * @tc.name : Test IpcStreamStub API
141 * @tc.type : FUNC
142 * @tc.number: IpcStreamStub_003
143 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
144 */
145 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_003, TestSize.Level1)
146 {
147 AudioProcessConfig config = InitProcessConfig();
148 int32_t ret = 0;
149 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
150
151 EXPECT_NE(ptrIpcStreamStub, nullptr);
152
153 MessageParcel data;
154 MessageParcel reply;
155 MessageOption option;
156
157 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_LOWPOWER_VOLUME,
158 data, reply, option);
159 EXPECT_EQ(result, AUDIO_OK);
160 }
161
162 /**
163 * @tc.name : Test IpcStreamStub API
164 * @tc.type : FUNC
165 * @tc.number: IpcStreamStub_004
166 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
167 */
168 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_004, TestSize.Level1)
169 {
170 AudioProcessConfig config = InitProcessConfig();
171 int32_t ret = 0;
172 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
173
174 EXPECT_NE(ptrIpcStreamStub, nullptr);
175
176 MessageParcel data;
177 MessageParcel reply;
178 MessageOption option;
179
180 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_EFFECT_MODE,
181 data, reply, option);
182 EXPECT_EQ(result, AUDIO_OK);
183 }
184
185 /**
186 * @tc.name : Test IpcStreamStub API
187 * @tc.type : FUNC
188 * @tc.number: IpcStreamStub_005
189 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
190 */
191 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_005, TestSize.Level1)
192 {
193 AudioProcessConfig config = InitProcessConfig();
194 int32_t ret = 0;
195 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
196
197 EXPECT_NE(ptrIpcStreamStub, nullptr);
198
199 MessageParcel data;
200 MessageParcel reply;
201 MessageOption option;
202
203 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_EFFECT_MODE,
204 data, reply, option);
205 EXPECT_EQ(result, AUDIO_OK);
206 }
207
208 /**
209 * @tc.name : Test IpcStreamStub API
210 * @tc.type : FUNC
211 * @tc.number: IpcStreamStub_006
212 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
213 */
214 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_006, TestSize.Level1)
215 {
216 AudioProcessConfig config = InitProcessConfig();
217 int32_t ret = 0;
218 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
219
220 EXPECT_NE(ptrIpcStreamStub, nullptr);
221
222 MessageParcel data;
223 MessageParcel reply;
224 MessageOption option;
225
226 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_PRIVACY_TYPE,
227 data, reply, option);
228 EXPECT_EQ(result, AUDIO_OK);
229 }
230
231 /**
232 * @tc.name : Test IpcStreamStub API
233 * @tc.type : FUNC
234 * @tc.number: IpcStreamStub_007
235 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
236 */
237 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_007, TestSize.Level1)
238 {
239 AudioProcessConfig config = InitProcessConfig();
240 int32_t ret = 0;
241 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
242
243 EXPECT_NE(ptrIpcStreamStub, nullptr);
244
245 MessageParcel data;
246 MessageParcel reply;
247 MessageOption option;
248
249 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_PRIVACY_TYPE,
250 data, reply, option);
251 EXPECT_EQ(result, AUDIO_OK);
252 }
253
254 /**
255 * @tc.name : Test IpcStreamStub API
256 * @tc.type : FUNC
257 * @tc.number: IpcStreamStub_008
258 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
259 */
260 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_008, TestSize.Level1)
261 {
262 AudioProcessConfig config = InitProcessConfig();
263 int32_t ret = 0;
264 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
265
266 EXPECT_NE(ptrIpcStreamStub, nullptr);
267
268 MessageParcel data;
269 MessageParcel reply;
270 MessageOption option;
271
272 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_OFFLOAD_MODE,
273 data, reply, option);
274 EXPECT_EQ(result, AUDIO_OK);
275 }
276
277 /**
278 * @tc.name : Test IpcStreamStub API
279 * @tc.type : FUNC
280 * @tc.number: IpcStreamStub_009
281 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
282 */
283 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_009, TestSize.Level1)
284 {
285 AudioProcessConfig config = InitProcessConfig();
286 int32_t ret = 0;
287 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
288
289 EXPECT_NE(ptrIpcStreamStub, nullptr);
290
291 MessageParcel data;
292 MessageParcel reply;
293 MessageOption option;
294
295 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_UNSET_OFFLOAD_MODE,
296 data, reply, option);
297 EXPECT_EQ(result, AUDIO_OK);
298 }
299
300 /**
301 * @tc.name : Test IpcStreamStub API
302 * @tc.type : FUNC
303 * @tc.number: IpcStreamStub_010
304 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
305 */
306 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_010, TestSize.Level1)
307 {
308 AudioProcessConfig config = InitProcessConfig();
309 int32_t ret = 0;
310 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
311
312 EXPECT_NE(ptrIpcStreamStub, nullptr);
313
314 MessageParcel data;
315 MessageParcel reply;
316 MessageOption option;
317
318 auto result = ptrIpcStreamStub->
319 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_OFFLOAD_APPROXIMATELY_CACHE_TIME,
320 data, reply, option);
321 EXPECT_EQ(result, AUDIO_OK);
322 }
323
324 /**
325 * @tc.name : Test IpcStreamStub API
326 * @tc.type : FUNC
327 * @tc.number: IpcStreamStub_012
328 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
329 */
330 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_012, TestSize.Level1)
331 {
332 AudioProcessConfig config = InitProcessConfig();
333 int32_t ret = 0;
334 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
335
336 EXPECT_NE(ptrIpcStreamStub, nullptr);
337
338 MessageParcel data;
339 MessageParcel reply;
340 MessageOption option;
341
342 auto result = ptrIpcStreamStub->
343 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_UPDATE_SPATIALIZATION_STATE,
344 data, reply, option);
345 EXPECT_EQ(result, AUDIO_OK);
346 }
347
348 /**
349 * @tc.name : Test IpcStreamStub API
350 * @tc.type : FUNC
351 * @tc.number: IpcStreamStub_013
352 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
353 */
354 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_013, TestSize.Level1)
355 {
356 AudioProcessConfig config = InitProcessConfig();
357 int32_t ret = 0;
358 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
359
360 EXPECT_NE(ptrIpcStreamStub, nullptr);
361
362 MessageParcel data;
363 MessageParcel reply;
364 MessageOption option;
365
366 auto result = ptrIpcStreamStub->
367 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_STREAM_MANAGER_TYPE,
368 data, reply, option);
369 EXPECT_EQ(result, AUDIO_OK);
370 }
371
372 /**
373 * @tc.name : Test IpcStreamStub API
374 * @tc.type : FUNC
375 * @tc.number: IpcStreamStub_014
376 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
377 */
378 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_014, TestSize.Level1)
379 {
380 AudioProcessConfig config = InitProcessConfig();
381 int32_t ret = 0;
382 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
383
384 EXPECT_NE(ptrIpcStreamStub, nullptr);
385
386 MessageParcel data;
387 MessageParcel reply;
388 MessageOption option;
389
390 auto result = ptrIpcStreamStub->
391 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_SILENT_MODE_AND_MIX_WITH_OTHERS,
392 data, reply, option);
393 EXPECT_EQ(result, AUDIO_OK);
394 }
395
396 /**
397 * @tc.name : Test IpcStreamStub API
398 * @tc.type : FUNC
399 * @tc.number: IpcStreamStub_015
400 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
401 */
402 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_015, TestSize.Level1)
403 {
404 AudioProcessConfig config = InitProcessConfig();
405 int32_t ret = 0;
406 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
407
408 EXPECT_NE(ptrIpcStreamStub, nullptr);
409
410 MessageParcel data;
411 MessageParcel reply;
412 MessageOption option;
413
414 auto result = ptrIpcStreamStub->
415 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_CLIENT_VOLUME,
416 data, reply, option);
417 EXPECT_EQ(result, AUDIO_OK);
418 }
419
420 /**
421 * @tc.name : Test IpcStreamStub API
422 * @tc.type : FUNC
423 * @tc.number: IpcStreamStub_016
424 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
425 */
426 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_016, TestSize.Level1)
427 {
428 AudioProcessConfig config = InitProcessConfig();
429 int32_t ret = 0;
430 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
431
432 EXPECT_NE(ptrIpcStreamStub, nullptr);
433
434 MessageParcel data;
435 MessageParcel reply;
436 MessageOption option;
437
438 auto result = ptrIpcStreamStub->
439 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_MUTE,
440 data, reply, option);
441 EXPECT_EQ(result, AUDIO_OK);
442 }
443
444 /**
445 * @tc.name : Test IpcStreamStub API
446 * @tc.type : FUNC
447 * @tc.number: IpcStreamStub_017
448 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
449 */
450 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_017, TestSize.Level1)
451 {
452 AudioProcessConfig config = InitProcessConfig();
453 int32_t ret = 0;
454 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
455
456 EXPECT_NE(ptrIpcStreamStub, nullptr);
457
458 MessageParcel data;
459 MessageParcel reply;
460 MessageOption option;
461
462 auto result = ptrIpcStreamStub->
463 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_REGISTER_THREAD_PRIORITY,
464 data, reply, option);
465 EXPECT_EQ(result, AUDIO_OK);
466 }
467
468 /**
469 * @tc.name : Test IpcStreamStub API
470 * @tc.type : FUNC
471 * @tc.number: IpcStreamStub_018
472 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
473 */
474 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_018, TestSize.Level1)
475 {
476 AudioProcessConfig config = InitProcessConfig();
477 int32_t ret = 0;
478 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
479
480 EXPECT_NE(ptrIpcStreamStub, nullptr);
481
482 MessageParcel data;
483 MessageParcel reply;
484 MessageOption option;
485
486 auto result = ptrIpcStreamStub->
487 OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::IPC_STREAM_MAX_MSG,
488 data, reply, option);
489 EXPECT_NE(result, AUDIO_OK);
490 }
491
492 /**
493 * @tc.name : Test IpcStreamStub API
494 * @tc.type : FUNC
495 * @tc.number: IpcStreamStub_019
496 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
497 */
498 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_019, TestSize.Level1)
499 {
500 AudioProcessConfig config = InitProcessConfig();
501 int32_t ret = 0;
502 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
503
504 EXPECT_NE(ptrIpcStreamStub, nullptr);
505
506 MessageParcel data;
507 MessageParcel reply;
508 MessageOption option;
509
510 auto result = ptrIpcStreamStub->
511 OnRemoteRequest(IpcStream::IpcStreamMsg::IPC_STREAM_MAX_MSG,
512 data, reply, option);
513 EXPECT_NE(result, AUDIO_OK);
514 }
515
516 /**
517 * @tc.name : Test IpcStreamStub API
518 * @tc.type : FUNC
519 * @tc.number: IpcStreamStub_020
520 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
521 */
522 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_020, TestSize.Level1)
523 {
524 AudioProcessConfig config = InitProcessConfig();
525 int32_t ret = 0;
526 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
527
528 EXPECT_NE(ptrIpcStreamStub, nullptr);
529
530 MessageParcel data;
531 MessageParcel reply;
532 MessageOption option;
533
534 auto result = ptrIpcStreamStub->
535 OnRemoteRequest(IpcStream::IpcStreamMsg::ON_UPDATE_POSITION,
536 data, reply, option);
537 EXPECT_NE(result, AUDIO_OK);
538 }
539
540 /**
541 * @tc.name : Test IpcStreamStub API
542 * @tc.type : FUNC
543 * @tc.number: IpcStreamStub_021
544 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
545 */
546 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_021, TestSize.Level1)
547 {
548 AudioProcessConfig config = InitProcessConfig();
549 int32_t ret = 0;
550 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
551
552 EXPECT_NE(ptrIpcStreamStub, nullptr);
553
554 MessageParcel data;
555 MessageParcel reply;
556 MessageOption option;
557
558 auto result = ptrIpcStreamStub->
559 OnRemoteRequest(IpcStream::IpcStreamMsg::OH_GET_AUDIO_TIME,
560 data, reply, option);
561 EXPECT_NE(result, AUDIO_OK);
562 }
563
564 /**
565 * @tc.name : Test IpcStreamStub API
566 * @tc.type : FUNC
567 * @tc.number: IpcStreamStub_022
568 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
569 */
570 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_022, TestSize.Level1)
571 {
572 AudioProcessConfig config = InitProcessConfig();
573 int32_t ret = 0;
574 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
575
576 EXPECT_NE(ptrIpcStreamStub, nullptr);
577
578 MessageParcel data;
579 MessageParcel reply;
580 MessageOption option;
581
582 auto result = ptrIpcStreamStub->
583 OnRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_LATENCY,
584 data, reply, option);
585 EXPECT_NE(result, AUDIO_OK);
586 }
587
588 /**
589 * @tc.name : Test IpcStreamStub API
590 * @tc.type : FUNC
591 * @tc.number: IpcStreamStub_023
592 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
593 */
594 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_023, TestSize.Level1)
595 {
596 AudioProcessConfig config = InitProcessConfig();
597 int32_t ret = 0;
598 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
599
600 EXPECT_NE(ptrIpcStreamStub, nullptr);
601
602 MessageParcel data;
603 MessageParcel reply;
604 MessageOption option;
605
606 auto result = ptrIpcStreamStub->
607 OnRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_RATE,
608 data, reply, option);
609 EXPECT_NE(result, AUDIO_OK);
610 }
611
612 /**
613 * @tc.name : Test IpcStreamStub API
614 * @tc.type : FUNC
615 * @tc.number: IpcStreamStub_024
616 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
617 */
618 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_024, TestSize.Level1)
619 {
620 AudioProcessConfig config = InitProcessConfig();
621 int32_t ret = 0;
622 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
623
624 EXPECT_NE(ptrIpcStreamStub, nullptr);
625
626 MessageParcel data;
627 MessageParcel reply;
628 MessageOption option;
629
630 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_DUCK_FACTOR,
631 data, reply, option);
632 EXPECT_EQ(result, AUDIO_OK);
633 }
634
635 /**
636 * @tc.name : Test IpcStreamStub API
637 * @tc.type : FUNC
638 * @tc.number: IpcStreamStub_025
639 * @tc.desc : Test IpcStreamStub::OnMiddleCodeRemoteRequest.
640 */
641 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_025, TestSize.Level1)
642 {
643 AudioProcessConfig config = InitProcessConfig();
644 int32_t ret = 0;
645 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
646
647 EXPECT_NE(ptrIpcStreamStub, nullptr);
648
649 MessageParcel data;
650 MessageParcel reply;
651 MessageOption option;
652
653 auto result = ptrIpcStreamStub->OnMiddleCodeRemoteRequest(IpcStream::IpcStreamMsg::ON_SET_DEFAULT_OUTPUT_DEVICE,
654 data, reply, option);
655 EXPECT_EQ(result, AUDIO_OK);
656 }
657
658 /**
659 * @tc.name : Test IpcStreamStub API
660 * @tc.type : FUNC
661 * @tc.number: IpcStreamStub_026
662 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
663 */
664 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_026, TestSize.Level1)
665 {
666 AudioProcessConfig config = InitProcessConfig();
667 int32_t ret = 0;
668 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
669
670 EXPECT_NE(ptrIpcStreamStub, nullptr);
671
672 MessageParcel data;
673 MessageParcel reply;
674 MessageOption option;
675
676 auto result = ptrIpcStreamStub->
677 OnRemoteRequest(IpcStream::IpcStreamMsg::ON_REGISTER_STREAM_LISTENER,
678 data, reply, option);
679 EXPECT_NE(result, AUDIO_OK);
680
681 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_RESOLVE_BUFFER,
682 data, reply, option);
683 EXPECT_NE(result, AUDIO_OK);
684
685 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_GET_AUDIO_SESSIONID,
686 data, reply, option);
687 EXPECT_NE(result, AUDIO_OK);
688
689 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_START,
690 data, reply, option);
691 EXPECT_NE(result, AUDIO_OK);
692
693 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_STOP,
694 data, reply, option);
695 EXPECT_NE(result, AUDIO_OK);
696
697 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_RELEASE,
698 data, reply, option);
699 EXPECT_NE(result, AUDIO_OK);
700
701 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_FLUSH,
702 data, reply, option);
703 EXPECT_NE(result, AUDIO_OK);
704 }
705
706 /**
707 * @tc.name : Test IpcStreamStub API
708 * @tc.type : FUNC
709 * @tc.number: IpcStreamStub_027
710 * @tc.desc : Test IpcStreamStub::OnRemoteRequest.
711 */
712 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_027, TestSize.Level1)
713 {
714 AudioProcessConfig config = InitProcessConfig();
715 int32_t ret = 0;
716 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
717
718 EXPECT_NE(ptrIpcStreamStub, nullptr);
719
720 MessageParcel data;
721 MessageParcel reply;
722 MessageOption option;
723
724 auto result = ptrIpcStreamStub->
725 OnRemoteRequest(IpcStream::IpcStreamMsg::ON_DRAIN,
726 data, reply, option);
727 EXPECT_NE(result, AUDIO_OK);
728
729 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::ON_UPDATA_PLAYBACK_CAPTURER_CONFIG,
730 data, reply, option);
731 EXPECT_NE(result, AUDIO_OK);
732
733 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::OH_GET_AUDIO_POSITION,
734 data, reply, option);
735 EXPECT_NE(result, AUDIO_OK);
736
737 result = ptrIpcStreamStub->OnRemoteRequest(IpcStream::IpcStreamMsg::OH_GET_AUDIO_POSITION,
738 data, reply, option);
739 EXPECT_NE(result, AUDIO_OK);
740 }
741
742 /**
743 * @tc.name : Test IpcStreamStub API
744 * @tc.type : FUNC
745 * @tc.number: IpcStreamStub_028
746 * @tc.desc : Test IpcStreamStub::HandleRegisterStreamListener.
747 */
748 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_028, TestSize.Level1)
749 {
750 AudioProcessConfig config = InitProcessConfig();
751 int32_t ret = 0;
752 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
753 ASSERT_TRUE(ptrIpcStreamStub != nullptr);
754
755 MessageParcel data;
756 MessageParcel reply;
757
758 auto result = ptrIpcStreamStub->HandleRegisterStreamListener(data, reply);
759 EXPECT_EQ(result, AUDIO_INVALID_PARAM);
760
761 sptr<IRemoteObject> impl = new RemoteObjectTestStub();
762 data.WriteRemoteObject(impl);
763 result = ptrIpcStreamStub->HandleRegisterStreamListener(data, reply);
764 EXPECT_EQ(result, AUDIO_OK);
765 }
766
767 /**
768 * @tc.name : Test IpcStreamStub API
769 * @tc.type : FUNC
770 * @tc.number: IpcStreamStub_029
771 * @tc.desc : Test IpcStreamStub::HandleResolveBuffer.
772 */
773 HWTEST(IpcStreamStubUnitTest, IpcStreamStub_029, TestSize.Level1)
774 {
775 AudioProcessConfig config = InitProcessConfig();
776 int32_t ret = 0;
777 sptr<IpcStreamInServer> ptrIpcStreamStub = IpcStreamInServer::Create(config, ret);
778 ASSERT_TRUE(ptrIpcStreamStub != nullptr);
779
780 MessageParcel data;
781 MessageParcel reply;
782
783 auto result = ptrIpcStreamStub->HandleResolveBuffer(data, reply);
784 EXPECT_EQ(result, AUDIO_OK);
785 }
786 } // namespace AudioStandard
787 } // namespace OHOS