1 /*
2 * Copyright (c) 2025 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 <iostream>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include "audio_utils.h"
20 #include "common/hdi_adapter_info.h"
21 #include "manager/hdi_adapter_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 class AudioRenderSinkUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
SetUp()31 virtual void SetUp() {}
TearDown()32 virtual void TearDown() {}
33
34 void InitPrimarySink();
35 void DeInitPrimarySink();
36 void InitUsbSink();
37 void DeInitUsbSink();
38 void InitDirectSink();
39 void DeInitDirectSink();
40 void InitVoipSink();
41 void DeInitVoipSink();
42
43 protected:
44 static uint32_t primaryId_;
45 static uint32_t usbId_;
46 static uint32_t directId_;
47 static uint32_t voipId_;
48 static std::shared_ptr<IAudioRenderSink> primarySink_;
49 static std::shared_ptr<IAudioRenderSink> usbSink_;
50 static std::shared_ptr<IAudioRenderSink> directSink_;
51 static std::shared_ptr<IAudioRenderSink> voipSink_;
52 static IAudioSinkAttr attr_;
53 static bool primarySinkInited_;
54 };
55
56 uint32_t AudioRenderSinkUnitTest::primaryId_ = HDI_INVALID_ID;
57 uint32_t AudioRenderSinkUnitTest::usbId_ = HDI_INVALID_ID;
58 uint32_t AudioRenderSinkUnitTest::directId_ = HDI_INVALID_ID;
59 uint32_t AudioRenderSinkUnitTest::voipId_ = HDI_INVALID_ID;
60 std::shared_ptr<IAudioRenderSink> AudioRenderSinkUnitTest::primarySink_ = nullptr;
61 std::shared_ptr<IAudioRenderSink> AudioRenderSinkUnitTest::usbSink_ = nullptr;
62 std::shared_ptr<IAudioRenderSink> AudioRenderSinkUnitTest::directSink_ = nullptr;
63 std::shared_ptr<IAudioRenderSink> AudioRenderSinkUnitTest::voipSink_ = nullptr;
64 IAudioSinkAttr AudioRenderSinkUnitTest::attr_ = {};
65 bool AudioRenderSinkUnitTest::primarySinkInited_ = false;
66
SetUpTestCase()67 void AudioRenderSinkUnitTest::SetUpTestCase()
68 {
69 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
70 primaryId_ = manager.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_DEFAULT, true);
71 usbId_ = manager.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_USB, true);
72 directId_ = manager.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_DIRECT, true);
73 voipId_ = manager.GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_VOIP, true);
74 }
75
TearDownTestCase()76 void AudioRenderSinkUnitTest::TearDownTestCase()
77 {
78 HdiAdapterManager::GetInstance().ReleaseId(primaryId_);
79 HdiAdapterManager::GetInstance().ReleaseId(usbId_);
80 HdiAdapterManager::GetInstance().ReleaseId(directId_);
81 HdiAdapterManager::GetInstance().ReleaseId(voipId_);
82 }
83
InitPrimarySink()84 void AudioRenderSinkUnitTest::InitPrimarySink()
85 {
86 primarySink_ = HdiAdapterManager::GetInstance().GetRenderSink(primaryId_, true);
87 if (primarySink_ == nullptr) {
88 return;
89 }
90 if (!primarySink_->IsInited()) {
91 attr_.adapterName = "primary";
92 attr_.sampleRate = 48000; // 48000: sample rate
93 attr_.channel = 2; // 2: channel
94 attr_.format = SAMPLE_S16LE;
95 attr_.channelLayout = 3; // 3: channel layout
96 attr_.deviceType = DEVICE_TYPE_SPEAKER;
97 attr_.volume = 1.0f;
98 attr_.openMicSpeaker = 1;
99 primarySink_->Init(attr_);
100 } else {
101 primarySinkInited_ = true;
102 }
103 }
104
DeInitPrimarySink()105 void AudioRenderSinkUnitTest::DeInitPrimarySink()
106 {
107 if (primarySink_ && primarySink_->IsInited() && !primarySinkInited_) {
108 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
109 primarySink_->UpdateActiveDevice(deviceTypes);
110 primarySink_->DeInit();
111 }
112 primarySink_ = nullptr;
113 }
114
InitUsbSink()115 void AudioRenderSinkUnitTest::InitUsbSink()
116 {
117 usbSink_ = HdiAdapterManager::GetInstance().GetRenderSink(usbId_, true);
118 if (usbSink_ == nullptr) {
119 return;
120 }
121 attr_.adapterName = "primary";
122 attr_.sampleRate = 48000; // 48000: sample rate
123 attr_.channel = 2; // 2: channel
124 attr_.format = SAMPLE_S16LE;
125 attr_.channelLayout = 3; // 3: channel layout
126 attr_.deviceType = DEVICE_TYPE_USB_HEADSET;
127 attr_.volume = 1.0f;
128 attr_.openMicSpeaker = 1;
129 usbSink_->Init(attr_);
130 }
131
DeInitUsbSink()132 void AudioRenderSinkUnitTest::DeInitUsbSink()
133 {
134 if (usbSink_ && usbSink_->IsInited()) {
135 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
136 usbSink_->UpdateActiveDevice(deviceTypes);
137 usbSink_->DeInit();
138 }
139 usbSink_ = nullptr;
140 }
141
InitDirectSink()142 void AudioRenderSinkUnitTest::InitDirectSink()
143 {
144 directSink_ = HdiAdapterManager::GetInstance().GetRenderSink(directId_, true);
145 if (directSink_ == nullptr) {
146 return;
147 }
148 attr_.adapterName = "primary";
149 attr_.sampleRate = 48000; // 48000: sample rate
150 attr_.channel = 2; // 2: channel
151 attr_.format = SAMPLE_S32LE;
152 attr_.channelLayout = 3; // 3: channel layout
153 attr_.deviceType = DEVICE_TYPE_WIRED_HEADSET;
154 attr_.volume = 1.0f;
155 attr_.openMicSpeaker = 1;
156 directSink_->Init(attr_);
157 }
158
DeInitDirectSink()159 void AudioRenderSinkUnitTest::DeInitDirectSink()
160 {
161 if (directSink_ && directSink_->IsInited()) {
162 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
163 directSink_->UpdateActiveDevice(deviceTypes);
164 directSink_->DeInit();
165 }
166 directSink_ = nullptr;
167 }
168
InitVoipSink()169 void AudioRenderSinkUnitTest::InitVoipSink()
170 {
171 voipSink_ = HdiAdapterManager::GetInstance().GetRenderSink(voipId_, true);
172 if (voipSink_ == nullptr) {
173 return;
174 }
175 attr_.adapterName = "primary";
176 attr_.sampleRate = 48000; // 48000: sample rate
177 attr_.channel = 2; // 2: channel
178 attr_.format = SAMPLE_S16LE;
179 attr_.channelLayout = 3; // 3: channel layout
180 attr_.deviceType = DEVICE_TYPE_SPEAKER;
181 attr_.volume = 1.0f;
182 attr_.openMicSpeaker = 1;
183 voipSink_->Init(attr_);
184 }
185
DeInitVoipSink()186 void AudioRenderSinkUnitTest::DeInitVoipSink()
187 {
188 if (voipSink_ && voipSink_->IsInited()) {
189 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
190 voipSink_->UpdateActiveDevice(deviceTypes);
191 voipSink_->DeInit();
192 }
193 voipSink_ = nullptr;
194 }
195
196 /**
197 * @tc.name : Test PrimarySink API
198 * @tc.number : PrimarySinkUnitTest_001
199 * @tc.desc : Test primary sink create
200 */
201 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_001, TestSize.Level1)
202 {
203 InitPrimarySink();
204 EXPECT_TRUE(primarySink_ != nullptr);
205 DeInitPrimarySink();
206 }
207
208 /**
209 * @tc.name : Test PrimarySink API
210 * @tc.number : PrimarySinkUnitTest_002
211 * @tc.desc : Test primary sink init
212 */
213 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_002, TestSize.Level1)
214 {
215 InitPrimarySink();
216 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
217 if (!primarySinkInited_) {
218 primarySink_->DeInit();
219 attr_.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
220 int32_t ret = primarySink_->Init(attr_);
221 EXPECT_EQ(ret, SUCCESS);
222 ret = primarySink_->Init(attr_);
223 EXPECT_EQ(ret, SUCCESS);
224 EXPECT_TRUE(primarySink_->IsInited());
225 }
226 DeInitPrimarySink();
227 }
228
229 /**
230 * @tc.name : Test PrimarySink API
231 * @tc.number : PrimarySinkUnitTest_003
232 * @tc.desc : Test primary sink start, stop
233 */
234 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_003, TestSize.Level1)
235 {
236 InitPrimarySink();
237 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
238 int32_t ret = primarySink_->Start();
239 EXPECT_EQ(ret, SUCCESS);
240 ret = primarySink_->Stop();
241 EXPECT_EQ(ret, SUCCESS);
242 ret = primarySink_->Start();
243 EXPECT_EQ(ret, SUCCESS);
244 ret = primarySink_->Start();
245 EXPECT_EQ(ret, SUCCESS);
246 ret = primarySink_->Stop();
247 EXPECT_EQ(ret, SUCCESS);
248 DeInitPrimarySink();
249 }
250
251 /**
252 * @tc.name : Test PrimarySink API
253 * @tc.number : PrimarySinkUnitTest_004
254 * @tc.desc : Test primary sink resume
255 */
256 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_004, TestSize.Level1)
257 {
258 InitPrimarySink();
259 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
260 int32_t ret = primarySink_->Start();
261 EXPECT_EQ(ret, SUCCESS);
262 ret = primarySink_->Resume();
263 EXPECT_EQ(ret, SUCCESS);
264 ret = primarySink_->Stop();
265 EXPECT_EQ(ret, SUCCESS);
266 DeInitPrimarySink();
267 }
268
269 /**
270 * @tc.name : Test PrimarySink API
271 * @tc.number : PrimarySinkUnitTest_005
272 * @tc.desc : Test primary sink set volume
273 */
274 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_005, TestSize.Level1)
275 {
276 InitPrimarySink();
277 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
278 int32_t ret = primarySink_->SetVolume(1.0f, 1.0f);
279 EXPECT_NE(ret, SUCCESS);
280 DeInitPrimarySink();
281 }
282
283 /**
284 * @tc.name : Test PrimarySink API
285 * @tc.number : PrimarySinkUnitTest_006
286 * @tc.desc : Test primary sink set audio param
287 */
288 HWTEST_F(AudioRenderSinkUnitTest, PrimarySinkUnitTest_006, TestSize.Level1)
289 {
290 InitPrimarySink();
291 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
292 primarySink_->SetAudioParameter(NONE, "", "param=0");
293 DeInitPrimarySink();
294 }
295
296 /**
297 * @tc.name : Test SetDmDeviceType API
298 * @tc.number : SetDmDeviceType_001
299 * @tc.desc : Test SetDmDeviceType
300 */
301 HWTEST_F(AudioRenderSinkUnitTest, SetDmDeviceType_001, TestSize.Level1)
302 {
303 InitPrimarySink();
304 EXPECT_TRUE(primarySink_ && primarySink_->IsInited());
305 std::vector<DeviceType> outputDevices;
306 outputDevices.push_back(DEVICE_TYPE_NEARLINK);
307 primarySink_->UpdateActiveDevice(outputDevices);
308 primarySink_->SetDmDeviceType(DM_DEVICE_TYPE_DEFAULT, DEVICE_TYPE_NEARLINK_IN);
309 primarySink_->SetDmDeviceType(DM_DEVICE_TYPE_NEARLINK_SCO, DEVICE_TYPE_NEARLINK_IN);
310 primarySink_->SetDmDeviceType(DM_DEVICE_TYPE_DEFAULT, DEVICE_TYPE_NEARLINK_IN);
311 outputDevices.clear();
312 outputDevices.push_back(DEVICE_TYPE_SPEAKER);
313 primarySink_->UpdateActiveDevice(outputDevices);
314 DeInitPrimarySink();
315 }
316
317 /**
318 * @tc.name : Test UsbSink API
319 * @tc.number : UsbSinkUnitTest_001
320 * @tc.desc : Test usb sink create
321 */
322 HWTEST_F(AudioRenderSinkUnitTest, UsbSinkUnitTest_001, TestSize.Level1)
323 {
324 InitUsbSink();
325 EXPECT_TRUE(usbSink_ != nullptr);
326 DeInitUsbSink();
327 }
328
329 /**
330 * @tc.name : Test UsbSink API
331 * @tc.number : UsbSinkUnitTest_002
332 * @tc.desc : Test usb sink init
333 */
334 HWTEST_F(AudioRenderSinkUnitTest, UsbSinkUnitTest_002, TestSize.Level1)
335 {
336 InitUsbSink();
337 EXPECT_TRUE(usbSink_ && usbSink_->IsInited());
338 usbSink_->DeInit();
339 attr_.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
340 int32_t ret = usbSink_->Init(attr_);
341 EXPECT_EQ(ret, SUCCESS);
342 ret = usbSink_->Init(attr_);
343 EXPECT_EQ(ret, SUCCESS);
344 EXPECT_TRUE(usbSink_->IsInited());
345 DeInitUsbSink();
346 }
347
348 /**
349 * @tc.name : Test UsbSink API
350 * @tc.number : UsbSinkUnitTest_003
351 * @tc.desc : Test usb sink start, stop
352 */
353 HWTEST_F(AudioRenderSinkUnitTest, UsbSinkUnitTest_003, TestSize.Level1)
354 {
355 InitUsbSink();
356 EXPECT_TRUE(usbSink_ && usbSink_->IsInited());
357 int32_t ret = usbSink_->Start();
358 EXPECT_EQ(ret, SUCCESS);
359 ret = usbSink_->Stop();
360 EXPECT_EQ(ret, SUCCESS);
361 ret = usbSink_->Start();
362 EXPECT_EQ(ret, SUCCESS);
363 ret = usbSink_->Start();
364 EXPECT_EQ(ret, SUCCESS);
365 ret = usbSink_->Stop();
366 EXPECT_EQ(ret, SUCCESS);
367 DeInitUsbSink();
368 }
369
370 /**
371 * @tc.name : Test UsbSink API
372 * @tc.number : UsbSinkUnitTest_004
373 * @tc.desc : Test usb sink resume
374 */
375 HWTEST_F(AudioRenderSinkUnitTest, UsbSinkUnitTest_004, TestSize.Level1)
376 {
377 InitUsbSink();
378 EXPECT_TRUE(usbSink_ && usbSink_->IsInited());
379 int32_t ret = usbSink_->Start();
380 EXPECT_EQ(ret, SUCCESS);
381 ret = usbSink_->Resume();
382 EXPECT_EQ(ret, SUCCESS);
383 ret = usbSink_->Stop();
384 EXPECT_EQ(ret, SUCCESS);
385 DeInitUsbSink();
386 }
387
388 /**
389 * @tc.name : Test UsbSink API
390 * @tc.number : UsbSinkUnitTest_005
391 * @tc.desc : Test usb sink set volume
392 */
393 HWTEST_F(AudioRenderSinkUnitTest, UsbSinkUnitTest_005, TestSize.Level1)
394 {
395 InitUsbSink();
396 EXPECT_TRUE(usbSink_ && usbSink_->IsInited());
397 int32_t ret = usbSink_->SetVolume(1.0f, 1.0f);
398 EXPECT_NE(ret, SUCCESS);
399 DeInitUsbSink();
400 }
401
402 /**
403 * @tc.name : Test DirectSink API
404 * @tc.number : DirectSinkUnitTest_001
405 * @tc.desc : Test direct sink create
406 */
407 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_001, TestSize.Level1)
408 {
409 InitDirectSink();
410 EXPECT_TRUE(directSink_ != nullptr);
411 DeInitDirectSink();
412 }
413
414 /**
415 * @tc.name : Test DirectSink API
416 * @tc.number : DirectSinkUnitTest_002
417 * @tc.desc : Test direct sink init
418 */
419 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_002, TestSize.Level1)
420 {
421 InitDirectSink();
422 EXPECT_TRUE(directSink_ && directSink_->IsInited());
423 directSink_->DeInit();
424 int32_t ret = directSink_->Init(attr_);
425 EXPECT_EQ(ret, SUCCESS);
426 ret = directSink_->Init(attr_);
427 EXPECT_EQ(ret, SUCCESS);
428 attr_.sampleRate = 192000;
429 ret = directSink_->Init(attr_);
430 EXPECT_EQ(ret, SUCCESS);
431 attr_.deviceType = DEVICE_TYPE_USB_HEADSET;
432 ret = directSink_->Init(attr_);
433 EXPECT_TRUE(directSink_->IsInited());
434 DeInitDirectSink();
435 }
436
437 /**
438 * @tc.name : Test DirectSink API
439 * @tc.number : DirectSinkUnitTest_003
440 * @tc.desc : Test direct sink deinit
441 */
442 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_003, TestSize.Level1)
443 {
444 InitDirectSink();
445 EXPECT_TRUE(directSink_ && directSink_->IsInited());
446 directSink_->DeInit();
447 EXPECT_FALSE(directSink_->IsInited());
448 DeInitDirectSink();
449 }
450
451 /**
452 * @tc.name : Test DirectSink API
453 * @tc.number : DirectSinkUnitTest_004
454 * @tc.desc : Test direct sink start, stop
455 */
456 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_004, TestSize.Level1)
457 {
458 InitDirectSink();
459 EXPECT_TRUE(directSink_ && directSink_->IsInited());
460 int32_t ret = directSink_->Start();
461 EXPECT_EQ(ret, SUCCESS);
462 ret = directSink_->Stop();
463 EXPECT_EQ(ret, SUCCESS);
464 ret = directSink_->Start();
465 EXPECT_EQ(ret, SUCCESS);
466 ret = directSink_->Start();
467 EXPECT_EQ(ret, SUCCESS);
468 ret = directSink_->Stop();
469 EXPECT_EQ(ret, SUCCESS);
470 DeInitDirectSink();
471 }
472
473 /**
474 * @tc.name : Test DirectSink API
475 * @tc.number : DirectSinkUnitTest_005
476 * @tc.desc : Test direct sink resume
477 */
478 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_005, TestSize.Level1)
479 {
480 InitDirectSink();
481 EXPECT_TRUE(directSink_ && directSink_->IsInited());
482 int32_t ret = directSink_->Start();
483 EXPECT_EQ(ret, SUCCESS);
484 ret = directSink_->Resume();
485 EXPECT_EQ(ret, SUCCESS);
486 ret = directSink_->Stop();
487 EXPECT_EQ(ret, SUCCESS);
488 DeInitDirectSink();
489 }
490
491 /**
492 * @tc.name : Test DirectSink API
493 * @tc.number : DirectSinkUnitTest_006
494 * @tc.desc : Test direct sink render frame
495 */
496 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_006, TestSize.Level1)
497 {
498 InitDirectSink();
499 EXPECT_TRUE(directSink_ && directSink_->IsInited());
500 uint64_t writeLen = 0;
501 std::vector<char> buffer{'8', '8', '8', '8', '8', '8', '8', '8'};
502 int32_t ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
503 EXPECT_EQ(ret, SUCCESS);
504 directSink_->SetAudioMonoState(true);
505 directSink_->SetAudioBalanceValue(1.0f);
506 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
507 EXPECT_EQ(ret, SUCCESS);
508 directSink_->SetAudioBalanceValue(-1.0f);
509 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
510 EXPECT_EQ(ret, SUCCESS);
511 attr_.format = SAMPLE_U8;
512 ret = directSink_->Init(attr_);
513 EXPECT_EQ(ret, SUCCESS);
514 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
515 EXPECT_EQ(ret, SUCCESS);
516 attr_.format = SAMPLE_S16LE;
517 ret = directSink_->Init(attr_);
518 EXPECT_EQ(ret, SUCCESS);
519 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
520 EXPECT_EQ(ret, SUCCESS);
521 attr_.format = SAMPLE_S24LE;
522 ret = directSink_->Init(attr_);
523 EXPECT_EQ(ret, SUCCESS);
524 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
525 EXPECT_EQ(ret, SUCCESS);
526 attr_.format = INVALID_WIDTH;
527 ret = directSink_->Init(attr_);
528 EXPECT_EQ(ret, SUCCESS);
529 ret = directSink_->RenderFrame(*buffer.data(), buffer.size(), writeLen);
530 EXPECT_EQ(ret, SUCCESS);
531 DeInitDirectSink();
532 }
533
534 /**
535 * @tc.name : Test DirectSink API
536 * @tc.number : DirectSinkUnitTest_007
537 * @tc.desc : Test direct sink set volume
538 */
539 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_007, TestSize.Level1)
540 {
541 InitDirectSink();
542 EXPECT_TRUE(directSink_ && directSink_->IsInited());
543 int32_t ret = directSink_->SetVolume(0.0f, 0.0f);
544 EXPECT_EQ(ret, SUCCESS);
545 ret = directSink_->SetVolume(0.0f, 1.0f);
546 EXPECT_EQ(ret, SUCCESS);
547 ret = directSink_->SetVolume(1.0f, 0.0f);
548 EXPECT_EQ(ret, SUCCESS);
549 ret = directSink_->SetVolume(1.0f, 1.0f);
550 EXPECT_EQ(ret, SUCCESS);
551 DeInitDirectSink();
552 }
553
554 /**
555 * @tc.name : Test DirectSink API
556 * @tc.number : DirectSinkUnitTest_008
557 * @tc.desc : Test direct sink resume, pause, reset, flush, get presentation position, set pa power
558 */
559 HWTEST_F(AudioRenderSinkUnitTest, DirectSinkUnitTest_008, TestSize.Level1)
560 {
561 InitDirectSink();
562 EXPECT_TRUE(directSink_ && directSink_->IsInited());
563 int32_t ret = directSink_->Reset();
564 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
565 ret = directSink_->Flush();
566 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
567 ret = directSink_->Start();
568 EXPECT_EQ(ret, SUCCESS);
569 ret = directSink_->Resume();
570 EXPECT_EQ(ret, SUCCESS);
571 ret = directSink_->Pause();
572 EXPECT_NE(ret, SUCCESS);
573 ret = directSink_->Resume();
574 EXPECT_EQ(ret, SUCCESS);
575 uint64_t frame = 10;
576 int64_t timeSec = 10;
577 int64_t timeNanoSec = 10;
578 ret = directSink_->GetPresentationPosition(frame, timeSec, timeNanoSec);
579 EXPECT_EQ(ret, SUCCESS);
580 ret = directSink_->SetPaPower(1);
581 EXPECT_EQ(ret, SUCCESS);
582 ret = directSink_->Stop();
583 EXPECT_EQ(ret, SUCCESS);
584 DeInitDirectSink();
585 }
586
587 /**
588 * @tc.name : Test VoipSink API
589 * @tc.number : VoipSinkUnitTest_001
590 * @tc.desc : Test voip sink create
591 */
592 HWTEST_F(AudioRenderSinkUnitTest, VoipSinkUnitTest_001, TestSize.Level1)
593 {
594 InitVoipSink();
595 EXPECT_TRUE(voipSink_ != nullptr);
596 DeInitVoipSink();
597 }
598
599 /**
600 * @tc.name : Test VoipSink API
601 * @tc.number : VoipSinkUnitTest_002
602 * @tc.desc : Test voip sink init
603 */
604 HWTEST_F(AudioRenderSinkUnitTest, VoipSinkUnitTest_002, TestSize.Level1)
605 {
606 InitVoipSink();
607 EXPECT_TRUE(voipSink_ && voipSink_->IsInited());
608 voipSink_->DeInit();
609 attr_.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
610 int32_t ret = voipSink_->Init(attr_);
611 EXPECT_EQ(ret, SUCCESS);
612 ret = voipSink_->Init(attr_);
613 EXPECT_EQ(ret, SUCCESS);
614 EXPECT_TRUE(voipSink_->IsInited());
615 DeInitVoipSink();
616 }
617
618 /**
619 * @tc.name : Test VoipSink API
620 * @tc.number : VoipSinkUnitTest_003
621 * @tc.desc : Test voip sink start, stop
622 */
623 HWTEST_F(AudioRenderSinkUnitTest, VoipSinkUnitTest_003, TestSize.Level1)
624 {
625 InitVoipSink();
626 EXPECT_TRUE(voipSink_ && voipSink_->IsInited());
627 int32_t ret = voipSink_->Start();
628 EXPECT_EQ(ret, SUCCESS);
629 ret = voipSink_->Stop();
630 EXPECT_EQ(ret, SUCCESS);
631 ret = voipSink_->Start();
632 EXPECT_EQ(ret, SUCCESS);
633 ret = voipSink_->Start();
634 EXPECT_EQ(ret, SUCCESS);
635 ret = voipSink_->Stop();
636 EXPECT_EQ(ret, SUCCESS);
637 DeInitVoipSink();
638 }
639
640 /**
641 * @tc.name : Test VoipSink API
642 * @tc.number : VoipSinkUnitTest_004
643 * @tc.desc : Test voip sink resume
644 */
645 HWTEST_F(AudioRenderSinkUnitTest, VoipSinkUnitTest_004, TestSize.Level1)
646 {
647 InitVoipSink();
648 EXPECT_TRUE(voipSink_ && voipSink_->IsInited());
649 int32_t ret = voipSink_->Start();
650 EXPECT_EQ(ret, SUCCESS);
651 ret = voipSink_->Resume();
652 EXPECT_EQ(ret, SUCCESS);
653 ret = voipSink_->Stop();
654 EXPECT_EQ(ret, SUCCESS);
655 DeInitVoipSink();
656 }
657
658 /**
659 * @tc.name : Test VoipSink API
660 * @tc.number : VoipSinkUnitTest_005
661 * @tc.desc : Test voip sink set volume
662 */
663 HWTEST_F(AudioRenderSinkUnitTest, VoipSinkUnitTest_005, TestSize.Level1)
664 {
665 InitVoipSink();
666 EXPECT_TRUE(voipSink_ && voipSink_->IsInited());
667 int32_t ret = voipSink_->SetVolume(1.0f, 1.0f);
668 EXPECT_EQ(ret, SUCCESS);
669 DeInitVoipSink();
670 }
671
672 } // namespace AudioStandard
673 } // namespace OHOS
674