1 /*
2 * Copyright (c) 2022 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 <thread>
17 #include "audio_errors.h"
18 #include "audio_info.h"
19 #include "audio_stream_unit_test.h"
20
21 using namespace std;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 namespace AudioStandard {
26 const int32_t FAILURE = -1;
27 const uint32_t DEFAULT_SAMPLING_RATE = 44100;
28 const uint8_t DEFAULT_CHANNEL_COUNT = 2;
29 const uint8_t DEFAULT_SAMPLE_SIZE = 2;
30 const uint32_t DEFAULT_STREAM_VOLUME = 0;
31 const int32_t AUDIO_CLIENT_ERR = -1;
32 const int32_t AUDIO_CLIENT_INVALID_PARAMS_ERR = -2;
33 const int32_t AUDIO_CLIENT_INIT_ERR = -3;
34
SetUpTestCase(void)35 void AudioStreamUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)36 void AudioStreamUnitTest::TearDownTestCase(void) {}
SetUp(void)37 void AudioStreamUnitTest::SetUp(void) {}
TearDown(void)38 void AudioStreamUnitTest::TearDown(void) {}
39
InitAudioStream(std::shared_ptr<AudioStream> & audioStream)40 void AudioStreamUnitTest::InitAudioStream(std::shared_ptr<AudioStream> &audioStream)
41 {
42 AppInfo appInfo_ = {};
43 if (!(appInfo_.appPid)) {
44 appInfo_.appPid = getpid();
45 }
46
47 if (appInfo_.appUid < 0) {
48 appInfo_.appUid = static_cast<int32_t>(getuid());
49 }
50
51 audioStream = std::make_shared<AudioStream>(STREAM_NOTIFICATION, AUDIO_MODE_PLAYBACK, appInfo_.appUid);
52 if (audioStream) {
53 AUDIO_DEBUG_LOG("InitAudioStream::Audio stream created");
54 }
55 }
56
57 /**
58 * @tc.name : Test Audio_Stream_GetSamplingRate_001 via legal state
59 * @tc.number: Audio_Stream_GetSamplingRate_001
60 * @tc.desc : Test GetSamplingRate interface. Returns success.
61 */
62 HWTEST(AudioStreamUnitTest, Audio_Stream_GetSamplingRate_001, TestSize.Level1)
63 {
64 std::shared_ptr<AudioStream> audioStream_;
65 AudioStreamUnitTest::InitAudioStream(audioStream_);
66 uint32_t samplingRate = audioStream_->GetSamplingRate();
67 EXPECT_EQ(DEFAULT_SAMPLING_RATE, samplingRate);
68 }
69
70 /**
71 * @tc.name : Test Audio_Stream_GetChannelCount_001 via legal state
72 * @tc.number: Audio_Stream_GetChannelCount_001
73 * @tc.desc : Test GetChannelCount interface. Returns success.
74 */
75 HWTEST(AudioStreamUnitTest, Audio_Stream_GetChannelCount_001, TestSize.Level1)
76 {
77 std::shared_ptr<AudioStream> audioStream_;
78 AudioStreamUnitTest::InitAudioStream(audioStream_);
79 uint8_t channelCount = audioStream_->GetChannelCount();
80 EXPECT_EQ(DEFAULT_CHANNEL_COUNT, channelCount);
81 }
82
83 /**
84 * @tc.name : Test Audio_Stream_GetSampleSize_001 via legal state
85 * @tc.number: Audio_Stream_GetSampleSize_001
86 * @tc.desc : Test GetSampleSize interface. Returns success.
87 */
88 HWTEST(AudioStreamUnitTest, Audio_Stream_GetSampleSize_001, TestSize.Level1)
89 {
90 std::shared_ptr<AudioStream> audioStream_;
91 AudioStreamUnitTest::InitAudioStream(audioStream_);
92 uint8_t sampleSize = audioStream_->GetSampleSize();
93 EXPECT_EQ(DEFAULT_SAMPLE_SIZE, sampleSize);
94 }
95
96 /**
97 * @tc.name : Test Audio_Stream_GetStreamVolume_001 via legal state
98 * @tc.number: Audio_Stream_GetStreamVolume_001
99 * @tc.desc : Test GetStreamVolume interface. Returns success.
100 */
101 HWTEST(AudioStreamUnitTest, Audio_Stream_GetStreamVolume_001, TestSize.Level1)
102 {
103 std::shared_ptr<AudioStream> audioStream_;
104 AudioStreamUnitTest::InitAudioStream(audioStream_);
105 uint32_t sessionID = 0;
106 uint8_t streamVolume = audioStream_->GetStreamVolume(sessionID);
107 EXPECT_EQ(DEFAULT_STREAM_VOLUME, streamVolume);
108 }
109
110 /**
111 * @tc.name : Test Audio_Stream_RegisterAudioRendererCallbacks_001 via legal state
112 * @tc.number: Audio_Stream_RegisterAudioRendererCallbacks_001
113 * @tc.desc : Test RegisterAudioRendererCallbacks interface. Returns success.
114 */
115 HWTEST(AudioStreamUnitTest, Audio_Stream_RegisterAudioRendererCallbacks_001, TestSize.Level1)
116 {
117 std::shared_ptr<AudioStream> audioStream_;
118 AudioStreamUnitTest::InitAudioStream(audioStream_);
119 RenderCallbackTest renderCallback;
120 audioStream_->RegisterAudioRendererCallbacks(renderCallback);
121 }
122
123 /**
124 * @tc.name : Test Audio_Stream_RegisterAudioCapturerCallbacks_001 via legal state
125 * @tc.number: Audio_Stream_RegisterAudioCapturerCallbacks_001
126 * @tc.desc : Test RegisterAudioCapturerCallbacks interface. Returns success.
127 */
128 HWTEST(AudioStreamUnitTest, Audio_Stream_RegisterAudioCapturerCallbacks_001, TestSize.Level1)
129 {
130 std::shared_ptr<AudioStream> audioStream_;
131 AudioStreamUnitTest::InitAudioStream(audioStream_);
132 CapturterCallbackTest capturerCallback;
133 audioStream_->RegisterAudioCapturerCallbacks(capturerCallback);
134 }
135
136 /**
137 * @tc.name : Test Audio_Stream_SetStreamType_001 via illegal state
138 * @tc.number: Audio_Stream_SetStreamType_001
139 * @tc.desc : Test SetStreamType interface. Returns success.
140 */
141 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamType_001, TestSize.Level1)
142 {
143 std::shared_ptr<AudioStream> audioStream_;
144 AudioStreamUnitTest::InitAudioStream(audioStream_);
145 AudioStreamType audioStreamType = AudioStreamType::STREAM_MEDIA;
146 int32_t ret = audioStream_->SetStreamType(audioStreamType);
147 EXPECT_EQ(FAILURE, ret);
148 }
149
150 /**
151 * @tc.name : Test Audio_Stream_GetStreamRenderRate_001 via legal state
152 * @tc.number: Audio_Stream_GetStreamRenderRate_001
153 * @tc.desc : Test GetStreamRenderRate interface. Returns success.
154 */
155 HWTEST(AudioStreamUnitTest, Audio_Stream_GetStreamRenderRate_001, TestSize.Level1)
156 {
157 std::shared_ptr<AudioStream> audioStream_;
158 AudioStreamUnitTest::InitAudioStream(audioStream_);
159 AudioRendererRate renderRate = audioStream_->GetStreamRenderRate();
160 EXPECT_EQ(AudioRendererRate::RENDER_RATE_NORMAL, renderRate);
161 }
162
163 /**
164 * @tc.name : Test Audio_Stream_GetSupportedFormats_001 via legal state
165 * @tc.number: Audio_Stream_GetSupportedFormats_001
166 * @tc.desc : Test GetSupportedFormats interface. Returns success.
167 */
168 HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedFormats_001, TestSize.Level1)
169 {
170 std::shared_ptr<AudioStream> audioStream_;
171 AudioStreamUnitTest::InitAudioStream(audioStream_);
172 vector<AudioSampleFormat> supportedFormatList = audioStream_->GetSupportedFormats();
173 EXPECT_EQ(AUDIO_SUPPORTED_FORMATS.size(), supportedFormatList.size());
174 }
175
176 /**
177 * @tc.name : Test Audio_Stream_GetSupportedEncodingTypes_001 via legal state
178 * @tc.number: Audio_Stream_GetSupportedEncodingTypes_001
179 * @tc.desc : Test GetSupportedEncodingTypes interface. Returns success.
180 */
181 HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedEncodingTypes_001, TestSize.Level1)
182 {
183 std::shared_ptr<AudioStream> audioStream_;
184 AudioStreamUnitTest::InitAudioStream(audioStream_);
185 vector<AudioEncodingType> supportedEncodingTypes = audioStream_->GetSupportedEncodingTypes();
186 EXPECT_EQ(AUDIO_SUPPORTED_ENCODING_TYPES.size(), supportedEncodingTypes.size());
187 }
188
189 /**
190 * @tc.name : Test Audio_Stream_GetSupportedSamplingRates_001 via legal state
191 * @tc.number: Audio_Stream_GetSupportedSamplingRates_001
192 * @tc.desc : Test GetSupportedSamplingRates interface. Returns success.
193 */
194 HWTEST(AudioStreamUnitTest, Audio_Stream_GetSupportedSamplingRates_001, TestSize.Level1)
195 {
196 std::shared_ptr<AudioStream> audioStream_;
197 AudioStreamUnitTest::InitAudioStream(audioStream_);
198 vector<AudioSamplingRate> supportedSamplingRates = audioStream_->GetSupportedSamplingRates();
199 EXPECT_EQ(AUDIO_SUPPORTED_SAMPLING_RATES.size(), supportedSamplingRates.size());
200 }
201
202 /**
203 * @tc.name : Test Audio_Stream_SetAudioStreamType_001 via illegal state
204 * @tc.number: Audio_Stream_SetAudioStreamType_001
205 * @tc.desc : Test SetAudioStreamType interface. Returns success.
206 */
207 HWTEST(AudioStreamUnitTest, Audio_Stream_SetAudioStreamType_001, TestSize.Level1)
208 {
209 std::shared_ptr<AudioStream> audioStream_;
210 AudioStreamUnitTest::InitAudioStream(audioStream_);
211 AudioStreamType audioStreamType = AudioStreamType::STREAM_RING;
212 int32_t ret = audioStream_->SetAudioStreamType(audioStreamType);
213 EXPECT_EQ(FAILURE, ret);
214 }
215
216 /**
217 * @tc.name : Test Audio_Stream_SetRenderRate_001 via legal state
218 * @tc.number: Audio_Stream_SetRenderRate_001
219 * @tc.desc : Test SetRenderRate interface. Returns success.
220 */
221 HWTEST(AudioStreamUnitTest, Audio_Stream_SetRenderRate_001, TestSize.Level1)
222 {
223 std::shared_ptr<AudioStream> audioStream_;
224 AudioStreamUnitTest::InitAudioStream(audioStream_);
225 AudioRendererRate renderRate = AudioRendererRate::RENDER_RATE_NORMAL;
226 int32_t ret = audioStream_->SetRenderRate(renderRate);
227 EXPECT_EQ(SUCCESS, ret);
228 }
229
230 /**
231 * @tc.name : Test Audio_Stream_GetRenderRate_001 via legal state
232 * @tc.number: Audio_Stream_GetRenderRate_001
233 * @tc.desc : Test GetRenderRate interface. Returns success.
234 */
235 HWTEST(AudioStreamUnitTest, Audio_Stream_GetRenderRate_001, TestSize.Level1)
236 {
237 std::shared_ptr<AudioStream> audioStream_;
238 AudioStreamUnitTest::InitAudioStream(audioStream_);
239 AudioRendererRate renderRate = audioStream_->GetRenderRate();
240 EXPECT_EQ(renderRate, AudioRendererRate::RENDER_RATE_NORMAL);
241 }
242
243 /**
244 * @tc.name : Test Audio_Stream_GetCaptureMode_001 via legal state
245 * @tc.number: Audio_Stream_GetCaptureMode_001
246 * @tc.desc : Test GetCaptureMode interface. Returns success.
247 */
248 HWTEST(AudioStreamUnitTest, Audio_Stream_GetCaptureMode_001, TestSize.Level1)
249 {
250 std::shared_ptr<AudioStream> audioStream_;
251 AudioStreamUnitTest::InitAudioStream(audioStream_);
252 AudioCaptureMode captureMode = audioStream_->GetCaptureMode();
253 EXPECT_EQ(captureMode, AudioCaptureMode::CAPTURE_MODE_NORMAL);
254 }
255
256 /**
257 * @tc.name : Test Audio_Stream_SetStreamCallback_001 via legal state
258 * @tc.number: Audio_Stream_SetStreamCallback_001
259 * @tc.desc : Test SetStreamCallback interface. Returns success.
260 */
261 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamCallback_001, TestSize.Level1)
262 {
263 std::shared_ptr<AudioStream> audioStream_;
264 AudioStreamUnitTest::InitAudioStream(audioStream_);
265
266 std::shared_ptr<AudioStreamCallback> audioStreamCallback_ = nullptr;
267 int32_t ret = audioStream_->SetStreamCallback(audioStreamCallback_);
268 EXPECT_EQ(ERR_INVALID_PARAM, ret);
269
270 audioStreamCallback_ = std::make_shared<AudioStreamCallbackTest>();
271 ret = audioStream_->SetStreamCallback(audioStreamCallback_);
272 EXPECT_EQ(SUCCESS, ret);
273 }
274
275 /**
276 * @tc.name : Test Audio_Stream_SetRenderMode_001 via legal state
277 * @tc.number: Audio_Stream_SetRenderMode_001
278 * @tc.desc : Test SetRenderMode interface. Returns invalid.
279 */
280 HWTEST(AudioStreamUnitTest, Audio_Stream_SetRenderMode_001, TestSize.Level1)
281 {
282 std::shared_ptr<AudioStream> audioStream_;
283 AudioStreamUnitTest::InitAudioStream(audioStream_);
284 AudioRenderMode renderMode = AudioRenderMode::RENDER_MODE_NORMAL;
285 int32_t ret = audioStream_->SetRenderMode(renderMode);
286 EXPECT_EQ(SUCCESS, ret);
287 }
288
289 /**
290 * @tc.name : Test Audio_Stream_SetCaptureMode_001 via legal state
291 * @tc.number: Audio_Stream_SetCaptureMode_001
292 * @tc.desc : Test SetCaptureMode interface. Returns success.
293 */
294 HWTEST(AudioStreamUnitTest, Audio_Stream_SetCaptureMode_001, TestSize.Level1)
295 {
296 std::shared_ptr<AudioStream> audioStream_;
297 AudioStreamUnitTest::InitAudioStream(audioStream_);
298 AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_NORMAL;
299 int32_t ret = audioStream_->SetCaptureMode(captureMode);
300 EXPECT_EQ(SUCCESS, ret);
301 }
302
303 /**
304 * @tc.name : Test Audio_Stream_SetCapturerReadCallback_001 via illegal state
305 * @tc.number: Audio_Stream_SetCapturerReadCallback_001
306 * @tc.desc : Test SetCapturerReadCallback interface. Returns invalid.
307 */
308 HWTEST(AudioStreamUnitTest, Audio_Stream_SetCapturerReadCallback_001, TestSize.Level1)
309 {
310 std::shared_ptr<AudioStream> audioStream_;
311 AudioStreamUnitTest::InitAudioStream(audioStream_);
312
313 AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_NORMAL;
314 int32_t ret = audioStream_->SetCaptureMode(captureMode);
315 EXPECT_EQ(SUCCESS, ret);
316
317 std::shared_ptr<AudioCapturerReadCallback> callback = std::make_shared<AudioCapturerReadCallbackTest>();
318 ret = audioStream_->SetCapturerReadCallback(callback);
319 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
320 }
321
322 /**
323 * @tc.name : Test Audio_Stream_SetCapturerReadCallback_002 via illegal state
324 * @tc.number: Audio_Stream_SetCapturerReadCallback_002
325 * @tc.desc : Test SetCapturerReadCallback interface. Returns invalid.
326 */
327 HWTEST(AudioStreamUnitTest, Audio_Stream_SetCapturerReadCallback_002, TestSize.Level1)
328 {
329 std::shared_ptr<AudioStream> audioStream_;
330 AudioStreamUnitTest::InitAudioStream(audioStream_);
331
332 AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_CALLBACK;
333 int32_t ret = audioStream_->SetCaptureMode(captureMode);
334 EXPECT_EQ(SUCCESS, ret);
335
336 std::shared_ptr<AudioCapturerReadCallback> callback = nullptr;
337 ret = audioStream_->SetCapturerReadCallback(callback);
338 EXPECT_EQ(ERR_INVALID_PARAM, ret);
339 }
340
341 /**
342 * @tc.name : Test Audio_Stream_GetBufQueueState_001 via illegal state
343 * @tc.number: Audio_Stream_GetBufQueueState_001
344 * @tc.desc : Test GetBufQueueState interface. Returns invalid.
345 */
346 HWTEST(AudioStreamUnitTest, Audio_Stream_GetBufQueueState_001, TestSize.Level1)
347 {
348 int32_t ret = -1;
349 std::shared_ptr<AudioStream> audioStream_;
350 AudioStreamUnitTest::InitAudioStream(audioStream_);
351
352 AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_NORMAL;
353 ret = audioStream_->SetCaptureMode(captureMode);
354 EXPECT_EQ(SUCCESS, ret);
355
356 AudioRenderMode renderMode = AudioRenderMode::RENDER_MODE_NORMAL;
357 ret = audioStream_->SetRenderMode(renderMode);
358 EXPECT_EQ(SUCCESS, ret);
359
360 BufferQueueState bufState;
361 ret = audioStream_->GetBufQueueState(bufState);
362 EXPECT_EQ(ERR_INCORRECT_MODE, ret);
363 }
364
365 /**
366 * @tc.name : Test Audio_Stream_SaveReadCallback_001 via illegal state
367 * @tc.number: Audio_Stream_SaveReadCallback_001
368 * @tc.desc : Test SaveReadCallback interface. Returns invalid.
369 */
370 HWTEST(AudioStreamUnitTest, Audio_Stream_SaveReadCallback_001, TestSize.Level1)
371 {
372 int32_t ret = -1;
373 std::shared_ptr<AudioStream> audioStream_;
374 AudioStreamUnitTest::InitAudioStream(audioStream_);
375
376 std::weak_ptr<AudioCapturerReadCallback> callback;
377 ret = audioStream_->SaveReadCallback(callback);
378 EXPECT_EQ(AUDIO_CLIENT_INIT_ERR, ret);
379 }
380
381 /**
382 * @tc.name : Test Audio_Stream_SetStreamVolume_001 via legal state
383 * @tc.number: Audio_Stream_SetStreamVolume_001
384 * @tc.desc : Test SetStreamVolume interface. Returns success.
385 */
386 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamVolume_001, TestSize.Level1)
387 {
388 int32_t ret = -1;
389 std::shared_ptr<AudioStream> audioStream_;
390 AudioStreamUnitTest::InitAudioStream(audioStream_);
391
392 uint32_t sessionID = 1;
393 uint32_t volume =1;
394 ret = audioStream_->SetStreamVolume(sessionID, volume);
395 EXPECT_EQ(SUCCESS, ret);
396 }
397
398 /**
399 * @tc.name : Test Audio_Stream_SetStreamRenderRate_001 via illegal state
400 * @tc.number: Audio_Stream_SetStreamRenderRate_001
401 * @tc.desc : Test SetStreamRenderRate interface. Returns invalid.
402 */
403 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamRenderRate_001, TestSize.Level1)
404 {
405 int32_t ret = -1;
406 std::shared_ptr<AudioStream> audioStream_;
407 AudioStreamUnitTest::InitAudioStream(audioStream_);
408
409 AudioRendererRate audioRendererRateDouble = AudioRendererRate::RENDER_RATE_DOUBLE;
410 ret = audioStream_->SetStreamRenderRate(audioRendererRateDouble);
411 EXPECT_EQ(SUCCESS, ret);
412
413 AudioRendererRate audioRendererRateHalf = AudioRendererRate::RENDER_RATE_HALF;
414 ret = audioStream_->SetStreamRenderRate(audioRendererRateHalf);
415 EXPECT_EQ(SUCCESS, ret);
416 }
417
418 /**
419 * @tc.name : Test Audio_Stream_SetStreamLowPowerVolume_001 via illegal state
420 * @tc.number: Audio_Stream_SetStreamLowPowerVolume_001
421 * @tc.desc : Test SetStreamLowPowerVolume interface. Returns invalid.
422 */
423 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamLowPowerVolume_001, TestSize.Level1)
424 {
425 int32_t ret = -1;
426 std::shared_ptr<AudioStream> audioStream_;
427 AudioStreamUnitTest::InitAudioStream(audioStream_);
428
429 float powerVolumeFactor = 1.2;
430 ret = audioStream_->SetStreamLowPowerVolume(powerVolumeFactor);
431 EXPECT_EQ(AUDIO_CLIENT_ERR, ret);
432
433 ASClientType eClientType = ASClientType::AUDIO_SERVICE_CLIENT_PLAYBACK;
434 audioStream_->Initialize(eClientType);
435 ret = audioStream_->SetStreamLowPowerVolume(powerVolumeFactor);
436 EXPECT_EQ(AUDIO_CLIENT_INVALID_PARAMS_ERR, ret);
437 }
438
439 /**
440 * @tc.name : Test Audio_Stream_SetStreamRenderRate_002 via illegal state
441 * @tc.number: Audio_Stream_SetStreamRenderRate_002
442 * @tc.desc : Test SetStreamRenderRate interface. Returns invalid.
443 */
444 HWTEST(AudioStreamUnitTest, Audio_Stream_SetStreamRenderRate_002, TestSize.Level1)
445 {
446 int32_t ret = -1;
447 std::shared_ptr<AudioStream> audioStream_;
448 AudioStreamUnitTest::InitAudioStream(audioStream_);
449
450 std::shared_ptr<AudioRendererWriteCallback> callback = nullptr;
451 ret = audioStream_->SetRendererWriteCallback(callback);
452 EXPECT_EQ(true, ret < 0);
453 }
454 } // namespace AudioStandard
455 } // namespace OHOS