1 /*
2 * Copyright (c) 2024 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include <gtest/gtest.h>
16 #include "none_mix_engine.h"
17 #include "sink/i_audio_render_sink.h"
18 #include "common/hdi_adapter_info.h"
19 #include "manager/hdi_adapter_manager.h"
20 #include "pro_renderer_stream_impl.h"
21 #include "audio_errors.h"
22
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace AudioStandard {
26 constexpr int32_t DEFAULT_STREAM_ID = 10;
27 class NoneMixEngineUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33
34 protected:
35 AudioProcessConfig InitProcessConfig();
36
37 protected:
38 std::unique_ptr<AudioPlaybackEngine> playbackEngine_;
39 };
40
SetUpTestCase(void)41 void NoneMixEngineUnitTest::SetUpTestCase(void)
42 {
43 // input testsuit setup step，setup invoked before all testcases
44 }
45
TearDownTestCase(void)46 void NoneMixEngineUnitTest::TearDownTestCase(void)
47 {
48 // input testsuit teardown step，teardown invoked after all testcases
49 }
50
SetUp(void)51 void NoneMixEngineUnitTest::SetUp(void)
52 {
53 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
54 deviceInfo.deviceType_ = DEVICE_TYPE_USB_HEADSET;
55 playbackEngine_ = std::make_unique<NoneMixEngine>();
56 playbackEngine_->Init(deviceInfo, false);
57 }
58
TearDown(void)59 void NoneMixEngineUnitTest::TearDown(void)
60 {
61 if (playbackEngine_) {
62 playbackEngine_->Stop();
63 playbackEngine_ = nullptr;
64 }
65 }
66
InitProcessConfig()67 AudioProcessConfig NoneMixEngineUnitTest::InitProcessConfig()
68 {
69 AudioProcessConfig config;
70 config.appInfo.appUid = DEFAULT_STREAM_ID;
71 config.appInfo.appPid = DEFAULT_STREAM_ID;
72 config.streamInfo.format = SAMPLE_S32LE;
73 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
74 config.streamInfo.channels = STEREO;
75 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
76 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
77 config.streamType = AudioStreamType::STREAM_MUSIC;
78 config.deviceType = DEVICE_TYPE_USB_HEADSET;
79 return config;
80 }
81
82 /**
83 * @tc.name : Test Direct Audio Playback Engine State
84 * @tc.type : FUNC
85 * @tc.number: DirectAudioPlayBackEngineState_001
86 * @tc.desc : Test direct audio playback engine state(start->pause->flush->stop->release) success
87 */
88 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_001, TestSize.Level1)
89 {
90 AudioProcessConfig config = InitProcessConfig();
91 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
92 int32_t ret = rendererStream->InitParams();
93 EXPECT_EQ(SUCCESS, ret);
94 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
95 ret = rendererStream->Start();
96 EXPECT_EQ(SUCCESS, ret);
97 ret = rendererStream->Pause();
98 EXPECT_EQ(SUCCESS, ret);
99 ret = rendererStream->Flush();
100 EXPECT_EQ(SUCCESS, ret);
101 ret = rendererStream->Stop();
102 EXPECT_EQ(SUCCESS, ret);
103 ret = rendererStream->Release();
104 EXPECT_EQ(SUCCESS, ret);
105 }
106
107 /**
108 * @tc.name : Test Direct Audio Playback Engine State
109 * @tc.type : FUNC
110 * @tc.number: DirectAudioPlayBackEngineState_002
111 * @tc.desc : Test direct audio playback engine state init success
112 */
113 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_002, TestSize.Level1)
114 {
115 AudioProcessConfig config;
116 config.appInfo.appUid = DEFAULT_STREAM_ID;
117 config.appInfo.appPid = DEFAULT_STREAM_ID;
118 config.streamInfo.format = SAMPLE_S32LE;
119 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
120 config.streamInfo.channels = STEREO;
121 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
122 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
123 config.streamType = AudioStreamType::STREAM_MUSIC;
124 config.deviceType = DEVICE_TYPE_USB_HEADSET;
125 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
126 int32_t ret = rendererStream->InitParams();
127 EXPECT_EQ(SUCCESS, ret);
128
129 // ERR_ILLEGAL_STATE
130 ret = rendererStream->Start();
131 EXPECT_EQ(SUCCESS, ret);
132 ret = rendererStream->InitParams();
133 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
134
135 // ERR_ILLEGAL_STATE
136 ret = rendererStream->Stop();
137 EXPECT_EQ(SUCCESS, ret);
138 ret = rendererStream->InitParams();
139 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
140
141 ret = rendererStream->Release();
142 EXPECT_EQ(SUCCESS, ret);
143 ret = rendererStream->InitParams();
144 EXPECT_EQ(SUCCESS, ret);
145 }
146
147 /**
148 * @tc.name : Test Direct Audio Playback Engine State
149 * @tc.type : FUNC
150 * @tc.number: DirectAudioPlayBackEngineState_003
151 * @tc.desc : Test direct audio playback engine state start success
152 */
153 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_003, TestSize.Level1)
154 {
155 AudioProcessConfig config = InitProcessConfig();
156 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
157 int32_t ret = rendererStream->InitParams();
158 EXPECT_EQ(SUCCESS, ret);
159 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
160 ret = rendererStream->Start();
161 EXPECT_EQ(SUCCESS, ret);
162 ret = rendererStream->Stop();
163 EXPECT_EQ(SUCCESS, ret);
164 ret = rendererStream->Release();
165 EXPECT_EQ(SUCCESS, ret);
166
167 // ERR_ILLEGAL_STATE
168 ret = rendererStream->Start();
169 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
170 }
171
172 /**
173 * @tc.name : Test Direct Audio Playback Engine State
174 * @tc.type : FUNC
175 * @tc.number: DirectAudioPlayBackEngineState_004
176 * @tc.desc : Test direct audio playback engine state pause success
177 */
178 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_004, TestSize.Level1)
179 {
180 AudioProcessConfig config = InitProcessConfig();
181 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
182 int32_t ret = rendererStream->InitParams();
183 EXPECT_EQ(SUCCESS, ret);
184 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
185 ret = rendererStream->Start();
186 EXPECT_EQ(SUCCESS, ret);
187 ret = rendererStream->Pause();
188 EXPECT_EQ(SUCCESS, ret);
189 ret = rendererStream->Stop();
190 EXPECT_EQ(SUCCESS, ret);
191 ret = rendererStream->Release();
192 EXPECT_EQ(SUCCESS, ret);
193 }
194
195 /**
196 * @tc.name : Test Direct Audio Playback Engine State
197 * @tc.type : FUNC
198 * @tc.number: DirectAudioPlayBackEngineState_005
199 * @tc.desc : Test direct audio playback engine state flush success
200 */
201 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_005, TestSize.Level1)
202 {
203 AudioProcessConfig config = InitProcessConfig();
204 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
205 int32_t ret = rendererStream->InitParams();
206 EXPECT_EQ(SUCCESS, ret);
207 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
208 ret = rendererStream->Start();
209 EXPECT_EQ(SUCCESS, ret);
210 ret = rendererStream->Flush();
211 EXPECT_EQ(SUCCESS, ret);
212 ret = rendererStream->Stop();
213 EXPECT_EQ(SUCCESS, ret);
214 ret = rendererStream->Release();
215 EXPECT_EQ(SUCCESS, ret);
216 }
217
218 /**
219 * @tc.name : Test Direct Audio Playback Engine State
220 * @tc.type : FUNC
221 * @tc.number: DirectAudioPlayBackEngineState_006
222 * @tc.desc : Test direct audio playback engine state drain success
223 */
224 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_006, TestSize.Level1)
225 {
226 AudioProcessConfig config = InitProcessConfig();
227 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
228 int32_t ret = rendererStream->InitParams();
229 EXPECT_EQ(SUCCESS, ret);
230 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
231 ret = rendererStream->Start();
232 EXPECT_EQ(SUCCESS, ret);
233 ret = rendererStream->Drain();
234 EXPECT_EQ(SUCCESS, ret);
235 ret = rendererStream->Stop();
236 EXPECT_EQ(SUCCESS, ret);
237 ret = rendererStream->Release();
238 EXPECT_EQ(SUCCESS, ret);
239 }
240
241 /**
242 * @tc.name : Test Direct Audio Playback Engine Set Config
243 * @tc.type : FUNC
244 * @tc.number: DirectAudioPlayBackEngineSetConfig_001
245 * @tc.desc : Test direct audio playback engine set config (sampleRate 192000) success
246 */
247 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_001, TestSize.Level1)
248 {
249 AudioProcessConfig config = InitProcessConfig();
250 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_192000;
251 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
252 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
253 int32_t ret = rendererStream->InitParams();
254 EXPECT_EQ(SUCCESS, ret);
255 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
256 ret = rendererStream->Start();
257 EXPECT_EQ(SUCCESS, ret);
258 ret = rendererStream->Stop();
259 EXPECT_EQ(SUCCESS, ret);
260 ret = rendererStream->Release();
261 EXPECT_EQ(SUCCESS, ret);
262 }
263
264 /**
265 * @tc.name : Test Direct Audio Playback Engine Set Config
266 * @tc.type : FUNC
267 * @tc.number: DirectAudioPlayBackEngineSetConfig_002
268 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
269 */
270 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_002, TestSize.Level1)
271 {
272 AudioProcessConfig config = InitProcessConfig();
273 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_192000;
274 config.deviceType = DEVICE_TYPE_USB_HEADSET;
275 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
276 int32_t ret = rendererStream->InitParams();
277 EXPECT_EQ(SUCCESS, ret);
278 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
279 ret = rendererStream->Start();
280 EXPECT_EQ(SUCCESS, ret);
281 ret = rendererStream->Stop();
282 EXPECT_EQ(SUCCESS, ret);
283 ret = rendererStream->Release();
284 EXPECT_EQ(SUCCESS, ret);
285 }
286
287 /**
288 * @tc.name : Test Direct Audio Playback Engine Set Config
289 * @tc.type : FUNC
290 * @tc.number: DirectAudioPlayBackEngineSetConfig_003
291 * @tc.desc : Test direct audio playback engine set config (sampleRate 176400) success
292 */
293 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_003, TestSize.Level1)
294 {
295 AudioProcessConfig config = InitProcessConfig();
296 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_176400;
297 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
298 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
299 int32_t ret = rendererStream->InitParams();
300 EXPECT_EQ(SUCCESS, ret);
301 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
302 ret = rendererStream->Start();
303 EXPECT_EQ(SUCCESS, ret);
304 ret = rendererStream->Stop();
305 EXPECT_EQ(SUCCESS, ret);
306 ret = rendererStream->Release();
307 EXPECT_EQ(SUCCESS, ret);
308 }
309
310 /**
311 * @tc.name : Test Direct Audio Playback Engine Set Config
312 * @tc.type : FUNC
313 * @tc.number: DirectAudioPlayBackEngineSetConfig_004
314 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
315 */
316 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_004, TestSize.Level1)
317 {
318 AudioProcessConfig config = InitProcessConfig();
319 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_176400;
320 config.deviceType = DEVICE_TYPE_USB_HEADSET;
321 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
322 int32_t ret = rendererStream->InitParams();
323 EXPECT_EQ(SUCCESS, ret);
324 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
325 ret = rendererStream->Start();
326 EXPECT_EQ(SUCCESS, ret);
327 ret = rendererStream->Stop();
328 EXPECT_EQ(SUCCESS, ret);
329 ret = rendererStream->Release();
330 EXPECT_EQ(SUCCESS, ret);
331 }
332
333 /**
334 * @tc.name : Test Direct Audio Playback Engine Set Config
335 * @tc.type : FUNC
336 * @tc.number: DirectAudioPlayBackEngineSetConfig_005
337 * @tc.desc : Test direct audio playback engine set config (sampleRate 96000) success
338 */
339 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_005, TestSize.Level1)
340 {
341 AudioProcessConfig config = InitProcessConfig();
342 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
343 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
344 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
345 int32_t ret = rendererStream->InitParams();
346 EXPECT_EQ(SUCCESS, ret);
347 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
348 ret = rendererStream->Start();
349 EXPECT_EQ(SUCCESS, ret);
350 ret = rendererStream->Stop();
351 EXPECT_EQ(SUCCESS, ret);
352 ret = rendererStream->Release();
353 EXPECT_EQ(SUCCESS, ret);
354 }
355
356 /**
357 * @tc.name : Test Direct Audio Playback Engine Set Config
358 * @tc.type : FUNC
359 * @tc.number: DirectAudioPlayBackEngineSetConfig_006
360 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
361 */
362 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_006, TestSize.Level1)
363 {
364 AudioProcessConfig config = InitProcessConfig();
365 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
366 config.deviceType = DEVICE_TYPE_USB_HEADSET;
367 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
368 int32_t ret = rendererStream->InitParams();
369 EXPECT_EQ(SUCCESS, ret);
370 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
371 ret = rendererStream->Start();
372 EXPECT_EQ(SUCCESS, ret);
373 ret = rendererStream->Stop();
374 EXPECT_EQ(SUCCESS, ret);
375 ret = rendererStream->Release();
376 EXPECT_EQ(SUCCESS, ret);
377 }
378
379 /**
380 * @tc.name : Test Direct Audio Playback Engine Set Config
381 * @tc.type : FUNC
382 * @tc.number: DirectAudioPlayBackEngineSetConfig_007
383 * @tc.desc : Test direct audio playback engine set config (sampleRate 88200) success
384 */
385 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_007, TestSize.Level1)
386 {
387 AudioProcessConfig config = InitProcessConfig();
388 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_88200;
389 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
390 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
391 int32_t ret = rendererStream->InitParams();
392 EXPECT_EQ(SUCCESS, ret);
393 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
394 ret = rendererStream->Start();
395 EXPECT_EQ(SUCCESS, ret);
396 ret = rendererStream->Stop();
397 EXPECT_EQ(SUCCESS, ret);
398 ret = rendererStream->Release();
399 EXPECT_EQ(SUCCESS, ret);
400 }
401
402 /**
403 * @tc.name : Test Direct Audio Playback Engine Set Config
404 * @tc.type : FUNC
405 * @tc.number: DirectAudioPlayBackEngineSetConfig_008
406 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
407 */
408 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_008, TestSize.Level1)
409 {
410 AudioProcessConfig config = InitProcessConfig();
411 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_88200;
412 config.deviceType = DEVICE_TYPE_USB_HEADSET;
413 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
414 int32_t ret = rendererStream->InitParams();
415 EXPECT_EQ(SUCCESS, ret);
416 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
417 ret = rendererStream->Start();
418 EXPECT_EQ(SUCCESS, ret);
419 ret = rendererStream->Stop();
420 EXPECT_EQ(SUCCESS, ret);
421 ret = rendererStream->Release();
422 EXPECT_EQ(SUCCESS, ret);
423 }
424
425 /**
426 * @tc.name : Test Direct Audio Playback Engine Set Config
427 * @tc.type : FUNC
428 * @tc.number: DirectAudioPlayBackEngineSetConfig_009
429 * @tc.desc : Test direct audio playback engine set config (sampleRate 48000) success
430 */
431 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_009, TestSize.Level1)
432 {
433 AudioProcessConfig config = InitProcessConfig();
434 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
435 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
436 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
437 int32_t ret = rendererStream->InitParams();
438 EXPECT_EQ(SUCCESS, ret);
439 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
440 ret = rendererStream->Start();
441 EXPECT_EQ(SUCCESS, ret);
442 ret = rendererStream->Stop();
443 EXPECT_EQ(SUCCESS, ret);
444 ret = rendererStream->Release();
445 EXPECT_EQ(SUCCESS, ret);
446 }
447
448 /**
449 * @tc.name : Test Direct Audio Playback Engine Set Config
450 * @tc.type : FUNC
451 * @tc.number: DirectAudioPlayBackEngineSetConfig_010
452 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
453 */
454 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_010, TestSize.Level1)
455 {
456 AudioProcessConfig config = InitProcessConfig();
457 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
458 config.deviceType = DEVICE_TYPE_USB_HEADSET;
459 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
460 int32_t ret = rendererStream->InitParams();
461 EXPECT_EQ(SUCCESS, ret);
462 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
463 ret = rendererStream->Start();
464 EXPECT_EQ(SUCCESS, ret);
465 ret = rendererStream->Stop();
466 EXPECT_EQ(SUCCESS, ret);
467 ret = rendererStream->Release();
468 EXPECT_EQ(SUCCESS, ret);
469 }
470
471 /**
472 * @tc.name : Test Direct Audio Playback Engine Set Config
473 * @tc.type : FUNC
474 * @tc.number: DirectAudioPlayBackEngineSetConfig_011
475 * @tc.desc : Test direct audio playback engine set config (sampleRate 44100) success
476 */
477 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_011, TestSize.Level1)
478 {
479 AudioProcessConfig config = InitProcessConfig();
480 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
481 config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
482 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
483 int32_t ret = rendererStream->InitParams();
484 EXPECT_EQ(SUCCESS, ret);
485 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
486 ret = rendererStream->Start();
487 EXPECT_EQ(SUCCESS, ret);
488 ret = rendererStream->Stop();
489 EXPECT_EQ(SUCCESS, ret);
490 ret = rendererStream->Release();
491 EXPECT_EQ(SUCCESS, ret);
492 }
493
494 /**
495 * @tc.name : Test Direct Audio Playback Engine Set Config
496 * @tc.type : FUNC
497 * @tc.number: DirectAudioPlayBackEngineSetConfig_012
498 * @tc.desc : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
499 */
500 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_012, TestSize.Level1)
501 {
502 AudioProcessConfig config = InitProcessConfig();
503 config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
504 config.deviceType = DEVICE_TYPE_USB_HEADSET;
505 std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
506 int32_t ret = rendererStream->InitParams();
507 EXPECT_EQ(SUCCESS, ret);
508 rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
509 ret = rendererStream->Start();
510 EXPECT_EQ(SUCCESS, ret);
511 ret = rendererStream->Stop();
512 EXPECT_EQ(SUCCESS, ret);
513 ret = rendererStream->Release();
514 EXPECT_EQ(SUCCESS, ret);
515 }
516
517 /**
518 * @tc.name : Test NoneMixEngine API
519 * @tc.type : FUNC
520 * @tc.number: NoneMixEngine_001
521 * @tc.desc : Test NoneMixEngine interface.
522 */
523 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_001, TestSize.Level1)
524 {
525 NoneMixEngine noneMixEngineRet;
526 AudioDeviceDescriptor deviceRet(AudioDeviceDescriptor::DEVICE_INFO);
527 bool isVoipRet = true;
528 noneMixEngineRet.isInit_ = true;
529 deviceRet.deviceType_ = DEVICE_TYPE_INVALID;
530 noneMixEngineRet.device_.deviceType_ = DEVICE_TYPE_NONE;
531 noneMixEngineRet.renderId_ = HDI_INVALID_ID;
532
533 auto ret = noneMixEngineRet.Init(deviceRet, isVoipRet);
534 EXPECT_EQ(ret, SUCCESS);
535
536 ret = noneMixEngineRet.Init(deviceRet, isVoipRet);
537 EXPECT_EQ(ret, SUCCESS);
538 }
539
540 /**
541 * @tc.name : Test NoneMixEngine API
542 * @tc.type : FUNC
543 * @tc.number: NoneMixEngine_002
544 * @tc.desc : Test NoneMixEngine interface.
545 */
546 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_002, TestSize.Level1)
547 {
548 NoneMixEngine noneMixEngineRet;
549 AudioDeviceDescriptor deviceRet(AudioDeviceDescriptor::DEVICE_INFO);
550 bool isVoipRet = true;
551 noneMixEngineRet.isInit_ = true;
552 deviceRet.deviceType_ = DEVICE_TYPE_INVALID;
553 noneMixEngineRet.device_.deviceType_ = DEVICE_TYPE_INVALID;
554 noneMixEngineRet.renderId_ = HDI_INVALID_ID;
555
556 auto ret = noneMixEngineRet.Init(deviceRet, isVoipRet);
557 EXPECT_EQ(ret, SUCCESS);
558
559 deviceRet.deviceType_ = DEVICE_TYPE_NONE;
560 ret = noneMixEngineRet.Init(deviceRet, isVoipRet);
561 EXPECT_EQ(ret, SUCCESS);
562 }
563
564 /**
565 * @tc.name : Test NoneMixEngine API
566 * @tc.type : FUNC
567 * @tc.number: NoneMixEngine_003
568 * @tc.desc : Test NoneMixEngine interface.
569 */
570 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_003, TestSize.Level1)
571 {
572 NoneMixEngine noneMixEngineRet;
573 noneMixEngineRet.playbackThread_ = nullptr;
574 noneMixEngineRet.isStart_ = true;
575
576 auto ret = noneMixEngineRet.Stop();
577 EXPECT_EQ(ret, SUCCESS);
578
579 noneMixEngineRet.PauseAsync();
580 ret = noneMixEngineRet.StopAudioSink();
581 EXPECT_EQ(ret, SUCCESS);
582 }
583
584 /**
585 * @tc.name : Test NoneMixEngine API
586 * @tc.type : FUNC
587 * @tc.number: NoneMixEngine_004
588 * @tc.desc : Test NoneMixEngine interface.
589 */
590 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_004, TestSize.Level1)
591 {
592 NoneMixEngine noneMixEngineRet;
593 noneMixEngineRet.playbackThread_ = nullptr;
594 noneMixEngineRet.isStart_ = true;
595
596 noneMixEngineRet.Flush();
597 noneMixEngineRet.MixStreams();
598 auto ret = noneMixEngineRet.Pause();
599 EXPECT_EQ(ret, SUCCESS);
600 }
601
602 /**
603 * @tc.name : Test NoneMixEngine API
604 * @tc.type : FUNC
605 * @tc.number: NoneMixEngine_005
606 * @tc.desc : Test NoneMixEngine interface.
607 */
608 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_005, TestSize.Level1)
609 {
610 NoneMixEngine noneMixEngineRet;
611 noneMixEngineRet.playbackThread_ = nullptr;
612 noneMixEngineRet.isStart_ = true;
613 uint32_t indexRet1 = 0;
614 uint32_t indexRet2 = 1;
615 AudioProcessConfig configRet;
616 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(configRet, true);
617 rendererStream1->SetStreamIndex(indexRet1);
618 noneMixEngineRet.stream_ = rendererStream1;
619
620 auto ret = noneMixEngineRet.AddRenderer(rendererStream1);
621 EXPECT_EQ(ret, SUCCESS);
622
623 std::shared_ptr<ProRendererStreamImpl> rendererStream2 = std::make_shared<ProRendererStreamImpl>(configRet, true);
624 rendererStream2->SetStreamIndex(indexRet2);
625 ret = noneMixEngineRet.AddRenderer(rendererStream2);
626 EXPECT_EQ(ret, ERROR_UNSUPPORTED);
627 }
628
629 /**
630 * @tc.name : Test NoneMixEngine API
631 * @tc.type : FUNC
632 * @tc.number: NoneMixEngine_006
633 * @tc.desc : Test NoneMixEngine interface.
634 */
635 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_006, TestSize.Level1)
636 {
637 NoneMixEngine noneMixEngineRet;
638 noneMixEngineRet.playbackThread_ = nullptr;
639 noneMixEngineRet.isStart_ = true;
640 uint32_t indexRet1 = 0;
641 uint32_t indexRet2 = 1;
642 AudioProcessConfig configRet;
643 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(configRet, true);
644 rendererStream1->SetStreamIndex(indexRet1);
645
646 EXPECT_EQ(noneMixEngineRet.stream_, nullptr);
647 noneMixEngineRet.RemoveRenderer(rendererStream1);
648 noneMixEngineRet.stream_ = rendererStream1;
649
650 std::shared_ptr<ProRendererStreamImpl> rendererStream2 = std::make_shared<ProRendererStreamImpl>(configRet, true);
651 rendererStream2->SetStreamIndex(indexRet2);
652 EXPECT_NE(noneMixEngineRet.stream_->GetStreamIndex(), rendererStream2->GetStreamIndex());
653 noneMixEngineRet.RemoveRenderer(rendererStream2);
654 }
655
656 /**
657 * @tc.name : Test NoneMixEngine API
658 * @tc.type : FUNC
659 * @tc.number: NoneMixEngine_007
660 * @tc.desc : Test NoneMixEngine interface.
661 */
662 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_007, TestSize.Level1)
663 {
664 NoneMixEngine noneMixEngineRet;
665 AudioSamplingRate sampleRateRet = AudioSamplingRate::SAMPLE_RATE_44100;
666 auto ret = noneMixEngineRet.GetDirectSampleRate(sampleRateRet);
667 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_48000);
668
669 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_88200;
670 ret = noneMixEngineRet.GetDirectSampleRate(sampleRateRet);
671 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_96000);
672
673 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_176400;
674 ret = noneMixEngineRet.GetDirectSampleRate(sampleRateRet);
675 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_192000);
676
677 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_8000;
678 ret = noneMixEngineRet.GetDirectSampleRate(sampleRateRet);
679 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_8000);
680 }
681
682 /**
683 * @tc.name : Test NoneMixEngine API
684 * @tc.type : FUNC
685 * @tc.number: NoneMixEngine_008
686 * @tc.desc : Test NoneMixEngine interface.
687 */
688 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_008, TestSize.Level1)
689 {
690 NoneMixEngine noneMixEngineRet;
691 AudioSamplingRate sampleRateRet = AudioSamplingRate::SAMPLE_RATE_8000;
692 auto ret = noneMixEngineRet.GetDirectVoipSampleRate(sampleRateRet);
693 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_16000);
694 }
695
696 /**
697 * @tc.name : Test NoneMixEngine API
698 * @tc.type : FUNC
699 * @tc.number: NoneMixEngine_010
700 * @tc.desc : Test NoneMixEngine::Start()
701 */
702 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_010, TestSize.Level1)
703 {
704 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
705 EXPECT_NE(ptrNoneMixEngine, nullptr);
706
707 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
708 HDI_ID_INFO_DEFAULT, true);
709 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
710
711 auto ret = ptrNoneMixEngine->Start();
712 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
713 }
714
715 /**
716 * @tc.name : Test NoneMixEngine API
717 * @tc.type : FUNC
718 * @tc.number: NoneMixEngine_011
719 * @tc.desc : Test NoneMixEngine::DoFadeinOut
720 */
721 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_011, TestSize.Level1)
722 {
723 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
724 EXPECT_NE(ptrNoneMixEngine, nullptr);
725
726 bool isFadeOut = true;
727 char buffer = 'a';
728 size_t bufferSize = 10;
729 char *pBuffer = &buffer;
730 EXPECT_NE(pBuffer, nullptr);
731
732 ptrNoneMixEngine->uChannel_ = 10;
733 ptrNoneMixEngine->uFormat_ = sizeof(int16_t);
734
735 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
736 }
737
738 /**
739 * @tc.name : Test NoneMixEngine API
740 * @tc.type : FUNC
741 * @tc.number: NoneMixEngine_012
742 * @tc.desc : Test NoneMixEngine::DoFadeinOut
743 */
744 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_012, TestSize.Level1)
745 {
746 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
747 EXPECT_NE(ptrNoneMixEngine, nullptr);
748
749 bool isFadeOut = true;
750 char buffer = 'a';
751 size_t bufferSize = 10;
752 char *pBuffer = &buffer;
753 EXPECT_NE(pBuffer, nullptr);
754
755 ptrNoneMixEngine->uChannel_ = 10;
756 ptrNoneMixEngine->uFormat_ = sizeof(int32_t);
757
758 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
759 }
760
761 /**
762 * @tc.name : Test NoneMixEngine API
763 * @tc.type : FUNC
764 * @tc.number: NoneMixEngine_013
765 * @tc.desc : Test NoneMixEngine::DoFadeinOut
766 */
767 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_013, TestSize.Level1)
768 {
769 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
770 EXPECT_NE(ptrNoneMixEngine, nullptr);
771
772 bool isFadeOut = false;
773 char buffer = 'a';
774 size_t bufferSize = 10;
775 char *pBuffer = &buffer;
776 EXPECT_NE(pBuffer, nullptr);
777
778 ptrNoneMixEngine->uChannel_ = 10;
779 ptrNoneMixEngine->uFormat_ = sizeof(int16_t);
780
781 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
782 }
783
784 /**
785 * @tc.name : Test NoneMixEngine API
786 * @tc.type : FUNC
787 * @tc.number: NoneMixEngine_014
788 * @tc.desc : Test NoneMixEngine::DoFadeinOut
789 */
790 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_014, TestSize.Level1)
791 {
792 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
793 EXPECT_NE(ptrNoneMixEngine, nullptr);
794
795 bool isFadeOut = false;
796 char buffer = 'a';
797 size_t bufferSize = 10;
798 char *pBuffer = &buffer;
799 EXPECT_NE(pBuffer, nullptr);
800
801 ptrNoneMixEngine->uChannel_ = 10;
802 ptrNoneMixEngine->uFormat_ = sizeof(int32_t);
803
804 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
805 }
806
807 /**
808 * @tc.name : Test NoneMixEngine API
809 * @tc.type : FUNC
810 * @tc.number: NoneMixEngine_015
811 * @tc.desc : Test NoneMixEngine::MixStreams
812 */
813 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_015, TestSize.Level1)
814 {
815 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
816 EXPECT_NE(ptrNoneMixEngine, nullptr);
817
818 AudioProcessConfig configRet;
819
820 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
821 EXPECT_NE(ptrNoneMixEngine->stream_, nullptr);
822
823 ptrNoneMixEngine->MixStreams();
824 }
825
826 /**
827 * @tc.name : Test NoneMixEngine API
828 * @tc.type : FUNC
829 * @tc.number: NoneMixEngine_016
830 * @tc.desc : Test NoneMixEngine::MixStreams
831 */
832 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_016, TestSize.Level1)
833 {
834 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
835 EXPECT_NE(ptrNoneMixEngine, nullptr);
836
837 AudioProcessConfig configRet;
838
839 ptrNoneMixEngine->stream_ = nullptr;
840
841 ptrNoneMixEngine->MixStreams();
842 }
843
844 /**
845 * @tc.name : Test NoneMixEngine API
846 * @tc.type : FUNC
847 * @tc.number: NoneMixEngine_017
848 * @tc.desc : Test NoneMixEngine::MixStreams
849 */
850 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_017, TestSize.Level1)
851 {
852 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
853 EXPECT_NE(ptrNoneMixEngine, nullptr);
854
855 AudioProcessConfig configRet;
856
857 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
858 EXPECT_NE(ptrNoneMixEngine->stream_, nullptr);
859 ptrNoneMixEngine->failedCount_.store(100);
860
861 ptrNoneMixEngine->MixStreams();
862 }
863
864 /**
865 * @tc.name : Test NoneMixEngine API
866 * @tc.type : FUNC
867 * @tc.number: NoneMixEngine_018
868 * @tc.desc : Test NoneMixEngine::MixStreams
869 */
870 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_018, TestSize.Level1)
871 {
872 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
873 EXPECT_NE(ptrNoneMixEngine, nullptr);
874
875 AudioProcessConfig configRet;
876
877 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
878 EXPECT_NE(ptrNoneMixEngine->stream_, nullptr);
879 ptrNoneMixEngine->failedCount_.store(10);
880 ptrNoneMixEngine->startFadeout_.store(true);
881
882 ptrNoneMixEngine->MixStreams();
883 }
884
885 /**
886 * @tc.name : Test NoneMixEngine API
887 * @tc.type : FUNC
888 * @tc.number: NoneMixEngine_019
889 * @tc.desc : Test NoneMixEngine::MixStreams
890 */
891 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_019, TestSize.Level1)
892 {
893 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
894 EXPECT_NE(ptrNoneMixEngine, nullptr);
895
896 AudioProcessConfig configRet;
897
898 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
899 EXPECT_NE(ptrNoneMixEngine->stream_, nullptr);
900 ptrNoneMixEngine->failedCount_.store(10);
901 ptrNoneMixEngine->startFadeout_.store(false);
902 ptrNoneMixEngine->startFadein_.store(true);
903
904 ptrNoneMixEngine->MixStreams();
905 }
906
907 /**
908 * @tc.name : Test NoneMixEngine API
909 * @tc.type : FUNC
910 * @tc.number: NoneMixEngine_020
911 * @tc.desc : Test NoneMixEngine::MixStreams
912 */
913 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_020, TestSize.Level1)
914 {
915 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
916 EXPECT_NE(ptrNoneMixEngine, nullptr);
917
918 AudioProcessConfig configRet;
919
920 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
921 EXPECT_NE(ptrNoneMixEngine->stream_, nullptr);
922 ptrNoneMixEngine->failedCount_.store(10);
923 ptrNoneMixEngine->startFadeout_.store(false);
924 ptrNoneMixEngine->startFadein_.store(false);
925
926 ptrNoneMixEngine->MixStreams();
927 }
928
929 /**
930 * @tc.name : Test NoneMixEngine API
931 * @tc.type : FUNC
932 * @tc.number: NoneMixEngine_021
933 * @tc.desc : Test NoneMixEngine::GetDirectSampleRate
934 */
935 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_021, TestSize.Level1)
936 {
937 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
938 EXPECT_NE(ptrNoneMixEngine, nullptr);
939
940 AudioSamplingRate sampleRateRet = AudioSamplingRate::SAMPLE_RATE_44100;
941 auto ret = ptrNoneMixEngine->GetDirectSampleRate(sampleRateRet);
942 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_48000);
943
944 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_88200;
945 ret = ptrNoneMixEngine->GetDirectSampleRate(sampleRateRet);
946 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_96000);
947
948 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_176400;
949 ret = ptrNoneMixEngine->GetDirectSampleRate(sampleRateRet);
950 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_192000);
951
952 sampleRateRet = AudioSamplingRate::SAMPLE_RATE_8000;
953 ret = ptrNoneMixEngine->GetDirectSampleRate(sampleRateRet);
954 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_8000);
955 }
956
957 /**
958 * @tc.name : Test NoneMixEngine API
959 * @tc.type : FUNC
960 * @tc.number: NoneMixEngine_022
961 * @tc.desc : Test NoneMixEngine::InitSink
962 */
963 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_022, TestSize.Level1)
964 {
965 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
966 EXPECT_NE(ptrNoneMixEngine, nullptr);
967
968 AudioStreamInfo streamInfo;
969 ptrNoneMixEngine->isInit_ = false;
970 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
971 HDI_ID_INFO_DEFAULT, true);
972 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
973
974 ptrNoneMixEngine->InitSink(streamInfo);
975 }
976
977
978 /**
979 * @tc.name : Test NoneMixEngine API
980 * @tc.type : FUNC
981 * @tc.number: NoneMixEngine_023
982 * @tc.desc : Test NoneMixEngine::InitSink
983 */
984 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_023, TestSize.Level1)
985 {
986 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
987 EXPECT_NE(ptrNoneMixEngine, nullptr);
988
989 AudioStreamInfo streamInfo;
990 ptrNoneMixEngine->isInit_ = true;
991 ptrNoneMixEngine->renderId_ = HDI_INVALID_ID;
992
993 ptrNoneMixEngine->InitSink(streamInfo);
994 }
995
996 /**
997 * @tc.name : Test NoneMixEngine API
998 * @tc.type : FUNC
999 * @tc.number: NoneMixEngine_024
1000 * @tc.desc : Test NoneMixEngine::InitSink
1001 */
1002 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_024, TestSize.Level1)
1003 {
1004 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1005 EXPECT_NE(ptrNoneMixEngine, nullptr);
1006
1007 AudioStreamInfo streamInfo;
1008 ptrNoneMixEngine->isInit_ = true;
1009 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1010 HDI_ID_INFO_DEFAULT, true);
1011 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1012
1013 streamInfo.channels = AudioChannel::CHANNEL_15;
1014 ptrNoneMixEngine->uChannel_ = 1;
1015
1016 ptrNoneMixEngine->InitSink(streamInfo);
1017 }
1018
1019 /**
1020 * @tc.name : Test NoneMixEngine API
1021 * @tc.type : FUNC
1022 * @tc.number: NoneMixEngine_025
1023 * @tc.desc : Test NoneMixEngine::InitSink
1024 */
1025 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_025, TestSize.Level1)
1026 {
1027 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1028 EXPECT_NE(ptrNoneMixEngine, nullptr);
1029
1030 AudioStreamInfo streamInfo;
1031 ptrNoneMixEngine->isInit_ = true;
1032 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1033 HDI_ID_INFO_DEFAULT, true);
1034 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1035
1036 streamInfo.channels = AudioChannel::CHANNEL_15;
1037 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1038 ptrNoneMixEngine->uChannel_ = 2;
1039 ptrNoneMixEngine->uFormat_ = SAMPLE_S32LE;
1040
1041 ptrNoneMixEngine->InitSink(streamInfo);
1042 }
1043
1044 /**
1045 * @tc.name : Test NoneMixEngine API
1046 * @tc.type : FUNC
1047 * @tc.number: NoneMixEngine_026
1048 * @tc.desc : Test NoneMixEngine::InitSink
1049 */
1050 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_026, TestSize.Level1)
1051 {
1052 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1053 EXPECT_NE(ptrNoneMixEngine, nullptr);
1054
1055 AudioStreamInfo streamInfo;
1056 ptrNoneMixEngine->isInit_ = true;
1057 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1058 HDI_ID_INFO_DEFAULT, true);
1059 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1060
1061 streamInfo.channels = AudioChannel::CHANNEL_15;
1062 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1063 ptrNoneMixEngine->uChannel_ = 2;
1064 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1065 ptrNoneMixEngine->isVoip_ = true;
1066 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1067 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_24000;
1068
1069 ptrNoneMixEngine->InitSink(streamInfo);
1070 }
1071
1072 /**
1073 * @tc.name : Test NoneMixEngine API
1074 * @tc.type : FUNC
1075 * @tc.number: NoneMixEngine_027
1076 * @tc.desc : Test NoneMixEngine::InitSink
1077 */
1078 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_027, TestSize.Level1)
1079 {
1080 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1081 EXPECT_NE(ptrNoneMixEngine, nullptr);
1082
1083 AudioStreamInfo streamInfo;
1084 ptrNoneMixEngine->isInit_ = true;
1085 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1086 HDI_ID_INFO_DEFAULT, true);
1087 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1088
1089 streamInfo.channels = AudioChannel::CHANNEL_15;
1090 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1091 ptrNoneMixEngine->uChannel_ = 2;
1092 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1093 ptrNoneMixEngine->isVoip_ = true;
1094 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1095 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1096
1097 ptrNoneMixEngine->InitSink(streamInfo);
1098 }
1099
1100 /**
1101 * @tc.name : Test NoneMixEngine API
1102 * @tc.type : FUNC
1103 * @tc.number: NoneMixEngine_028
1104 * @tc.desc : Test NoneMixEngine::SwitchSink
1105 */
1106 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_028, TestSize.Level1)
1107 {
1108 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1109 EXPECT_NE(ptrNoneMixEngine, nullptr);
1110
1111 AudioStreamInfo streamInfo;
1112 ptrNoneMixEngine->isInit_ = true;
1113 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1114 HDI_ID_INFO_DEFAULT, true);
1115 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1116
1117 streamInfo.channels = AudioChannel::CHANNEL_15;
1118 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1119 ptrNoneMixEngine->uChannel_ = 2;
1120 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1121 ptrNoneMixEngine->isVoip_ = true;
1122 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1123 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1124 bool isVoip = true;
1125 int32_t ret = ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1126 EXPECT_EQ(ret, SUCCESS);
1127 }
1128
1129 /**
1130 * @tc.name : Test NoneMixEngine API
1131 * @tc.type : FUNC
1132 * @tc.number: NoneMixEngine_029
1133 * @tc.desc : Test NoneMixEngine::SwitchSink
1134 */
1135 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_029, TestSize.Level1)
1136 {
1137 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1138 EXPECT_NE(ptrNoneMixEngine, nullptr);
1139
1140 AudioStreamInfo streamInfo;
1141 ptrNoneMixEngine->isInit_ = false;
1142 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1143 HDI_ID_INFO_DEFAULT, true);
1144 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1145
1146 streamInfo.channels = AudioChannel::CHANNEL_15;
1147 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1148 ptrNoneMixEngine->uChannel_ = 2;
1149 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1150 ptrNoneMixEngine->isVoip_ = true;
1151 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1152 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1153 bool isVoip = true;
1154 int32_t ret = ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1155 EXPECT_EQ(ret, SUCCESS);
1156 }
1157 /**
1158 * @tc.name : Test NoneMixEngine API
1159 * @tc.type : FUNC
1160 * @tc.number: NoneMixEngine_030
1161 * @tc.desc : Test NoneMixEngine::Start
1162 */
1163 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_030, TestSize.Level1)
1164 {
1165 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1166 EXPECT_NE(ptrNoneMixEngine, nullptr);
1167
1168 AudioStreamInfo streamInfo;
1169 ptrNoneMixEngine->isInit_ = true;
1170 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1171 HDI_ID_INFO_DEFAULT, true);
1172 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1173
1174 streamInfo.channels = AudioChannel::CHANNEL_15;
1175 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1176 ptrNoneMixEngine->uChannel_ = 2;
1177 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1178 ptrNoneMixEngine->isVoip_ = true;
1179 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1180 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1181 bool isVoip = true;
1182 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1183 int32_t ret = ptrNoneMixEngine->Start();
1184 EXPECT_EQ(ret, SUCCESS);
1185 }
1186
1187 /**
1188 * @tc.name : Test NoneMixEngine API
1189 * @tc.type : FUNC
1190 * @tc.number: NoneMixEngine_031
1191 * @tc.desc : Test NoneMixEngine::Start
1192 */
1193 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_031, TestSize.Level1)
1194 {
1195 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1196 EXPECT_NE(ptrNoneMixEngine, nullptr);
1197
1198 AudioStreamInfo streamInfo;
1199 ptrNoneMixEngine->isInit_ = false;
1200 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1201 HDI_ID_INFO_DEFAULT, true);
1202 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1203
1204 streamInfo.channels = AudioChannel::CHANNEL_15;
1205 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1206 ptrNoneMixEngine->uChannel_ = 2;
1207 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1208 ptrNoneMixEngine->isVoip_ = true;
1209 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1210 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1211 bool isVoip = true;
1212 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1213 int32_t ret = ptrNoneMixEngine->Start();
1214 EXPECT_EQ(ret, SUCCESS);
1215 }
1216
1217 /**
1218 * @tc.name : Test NoneMixEngine API
1219 * @tc.type : FUNC
1220 * @tc.number: NoneMixEngine_032
1221 * @tc.desc : Test NoneMixEngine::Pause
1222 */
1223 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_032, TestSize.Level1)
1224 {
1225 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1226 EXPECT_NE(ptrNoneMixEngine, nullptr);
1227
1228 AudioStreamInfo streamInfo;
1229 ptrNoneMixEngine->isInit_ = true;
1230 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1231 HDI_ID_INFO_DEFAULT, true);
1232 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1233
1234 streamInfo.channels = AudioChannel::CHANNEL_15;
1235 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1236 ptrNoneMixEngine->uChannel_ = 2;
1237 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1238 ptrNoneMixEngine->isVoip_ = true;
1239 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1240 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1241 bool isVoip = true;
1242 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1243 int32_t ret = ptrNoneMixEngine->Pause();
1244 EXPECT_EQ(ret, SUCCESS);
1245 }
1246
1247 /**
1248 * @tc.name : Test NoneMixEngine API
1249 * @tc.type : FUNC
1250 * @tc.number: NoneMixEngine_033
1251 * @tc.desc : Test NoneMixEngine::Pause
1252 */
1253 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_033, TestSize.Level1)
1254 {
1255 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1256 EXPECT_NE(ptrNoneMixEngine, nullptr);
1257
1258 AudioStreamInfo streamInfo;
1259 ptrNoneMixEngine->isInit_ = false;
1260 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1261 HDI_ID_INFO_DEFAULT, true);
1262 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1263
1264 streamInfo.channels = AudioChannel::CHANNEL_15;
1265 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1266 ptrNoneMixEngine->uChannel_ = 2;
1267 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1268 ptrNoneMixEngine->isVoip_ = true;
1269 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1270 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1271 bool isVoip = true;
1272 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1273 int32_t ret = ptrNoneMixEngine->Pause();
1274 EXPECT_EQ(ret, SUCCESS);
1275 }
1276
1277 /**
1278 * @tc.name : Test NoneMixEngine API
1279 * @tc.type : FUNC
1280 * @tc.number: NoneMixEngine_034
1281 * @tc.desc : Test NoneMixEngine interface.
1282 */
1283 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_034, TestSize.Level1)
1284 {
1285 NoneMixEngine noneMixEngineRet;
1286 AudioSamplingRate sampleRateRet = AudioSamplingRate::SAMPLE_RATE_48000;
1287 auto ret = noneMixEngineRet.GetDirectVoipSampleRate(sampleRateRet);
1288 EXPECT_EQ(ret, AudioSamplingRate::SAMPLE_RATE_48000);
1289 }
1290
1291 /**
1292 * @tc.name : Test NoneMixEngine API
1293 * @tc.type : FUNC
1294 * @tc.number: NoneMixEngine_035
1295 * @tc.desc : Test NoneMixEngine interface.
1296 */
1297 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_035, TestSize.Level1)
1298 {
1299 NoneMixEngine noneMixEngineRet;
1300 AudioSampleFormat formatRet = SAMPLE_S16LE;
1301 auto ret = noneMixEngineRet.GetDirectFormatByteSize(formatRet);
1302 EXPECT_EQ(ret, sizeof(int16_t));
1303
1304 formatRet = SAMPLE_S32LE;
1305 ret = noneMixEngineRet.GetDirectFormatByteSize(formatRet);
1306 EXPECT_EQ(ret, sizeof(int32_t));
1307
1308 formatRet = SAMPLE_F32LE;
1309 ret = noneMixEngineRet.GetDirectFormatByteSize(formatRet);
1310 EXPECT_EQ(ret, sizeof(int32_t));
1311
1312 formatRet = INVALID_WIDTH;
1313 ret = noneMixEngineRet.GetDirectFormatByteSize(formatRet);
1314 EXPECT_EQ(ret, sizeof(int32_t));
1315 }
1316
1317 /**
1318 * @tc.name : Test NoneMixEngine API
1319 * @tc.type : FUNC
1320 * @tc.number: NoneMixEngine_036
1321 * @tc.desc : Test NoneMixEngine::GetLatency
1322 */
1323 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_036, TestSize.Level1)
1324 {
1325 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1326 EXPECT_NE(ptrNoneMixEngine, nullptr);
1327 uint64_t latency = ptrNoneMixEngine->GetLatency();
1328 EXPECT_EQ(latency, 0);
1329
1330 AudioStreamInfo streamInfo;
1331 ptrNoneMixEngine->isInit_ = false;
1332 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1333 HDI_ID_INFO_DEFAULT, true);
1334 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1335
1336 streamInfo.channels = AudioChannel::CHANNEL_15;
1337 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1338 ptrNoneMixEngine->uChannel_ = 2;
1339 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1340 ptrNoneMixEngine->isVoip_ = true;
1341 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1342 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1343 bool isVoip = true;
1344 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1345 int32_t ret = ptrNoneMixEngine->Start();
1346 EXPECT_EQ(ret, SUCCESS);
1347
1348 latency = ptrNoneMixEngine->GetLatency();
1349 EXPECT_NE(latency, 0);
1350 }
1351
1352 /**
1353 * @tc.name : Test NoneMixEngine API
1354 * @tc.type : FUNC
1355 * @tc.number: NoneMixEngine_037
1356 * @tc.desc : Test NoneMixEngine::Stop()
1357 */
1358 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_037, TestSize.Level1)
1359 {
1360 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1361 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1362
1363 std::string name = "test";
1364 ptrNoneMixEngine->isStart_ = true;
1365 ptrNoneMixEngine->playbackThread_ = std::make_unique<AudioThreadTask>(name);
1366 auto ret = ptrNoneMixEngine->Stop();
1367 EXPECT_EQ(ret, SUCCESS);
1368 }
1369
1370 /**
1371 * @tc.name : Test NoneMixEngine API
1372 * @tc.type : FUNC
1373 * @tc.number: NoneMixEngine_038
1374 * @tc.desc : Test NoneMixEngine::PauseAsync()
1375 */
1376 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_038, TestSize.Level1)
1377 {
1378 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1379 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1380
1381 ptrNoneMixEngine->playbackThread_ = nullptr;
1382 ptrNoneMixEngine->PauseAsync();
1383 EXPECT_EQ(ptrNoneMixEngine->isStart_, false);
1384 }
1385
1386 /**
1387 * @tc.name : Test NoneMixEngine API
1388 * @tc.type : FUNC
1389 * @tc.number: NoneMixEngine_039
1390 * @tc.desc : Test NoneMixEngine::StopAudioSink()
1391 */
1392 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_039, TestSize.Level1)
1393 {
1394 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1395 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1396
1397 ptrNoneMixEngine->renderId_ = -1;
1398 auto ret = ptrNoneMixEngine->StopAudioSink();
1399 EXPECT_EQ(ret, SUCCESS);
1400 }
1401
1402 /**
1403 * @tc.name : Test NoneMixEngine API
1404 * @tc.type : FUNC
1405 * @tc.number: NoneMixEngine_040
1406 * @tc.desc : Test NoneMixEngine::StopAudioSink()
1407 */
1408 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_040, TestSize.Level1)
1409 {
1410 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1411 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1412
1413 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1414 HDI_ID_INFO_DEFAULT, true);
1415 auto sink = HdiAdapterManager::GetInstance().GetRenderSink(ptrNoneMixEngine->renderId_, true);
1416 ASSERT_TRUE(sink != nullptr);
1417
1418 auto ret = ptrNoneMixEngine->StopAudioSink();
1419 EXPECT_EQ(ret, SUCCESS);
1420 }
1421
1422 /**
1423 * @tc.name : Test NoneMixEngine API
1424 * @tc.type : FUNC
1425 * @tc.number: NoneMixEngine_041
1426 * @tc.desc : Test NoneMixEngine::Pause()
1427 */
1428 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_041, TestSize.Level1)
1429 {
1430 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1431 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1432
1433 ptrNoneMixEngine->isStart_ = true;
1434 std::string name = "test";
1435 ptrNoneMixEngine->playbackThread_ = std::make_unique<AudioThreadTask>(name);
1436 auto ret = ptrNoneMixEngine->Pause();
1437 EXPECT_EQ(ret, SUCCESS);
1438 }
1439
1440 /**
1441 * @tc.name : Test NoneMixEngine API
1442 * @tc.type : FUNC
1443 * @tc.number: NoneMixEngine_042
1444 * @tc.desc : Test NoneMixEngine::DoFadeinOut()
1445 */
1446 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_042, TestSize.Level1)
1447 {
1448 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1449 EXPECT_NE(ptrNoneMixEngine, nullptr);
1450
1451 bool isFadeOut = true;
1452 char buffer = 'a';
1453 size_t bufferSize = 2;
1454 char *pBuffer = &buffer;
1455 EXPECT_NE(pBuffer, nullptr);
1456
1457 ptrNoneMixEngine->uChannel_ = 1;
1458 ptrNoneMixEngine->uFormat_ = sizeof(int16_t);
1459
1460 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
1461 }
1462
1463 /**
1464 * @tc.name : Test NoneMixEngine API
1465 * @tc.type : FUNC
1466 * @tc.number: NoneMixEngine_043
1467 * @tc.desc : Test NoneMixEngine::DoFadeinOut()
1468 */
1469 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_043, TestSize.Level1)
1470 {
1471 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1472 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1473
1474 char buffer = 'a';
1475 char *pBuffer = &buffer;
1476 ptrNoneMixEngine->uFormat_ = 1;
1477 ptrNoneMixEngine->uChannel_ = 1;
1478 ptrNoneMixEngine->uFormat_ = sizeof(int16_t);
1479 bool isFadeOut = false;
1480 size_t bufferSize = 2;
1481 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
1482 }
1483
1484 /**
1485 * @tc.name : Test NoneMixEngine API
1486 * @tc.type : FUNC
1487 * @tc.number: NoneMixEngine_044
1488 * @tc.desc : Test NoneMixEngine::DoFadeinOut()
1489 */
1490 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_044, TestSize.Level1)
1491 {
1492 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1493 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1494
1495 char buffer = 'a';
1496 char *pBuffer = &buffer;
1497 ptrNoneMixEngine->uFormat_ = 1;
1498 ptrNoneMixEngine->uChannel_ = 1;
1499 ptrNoneMixEngine->uFormat_ = sizeof(int16_t);
1500 bool isFadeOut = false;
1501 size_t bufferSize = 0;
1502 ptrNoneMixEngine->DoFadeinOut(isFadeOut, pBuffer, bufferSize);
1503 }
1504
1505 /**
1506 * @tc.name : Test NoneMixEngine API
1507 * @tc.type : FUNC
1508 * @tc.number: NoneMixEngine_045
1509 * @tc.desc : Test NoneMixEngine::AdjustVoipVolume()
1510 */
1511 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_045, TestSize.Level1)
1512 {
1513 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1514 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1515
1516 ptrNoneMixEngine->isVoip_ = false;
1517 ptrNoneMixEngine->AdjustVoipVolume();
1518 }
1519
1520 /**
1521 * @tc.name : Test NoneMixEngine API
1522 * @tc.type : FUNC
1523 * @tc.number: NoneMixEngine_046
1524 * @tc.desc : Test NoneMixEngine::AdjustVoipVolume()
1525 */
1526 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_046, TestSize.Level1)
1527 {
1528 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1529 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1530
1531 AudioProcessConfig processConfig;
1532 ptrNoneMixEngine->isVoip_ = true;
1533 ptrNoneMixEngine->firstSetVolume_ = false;
1534 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(processConfig, true);
1535 ptrNoneMixEngine->AdjustVoipVolume();
1536 }
1537
1538 /**
1539 * @tc.name : Test NoneMixEngine API
1540 * @tc.type : FUNC
1541 * @tc.number: NoneMixEngine_047
1542 * @tc.desc : Test NoneMixEngine::AdjustVoipVolume()
1543 */
1544 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_047, TestSize.Level1)
1545 {
1546 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1547 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1548
1549 AudioProcessConfig processConfig;
1550 ptrNoneMixEngine->isVoip_ = true;
1551 ptrNoneMixEngine->firstSetVolume_ = true;
1552 ptrNoneMixEngine->stream_ = std::make_shared<ProRendererStreamImpl>(processConfig, true);
1553 ptrNoneMixEngine->AdjustVoipVolume();
1554 }
1555
1556 /**
1557 * @tc.name : Test NoneMixEngine API
1558 * @tc.type : FUNC
1559 * @tc.number: NoneMixEngine_048
1560 * @tc.desc : Test NoneMixEngine::AddRenderer()
1561 */
1562 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_048, TestSize.Level1)
1563 {
1564 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1565 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1566
1567 AudioProcessConfig configRet;
1568 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(configRet, true);
1569 ptrNoneMixEngine->stream_ = nullptr;
1570 ptrNoneMixEngine->AddRenderer(rendererStream1);
1571 }
1572
1573 /**
1574 * @tc.name : Test NoneMixEngine API
1575 * @tc.type : FUNC
1576 * @tc.number: NoneMixEngine_049
1577 * @tc.desc : Test NoneMixEngine::AddRenderer()
1578 */
1579 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_049, TestSize.Level1)
1580 {
1581 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1582 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1583
1584 AudioProcessConfig configRet;
1585 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(configRet, true);
1586 ptrNoneMixEngine->stream_ = rendererStream1;
1587 ptrNoneMixEngine->AddRenderer(rendererStream1);
1588 }
1589
1590 /**
1591 * @tc.name : Test NoneMixEngine API
1592 * @tc.type : FUNC
1593 * @tc.number: NoneMixEngine_050
1594 * @tc.desc : Test NoneMixEngine::GetLatency()
1595 */
1596 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_050, TestSize.Level1)
1597 {
1598 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1599 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1600
1601 ptrNoneMixEngine->isStart_ = true;
1602 ptrNoneMixEngine->latency_ = 1;
1603 auto ret = ptrNoneMixEngine->GetLatency();
1604 EXPECT_EQ(ret, 1);
1605 }
1606
1607 /**
1608 * @tc.name : Test NoneMixEngine API
1609 * @tc.type : FUNC
1610 * @tc.number: NoneMixEngine_051
1611 * @tc.desc : Test NoneMixEngine::Start
1612 */
1613 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_051, TestSize.Level1)
1614 {
1615 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1616 EXPECT_NE(ptrNoneMixEngine, nullptr);
1617
1618 AudioStreamInfo streamInfo;
1619 ptrNoneMixEngine->isInit_ = true;
1620 ptrNoneMixEngine->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY,
1621 HDI_ID_INFO_DEFAULT, true);
1622 EXPECT_NE(ptrNoneMixEngine->renderId_, HDI_INVALID_ID);
1623
1624 streamInfo.channels = AudioChannel::CHANNEL_15;
1625 streamInfo.format = AudioSampleFormat::SAMPLE_U8;
1626 ptrNoneMixEngine->uChannel_ = 2;
1627 ptrNoneMixEngine->uFormat_ = SAMPLE_S16LE;
1628 ptrNoneMixEngine->isVoip_ = true;
1629 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
1630 ptrNoneMixEngine->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_16000;
1631 bool isVoip = true;
1632 ptrNoneMixEngine->SwitchSink(streamInfo, isVoip);
1633
1634 std::string name = "noneMixThread";
1635 ptrNoneMixEngine->playbackThread_ = std::make_unique<AudioThreadTask>(name);
1636 ptrNoneMixEngine->isStart_ = true;
1637 int32_t ret = ptrNoneMixEngine->Start();
1638 EXPECT_EQ(ret, SUCCESS);
1639 }
1640
1641 /**
1642 * @tc.name : Test NoneMixEngine API
1643 * @tc.type : FUNC
1644 * @tc.number: NoneMixEngine_052
1645 * @tc.desc : Test NoneMixEngine::PauseAsync()
1646 */
1647 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_052, TestSize.Level1)
1648 {
1649 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1650 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1651
1652 std::string name = "noneMixThread";
1653 ptrNoneMixEngine->isStart_ = true;
1654 ptrNoneMixEngine->playbackThread_ = std::make_unique<AudioThreadTask>(name);
1655 ptrNoneMixEngine->playbackThread_->state_.store(AudioThreadTask::RunningState::PAUSING);
1656 ptrNoneMixEngine->PauseAsync();
1657 EXPECT_EQ(ptrNoneMixEngine->isStart_, false);
1658
1659 ptrNoneMixEngine->playbackThread_ = nullptr;
1660 ptrNoneMixEngine->PauseAsync();
1661 EXPECT_EQ(ptrNoneMixEngine->isStart_, false);
1662 }
1663
1664 /**
1665 * @tc.name : Test NoneMixEngine API
1666 * @tc.type : FUNC
1667 * @tc.number: NoneMixEngine_053
1668 * @tc.desc : Test NoneMixEngine::Pause()
1669 */
1670 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_053, TestSize.Level1)
1671 {
1672 auto ptrNoneMixEngine = std::make_shared<NoneMixEngine>();
1673 ASSERT_TRUE(ptrNoneMixEngine != nullptr);
1674
1675 ptrNoneMixEngine->isStart_ = true;
1676 auto ret = ptrNoneMixEngine->Pause();
1677 EXPECT_EQ(ret, SUCCESS);
1678
1679 std::string name = "test";
1680 ptrNoneMixEngine->isStart_ = true;
1681 ptrNoneMixEngine->playbackThread_ = std::make_unique<AudioThreadTask>(name);
1682 ret = ptrNoneMixEngine->Pause();
1683 EXPECT_EQ(ret, SUCCESS);
1684 }
1685
1686 /**
1687 * @tc.name : Test NoneMixEngine API
1688 * @tc.type : FUNC
1689 * @tc.number: NoneMixEngine_051
1690 * @tc.desc : Test NoneMixEngine::GetDirectVoipDeviceFormat()
1691 */
1692 HWTEST_F(NoneMixEngineUnitTest, NoneMixEngine_051, TestSize.Level1)
1693 {
1694 NoneMixEngine noneMixEngineRet;
1695 AudioSampleFormat formatRet = AudioSampleFormat::SAMPLE_S24LE;
1696 auto ret = noneMixEngineRet.GetDirectVoipDeviceFormat(formatRet);
1697 EXPECT_EQ(SAMPLE_S32LE, ret);
1698
1699 formatRet = AudioSampleFormat::SAMPLE_S32LE;
1700 ret = noneMixEngineRet.GetDirectVoipDeviceFormat(formatRet);
1701 EXPECT_EQ(SAMPLE_S32LE, ret);
1702
1703 formatRet = AudioSampleFormat::INVALID_WIDTH;
1704 ret = noneMixEngineRet.GetDirectVoipDeviceFormat(formatRet);
1705 EXPECT_EQ(SAMPLE_S16LE, ret);
1706 }
1707 } // namespace AudioStandard
1708 } // namespace OHOS
1709