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 "pro_renderer_stream_impl.h"
18 #include "audio_errors.h"
19 
20 using namespace testing::ext;
21 namespace OHOS {
22 namespace AudioStandard {
23 constexpr int32_t DEFAULT_STREAM_ID = 10;
24 class NoneMixEngineUnitTest : public testing::Test {
25 public:
26     static void SetUpTestCase(void);
27     static void TearDownTestCase(void);
28     void SetUp();
29     void TearDown();
30 
31 protected:
32     AudioProcessConfig InitProcessConfig();
33 
34 protected:
35     std::unique_ptr<AudioPlaybackEngine> playbackEngine_;
36 };
37 
SetUpTestCase(void)38 void NoneMixEngineUnitTest::SetUpTestCase(void)
39 {
40     // input testsuit setup step，setup invoked before all testcases
41 }
42 
TearDownTestCase(void)43 void NoneMixEngineUnitTest::TearDownTestCase(void)
44 {
45     // input testsuit teardown step，teardown invoked after all testcases
46 }
47 
SetUp(void)48 void NoneMixEngineUnitTest::SetUp(void)
49 {
50     DeviceInfo deviceInfo;
51     deviceInfo.deviceType = DEVICE_TYPE_USB_HEADSET;
52     playbackEngine_ = std::make_unique<NoneMixEngine>();
53     playbackEngine_->Init(deviceInfo, false);
54 }
55 
TearDown(void)56 void NoneMixEngineUnitTest::TearDown(void)
57 {
58     if (playbackEngine_) {
59         playbackEngine_->Stop();
60         playbackEngine_ = nullptr;
61     }
62 }
63 
InitProcessConfig()64 AudioProcessConfig NoneMixEngineUnitTest::InitProcessConfig()
65 {
66     AudioProcessConfig config;
67     config.appInfo.appUid = DEFAULT_STREAM_ID;
68     config.appInfo.appPid = DEFAULT_STREAM_ID;
69     config.streamInfo.format = SAMPLE_S32LE;
70     config.streamInfo.samplingRate = SAMPLE_RATE_48000;
71     config.streamInfo.channels = STEREO;
72     config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
73     config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
74     config.streamType = AudioStreamType::STREAM_MUSIC;
75     config.deviceType = DEVICE_TYPE_USB_HEADSET;
76     return config;
77 }
78 
79 /**
80  * @tc.name  : Test Direct Audio Playback Engine State
81  * @tc.type  : FUNC
82  * @tc.number: DirectAudioPlayBackEngineState_001
83  * @tc.desc  : Test direct audio playback engine state(start->pause->flush->stop->release) success
84  */
85 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_001, TestSize.Level1)
86 {
87     AudioProcessConfig config = InitProcessConfig();
88     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
89     int32_t ret = rendererStream->InitParams();
90     EXPECT_EQ(SUCCESS, ret);
91     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
92     ret = rendererStream->Start();
93     EXPECT_EQ(SUCCESS, ret);
94     ret = rendererStream->Pause();
95     EXPECT_EQ(SUCCESS, ret);
96     ret = rendererStream->Flush();
97     EXPECT_EQ(SUCCESS, ret);
98     ret = rendererStream->Stop();
99     EXPECT_EQ(SUCCESS, ret);
100     ret = rendererStream->Release();
101     EXPECT_EQ(SUCCESS, ret);
102 }
103 
104 /**
105  * @tc.name  : Test Direct Audio Playback Engine State
106  * @tc.type  : FUNC
107  * @tc.number: DirectAudioPlayBackEngineState_002
108  * @tc.desc  : Test direct audio playback engine state init success
109  */
110 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_002, TestSize.Level1)
111 {
112     AudioProcessConfig config;
113     config.appInfo.appUid = DEFAULT_STREAM_ID;
114     config.appInfo.appPid = DEFAULT_STREAM_ID;
115     config.streamInfo.format = SAMPLE_S32LE;
116     config.streamInfo.samplingRate = SAMPLE_RATE_48000;
117     config.streamInfo.channels = STEREO;
118     config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
119     config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
120     config.streamType = AudioStreamType::STREAM_MUSIC;
121     config.deviceType = DEVICE_TYPE_USB_HEADSET;
122     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
123     int32_t ret = rendererStream->InitParams();
124     EXPECT_EQ(SUCCESS, ret);
125 
126     // ERR_ILLEGAL_STATE
127     ret = rendererStream->Start();
128     EXPECT_EQ(SUCCESS, ret);
129     ret = rendererStream->InitParams();
130     EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
131 
132     // ERR_ILLEGAL_STATE
133     ret = rendererStream->Stop();
134     EXPECT_EQ(SUCCESS, ret);
135     ret = rendererStream->InitParams();
136     EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
137 
138     ret = rendererStream->Release();
139     EXPECT_EQ(SUCCESS, ret);
140     ret = rendererStream->InitParams();
141     EXPECT_EQ(SUCCESS, ret);
142 }
143 
144 /**
145  * @tc.name  : Test Direct Audio Playback Engine State
146  * @tc.type  : FUNC
147  * @tc.number: DirectAudioPlayBackEngineState_003
148  * @tc.desc  : Test direct audio playback engine state start success
149  */
150 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_003, TestSize.Level1)
151 {
152     AudioProcessConfig config = InitProcessConfig();
153     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
154     int32_t ret = rendererStream->InitParams();
155     EXPECT_EQ(SUCCESS, ret);
156     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
157     ret = rendererStream->Start();
158     EXPECT_EQ(SUCCESS, ret);
159     ret = rendererStream->Stop();
160     EXPECT_EQ(SUCCESS, ret);
161     ret = rendererStream->Release();
162     EXPECT_EQ(SUCCESS, ret);
163 
164     // ERR_ILLEGAL_STATE
165     ret = rendererStream->Start();
166     EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
167 }
168 
169 /**
170  * @tc.name  : Test Direct Audio Playback Engine State
171  * @tc.type  : FUNC
172  * @tc.number: DirectAudioPlayBackEngineState_004
173  * @tc.desc  : Test direct audio playback engine state pause success
174  */
175 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_004, TestSize.Level1)
176 {
177     AudioProcessConfig config = InitProcessConfig();
178     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
179     int32_t ret = rendererStream->InitParams();
180     EXPECT_EQ(SUCCESS, ret);
181     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
182     ret = rendererStream->Start();
183     EXPECT_EQ(SUCCESS, ret);
184     ret = rendererStream->Pause();
185     EXPECT_EQ(SUCCESS, ret);
186     ret = rendererStream->Stop();
187     EXPECT_EQ(SUCCESS, ret);
188     ret = rendererStream->Release();
189     EXPECT_EQ(SUCCESS, ret);
190 }
191 
192 /**
193  * @tc.name  : Test Direct Audio Playback Engine State
194  * @tc.type  : FUNC
195  * @tc.number: DirectAudioPlayBackEngineState_005
196  * @tc.desc  : Test direct audio playback engine state flush success
197  */
198 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_005, TestSize.Level1)
199 {
200     AudioProcessConfig config = InitProcessConfig();
201     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
202     int32_t ret = rendererStream->InitParams();
203     EXPECT_EQ(SUCCESS, ret);
204     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
205     ret = rendererStream->Start();
206     EXPECT_EQ(SUCCESS, ret);
207     ret = rendererStream->Flush();
208     EXPECT_EQ(SUCCESS, ret);
209     ret = rendererStream->Stop();
210     EXPECT_EQ(SUCCESS, ret);
211     ret = rendererStream->Release();
212     EXPECT_EQ(SUCCESS, ret);
213 }
214 
215 /**
216  * @tc.name  : Test Direct Audio Playback Engine State
217  * @tc.type  : FUNC
218  * @tc.number: DirectAudioPlayBackEngineState_006
219  * @tc.desc  : Test direct audio playback engine state drain success
220  */
221 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineState_006, TestSize.Level1)
222 {
223     AudioProcessConfig config = InitProcessConfig();
224     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
225     int32_t ret = rendererStream->InitParams();
226     EXPECT_EQ(SUCCESS, ret);
227     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
228     ret = rendererStream->Start();
229     EXPECT_EQ(SUCCESS, ret);
230     ret = rendererStream->Drain();
231     EXPECT_EQ(SUCCESS, ret);
232     ret = rendererStream->Stop();
233     EXPECT_EQ(SUCCESS, ret);
234     ret = rendererStream->Release();
235     EXPECT_EQ(SUCCESS, ret);
236 }
237 
238 /**
239  * @tc.name  : Test Direct Audio Playback Engine Set Config
240  * @tc.type  : FUNC
241  * @tc.number: DirectAudioPlayBackEngineSetConfig_001
242  * @tc.desc  : Test direct audio playback engine set config (sampleRate 192000) success
243  */
244 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_001, TestSize.Level1)
245 {
246     AudioProcessConfig config = InitProcessConfig();
247     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_192000;
248     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
249     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
250     int32_t ret = rendererStream->InitParams();
251     EXPECT_EQ(SUCCESS, ret);
252     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
253     ret = rendererStream->Start();
254     EXPECT_EQ(SUCCESS, ret);
255     ret = rendererStream->Stop();
256     EXPECT_EQ(SUCCESS, ret);
257     ret = rendererStream->Release();
258     EXPECT_EQ(SUCCESS, ret);
259 }
260 
261 /**
262  * @tc.name  : Test Direct Audio Playback Engine Set Config
263  * @tc.type  : FUNC
264  * @tc.number: DirectAudioPlayBackEngineSetConfig_002
265  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
266  */
267 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_002, TestSize.Level1)
268 {
269     AudioProcessConfig config = InitProcessConfig();
270     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_192000;
271     config.deviceType = DEVICE_TYPE_USB_HEADSET;
272     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
273     int32_t ret = rendererStream->InitParams();
274     EXPECT_EQ(SUCCESS, ret);
275     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
276     ret = rendererStream->Start();
277     EXPECT_EQ(SUCCESS, ret);
278     ret = rendererStream->Stop();
279     EXPECT_EQ(SUCCESS, ret);
280     ret = rendererStream->Release();
281     EXPECT_EQ(SUCCESS, ret);
282 }
283 
284 /**
285  * @tc.name  : Test Direct Audio Playback Engine Set Config
286  * @tc.type  : FUNC
287  * @tc.number: DirectAudioPlayBackEngineSetConfig_003
288  * @tc.desc  : Test direct audio playback engine set config (sampleRate 176400) success
289  */
290 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_003, TestSize.Level1)
291 {
292     AudioProcessConfig config = InitProcessConfig();
293     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_176400;
294     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
295     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
296     int32_t ret = rendererStream->InitParams();
297     EXPECT_EQ(SUCCESS, ret);
298     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
299     ret = rendererStream->Start();
300     EXPECT_EQ(SUCCESS, ret);
301     ret = rendererStream->Stop();
302     EXPECT_EQ(SUCCESS, ret);
303     ret = rendererStream->Release();
304     EXPECT_EQ(SUCCESS, ret);
305 }
306 
307 /**
308  * @tc.name  : Test Direct Audio Playback Engine Set Config
309  * @tc.type  : FUNC
310  * @tc.number: DirectAudioPlayBackEngineSetConfig_004
311  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
312  */
313 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_004, TestSize.Level1)
314 {
315     AudioProcessConfig config = InitProcessConfig();
316     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_176400;
317     config.deviceType = DEVICE_TYPE_USB_HEADSET;
318     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
319     int32_t ret = rendererStream->InitParams();
320     EXPECT_EQ(SUCCESS, ret);
321     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
322     ret = rendererStream->Start();
323     EXPECT_EQ(SUCCESS, ret);
324     ret = rendererStream->Stop();
325     EXPECT_EQ(SUCCESS, ret);
326     ret = rendererStream->Release();
327     EXPECT_EQ(SUCCESS, ret);
328 }
329 
330 /**
331  * @tc.name  : Test Direct Audio Playback Engine Set Config
332  * @tc.type  : FUNC
333  * @tc.number: DirectAudioPlayBackEngineSetConfig_005
334  * @tc.desc  : Test direct audio playback engine set config (sampleRate 96000) success
335  */
336 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_005, TestSize.Level1)
337 {
338     AudioProcessConfig config = InitProcessConfig();
339     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
340     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
341     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
342     int32_t ret = rendererStream->InitParams();
343     EXPECT_EQ(SUCCESS, ret);
344     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
345     ret = rendererStream->Start();
346     EXPECT_EQ(SUCCESS, ret);
347     ret = rendererStream->Stop();
348     EXPECT_EQ(SUCCESS, ret);
349     ret = rendererStream->Release();
350     EXPECT_EQ(SUCCESS, ret);
351 }
352 
353 /**
354  * @tc.name  : Test Direct Audio Playback Engine Set Config
355  * @tc.type  : FUNC
356  * @tc.number: DirectAudioPlayBackEngineSetConfig_006
357  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
358  */
359 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_006, TestSize.Level1)
360 {
361     AudioProcessConfig config = InitProcessConfig();
362     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
363     config.deviceType = DEVICE_TYPE_USB_HEADSET;
364     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
365     int32_t ret = rendererStream->InitParams();
366     EXPECT_EQ(SUCCESS, ret);
367     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
368     ret = rendererStream->Start();
369     EXPECT_EQ(SUCCESS, ret);
370     ret = rendererStream->Stop();
371     EXPECT_EQ(SUCCESS, ret);
372     ret = rendererStream->Release();
373     EXPECT_EQ(SUCCESS, ret);
374 }
375 
376 /**
377  * @tc.name  : Test Direct Audio Playback Engine Set Config
378  * @tc.type  : FUNC
379  * @tc.number: DirectAudioPlayBackEngineSetConfig_007
380  * @tc.desc  : Test direct audio playback engine set config (sampleRate 88200) success
381  */
382 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_007, TestSize.Level1)
383 {
384     AudioProcessConfig config = InitProcessConfig();
385     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_88200;
386     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
387     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
388     int32_t ret = rendererStream->InitParams();
389     EXPECT_EQ(SUCCESS, ret);
390     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
391     ret = rendererStream->Start();
392     EXPECT_EQ(SUCCESS, ret);
393     ret = rendererStream->Stop();
394     EXPECT_EQ(SUCCESS, ret);
395     ret = rendererStream->Release();
396     EXPECT_EQ(SUCCESS, ret);
397 }
398 
399 /**
400  * @tc.name  : Test Direct Audio Playback Engine Set Config
401  * @tc.type  : FUNC
402  * @tc.number: DirectAudioPlayBackEngineSetConfig_008
403  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
404  */
405 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_008, TestSize.Level1)
406 {
407     AudioProcessConfig config = InitProcessConfig();
408     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_88200;
409     config.deviceType = DEVICE_TYPE_USB_HEADSET;
410     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
411     int32_t ret = rendererStream->InitParams();
412     EXPECT_EQ(SUCCESS, ret);
413     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
414     ret = rendererStream->Start();
415     EXPECT_EQ(SUCCESS, ret);
416     ret = rendererStream->Stop();
417     EXPECT_EQ(SUCCESS, ret);
418     ret = rendererStream->Release();
419     EXPECT_EQ(SUCCESS, ret);
420 }
421 
422 /**
423  * @tc.name  : Test Direct Audio Playback Engine Set Config
424  * @tc.type  : FUNC
425  * @tc.number: DirectAudioPlayBackEngineSetConfig_009
426  * @tc.desc  : Test direct audio playback engine set config (sampleRate 48000) success
427  */
428 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_009, TestSize.Level1)
429 {
430     AudioProcessConfig config = InitProcessConfig();
431     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
432     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
433     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
434     int32_t ret = rendererStream->InitParams();
435     EXPECT_EQ(SUCCESS, ret);
436     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
437     ret = rendererStream->Start();
438     EXPECT_EQ(SUCCESS, ret);
439     ret = rendererStream->Stop();
440     EXPECT_EQ(SUCCESS, ret);
441     ret = rendererStream->Release();
442     EXPECT_EQ(SUCCESS, ret);
443 }
444 
445 /**
446  * @tc.name  : Test Direct Audio Playback Engine Set Config
447  * @tc.type  : FUNC
448  * @tc.number: DirectAudioPlayBackEngineSetConfig_010
449  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
450  */
451 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_010, TestSize.Level1)
452 {
453     AudioProcessConfig config = InitProcessConfig();
454     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
455     config.deviceType = DEVICE_TYPE_USB_HEADSET;
456     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
457     int32_t ret = rendererStream->InitParams();
458     EXPECT_EQ(SUCCESS, ret);
459     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
460     ret = rendererStream->Start();
461     EXPECT_EQ(SUCCESS, ret);
462     ret = rendererStream->Stop();
463     EXPECT_EQ(SUCCESS, ret);
464     ret = rendererStream->Release();
465     EXPECT_EQ(SUCCESS, ret);
466 }
467 
468 /**
469  * @tc.name  : Test Direct Audio Playback Engine Set Config
470  * @tc.type  : FUNC
471  * @tc.number: DirectAudioPlayBackEngineSetConfig_011
472  * @tc.desc  : Test direct audio playback engine set config (sampleRate 44100) success
473  */
474 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_011, TestSize.Level1)
475 {
476     AudioProcessConfig config = InitProcessConfig();
477     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
478     config.deviceType = DEVICE_TYPE_WIRED_HEADSET;
479     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
480     int32_t ret = rendererStream->InitParams();
481     EXPECT_EQ(SUCCESS, ret);
482     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
483     ret = rendererStream->Start();
484     EXPECT_EQ(SUCCESS, ret);
485     ret = rendererStream->Stop();
486     EXPECT_EQ(SUCCESS, ret);
487     ret = rendererStream->Release();
488     EXPECT_EQ(SUCCESS, ret);
489 }
490 
491 /**
492  * @tc.name  : Test Direct Audio Playback Engine Set Config
493  * @tc.type  : FUNC
494  * @tc.number: DirectAudioPlayBackEngineSetConfig_012
495  * @tc.desc  : Test direct audio playback engine set config (deviceType DEVICE_TYPE_USB_HEADSET) success
496  */
497 HWTEST_F(NoneMixEngineUnitTest, DirectAudioPlayBackEngineSetConfig_012, TestSize.Level1)
498 {
499     AudioProcessConfig config = InitProcessConfig();
500     config.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
501     config.deviceType = DEVICE_TYPE_USB_HEADSET;
502     std::shared_ptr<ProRendererStreamImpl> rendererStream = std::make_shared<ProRendererStreamImpl>(config, true);
503     int32_t ret = rendererStream->InitParams();
504     EXPECT_EQ(SUCCESS, ret);
505     rendererStream->SetStreamIndex(DEFAULT_STREAM_ID);
506     ret = rendererStream->Start();
507     EXPECT_EQ(SUCCESS, ret);
508     ret = rendererStream->Stop();
509     EXPECT_EQ(SUCCESS, ret);
510     ret = rendererStream->Release();
511     EXPECT_EQ(SUCCESS, ret);
512 }
513 } // namespace AudioStandard
514 } // namespace OHOS