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 #include "sink/multichannel_audio_render_sink.h"
23
24 using namespace testing::ext;
25
26 namespace OHOS {
27 namespace AudioStandard {
28 class MultichannelAudioRenderSinkUnitTest : public testing::Test {
29 public:
30 static void SetUpTestCase();
31 static void TearDownTestCase();
32 virtual void SetUp();
33 virtual void TearDown();
34
35 protected:
36 static uint32_t id_;
37 static std::shared_ptr<IAudioRenderSink> sink_;
38 static IAudioSinkAttr attr_;
39 };
40
41 uint32_t MultichannelAudioRenderSinkUnitTest::id_ = HDI_INVALID_ID;
42 std::shared_ptr<IAudioRenderSink> MultichannelAudioRenderSinkUnitTest::sink_ = nullptr;
43 IAudioSinkAttr MultichannelAudioRenderSinkUnitTest::attr_ = {};
44
SetUpTestCase()45 void MultichannelAudioRenderSinkUnitTest::SetUpTestCase()
46 {
47 id_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_MULTICHANNEL, HDI_ID_INFO_DEFAULT,
48 true);
49 }
50
TearDownTestCase()51 void MultichannelAudioRenderSinkUnitTest::TearDownTestCase()
52 {
53 HdiAdapterManager::GetInstance().ReleaseId(id_);
54 }
55
SetUp()56 void MultichannelAudioRenderSinkUnitTest::SetUp()
57 {
58 sink_ = HdiAdapterManager::GetInstance().GetRenderSink(id_, true);
59 if (sink_ == nullptr) {
60 return;
61 }
62 }
63
TearDown()64 void MultichannelAudioRenderSinkUnitTest::TearDown()
65 {
66 sink_ = nullptr;
67 }
68
69 /**
70 * @tc.name : Test MultichannelSink API
71 * @tc.number : MultichannelSinkUnitTest_001
72 * @tc.desc : Test multichannel sink create
73 */
74 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_001, TestSize.Level1)
75 {
76 EXPECT_TRUE(sink_);
77 }
78
79 /**
80 * @tc.name : Test MultichannelSink API
81 * @tc.number : MultichannelSinkUnitTest_002
82 * @tc.desc : Test multichannel sink deinit
83 */
84 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_002, TestSize.Level1)
85 {
86 EXPECT_TRUE(sink_);
87 sink_->DeInit();
88 EXPECT_FALSE(sink_->IsInited());
89 }
90
91 /**
92 * @tc.name : Test MultichannelSink API
93 * @tc.number : MultichannelSinkUnitTest_003
94 * @tc.desc : Test multichannel sink start, stop, resume, pause, flush, reset
95 */
96 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_003, TestSize.Level1)
97 {
98 EXPECT_TRUE(sink_);
99 int32_t ret = sink_->Start();
100 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
101 ret = sink_->Stop();
102 EXPECT_EQ(ret, SUCCESS);
103 ret = sink_->Resume();
104 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
105 ret = sink_->Pause();
106 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
107 ret = sink_->Flush();
108 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
109 ret = sink_->Reset();
110 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
111 ret = sink_->Stop();
112 EXPECT_EQ(ret, SUCCESS);
113 }
114
115 /**
116 * @tc.name : Test MultichannelSink API
117 * @tc.number : MultichannelSinkUnitTest_004
118 * @tc.desc : Test multichannel sink set/get volume
119 */
120 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_004, TestSize.Level1)
121 {
122 EXPECT_TRUE(sink_);
123 int32_t ret = sink_->SetVolume(0.0f, 0.0f);
124 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
125 ret = sink_->SetVolume(0.0f, 1.0f);
126 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
127 ret = sink_->SetVolume(1.0f, 0.0f);
128 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
129 ret = sink_->SetVolume(1.0f, 1.0f);
130 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
131 float left;
132 float right;
133 ret = sink_->GetVolume(left, right);
134 EXPECT_EQ(ret, SUCCESS);
135 }
136
137 /**
138 * @tc.name : Test MultichannelSink API
139 * @tc.number : MultichannelSinkUnitTest_005
140 * @tc.desc : Test multichannel sink set audio scene
141 */
142 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_005, TestSize.Level1)
143 {
144 EXPECT_TRUE(sink_);
145 int32_t ret = sink_->SetAudioScene(AUDIO_SCENE_DEFAULT);
146 EXPECT_EQ(ret, SUCCESS);
147 }
148
149 /**
150 * @tc.name : Test MultichannelSink API
151 * @tc.number : MultichannelSinkUnitTest_006
152 * @tc.desc : Test multichannel sink update active device
153 */
154 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_006, TestSize.Level1)
155 {
156 EXPECT_TRUE(sink_);
157 std::vector<DeviceType> deviceTypes = { DEVICE_TYPE_SPEAKER };
158 int32_t ret = sink_->UpdateActiveDevice(deviceTypes);
159 EXPECT_NE(ret, SUCCESS);
160 }
161
162 /**
163 * @tc.name : Test MultichannelSink API
164 * @tc.number : MultichannelSinkUnitTest_007
165 * @tc.desc : Test multichannel sink static function
166 */
167 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_007, TestSize.Level1)
168 {
169 AudioFormat hdiFormat = MultichannelAudioRenderSink::ConvertToHdiFormat(SAMPLE_U8);
170 EXPECT_EQ(hdiFormat, AUDIO_FORMAT_TYPE_PCM_8_BIT);
171 hdiFormat = MultichannelAudioRenderSink::ConvertToHdiFormat(SAMPLE_S16LE);
172 EXPECT_EQ(hdiFormat, AUDIO_FORMAT_TYPE_PCM_16_BIT);
173 hdiFormat = MultichannelAudioRenderSink::ConvertToHdiFormat(SAMPLE_S24LE);
174 EXPECT_EQ(hdiFormat, AUDIO_FORMAT_TYPE_PCM_24_BIT);
175 hdiFormat = MultichannelAudioRenderSink::ConvertToHdiFormat(SAMPLE_S32LE);
176 EXPECT_EQ(hdiFormat, AUDIO_FORMAT_TYPE_PCM_32_BIT);
177 hdiFormat = MultichannelAudioRenderSink::ConvertToHdiFormat(SAMPLE_F32LE);
178 EXPECT_EQ(hdiFormat, AUDIO_FORMAT_TYPE_PCM_16_BIT);
179
180 uint32_t bitFormat = MultichannelAudioRenderSink::PcmFormatToBit(SAMPLE_U8);
181 EXPECT_EQ(bitFormat, PCM_8_BIT);
182 bitFormat = MultichannelAudioRenderSink::PcmFormatToBit(SAMPLE_S16LE);
183 EXPECT_EQ(bitFormat, PCM_16_BIT);
184 bitFormat = MultichannelAudioRenderSink::PcmFormatToBit(SAMPLE_S24LE);
185 EXPECT_EQ(bitFormat, PCM_24_BIT);
186 bitFormat = MultichannelAudioRenderSink::PcmFormatToBit(SAMPLE_S32LE);
187 EXPECT_EQ(bitFormat, PCM_32_BIT);
188 bitFormat = MultichannelAudioRenderSink::PcmFormatToBit(SAMPLE_F32LE);
189 EXPECT_EQ(bitFormat, PCM_16_BIT);
190 }
191
192 /**
193 * @tc.name : Test MultichannelSink API
194 * @tc.number : MultichannelSinkUnitTest_008
195 * @tc.desc : Test multichannel sink static function
196 */
197 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_008, TestSize.Level1)
198 {
199 AudioSampleFormat sampleFormat = MultichannelAudioRenderSink::ParseAudioFormat("AUDIO_FORMAT_PCM_16_BIT");
200 EXPECT_EQ(sampleFormat, SAMPLE_S16LE);
201 sampleFormat = MultichannelAudioRenderSink::ParseAudioFormat("AUDIO_FORMAT_PCM_24_BIT");
202 EXPECT_EQ(sampleFormat, SAMPLE_S24LE);
203 sampleFormat = MultichannelAudioRenderSink::ParseAudioFormat("AUDIO_FORMAT_PCM_32_BIT");
204 EXPECT_EQ(sampleFormat, SAMPLE_S32LE);
205 sampleFormat = MultichannelAudioRenderSink::ParseAudioFormat("");
206 EXPECT_EQ(sampleFormat, SAMPLE_S16LE);
207
208 AudioCategory audioCategory = MultichannelAudioRenderSink::GetAudioCategory(AUDIO_SCENE_DEFAULT);
209 EXPECT_EQ(audioCategory, AUDIO_IN_MEDIA);
210 audioCategory = MultichannelAudioRenderSink::GetAudioCategory(AUDIO_SCENE_RINGING);
211 EXPECT_EQ(audioCategory, AUDIO_IN_RINGTONE);
212 audioCategory = MultichannelAudioRenderSink::GetAudioCategory(AUDIO_SCENE_PHONE_CALL);
213 EXPECT_EQ(audioCategory, AUDIO_IN_CALL);
214 audioCategory = MultichannelAudioRenderSink::GetAudioCategory(AUDIO_SCENE_PHONE_CHAT);
215 EXPECT_EQ(audioCategory, AUDIO_IN_COMMUNICATION);
216 audioCategory = MultichannelAudioRenderSink::GetAudioCategory(AUDIO_SCENE_MAX);
217 EXPECT_EQ(audioCategory, AUDIO_IN_MEDIA);
218 }
219
220 /**
221 * @tc.name : Test MultichannelSink API
222 * @tc.number : MultichannelSinkUnitTest_009
223 * @tc.desc : Test MultichannelAudioRenderSink
224 */
225 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_009, TestSize.Level1)
226 {
227 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
228 EXPECT_NE(multichannelAudioRenderSink, nullptr);
229
230 char *data = nullptr;
231 uint64_t len = 0;
232 multichannelAudioRenderSink->startUpdate_ = false;
233 multichannelAudioRenderSink->CheckUpdateState(data, len);
234 EXPECT_NE(multichannelAudioRenderSink, nullptr);
235 }
236
237 /**
238 * @tc.name : Test MultichannelSink API
239 * @tc.number : MultichannelSinkUnitTest_010
240 * @tc.desc : Test MultichannelAudioRenderSink
241 */
242 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_010, TestSize.Level1)
243 {
244 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
245 EXPECT_NE(multichannelAudioRenderSink, nullptr);
246
247 char *data = nullptr;
248 uint64_t len = 0;
249 multichannelAudioRenderSink->startUpdate_ = true;
250 multichannelAudioRenderSink->renderFrameNum_ = 0;
251 multichannelAudioRenderSink->CheckUpdateState(data, len);
252 EXPECT_EQ(multichannelAudioRenderSink->renderFrameNum_, 1);
253 }
254
255 /**
256 * @tc.name : Test MultichannelSink API
257 * @tc.number : MultichannelSinkUnitTest_011
258 * @tc.desc : Test MultichannelAudioRenderSink
259 */
260 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_011, TestSize.Level1)
261 {
262 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
263 EXPECT_NE(multichannelAudioRenderSink, nullptr);
264
265 char *data = nullptr;
266 uint64_t len = 0;
267 multichannelAudioRenderSink->startUpdate_ = true;
268 multichannelAudioRenderSink->renderFrameNum_ = 9;
269 multichannelAudioRenderSink->lastGetMaxAmplitudeTime_ = -1;
270 multichannelAudioRenderSink->CheckUpdateState(data, len);
271 EXPECT_EQ(multichannelAudioRenderSink->renderFrameNum_, 0);
272 EXPECT_EQ(multichannelAudioRenderSink->startUpdate_, false);
273 }
274
275 /**
276 * @tc.name : Test MultichannelSink API
277 * @tc.number : MultichannelSinkUnitTest_012
278 * @tc.desc : Test MultichannelAudioRenderSink
279 */
280 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_012, TestSize.Level1)
281 {
282 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
283 EXPECT_NE(multichannelAudioRenderSink, nullptr);
284
285 char *data = nullptr;
286 uint64_t len = 0;
287 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
288 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_U8;
289
290 multichannelAudioRenderSink->AdjustAudioBalance(data, len);
291 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
292 }
293
294 /**
295 * @tc.name : Test MultichannelSink API
296 * @tc.number : MultichannelSinkUnitTest_013
297 * @tc.desc : Test MultichannelAudioRenderSink
298 */
299 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_013, TestSize.Level1)
300 {
301 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
302 EXPECT_NE(multichannelAudioRenderSink, nullptr);
303
304 char *data = nullptr;
305 uint64_t len = 0;
306 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
307 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S16LE;
308
309 multichannelAudioRenderSink->AdjustAudioBalance(data, len);
310 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
311 }
312
313 /**
314 * @tc.name : Test MultichannelSink API
315 * @tc.number : MultichannelSinkUnitTest_014
316 * @tc.desc : Test MultichannelAudioRenderSink
317 */
318 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_014, TestSize.Level1)
319 {
320 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
321 EXPECT_NE(multichannelAudioRenderSink, nullptr);
322
323 char *data = nullptr;
324 uint64_t len = 0;
325 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
326 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S24LE;
327
328 multichannelAudioRenderSink->AdjustAudioBalance(data, len);
329 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
330 }
331
332 /**
333 * @tc.name : Test MultichannelSink API
334 * @tc.number : MultichannelSinkUnitTest_015
335 * @tc.desc : Test MultichannelAudioRenderSink
336 */
337 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_015, TestSize.Level1)
338 {
339 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
340 EXPECT_NE(multichannelAudioRenderSink, nullptr);
341
342 char *data = nullptr;
343 uint64_t len = 0;
344 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
345 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S32LE;
346
347 multichannelAudioRenderSink->AdjustAudioBalance(data, len);
348 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
349 }
350
351 /**
352 * @tc.name : Test MultichannelSink API
353 * @tc.number : MultichannelSinkUnitTest_016
354 * @tc.desc : Test MultichannelAudioRenderSink
355 */
356 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_016, TestSize.Level1)
357 {
358 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
359 EXPECT_NE(multichannelAudioRenderSink, nullptr);
360
361 char *data = nullptr;
362 uint64_t len = 0;
363 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
364 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_F32LE;
365
366 multichannelAudioRenderSink->AdjustAudioBalance(data, len);
367 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
368 }
369
370 /**
371 * @tc.name : Test MultichannelSink API
372 * @tc.number : MultichannelSinkUnitTest_017
373 * @tc.desc : Test MultichannelAudioRenderSink
374 */
375 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_017, TestSize.Level1)
376 {
377 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
378 EXPECT_NE(multichannelAudioRenderSink, nullptr);
379
380 char *data = nullptr;
381 uint64_t len = 0;
382 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
383 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_U8;
384
385 multichannelAudioRenderSink->AdjustStereoToMono(data, len);
386 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
387 }
388
389 /**
390 * @tc.name : Test MultichannelSink API
391 * @tc.number : MultichannelSinkUnitTest_018
392 * @tc.desc : Test MultichannelAudioRenderSink
393 */
394 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_018, TestSize.Level1)
395 {
396 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
397 EXPECT_NE(multichannelAudioRenderSink, nullptr);
398
399 char *data = nullptr;
400 uint64_t len = 0;
401 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
402 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S16LE;
403
404 multichannelAudioRenderSink->AdjustStereoToMono(data, len);
405 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
406 }
407
408 /**
409 * @tc.name : Test MultichannelSink API
410 * @tc.number : MultichannelSinkUnitTest_019
411 * @tc.desc : Test MultichannelAudioRenderSink
412 */
413 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_019, TestSize.Level1)
414 {
415 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
416 EXPECT_NE(multichannelAudioRenderSink, nullptr);
417
418 char *data = nullptr;
419 uint64_t len = 0;
420 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
421 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S24LE;
422
423 multichannelAudioRenderSink->AdjustStereoToMono(data, len);
424 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
425 }
426
427 /**
428 * @tc.name : Test MultichannelSink API
429 * @tc.number : MultichannelSinkUnitTest_020
430 * @tc.desc : Test MultichannelAudioRenderSink
431 */
432 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_020, TestSize.Level1)
433 {
434 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
435 EXPECT_NE(multichannelAudioRenderSink, nullptr);
436
437 char *data = nullptr;
438 uint64_t len = 0;
439 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
440 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_S32LE;
441
442 multichannelAudioRenderSink->AdjustStereoToMono(data, len);
443 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
444 }
445
446 /**
447 * @tc.name : Test MultichannelSink API
448 * @tc.number : MultichannelSinkUnitTest_021
449 * @tc.desc : Test MultichannelAudioRenderSink
450 */
451 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_021, TestSize.Level1)
452 {
453 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
454 EXPECT_NE(multichannelAudioRenderSink, nullptr);
455
456 char *data = nullptr;
457 uint64_t len = 0;
458 multichannelAudioRenderSink->attr_.channel = MultichannelAudioRenderSink::STEREO_CHANNEL_COUNT;
459 multichannelAudioRenderSink->attr_.format = AudioSampleFormat::SAMPLE_F32LE;
460
461 multichannelAudioRenderSink->AdjustStereoToMono(data, len);
462 EXPECT_EQ(multichannelAudioRenderSink->attr_.channel, 2);
463 }
464
465 /**
466 * @tc.name : Test MultichannelSink API
467 * @tc.number : MultichannelSinkUnitTest_022
468 * @tc.desc : Test MultichannelAudioRenderSink
469 */
470 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_022, TestSize.Level1)
471 {
472 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
473 EXPECT_NE(multichannelAudioRenderSink, nullptr);
474
475 multichannelAudioRenderSink->renderInited_ = true;
476
477 auto ret = multichannelAudioRenderSink->InitRender();
478 EXPECT_EQ(ret, SUCCESS);
479 }
480
481 /**
482 * @tc.name : Test MultichannelSink API
483 * @tc.number : MultichannelSinkUnitTest_023
484 * @tc.desc : Test MultichannelAudioRenderSink
485 */
486 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_023, TestSize.Level1)
487 {
488 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>();
489 EXPECT_NE(multichannelAudioRenderSink, nullptr);
490
491 multichannelAudioRenderSink->renderInited_ = true;
492
493 auto ret = multichannelAudioRenderSink->InitRender();
494 EXPECT_EQ(ret, SUCCESS);
495 }
496
497 /**
498 * @tc.name : Test MultichannelSink API
499 * @tc.number : MultichannelSinkUnitTest_024
500 * @tc.desc : Test MultichannelAudioRenderSink
501 */
502 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_024, TestSize.Level1)
503 {
504 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_USB);
505 EXPECT_NE(multichannelAudioRenderSink, nullptr);
506
507 struct AudioSceneDescriptor sceneDesc;
508 AudioScene audioScene = AUDIO_SCENE_DEFAULT;
509
510 multichannelAudioRenderSink->InitSceneDesc(sceneDesc, audioScene);
511 EXPECT_EQ(sceneDesc.desc.pins, PIN_OUT_USB_HEADSET);
512 }
513
514 /**
515 * @tc.name : Test MultichannelSink API
516 * @tc.number : MultichannelSinkUnitTest_025
517 * @tc.desc : Test MultichannelAudioRenderSink
518 */
519 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_025, TestSize.Level1)
520 {
521 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
522 EXPECT_NE(multichannelAudioRenderSink, nullptr);
523
524 struct AudioSceneDescriptor sceneDesc;
525 AudioScene audioScene = AUDIO_SCENE_DEFAULT;
526
527 multichannelAudioRenderSink->InitSceneDesc(sceneDesc, audioScene);
528 EXPECT_EQ(sceneDesc.desc.pins, PIN_OUT_SPEAKER);
529 }
530
531 /**
532 * @tc.name : Test MultichannelSink API
533 * @tc.number : MultichannelSinkUnitTest_026
534 * @tc.desc : Test MultichannelAudioRenderSink
535 */
536 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_026, TestSize.Level1)
537 {
538 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_USB);
539 EXPECT_NE(multichannelAudioRenderSink, nullptr);
540
541 struct AudioDeviceDescriptor deviceDesc;
542
543 multichannelAudioRenderSink->InitDeviceDesc(deviceDesc);
544 EXPECT_EQ(deviceDesc.pins, PIN_OUT_USB_HEADSET);
545 }
546
547 /**
548 * @tc.name : Test MultichannelSink API
549 * @tc.number : MultichannelSinkUnitTest_027
550 * @tc.desc : Test MultichannelAudioRenderSink
551 */
552 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_027, TestSize.Level1)
553 {
554 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
555 EXPECT_NE(multichannelAudioRenderSink, nullptr);
556
557 struct AudioDeviceDescriptor deviceDesc;
558
559 multichannelAudioRenderSink->halName_ = HDI_ID_INFO_USB;
560 multichannelAudioRenderSink->InitDeviceDesc(deviceDesc);
561 EXPECT_EQ(deviceDesc.pins, PIN_OUT_USB_HEADSET);
562 }
563
564 /**
565 * @tc.name : Test MultichannelSink API
566 * @tc.number : MultichannelSinkUnitTest_028
567 * @tc.desc : Test MultichannelAudioRenderSink
568 */
569 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_028, TestSize.Level1)
570 {
571 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
572 EXPECT_NE(multichannelAudioRenderSink, nullptr);
573
574 DeviceType device = DEVICE_TYPE_WIRED_HEADSET;
575 multichannelAudioRenderSink->currentActiveDevice_ = DEVICE_TYPE_WIRED_HEADSET;
576
577 multichannelAudioRenderSink->ResetActiveDeviceForDisconnect(device);
578 }
579
580 /**
581 * @tc.name : Test MultichannelSink API
582 * @tc.number : MultichannelSinkUnitTest_029
583 * @tc.desc : Test MultichannelAudioRenderSink
584 */
585 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_029, TestSize.Level1)
586 {
587 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
588 EXPECT_NE(multichannelAudioRenderSink, nullptr);
589
590 DeviceType device = DEVICE_TYPE_NONE;
591 multichannelAudioRenderSink->currentActiveDevice_ = DEVICE_TYPE_WIRED_HEADSET;
592
593 multichannelAudioRenderSink->ResetActiveDeviceForDisconnect(device);
594 }
595
596 /**
597 * @tc.name : Test MultichannelSink API
598 * @tc.number : MultichannelSinkUnitTest_030
599 * @tc.desc : Test MultichannelAudioRenderSink
600 */
601 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_030, TestSize.Level1)
602 {
603 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
604 EXPECT_NE(multichannelAudioRenderSink, nullptr);
605
606 std::vector<DeviceType> outputDevices;
607 outputDevices.push_back(DEVICE_TYPE_NONE);
608 EXPECT_EQ(!outputDevices.empty() && outputDevices.size() == 1, true);
609
610 multichannelAudioRenderSink->currentActiveDevice_ = DEVICE_TYPE_NONE;
611
612 auto ret = multichannelAudioRenderSink->UpdateActiveDevice(outputDevices);
613 EXPECT_EQ(ret, SUCCESS);
614 }
615
616 /**
617 * @tc.name : Test MultichannelSink API
618 * @tc.number : MultichannelSinkUnitTest_031
619 * @tc.desc : Test MultichannelAudioRenderSink
620 */
621 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_031, TestSize.Level1)
622 {
623 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
624 EXPECT_NE(multichannelAudioRenderSink, nullptr);
625
626 std::vector<DeviceType> outputDevices;
627 outputDevices.push_back(DEVICE_TYPE_NONE);
628 EXPECT_EQ(!outputDevices.empty() && outputDevices.size() == 1, true);
629
630 multichannelAudioRenderSink->currentActiveDevice_ = DEVICE_TYPE_SPEAKER;
631
632 auto ret = multichannelAudioRenderSink->UpdateActiveDevice(outputDevices);
633 EXPECT_EQ(ret, SUCCESS);
634 }
635
636 /**
637 * @tc.name : Test MultichannelSink API
638 * @tc.number : MultichannelSinkUnitTest_032
639 * @tc.desc : Test MultichannelAudioRenderSink
640 */
641 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_032, TestSize.Level1)
642 {
643 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
644 EXPECT_NE(multichannelAudioRenderSink, nullptr);
645
646 AudioParamKey key = NONE;
647 std::string condition = "get_usb_info";
648 multichannelAudioRenderSink->adapterNameCase_ = "abc";
649
650 multichannelAudioRenderSink->GetAudioParameter(key, condition);
651 }
652
653 /**
654 * @tc.name : Test MultichannelSink API
655 * @tc.number : MultichannelSinkUnitTest_033
656 * @tc.desc : Test MultichannelAudioRenderSink
657 */
658 HWTEST_F(MultichannelAudioRenderSinkUnitTest, MultichannelSinkUnitTest_033, TestSize.Level1)
659 {
660 auto multichannelAudioRenderSink = std::make_shared<MultichannelAudioRenderSink>(HDI_ID_INFO_DP);
661 EXPECT_NE(multichannelAudioRenderSink, nullptr);
662
663 AudioParamKey key = NONE;
664 std::string condition = "abc";
665
666 multichannelAudioRenderSink->GetAudioParameter(key, condition);
667 EXPECT_EQ(multichannelAudioRenderSink->adapterNameCase_, "");
668 }
669 } // namespace AudioStandard
670 } // namespace OHOS