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 IpcStreamInServerUnitTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase(void)44 void IpcStreamInServerUnitTest::SetUpTestCase(void)
45 {
46 // input testsuit setup step，setup invoked before all testcases
47 }
48
TearDownTestCase(void)49 void IpcStreamInServerUnitTest::TearDownTestCase(void)
50 {
51 // input testsuit teardown step，teardown invoked after all testcases
52 }
53
SetUp(void)54 void IpcStreamInServerUnitTest::SetUp(void)
55 {
56 // input testcase setup step，setup invoked before each testcases
57 }
58
TearDown(void)59 void IpcStreamInServerUnitTest::TearDown(void)
60 {
61 // input testcase teardown step，teardown invoked after each testcases
62 }
63
64 /**
65 * @tc.name : Test IpcStreamInServer API
66 * @tc.type : FUNC
67 * @tc.number: IpcStreamInServer_001
68 * @tc.desc : Test IpcStreamInServer interface.
69 */
70 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_001, TestSize.Level1)
71 {
72 AudioProcessConfig configRet;
73 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
74 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
75 auto ret = ipcStreamInServerRet.GetCapturer();
76 EXPECT_EQ(ret, nullptr);
77 }
78
79 /**
80 * @tc.name : Test IpcStreamInServer API
81 * @tc.type : FUNC
82 * @tc.number: IpcStreamInServer_002
83 * @tc.desc : Test IpcStreamInServer interface.
84 */
85 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_002, TestSize.Level1)
86 {
87 AudioProcessConfig configRet;
88 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
89 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
90 std::shared_ptr<OHAudioBuffer> buffer;
91 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
92 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
93 }
94
95 /**
96 * @tc.name : Test IpcStreamInServer API
97 * @tc.type : FUNC
98 * @tc.number: IpcStreamInServer_003
99 * @tc.desc : Test IpcStreamInServer interface.
100 */
101 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_003, TestSize.Level1)
102 {
103 AudioProcessConfig configRet;
104 AudioMode modeRet = AUDIO_MODE_RECORD;
105 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
106
107 auto ret1 = ipcStreamInServerRet.UpdatePosition();
108 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
109
110 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
111 ret1 = ipcStreamInServerRet.UpdatePosition();
112 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
113
114 ipcStreamInServerRet.ConfigCapturer();
115 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
116 ret1 = ipcStreamInServerRet.UpdatePosition();
117 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
118 }
119
120 /**
121 * @tc.name : Test IpcStreamInServer API
122 * @tc.type : FUNC
123 * @tc.number: IpcStreamInServer_004
124 * @tc.desc : Test IpcStreamInServer interface.
125 */
126 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_004, TestSize.Level1)
127 {
128 AudioProcessConfig configRet;
129 AudioMode modeRet = AUDIO_MODE_RECORD;
130 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
131
132 auto ret1 = ipcStreamInServerRet.Config();
133 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
134 EXPECT_EQ(ipcStreamInServerRet.mode_, AUDIO_MODE_RECORD);
135 }
136
137 /**
138 * @tc.name : Test IpcStreamInServer API
139 * @tc.type : FUNC
140 * @tc.number: IpcStreamInServer_005
141 * @tc.desc : Test IpcStreamInServer interface.
142 */
143 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_005, TestSize.Level1)
144 {
145 AudioProcessConfig configRet;
146 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
147 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
148 uint32_t sessionIdRet;
149 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
150 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
151
152 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
153 ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
154 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
155
156 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
157 ipcStreamInServerRet.ConfigCapturer();
158 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
159 ret = ipcStreamInServerRet.GetAudioSessionID(sessionIdRet);
160 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
161 }
162
163 /**
164 * @tc.name : Test IpcStreamInServer API
165 * @tc.type : FUNC
166 * @tc.number: IpcStreamInServer_006
167 * @tc.desc : Test IpcStreamInServer interface.
168 */
169 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_006, TestSize.Level1)
170 {
171 AudioProcessConfig configRet;
172 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
173 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
174 auto ret = ipcStreamInServerRet.Start();
175 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
176
177 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
178 ret = ipcStreamInServerRet.Start();
179 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
180
181 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
182 ipcStreamInServerRet.ConfigCapturer();
183 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
184 ret = ipcStreamInServerRet.Start();
185 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
186 }
187
188 /**
189 * @tc.name : Test IpcStreamInServer API
190 * @tc.type : FUNC
191 * @tc.number: IpcStreamInServer_007
192 * @tc.desc : Test IpcStreamInServer interface.
193 */
194 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_007, TestSize.Level1)
195 {
196 AudioProcessConfig configRet;
197 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
198 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
199
200 auto ret = ipcStreamInServerRet.Pause();
201 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
202
203 ret = ipcStreamInServerRet.Stop();
204 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
205 }
206
207 /**
208 * @tc.name : Test IpcStreamInServer API
209 * @tc.type : FUNC
210 * @tc.number: IpcStreamInServer_008
211 * @tc.desc : Test IpcStreamInServer interface.
212 */
213 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_008, TestSize.Level1)
214 {
215 AudioProcessConfig configRet;
216 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
217 IpcStreamInServer ipcStreamInServerRet1(configRet, modeRet);
218 uint64_t framePosRet = 0;
219 uint64_t timestampRet = 0;
220 uint64_t latency = 0;
221 auto ret1 = ipcStreamInServerRet1.GetAudioPosition(framePosRet, timestampRet, latency);
222 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
223
224 modeRet = AUDIO_MODE_RECORD;
225 IpcStreamInServer ipcStreamInServerRet2(configRet, modeRet);
226 ipcStreamInServerRet2.rendererInServer_ = std::make_shared<RendererInServer>(
227 ipcStreamInServerRet2.config_,
228 ipcStreamInServerRet2.streamListenerHolder_);
229 auto ret2 = ipcStreamInServerRet1.GetAudioPosition(framePosRet, timestampRet, latency);
230 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
231 }
232
233 /**
234 * @tc.name : Test IpcStreamInServer API
235 * @tc.type : FUNC
236 * @tc.number: IpcStreamInServer_009
237 * @tc.desc : Test IpcStreamInServer interface.
238 */
239 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_009, TestSize.Level1)
240 {
241 AudioProcessConfig configRet;
242 AudioMode modeRet = AUDIO_MODE_RECORD;
243 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
244 uint64_t latency;
245
246 auto ret = ipcStreamInServerRet.GetLatency(latency);
247 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
248
249 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
250 ret = ipcStreamInServerRet.GetLatency(latency);
251 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
252 ipcStreamInServerRet.ConfigCapturer();
253 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
254 ret = ipcStreamInServerRet.GetLatency(latency);
255 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
256 }
257
258 /**
259 * @tc.name : Test IpcStreamInServer API
260 * @tc.type : FUNC
261 * @tc.number: IpcStreamInServer_010
262 * @tc.desc : Test IpcStreamInServer interface.
263 */
264 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_010, TestSize.Level1)
265 {
266 AudioProcessConfig configRet;
267 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
268 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
269 float volumeRet = 0.5;
270
271 auto ret1 = ipcStreamInServerRet.SetLowPowerVolume(volumeRet);
272 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
273
274 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
275 ipcStreamInServerRet.ConfigRenderer();
276 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
277 auto ret2 = ipcStreamInServerRet.SetLowPowerVolume(volumeRet);
278 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
279 }
280
281 /**
282 * @tc.name : Test IpcStreamInServer API
283 * @tc.type : FUNC
284 * @tc.number: IpcStreamInServer_011
285 * @tc.desc : Test IpcStreamInServer interface.
286 */
287 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_011, TestSize.Level1)
288 {
289 AudioProcessConfig configRet;
290 AudioMode modeRet = AUDIO_MODE_RECORD;
291 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
292 float volumeRet = 0.5;
293
294 auto ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
295 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
296
297 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
298 ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
299 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
300
301 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
302 ipcStreamInServerRet.ConfigRenderer();
303 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
304 ret = ipcStreamInServerRet.GetLowPowerVolume(volumeRet);
305 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
306 }
307
308 /**
309 * @tc.name : Test IpcStreamInServer API
310 * @tc.type : FUNC
311 * @tc.number: IpcStreamInServer_012
312 * @tc.desc : Test IpcStreamInServer interface.
313 */
314 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_012, TestSize.Level1)
315 {
316 AudioProcessConfig configRet;
317 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
318 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
319
320 auto ret1 = ipcStreamInServerRet.SetAudioEffectMode(EFFECT_NONE);
321 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
322
323 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
324 ipcStreamInServerRet.ConfigRenderer();
325 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
326 auto ret2 = ipcStreamInServerRet.SetAudioEffectMode(EFFECT_NONE);
327 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
328 }
329
330 /**
331 * @tc.name : Test IpcStreamInServer API
332 * @tc.type : FUNC
333 * @tc.number: IpcStreamInServer_013
334 * @tc.desc : Test IpcStreamInServer interface.
335 */
336 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_013, TestSize.Level1)
337 {
338 AudioProcessConfig configRet;
339 AudioMode modeRet = AUDIO_MODE_RECORD;
340 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
341 int32_t effectModeRet = EFFECT_NONE;
342
343 auto ret1 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
344 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
345
346 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
347 auto ret2 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
348 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
349
350 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
351 ipcStreamInServerRet.ConfigRenderer();
352 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
353 auto ret3 = ipcStreamInServerRet.GetAudioEffectMode(effectModeRet);
354 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
355 }
356
357 /**
358 * @tc.name : Test IpcStreamInServer API
359 * @tc.type : FUNC
360 * @tc.number: IpcStreamInServer_014
361 * @tc.desc : Test IpcStreamInServer interface.
362 */
363 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_014, TestSize.Level1)
364 {
365 AudioProcessConfig configRet;
366 AudioMode modeRet = AUDIO_MODE_RECORD;
367 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
368 int32_t privacyTypeRet = EFFECT_NONE;
369
370 auto ret1 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
371 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
372
373 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
374 auto ret2 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
375 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
376
377 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
378 ipcStreamInServerRet.ConfigRenderer();
379 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
380 auto ret3 = ipcStreamInServerRet.SetPrivacyType(privacyTypeRet);
381 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
382 }
383
384 /**
385 * @tc.name : Test IpcStreamInServer API
386 * @tc.type : FUNC
387 * @tc.number: IpcStreamInServer_015
388 * @tc.desc : Test IpcStreamInServer interface.
389 */
390 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_015, TestSize.Level1)
391 {
392 AudioProcessConfig configRet;
393 AudioMode modeRet = AUDIO_MODE_RECORD;
394 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
395 int32_t privacyTypeRet = EFFECT_NONE;
396
397 auto ret1 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
398 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
399
400 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
401 auto ret2 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
402 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
403
404 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
405 ipcStreamInServerRet.ConfigRenderer();
406 auto ret3 = ipcStreamInServerRet.GetPrivacyType(privacyTypeRet);
407 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
408 }
409
410 /**
411 * @tc.name : Test IpcStreamInServer API
412 * @tc.type : FUNC
413 * @tc.number: IpcStreamInServer_016
414 * @tc.desc : Test IpcStreamInServer interface.
415 */
416 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_016, TestSize.Level1)
417 {
418 AudioProcessConfig configRet;
419 AudioMode modeRet = AUDIO_MODE_RECORD;
420 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
421 int32_t stateRet = EFFECT_NONE;
422 bool isAppBackRet = false;
423
424 auto ret1 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
425 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
426
427 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
428 auto ret2 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
429 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
430
431 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
432 ipcStreamInServerRet.ConfigRenderer();
433 auto ret3 = ipcStreamInServerRet.SetOffloadMode(stateRet, isAppBackRet);
434 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
435 }
436
437 /**
438 * @tc.name : Test IpcStreamInServer API
439 * @tc.type : FUNC
440 * @tc.number: IpcStreamInServer_017
441 * @tc.desc : Test IpcStreamInServer interface.
442 */
443 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_017, TestSize.Level1)
444 {
445 AudioProcessConfig configRet;
446 AudioMode modeRet = AUDIO_MODE_RECORD;
447 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
448
449 auto ret1 = ipcStreamInServerRet.UnsetOffloadMode();
450 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
451
452 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
453 auto ret2 = ipcStreamInServerRet.UnsetOffloadMode();
454 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
455
456 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
457 ipcStreamInServerRet.ConfigRenderer();
458 auto ret3 = ipcStreamInServerRet.UnsetOffloadMode();
459 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
460 }
461
462 /**
463 * @tc.name : Test IpcStreamInServer API
464 * @tc.type : FUNC
465 * @tc.number: IpcStreamInServer_018
466 * @tc.desc : Test IpcStreamInServer interface.
467 */
468 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_018, TestSize.Level1)
469 {
470 AudioProcessConfig configRet;
471 AudioMode modeRet = AUDIO_MODE_RECORD;
472 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
473 uint64_t timestampRet = EFFECT_NONE;
474 uint64_t paWriteIndexRet = EFFECT_NONE;
475 uint64_t cacheTimeDspRet = EFFECT_NONE;
476 uint64_t cacheTimePaRet = EFFECT_NONE;
477
478 auto ret1 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
479 cacheTimeDspRet, cacheTimePaRet);
480 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
481
482 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
483 auto ret2 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
484 cacheTimeDspRet, cacheTimePaRet);
485 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
486
487 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
488 ipcStreamInServerRet.ConfigRenderer();
489 auto ret3 = ipcStreamInServerRet.GetOffloadApproximatelyCacheTime(timestampRet, paWriteIndexRet,
490 cacheTimeDspRet, cacheTimePaRet);
491 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
492 }
493
494 /**
495 * @tc.name : Test IpcStreamInServer API
496 * @tc.type : FUNC
497 * @tc.number: IpcStreamInServer_020
498 * @tc.desc : Test IpcStreamInServer interface.
499 */
500 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_020, TestSize.Level1)
501 {
502 AudioProcessConfig configRet;
503 AudioMode modeRet = AUDIO_MODE_RECORD;
504 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
505 bool spatializationEnabledRet = false;
506 bool headTrackingEnabledRet = false;
507
508 auto ret1 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
509 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
510
511 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
512 auto ret2 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
513 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
514
515 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
516 ipcStreamInServerRet.ConfigRenderer();
517 auto ret3 = ipcStreamInServerRet.UpdateSpatializationState(spatializationEnabledRet, headTrackingEnabledRet);
518 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
519 }
520
521 /**
522 * @tc.name : Test IpcStreamInServer API
523 * @tc.type : FUNC
524 * @tc.number: IpcStreamInServer_021
525 * @tc.desc : Test IpcStreamInServer interface.
526 */
527 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_021, TestSize.Level1)
528 {
529 AudioProcessConfig configRet;
530 AudioMode modeRet = AUDIO_MODE_RECORD;
531 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
532
533 auto ret1 = ipcStreamInServerRet.GetStreamManagerType();
534 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
535
536 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
537 auto ret2 = ipcStreamInServerRet.GetStreamManagerType();
538 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
539
540 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
541 ipcStreamInServerRet.ConfigRenderer();
542 auto ret3 = ipcStreamInServerRet.GetStreamManagerType();
543 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
544 }
545
546 /**
547 * @tc.name : Test IpcStreamInServer API
548 * @tc.type : FUNC
549 * @tc.number: IpcStreamInServer_022
550 * @tc.desc : Test IpcStreamInServer interface.
551 */
552 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_022, TestSize.Level1)
553 {
554 AudioProcessConfig configRet;
555 AudioMode modeRet = AUDIO_MODE_RECORD;
556 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
557 bool onRet = false;
558
559 auto ret1 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
560 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
561
562 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
563 auto ret2 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
564 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
565
566 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
567 ipcStreamInServerRet.ConfigRenderer();
568 auto ret3 = ipcStreamInServerRet.SetSilentModeAndMixWithOthers(onRet);
569 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
570 }
571
572 /**
573 * @tc.name : Test IpcStreamInServer API
574 * @tc.type : FUNC
575 * @tc.number: IpcStreamInServer_023
576 * @tc.desc : Test IpcStreamInServer interface.
577 */
578 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_023, TestSize.Level1)
579 {
580 AudioProcessConfig configRet;
581 AudioMode modeRet = AUDIO_MODE_RECORD;
582 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
583
584 auto ret1 = ipcStreamInServerRet.SetClientVolume();
585 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
586
587 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
588 auto ret2 = ipcStreamInServerRet.SetClientVolume();
589 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
590
591 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
592 ipcStreamInServerRet.ConfigRenderer();
593 auto ret3 = ipcStreamInServerRet.SetClientVolume();
594 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
595 }
596
597 /**
598 * @tc.name : Test IpcStreamInServer API
599 * @tc.type : FUNC
600 * @tc.number: IpcStreamInServer_024
601 * @tc.desc : Test IpcStreamInServer interface.
602 */
603 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_024, TestSize.Level1)
604 {
605 AudioProcessConfig configRet;
606 AudioMode modeRet = AUDIO_MODE_RECORD;
607 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
608 uint32_t tidRet = 0;
609 std::string clientBundleNameRet;
610
611 auto ret = ipcStreamInServerRet.RegisterThreadPriority(tidRet, clientBundleNameRet);
612 EXPECT_EQ(ret, SUCCESS);
613
614 ipcStreamInServerRet.clientThreadPriorityRequested_ = true;
615 ret = ipcStreamInServerRet.RegisterThreadPriority(tidRet, clientBundleNameRet);
616 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
617 }
618
619 /**
620 * @tc.name : Test IpcStreamInServer API
621 * @tc.type : FUNC
622 * @tc.number: IpcStreamInServer_025
623 * @tc.desc : Test IpcStreamInServer interface.
624 */
625 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_025, TestSize.Level1)
626 {
627 AudioProcessConfig configRet;
628 AudioMode modeRet = AUDIO_MODE_RECORD;
629 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
630 int32_t rateRet = 0;
631 uint64_t famePosRet = 0;
632 uint64_t timestampRet = 0;
633 uint64_t latency = 0;
634
635 auto ret = ipcStreamInServerRet.SetRate(rateRet);
636 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
637 auto ret1 = ipcStreamInServerRet.GetAudioPosition(famePosRet, timestampRet, latency);
638 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
639
640 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
641 ret = ipcStreamInServerRet.SetRate(rateRet);
642 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
643
644 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
645 ipcStreamInServerRet.ConfigRenderer();
646 ret = ipcStreamInServerRet.SetRate(rateRet);
647 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
648 }
649
650 /**
651 * @tc.name : Test IpcStreamInServer API
652 * @tc.type : FUNC
653 * @tc.number: IpcStreamInServer_026
654 * @tc.desc : Test IpcStreamInServer interface.
655 */
656 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_026, TestSize.Level1)
657 {
658 AudioProcessConfig configRet;
659 AudioMode modeRet = AUDIO_MODE_RECORD;
660 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
661 uint64_t famePosRet = 0;
662 uint64_t timestampRet = 0;
663
664 auto ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
665 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
666
667 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
668 ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
669 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
670 ipcStreamInServerRet.ConfigCapturer();
671 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
672 ret = ipcStreamInServerRet.GetAudioTime(famePosRet, timestampRet);
673 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
674 }
675
676 /**
677 * @tc.name : Test IpcStreamInServer API
678 * @tc.type : FUNC
679 * @tc.number: IpcStreamInServer_027
680 * @tc.desc : Test IpcStreamInServer interface.
681 */
682 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_027, TestSize.Level1)
683 {
684 AudioProcessConfig configRet;
685 AudioMode modeRet = AUDIO_MODE_RECORD;
686 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
687 AudioPlaybackCaptureConfig config;
688
689 auto ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
690 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
691
692 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
693 ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
694 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
695 ipcStreamInServerRet.ConfigCapturer();
696 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
697 ret = ipcStreamInServerRet.UpdatePlaybackCaptureConfig(config);
698 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
699 }
700
701 /**
702 * @tc.name : Test IpcStreamInServer API
703 * @tc.type : FUNC
704 * @tc.number: IpcStreamInServer_028
705 * @tc.desc : Test IpcStreamInServer interface.
706 */
707 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_028, TestSize.Level1)
708 {
709 AudioProcessConfig configRet;
710 AudioMode modeRet = AUDIO_MODE_RECORD;
711 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
712 bool stopFlagRet = false;
713
714 auto ret = ipcStreamInServerRet.Drain(stopFlagRet);
715 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
716
717 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
718 ret = ipcStreamInServerRet.Drain(stopFlagRet);
719 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
720
721 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
722 ipcStreamInServerRet.ConfigRenderer();
723 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
724 ret = ipcStreamInServerRet.Drain(stopFlagRet);
725 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
726 }
727
728 /**
729 * @tc.name : Test IpcStreamInServer API
730 * @tc.type : FUNC
731 * @tc.number: IpcStreamInServer_029
732 * @tc.desc : Test IpcStreamInServer interface.
733 */
734 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_029, TestSize.Level1)
735 {
736 AudioProcessConfig configRet;
737 AudioMode modeRet = AUDIO_MODE_RECORD;
738 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
739
740 auto ret = ipcStreamInServerRet.Flush();
741 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
742
743 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
744 ret = ipcStreamInServerRet.Flush();
745 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
746 ipcStreamInServerRet.ConfigCapturer();
747 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
748 ret = ipcStreamInServerRet.Flush();
749 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
750 }
751
752 /**
753 * @tc.name : Test IpcStreamInServer API
754 * @tc.type : FUNC
755 * @tc.number: IpcStreamInServer_030
756 * @tc.desc : Test IpcStreamInServer interface.
757 */
758 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_030, TestSize.Level1)
759 {
760 AudioProcessConfig configRet;
761 AudioMode modeRet = AUDIO_MODE_RECORD;
762 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
763
764 auto ret = ipcStreamInServerRet.Release();
765 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
766
767 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
768 ret = ipcStreamInServerRet.Release();
769 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
770
771 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
772 ipcStreamInServerRet.ConfigRenderer();
773 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
774 ret = ipcStreamInServerRet.Release();
775 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
776 }
777
778 /**
779 * @tc.name : Test IpcStreamInServer API
780 * @tc.type : FUNC
781 * @tc.number: IpcStreamInServer_031
782 * @tc.desc : Test IpcStreamInServer interface.
783 */
784 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_031, TestSize.Level1)
785 {
786 AudioProcessConfig configRet;
787 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
788 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
789
790 auto ret = ipcStreamInServerRet.Stop();
791 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
792
793 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
794 ret = ipcStreamInServerRet.Stop();
795 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
796
797 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
798 ipcStreamInServerRet.ConfigCapturer();
799 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
800 ret = ipcStreamInServerRet.Stop();
801 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
802 }
803
804 /**
805 * @tc.name : Test IpcStreamInServer API
806 * @tc.type : FUNC
807 * @tc.number: IpcStreamInServer_032
808 * @tc.desc : Test IpcStreamInServer interface.
809 */
810 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_032, TestSize.Level1)
811 {
812 AudioProcessConfig configRet;
813 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
814 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
815
816 auto ret = ipcStreamInServerRet.Pause();
817 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
818
819 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
820 ret = ipcStreamInServerRet.Pause();
821 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
822
823 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
824 ipcStreamInServerRet.ConfigCapturer();
825 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
826 ret = ipcStreamInServerRet.Pause();
827 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
828 }
829
830 /**
831 * @tc.name : Test IpcStreamInServer API
832 * @tc.type : FUNC
833 * @tc.number: IpcStreamInServer_033
834 * @tc.desc : Test IpcStreamInServer interface.
835 */
836 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_033, TestSize.Level1)
837 {
838 AudioProcessConfig configRet;
839 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
840 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
841 std::shared_ptr<OHAudioBuffer> buffer;
842
843 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
844 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
845
846 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
847 ret = ipcStreamInServerRet.ResolveBuffer(buffer);
848 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
849
850 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
851 ipcStreamInServerRet.ConfigCapturer();
852 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
853 ret = ipcStreamInServerRet.ResolveBuffer(buffer);
854 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
855 }
856
857 /**
858 * @tc.name : Test IpcStreamInServer API
859 * @tc.type : FUNC
860 * @tc.number: IpcStreamInServer_034
861 * @tc.desc : Test IpcStreamInServer interface.
862 */
863 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_034, TestSize.Level1)
864 {
865 AudioProcessConfig configRet;
866 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
867 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
868
869 auto ret = ipcStreamInServerRet.GetCapturer();
870 EXPECT_EQ(ret, nullptr);
871
872 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
873 ret = ipcStreamInServerRet.GetCapturer();
874 EXPECT_EQ(ret, nullptr);
875
876 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
877 ipcStreamInServerRet.ConfigCapturer();
878 EXPECT_NE(ipcStreamInServerRet.capturerInServer_, nullptr);
879 ret = ipcStreamInServerRet.GetCapturer();
880 EXPECT_EQ(ret, nullptr);
881 }
882
883 /**
884 * @tc.name : Test IpcStreamInServer API
885 * @tc.type : FUNC
886 * @tc.number: IpcStreamInServer_035
887 * @tc.desc : Test IpcStreamInServer interface.
888 */
889 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_035, TestSize.Level1)
890 {
891 AudioProcessConfig configRet;
892 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
893 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
894
895 auto ret = ipcStreamInServerRet.GetRenderer();
896 EXPECT_EQ(ret, nullptr);
897
898 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
899 ret = ipcStreamInServerRet.GetRenderer();
900 EXPECT_EQ(ret, nullptr);
901
902 ipcStreamInServerRet.ConfigRenderer();
903 EXPECT_NE(ipcStreamInServerRet.rendererInServer_, nullptr);
904 ret = ipcStreamInServerRet.GetRenderer();
905 EXPECT_EQ(ret, nullptr);
906 }
907
908 /**
909 * @tc.name : Test IpcStreamInServer API
910 * @tc.type : FUNC
911 * @tc.number: IpcStreamInServer_036
912 * @tc.desc : Test IpcStreamInServer interface.
913 */
914 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_036, TestSize.Level1)
915 {
916 AudioProcessConfig configRet;
917 AudioMode modeRet = AUDIO_MODE_RECORD;
918 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
919 bool onRet = false;
920
921 auto ret1 = ipcStreamInServerRet.SetMute(onRet);
922 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
923
924 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
925 auto ret2 = ipcStreamInServerRet.SetMute(onRet);
926 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
927
928 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
929 ipcStreamInServerRet.ConfigRenderer();
930 auto ret3 = ipcStreamInServerRet.SetMute(onRet);
931 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
932 }
933
934 /**
935 * @tc.name : Test IpcStreamInServer API
936 * @tc.type : FUNC
937 * @tc.number: IpcStreamInServer_037
938 * @tc.desc : Test IpcStreamInServer interface.
939 */
940 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_037, TestSize.Level1)
941 {
942 AudioProcessConfig configRet;
943 AudioMode modeRet = AUDIO_MODE_RECORD;
944 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
945 float duckFactor = 0.2f;
946
947 auto ret1 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
948 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
949
950 ipcStreamInServerRet.mode_ = AUDIO_MODE_PLAYBACK;
951 auto ret2 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
952 EXPECT_EQ(ret2, ERR_OPERATION_FAILED);
953
954 ipcStreamInServerRet.mode_ = AUDIO_MODE_RECORD;
955 ipcStreamInServerRet.ConfigRenderer();
956 auto ret3 = ipcStreamInServerRet.SetDuckFactor(duckFactor);
957 EXPECT_EQ(ret3, ERR_OPERATION_FAILED);
958 }
959
960 /**
961 * @tc.name : Test IpcStreamInServer API
962 * @tc.type : FUNC
963 * @tc.number: IpcStreamInServer_038
964 * @tc.desc : Test Config interface.
965 */
966 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_038, TestSize.Level1)
967 {
968 int defaultAudioMode = 3;
969 AudioProcessConfig configRet;
970 AudioMode modeRet = static_cast<AudioMode>(defaultAudioMode);
971 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
972
973 auto ret1 = ipcStreamInServerRet.Config();
974 EXPECT_EQ(ret1, ERR_OPERATION_FAILED);
975 }
976
977 /**
978 * @tc.name : Test IpcStreamInServer API
979 * @tc.type : FUNC
980 * @tc.number: IpcStreamInServer_039
981 * @tc.desc : Test GetRenderer interface.
982 */
983 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_039, TestSize.Level1)
984 {
985 AudioProcessConfig configRet;
986 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
987 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
988
989 ipcStreamInServerRet.rendererInServer_ = nullptr;
990 auto ret1 = ipcStreamInServerRet.GetRenderer();
991 EXPECT_EQ(ret1, nullptr);
992 }
993
994 /**
995 * @tc.name : Test IpcStreamInServer API
996 * @tc.type : FUNC
997 * @tc.number: IpcStreamInServer_040
998 * @tc.desc : Test GetCapturer interface.
999 */
1000 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_040, TestSize.Level1)
1001 {
1002 AudioProcessConfig configRet;
1003 AudioMode modeRet = AUDIO_MODE_RECORD;
1004 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1005
1006 ipcStreamInServerRet.capturerInServer_ = nullptr;
1007 auto ret = ipcStreamInServerRet.GetCapturer();
1008 EXPECT_EQ(ret, nullptr);
1009 }
1010
1011 /**
1012 * @tc.name : Test IpcStreamInServer API
1013 * @tc.type : FUNC
1014 * @tc.number: IpcStreamInServer_041
1015 * @tc.desc : Test ResolveBuffer interface.
1016 */
1017 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_041, TestSize.Level1)
1018 {
1019 AudioProcessConfig configRet;
1020 AudioMode modeRet = AUDIO_MODE_RECORD;
1021 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1022 std::shared_ptr<OHAudioBuffer> buffer;
1023
1024 ipcStreamInServerRet.rendererInServer_ = nullptr;
1025 ipcStreamInServerRet.capturerInServer_ = nullptr;
1026 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1027 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1028 }
1029
1030 /**
1031 * @tc.name : Test IpcStreamInServer API
1032 * @tc.type : FUNC
1033 * @tc.number: IpcStreamInServer_042
1034 * @tc.desc : Test ResolveBuffer interface.
1035 */
1036 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_042, TestSize.Level1)
1037 {
1038 AudioProcessConfig configRet;
1039 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1040 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1041 std::shared_ptr<OHAudioBuffer> buffer;
1042
1043 ipcStreamInServerRet.rendererInServer_ = nullptr;
1044 ipcStreamInServerRet.capturerInServer_ = nullptr;
1045 auto ret = ipcStreamInServerRet.ResolveBuffer(buffer);
1046 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1047 }
1048
1049 /**
1050 * @tc.name : Test IpcStreamInServer API
1051 * @tc.type : FUNC
1052 * @tc.number: IpcStreamInServer_043
1053 * @tc.desc : Test UpdatePosition interface.
1054 */
1055 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_043, TestSize.Level1)
1056 {
1057 AudioProcessConfig configRet;
1058 AudioMode modeRet = AUDIO_MODE_RECORD;
1059 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1060
1061 ipcStreamInServerRet.rendererInServer_ = nullptr;
1062 ipcStreamInServerRet.capturerInServer_ = nullptr;
1063 auto ret = ipcStreamInServerRet.UpdatePosition();
1064 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1065 }
1066
1067 /**
1068 * @tc.name : Test IpcStreamInServer API
1069 * @tc.type : FUNC
1070 * @tc.number: IpcStreamInServer_044
1071 * @tc.desc : Test UpdatePosition interface.
1072 */
1073 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_044, TestSize.Level1)
1074 {
1075 AudioProcessConfig configRet;
1076 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1077 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1078
1079 ipcStreamInServerRet.rendererInServer_ = nullptr;
1080 ipcStreamInServerRet.capturerInServer_ = nullptr;
1081 auto ret = ipcStreamInServerRet.UpdatePosition();
1082 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1083 }
1084
1085 /**
1086 * @tc.name : Test IpcStreamInServer API
1087 * @tc.type : FUNC
1088 * @tc.number: IpcStreamInServer_045
1089 * @tc.desc : Test GetAudioSessionID interface.
1090 */
1091 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_045, TestSize.Level1)
1092 {
1093 AudioProcessConfig configRet;
1094 AudioMode modeRet = AUDIO_MODE_RECORD;
1095 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1096 uint32_t sessionId = 0;
1097
1098 ipcStreamInServerRet.rendererInServer_ = nullptr;
1099 ipcStreamInServerRet.capturerInServer_ = nullptr;
1100 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1101 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1102 }
1103
1104 /**
1105 * @tc.name : Test IpcStreamInServer API
1106 * @tc.type : FUNC
1107 * @tc.number: IpcStreamInServer_046
1108 * @tc.desc : Test GetAudioSessionID interface.
1109 */
1110 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_046, TestSize.Level1)
1111 {
1112 AudioProcessConfig configRet;
1113 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1114 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1115 uint32_t sessionId = 0;
1116
1117 ipcStreamInServerRet.rendererInServer_ = nullptr;
1118 ipcStreamInServerRet.capturerInServer_ = nullptr;
1119 auto ret = ipcStreamInServerRet.GetAudioSessionID(sessionId);
1120 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1121 }
1122
1123 /**
1124 * @tc.name : Test IpcStreamInServer API
1125 * @tc.type : FUNC
1126 * @tc.number: IpcStreamInServer_047
1127 * @tc.desc : Test Start interface.
1128 */
1129 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_047, TestSize.Level1)
1130 {
1131 AudioProcessConfig configRet;
1132 AudioMode modeRet = AUDIO_MODE_RECORD;
1133 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1134
1135 ipcStreamInServerRet.rendererInServer_ = nullptr;
1136 ipcStreamInServerRet.capturerInServer_ = nullptr;
1137 auto ret = ipcStreamInServerRet.Start();
1138 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1139 }
1140
1141 /**
1142 * @tc.name : Test IpcStreamInServer API
1143 * @tc.type : FUNC
1144 * @tc.number: IpcStreamInServer_048
1145 * @tc.desc : Test Start interface.
1146 */
1147 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_048, TestSize.Level1)
1148 {
1149 AudioProcessConfig configRet;
1150 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1151 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1152
1153 ipcStreamInServerRet.rendererInServer_ = nullptr;
1154 ipcStreamInServerRet.capturerInServer_ = nullptr;
1155 auto ret = ipcStreamInServerRet.Start();
1156 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1157 }
1158
1159 /**
1160 * @tc.name : Test IpcStreamInServer API
1161 * @tc.type : FUNC
1162 * @tc.number: IpcStreamInServer_049
1163 * @tc.desc : Test Pause interface.
1164 */
1165 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_049, TestSize.Level1)
1166 {
1167 AudioProcessConfig configRet;
1168 AudioMode modeRet = AUDIO_MODE_RECORD;
1169 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1170
1171 ipcStreamInServerRet.rendererInServer_ = nullptr;
1172 ipcStreamInServerRet.capturerInServer_ = nullptr;
1173 auto ret = ipcStreamInServerRet.Pause();
1174 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1175 }
1176
1177 /**
1178 * @tc.name : Test IpcStreamInServer API
1179 * @tc.type : FUNC
1180 * @tc.number: IpcStreamInServer_050
1181 * @tc.desc : Test Pause interface.
1182 */
1183 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_050, TestSize.Level1)
1184 {
1185 AudioProcessConfig configRet;
1186 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1187 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1188
1189 ipcStreamInServerRet.rendererInServer_ = nullptr;
1190 ipcStreamInServerRet.capturerInServer_ = nullptr;
1191 auto ret = ipcStreamInServerRet.Pause();
1192 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1193 }
1194
1195 /**
1196 * @tc.name : Test IpcStreamInServer API
1197 * @tc.type : FUNC
1198 * @tc.number: IpcStreamInServer_051
1199 * @tc.desc : Test Stop interface.
1200 */
1201 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_051, TestSize.Level1)
1202 {
1203 AudioProcessConfig configRet;
1204 AudioMode modeRet = AUDIO_MODE_RECORD;
1205 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1206
1207 ipcStreamInServerRet.rendererInServer_ = nullptr;
1208 ipcStreamInServerRet.capturerInServer_ = nullptr;
1209 auto ret = ipcStreamInServerRet.Stop();
1210 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1211 }
1212
1213 /**
1214 * @tc.name : Test IpcStreamInServer API
1215 * @tc.type : FUNC
1216 * @tc.number: IpcStreamInServer_052
1217 * @tc.desc : Test Stop interface.
1218 */
1219 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_052, TestSize.Level1)
1220 {
1221 AudioProcessConfig configRet;
1222 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1223 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1224
1225 ipcStreamInServerRet.rendererInServer_ = nullptr;
1226 ipcStreamInServerRet.capturerInServer_ = nullptr;
1227 auto ret = ipcStreamInServerRet.Stop();
1228 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1229 }
1230
1231 /**
1232 * @tc.name : Test IpcStreamInServer API
1233 * @tc.type : FUNC
1234 * @tc.number: IpcStreamInServer_053
1235 * @tc.desc : Test Release interface.
1236 */
1237 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_053, TestSize.Level1)
1238 {
1239 AudioProcessConfig configRet;
1240 AudioMode modeRet = AUDIO_MODE_RECORD;
1241 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1242
1243 ipcStreamInServerRet.rendererInServer_ = nullptr;
1244 ipcStreamInServerRet.capturerInServer_ = nullptr;
1245 auto ret = ipcStreamInServerRet.Release();
1246 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1247 }
1248
1249 /**
1250 * @tc.name : Test IpcStreamInServer API
1251 * @tc.type : FUNC
1252 * @tc.number: IpcStreamInServer_054
1253 * @tc.desc : Test Release interface.
1254 */
1255 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_054, TestSize.Level1)
1256 {
1257 AudioProcessConfig configRet;
1258 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1259 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1260
1261 ipcStreamInServerRet.rendererInServer_ = nullptr;
1262 ipcStreamInServerRet.capturerInServer_ = nullptr;
1263 auto ret = ipcStreamInServerRet.Release();
1264 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1265 }
1266
1267 /**
1268 * @tc.name : Test IpcStreamInServer API
1269 * @tc.type : FUNC
1270 * @tc.number: IpcStreamInServer_055
1271 * @tc.desc : Test Flush interface.
1272 */
1273 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_055, TestSize.Level1)
1274 {
1275 AudioProcessConfig configRet;
1276 AudioMode modeRet = AUDIO_MODE_RECORD;
1277 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1278
1279 ipcStreamInServerRet.rendererInServer_ = nullptr;
1280 ipcStreamInServerRet.capturerInServer_ = nullptr;
1281 auto ret = ipcStreamInServerRet.Flush();
1282 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1283 }
1284
1285 /**
1286 * @tc.name : Test IpcStreamInServer API
1287 * @tc.type : FUNC
1288 * @tc.number: IpcStreamInServer_056
1289 * @tc.desc : Test Flush interface.
1290 */
1291 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_056, TestSize.Level1)
1292 {
1293 AudioProcessConfig configRet;
1294 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1295 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1296
1297 ipcStreamInServerRet.rendererInServer_ = nullptr;
1298 ipcStreamInServerRet.capturerInServer_ = nullptr;
1299 auto ret = ipcStreamInServerRet.Flush();
1300 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1301 }
1302
1303 /**
1304 * @tc.name : Test IpcStreamInServer API
1305 * @tc.type : FUNC
1306 * @tc.number: IpcStreamInServer_057
1307 * @tc.desc : Test Flush interface.
1308 */
1309 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_057, TestSize.Level1)
1310 {
1311 AudioProcessConfig configRet;
1312 AudioMode modeRet = AUDIO_MODE_RECORD;
1313 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1314
1315 bool stopFlag = true;
1316 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1317 ipcStreamInServerRet.streamListenerHolder_);
1318 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1319
1320 auto result = ipcStreamInServerRet.Drain(stopFlag);
1321 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1322 }
1323
1324 /**
1325 * @tc.name : Test IpcStreamInServer API
1326 * @tc.type : FUNC
1327 * @tc.number: IpcStreamInServer_058
1328 * @tc.desc : Test GetAudioTime interface.
1329 */
1330 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_058, TestSize.Level1)
1331 {
1332 AudioProcessConfig configRet;
1333 AudioMode modeRet = AUDIO_MODE_RECORD;
1334 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1335
1336 uint64_t framePos = 0;
1337 uint64_t timestamp = 0;
1338
1339 ipcStreamInServerRet.rendererInServer_ = nullptr;
1340 ipcStreamInServerRet.capturerInServer_ = nullptr;
1341 auto ret = ipcStreamInServerRet.GetAudioTime(framePos, timestamp);
1342 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1343 }
1344
1345 /**
1346 * @tc.name : Test IpcStreamInServer API
1347 * @tc.type : FUNC
1348 * @tc.number: IpcStreamInServer_059
1349 * @tc.desc : Test GetAudioTime interface.
1350 */
1351 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_059, TestSize.Level1)
1352 {
1353 AudioProcessConfig configRet;
1354 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1355 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1356
1357 uint64_t framePos = 0;
1358 uint64_t timestamp = 0;
1359
1360 ipcStreamInServerRet.rendererInServer_ = nullptr;
1361 ipcStreamInServerRet.capturerInServer_ = nullptr;
1362 auto ret = ipcStreamInServerRet.GetAudioTime(framePos, timestamp);
1363 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1364 }
1365
1366 /**
1367 * @tc.name : Test IpcStreamInServer API
1368 * @tc.type : FUNC
1369 * @tc.number: IpcStreamInServer_060
1370 * @tc.desc : Test GetAudioPosition interface.
1371 */
1372 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_060, TestSize.Level1)
1373 {
1374 AudioProcessConfig configRet;
1375 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1376 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1377
1378 uint64_t framePos = 0;
1379 uint64_t timestamp = 0;
1380 uint64_t latency = 0;
1381 ipcStreamInServerRet.rendererInServer_ = nullptr;
1382
1383 auto ret = ipcStreamInServerRet.GetAudioPosition(framePos, timestamp, latency);
1384 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1385 }
1386
1387 /**
1388 * @tc.name : Test IpcStreamInServer API
1389 * @tc.type : FUNC
1390 * @tc.number: IpcStreamInServer_061
1391 * @tc.desc : Test GetLatency interface.
1392 */
1393 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_061, TestSize.Level1)
1394 {
1395 AudioProcessConfig configRet;
1396 AudioMode modeRet = AUDIO_MODE_RECORD;
1397 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1398
1399 uint64_t latency = 0;
1400 ipcStreamInServerRet.rendererInServer_ = nullptr;
1401 ipcStreamInServerRet.capturerInServer_ = nullptr;
1402 auto ret = ipcStreamInServerRet.GetLatency(latency);
1403 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1404 }
1405
1406 /**
1407 * @tc.name : Test IpcStreamInServer API
1408 * @tc.type : FUNC
1409 * @tc.number: IpcStreamInServer_062
1410 * @tc.desc : Test GetLatency interface.
1411 */
1412 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_062, TestSize.Level1)
1413 {
1414 AudioProcessConfig configRet;
1415 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1416 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1417
1418 uint64_t latency = 0;
1419 ipcStreamInServerRet.rendererInServer_ = nullptr;
1420 ipcStreamInServerRet.capturerInServer_ = nullptr;
1421 auto ret = ipcStreamInServerRet.GetLatency(latency);
1422 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
1423 }
1424
1425 /**
1426 * @tc.name : Test IpcStreamInServer API
1427 * @tc.type : FUNC
1428 * @tc.number: IpcStreamInServer_063
1429 * @tc.desc : Test SetRate interface.
1430 */
1431 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_063, TestSize.Level1)
1432 {
1433 AudioProcessConfig configRet;
1434 AudioMode modeRet = AUDIO_MODE_RECORD;
1435 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1436
1437 int32_t rate = 0;
1438 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1439 ipcStreamInServerRet.streamListenerHolder_);
1440 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1441
1442 auto result = ipcStreamInServerRet.SetRate(rate);
1443 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1444 }
1445
1446 /**
1447 * @tc.name : Test IpcStreamInServer API
1448 * @tc.type : FUNC
1449 * @tc.number: IpcStreamInServer_064
1450 * @tc.desc : Test SetDuckFactor interface.
1451 */
1452 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_064, TestSize.Level1)
1453 {
1454 AudioProcessConfig configRet;
1455 AudioMode modeRet = AUDIO_MODE_RECORD;
1456 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1457
1458 float duckFactor = 0.1;
1459 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1460 ipcStreamInServerRet.streamListenerHolder_);
1461 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1462
1463 auto result = ipcStreamInServerRet.SetDuckFactor(duckFactor);
1464 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1465 }
1466
1467 /**
1468 * @tc.name : Test IpcStreamInServer API
1469 * @tc.type : FUNC
1470 * @tc.number: IpcStreamInServer_065
1471 * @tc.desc : Test SetDefaultOutputDevice interface.
1472 */
1473 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_065, TestSize.Level1)
1474 {
1475 AudioProcessConfig configRet;
1476 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1477 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1478
1479 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1480 ipcStreamInServerRet.streamListenerHolder_);
1481 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1482
1483 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1484 EXPECT_EQ(result, ERROR);
1485 }
1486
1487 /**
1488 * @tc.name : Test IpcStreamInServer API
1489 * @tc.type : FUNC
1490 * @tc.number: IpcStreamInServer_066
1491 * @tc.desc : Test SetDefaultOutputDevice interface.
1492 */
1493 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_066, TestSize.Level1)
1494 {
1495 AudioProcessConfig configRet;
1496 AudioMode modeRet = AUDIO_MODE_RECORD;
1497 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1498
1499 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1500 ipcStreamInServerRet.streamListenerHolder_);
1501 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1502
1503 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1504 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1505 }
1506
1507 /**
1508 * @tc.name : Test IpcStreamInServer API
1509 * @tc.type : FUNC
1510 * @tc.number: IpcStreamInServer_067
1511 * @tc.desc : Test SetDefaultOutputDevice interface.
1512 */
1513 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_067, TestSize.Level1)
1514 {
1515 AudioProcessConfig configRet;
1516 AudioMode modeRet = AUDIO_MODE_RECORD;
1517 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1518
1519 ipcStreamInServerRet.rendererInServer_ = nullptr;
1520 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1521 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1522 }
1523
1524 /**
1525 * @tc.name : Test IpcStreamInServer API
1526 * @tc.type : FUNC
1527 * @tc.number: IpcStreamInServer_068
1528 * @tc.desc : Test SetDefaultOutputDevice interface.
1529 */
1530 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_068, TestSize.Level1)
1531 {
1532 AudioProcessConfig configRet;
1533 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1534 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1535
1536 ipcStreamInServerRet.rendererInServer_ = nullptr;
1537 auto result = ipcStreamInServerRet.SetDefaultOutputDevice(DeviceType::DEVICE_TYPE_BLUETOOTH_A2DP);
1538 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1539 }
1540
1541 /**
1542 * @tc.name : Test IpcStreamInServer API
1543 * @tc.type : FUNC
1544 * @tc.number: IpcStreamInServer_069
1545 * @tc.desc : Test SetSourceDuration interface.
1546 */
1547 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_069, TestSize.Level1)
1548 {
1549 AudioProcessConfig configRet;
1550 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1551 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1552
1553 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1554 ipcStreamInServerRet.streamListenerHolder_);
1555 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1556
1557 int64_t duration = 0;
1558 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1559 EXPECT_EQ(result, SUCCESS);
1560 }
1561
1562 /**
1563 * @tc.name : Test IpcStreamInServer API
1564 * @tc.type : FUNC
1565 * @tc.number: IpcStreamInServer_070
1566 * @tc.desc : Test SetDefaultOutputDevice interface.
1567 */
1568 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_070, TestSize.Level1)
1569 {
1570 AudioProcessConfig configRet;
1571 AudioMode modeRet = AUDIO_MODE_RECORD;
1572 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1573
1574 ipcStreamInServerRet.rendererInServer_ = std::make_shared<RendererInServer>(ipcStreamInServerRet.config_,
1575 ipcStreamInServerRet.streamListenerHolder_);
1576 ASSERT_TRUE(ipcStreamInServerRet.rendererInServer_ != nullptr);
1577
1578 int64_t duration = 0;
1579 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1580 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1581 }
1582
1583 /**
1584 * @tc.name : Test IpcStreamInServer API
1585 * @tc.type : FUNC
1586 * @tc.number: IpcStreamInServer_071
1587 * @tc.desc : Test SetDefaultOutputDevice interface.
1588 */
1589 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_071, TestSize.Level1)
1590 {
1591 AudioProcessConfig configRet;
1592 AudioMode modeRet = AUDIO_MODE_RECORD;
1593 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1594
1595 ipcStreamInServerRet.rendererInServer_ = nullptr;
1596 int64_t duration = 0;
1597 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1598 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1599 }
1600
1601 /**
1602 * @tc.name : Test IpcStreamInServer API
1603 * @tc.type : FUNC
1604 * @tc.number: IpcStreamInServer_072
1605 * @tc.desc : Test SetDefaultOutputDevice interface.
1606 */
1607 HWTEST(IpcStreamInServerUnitTest, IpcStreamInServer_072, TestSize.Level1)
1608 {
1609 AudioProcessConfig configRet;
1610 AudioMode modeRet = AUDIO_MODE_PLAYBACK;
1611 IpcStreamInServer ipcStreamInServerRet(configRet, modeRet);
1612
1613 ipcStreamInServerRet.rendererInServer_ = nullptr;
1614 int64_t duration = 0;
1615 auto result = ipcStreamInServerRet.SetSourceDuration(duration);
1616 EXPECT_EQ(result, ERR_OPERATION_FAILED);
1617 }
1618 }
1619 }
1620