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 "audio_renderer_sink.h"
17 #include "audio_errors.h"
18
19 using namespace testing::ext;
20 namespace OHOS {
21 namespace AudioStandard {
22 const std::string DIRECT_SINK_NAME = "direct";
23 const std::string VOIP_SINK_NAME = "voip";
24 const std::string USB_SINK_NAME = "usb";
25 const char *SINK_ADAPTER_NAME = "primary";
26 class AudioDirectSinkUnitTest : public testing::Test {
27 public:
28 static void SetUpTestCase(void);
29 static void TearDownTestCase(void);
30 void SetUp();
31 void TearDown();
32
33 protected:
34 AudioRendererSink *sink;
35 AudioRendererSink *voipSink;
36 AudioRendererSink *usbSink;
37 };
38
SetUpTestCase(void)39 void AudioDirectSinkUnitTest::SetUpTestCase(void)
40 {
41 // input testsuit setup step，setup invoked before all testcases
42 }
43
TearDownTestCase(void)44 void AudioDirectSinkUnitTest::TearDownTestCase(void)
45 {
46 // input testsuit teardown step，teardown invoked after all testcases
47 }
48
SetUp(void)49 void AudioDirectSinkUnitTest::SetUp(void)
50 {
51 sink = AudioRendererSink::GetInstance(DIRECT_SINK_NAME);
52 voipSink = AudioRendererSink::GetInstance(VOIP_SINK_NAME);
53 usbSink = AudioRendererSink::GetInstance(USB_SINK_NAME);
54 }
55
TearDown(void)56 void AudioDirectSinkUnitTest::TearDown(void)
57 {
58 if (sink && sink->IsInited()) {
59 sink->DeInit();
60 }
61 if (voipSink && voipSink->IsInited()) {
62 voipSink->DeInit();
63 }
64 }
65
66 /**
67 * @tc.name : Test Audio Direct Sink Create
68 * @tc.type : FUNC
69 * @tc.number: DirectAudioSinkCreate_001
70 * @tc.desc : Test audio direct sink create success
71 */
72 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkCreate_001, TestSize.Level1)
73 {
74 EXPECT_NE(nullptr, this->sink);
75 }
76
77 /**
78 * @tc.name : Test Audio Direct Sink
79 * @tc.type : FUNC
80 * @tc.number: DirectAudioSinkInit_001
81 * @tc.desc : Test audio direct sink init(setVolume) success
82 */
83 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkInit_001, TestSize.Level1)
84 {
85 EXPECT_NE(nullptr, this->sink);
86 IAudioSinkAttr attr = {};
87 attr.adapterName = SINK_ADAPTER_NAME;
88 attr.sampleRate = 48000;
89 attr.channel = 2;
90 attr.format = HdiAdapterFormat::SAMPLE_S32;
91 attr.channelLayout = 3;
92 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
93 attr.volume = 1.0f;
94 attr.openMicSpeaker = 1;
95 int32_t ret = sink->Init(attr);
96 EXPECT_EQ(SUCCESS, ret);
97 float volume = 1.0f;
98 ret = sink->SetVolume(volume, volume);
99 EXPECT_EQ(SUCCESS, ret);
100 }
101
102 /**
103 * @tc.name : Test Direct Sink State
104 * @tc.type : FUNC
105 * @tc.number: DirectAudioSinkState_001
106 * @tc.desc : Test direct sink state(init->start->stop) success
107 */
108 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_001, TestSize.Level1)
109 {
110 EXPECT_NE(nullptr, this->sink);
111 IAudioSinkAttr attr = {};
112 attr.adapterName = SINK_ADAPTER_NAME;
113 attr.sampleRate = 48000;
114 attr.channel = 2;
115 attr.format = HdiAdapterFormat::SAMPLE_S32;
116 attr.channelLayout = 3;
117 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
118 attr.volume = 1.0f;
119 attr.openMicSpeaker = 1;
120 int32_t ret = sink->Init(attr);
121 EXPECT_EQ(SUCCESS, ret);
122 ret = sink->Start();
123 EXPECT_EQ(SUCCESS, ret);
124 ret = sink->Stop();
125 EXPECT_EQ(SUCCESS, ret);
126 }
127
128 /**
129 * @tc.name : Test Direct Sink Init State
130 * @tc.type : FUNC
131 * @tc.number: DirectAudioSinkState_002
132 * @tc.desc : Test direct sink init state success
133 */
134 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_002, TestSize.Level1)
135 {
136 EXPECT_NE(nullptr, this->sink);
137 IAudioSinkAttr attr = {};
138 attr.adapterName = SINK_ADAPTER_NAME;
139 attr.sampleRate = 48000;
140 attr.channel = 2;
141 attr.format = HdiAdapterFormat::SAMPLE_S32;
142 attr.channelLayout = 3;
143 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
144 attr.volume = 1.0f;
145 attr.openMicSpeaker = 1;
146 bool isInited = sink->IsInited();
147 EXPECT_EQ(false, isInited);
148
149 int32_t ret = sink->Init(attr);
150 EXPECT_EQ(SUCCESS, ret);
151
152 isInited = sink->IsInited();
153 EXPECT_EQ(true, isInited);
154
155 sink->DeInit();
156
157 isInited = sink->IsInited();
158 EXPECT_EQ(false, isInited);
159
160 // Continuous execution init
161 ret = sink->Init(attr);
162 EXPECT_EQ(SUCCESS, ret);
163 ret = sink->Init(attr);
164 EXPECT_EQ(SUCCESS, ret);
165 isInited = sink->IsInited();
166 EXPECT_EQ(true, isInited);
167 }
168
169 /**
170 * @tc.name : Test Direct Sink Start State
171 * @tc.type : FUNC
172 * @tc.number: DirectAudioSinkState_003
173 * @tc.desc : Test direct sink start state success
174 */
175 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_003, TestSize.Level1)
176 {
177 EXPECT_NE(nullptr, this->sink);
178 IAudioSinkAttr attr = {};
179 attr.adapterName = SINK_ADAPTER_NAME;
180 attr.sampleRate = 48000;
181 attr.channel = 2;
182 attr.format = HdiAdapterFormat::SAMPLE_S32;
183 attr.channelLayout = 3;
184 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
185 attr.volume = 1.0f;
186 attr.openMicSpeaker = 1;
187 int32_t ret = sink->Init(attr);
188 EXPECT_EQ(SUCCESS, ret);
189
190 ret = sink->Start();
191 EXPECT_EQ(SUCCESS, ret);
192 ret = sink->Stop();
193 EXPECT_EQ(SUCCESS, ret);
194
195 // Continuous execution start
196 ret = sink->Start();
197 EXPECT_EQ(SUCCESS, ret);
198 ret = sink->Start();
199 EXPECT_EQ(SUCCESS, ret);
200 ret = sink->Stop();
201 EXPECT_EQ(SUCCESS, ret);
202 }
203
204 /**
205 * @tc.name : Test Direct Sink Resume State
206 * @tc.type : FUNC
207 * @tc.number: DirectAudioSinkState_004
208 * @tc.desc : Test direct sink resume state success
209 */
210 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_004, TestSize.Level1)
211 {
212 EXPECT_NE(nullptr, this->sink);
213 IAudioSinkAttr attr = {};
214 attr.adapterName = SINK_ADAPTER_NAME;
215 attr.sampleRate = 48000;
216 attr.channel = 2;
217 attr.format = HdiAdapterFormat::SAMPLE_S32;
218 attr.channelLayout = 3;
219 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
220 attr.volume = 1.0f;
221 attr.openMicSpeaker = 1;
222 int32_t ret = sink->Init(attr);
223 EXPECT_EQ(SUCCESS, ret);
224 ret = sink->Start();
225 EXPECT_EQ(SUCCESS, ret);
226 ret = sink->Resume();
227 EXPECT_EQ(SUCCESS, ret);
228 ret = sink->Stop();
229 EXPECT_EQ(SUCCESS, ret);
230 }
231
232 /**
233 * @tc.name : Test Audio Direct Sink Attribute
234 * @tc.type : FUNC
235 * @tc.number: DirectAudioSinkSetAttribute_001
236 * @tc.desc : Test audio direct sink attribute(sampleRate) success
237 */
238 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkSetAttribute_001, TestSize.Level1)
239 {
240 EXPECT_NE(nullptr, this->sink);
241 IAudioSinkAttr attr = {};
242 attr.adapterName = SINK_ADAPTER_NAME;
243 attr.sampleRate = 192000;
244 attr.channel = 2;
245 attr.format = HdiAdapterFormat::SAMPLE_S32;
246 attr.channelLayout = 3;
247 attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
248 attr.volume = 1.0f;
249 attr.openMicSpeaker = 1;
250 int32_t ret = sink->Init(attr);
251 EXPECT_EQ(SUCCESS, ret);
252 ret = sink->Start();
253 EXPECT_EQ(SUCCESS, ret);
254 ret = sink->Stop();
255 EXPECT_EQ(SUCCESS, ret);
256 }
257
258 /**
259 * @tc.name : Test Audio Direct Sink Attribute
260 * @tc.type : FUNC
261 * @tc.number: DirectAudioSinkSetAttribute_002
262 * @tc.desc : Test audio direct sink attribute(deviceType) success
263 */
264 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkSetAttribute_002, TestSize.Level1)
265 {
266 EXPECT_NE(nullptr, this->sink);
267 IAudioSinkAttr attr = {};
268 attr.adapterName = SINK_ADAPTER_NAME;
269 attr.sampleRate = 192000;
270 attr.channel = 2;
271 attr.format = HdiAdapterFormat::SAMPLE_S32;
272 attr.channelLayout = 3;
273 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
274 attr.volume = 1.0f;
275 attr.openMicSpeaker = 1;
276 int32_t ret = sink->Init(attr);
277 EXPECT_EQ(SUCCESS, ret);
278 ret = sink->Start();
279 EXPECT_EQ(SUCCESS, ret);
280 ret = sink->Stop();
281 EXPECT_EQ(SUCCESS, ret);
282 }
283
284 /**
285 * @tc.name : Test Audio Sink RenderFrame
286 * @tc.type : FUNC
287 * @tc.number: RenderFrame_001
288 * @tc.desc : Test audio sink RenderFrame when audioMonoState_ is false, audioBalanceState_ is false
289 */
290 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkRenderFrame_001, TestSize.Level1)
291 {
292 EXPECT_NE(nullptr, this->sink);
293 IAudioSinkAttr attr = {};
294 attr.adapterName = SINK_ADAPTER_NAME;
295 attr.sampleRate = 192000;
296 attr.channel = 2;
297 attr.format = HdiAdapterFormat::SAMPLE_S32;
298 attr.channelLayout = 3;
299 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
300 attr.volume = 1.0f;
301 attr.openMicSpeaker = 1;
302 int32_t ret = sink->Init(attr);
303 EXPECT_EQ(SUCCESS, ret);
304 uint64_t written = 0;
305 std::vector<char> audioBuffer{'8', '8', '8', '8', '8', '8', '8', '8'};
306 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
307 EXPECT_EQ('8', audioBuffer[0]);
308 EXPECT_EQ(SUCCESS, ret);
309 }
310
311 /**
312 * @tc.name : Test Audio Sink RenderFrame
313 * @tc.type : FUNC
314 * @tc.number: DirectAudioSinkRenderFrame_002
315 * @tc.desc : Test audio sink of each format type RenderFrame when audioMonoState_ is true, audioBalanceState_ is
316 * true success
317 */
318 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkRenderFrame_002, TestSize.Level1)
319 {
320 EXPECT_NE(nullptr, this->sink);
321 IAudioSinkAttr attr = {};
322 attr.adapterName = SINK_ADAPTER_NAME;
323 attr.sampleRate = 192000;
324 attr.channel = 2;
325 attr.format = HdiAdapterFormat::SAMPLE_S32;
326 attr.channelLayout = 3;
327 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
328 attr.volume = 1.0f;
329 attr.openMicSpeaker = 1;
330 int32_t ret = sink->Init(attr);
331 EXPECT_EQ(SUCCESS, ret);
332 uint64_t written = 0;
333 sink->SetAudioMonoState(true);
334 sink->SetAudioBalanceValue(1.0f);
335 sink->SetAudioBalanceValue(-1.0f);
336 std::vector<char> audioBuffer{'8', '8', '8', '8', '8', '8', '8', '8'};
337 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
338 EXPECT_EQ(SUCCESS, ret);
339
340 attr.format = HdiAdapterFormat::SAMPLE_U8;
341 ret = sink->Init(attr);
342 EXPECT_EQ(SUCCESS, ret);
343 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
344 EXPECT_EQ(SUCCESS, ret);
345
346 attr.format = HdiAdapterFormat::SAMPLE_S16;
347 ret = sink->Init(attr);
348 EXPECT_EQ(SUCCESS, ret);
349 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
350 EXPECT_EQ(SUCCESS, ret);
351
352 ret = sink->Stop();
353 EXPECT_EQ(SUCCESS, ret);
354 }
355
356 /**
357 * @tc.name : Test Audio Sink RenderFrame
358 * @tc.type : FUNC
359 * @tc.number: DirectAudioSinkRenderFrame_003
360 * @tc.desc : Test audio sink of each format type RenderFrame when audioMonoState_ is true, audioBalanceState_ is
361 * true success
362 */
363 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkRenderFrame_003, TestSize.Level1)
364 {
365 EXPECT_NE(nullptr, this->sink);
366 IAudioSinkAttr attr = {};
367 attr.adapterName = SINK_ADAPTER_NAME;
368 attr.sampleRate = 192000;
369 attr.channel = 2;
370 attr.format = HdiAdapterFormat::SAMPLE_S32;
371 attr.channelLayout = 3;
372 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
373 attr.volume = 1.0f;
374 attr.openMicSpeaker = 1;
375 int32_t ret = sink->Init(attr);
376 EXPECT_EQ(SUCCESS, ret);
377 uint64_t written = 0;
378 sink->SetAudioMonoState(true);
379 sink->SetAudioBalanceValue(-1.0f);
380 std::vector<char> audioBuffer{'8', '8', '8', '8', '8', '8', '8', '8'};
381 attr.format = HdiAdapterFormat::SAMPLE_S24;
382 ret = sink->Init(attr);
383 EXPECT_EQ(SUCCESS, ret);
384 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
385 EXPECT_EQ(SUCCESS, ret);
386
387 attr.format = HdiAdapterFormat::SAMPLE_S32;
388 ret = sink->Init(attr);
389 EXPECT_EQ(SUCCESS, ret);
390 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
391 EXPECT_EQ(SUCCESS, ret);
392
393 attr.format = HdiAdapterFormat::INVALID_WIDTH;
394 ret = sink->Init(attr);
395 EXPECT_EQ(SUCCESS, ret);
396 ret = sink->RenderFrame(*audioBuffer.data(), audioBuffer.size(), written);
397 EXPECT_EQ(SUCCESS, ret);
398
399 ret = sink->Stop();
400 EXPECT_EQ(SUCCESS, ret);
401 }
402
403 /**
404 * @tc.name : Test Audio Direct Sink SetVolume
405 * @tc.type : FUNC
406 * @tc.number: DirectAudioSinkSetVolume_001
407 * @tc.desc : Test audio direct sink SetVolume success
408 */
409 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkSetVolume_001, TestSize.Level1)
410 {
411 EXPECT_NE(nullptr, this->sink);
412 IAudioSinkAttr attr = {};
413 attr.adapterName = SINK_ADAPTER_NAME;
414 attr.sampleRate = 192000;
415 attr.channel = 2;
416 attr.format = HdiAdapterFormat::SAMPLE_S32;
417 attr.channelLayout = 3;
418 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
419 attr.volume = 1.0f;
420 attr.openMicSpeaker = 1;
421 int32_t ret = sink->Init(attr);
422 EXPECT_EQ(SUCCESS, ret);
423 ret = sink->SetVolume(0.0f, 0.0f);
424 EXPECT_EQ(SUCCESS, ret);
425 ret = sink->SetVolume(0.0f, 1.0f);
426 EXPECT_EQ(SUCCESS, ret);
427 ret = sink->SetVolume(1.0f, 0.0f);
428 EXPECT_EQ(SUCCESS, ret);
429 ret = sink->SetVolume(1.0f, 1.0f);
430 EXPECT_EQ(SUCCESS, ret);
431 }
432
433 /**
434 * @tc.name : Test Audio Direct Sink SetVolume
435 * @tc.type : FUNC
436 * @tc.number: DirectAudioSinkMix_001
437 * @tc.desc : Test audio direct sink Start, Resume, Pause, Reset, Flush, GetPresentationPosition.
438 */
439 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkMix_001, TestSize.Level1)
440 {
441 EXPECT_NE(nullptr, this->sink);
442 IAudioSinkAttr attr = {};
443 attr.adapterName = SINK_ADAPTER_NAME;
444 attr.sampleRate = 192000;
445 attr.channel = 2;
446 attr.format = HdiAdapterFormat::SAMPLE_S32;
447 attr.channelLayout = 3;
448 attr.deviceType = DEVICE_TYPE_USB_HEADSET;
449 attr.volume = 1.0f;
450 attr.openMicSpeaker = 1;
451 uint64_t frame = 10;
452 int64_t timeSec = 10;
453 int64_t timeNanoSec = 10;
454 int32_t ret = sink->GetPresentationPosition(frame, timeSec, timeNanoSec);
455 EXPECT_EQ(ERR_INVALID_HANDLE, ret);
456 ret = sink->Reset();
457 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
458 ret = sink->Flush();
459 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
460 ret = sink->Init(attr);
461 EXPECT_EQ(SUCCESS, ret);
462 ret = sink->Stop();
463 EXPECT_EQ(SUCCESS, ret);
464 ret = sink->Start();
465 EXPECT_EQ(SUCCESS, ret);
466 ret = sink->Resume();
467 EXPECT_EQ(SUCCESS, ret);
468 ret = sink->Pause();
469 EXPECT_NE(SUCCESS, ret);
470 ret = sink->Resume();
471 EXPECT_EQ(SUCCESS, ret);
472 ret = sink->GetPresentationPosition(frame, timeSec, timeNanoSec);
473 EXPECT_EQ(SUCCESS, ret);
474 ret = sink->SetPaPower(1);
475 EXPECT_EQ(SUCCESS, ret);
476 }
477
478 /**
479 * @tc.name : Test Create Direct Voip Sink
480 * @tc.type : FUNC
481 * @tc.number: DirectVoipAudioSinkCreate_001
482 * @tc.desc : Test create direct voip sink success
483 */
484 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkCreate_001, TestSize.Level1)
485 {
486 EXPECT_NE(nullptr, this->voipSink);
487 }
488
489 /**
490 * @tc.name : Test Init Direct Voip Sink
491 * @tc.type : FUNC
492 * @tc.number: DirectVoipAudioSinkInit_001
493 * @tc.desc : Test init direct voip sink success
494 */
495 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkInit_001, TestSize.Level1)
496 {
497 EXPECT_NE(nullptr, this->voipSink);
498 IAudioSinkAttr attr = {};
499 attr.adapterName = SINK_ADAPTER_NAME;
500 attr.sampleRate = 48000;
501 attr.channel = 2;
502 attr.format = HdiAdapterFormat::SAMPLE_S16;
503 attr.channelLayout = 3;
504 attr.deviceType = DEVICE_TYPE_SPEAKER;
505 attr.volume = 1.0f;
506 attr.openMicSpeaker = 1;
507 int32_t ret = voipSink->Init(attr);
508 EXPECT_EQ(SUCCESS, ret);
509 float volume = 1.0f;
510 ret = voipSink->SetVolume(volume, volume);
511 EXPECT_EQ(SUCCESS, ret);
512 }
513
514 /**
515 * @tc.name : Test Direct Voip Sink State
516 * @tc.type : FUNC
517 * @tc.number: DirectVoipAudioSinkState_001
518 * @tc.desc : Test direct voip sink state success
519 */
520 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_001, TestSize.Level1)
521 {
522 EXPECT_NE(nullptr, this->voipSink);
523 IAudioSinkAttr attr = {};
524 attr.adapterName = SINK_ADAPTER_NAME;
525 attr.sampleRate = 48000;
526 attr.channel = 2;
527 attr.format = HdiAdapterFormat::SAMPLE_S16;
528 attr.channelLayout = 3;
529 attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
530 attr.volume = 1.0f;
531 attr.openMicSpeaker = 1;
532 int32_t ret = voipSink->Init(attr);
533 EXPECT_EQ(SUCCESS, ret);
534 ret = voipSink->Start();
535 EXPECT_EQ(SUCCESS, ret);
536 ret = voipSink->Stop();
537 EXPECT_EQ(SUCCESS, ret);
538 }
539
540 /**
541 * @tc.name : Test Direct Voip Sink init State
542 * @tc.type : FUNC
543 * @tc.number: DirectVoipAudioSinkState_002
544 * @tc.desc : Test direct voip sink init state success
545 */
546 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_002, TestSize.Level1)
547 {
548 EXPECT_NE(nullptr, this->voipSink);
549 IAudioSinkAttr attr = {};
550 attr.adapterName = SINK_ADAPTER_NAME;
551 attr.sampleRate = 48000;
552 attr.channel = 2;
553 attr.format = HdiAdapterFormat::SAMPLE_S16;
554 attr.channelLayout = 3;
555 attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
556 attr.volume = 1.0f;
557 attr.openMicSpeaker = 1;
558 bool isInited = voipSink->IsInited();
559 EXPECT_EQ(false, isInited);
560
561 int32_t ret = voipSink->Init(attr);
562 EXPECT_EQ(SUCCESS, ret);
563
564 isInited = voipSink->IsInited();
565 EXPECT_EQ(true, isInited);
566
567 voipSink->DeInit();
568
569 isInited = voipSink->IsInited();
570 EXPECT_EQ(false, isInited);
571
572 // Continuous execution init
573 ret = voipSink->Init(attr);
574 EXPECT_EQ(SUCCESS, ret);
575 ret = voipSink->Init(attr);
576 EXPECT_EQ(SUCCESS, ret);
577 isInited = voipSink->IsInited();
578 EXPECT_EQ(true, isInited);
579 }
580
581 /**
582 * @tc.name : Test Direct Voip Sink Start State
583 * @tc.type : FUNC
584 * @tc.number: DirectVoipAudioSinkState_003
585 * @tc.desc : Test direct voip sink start state success
586 */
587 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_003, TestSize.Level1)
588 {
589 EXPECT_NE(nullptr, this->voipSink);
590 IAudioSinkAttr attr = {};
591 attr.adapterName = SINK_ADAPTER_NAME;
592 attr.sampleRate = 48000;
593 attr.channel = 2;
594 attr.format = HdiAdapterFormat::SAMPLE_S16;
595 attr.channelLayout = 3;
596 attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
597 attr.volume = 1.0f;
598 attr.openMicSpeaker = 1;
599 int32_t ret = voipSink->Init(attr);
600 EXPECT_EQ(SUCCESS, ret);
601
602 ret = voipSink->Start();
603 EXPECT_EQ(SUCCESS, ret);
604 ret = voipSink->Stop();
605 EXPECT_EQ(SUCCESS, ret);
606
607 // Continuous execution start
608 ret = voipSink->Start();
609 EXPECT_EQ(SUCCESS, ret);
610 ret = voipSink->Start();
611 EXPECT_EQ(SUCCESS, ret);
612 ret = voipSink->Stop();
613 EXPECT_EQ(SUCCESS, ret);
614 }
615
616 /**
617 * @tc.name : Test Direct Voip Sink Resume State
618 * @tc.type : FUNC
619 * @tc.number: DirectVoipAudioSinkState_004
620 * @tc.desc : Test direct voip sink resume state success
621 */
622 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_004, TestSize.Level1)
623 {
624 EXPECT_NE(nullptr, this->voipSink);
625 IAudioSinkAttr attr = {};
626 attr.adapterName = SINK_ADAPTER_NAME;
627 attr.sampleRate = 48000;
628 attr.channel = 2;
629 attr.format = HdiAdapterFormat::SAMPLE_S16;
630 attr.channelLayout = 3;
631 attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
632 attr.volume = 1.0f;
633 attr.openMicSpeaker = 1;
634 int32_t ret = voipSink->Init(attr);
635 EXPECT_EQ(SUCCESS, ret);
636 ret = voipSink->Start();
637 EXPECT_EQ(SUCCESS, ret);
638 ret = voipSink->Resume();
639 EXPECT_EQ(SUCCESS, ret);
640 ret = voipSink->Stop();
641 EXPECT_EQ(SUCCESS, ret);
642 ret = voipSink->SetPaPower(1);
643 EXPECT_EQ(SUCCESS, ret);
644 }
645
CreateUsbAttrInfo(const std::string sinkFormat)646 std::string CreateUsbAttrInfo(const std::string sinkFormat)
647 {
648 return "sink_rate:48000;sink_format:" + sinkFormat + ";";
649 }
650
651 /**
652 * @tc.name : Test Usb Sink Resume State
653 * @tc.type : FUNC
654 * @tc.number: UsbAudioSinkPreload_001
655 * @tc.desc : Test Usb sink Preload state success
656 */
657 HWTEST_F(AudioDirectSinkUnitTest, UsbAudioSinkPreload_001, TestSize.Level1)
658 {
659 EXPECT_NE(nullptr, this->usbSink);
660 IAudioSinkAttr attr = {};
661 attr.adapterName = SINK_ADAPTER_NAME;
662 attr.sampleRate = 48000;
663 attr.channel = 2;
664 attr.format = HdiAdapterFormat::SAMPLE_S16;
665 attr.channelLayout = 3;
666 attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
667 attr.volume = 1.0f;
668 attr.openMicSpeaker = 1;
669 int32_t ret = usbSink->Init(attr);
670 EXPECT_EQ(SUCCESS, ret);
671 ret = usbSink->Preload(CreateUsbAttrInfo(""));
672 EXPECT_EQ(SUCCESS, ret);
673 ret = usbSink->Preload(CreateUsbAttrInfo("sAUDIO_FORMAT_PCM_16_BIT"));
674 EXPECT_EQ(SUCCESS, ret);
675 ret = usbSink->Preload(CreateUsbAttrInfo("AUDIO_FORMAT_PCM_24_BIT"));
676 EXPECT_EQ(SUCCESS, ret);
677 ret = usbSink->Preload(CreateUsbAttrInfo("AUDIO_FORMAT_PCM_32_BIT"));
678 EXPECT_EQ(SUCCESS, ret);
679 ret = usbSink->SetPaPower(1);
680 EXPECT_EQ(SUCCESS, ret);
681 ret = usbSink->SetPaPower(0);
682 EXPECT_EQ(SUCCESS, ret);
683 ret = usbSink->SetPaPower(0);
684 EXPECT_EQ(SUCCESS, ret);
685 ret = usbSink->SetPaPower(1);
686 EXPECT_EQ(SUCCESS, ret);
687 }
688 } // namespace AudioStandard
689 } // namespace OHOS