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 char *SINK_ADAPTER_NAME = "primary";
25 class AudioDirectSinkUnitTest : public testing::Test {
26 public:
27     static void SetUpTestCase(void);
28     static void TearDownTestCase(void);
29     void SetUp();
30     void TearDown();
31 
32 protected:
33     AudioRendererSink *sink;
34     AudioRendererSink *voipSink;
35 };
36 
SetUpTestCase(void)37 void AudioDirectSinkUnitTest::SetUpTestCase(void)
38 {
39     // input testsuit setup step，setup invoked before all testcases
40 }
41 
TearDownTestCase(void)42 void AudioDirectSinkUnitTest::TearDownTestCase(void)
43 {
44     // input testsuit teardown step，teardown invoked after all testcases
45 }
46 
SetUp(void)47 void AudioDirectSinkUnitTest::SetUp(void)
48 {
49     sink = AudioRendererSink::GetInstance(DIRECT_SINK_NAME);
50     voipSink = AudioRendererSink::GetInstance(VOIP_SINK_NAME);
51 }
52 
TearDown(void)53 void AudioDirectSinkUnitTest::TearDown(void)
54 {
55     if (sink && sink->IsInited()) {
56         sink->DeInit();
57     }
58     if (voipSink && voipSink->IsInited()) {
59         voipSink->DeInit();
60     }
61 }
62 
63 /**
64  * @tc.name  : Test Audio Direct Sink Create
65  * @tc.type  : FUNC
66  * @tc.number: DirectAudioSinkCreate_001
67  * @tc.desc  : Test audio direct sink create success
68  */
69 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkCreate_001, TestSize.Level1)
70 {
71     EXPECT_NE(nullptr, this->sink);
72 }
73 
74 /**
75  * @tc.name  : Test Audio Direct Sink
76  * @tc.type  : FUNC
77  * @tc.number: DirectAudioSinkInit_001
78  * @tc.desc  : Test audio direct sink init(setVolume) success
79  */
80 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkInit_001, TestSize.Level1)
81 {
82     EXPECT_NE(nullptr, this->sink);
83     IAudioSinkAttr attr = {};
84     attr.adapterName = SINK_ADAPTER_NAME;
85     attr.sampleRate = 48000;
86     attr.channel = 2;
87     attr.format = HdiAdapterFormat::SAMPLE_S32;
88     attr.channelLayout = 3;
89     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
90     attr.volume = 1.0f;
91     attr.openMicSpeaker = 1;
92     int32_t ret = sink->Init(attr);
93     EXPECT_EQ(SUCCESS, ret);
94     float volume = 1.0f;
95     ret = sink->SetVolume(volume, volume);
96     EXPECT_EQ(SUCCESS, ret);
97 }
98 
99 /**
100  * @tc.name  : Test Direct Sink State
101  * @tc.type  : FUNC
102  * @tc.number: DirectAudioSinkState_001
103  * @tc.desc  : Test direct sink state(init->start->stop) success
104  */
105 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_001, TestSize.Level1)
106 {
107     EXPECT_NE(nullptr, this->sink);
108     IAudioSinkAttr attr = {};
109     attr.adapterName = SINK_ADAPTER_NAME;
110     attr.sampleRate = 48000;
111     attr.channel = 2;
112     attr.format = HdiAdapterFormat::SAMPLE_S32;
113     attr.channelLayout = 3;
114     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
115     attr.volume = 1.0f;
116     attr.openMicSpeaker = 1;
117     int32_t ret = sink->Init(attr);
118     EXPECT_EQ(SUCCESS, ret);
119     ret = sink->Start();
120     EXPECT_EQ(SUCCESS, ret);
121     ret = sink->Stop();
122     EXPECT_EQ(SUCCESS, ret);
123 }
124 
125 /**
126  * @tc.name  : Test Direct Sink Init State
127  * @tc.type  : FUNC
128  * @tc.number: DirectAudioSinkState_002
129  * @tc.desc  : Test direct sink init state success
130  */
131 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_002, TestSize.Level1)
132 {
133     EXPECT_NE(nullptr, this->sink);
134     IAudioSinkAttr attr = {};
135     attr.adapterName = SINK_ADAPTER_NAME;
136     attr.sampleRate = 48000;
137     attr.channel = 2;
138     attr.format = HdiAdapterFormat::SAMPLE_S32;
139     attr.channelLayout = 3;
140     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
141     attr.volume = 1.0f;
142     attr.openMicSpeaker = 1;
143     bool isInited = sink->IsInited();
144     EXPECT_EQ(false, isInited);
145 
146     int32_t ret = sink->Init(attr);
147     EXPECT_EQ(SUCCESS, ret);
148 
149     isInited = sink->IsInited();
150     EXPECT_EQ(true, isInited);
151 
152     sink->DeInit();
153 
154     isInited = sink->IsInited();
155     EXPECT_EQ(false, isInited);
156 
157     // Continuous execution init
158     ret = sink->Init(attr);
159     EXPECT_EQ(SUCCESS, ret);
160     ret = sink->Init(attr);
161     EXPECT_EQ(SUCCESS, ret);
162     isInited = sink->IsInited();
163     EXPECT_EQ(true, isInited);
164 }
165 
166 /**
167  * @tc.name  : Test Direct Sink Start State
168  * @tc.type  : FUNC
169  * @tc.number: DirectAudioSinkState_003
170  * @tc.desc  : Test direct sink start state success
171  */
172 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_003, TestSize.Level1)
173 {
174     EXPECT_NE(nullptr, this->sink);
175     IAudioSinkAttr attr = {};
176     attr.adapterName = SINK_ADAPTER_NAME;
177     attr.sampleRate = 48000;
178     attr.channel = 2;
179     attr.format = HdiAdapterFormat::SAMPLE_S32;
180     attr.channelLayout = 3;
181     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
182     attr.volume = 1.0f;
183     attr.openMicSpeaker = 1;
184     int32_t ret = sink->Init(attr);
185     EXPECT_EQ(SUCCESS, ret);
186 
187     ret = sink->Start();
188     EXPECT_EQ(SUCCESS, ret);
189     ret = sink->Stop();
190     EXPECT_EQ(SUCCESS, ret);
191 
192     // Continuous execution start
193     ret = sink->Start();
194     EXPECT_EQ(SUCCESS, ret);
195     ret = sink->Start();
196     EXPECT_EQ(SUCCESS, ret);
197     ret = sink->Stop();
198     EXPECT_EQ(SUCCESS, ret);
199 }
200 
201 /**
202  * @tc.name  : Test Direct Sink Resume State
203  * @tc.type  : FUNC
204  * @tc.number: DirectAudioSinkState_004
205  * @tc.desc  : Test direct sink resume state success
206  */
207 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkState_004, TestSize.Level1)
208 {
209     EXPECT_NE(nullptr, this->sink);
210     IAudioSinkAttr attr = {};
211     attr.adapterName = SINK_ADAPTER_NAME;
212     attr.sampleRate = 48000;
213     attr.channel = 2;
214     attr.format = HdiAdapterFormat::SAMPLE_S32;
215     attr.channelLayout = 3;
216     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
217     attr.volume = 1.0f;
218     attr.openMicSpeaker = 1;
219     int32_t ret = sink->Init(attr);
220     EXPECT_EQ(SUCCESS, ret);
221     ret = sink->Start();
222     EXPECT_EQ(SUCCESS, ret);
223     ret = sink->Resume();
224     EXPECT_EQ(SUCCESS, ret);
225     ret = sink->Stop();
226     EXPECT_EQ(SUCCESS, ret);
227 }
228 
229 /**
230  * @tc.name  : Test Audio Direct Sink Attribute
231  * @tc.type  : FUNC
232  * @tc.number: DirectAudioSinkSetAttribute_001
233  * @tc.desc  : Test audio direct sink attribute(sampleRate) success
234  */
235 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkSetAttribute_001, TestSize.Level1)
236 {
237     EXPECT_NE(nullptr, this->sink);
238     IAudioSinkAttr attr = {};
239     attr.adapterName = SINK_ADAPTER_NAME;
240     attr.sampleRate = 192000;
241     attr.channel = 2;
242     attr.format = HdiAdapterFormat::SAMPLE_S32;
243     attr.channelLayout = 3;
244     attr.deviceType = DEVICE_TYPE_WIRED_HEADSET;
245     attr.volume = 1.0f;
246     attr.openMicSpeaker = 1;
247     int32_t ret = sink->Init(attr);
248     EXPECT_EQ(SUCCESS, ret);
249     ret = sink->Start();
250     EXPECT_EQ(SUCCESS, ret);
251     ret = sink->Stop();
252     EXPECT_EQ(SUCCESS, ret);
253 }
254 
255 /**
256  * @tc.name  : Test Audio Direct Sink Attribute
257  * @tc.type  : FUNC
258  * @tc.number: DirectAudioSinkSetAttribute_002
259  * @tc.desc  : Test audio direct sink attribute(deviceType) success
260  */
261 HWTEST_F(AudioDirectSinkUnitTest, DirectAudioSinkSetAttribute_002, TestSize.Level1)
262 {
263     EXPECT_NE(nullptr, this->sink);
264     IAudioSinkAttr attr = {};
265     attr.adapterName = SINK_ADAPTER_NAME;
266     attr.sampleRate = 192000;
267     attr.channel = 2;
268     attr.format = HdiAdapterFormat::SAMPLE_S32;
269     attr.channelLayout = 3;
270     attr.deviceType = DEVICE_TYPE_USB_HEADSET;
271     attr.volume = 1.0f;
272     attr.openMicSpeaker = 1;
273     int32_t ret = sink->Init(attr);
274     EXPECT_EQ(SUCCESS, ret);
275     ret = sink->Start();
276     EXPECT_EQ(SUCCESS, ret);
277     ret = sink->Stop();
278     EXPECT_EQ(SUCCESS, ret);
279 }
280 
281 /**
282  * @tc.name  : Test Create Direct Voip Sink
283  * @tc.type  : FUNC
284  * @tc.number: DirectVoipAudioSinkCreate_001
285  * @tc.desc  : Test create direct voip sink success
286  */
287 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkCreate_001, TestSize.Level1)
288 {
289     EXPECT_NE(nullptr, this->voipSink);
290 }
291 
292 /**
293  * @tc.name  : Test Init Direct Voip Sink
294  * @tc.type  : FUNC
295  * @tc.number: DirectVoipAudioSinkInit_001
296  * @tc.desc  : Test init direct voip sink success
297  */
298 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkInit_001, TestSize.Level1)
299 {
300     EXPECT_NE(nullptr, this->voipSink);
301     IAudioSinkAttr attr = {};
302     attr.adapterName = SINK_ADAPTER_NAME;
303     attr.sampleRate = 48000;
304     attr.channel = 2;
305     attr.format = HdiAdapterFormat::SAMPLE_S16;
306     attr.channelLayout = 3;
307     attr.deviceType = DEVICE_TYPE_SPEAKER;
308     attr.volume = 1.0f;
309     attr.openMicSpeaker = 1;
310     int32_t ret = voipSink->Init(attr);
311     EXPECT_EQ(SUCCESS, ret);
312     float volume = 1.0f;
313     ret = voipSink->SetVolume(volume, volume);
314     EXPECT_EQ(SUCCESS, ret);
315 }
316 
317 /**
318  * @tc.name  : Test Direct Voip Sink State
319  * @tc.type  : FUNC
320  * @tc.number: DirectVoipAudioSinkState_001
321  * @tc.desc  : Test direct voip sink state success
322  */
323 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_001, TestSize.Level1)
324 {
325     EXPECT_NE(nullptr, this->voipSink);
326     IAudioSinkAttr attr = {};
327     attr.adapterName = SINK_ADAPTER_NAME;
328     attr.sampleRate = 48000;
329     attr.channel = 2;
330     attr.format = HdiAdapterFormat::SAMPLE_S16;
331     attr.channelLayout = 3;
332     attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
333     attr.volume = 1.0f;
334     attr.openMicSpeaker = 1;
335     int32_t ret = voipSink->Init(attr);
336     EXPECT_EQ(SUCCESS, ret);
337     ret = voipSink->Start();
338     EXPECT_EQ(SUCCESS, ret);
339     ret = voipSink->Stop();
340     EXPECT_EQ(SUCCESS, ret);
341 }
342 
343 /**
344  * @tc.name  : Test Direct Voip Sink init State
345  * @tc.type  : FUNC
346  * @tc.number: DirectVoipAudioSinkState_002
347  * @tc.desc  : Test direct voip sink init state success
348  */
349 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_002, TestSize.Level1)
350 {
351     EXPECT_NE(nullptr, this->voipSink);
352     IAudioSinkAttr attr = {};
353     attr.adapterName = SINK_ADAPTER_NAME;
354     attr.sampleRate = 48000;
355     attr.channel = 2;
356     attr.format = HdiAdapterFormat::SAMPLE_S16;
357     attr.channelLayout = 3;
358     attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
359     attr.volume = 1.0f;
360     attr.openMicSpeaker = 1;
361     bool isInited = voipSink->IsInited();
362     EXPECT_EQ(false, isInited);
363 
364     int32_t ret = voipSink->Init(attr);
365     EXPECT_EQ(SUCCESS, ret);
366 
367     isInited = voipSink->IsInited();
368     EXPECT_EQ(true, isInited);
369 
370     voipSink->DeInit();
371 
372     isInited = voipSink->IsInited();
373     EXPECT_EQ(false, isInited);
374 
375     // Continuous execution init
376     ret = voipSink->Init(attr);
377     EXPECT_EQ(SUCCESS, ret);
378     ret = voipSink->Init(attr);
379     EXPECT_EQ(SUCCESS, ret);
380     isInited = voipSink->IsInited();
381     EXPECT_EQ(true, isInited);
382 }
383 
384 /**
385  * @tc.name  : Test Direct Voip Sink Start State
386  * @tc.type  : FUNC
387  * @tc.number: DirectVoipAudioSinkState_003
388  * @tc.desc  : Test direct voip sink start state success
389  */
390 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_003, TestSize.Level1)
391 {
392     EXPECT_NE(nullptr, this->voipSink);
393     IAudioSinkAttr attr = {};
394     attr.adapterName = SINK_ADAPTER_NAME;
395     attr.sampleRate = 48000;
396     attr.channel = 2;
397     attr.format = HdiAdapterFormat::SAMPLE_S16;
398     attr.channelLayout = 3;
399     attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
400     attr.volume = 1.0f;
401     attr.openMicSpeaker = 1;
402     int32_t ret = voipSink->Init(attr);
403     EXPECT_EQ(SUCCESS, ret);
404 
405     ret = voipSink->Start();
406     EXPECT_EQ(SUCCESS, ret);
407     ret = voipSink->Stop();
408     EXPECT_EQ(SUCCESS, ret);
409 
410     // Continuous execution start
411     ret = voipSink->Start();
412     EXPECT_EQ(SUCCESS, ret);
413     ret = voipSink->Start();
414     EXPECT_EQ(SUCCESS, ret);
415     ret = voipSink->Stop();
416     EXPECT_EQ(SUCCESS, ret);
417 }
418 
419 /**
420  * @tc.name  : Test Direct Voip Sink Resume State
421  * @tc.type  : FUNC
422  * @tc.number: DirectVoipAudioSinkState_004
423  * @tc.desc  : Test direct voip sink resume state success
424  */
425 HWTEST_F(AudioDirectSinkUnitTest, DirectVoipAudioSinkState_004, TestSize.Level1)
426 {
427     EXPECT_NE(nullptr, this->voipSink);
428     IAudioSinkAttr attr = {};
429     attr.adapterName = SINK_ADAPTER_NAME;
430     attr.sampleRate = 48000;
431     attr.channel = 2;
432     attr.format = HdiAdapterFormat::SAMPLE_S16;
433     attr.channelLayout = 3;
434     attr.deviceType = DEVICE_TYPE_BLUETOOTH_SCO;
435     attr.volume = 1.0f;
436     attr.openMicSpeaker = 1;
437     int32_t ret = voipSink->Init(attr);
438     EXPECT_EQ(SUCCESS, ret);
439     ret = voipSink->Start();
440     EXPECT_EQ(SUCCESS, ret);
441     ret = voipSink->Resume();
442     EXPECT_EQ(SUCCESS, ret);
443     ret = voipSink->Stop();
444     EXPECT_EQ(SUCCESS, ret);
445 }
446 } // namespace AudioStandard
447 } // namespace OHOS