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 "iipc_stream.h"
29 #include "message_parcel.h"
30 #include "parcel.h"
31 #include "audio_stream_enum.h"
32
33 using namespace testing::ext;
34
35 namespace OHOS {
36 namespace AudioStandard {
37 class IpcStreamInServerUnitTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void IpcStreamInServerUnitTest::SetUpTestCase(void)
46 {
47 // input testsuit setup step，setup invoked before all testcases
48 }
49
TearDownTestCase(void)50 void IpcStreamInServerUnitTest::TearDownTestCase(void)
51 {
52 // input testsuit teardown step，teardown invoked after all testcases
53 }
54
SetUp(void)55 void IpcStreamInServerUnitTest::SetUp(void)
56 {
57 // input testcase setup step，setup invoked before each testcases
58 }
59
TearDown(void)60 void IpcStreamInServerUnitTest::TearDown(void)
61 {
62 // input testcase teardown step，teardown invoked after each testcases
63 }
64
65 /**
66 * @tc.name : Test IpcStreamInServer API
67 * @tc.type : FUNC
68 * @tc.number: IpcStreamInServer_001
69 * @tc.desc : Test IpcStreamInServer interface.
70 */
71 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_001, TestSize.Level1)
72 {
73 AudioProcessConfig configRet;
74 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
75 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
76 auto ret = ipcStreamInServerRet.GetCapturer();
77 EXPECT_EQ(ret, nullptr);
78 }
79
80 /**
81 * @tc.name : Test IpcStreamInServer API
82 * @tc.type : FUNC
83 * @tc.number: IpcStreamInServer_002
84 * @tc.desc : Test IpcStreamInServer interface.
85 */
86 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_002, TestSize.Level1)
87 {
88 AudioProcessConfig configRet;
89 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
90 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
91 std::shared_ptr<OHAudioBuffer> buffer;
92 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
93 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
94 }
95
96 /**
97 * @tc.name : Test IpcStreamInServer API
98 * @tc.type : FUNC
99 * @tc.number: IpcStreamInServer_003
100 * @tc.desc : Test IpcStreamInServer interface.
101 */
102 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_003, TestSize.Level1)
103 {
104 AudioProcessConfig configRet;
105 AudioMode modeRet = AUDIO_MODE_RECORD;
106 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
107
108 auto ret1 = ipcStreamInServerRet.UpdatePosition();
109 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
110
111 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
112 ret1 = ipcStreamInServerRet.UpdatePosition();
113 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
114
115 ipcStreamInServerRet.ConfigCapturer();
116 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
117 ret1 = ipcStreamInServerRet.UpdatePosition();
118 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
119 }
120
121 /**
122 * @tc.name : Test IpcStreamInServer API
123 * @tc.type : FUNC
124 * @tc.number: IpcStreamInServer_004
125 * @tc.desc : Test IpcStreamInServer interface.
126 */
127 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_004, TestSize.Level1)
128 {
129 AudioProcessConfig configRet;
130 AudioMode modeRet = AUDIO_MODE_RECORD;
131 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
132
133 auto ret1 = ipcStreamInServerRet.Config();
134 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
135 EXPECT_EQ(ipcStreamInServerRet.mode_, AUDIO_MODE_RECORD);
136 }
137
138 /**
139 * @tc.name : Test IpcStreamInServer API
140 * @tc.type : FUNC
141 * @tc.number: IpcStreamInServer_005
142 * @tc.desc : Test IpcStreamInServer interface.
143 */
144 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_005, TestSize.Level1)
145 {
146 AudioProcessConfig configRet;
147 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
148 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
149 uint32_t sessionIdRet;
150 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
151 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
152
153 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
154 ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
155 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
156
157 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
158 ipcStreamInServerRet.ConfigCapturer();
159 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
160 ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
161 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
162 }
163
164 /**
165 * @tc.name : Test IpcStreamInServer API
166 * @tc.type : FUNC
167 * @tc.number: IpcStreamInServer_006
168 * @tc.desc : Test IpcStreamInServer interface.
169 */
170 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_006, TestSize.Level1)
171 {
172 AudioProcessConfig configRet;
173 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
174 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
175 auto ret = ipcStreamInServerRet.Start();
176 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
177
178 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
179 ret = ipcStreamInServerRet.Start();
180 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
181
182 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
183 ipcStreamInServerRet.ConfigCapturer();
184 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
185 ret = ipcStreamInServerRet.Start();
186 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
187 }
188
189 /**
190 * @tc.name : Test IpcStreamInServer API
191 * @tc.type : FUNC
192 * @tc.number: IpcStreamInServer_007
193 * @tc.desc : Test IpcStreamInServer interface.
194 */
195 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_007, TestSize.Level1)
196 {
197 AudioProcessConfig configRet;
198 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
199 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
200
201 auto ret = ipcStreamInServerRet.Pause();
202 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
203
204 ret = ipcStreamInServerRet.Stop();
205 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
206 }
207
208 /**
209 * @tc.name : Test IpcStreamInServer API
210 * @tc.type : FUNC
211 * @tc.number: IpcStreamInServer_008
212 * @tc.desc : Test IpcStreamInServer interface.
213 */
214 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_008, TestSize.Level1)
215 {
216 AudioProcessConfig configRet;
217 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
218 IpcStreamInServer ipcStreamInServerRet1(configRet, modeRet);
219 uint64_t framePosRet = 0;
220 uint64_t timestampRet = 0;
221 uint64_t latency = 0;
222 auto ret1 = ipcStreamInServerRet1.GetAudioPosition(framePosRet, timestampRet, latency, Timestamp::MONOTONIC);
223 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
224
225 modeRet = AUDIO_MODE_RECORD;
226 IpcStreamInServer ipcStreamInServerRet2(configRet, modeRet);
227 ipcStreamInServerRet2.rendererInServer_ = std::make_shared<RendererInServer>(
228 ipcStreamInServerRet2.config_,
229 ipcStreamInServerRet2.streamListenerHolder_);
230 auto ret2 = ipcStreamInServerRet1.GetAudioPosition(framePosRet, timestampRet, latency, Timestamp::MONOTONIC);
231 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
232 }
233
234 /**
235 * @tc.name : Test IpcStreamInServer API
236 * @tc.type : FUNC
237 * @tc.number: IpcStreamInServer_009
238 * @tc.desc : Test IpcStreamInServer interface.
239 */
240 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_009, TestSize.Level1)
241 {
242 AudioProcessConfig configRet;
243 AudioMode modeRet = AUDIO_MODE_RECORD;
244 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
245 uint64_t latency;
246
247 auto ret = ipcStreamInServerRet.GetLatency(latency);
248 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
249
250 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
251 ret = ipcStreamInServerRet.GetLatency(latency);
252 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
253 ipcStreamInServerRet.ConfigCapturer();
254 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
255 ret = ipcStreamInServerRet.GetLatency(latency);
256 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
257 }
258
259 /**
260 * @tc.name : Test IpcStreamInServer API
261 * @tc.type : FUNC
262 * @tc.number: IpcStreamInServer_010
263 * @tc.desc : Test IpcStreamInServer interface.
264 */
265 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_010, TestSize.Level1)
266 {
267 AudioProcessConfig configRet;
268 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
269 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
270 float volumeRet = 0.5;
271
272 auto ret1 = ipcStreamInServerRet.SetLowPowerVolume(volumeRet);
273 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
274
275 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
276 ipcStreamInServerRet.ConfigRenderer();
277 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
278 auto ret2 = ipcStreamInServerRet.SetLowPowerVolume(volumeRet);
279 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
280 }
281
282 /**
283 * @tc.name : Test IpcStreamInServer API
284 * @tc.type : FUNC
285 * @tc.number: IpcStreamInServer_011
286 * @tc.desc : Test IpcStreamInServer interface.
287 */
288 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_011, TestSize.Level1)
289 {
290 AudioProcessConfig configRet;
291 AudioMode modeRet = AUDIO_MODE_RECORD;
292 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
293 float volumeRet = 0.5;
294
295 auto ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
296 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
297
298 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
299 ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
300 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
301
302 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
303 ipcStreamInServerRet.ConfigRenderer();
304 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
305 ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
306 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
307 }
308
309 /**
310 * @tc.name : Test IpcStreamInServer API
311 * @tc.type : FUNC
312 * @tc.number: IpcStreamInServer_012
313 * @tc.desc : Test IpcStreamInServer interface.
314 */
315 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_012, TestSize.Level1)
316 {
317 AudioProcessConfig configRet;
318 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
319 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
320
321 auto ret1 = ipcStreamInServerRet.SetAudioEffectMode(EFFECT_NONE);
322 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
323
324 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
325 ipcStreamInServerRet.ConfigRenderer();
326 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
327 auto ret2 = ipcStreamInServerRet.SetAudioEffectMode(EFFECT_NONE);
328 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
329 }
330
331 /**
332 * @tc.name : Test IpcStreamInServer API
333 * @tc.type : FUNC
334 * @tc.number: IpcStreamInServer_013
335 * @tc.desc : Test IpcStreamInServer interface.
336 */
337 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_013, TestSize.Level1)
338 {
339 AudioProcessConfig configRet;
340 AudioMode modeRet = AUDIO_MODE_RECORD;
341 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
342 int32_t effectModeRet = EFFECT_NONE;
343
344 auto ret1 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
345 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
346
347 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
348 auto ret2 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
349 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
350
351 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
352 ipcStreamInServerRet.ConfigRenderer();
353 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
354 auto ret3 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
355 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
356 }
357
358 /**
359 * @tc.name : Test IpcStreamInServer API
360 * @tc.type : FUNC
361 * @tc.number: IpcStreamInServer_014
362 * @tc.desc : Test IpcStreamInServer interface.
363 */
364 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_014, TestSize.Level1)
365 {
366 AudioProcessConfig configRet;
367 AudioMode modeRet = AUDIO_MODE_RECORD;
368 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
369 int32_t privacyTypeRet = EFFECT_NONE;
370
371 auto ret1 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
372 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
373
374 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
375 auto ret2 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
376 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
377
378 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
379 ipcStreamInServerRet.ConfigRenderer();
380 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
381 auto ret3 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
382 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
383 }
384
385 /**
386 * @tc.name : Test IpcStreamInServer API
387 * @tc.type : FUNC
388 * @tc.number: IpcStreamInServer_015
389 * @tc.desc : Test IpcStreamInServer interface.
390 */
391 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_015, TestSize.Level1)
392 {
393 AudioProcessConfig configRet;
394 AudioMode modeRet = AUDIO_MODE_RECORD;
395 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
396 int32_t privacyTypeRet = EFFECT_NONE;
397
398 auto ret1 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
399 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
400
401 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
402 auto ret2 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
403 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
404
405 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
406 ipcStreamInServerRet.ConfigRenderer();
407 auto ret3 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
408 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
409 }
410
411 /**
412 * @tc.name : Test IpcStreamInServer API
413 * @tc.type : FUNC
414 * @tc.number: IpcStreamInServer_016
415 * @tc.desc : Test IpcStreamInServer interface.
416 */
417 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_016, TestSize.Level1)
418 {
419 AudioProcessConfig configRet;
420 AudioMode modeRet = AUDIO_MODE_RECORD;
421 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
422 int32_t stateRet = EFFECT_NONE;
423 bool isAppBackRet = false;
424
425 auto ret1 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
426 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
427
428 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
429 auto ret2 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
430 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
431
432 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
433 ipcStreamInServerRet.ConfigRenderer();
434 auto ret3 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
435 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
436 }
437
438 /**
439 * @tc.name : Test IpcStreamInServer API
440 * @tc.type : FUNC
441 * @tc.number: IpcStreamInServer_017
442 * @tc.desc : Test IpcStreamInServer interface.
443 */
444 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_017, TestSize.Level1)
445 {
446 AudioProcessConfig configRet;
447 AudioMode modeRet = AUDIO_MODE_RECORD;
448 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
449
450 auto ret1 = ipcStreamInServerRet.UnsetOffloadMode();
451 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
452
453 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
454 auto ret2 = ipcStreamInServerRet.UnsetOffloadMode();
455 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
456
457 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
458 ipcStreamInServerRet.ConfigRenderer();
459 auto ret3 = ipcStreamInServerRet.UnsetOffloadMode();
460 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
461 }
462
463 /**
464 * @tc.name : Test IpcStreamInServer API
465 * @tc.type : FUNC
466 * @tc.number: IpcStreamInServer_018
467 * @tc.desc : Test IpcStreamInServer interface.
468 */
469 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_018, TestSize.Level1)
470 {
471 AudioProcessConfig configRet;
472 AudioMode modeRet = AUDIO_MODE_RECORD;
473 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
474 uint64_t timestampRet = EFFECT_NONE;
475 uint64_t paWriteIndexRet = EFFECT_NONE;
476 uint64_t cacheTimeDspRet = EFFECT_NONE;
477 uint64_t cacheTimePaRet = EFFECT_NONE;
478
479 auto ret1 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
480 cacheTimeDspRet, cacheTimePaRet);
481 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
482
483 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
484 auto ret2 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
485 cacheTimeDspRet, cacheTimePaRet);
486 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
487
488 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
489 ipcStreamInServerRet.ConfigRenderer();
490 auto ret3 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
491 cacheTimeDspRet, cacheTimePaRet);
492 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
493 }
494
495 /**
496 * @tc.name : Test IpcStreamInServer API
497 * @tc.type : FUNC
498 * @tc.number: IpcStreamInServer_020
499 * @tc.desc : Test IpcStreamInServer interface.
500 */
501 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_020, TestSize.Level1)
502 {
503 AudioProcessConfig configRet;
504 AudioMode modeRet = AUDIO_MODE_RECORD;
505 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
506 bool spatializationEnabledRet = false;
507 bool headTrackingEnabledRet = false;
508
509 auto ret1 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
510 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
511
512 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
513 auto ret2 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
514 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
515
516 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
517 ipcStreamInServerRet.ConfigRenderer();
518 auto ret3 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
519 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
520 }
521
522 /**
523 * @tc.name : Test IpcStreamInServer API
524 * @tc.type : FUNC
525 * @tc.number: IpcStreamInServer_021
526 * @tc.desc : Test IpcStreamInServer interface.
527 */
528 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_021, TestSize.Level1)
529 {
530 AudioProcessConfig configRet;
531 AudioMode modeRet = AUDIO_MODE_RECORD;
532 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
533
534 auto ret1 = ipcStreamInServerRet.GetStreamManagerType();
535 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
536
537 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
538 auto ret2 = ipcStreamInServerRet.GetStreamManagerType();
539 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
540
541 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
542 ipcStreamInServerRet.ConfigRenderer();
543 auto ret3 = ipcStreamInServerRet.GetStreamManagerType();
544 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
545 }
546
547 /**
548 * @tc.name : Test IpcStreamInServer API
549 * @tc.type : FUNC
550 * @tc.number: IpcStreamInServer_022
551 * @tc.desc : Test IpcStreamInServer interface.
552 */
553 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_022, TestSize.Level1)
554 {
555 AudioProcessConfig configRet;
556 AudioMode modeRet = AUDIO_MODE_RECORD;
557 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
558 bool onRet = false;
559
560 auto ret1 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
561 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
562
563 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
564 auto ret2 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
565 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
566
567 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
568 ipcStreamInServerRet.ConfigRenderer();
569 auto ret3 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
570 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
571 }
572
573 /**
574 * @tc.name : Test IpcStreamInServer API
575 * @tc.type : FUNC
576 * @tc.number: IpcStreamInServer_023
577 * @tc.desc : Test IpcStreamInServer interface.
578 */
579 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_023, TestSize.Level1)
580 {
581 AudioProcessConfig configRet;
582 AudioMode modeRet = AUDIO_MODE_RECORD;
583 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
584
585 auto ret1 = ipcStreamInServerRet.SetClientVolume();
586 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
587
588 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
589 auto ret2 = ipcStreamInServerRet.SetClientVolume();
590 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
591
592 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
593 ipcStreamInServerRet.ConfigRenderer();
594 auto ret3 = ipcStreamInServerRet.SetClientVolume();
595 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
596 }
597
598 /**
599 * @tc.name : Test IpcStreamInServer API
600 * @tc.type : FUNC
601 * @tc.number: IpcStreamInServer_024
602 * @tc.desc : Test IpcStreamInServer interface.
603 */
604 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_024, TestSize.Level1)
605 {
606 AudioProcessConfig configRet;
607 AudioMode modeRet = AUDIO_MODE_RECORD;
608 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
609 pid_t tidRet = 0;
610 std::string clientBundleNameRet;
611
612 auto ret = ipcStreamInServerRet.RegisterThreadPriority(tidRet, clientBundleNameRet, METHOD_START);
613 EXPECT_EQ(ret, SUCCESS);
614 }
615
616 /**
617 * @tc.name : Test IpcStreamInServer API
618 * @tc.type : FUNC
619 * @tc.number: IpcStreamInServer_025
620 * @tc.desc : Test IpcStreamInServer interface.
621 */
622 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_025, TestSize.Level1)
623 {
624 AudioProcessConfig configRet;
625 AudioMode modeRet = AUDIO_MODE_RECORD;
626 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
627 int32_t rateRet = 0;
628 uint64_t famePosRet = 0;
629 uint64_t timestampRet = 0;
630 uint64_t latency = 0;
631
632 auto ret = ipcStreamInServerRet.SetRate(rateRet);
633 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
634 auto ret1 = ipcStreamInServerRet.GetAudioPosition(famePosRet, timestampRet, latency, Timestamp::MONOTONIC);
635 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
636
637 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
638 ret = ipcStreamInServerRet.SetRate(rateRet);
639 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
640
641 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
642 ipcStreamInServerRet.ConfigRenderer();
643 ret = ipcStreamInServerRet.SetRate(rateRet);
644 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
645 }
646
647 /**
648 * @tc.name : Test IpcStreamInServer API
649 * @tc.type : FUNC
650 * @tc.number: IpcStreamInServer_026
651 * @tc.desc : Test IpcStreamInServer interface.
652 */
653 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_026, TestSize.Level1)
654 {
655 AudioProcessConfig configRet;
656 AudioMode modeRet = AUDIO_MODE_RECORD;
657 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
658 uint64_t famePosRet = 0;
659 uint64_t timestampRet = 0;
660
661 auto ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
662 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
663
664 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
665 ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
666 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
667 ipcStreamInServerRet.ConfigCapturer();
668 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
669 ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
670 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
671 }
672
673 /**
674 * @tc.name : Test IpcStreamInServer API
675 * @tc.type : FUNC
676 * @tc.number: IpcStreamInServer_027
677 * @tc.desc : Test IpcStreamInServer interface.
678 */
679 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_027, TestSize.Level1)
680 {
681 AudioProcessConfig configRet;
682 AudioMode modeRet = AUDIO_MODE_RECORD;
683 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
684 AudioPlaybackCaptureConfig config;
685
686 auto ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
687 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
688
689 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
690 ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
691 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
692 ipcStreamInServerRet.ConfigCapturer();
693 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
694 ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
695 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
696 }
697
698 /**
699 * @tc.name : Test IpcStreamInServer API
700 * @tc.type : FUNC
701 * @tc.number: IpcStreamInServer_028
702 * @tc.desc : Test IpcStreamInServer interface.
703 */
704 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_028, TestSize.Level1)
705 {
706 AudioProcessConfig configRet;
707 AudioMode modeRet = AUDIO_MODE_RECORD;
708 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
709 bool stopFlagRet = false;
710
711 auto ret = ipcStreamInServerRet.Drain(stopFlagRet);
712 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
713
714 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
715 ret = ipcStreamInServerRet.Drain(stopFlagRet);
716 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
717
718 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
719 ipcStreamInServerRet.ConfigRenderer();
720 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
721 ret = ipcStreamInServerRet.Drain(stopFlagRet);
722 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
723 }
724
725 /**
726 * @tc.name : Test IpcStreamInServer API
727 * @tc.type : FUNC
728 * @tc.number: IpcStreamInServer_029
729 * @tc.desc : Test IpcStreamInServer interface.
730 */
731 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_029, TestSize.Level1)
732 {
733 AudioProcessConfig configRet;
734 AudioMode modeRet = AUDIO_MODE_RECORD;
735 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
736
737 auto ret = ipcStreamInServerRet.Flush();
738 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
739
740 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
741 ret = ipcStreamInServerRet.Flush();
742 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
743 ipcStreamInServerRet.ConfigCapturer();
744 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
745 ret = ipcStreamInServerRet.Flush();
746 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
747 }
748
749 /**
750 * @tc.name : Test IpcStreamInServer API
751 * @tc.type : FUNC
752 * @tc.number: IpcStreamInServer_030
753 * @tc.desc : Test IpcStreamInServer interface.
754 */
755 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_030, TestSize.Level1)
756 {
757 AudioProcessConfig configRet;
758 AudioMode modeRet = AUDIO_MODE_RECORD;
759 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
760
761 auto ret = ipcStreamInServerRet.Release(false);
762 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
763
764 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
765 ret = ipcStreamInServerRet.Release(false);
766 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
767
768 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
769 ipcStreamInServerRet.ConfigRenderer();
770 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
771 ret = ipcStreamInServerRet.Release(false);
772 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
773 }
774
775 /**
776 * @tc.name : Test IpcStreamInServer API
777 * @tc.type : FUNC
778 * @tc.number: IpcStreamInServer_031
779 * @tc.desc : Test IpcStreamInServer interface.
780 */
781 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_031, TestSize.Level1)
782 {
783 AudioProcessConfig configRet;
784 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
785 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
786
787 auto ret = ipcStreamInServerRet.Stop();
788 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
789
790 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
791 ret = ipcStreamInServerRet.Stop();
792 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
793
794 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
795 ipcStreamInServerRet.ConfigCapturer();
796 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
797 ret = ipcStreamInServerRet.Stop();
798 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
799 }
800
801 /**
802 * @tc.name : Test IpcStreamInServer API
803 * @tc.type : FUNC
804 * @tc.number: IpcStreamInServer_032
805 * @tc.desc : Test IpcStreamInServer interface.
806 */
807 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_032, TestSize.Level1)
808 {
809 AudioProcessConfig configRet;
810 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
811 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
812
813 auto ret = ipcStreamInServerRet.Pause();
814 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
815
816 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
817 ret = ipcStreamInServerRet.Pause();
818 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
819
820 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
821 ipcStreamInServerRet.ConfigCapturer();
822 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
823 ret = ipcStreamInServerRet.Pause();
824 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
825 }
826
827 /**
828 * @tc.name : Test IpcStreamInServer API
829 * @tc.type : FUNC
830 * @tc.number: IpcStreamInServer_033
831 * @tc.desc : Test IpcStreamInServer interface.
832 */
833 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_033, TestSize.Level1)
834 {
835 AudioProcessConfig configRet;
836 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
837 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
838 std::shared_ptr<OHAudioBuffer> buffer;
839
840 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
841 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
842
843 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
844 ret = ipcStreamInServerRet.ResolveBuffer(buffer);
845 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
846
847 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
848 ipcStreamInServerRet.ConfigCapturer();
849 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
850 ret = ipcStreamInServerRet.ResolveBuffer(buffer);
851 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
852 }
853
854 /**
855 * @tc.name : Test IpcStreamInServer API
856 * @tc.type : FUNC
857 * @tc.number: IpcStreamInServer_034
858 * @tc.desc : Test IpcStreamInServer interface.
859 */
860 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_034, TestSize.Level1)
861 {
862 AudioProcessConfig configRet;
863 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
864 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
865
866 auto ret = ipcStreamInServerRet.GetCapturer();
867 EXPECT_EQ(ret, nullptr);
868
869 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
870 ret = ipcStreamInServerRet.GetCapturer();
871 EXPECT_EQ(ret, nullptr);
872
873 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
874 ipcStreamInServerRet.ConfigCapturer();
875 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
876 ret = ipcStreamInServerRet.GetCapturer();
877 EXPECT_EQ(ret, nullptr);
878 }
879
880 /**
881 * @tc.name : Test IpcStreamInServer API
882 * @tc.type : FUNC
883 * @tc.number: IpcStreamInServer_035
884 * @tc.desc : Test IpcStreamInServer interface.
885 */
886 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_035, TestSize.Level1)
887 {
888 AudioProcessConfig configRet;
889 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
890 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
891
892 auto ret = ipcStreamInServerRet.GetRenderer();
893 EXPECT_EQ(ret, nullptr);
894
895 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
896 ret = ipcStreamInServerRet.GetRenderer();
897 EXPECT_EQ(ret, nullptr);
898
899 ipcStreamInServerRet.ConfigRenderer();
900 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
901 ret = ipcStreamInServerRet.GetRenderer();
902 EXPECT_EQ(ret, nullptr);
903 }
904
905 /**
906 * @tc.name : Test IpcStreamInServer API
907 * @tc.type : FUNC
908 * @tc.number: IpcStreamInServer_036
909 * @tc.desc : Test IpcStreamInServer interface.
910 */
911 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_036, TestSize.Level1)
912 {
913 AudioProcessConfig configRet;
914 AudioMode modeRet = AUDIO_MODE_RECORD;
915 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
916 bool onRet = false;
917
918 auto ret1 = ipcStreamInServerRet.SetMute(onRet);
919 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
920
921 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
922 auto ret2 = ipcStreamInServerRet.SetMute(onRet);
923 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
924
925 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
926 ipcStreamInServerRet.ConfigRenderer();
927 auto ret3 = ipcStreamInServerRet.SetMute(onRet);
928 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
929 }
930
931 /**
932 * @tc.name : Test IpcStreamInServer API
933 * @tc.type : FUNC
934 * @tc.number: IpcStreamInServer_037
935 * @tc.desc : Test IpcStreamInServer interface.
936 */
937 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_037, TestSize.Level1)
938 {
939 AudioProcessConfig configRet;
940 AudioMode modeRet = AUDIO_MODE_RECORD;
941 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
942 float duckFactor = 0.2f;
943
944 auto ret1 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
945 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
946
947 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
948 auto ret2 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
949 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
950
951 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
952 ipcStreamInServerRet.ConfigRenderer();
953 auto ret3 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
954 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
955 }
956
957 /**
958 * @tc.name : Test IpcStreamInServer API
959 * @tc.type : FUNC
960 * @tc.number: IpcStreamInServer_038
961 * @tc.desc : Test Config interface.
962 */
963 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_038, TestSize.Level1)
964 {
965 int defaultAudioMode = 3;
966 AudioProcessConfig configRet;
967 AudioMode modeRet = static_cast<AudioMode>(defaultAudioMode);
968 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
969
970 auto ret1 = ipcStreamInServerRet.Config();
971 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
972 }
973
974 /**
975 * @tc.name : Test IpcStreamInServer API
976 * @tc.type : FUNC
977 * @tc.number: IpcStreamInServer_039
978 * @tc.desc : Test GetRenderer interface.
979 */
980 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_039, TestSize.Level1)
981 {
982 AudioProcessConfig configRet;
983 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
984 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
985
986 ipcStreamInServerRet.rendererInServer_ = nullptr;
987 auto ret1 = ipcStreamInServerRet.GetRenderer();
988 EXPECT_EQ(ret1, nullptr);
989 }
990
991 /**
992 * @tc.name : Test IpcStreamInServer API
993 * @tc.type : FUNC
994 * @tc.number: IpcStreamInServer_040
995 * @tc.desc : Test GetCapturer interface.
996 */
997 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_040, TestSize.Level1)
998 {
999 AudioProcessConfig configRet;
1000 AudioMode modeRet = AUDIO_MODE_RECORD;
1001 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1002
1003 ipcStreamInServerRet.capturerInServer_ = nullptr;
1004 auto ret = ipcStreamInServerRet.GetCapturer();
1005 EXPECT_EQ(ret, nullptr);
1006 }
1007
1008 /**
1009 * @tc.name : Test IpcStreamInServer API
1010 * @tc.type : FUNC
1011 * @tc.number: IpcStreamInServer_041
1012 * @tc.desc : Test ResolveBuffer interface.
1013 */
1014 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_041, TestSize.Level1)
1015 {
1016 AudioProcessConfig configRet;
1017 AudioMode modeRet = AUDIO_MODE_RECORD;
1018 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1019 std::shared_ptr<OHAudioBuffer> buffer;
1020
1021 ipcStreamInServerRet.rendererInServer_ = nullptr;
1022 ipcStreamInServerRet.capturerInServer_ = nullptr;
1023 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1024 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1025 }
1026
1027 /**
1028 * @tc.name : Test IpcStreamInServer API
1029 * @tc.type : FUNC
1030 * @tc.number: IpcStreamInServer_042
1031 * @tc.desc : Test ResolveBuffer interface.
1032 */
1033 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_042, TestSize.Level1)
1034 {
1035 AudioProcessConfig configRet;
1036 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1037 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1038 std::shared_ptr<OHAudioBuffer> buffer;
1039
1040 ipcStreamInServerRet.rendererInServer_ = nullptr;
1041 ipcStreamInServerRet.capturerInServer_ = nullptr;
1042 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1043 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1044 }
1045
1046 /**
1047 * @tc.name : Test IpcStreamInServer API
1048 * @tc.type : FUNC
1049 * @tc.number: IpcStreamInServer_043
1050 * @tc.desc : Test UpdatePosition interface.
1051 */
1052 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_043, TestSize.Level1)
1053 {
1054 AudioProcessConfig configRet;
1055 AudioMode modeRet = AUDIO_MODE_RECORD;
1056 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1057
1058 ipcStreamInServerRet.rendererInServer_ = nullptr;
1059 ipcStreamInServerRet.capturerInServer_ = nullptr;
1060 auto ret = ipcStreamInServerRet.UpdatePosition();
1061 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1062 }
1063
1064 /**
1065 * @tc.name : Test IpcStreamInServer API
1066 * @tc.type : FUNC
1067 * @tc.number: IpcStreamInServer_044
1068 * @tc.desc : Test UpdatePosition interface.
1069 */
1070 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_044, TestSize.Level1)
1071 {
1072 AudioProcessConfig configRet;
1073 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1074 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1075
1076 ipcStreamInServerRet.rendererInServer_ = nullptr;
1077 ipcStreamInServerRet.capturerInServer_ = nullptr;
1078 auto ret = ipcStreamInServerRet.UpdatePosition();
1079 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1080 }
1081
1082 /**
1083 * @tc.name : Test IpcStreamInServer API
1084 * @tc.type : FUNC
1085 * @tc.number: IpcStreamInServer_045
1086 * @tc.desc : Test GetAudioSessionID interface.
1087 */
1088 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_045, TestSize.Level1)
1089 {
1090 AudioProcessConfig configRet;
1091 AudioMode modeRet = AUDIO_MODE_RECORD;
1092 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1093 uint32_t sessionId = 0;
1094
1095 ipcStreamInServerRet.rendererInServer_ = nullptr;
1096 ipcStreamInServerRet.capturerInServer_ = nullptr;
1097 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1098 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1099 }
1100
1101 /**
1102 * @tc.name : Test IpcStreamInServer API
1103 * @tc.type : FUNC
1104 * @tc.number: IpcStreamInServer_046
1105 * @tc.desc : Test GetAudioSessionID interface.
1106 */
1107 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_046, TestSize.Level1)
1108 {
1109 AudioProcessConfig configRet;
1110 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1111 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1112 uint32_t sessionId = 0;
1113
1114 ipcStreamInServerRet.rendererInServer_ = nullptr;
1115 ipcStreamInServerRet.capturerInServer_ = nullptr;
1116 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1117 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1118 }
1119
1120 /**
1121 * @tc.name : Test IpcStreamInServer API
1122 * @tc.type : FUNC
1123 * @tc.number: IpcStreamInServer_047
1124 * @tc.desc : Test Start interface.
1125 */
1126 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_047, TestSize.Level1)
1127 {
1128 AudioProcessConfig configRet;
1129 AudioMode modeRet = AUDIO_MODE_RECORD;
1130 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1131
1132 ipcStreamInServerRet.rendererInServer_ = nullptr;
1133 ipcStreamInServerRet.capturerInServer_ = nullptr;
1134 auto ret = ipcStreamInServerRet.Start();
1135 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1136 }
1137
1138 /**
1139 * @tc.name : Test IpcStreamInServer API
1140 * @tc.type : FUNC
1141 * @tc.number: IpcStreamInServer_048
1142 * @tc.desc : Test Start interface.
1143 */
1144 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_048, TestSize.Level1)
1145 {
1146 AudioProcessConfig configRet;
1147 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1148 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1149
1150 ipcStreamInServerRet.rendererInServer_ = nullptr;
1151 ipcStreamInServerRet.capturerInServer_ = nullptr;
1152 auto ret = ipcStreamInServerRet.Start();
1153 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1154 }
1155
1156 /**
1157 * @tc.name : Test IpcStreamInServer API
1158 * @tc.type : FUNC
1159 * @tc.number: IpcStreamInServer_049
1160 * @tc.desc : Test Pause interface.
1161 */
1162 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_049, TestSize.Level1)
1163 {
1164 AudioProcessConfig configRet;
1165 AudioMode modeRet = AUDIO_MODE_RECORD;
1166 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1167
1168 ipcStreamInServerRet.rendererInServer_ = nullptr;
1169 ipcStreamInServerRet.capturerInServer_ = nullptr;
1170 auto ret = ipcStreamInServerRet.Pause();
1171 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1172 }
1173
1174 /**
1175 * @tc.name : Test IpcStreamInServer API
1176 * @tc.type : FUNC
1177 * @tc.number: IpcStreamInServer_050
1178 * @tc.desc : Test Pause interface.
1179 */
1180 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_050, TestSize.Level1)
1181 {
1182 AudioProcessConfig configRet;
1183 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1184 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1185
1186 ipcStreamInServerRet.rendererInServer_ = nullptr;
1187 ipcStreamInServerRet.capturerInServer_ = nullptr;
1188 auto ret = ipcStreamInServerRet.Pause();
1189 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1190 }
1191
1192 /**
1193 * @tc.name : Test IpcStreamInServer API
1194 * @tc.type : FUNC
1195 * @tc.number: IpcStreamInServer_051
1196 * @tc.desc : Test Stop interface.
1197 */
1198 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_051, TestSize.Level1)
1199 {
1200 AudioProcessConfig configRet;
1201 AudioMode modeRet = AUDIO_MODE_RECORD;
1202 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1203
1204 ipcStreamInServerRet.rendererInServer_ = nullptr;
1205 ipcStreamInServerRet.capturerInServer_ = nullptr;
1206 auto ret = ipcStreamInServerRet.Stop();
1207 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1208 }
1209
1210 /**
1211 * @tc.name : Test IpcStreamInServer API
1212 * @tc.type : FUNC
1213 * @tc.number: IpcStreamInServer_052
1214 * @tc.desc : Test Stop interface.
1215 */
1216 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_052, TestSize.Level1)
1217 {
1218 AudioProcessConfig configRet;
1219 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1220 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1221
1222 ipcStreamInServerRet.rendererInServer_ = nullptr;
1223 ipcStreamInServerRet.capturerInServer_ = nullptr;
1224 auto ret = ipcStreamInServerRet.Stop();
1225 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1226 }
1227
1228 /**
1229 * @tc.name : Test IpcStreamInServer API
1230 * @tc.type : FUNC
1231 * @tc.number: IpcStreamInServer_053
1232 * @tc.desc : Test Release interface.
1233 */
1234 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_053, TestSize.Level1)
1235 {
1236 AudioProcessConfig configRet;
1237 AudioMode modeRet = AUDIO_MODE_RECORD;
1238 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1239
1240 ipcStreamInServerRet.rendererInServer_ = nullptr;
1241 ipcStreamInServerRet.capturerInServer_ = nullptr;
1242 auto ret = ipcStreamInServerRet.Release(false);
1243 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1244 }
1245
1246 /**
1247 * @tc.name : Test IpcStreamInServer API
1248 * @tc.type : FUNC
1249 * @tc.number: IpcStreamInServer_054
1250 * @tc.desc : Test Release interface.
1251 */
1252 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_054, TestSize.Level1)
1253 {
1254 AudioProcessConfig configRet;
1255 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1256 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1257
1258 ipcStreamInServerRet.rendererInServer_ = nullptr;
1259 ipcStreamInServerRet.capturerInServer_ = nullptr;
1260 auto ret = ipcStreamInServerRet.Release(false);
1261 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1262 }
1263
1264 /**
1265 * @tc.name : Test IpcStreamInServer API
1266 * @tc.type : FUNC
1267 * @tc.number: IpcStreamInServer_055
1268 * @tc.desc : Test Flush interface.
1269 */
1270 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_055, TestSize.Level1)
1271 {
1272 AudioProcessConfig configRet;
1273 AudioMode modeRet = AUDIO_MODE_RECORD;
1274 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1275
1276 ipcStreamInServerRet.rendererInServer_ = nullptr;
1277 ipcStreamInServerRet.capturerInServer_ = nullptr;
1278 auto ret = ipcStreamInServerRet.Flush();
1279 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1280 }
1281
1282 /**
1283 * @tc.name : Test IpcStreamInServer API
1284 * @tc.type : FUNC
1285 * @tc.number: IpcStreamInServer_056
1286 * @tc.desc : Test Flush interface.
1287 */
1288 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_056, TestSize.Level1)
1289 {
1290 AudioProcessConfig configRet;
1291 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1292 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1293
1294 ipcStreamInServerRet.rendererInServer_ = nullptr;
1295 ipcStreamInServerRet.capturerInServer_ = nullptr;
1296 auto ret = ipcStreamInServerRet.Flush();
1297 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1298 }
1299
1300 /**
1301 * @tc.name : Test IpcStreamInServer API
1302 * @tc.type : FUNC
1303 * @tc.number: IpcStreamInServer_057
1304 * @tc.desc : Test Flush interface.
1305 */
1306 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_057, TestSize.Level1)
1307 {
1308 AudioProcessConfig configRet;
1309 AudioMode modeRet = AUDIO_MODE_RECORD;
1310 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1311
1312 bool stopFlag = true;
1313 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1314 ipcStreamInServerRet.streamListenerHolder_);
1315 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1316
1317 auto result = ipcStreamInServerRet.Drain(stopFlag);
1318 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1319 }
1320
1321 /**
1322 * @tc.name : Test IpcStreamInServer API
1323 * @tc.type : FUNC
1324 * @tc.number: IpcStreamInServer_058
1325 * @tc.desc : Test GetAudioTime interface.
1326 */
1327 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_058, TestSize.Level1)
1328 {
1329 AudioProcessConfig configRet;
1330 AudioMode modeRet = AUDIO_MODE_RECORD;
1331 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1332
1333 uint64_t framePos = 0;
1334 uint64_t timestamp = 0;
1335
1336 ipcStreamInServerRet.rendererInServer_ = nullptr;
1337 ipcStreamInServerRet.capturerInServer_ = nullptr;
1338 auto ret = ipcStreamInServerRet.GetAudioTime(framePos, timestamp);
1339 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1340 }
1341
1342 /**
1343 * @tc.name : Test IpcStreamInServer API
1344 * @tc.type : FUNC
1345 * @tc.number: IpcStreamInServer_059
1346 * @tc.desc : Test GetAudioTime interface.
1347 */
1348 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_059, TestSize.Level1)
1349 {
1350 AudioProcessConfig configRet;
1351 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1352 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1353
1354 uint64_t framePos = 0;
1355 uint64_t timestamp = 0;
1356
1357 ipcStreamInServerRet.rendererInServer_ = nullptr;
1358 ipcStreamInServerRet.capturerInServer_ = nullptr;
1359 auto ret = ipcStreamInServerRet.GetAudioTime(framePos, timestamp);
1360 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1361 }
1362
1363 /**
1364 * @tc.name : Test IpcStreamInServer API
1365 * @tc.type : FUNC
1366 * @tc.number: IpcStreamInServer_060
1367 * @tc.desc : Test GetAudioPosition interface.
1368 */
1369 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_060, TestSize.Level1)
1370 {
1371 AudioProcessConfig configRet;
1372 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1373 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1374
1375 uint64_t framePos = 0;
1376 uint64_t timestamp = 0;
1377 uint64_t latency = 0;
1378 ipcStreamInServerRet.rendererInServer_ = nullptr;
1379
1380 auto ret = ipcStreamInServerRet.GetAudioPosition(framePos, timestamp, latency, Timestamp::MONOTONIC);
1381 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1382 }
1383
1384 /**
1385 * @tc.name : Test IpcStreamInServer API
1386 * @tc.type : FUNC
1387 * @tc.number: IpcStreamInServer_061
1388 * @tc.desc : Test GetLatency interface.
1389 */
1390 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_061, TestSize.Level1)
1391 {
1392 AudioProcessConfig configRet;
1393 AudioMode modeRet = AUDIO_MODE_RECORD;
1394 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1395
1396 uint64_t latency = 0;
1397 ipcStreamInServerRet.rendererInServer_ = nullptr;
1398 ipcStreamInServerRet.capturerInServer_ = nullptr;
1399 auto ret = ipcStreamInServerRet.GetLatency(latency);
1400 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1401 }
1402
1403 /**
1404 * @tc.name : Test IpcStreamInServer API
1405 * @tc.type : FUNC
1406 * @tc.number: IpcStreamInServer_062
1407 * @tc.desc : Test GetLatency interface.
1408 */
1409 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_062, TestSize.Level1)
1410 {
1411 AudioProcessConfig configRet;
1412 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1413 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1414
1415 uint64_t latency = 0;
1416 ipcStreamInServerRet.rendererInServer_ = nullptr;
1417 ipcStreamInServerRet.capturerInServer_ = nullptr;
1418 auto ret = ipcStreamInServerRet.GetLatency(latency);
1419 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1420 }
1421
1422 /**
1423 * @tc.name : Test IpcStreamInServer API
1424 * @tc.type : FUNC
1425 * @tc.number: IpcStreamInServer_063
1426 * @tc.desc : Test SetRate interface.
1427 */
1428 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_063, TestSize.Level1)
1429 {
1430 AudioProcessConfig configRet;
1431 AudioMode modeRet = AUDIO_MODE_RECORD;
1432 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1433
1434 int32_t rate = 0;
1435 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1436 ipcStreamInServerRet.streamListenerHolder_);
1437 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1438
1439 auto result = ipcStreamInServerRet.SetRate(rate);
1440 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1441 }
1442
1443 /**
1444 * @tc.name : Test IpcStreamInServer API
1445 * @tc.type : FUNC
1446 * @tc.number: IpcStreamInServer_064
1447 * @tc.desc : Test SetDuckFactor interface.
1448 */
1449 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_064, TestSize.Level1)
1450 {
1451 AudioProcessConfig configRet;
1452 AudioMode modeRet = AUDIO_MODE_RECORD;
1453 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1454
1455 float duckFactor = 0.1;
1456 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1457 ipcStreamInServerRet.streamListenerHolder_);
1458 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1459
1460 auto result = ipcStreamInServerRet.SetDuckFactor(duckFactor);
1461 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1462 }
1463
1464 /**
1465 * @tc.name : Test IpcStreamInServer API
1466 * @tc.type : FUNC
1467 * @tc.number: IpcStreamInServer_065
1468 * @tc.desc : Test SetDefaultOutputDevice interface.
1469 */
1470 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_065, TestSize.Level1)
1471 {
1472 AudioProcessConfig configRet;
1473 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1474 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1475
1476 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1477 ipcStreamInServerRet.streamListenerHolder_);
1478 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1479
1480 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1481 EXPECT_EQ(result, ERROR);
1482 }
1483
1484 /**
1485 * @tc.name : Test IpcStreamInServer API
1486 * @tc.type : FUNC
1487 * @tc.number: IpcStreamInServer_066
1488 * @tc.desc : Test SetDefaultOutputDevice interface.
1489 */
1490 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_066, TestSize.Level1)
1491 {
1492 AudioProcessConfig configRet;
1493 AudioMode modeRet = AUDIO_MODE_RECORD;
1494 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1495
1496 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1497 ipcStreamInServerRet.streamListenerHolder_);
1498 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1499
1500 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1501 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1502 }
1503
1504 /**
1505 * @tc.name : Test IpcStreamInServer API
1506 * @tc.type : FUNC
1507 * @tc.number: IpcStreamInServer_067
1508 * @tc.desc : Test SetDefaultOutputDevice interface.
1509 */
1510 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_067, TestSize.Level1)
1511 {
1512 AudioProcessConfig configRet;
1513 AudioMode modeRet = AUDIO_MODE_RECORD;
1514 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1515
1516 ipcStreamInServerRet.rendererInServer_ = nullptr;
1517 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1518 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1519 }
1520
1521 /**
1522 * @tc.name : Test IpcStreamInServer API
1523 * @tc.type : FUNC
1524 * @tc.number: IpcStreamInServer_068
1525 * @tc.desc : Test SetDefaultOutputDevice interface.
1526 */
1527 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_068, TestSize.Level1)
1528 {
1529 AudioProcessConfig configRet;
1530 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1531 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1532
1533 ipcStreamInServerRet.rendererInServer_ = nullptr;
1534 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1535 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1536 }
1537
1538 /**
1539 * @tc.name : Test IpcStreamInServer API
1540 * @tc.type : FUNC
1541 * @tc.number: IpcStreamInServer_069
1542 * @tc.desc : Test SetSourceDuration interface.
1543 */
1544 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_069, TestSize.Level1)
1545 {
1546 AudioProcessConfig configRet;
1547 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1548 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1549
1550 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1551 ipcStreamInServerRet.streamListenerHolder_);
1552 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1553
1554 int64_t duration = 0;
1555 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1556 EXPECT_EQ(result, SUCCESS);
1557 }
1558
1559 /**
1560 * @tc.name : Test IpcStreamInServer API
1561 * @tc.type : FUNC
1562 * @tc.number: IpcStreamInServer_070
1563 * @tc.desc : Test SetDefaultOutputDevice interface.
1564 */
1565 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_070, TestSize.Level1)
1566 {
1567 AudioProcessConfig configRet;
1568 AudioMode modeRet = AUDIO_MODE_RECORD;
1569 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1570
1571 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1572 ipcStreamInServerRet.streamListenerHolder_);
1573 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1574
1575 int64_t duration = 0;
1576 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1577 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1578 }
1579
1580 /**
1581 * @tc.name : Test IpcStreamInServer API
1582 * @tc.type : FUNC
1583 * @tc.number: IpcStreamInServer_071
1584 * @tc.desc : Test SetDefaultOutputDevice interface.
1585 */
1586 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_071, TestSize.Level1)
1587 {
1588 AudioProcessConfig configRet;
1589 AudioMode modeRet = AUDIO_MODE_RECORD;
1590 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1591
1592 ipcStreamInServerRet.rendererInServer_ = nullptr;
1593 int64_t duration = 0;
1594 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1595 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1596 }
1597
1598 /**
1599 * @tc.name : Test IpcStreamInServer API
1600 * @tc.type : FUNC
1601 * @tc.number: IpcStreamInServer_072
1602 * @tc.desc : Test SetDefaultOutputDevice interface.
1603 */
1604 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_072, TestSize.Level1)
1605 {
1606 AudioProcessConfig configRet;
1607 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1608 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1609
1610 ipcStreamInServerRet.rendererInServer_ = nullptr;
1611 int64_t duration = 0;
1612 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1613 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1614 }
1615
1616 /**
1617 * @tc.name : Test IpcStreamInServer API
1618 * @tc.type : FUNC
1619 * @tc.number: IpcStreamInServer_073
1620 * @tc.desc : Test SetAudioHapticsSyncId interface.
1621 */
1622 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_073, TestSize.Level1)
1623 {
1624 AudioProcessConfig configRet;
1625 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1626 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1627
1628 int32_t syncId = 0;
1629
1630 ipcStreamInServerRet.rendererInServer_ = nullptr;
1631 auto result = ipcStreamInServerRet.SetAudioHapticsSyncId(syncId);
1632 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1633
1634 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
1635 result = ipcStreamInServerRet.SetAudioHapticsSyncId(syncId);
1636 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1637
1638 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1639 ipcStreamInServerRet.streamListenerHolder_);
1640 result = ipcStreamInServerRet.SetAudioHapticsSyncId(syncId);
1641 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1642
1643 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
1644 result = ipcStreamInServerRet.SetAudioHapticsSyncId(syncId);
1645 EXPECT_EQ(result, SUCCESS);
1646 }
1647
1648 /**
1649 * @tc.name : Test ProcessManagerType
1650 * @tc.type : FUNC
1651 * @tc.number: ProcessManagerType_001
1652 * @tc.desc : Test ProcessManagerType interface when flag is DIRECT_PLAYBACK.
1653 */
1654 HWTEST(IpcStreamInServerUnitTest, ProcessManagerType_001, TestSize.Level1)
1655 {
1656 AudioProcessConfig configRet;
1657 configRet.rendererInfo.audioFlag = (AUDIO_OUTPUT_FLAG_HD|AUDIO_OUTPUT_FLAG_DIRECT);
1658 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1659 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1660
1661 ipcStreamInServerRet.ConfigRenderer();
1662 ipcStreamInServerRet.rendererInServer_->ProcessManagerType();
1663 EXPECT_EQ(ipcStreamInServerRet.rendererInServer_->managerType_, DIRECT_PLAYBACK);
1664 }
1665
1666 /**
1667 * @tc.name : Test ProcessManagerType
1668 * @tc.type : FUNC
1669 * @tc.number: ProcessManagerType_002
1670 * @tc.desc : Test ProcessManagerType interface when encoding is ENCODING_EAC3.
1671 */
1672 HWTEST(IpcStreamInServerUnitTest, ProcessManagerType_002, TestSize.Level1)
1673 {
1674 AudioProcessConfig configRet;
1675 configRet.streamInfo.encoding = ENCODING_EAC3;
1676 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1677 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1678
1679 ipcStreamInServerRet.ConfigRenderer();
1680 ipcStreamInServerRet.rendererInServer_->ProcessManagerType();
1681 EXPECT_EQ(ipcStreamInServerRet.rendererInServer_->managerType_, EAC3_PLAYBACK);
1682 }
1683
1684 /**
1685 * @tc.name : Test ProcessManagerType
1686 * @tc.type : FUNC
1687 * @tc.number: ProcessManagerType_003
1688 * @tc.desc : Test ProcessManagerType interface when flag is AUDIO_FLAG_VOIP_DIRECT.
1689 */
1690 HWTEST(IpcStreamInServerUnitTest, ProcessManagerType_003, TestSize.Level1)
1691 {
1692 AudioProcessConfig configRet;
1693 configRet.rendererInfo.rendererFlags = AUDIO_FLAG_VOIP_DIRECT;
1694 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1695 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1696
1697 ipcStreamInServerRet.ConfigRenderer();
1698 ipcStreamInServerRet.rendererInServer_->ProcessManagerType();
1699 EXPECT_EQ(ipcStreamInServerRet.rendererInServer_->managerType_, VOIP_PLAYBACK);
1700 }
1701
1702 /**
1703 * @tc.name : Test GetAudioSessionID API
1704 * @tc.type : FUNC
1705 * @tc.number: GetAudioSessionID_001
1706 * @tc.desc : Test GetAudioSessionID interface.
1707 */
1708 HWTEST(IpcStreamInServerUnitTest, GetAudioSessionID_001, TestSize.Level3)
1709 {
1710 AudioProcessConfig configRet;
1711 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1712 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1713 uint32_t sessionId = 0;
1714
1715 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1716 ipcStreamInServerRet.streamListenerHolder_);
1717 ipcStreamInServerRet.capturerInServer_ = nullptr;
1718 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1719 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1720 }
1721
1722 /**
1723 * @tc.name : Test GetAudioSessionID API
1724 * @tc.type : FUNC
1725 * @tc.number: GetAudioSessionID_002
1726 * @tc.desc : Test GetAudioSessionID interface.
1727 */
1728 HWTEST(IpcStreamInServerUnitTest, GetAudioSessionID_002, TestSize.Level3)
1729 {
1730 AudioProcessConfig configRet;
1731 AudioMode modeRet = AUDIO_MODE_RECORD;
1732 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1733 uint32_t sessionId = 0;
1734
1735 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1736 ipcStreamInServerRet.streamListenerHolder_);
1737 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1738 ipcStreamInServerRet.streamListenerHolder_);
1739 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1740 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1741 }
1742
1743 /**
1744 * @tc.name : Test Start API
1745 * @tc.type : FUNC
1746 * @tc.number: Start_001
1747 * @tc.desc : Test Start interface.
1748 */
1749 HWTEST(IpcStreamInServerUnitTest, start_001, TestSize.Level3)
1750 {
1751 AudioProcessConfig configRet;
1752 AudioMode modeRet = AUDIO_MODE_RECORD;
1753 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1754
1755 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1756 ipcStreamInServerRet.streamListenerHolder_);
1757 auto ret = ipcStreamInServerRet.Start();
1758 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1759 }
1760
1761 /**
1762 * @tc.name : Test Start API
1763 * @tc.type : FUNC
1764 * @tc.number: Start_002
1765 * @tc.desc : Test Start interface.
1766 */
1767 HWTEST(IpcStreamInServerUnitTest, start_002, TestSize.Level3)
1768 {
1769 AudioProcessConfig configRet;
1770 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1771 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1772
1773 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1774 ipcStreamInServerRet.streamListenerHolder_);
1775 auto ret = ipcStreamInServerRet.Start();
1776 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1777 }
1778
1779 /**
1780 * @tc.name : Test Start API
1781 * @tc.type : FUNC
1782 * @tc.number: stop_001
1783 * @tc.desc : Test Start interface.
1784 */
1785 HWTEST(IpcStreamInServerUnitTest, Stop_001, TestSize.Level3)
1786 {
1787 AudioProcessConfig configRet;
1788 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1789 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1790
1791 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1792 ipcStreamInServerRet.streamListenerHolder_);
1793 auto ret = ipcStreamInServerRet.Stop();
1794 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1795 }
1796
1797 /**
1798 * @tc.name : Test Config API
1799 * @tc.type : FUNC
1800 * @tc.number: Config_001
1801 * @tc.desc : Test Config interface.
1802 */
1803 HWTEST(IpcStreamInServerUnitTest, Config_001, TestSize.Level3)
1804 {
1805 AudioProcessConfig configRet;
1806 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1807 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1808
1809 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1810 ipcStreamInServerRet.streamListenerHolder_);
1811 auto ret = ipcStreamInServerRet.Config();
1812 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1813 }
1814
1815 /**
1816 * @tc.name : Test GetRenderer API
1817 * @tc.type : FUNC
1818 * @tc.number: GetRenderer_001
1819 * @tc.desc : Test GetRenderer interface.
1820 */
1821 HWTEST(IpcStreamInServerUnitTest, GetRenderer_001, TestSize.Level3)
1822 {
1823 AudioProcessConfig configRet;
1824 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1825 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1826
1827 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1828 ipcStreamInServerRet.streamListenerHolder_);
1829 auto ret = ipcStreamInServerRet.GetRenderer();
1830 EXPECT_EQ(ret, ipcStreamInServerRet.rendererInServer_);
1831 }
1832
1833 /**
1834 * @tc.name : Test GetCapturer_001 API
1835 * @tc.type : FUNC
1836 * @tc.number: GetCapturer_001
1837 * @tc.desc : Test GetCapturer interface.
1838 */
1839 HWTEST(IpcStreamInServerUnitTest, GetCapturer_001, TestSize.Level3)
1840 {
1841 AudioProcessConfig configRet;
1842 AudioMode modeRet = AUDIO_MODE_RECORD;
1843 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1844
1845 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1846 ipcStreamInServerRet.streamListenerHolder_);
1847 auto ret = ipcStreamInServerRet.GetCapturer();
1848 EXPECT_EQ(ret, ipcStreamInServerRet.capturerInServer_);
1849 }
1850
1851 /**
1852 * @tc.name : Test ResolveBuffer API
1853 * @tc.type : FUNC
1854 * @tc.number: ResolveBuffer_001
1855 * @tc.desc : Test ResolveBuffer interface.
1856 */
1857 HWTEST(IpcStreamInServerUnitTest, ResolveBuffer_001, TestSize.Level3)
1858 {
1859 AudioProcessConfig configRet;
1860 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1861 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1862 std::shared_ptr<OHAudioBuffer> buffer;
1863
1864 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1865 ipcStreamInServerRet.streamListenerHolder_);
1866 ipcStreamInServerRet.capturerInServer_ = nullptr;
1867 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1868 EXPECT_EQ(ret, SUCCESS);
1869 }
1870
1871 /**
1872 * @tc.name : Test ResolveBuffer API
1873 * @tc.type : FUNC
1874 * @tc.number: ResolveBuffer_002
1875 * @tc.desc : Test ResolveBuffer interface.
1876 */
1877 HWTEST(IpcStreamInServerUnitTest, ResolveBuffer_002, TestSize.Level3)
1878 {
1879 AudioProcessConfig configRet;
1880 AudioMode modeRet = AUDIO_MODE_RECORD;
1881 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1882 std::shared_ptr<OHAudioBuffer> buffer;
1883
1884 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1885 ipcStreamInServerRet.streamListenerHolder_);
1886 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1887 EXPECT_EQ(ret, SUCCESS);
1888 }
1889
1890 /**
1891 * @tc.name : Test Pause API
1892 * @tc.type : FUNC
1893 * @tc.number: Pause_001
1894 * @tc.desc : Test Pause interface.
1895 */
1896 HWTEST(IpcStreamInServerUnitTest, Pause_001, TestSize.Level3)
1897 {
1898 AudioProcessConfig configRet;
1899 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1900 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1901
1902 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1903 ipcStreamInServerRet.streamListenerHolder_);
1904
1905 auto ret = ipcStreamInServerRet.Pause();
1906 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
1907 }
1908
1909 /**
1910 * @tc.name : Test Pause API
1911 * @tc.type : FUNC
1912 * @tc.number: Pause_002
1913 * @tc.desc : Test Pause interface.
1914 */
1915 HWTEST(IpcStreamInServerUnitTest, Pause_002, TestSize.Level3)
1916 {
1917 AudioProcessConfig configRet;
1918 AudioMode modeRet = AUDIO_MODE_RECORD;
1919 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1920
1921 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1922 ipcStreamInServerRet.streamListenerHolder_);
1923 auto ret = ipcStreamInServerRet.Pause();
1924 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
1925 }
1926
1927 /**
1928 * @tc.name : Test Start API
1929 * @tc.type : FUNC
1930 * @tc.number: Stop_002
1931 * @tc.desc : Test Start interface.
1932 */
1933 HWTEST(IpcStreamInServerUnitTest, Stop_002, TestSize.Level3)
1934 {
1935 AudioProcessConfig configRet;
1936 AudioMode modeRet = AUDIO_MODE_RECORD;
1937 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1938
1939 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1940 ipcStreamInServerRet.streamListenerHolder_);
1941 auto ret = ipcStreamInServerRet.Stop();
1942 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1943 }
1944
1945 /**
1946 * @tc.name : Test Release API
1947 * @tc.type : FUNC
1948 * @tc.number: Release_001
1949 * @tc.desc : Test Release interface.
1950 */
1951 HWTEST(IpcStreamInServerUnitTest, Release_001, TestSize.Level3)
1952 {
1953 AudioProcessConfig configRet;
1954 AudioMode modeRet = AUDIO_MODE_RECORD;
1955 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1956
1957 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1958 ipcStreamInServerRet.streamListenerHolder_);
1959 auto ret = ipcStreamInServerRet.Release(false);
1960 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1961 }
1962
1963 /**
1964 * @tc.name : Test Release API
1965 * @tc.type : FUNC
1966 * @tc.number: Release_002
1967 * @tc.desc : Test Release interface.
1968 */
1969 HWTEST(IpcStreamInServerUnitTest, Release_002, TestSize.Level3)
1970 {
1971 AudioProcessConfig configRet;
1972 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1973 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1974
1975 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1976 ipcStreamInServerRet.streamListenerHolder_);
1977 auto ret = ipcStreamInServerRet.Release(false);
1978 EXPECT_NE(ret, ERR_OPERATION_FAILED);
1979 }
1980
1981
1982 /**
1983 * @tc.name : Test Flush API
1984 * @tc.type : FUNC
1985 * @tc.number: Flush_001
1986 * @tc.desc : Test Flush interface.
1987 */
1988 HWTEST(IpcStreamInServerUnitTest, Flush_001, TestSize.Level3)
1989 {
1990 AudioProcessConfig configRet;
1991 AudioMode modeRet = AUDIO_MODE_RECORD;
1992 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1993
1994 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
1995 ipcStreamInServerRet.streamListenerHolder_);
1996 auto ret = ipcStreamInServerRet.Flush();
1997 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
1998 }
1999
2000 /**
2001 * @tc.name : Test IpcStreamInServer API
2002 * @tc.type : FUNC
2003 * @tc.number: Flush_002
2004 * @tc.desc : Test Flush interface.
2005 */
2006 HWTEST(IpcStreamInServerUnitTest, Flush_002, TestSize.Level3)
2007 {
2008 AudioProcessConfig configRet;
2009 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2010 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2011
2012 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2013 ipcStreamInServerRet.streamListenerHolder_);
2014 auto ret = ipcStreamInServerRet.Flush();
2015 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
2016 }
2017
2018 /**
2019 * @tc.name : Test GetLatency API
2020 * @tc.type : FUNC
2021 * @tc.number: GetLatency_001
2022 * @tc.desc : Test GetLatency interface.
2023 */
2024 HWTEST(IpcStreamInServerUnitTest, GetLatency_001, TestSize.Level3)
2025 {
2026 AudioProcessConfig configRet;
2027 AudioMode modeRet = AUDIO_MODE_RECORD;
2028 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2029
2030 uint64_t latency = 0;
2031 ipcStreamInServerRet.capturerInServer_ = std::make_shared<CapturerInServer>(ipcStreamInServerRet.config_,
2032 ipcStreamInServerRet.streamListenerHolder_);
2033 auto ret = ipcStreamInServerRet.GetLatency(latency);
2034 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2035 }
2036
2037 /**
2038 * @tc.name : Test SetLowPowerVolume API
2039 * @tc.type : FUNC
2040 * @tc.number: SetLowPowerVolume_001
2041 * @tc.desc : Test SetLowPowerVolume_001 interface.
2042 */
2043 HWTEST(IpcStreamInServerUnitTest, SetLowPowerVolume_001, TestSize.Level3)
2044 {
2045 AudioProcessConfig configRet;
2046 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2047 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2048 float volumeRet = 0.5;
2049 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2050 ipcStreamInServerRet.streamListenerHolder_);
2051
2052 auto ret = ipcStreamInServerRet.SetLowPowerVolume(volumeRet);
2053 EXPECT_EQ(ret, SUCCESS);
2054 }
2055
2056 /**
2057 * @tc.name : Test GetLowPowerVolume API
2058 * @tc.type : FUNC
2059 * @tc.number: GetLowPowerVolume_001
2060 * @tc.desc : Test GetLowPowerVolume interface.
2061 */
2062 HWTEST(IpcStreamInServerUnitTest, GetLowPowerVolume_001, TestSize.Level3)
2063 {
2064 AudioProcessConfig configRet;
2065 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2066 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2067 float volumeRet = 0.5;
2068 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2069 ipcStreamInServerRet.streamListenerHolder_);
2070
2071 auto ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
2072 EXPECT_EQ(ret, SUCCESS);
2073 }
2074
2075 /**
2076 * @tc.name : Test GetStreamManagerType API
2077 * @tc.type : FUNC
2078 * @tc.number: GetStreamManagerType_001
2079 * @tc.desc : Test GetStreamManagerType interface.
2080 */
2081 HWTEST(IpcStreamInServerUnitTest, GetStreamManagerType_001, TestSize.Level3)
2082 {
2083 AudioProcessConfig configRet;
2084 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2085 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2086 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2087 ipcStreamInServerRet.streamListenerHolder_);
2088
2089 auto ret = ipcStreamInServerRet.GetStreamManagerType();
2090 EXPECT_NE(ret, ERR_INVALID_OPERATION);
2091 }
2092
2093 /**
2094 * @tc.name : Test SetMute API
2095 * @tc.type : FUNC
2096 * @tc.number: SetMute_001
2097 * @tc.desc : Test SetMute interface.
2098 */
2099 HWTEST(IpcStreamInServerUnitTest, SetMute_001, TestSize.Level3)
2100 {
2101 AudioProcessConfig configRet;
2102 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2103 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2104 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2105 ipcStreamInServerRet.streamListenerHolder_);
2106 bool onRet = false;
2107
2108 auto ret = ipcStreamInServerRet.SetMute(onRet);
2109 EXPECT_EQ(ret, SUCCESS);
2110 }
2111
2112 /**
2113 * @tc.name : Test SetDuckFactor API
2114 * @tc.type : FUNC
2115 * @tc.number: SetDuckFactor_001
2116 * @tc.desc : Test SetDuckFactor interface.
2117 */
2118 HWTEST(IpcStreamInServerUnitTest, SetDuckFactor_001, TestSize.Level3)
2119 {
2120 AudioProcessConfig configRet;
2121 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2122 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2123 float duckFactor = 0.2f;
2124 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2125 ipcStreamInServerRet.streamListenerHolder_);
2126
2127 auto ret = ipcStreamInServerRet.SetDuckFactor(duckFactor);
2128 EXPECT_EQ(ret, SUCCESS);
2129 }
2130
2131 /**
2132 * @tc.name : Test SetSilentModeAndMixWithOthers API
2133 * @tc.type : FUNC
2134 * @tc.number: SetSilentModeAndMixWithOthers_001
2135 * @tc.desc : Test SetSilentModeAndMixWithOthers interface.
2136 */
2137 HWTEST(IpcStreamInServerUnitTest, SetSilentModeAndMixWithOthers_001, TestSize.Level3)
2138 {
2139 AudioProcessConfig configRet;
2140 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
2141 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2142 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2143 ipcStreamInServerRet.streamListenerHolder_);
2144 bool onRet = false;
2145
2146 auto ret = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
2147 EXPECT_NE(ret, ERR_OPERATION_FAILED);
2148 }
2149
2150 /**
2151 * @tc.name : Test unsetOffloadMode API
2152 * @tc.type : FUNC
2153 * @tc.number: UnsetOffloadMode_001
2154 * @tc.desc : Test UnsetOffloadMode interface.
2155 */
2156 HWTEST(IpcStreamInServerUnitTest, UnsetOffloadMode_001, TestSize.Level3)
2157 {
2158 AudioProcessConfig configRet;
2159 AudioMode modeRet = AUDIO_MODE_RECORD;
2160 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
2161 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
2162 ipcStreamInServerRet.streamListenerHolder_);
2163
2164 auto ret = ipcStreamInServerRet.UnsetOffloadMode();
2165 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
2166 }
2167 }
2168 }
2169