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 <gtest/gtest.h>
17 #include "direct_playback_engine.h"
18 #include "sink/i_audio_render_sink.h"
19 #include "common/hdi_adapter_info.h"
20 #include "manager/hdi_adapter_manager.h"
21 #include "pro_renderer_stream_impl.h"
22 #include "audio_errors.h"
23
24 using namespace testing::ext;
25 namespace OHOS {
26 namespace AudioStandard {
27 class DirectPlayBackEngineUnitTest : 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 DirectPlayBackEngineUnitTest::SetUpTestCase(void)
42 {
43 // input testsuit setup step，setup invoked before all testcases
44 }
45
TearDownTestCase(void)46 void DirectPlayBackEngineUnitTest::TearDownTestCase(void)
47 {
48 // input testsuit teardown step，teardown invoked after all testcases
49 }
50
SetUp(void)51 void DirectPlayBackEngineUnitTest::SetUp(void)
52 {
53 AudioDeviceDescriptor deviceInfo(AudioDeviceDescriptor::DEVICE_INFO);
54 deviceInfo.deviceType_ = DEVICE_TYPE_SPEAKER;
55 playbackEngine_ = std::make_unique<DirectPlayBackEngine>();
56 if (playbackEngine_) {
57 playbackEngine_->Init(deviceInfo, false);
58 }
59 }
60
TearDown(void)61 void DirectPlayBackEngineUnitTest::TearDown(void)
62 {
63 if (playbackEngine_) {
64 playbackEngine_->Stop();
65 playbackEngine_ = nullptr;
66 }
67 }
68
69 /**
70 * @tc.name : Test DirectPlayBackEngine API
71 * @tc.type : FUNC
72 * @tc.number: DirectPlayBackEngine_001
73 * @tc.desc : Test DirectPlayBackEngine::Init().
74 */
75 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_001, TestSize.Level2)
76 {
77 DirectPlayBackEngine engine;
78 AudioDeviceDescriptor deviceDesc(AudioDeviceDescriptor::DEVICE_INFO);
79 bool isVoip = true;
80 engine.isInit_ = true;
81 deviceDesc.deviceType_ = DEVICE_TYPE_INVALID;
82 engine.device_.deviceType_ = DEVICE_TYPE_NONE;
83 engine.renderId_ = HDI_INVALID_ID;
84
85 auto ret = engine.Init(deviceDesc, isVoip);
86 EXPECT_EQ(ret, SUCCESS);
87
88 engine.isInit_ = false;
89 ret = engine.Init(deviceDesc, isVoip);
90 EXPECT_EQ(ret, SUCCESS);
91 }
92
93 /**
94 * @tc.name : Test DirectPlayBackEngine API
95 * @tc.type : FUNC
96 * @tc.number: DirectPlayBackEngine_002
97 * @tc.desc : Test DirectPlayBackEngine::Init().
98 */
99 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_002, TestSize.Level2)
100 {
101 DirectPlayBackEngine engine;
102 AudioDeviceDescriptor deviceDesc(AudioDeviceDescriptor::DEVICE_INFO);
103 bool isVoip = true;
104 engine.isInit_ = true;
105 deviceDesc.deviceType_ = DEVICE_TYPE_INVALID;
106 engine.device_.deviceType_ = DEVICE_TYPE_INVALID;
107 engine.renderId_ = HDI_INVALID_ID;
108
109 auto ret = engine.Init(deviceDesc, isVoip);
110 EXPECT_EQ(ret, SUCCESS);
111
112 deviceDesc.deviceType_ = DEVICE_TYPE_NONE;
113 ret = engine.Init(deviceDesc, isVoip);
114 EXPECT_EQ(ret, SUCCESS);
115 }
116
117 /**
118 * @tc.name : Test DirectPlayBackEngine API
119 * @tc.type : FUNC
120 * @tc.number: DirectPlayBackEngine_003
121 * @tc.desc : Test DirectPlayBackEngine::AddRenderer().
122 */
123 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_003, TestSize.Level2)
124 {
125 DirectPlayBackEngine engine;
126 engine.isStart_ = true;
127 uint32_t idx1 = 0;
128 uint32_t idx2 = 1;
129 AudioProcessConfig config;
130 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(config, true);
131 if (rendererStream1) {
132 rendererStream1->SetStreamIndex(idx1);
133 }
134 engine.stream_ = rendererStream1;
135 auto ret = engine.AddRenderer(rendererStream1);
136 EXPECT_EQ(ret, SUCCESS);
137
138 std::shared_ptr<ProRendererStreamImpl> rendererStream2 = std::make_shared<ProRendererStreamImpl>(config, true);
139 if (rendererStream2) {
140 rendererStream2->SetStreamIndex(idx2);
141 }
142 ret = engine.AddRenderer(rendererStream2);
143 EXPECT_EQ(ret, ERROR_UNSUPPORTED);
144 }
145
146 /**
147 * @tc.name : Test DirectPlayBackEngine API
148 * @tc.type : FUNC
149 * @tc.number: DirectPlayBackEngine_004
150 * @tc.desc : Test DirectPlayBackEngine::RemoveRenderer().
151 */
152 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_004, TestSize.Level2)
153 {
154 DirectPlayBackEngine engine;
155 engine.isStart_ = true;
156 uint32_t idx1 = 0;
157 uint32_t idx2 = 1;
158 AudioProcessConfig config;
159 std::shared_ptr<ProRendererStreamImpl> rendererStream1 = std::make_shared<ProRendererStreamImpl>(config, true);
160 if (rendererStream1) {
161 rendererStream1->SetStreamIndex(idx1);
162 }
163 engine.stream_ = nullptr;
164 engine.RemoveRenderer(rendererStream1);
165
166 engine.stream_ = rendererStream1;
167 engine.RemoveRenderer(rendererStream1);
168 EXPECT_EQ(engine.stream_, nullptr);
169
170 std::shared_ptr<ProRendererStreamImpl> rendererStream2 = std::make_shared<ProRendererStreamImpl>(config, true);
171 if (rendererStream2) {
172 rendererStream2->SetStreamIndex(idx2);
173 }
174 engine.stream_ = rendererStream1;
175 EXPECT_NE(engine.stream_->GetStreamIndex(), rendererStream2->GetStreamIndex());
176 engine.RemoveRenderer(rendererStream2);
177 }
178
179 /**
180 * @tc.name : Test DirectPlayBackEngine API
181 * @tc.type : FUNC
182 * @tc.number: DirectPlayBackEngine_005
183 * @tc.desc : Test DirectPlayBackEngine::MixStreams()
184 */
185 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_005, TestSize.Level2)
186 {
187 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
188 EXPECT_NE(enginePtr, nullptr);
189
190 AudioProcessConfig configRet;
191 enginePtr->stream_ = std::make_shared<ProRendererStreamImpl>(configRet, true);
192 EXPECT_NE(enginePtr->stream_, nullptr);
193 enginePtr->MixStreams();
194
195 enginePtr->stream_ = nullptr;
196 enginePtr->MixStreams();
197 }
198
199 /**
200 * @tc.name : Test DirectPlayBackEngine API
201 * @tc.type : FUNC
202 * @tc.number: DirectPlayBackEngine_006
203 * @tc.desc : Test DirectPlayBackEngine::MixStreams()
204 */
205 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_006, TestSize.Level2)
206 {
207 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
208 EXPECT_NE(enginePtr, nullptr);
209
210 AudioProcessConfig config;
211 enginePtr->stream_ = std::make_shared<ProRendererStreamImpl>(config, true);
212 EXPECT_NE(enginePtr->stream_, nullptr);
213 enginePtr->failedCount_.store(10);
214 enginePtr->MixStreams();
215
216 enginePtr->failedCount_.store(100);
217 enginePtr->MixStreams();
218 }
219
220 /**
221 * @tc.name : Test DirectPlayBackEngine API
222 * @tc.type : FUNC
223 * @tc.number: DirectPlayBackEngine_007
224 * @tc.desc : Test DirectPlayBackEngine::GetDirectFormatByteSize().
225 */
226 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_007, TestSize.Level2)
227 {
228 DirectPlayBackEngine engine;
229 AudioSampleFormat format = SAMPLE_S16LE;
230 auto ret = engine.GetDirectFormatByteSize(format);
231 EXPECT_EQ(ret, sizeof(int16_t));
232
233 format = SAMPLE_S32LE;
234 ret = engine.GetDirectFormatByteSize(format);
235 EXPECT_EQ(ret, sizeof(int32_t));
236
237 format = SAMPLE_F32LE;
238 ret = engine.GetDirectFormatByteSize(format);
239 EXPECT_EQ(ret, sizeof(int32_t));
240
241 format = INVALID_WIDTH;
242 ret = engine.GetDirectFormatByteSize(format);
243 EXPECT_EQ(ret, sizeof(int32_t));
244 }
245
246 /**
247 * @tc.name : Test DirectPlayBackEngine API
248 * @tc.type : FUNC
249 * @tc.number: DirectPlayBackEngine_008
250 * @tc.desc : Test DirectPlayBackEngine::InitSink()
251 */
252 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_008, TestSize.Level2)
253 {
254 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
255 EXPECT_NE(enginePtr, nullptr);
256
257 AudioStreamInfo streamInfo;
258 enginePtr->isInit_ = false;
259 enginePtr->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_EAC3,
260 HDI_ID_INFO_DEFAULT, true);
261 EXPECT_NE(enginePtr->renderId_, HDI_INVALID_ID);
262
263 auto ret = enginePtr->InitSink(streamInfo);
264 EXPECT_NE(ret, SUCCESS);
265 }
266
267
268 /**
269 * @tc.name : Test DirectPlayBackEngine API
270 * @tc.type : FUNC
271 * @tc.number: DirectPlayBackEngine_009
272 * @tc.desc : Test DirectPlayBackEngine::InitSink()
273 */
274 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_009, TestSize.Level2)
275 {
276 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
277 EXPECT_NE(enginePtr, nullptr);
278
279 AudioStreamInfo streamInfo;
280 enginePtr->isInit_ = true;
281 enginePtr->renderId_ = HDI_INVALID_ID;
282
283 auto ret = enginePtr->InitSink(streamInfo);
284 EXPECT_NE(ret, SUCCESS);
285 }
286
287 /**
288 * @tc.name : Test DirectPlayBackEngine API
289 * @tc.type : FUNC
290 * @tc.number: DirectPlayBackEngine_010
291 * @tc.desc : Test DirectPlayBackEngine::InitSink()
292 */
293 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_010, TestSize.Level2)
294 {
295 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
296 EXPECT_NE(enginePtr, nullptr);
297
298 AudioStreamInfo streamInfo;
299 streamInfo.channels = AudioChannel::STEREO;
300 streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
301 streamInfo.format = SAMPLE_S32LE;
302 enginePtr->isInit_ = true;
303 enginePtr->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_EAC3,
304 HDI_ID_INFO_DEFAULT, true);
305 EXPECT_NE(enginePtr->renderId_, HDI_INVALID_ID);
306 auto ret = enginePtr->InitSink(streamInfo);
307 EXPECT_NE(ret, SUCCESS);
308
309 enginePtr->uChannel_ = AudioChannel::CHANNEL_UNKNOW;
310 ret = enginePtr->InitSink(streamInfo);
311 EXPECT_NE(ret, SUCCESS);
312
313 enginePtr->uChannel_ = AudioChannel::STEREO;
314 ret = enginePtr->InitSink(streamInfo);
315 EXPECT_NE(ret, SUCCESS);
316
317 enginePtr->format_ = SAMPLE_S16LE;
318 ret = enginePtr->InitSink(streamInfo);
319 EXPECT_NE(ret, SUCCESS);
320
321 enginePtr->format_ = SAMPLE_S32LE;
322 ret = enginePtr->InitSink(streamInfo);
323 EXPECT_NE(ret, SUCCESS);
324
325 enginePtr->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_32000;
326 ret = enginePtr->InitSink(streamInfo);
327 EXPECT_NE(ret, SUCCESS);
328
329 enginePtr->uSampleRate_ = AudioSamplingRate::SAMPLE_RATE_48000;
330 ret = enginePtr->InitSink(streamInfo);
331 EXPECT_EQ(ret, SUCCESS);
332 }
333
334 /**
335 * @tc.name : Test DirectPlayBackEngine API
336 * @tc.type : FUNC
337 * @tc.number: DirectPlayBackEngine_011
338 * @tc.desc : Test DirectPlayBackEngine::StopAudioSink()
339 */
340 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_011, TestSize.Level2)
341 {
342 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
343 ASSERT_TRUE(enginePtr != nullptr);
344
345 enginePtr->renderId_ = -1;
346 auto ret = enginePtr->StopAudioSink();
347 EXPECT_EQ(ret, SUCCESS);
348 }
349
350 /**
351 * @tc.name : Test DirectPlayBackEngine API
352 * @tc.type : FUNC
353 * @tc.number: DirectPlayBackEngine_012
354 * @tc.desc : Test DirectPlayBackEngine::StopAudioSink()
355 */
356 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_012, TestSize.Level2)
357 {
358 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
359 ASSERT_TRUE(enginePtr != nullptr);
360
361 enginePtr->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_EAC3,
362 HDI_ID_INFO_DEFAULT, true);
363 auto sink = HdiAdapterManager::GetInstance().GetRenderSink(enginePtr->renderId_, true);
364 ASSERT_TRUE(sink != nullptr);
365
366 auto ret = enginePtr->StopAudioSink();
367 EXPECT_EQ(ret, SUCCESS);
368 }
369
370 /**
371 * @tc.name : Test DirectPlayBackEngine API
372 * @tc.type : FUNC
373 * @tc.number: DirectPlayBackEngine_013
374 * @tc.desc : Test DirectPlayBackEngine::Start()
375 */
376 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_013, TestSize.Level2)
377 {
378 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
379 EXPECT_NE(enginePtr, nullptr);
380
381 enginePtr->renderId_ = HdiAdapterManager::GetInstance().GetId(HDI_ID_BASE_RENDER, HDI_ID_TYPE_EAC3,
382 HDI_ID_INFO_DEFAULT, true);
383 EXPECT_NE(enginePtr->renderId_, HDI_INVALID_ID);
384
385 enginePtr->isStart_ = true;
386 auto ret = enginePtr->Start();
387 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
388
389 enginePtr->isStart_ = false;
390 ret = enginePtr->Start();
391 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
392 }
393
394 /**
395 * @tc.name : Test DirectPlayBackEngine API
396 * @tc.type : FUNC
397 * @tc.number: DirectPlayBackEngine_014
398 * @tc.desc : Test DirectPlayBackEngine::Stop()
399 */
400 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_014, TestSize.Level2)
401 {
402 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
403 ASSERT_TRUE(enginePtr != nullptr);
404
405 enginePtr->isStart_ = true;
406 auto ret = enginePtr->Stop();
407 EXPECT_EQ(ret, SUCCESS);
408
409 enginePtr->isStart_ = false;
410 ret = enginePtr->Stop();
411 EXPECT_EQ(ret, SUCCESS);
412 }
413
414 /**
415 * @tc.name : Test DirectPlayBackEngine API
416 * @tc.type : FUNC
417 * @tc.number: DirectPlayBackEngine_015
418 * @tc.desc : Test DirectPlayBackEngine::Pause()
419 */
420 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_015, TestSize.Level2)
421 {
422 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
423 ASSERT_TRUE(enginePtr != nullptr);
424
425 enginePtr->isStart_ = true;
426 auto ret = enginePtr->Pause();
427 EXPECT_EQ(ret, SUCCESS);
428
429 enginePtr->isStart_ = false;
430 ret = enginePtr->Pause();
431 EXPECT_EQ(ret, SUCCESS);
432 }
433
434 /**
435 * @tc.name : Test DirectPlayBackEngine API
436 * @tc.type : FUNC
437 * @tc.number: DirectPlayBackEngine_016
438 * @tc.desc : Test DirectPlayBackEngine::DirectCallback()
439 */
440 HWTEST_F(DirectPlayBackEngineUnitTest, DirectPlayBackEngine_016, TestSize.Level2)
441 {
442 auto enginePtr = std::make_shared<DirectPlayBackEngine>();
443 ASSERT_TRUE(enginePtr != nullptr);
444 enginePtr->DirectCallback(CB_NONBLOCK_WRITE_COMPLETED);
445 enginePtr->DirectCallback(CB_DRAIN_COMPLETED);
446 enginePtr->DirectCallback(CB_FLUSH_COMPLETED);
447 enginePtr->DirectCallback(CB_RENDER_FULL);
448 enginePtr->DirectCallback(CB_ERROR_OCCUR);
449 }
450 } // namespace AudioStandard
451 } // namespace OHOS
452