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