1 /*
2 * Copyright (c) 2021-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 "audio_capturer_unit_test.h"
17
18 #include <thread>
19
20 #include "audio_capturer.h"
21 #include "audio_errors.h"
22 #include "audio_info.h"
23
24 using namespace std;
25 using namespace testing::ext;
26
27 namespace OHOS {
28 namespace AudioStandard {
29 namespace {
30 const string AUDIO_CAPTURE_FILE1 = "/data/audiocapturetest_blocking.pcm";
31 const string AUDIO_CAPTURE_FILE2 = "/data/audiocapturetest_nonblocking.pcm";
32 const string AUDIO_TIME_STABILITY_TEST_FILE = "/data/audiocapture_getaudiotime_stability_test.pcm";
33 const string AUDIO_FLUSH_STABILITY_TEST_FILE = "/data/audiocapture_flush_stability_test.pcm";
34 const int32_t READ_BUFFERS_COUNT = 128;
35 const int32_t VALUE_NEGATIVE = -1;
36 const int32_t VALUE_ZERO = 0;
37 const int32_t VALUE_HUNDRED = 100;
38 const int32_t VALUE_THOUSAND = 1000;
39 const int32_t CAPTURER_FLAG = 0;
40
41 constexpr uint64_t BUFFER_DURATION_FIVE = 5;
42 constexpr uint64_t BUFFER_DURATION_TEN = 10;
43 constexpr uint64_t BUFFER_DURATION_FIFTEEN = 15;
44 constexpr uint64_t BUFFER_DURATION_TWENTY = 20;
45 } // namespace
46
SetUpTestCase(void)47 void AudioCapturerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)48 void AudioCapturerUnitTest::TearDownTestCase(void) {}
SetUp(void)49 void AudioCapturerUnitTest::SetUp(void) {}
TearDown(void)50 void AudioCapturerUnitTest::TearDown(void) {}
51
InitializeCapturer(unique_ptr<AudioCapturer> & audioCapturer)52 int32_t AudioCapturerUnitTest::InitializeCapturer(unique_ptr<AudioCapturer> &audioCapturer)
53 {
54 AudioCapturerParams capturerParams;
55 capturerParams.audioSampleFormat = SAMPLE_S16LE;
56 capturerParams.samplingRate = SAMPLE_RATE_44100;
57 capturerParams.audioChannel = STEREO;
58 capturerParams.audioEncoding = ENCODING_PCM;
59
60 return audioCapturer->SetParams(capturerParams);
61 }
62
InitializeCapturerOptions(AudioCapturerOptions & capturerOptions)63 void AudioCapturerUnitTest::InitializeCapturerOptions(AudioCapturerOptions &capturerOptions)
64 {
65 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
66 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
67 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
68 capturerOptions.streamInfo.channels = AudioChannel::MONO;
69 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
70 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
71 return;
72 }
73
StartCaptureThread(AudioCapturer * audioCapturer,const string filePath)74 void StartCaptureThread(AudioCapturer *audioCapturer, const string filePath)
75 {
76 int32_t ret = -1;
77 bool isBlockingRead = true;
78 size_t bufferLen;
79 ret = audioCapturer->GetBufferSize(bufferLen);
80 EXPECT_EQ(SUCCESS, ret);
81
82 auto buffer = std::make_unique<uint8_t[]>(bufferLen);
83 ASSERT_NE(nullptr, buffer);
84 FILE *capFile = fopen(filePath.c_str(), "wb");
85 ASSERT_NE(nullptr, capFile);
86
87 size_t size = 1;
88 int32_t bytesRead = 0;
89 int32_t numBuffersToCapture = READ_BUFFERS_COUNT;
90
91 while (numBuffersToCapture) {
92 bytesRead = audioCapturer->Read(*(buffer.get()), bufferLen, isBlockingRead);
93 if (bytesRead < 0) {
94 break;
95 } else if (bytesRead > 0) {
96 fwrite(buffer.get(), size, bytesRead, capFile);
97 numBuffersToCapture--;
98 }
99 }
100
101 audioCapturer->Flush();
102
103 fclose(capFile);
104 }
105
106 /**
107 * @tc.name : Test GetSupportedFormats API
108 * @tc.number: Audio_Capturer_GetSupportedFormats_001
109 * @tc.desc : Test GetSupportedFormats interface. Returns supported Formats on success.
110 */
111 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetSupportedFormats_001, TestSize.Level0)
112 {
113 vector<AudioSampleFormat> supportedFormatList = AudioCapturer::GetSupportedFormats();
114 EXPECT_EQ(AUDIO_SUPPORTED_FORMATS.size(), supportedFormatList.size());
115 }
116
117 /**
118 * @tc.name : Test GetSupportedChannels API
119 * @tc.number: Audio_Capturer_GetSupportedChannels_001
120 * @tc.desc : Test GetSupportedChannels interface. Returns supported Channels on success.
121 */
122 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetSupportedChannels_001, TestSize.Level0)
123 {
124 vector<AudioChannel> supportedChannelList = AudioCapturer::GetSupportedChannels();
125 EXPECT_EQ(CAPTURER_SUPPORTED_CHANNELS.size(), supportedChannelList.size());
126 }
127
128 /**
129 * @tc.name : Test GetSupportedEncodingTypes API
130 * @tc.number: Audio_Capturer_GetSupportedEncodingTypes_001
131 * @tc.desc : Test GetSupportedEncodingTypes interface. Returns supported Encoding types on success.
132 */
133 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetSupportedEncodingTypes_001, TestSize.Level0)
134 {
135 vector<AudioEncodingType> supportedEncodingTypes
136 = AudioCapturer::GetSupportedEncodingTypes();
137 EXPECT_EQ(AUDIO_SUPPORTED_ENCODING_TYPES.size(), supportedEncodingTypes.size());
138 }
139
140 /**
141 * @tc.name : Test GetSupportedSamplingRates API
142 * @tc.number: Audio_Capturer_GetSupportedSamplingRates_001
143 * @tc.desc : Test GetSupportedSamplingRates interface. Returns supported Sampling rates on success.
144 */
145 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetSupportedSamplingRates_001, TestSize.Level0)
146 {
147 vector<AudioSamplingRate> supportedSamplingRates = AudioCapturer::GetSupportedSamplingRates();
148 EXPECT_EQ(AUDIO_SUPPORTED_SAMPLING_RATES.size(), supportedSamplingRates.size());
149 }
150
151 /**
152 * @tc.name : Test Create API via legal input.
153 * @tc.number: Audio_Capturer_Create_001
154 * @tc.desc : Test Create interface with STREAM_MUSIC. Returns audioCapturer instance, if create is successful.
155 */
156 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_001, TestSize.Level0)
157 {
158 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
159 EXPECT_NE(nullptr, audioCapturer);
160 }
161
162 /**
163 * @tc.name : Test Create API via legal input.
164 * @tc.number: Audio_Capturer_Create_002
165 * @tc.desc : Test Create interface with STREAM_RING. Returns audioCapturer instance, if create is successful.
166 */
167 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_002, TestSize.Level0)
168 {
169 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_RING);
170 EXPECT_NE(nullptr, audioCapturer);
171 }
172
173 /**
174 * @tc.name : Test Create API via legal input.
175 * @tc.number: Audio_Capturer_Create_003
176 * @tc.desc : Test Create interface with STREAM_VOICE_CALL. Returns audioCapturer instance if create is successful.
177 * Note: instance will be created but functional support for STREAM_VOICE_CALL not available yet.
178 */
179 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_003, TestSize.Level0)
180 {
181 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_VOICE_CALL);
182 EXPECT_NE(nullptr, audioCapturer);
183 }
184
185 /**
186 * @tc.name : Test Create API via legal input.
187 * @tc.number: Audio_Capturer_Create_004
188 * @tc.desc : Test Create interface with STREAM_SYSTEM. Returns audioCapturer instance, if create is successful.
189 * Note: instance will be created but functional support for STREAM_SYSTEM not available yet.
190 */
191 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_004, TestSize.Level0)
192 {
193 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_SYSTEM);
194 EXPECT_NE(nullptr, audioCapturer);
195 }
196
197 /**
198 * @tc.name : Test Create API via legal input.
199 * @tc.number: Audio_Capturer_Create_005
200 * @tc.desc : Test Create interface with STREAM_BLUETOOTH_SCO. Returns audioCapturer instance, if create is successful.
201 * Note: instance will be created but functional support for STREAM_BLUETOOTH_SCO not available yet
202 */
203 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_005, TestSize.Level0)
204 {
205 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_BLUETOOTH_SCO);
206 EXPECT_NE(nullptr, audioCapturer);
207 }
208
209 /**
210 * @tc.name : Test Create API via legal input.
211 * @tc.number: Audio_Capturer_Create_006
212 * @tc.desc : Test Create interface with STREAM_ALARM. Returns audioCapturer instance, if create is successful.
213 * Note: instance will be created but functional support for STREAM_ALARM not available yet.
214 */
215 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_006, TestSize.Level0)
216 {
217 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_ALARM);
218 EXPECT_NE(nullptr, audioCapturer);
219 }
220
221 /**
222 * @tc.name : Test Create API via legal input.
223 * @tc.number: Audio_Capturer_Create_007
224 * @tc.desc : Test Create interface with STREAM_NOTIFICATION. Returns audioCapturer instance, if create is successful.
225 * Note: instance will be created but functional support for STREAM_NOTIFICATION not available yet.
226 */
227 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_007, TestSize.Level0)
228 {
229 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_NOTIFICATION);
230 EXPECT_NE(nullptr, audioCapturer);
231 }
232
233 /**
234 * @tc.name : Test Create API via legal input.
235 * @tc.number: Audio_Capturer_Create_008
236 * @tc.desc : Test Create interface with AudioCapturerOptions below.
237 * Returns audioCapturer instance, if create is successful.
238 * capturerOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
239 * capturerOptions.streamInfo.encoding = ENCODING_PCM;
240 * capturerOptions.streamInfo.format = SAMPLE_U8;
241 * capturerOptions.streamInfo.channels = MONO;
242 * capturerOptions.capturerInfo.sourceType = SOURCE_TYPE_MIC;
243 * capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
244 */
245 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_008, TestSize.Level0)
246 {
247 AudioCapturerOptions capturerOptions;
248 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
249 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
250 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
251 capturerOptions.streamInfo.channels = AudioChannel::MONO;
252 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
253 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
254
255 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
256 ASSERT_NE(nullptr, audioCapturer);
257 audioCapturer->Release();
258 }
259
260 /**
261 * @tc.name : Test Create API via legal input.
262 * @tc.number: Audio_Capturer_Create_009
263 * @tc.desc : Test Create interface with AudioCapturerOptions below.
264 * Returns audioCapturer instance, if create is successful.
265 * capturerOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
266 * capturerOptions.streamInfo.encoding = ENCODING_PCM;
267 * capturerOptions.streamInfo.format = SAMPLE_U8;
268 * capturerOptions.streamInfo.channels = MONO;
269 * capturerOptions.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
270 * capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
271 */
272 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_009, TestSize.Level0)
273 {
274 AudioCapturerOptions capturerOptions;
275 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
276 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
277 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
278 capturerOptions.streamInfo.channels = AudioChannel::MONO;
279 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
280 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
281
282 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
283 ASSERT_NE(nullptr, audioCapturer);
284 audioCapturer->Release();
285 }
286
287 /**
288 * @tc.name : Test Create API via legal input.
289 * @tc.number: Audio_Capturer_Create_010
290 * @tc.desc : Test Create interface with AudioCapturerOptions below.
291 * Returns audioCapturer instance, if create is successful.
292 * capturerOptions.streamInfo.samplingRate = SAMPLE_RATE_96000;
293 * capturerOptions.streamInfo.encoding = ENCODING_PCM;
294 * capturerOptions.streamInfo.format = SAMPLE_S32LE;
295 * capturerOptions.streamInfo.channels = MONO;
296 * capturerOptions.capturerInfo.sourceType = SOURCE_TYPE_VOICE_COMMUNICATION;
297 * capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
298 */
299 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_010, TestSize.Level0)
300 {
301 AudioCapturerOptions capturerOptions;
302 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_64000;
303 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
304 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
305 capturerOptions.streamInfo.channels = AudioChannel::MONO;
306 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_VOICE_COMMUNICATION;
307 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
308
309 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
310 ASSERT_NE(nullptr, audioCapturer);
311 audioCapturer->Release();
312 }
313
314 /**
315 * @tc.name : Test Create API via legal input.
316 * @tc.number: Audio_Capturer_Create_011
317 * @tc.desc : Test Create interface with AudioCapturerOptions below.
318 * Returns audioCapturer instance, if create is successful.
319 * capturerOptions.streamInfo.samplingRate = SAMPLE_RATE_64000;
320 * capturerOptions.streamInfo.encoding = ENCODING_PCM;
321 * capturerOptions.streamInfo.format = SAMPLE_S32LE;
322 * capturerOptions.streamInfo.channels = STEREO;
323 * capturerOptions.capturerInfo.sourceType = SOURCE_TYPE_MIC;
324 * capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
325 */
326 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_011, TestSize.Level0)
327 {
328 AudioCapturerOptions capturerOptions;
329 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_64000;
330 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
331 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S32LE;
332 capturerOptions.streamInfo.channels = AudioChannel::STEREO;
333 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
334 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
335
336 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
337 ASSERT_NE(nullptr, audioCapturer);
338 audioCapturer->Release();
339 }
340
341 /**
342 * @tc.name : Test Create API via legal input.
343 * @tc.number: Audio_Capturer_Create_012
344 * @tc.desc : Test Create interface with AudioCapturerOptions below.
345 * Returns audioCapturer instance, if create is successful.
346 * capturerOptions.streamInfo.samplingRate = SAMPLE_RATE_44100;
347 * capturerOptions.streamInfo.encoding = ENCODING_PCM;
348 * capturerOptions.streamInfo.format = SAMPLE_S16LE;
349 * capturerOptions.streamInfo.channels = STEREO;
350 * capturerOptions.capturerInfo.sourceType = SOURCE_TYPE_MIC;
351 * capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
352 */
353 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_012, TestSize.Level0)
354 {
355 AudioCapturerOptions capturerOptions;
356 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
357 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
358 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
359 capturerOptions.streamInfo.channels = AudioChannel::STEREO;
360 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
361 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
362
363 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
364 ASSERT_NE(nullptr, audioCapturer);
365 audioCapturer->Release();
366 }
367
368 /**
369 * @tc.name : Test Create API via legal input.
370 * @tc.number: Audio_Capturer_Create_013
371 * @tc.desc : Test Create interface with STREAM_MUSIC and appInfo. Returns audioCapturer instance, if successful.
372 */
373 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_013, TestSize.Level0)
374 {
375 AppInfo appInfo = {};
376 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC, appInfo);
377 ASSERT_NE(nullptr, audioCapturer);
378
379 AudioCapturerParams capturerParams;
380 capturerParams.audioSampleFormat = SAMPLE_S16LE;
381 capturerParams.samplingRate = SAMPLE_RATE_44100;
382 capturerParams.audioChannel = STEREO;
383 capturerParams.audioEncoding = ENCODING_PCM;
384
385 int32_t ret = audioCapturer->SetParams(capturerParams);
386 EXPECT_EQ(SUCCESS, ret);
387 audioCapturer->Release();
388 }
389
390 /**
391 * @tc.name : Test Create API via legal input.
392 * @tc.number: Audio_Capturer_Create_014
393 * @tc.desc : Test Create interface with STREAM_MUSIC and appInfo. Returns audioCapturer instance, if successful.
394 */
395 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_014, TestSize.Level0)
396 {
397 AppInfo appInfo = {};
398 appInfo.appTokenId = VALUE_THOUSAND;
399 appInfo.appUid = VALUE_HUNDRED;
400 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC, appInfo);
401 ASSERT_NE(nullptr, audioCapturer);
402
403 AudioCapturerParams capturerParams;
404 capturerParams.audioSampleFormat = SAMPLE_S16LE;
405 capturerParams.samplingRate = SAMPLE_RATE_44100;
406 capturerParams.audioChannel = STEREO;
407 capturerParams.audioEncoding = ENCODING_PCM;
408
409 int32_t ret = audioCapturer->SetParams(capturerParams);
410 EXPECT_EQ(SUCCESS, ret);
411 audioCapturer->Release();
412 }
413
414 /**
415 * @tc.name : Test Create API via legal input.
416 * @tc.number: Audio_Capturer_Create_015
417 * @tc.desc : Test Create function with two types of parameters: AudioCapturerOptions and AppInfo.
418 */
419 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_015, TestSize.Level0)
420 {
421 AudioCapturerOptions capturerOptions;
422 AppInfo appInfo = {};
423 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000;
424 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
425 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
426 capturerOptions.streamInfo.channels = AudioChannel::MONO;
427 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
428 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
429 appInfo.appTokenId = VALUE_THOUSAND;
430 appInfo.appUid = VALUE_HUNDRED;
431 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, appInfo);
432 ASSERT_NE(nullptr, audioCapturer);
433 audioCapturer->Release();
434 }
435
436 /**
437 * @tc.name : Test Create API via legal input.
438 * @tc.number: Audio_Capturer_Create_016
439 * @tc.desc : Test Create function with two types of parameters: AudioCapturerOptions and AppInfo,
440 * and give different parameters.
441 */
442 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_016, TestSize.Level0)
443 {
444 AudioCapturerOptions capturerOptions;
445 AppInfo appInfo = {};
446 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_16000;
447 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
448 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
449 capturerOptions.streamInfo.channels = AudioChannel::MONO;
450 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION;
451 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
452 appInfo.appTokenId = VALUE_THOUSAND;
453 appInfo.appUid = VALUE_HUNDRED;
454 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, appInfo);
455 ASSERT_NE(nullptr, audioCapturer);
456 audioCapturer->Release();
457 }
458
459 /**
460 * @tc.name : Test Create API via legal input.
461 * @tc.number: Audio_Capturer_Create_017
462 * @tc.desc : Test Create function with two types of parameters: AudioCapturerOptions and string.
463 */
464 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_017, TestSize.Level0)
465 {
466 AudioCapturerOptions capturerOptions;
467 string cachePath = "/data/storage/el2/base/haps/entry/files";
468 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_16000;
469 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
470 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
471 capturerOptions.streamInfo.channels = AudioChannel::MONO;
472 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION;
473 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
474 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, cachePath.c_str());
475 ASSERT_NE(nullptr, audioCapturer);
476 audioCapturer->Release();
477 }
478
479 /**
480 * @tc.name : Test Create API via legal input.
481 * @tc.number: Audio_Capturer_Create_018
482 * @tc.desc : Test function Create uses three types of parameters: AudioCapturerOptions, string and AppInfo.
483 */
484 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Create_018, TestSize.Level0)
485 {
486 AudioCapturerOptions capturerOptions;
487 AppInfo appInfo = {};
488 string cachePath = "/data/storage/el2/base/haps/entry/files";
489 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_16000;
490 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
491 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
492 capturerOptions.streamInfo.channels = AudioChannel::MONO;
493 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_VOICE_RECOGNITION;
494 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
495 appInfo.appTokenId = VALUE_THOUSAND;
496 appInfo.appUid = VALUE_HUNDRED;
497 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions, cachePath.c_str(), appInfo);
498 ASSERT_NE(nullptr, audioCapturer);
499 audioCapturer->Release();
500 }
501
502 /**
503 * @tc.name : Test SetParams API via legal input
504 * @tc.number: Audio_Capturer_SetParams_001
505 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
506 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
507 * capturerParams.samplingRate = SAMPLE_RATE_44100;
508 * capturerParams.audioChannel = STEREO;
509 * capturerParams.audioEncoding = ENCODING_PCM;
510 */
511 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_001, TestSize.Level1)
512 {
513 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
514 ASSERT_NE(nullptr, audioCapturer);
515
516 AudioCapturerParams capturerParams;
517 capturerParams.audioSampleFormat = SAMPLE_S16LE;
518 capturerParams.samplingRate = SAMPLE_RATE_44100;
519 capturerParams.audioChannel = STEREO;
520 capturerParams.audioEncoding = ENCODING_PCM;
521
522 int32_t ret = audioCapturer->SetParams(capturerParams);
523 EXPECT_EQ(SUCCESS, ret);
524 audioCapturer->Release();
525 }
526
527 /**
528 * @tc.name : Test SetParams API via legal input.
529 * @tc.number: Audio_Capturer_SetParams_002
530 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
531 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
532 * capturerParams.samplingRate = SAMPLE_RATE_8000;
533 * capturerParams.audioChannel = MONO;
534 * capturerParams.audioEncoding = ENCODING_PCM;
535 */
536 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_002, TestSize.Level1)
537 {
538 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
539 ASSERT_NE(nullptr, audioCapturer);
540
541 AudioCapturerParams capturerParams;
542 capturerParams.audioSampleFormat = SAMPLE_S16LE;
543 capturerParams.samplingRate = SAMPLE_RATE_8000;
544 capturerParams.audioChannel = MONO;
545 capturerParams.audioEncoding = ENCODING_PCM;
546
547 int32_t ret = audioCapturer->SetParams(capturerParams);
548 EXPECT_EQ(SUCCESS, ret);
549 audioCapturer->Release();
550 }
551
552 /**
553 * @tc.name : Test SetParams API via legal input.
554 * @tc.number: Audio_Capturer_SetParams_003
555 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
556 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
557 * capturerParams.samplingRate = SAMPLE_RATE_11025;
558 * capturerParams.audioChannel = STEREO;
559 * capturerParams.audioEncoding = ENCODING_PCM;
560 */
561 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_003, TestSize.Level1)
562 {
563 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
564 ASSERT_NE(nullptr, audioCapturer);
565
566 AudioCapturerParams capturerParams;
567 capturerParams.audioSampleFormat = SAMPLE_S16LE;
568 capturerParams.samplingRate = SAMPLE_RATE_11025;
569 capturerParams.audioChannel = STEREO;
570 capturerParams.audioEncoding = ENCODING_PCM;
571
572 int32_t ret = audioCapturer->SetParams(capturerParams);
573 EXPECT_EQ(SUCCESS, ret);
574 audioCapturer->Release();
575 }
576
577 /**
578 * @tc.name : Test SetParams API via legal input.
579 * @tc.number: Audio_Capturer_SetParams_004
580 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
581 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
582 * capturerParams.samplingRate = SAMPLE_RATE_22050;
583 * capturerParams.audioChannel = MONO;
584 * capturerParams.audioEncoding = ENCODING_PCM;
585 */
586 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_004, TestSize.Level1)
587 {
588 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
589 ASSERT_NE(nullptr, audioCapturer);
590
591 AudioCapturerParams capturerParams;
592 capturerParams.audioSampleFormat = SAMPLE_S16LE;
593 capturerParams.samplingRate = SAMPLE_RATE_22050;
594 capturerParams.audioChannel = MONO;
595 capturerParams.audioEncoding = ENCODING_PCM;
596
597 int32_t ret = audioCapturer->SetParams(capturerParams);
598 EXPECT_EQ(SUCCESS, ret);
599 audioCapturer->Release();
600 }
601
602 /**
603 * @tc.name : Test SetParams API via legal input.
604 * @tc.number: Audio_Capturer_SetParams_005
605 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
606 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
607 * capturerParams.samplingRate = SAMPLE_RATE_96000;
608 * capturerParams.audioChannel = MONO;
609 * capturerParams.audioEncoding = ENCODING_PCM;
610 */
611 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_005, TestSize.Level1)
612 {
613 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
614 ASSERT_NE(nullptr, audioCapturer);
615
616 AudioCapturerParams capturerParams;
617 capturerParams.audioSampleFormat = SAMPLE_S16LE;
618 capturerParams.samplingRate = SAMPLE_RATE_96000;
619 capturerParams.audioChannel = MONO;
620 capturerParams.audioEncoding = ENCODING_PCM;
621
622 int32_t ret = audioCapturer->SetParams(capturerParams);
623 EXPECT_EQ(SUCCESS, ret);
624 }
625
626 /**
627 * @tc.name : Test SetParams API via legal input.
628 * @tc.number: Audio_Capturer_SetParams_006
629 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
630 * capturerParams.audioSampleFormat = SAMPLE_S24LE;
631 * capturerParams.samplingRate = SAMPLE_RATE_64000;
632 * capturerParams.audioChannel = MONO;
633 * capturerParams.audioEncoding = ENCODING_PCM;
634 */
635 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_006, TestSize.Level1)
636 {
637 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
638 ASSERT_NE(nullptr, audioCapturer);
639
640 AudioCapturerParams capturerParams;
641 capturerParams.audioSampleFormat = SAMPLE_S24LE;
642 capturerParams.samplingRate = SAMPLE_RATE_64000;
643 capturerParams.audioChannel = MONO;
644 capturerParams.audioEncoding = ENCODING_PCM;
645
646 int32_t ret = audioCapturer->SetParams(capturerParams);
647 EXPECT_EQ(SUCCESS, ret);
648 }
649
650 /**
651 * @tc.name : Test SetParams API via illegal input.
652 * @tc.number: Audio_Capturer_SetParams_007
653 * @tc.desc : Test SetParams interface. Returns 0 {SUCCESS}, if the setting is successful.
654 * capturerParams.audioSampleFormat = SAMPLE_S16LE;
655 * capturerParams.samplingRate = SAMPLE_RATE_16000;
656 * capturerParams.audioChannel = STEREO;
657 * capturerParams.audioEncoding = ENCODING_PCM;
658 */
659 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_007, TestSize.Level1)
660 {
661 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
662 ASSERT_NE(nullptr, audioCapturer);
663
664 AudioCapturerParams capturerParams;
665 capturerParams.audioSampleFormat = SAMPLE_S16LE;
666 capturerParams.samplingRate = SAMPLE_RATE_16000;
667 capturerParams.audioChannel = STEREO;
668 capturerParams.audioEncoding = ENCODING_PCM;
669
670 int32_t ret = audioCapturer->SetParams(capturerParams);
671 EXPECT_EQ(SUCCESS, ret);
672 audioCapturer->Release();
673 }
674
675 /**
676 * @tc.name : Test SetParams API stability.
677 * @tc.number: Audio_Capturer_SetParams_Stability_001
678 * @tc.desc : Test SetParams interface stability.
679 */
680 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetParams_Stability_001, TestSize.Level1)
681 {
682 int32_t ret = -1;
683 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
684 ASSERT_NE(nullptr, audioCapturer);
685
686 AudioCapturerParams capturerParams;
687 capturerParams.audioSampleFormat = SAMPLE_S16LE;
688 capturerParams.samplingRate = SAMPLE_RATE_16000;
689 capturerParams.audioChannel = STEREO;
690 capturerParams.audioEncoding = ENCODING_PCM;
691
692 for (int i = 0; i < VALUE_HUNDRED; i++) {
693 ret = audioCapturer->SetParams(capturerParams);
694 EXPECT_EQ(SUCCESS, ret);
695
696 AudioCapturerParams getCapturerParams;
697 ret = audioCapturer->GetParams(getCapturerParams);
698 EXPECT_EQ(SUCCESS, ret);
699 }
700
701 audioCapturer->Release();
702 }
703
704 /**
705 * @tc.name : Test GetParams API via legal input.
706 * @tc.number: Audio_Capturer_GetParams_001
707 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
708 */
709 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_001, TestSize.Level1)
710 {
711 int32_t ret = -1;
712 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
713 ASSERT_NE(nullptr, audioCapturer);
714
715 AudioCapturerParams capturerParams;
716 capturerParams.audioSampleFormat = SAMPLE_S16LE;
717 capturerParams.samplingRate = SAMPLE_RATE_44100;
718 capturerParams.audioChannel = STEREO;
719 capturerParams.audioEncoding = ENCODING_PCM;
720 ret = audioCapturer->SetParams(capturerParams);
721 EXPECT_EQ(SUCCESS, ret);
722
723 AudioCapturerParams getCapturerParams;
724 ret = audioCapturer->GetParams(getCapturerParams);
725 EXPECT_EQ(SUCCESS, ret);
726 EXPECT_EQ(capturerParams.audioSampleFormat, getCapturerParams.audioSampleFormat);
727 EXPECT_EQ(capturerParams.samplingRate, getCapturerParams.samplingRate);
728 EXPECT_EQ(capturerParams.audioChannel, getCapturerParams.audioChannel);
729 EXPECT_EQ(capturerParams.audioEncoding, getCapturerParams.audioEncoding);
730
731 audioCapturer->Release();
732 }
733
734 /**
735 * @tc.name : Test GetParams API via legal state, CAPTURER_RUNNING: GetParams after Start.
736 * @tc.number: Audio_Capturer_GetParams_002
737 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS} if the getting is successful.
738 */
739 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_002, TestSize.Level1)
740 {
741 int32_t ret = -1;
742 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
743 ASSERT_NE(nullptr, audioCapturer);
744
745 AudioCapturerParams capturerParams;
746 capturerParams.audioSampleFormat = SAMPLE_S16LE;
747 capturerParams.samplingRate = SAMPLE_RATE_44100;
748 capturerParams.audioChannel = MONO;
749 capturerParams.audioEncoding = ENCODING_PCM;
750 ret = audioCapturer->SetParams(capturerParams);
751 EXPECT_EQ(SUCCESS, ret);
752
753 bool isStarted = audioCapturer->Start();
754 EXPECT_EQ(true, isStarted);
755
756 AudioCapturerParams getCapturerParams;
757 ret = audioCapturer->GetParams(getCapturerParams);
758 EXPECT_EQ(SUCCESS, ret);
759
760 audioCapturer->Release();
761 }
762
763 /**
764 * @tc.name : Test GetParams API via illegal state, CAPTURER_NEW: Call GetParams without SetParams.
765 * @tc.number: Audio_Capturer_GetParams_003
766 * @tc.desc : Test GetParams interface. Returns error code, if the capturer state is CAPTURER_NEW.
767 */
768 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_003, TestSize.Level1)
769 {
770 int32_t ret = -1;
771 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
772 ASSERT_NE(nullptr, audioCapturer);
773
774 AudioCapturerParams capturerParams;
775 capturerParams.audioSampleFormat = SAMPLE_S16LE;
776 capturerParams.samplingRate = SAMPLE_RATE_44100;
777 capturerParams.audioChannel = MONO;
778 capturerParams.audioEncoding = ENCODING_PCM;
779
780 AudioCapturerParams getCapturerParams;
781 ret = audioCapturer->GetParams(getCapturerParams);
782 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
783 }
784
785 /**
786 * @tc.name : Test GetParams API via illegal state, CAPTURER_RELEASED: Call GetParams after Release.
787 * @tc.number: Audio_Capturer_GetParams_004
788 * @tc.desc : Test GetParams interface. Returns error code, if the capturer state is CAPTURER_RELEASED.
789 */
790 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_004, TestSize.Level1)
791 {
792 int32_t ret = -1;
793 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
794 ASSERT_NE(nullptr, audioCapturer);
795
796 ret = AudioCapturerUnitTest::InitializeCapturer(audioCapturer);
797 EXPECT_EQ(SUCCESS, ret);
798
799 bool isReleased = audioCapturer->Release();
800 EXPECT_EQ(true, isReleased);
801
802 AudioCapturerParams getCapturerParams;
803 ret = audioCapturer->GetParams(getCapturerParams);
804 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
805 }
806
807 /**
808 * @tc.name : Test GetParams API via legal state, CAPTURER_STOPPED: GetParams after Stop.
809 * @tc.number: Audio_Capturer_GetParams_005
810 * @tc.desc : Test GetParams interface. Returns 0 {SUCCESS}, if the getting is successful.
811 */
812 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_005, TestSize.Level1)
813 {
814 int32_t ret = -1;
815 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
816 ASSERT_NE(nullptr, audioCapturer);
817
818 ret = AudioCapturerUnitTest::InitializeCapturer(audioCapturer);
819 EXPECT_EQ(SUCCESS, ret);
820
821 bool isStarted = audioCapturer->Start();
822 EXPECT_EQ(true, isStarted);
823
824 bool isStopped = audioCapturer->Stop();
825 EXPECT_EQ(true, isStopped);
826
827 AudioCapturerParams getCapturerParams;
828 ret = audioCapturer->GetParams(getCapturerParams);
829 EXPECT_EQ(SUCCESS, ret);
830
831 audioCapturer->Release();
832 }
833
834 /**
835 * @tc.name : Test GetParams API stability.
836 * @tc.number: Audio_Capturer_GetParams_Stability_001
837 * @tc.desc : Test GetParams interface stability.
838 */
839 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetParams_Stability_001, TestSize.Level1)
840 {
841 int32_t ret = -1;
842 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
843 ASSERT_NE(nullptr, audioCapturer);
844
845 AudioCapturerParams capturerParams;
846 capturerParams.audioSampleFormat = SAMPLE_S16LE;
847 capturerParams.samplingRate = SAMPLE_RATE_44100;
848 capturerParams.audioChannel = MONO;
849 capturerParams.audioEncoding = ENCODING_PCM;
850
851 ret = audioCapturer->SetParams(capturerParams);
852 EXPECT_EQ(SUCCESS, ret);
853
854 for (int i = 0; i < VALUE_THOUSAND; i++) {
855 AudioCapturerParams getCapturerParams;
856 ret = audioCapturer->GetParams(getCapturerParams);
857 EXPECT_EQ(SUCCESS, ret);
858 }
859
860 audioCapturer->Release();
861 }
862
863 /**
864 * @tc.name : Test GetParams API stability.
865 * @tc.number: Audio_Capturer_GetParams_Stability_001
866 * @tc.desc : Test GetParams interface stability.
867 */
868 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioStreamId_001, TestSize.Level1)
869 {
870 int32_t ret = -1;
871 AudioCapturerOptions capturerOptions;
872
873 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
874 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
875 ASSERT_NE(nullptr, audioCapturer);
876
877 uint32_t sessionID;
878 ret = audioCapturer->GetAudioStreamId(sessionID);
879 EXPECT_EQ(SUCCESS, ret);
880
881 audioCapturer->Release();
882 }
883
884 /**
885 * @tc.name : Test GetBufferSize API via legal input.
886 * @tc.number: Audio_Capturer_GetBufferSize_001
887 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
888 */
889 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetBufferSize_001, TestSize.Level1)
890 {
891 int32_t ret = -1;
892 AudioCapturerOptions capturerOptions;
893
894 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
895 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
896 ASSERT_NE(nullptr, audioCapturer);
897
898 size_t bufferLen;
899 ret = audioCapturer->GetBufferSize(bufferLen);
900 EXPECT_EQ(SUCCESS, ret);
901
902 audioCapturer->Release();
903 }
904
905 /**
906 * @tc.name : Test GetBufferSize API via illegal state, CAPTURER_NEW: without initializing the capturer.
907 * @tc.number: Audio_Capturer_GetBufferSize_002
908 * @tc.desc : Test GetBufferSize interface. Returns error code, if the capturer state is CAPTURER_NEW.
909 */
910 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetBufferSize_002, TestSize.Level1)
911 {
912 int32_t ret = -1;
913 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
914 ASSERT_NE(nullptr, audioCapturer);
915
916 size_t bufferLen;
917 ret = audioCapturer->GetBufferSize(bufferLen);
918 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
919 }
920
921 /**
922 * @tc.name : Test GetBufferSize API via illegal state, CAPTURER_RELEASED: call Release before GetBufferSize
923 * @tc.number: Audio_Capturer_GetBufferSize_003
924 * @tc.desc : Test GetBufferSize interface. Returns error code, if the capturer state is CAPTURER_RELEASED.
925 */
926 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetBufferSize_003, TestSize.Level1)
927 {
928 int32_t ret = -1;
929 AudioCapturerOptions capturerOptions;
930
931 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
932 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
933 ASSERT_NE(nullptr, audioCapturer);
934
935 bool isReleased = audioCapturer->Release();
936 EXPECT_EQ(true, isReleased);
937
938 size_t bufferLen;
939 ret = audioCapturer->GetBufferSize(bufferLen);
940 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
941 }
942
943 /**
944 * @tc.name : Test GetBufferSize API via legal state, CAPTURER_STOPPED: call Stop before GetBufferSize
945 * @tc.number: Audio_Capturer_GetBufferSize_004
946 * @tc.desc : Test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
947 */
948 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetBufferSize_004, TestSize.Level1)
949 {
950 int32_t ret = -1;
951 AudioCapturerOptions capturerOptions;
952
953 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
954 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
955 ASSERT_NE(nullptr, audioCapturer);
956
957 bool isStarted = audioCapturer->Start();
958 EXPECT_EQ(true, isStarted);
959
960 bool isStopped = audioCapturer->Stop();
961 EXPECT_EQ(true, isStopped);
962
963 size_t bufferLen;
964 ret = audioCapturer->GetBufferSize(bufferLen);
965 EXPECT_EQ(SUCCESS, ret);
966
967 audioCapturer->Release();
968 }
969
970 /**
971 * @tc.name : Test GetBufferSize API via legal state, CAPTURER_RUNNING: call Start before GetBufferSize
972 * @tc.number: Audio_Capturer_GetBufferSize_005
973 * @tc.desc : test GetBufferSize interface. Returns 0 {SUCCESS}, if the getting is successful.
974 */
975 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetBufferSize_005, TestSize.Level1)
976 {
977 int32_t ret = -1;
978 AudioCapturerOptions capturerOptions;
979
980 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
981 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
982 ASSERT_NE(nullptr, audioCapturer);
983
984 bool isStarted = audioCapturer->Start();
985 EXPECT_EQ(true, isStarted);
986
987 size_t bufferLen;
988 ret = audioCapturer->GetBufferSize(bufferLen);
989 EXPECT_EQ(SUCCESS, ret);
990
991 audioCapturer->Release();
992 }
993
994 /**
995 * @tc.name : Test GetFrameCount API via legal input.
996 * @tc.number: Audio_Capturer_GetFrameCount_001
997 * @tc.desc : test GetFrameCount interface, Returns 0 {SUCCESS}, if the getting is successful.
998 */
999 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetFrameCount_001, TestSize.Level1)
1000 {
1001 int32_t ret = -1;
1002 AudioCapturerOptions capturerOptions;
1003
1004 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1005 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1006 ASSERT_NE(nullptr, audioCapturer);
1007
1008 uint32_t frameCount;
1009 ret = audioCapturer->GetFrameCount(frameCount);
1010 EXPECT_EQ(SUCCESS, ret);
1011
1012 audioCapturer->Release();
1013 }
1014
1015 /**
1016 * @tc.name : Test GetFrameCount API via illegal state, CAPTURER_NEW: without initialiing the capturer.
1017 * @tc.number: Audio_Capturer_GetFrameCount_002
1018 * @tc.desc : Test GetFrameCount interface. Returns error code, if the capturer state is CAPTURER_NEW.
1019 */
1020 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetFrameCount_002, TestSize.Level1)
1021 {
1022 int32_t ret = -1;
1023 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1024 ASSERT_NE(nullptr, audioCapturer);
1025
1026 uint32_t frameCount;
1027 ret = audioCapturer->GetFrameCount(frameCount);
1028 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1029 }
1030
1031 /**
1032 * @tc.name : Test GetFrameCount API via legal state, CAPTURER_RUNNING: call Start before GetFrameCount.
1033 * @tc.number: Audio_Capturer_GetFrameCount_003
1034 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1035 */
1036 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetFrameCount_003, TestSize.Level1)
1037 {
1038 int32_t ret = -1;
1039 AudioCapturerOptions capturerOptions;
1040
1041 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1042 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1043 ASSERT_NE(nullptr, audioCapturer);
1044
1045 bool isStarted = audioCapturer->Start();
1046 EXPECT_EQ(true, isStarted);
1047
1048 uint32_t frameCount;
1049 ret = audioCapturer->GetFrameCount(frameCount);
1050 EXPECT_EQ(SUCCESS, ret);
1051
1052 audioCapturer->Release();
1053 }
1054
1055 /**
1056 * @tc.name : Test GetFrameCount API via legal state, CAPTURER_STOPPED: call Stop before GetFrameCount
1057 * @tc.number: Audio_Capturer_GetFrameCount_004
1058 * @tc.desc : Test GetFrameCount interface. Returns 0 {SUCCESS}, if the getting is successful.
1059 */
1060 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetFrameCount_004, TestSize.Level1)
1061 {
1062 int32_t ret = -1;
1063 AudioCapturerOptions capturerOptions;
1064
1065 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1066 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1067 ASSERT_NE(nullptr, audioCapturer);
1068
1069 bool isStarted = audioCapturer->Start();
1070 EXPECT_EQ(true, isStarted);
1071
1072 bool isStopped = audioCapturer->Stop();
1073 EXPECT_EQ(true, isStopped);
1074
1075 uint32_t frameCount;
1076 ret = audioCapturer->GetFrameCount(frameCount);
1077 EXPECT_EQ(SUCCESS, ret);
1078
1079 audioCapturer->Release();
1080 }
1081
1082 /**
1083 * @tc.name : Test GetFrameCount API via illegal state, CAPTURER_RELEASED: call Release before GetFrameCount
1084 * @tc.number: Audio_Capturer_GetFrameCount_005
1085 * @tc.desc : Test GetFrameCount interface. Returns error code, if the state is CAPTURER_RELEASED.
1086 */
1087 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetFrameCount_005, TestSize.Level1)
1088 {
1089 int32_t ret = -1;
1090 AudioCapturerOptions capturerOptions;
1091
1092 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1093 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1094 ASSERT_NE(nullptr, audioCapturer);
1095
1096 bool isReleased = audioCapturer->Release();
1097 EXPECT_EQ(true, isReleased);
1098
1099 uint32_t frameCount;
1100 ret = audioCapturer->GetFrameCount(frameCount);
1101 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1102 }
1103
1104 /**
1105 * @tc.name : Test Start API via legal state, CAPTURER_PREPARED.
1106 * @tc.number: Audio_Capturer_Start_001
1107 * @tc.desc : Test Start interface. Returns true if start is successful.
1108 */
1109 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Start_001, TestSize.Level1)
1110 {
1111 AudioCapturerOptions capturerOptions;
1112
1113 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1114 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1115 ASSERT_NE(nullptr, audioCapturer);
1116
1117 bool isStarted = audioCapturer->Start();
1118 EXPECT_EQ(true, isStarted);
1119
1120 audioCapturer->Release();
1121 }
1122
1123 /**
1124 * @tc.name : Test Start API via illegal state, CAPTURER_NEW: without initializing the capturer.
1125 * @tc.number: Audio_Capturer_Start_002
1126 * @tc.desc : Test Start interface. Returns false, if the capturer state is CAPTURER_NEW.
1127 */
1128 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Start_002, TestSize.Level1)
1129 {
1130 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1131 ASSERT_NE(nullptr, audioCapturer);
1132
1133 bool isStarted = audioCapturer->Start();
1134 EXPECT_EQ(false, isStarted);
1135 }
1136
1137 /**
1138 * @tc.name : Test Start API via illegal state, CAPTURER_RELEASED: call Start after Release
1139 * @tc.number: Audio_Capturer_Start_003
1140 * @tc.desc : Test Start interface. Returns false, if the capturer state is CAPTURER_RELEASED.
1141 */
1142 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Start_003, TestSize.Level1)
1143 {
1144 AudioCapturerOptions capturerOptions;
1145
1146 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1147 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1148 ASSERT_NE(nullptr, audioCapturer);
1149
1150 bool isReleased = audioCapturer->Release();
1151 EXPECT_EQ(true, isReleased);
1152
1153 bool isStarted = audioCapturer->Start();
1154 EXPECT_EQ(false, isStarted);
1155
1156 audioCapturer->Release();
1157 }
1158
1159 /**
1160 * @tc.name : Test Start API via legal state, CAPTURER_STOPPED: Start Stop and then Start again
1161 * @tc.number: Audio_Capturer_Start_004
1162 * @tc.desc : Test Start interface. Returns true, if the start is successful.
1163 */
1164 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Start_004, TestSize.Level1)
1165 {
1166 AudioCapturerOptions capturerOptions;
1167
1168 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1169 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1170 ASSERT_NE(nullptr, audioCapturer);
1171
1172 bool isStarted = audioCapturer->Start();
1173 EXPECT_EQ(true, isStarted);
1174
1175 bool isStopped = audioCapturer->Stop();
1176 EXPECT_EQ(true, isStopped);
1177
1178 isStarted = audioCapturer->Start();
1179 EXPECT_EQ(true, isStarted);
1180
1181 audioCapturer->Release();
1182 }
1183
1184 /**
1185 * @tc.name : Test Start API via illegal state, CAPTURER_RUNNING : call Start repeatedly
1186 * @tc.number: Audio_Capturer_Start_005
1187 * @tc.desc : Test Start interface. Returns false, if the capturer state is CAPTURER_RUNNING.
1188 */
1189 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Start_005, TestSize.Level1)
1190 {
1191 AudioCapturerOptions capturerOptions;
1192
1193 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1194 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1195 ASSERT_NE(nullptr, audioCapturer);
1196
1197 bool isStarted = audioCapturer->Start();
1198 EXPECT_EQ(true, isStarted);
1199
1200 isStarted = audioCapturer->Start();
1201 EXPECT_EQ(false, isStarted);
1202
1203 audioCapturer->Release();
1204 }
1205
1206 /**
1207 * @tc.name : Test Read API via isBlockingRead = true.
1208 * @tc.number: Audio_Capturer_Read_001
1209 * @tc.desc : Test Read interface. Returns number of bytes read, if the read is successful.
1210 */
1211 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_001, TestSize.Level1)
1212 {
1213 int32_t ret = -1;
1214 bool isBlockingRead = true;
1215 AudioCapturerOptions capturerOptions;
1216
1217 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1218 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1219 ASSERT_NE(nullptr, audioCapturer);
1220
1221 bool isStarted = audioCapturer->Start();
1222 EXPECT_EQ(true, isStarted);
1223
1224 size_t bufferLen;
1225 ret = audioCapturer->GetBufferSize(bufferLen);
1226 EXPECT_EQ(SUCCESS, ret);
1227
1228 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1229 ASSERT_NE(nullptr, buffer);
1230 FILE *capFile = fopen(AUDIO_CAPTURE_FILE1.c_str(), "wb");
1231 ASSERT_NE(nullptr, capFile);
1232
1233 size_t size = 1;
1234 int32_t bytesRead = 0;
1235 int32_t numBuffersToCapture = READ_BUFFERS_COUNT;
1236
1237 while (numBuffersToCapture) {
1238 bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1239 if (bytesRead <= 0) {
1240 break;
1241 } else if (bytesRead > 0) {
1242 fwrite(buffer, size, bytesRead, capFile);
1243 numBuffersToCapture--;
1244 }
1245 }
1246
1247 audioCapturer->Flush();
1248 audioCapturer->Stop();
1249 audioCapturer->Release();
1250
1251 free(buffer);
1252 fclose(capFile);
1253 }
1254
1255 /**
1256 * @tc.name : Test Read API via isBlockingRead = false.
1257 * @tc.number: Audio_Capturer_Read_002
1258 * @tc.desc : Test Read interface. Returns number of bytes read, if the read is successful.
1259 */
1260 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_002, TestSize.Level1)
1261 {
1262 int32_t ret = -1;
1263 bool isBlockingRead = false;
1264 AudioCapturerOptions capturerOptions;
1265
1266 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1267 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1268 ASSERT_NE(nullptr, audioCapturer);
1269
1270 bool isStarted = audioCapturer->Start();
1271 EXPECT_EQ(true, isStarted);
1272
1273 size_t bufferLen;
1274 ret = audioCapturer->GetBufferSize(bufferLen);
1275 EXPECT_EQ(SUCCESS, ret);
1276
1277 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1278 ASSERT_NE(nullptr, buffer);
1279 FILE *capFile = fopen(AUDIO_CAPTURE_FILE2.c_str(), "wb");
1280 ASSERT_NE(nullptr, capFile);
1281
1282 size_t size = 1;
1283 int32_t bytesRead = 0;
1284 int32_t numBuffersToCapture = READ_BUFFERS_COUNT;
1285
1286 while (numBuffersToCapture) {
1287 bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1288 if (bytesRead <= 0) {
1289 break;
1290 } else if (bytesRead > 0) {
1291 fwrite(buffer, size, bytesRead, capFile);
1292 numBuffersToCapture--;
1293 }
1294 }
1295
1296 audioCapturer->Flush();
1297 audioCapturer->Stop();
1298 audioCapturer->Release();
1299
1300 free(buffer);
1301 fclose(capFile);
1302 }
1303
1304 /**
1305 * @tc.name : Test Read API via illegl state, CAPTURER_NEW : without Initializing the capturer.
1306 * @tc.number: Audio_Capturer_Read_003
1307 * @tc.desc : Test Read interface. Returns error code, if the capturer state is CAPTURER_NEW.
1308 * : bufferLen is invalid here, firstly bufferLen is validated in Read. So it returns ERR_INVALID_PARAM.
1309 */
1310 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_003, TestSize.Level1)
1311 {
1312 int32_t ret = -1;
1313 bool isBlockingRead = true;
1314 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1315 ASSERT_NE(nullptr, audioCapturer);
1316
1317 bool isStarted = audioCapturer->Start();
1318 EXPECT_EQ(false, isStarted);
1319
1320 size_t bufferLen;
1321 ret = audioCapturer->GetBufferSize(bufferLen);
1322 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
1323
1324 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1325 ASSERT_NE(nullptr, buffer);
1326
1327 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1328 EXPECT_EQ(ERR_INVALID_PARAM, bytesRead);
1329
1330 audioCapturer->Flush();
1331 audioCapturer->Stop();
1332 audioCapturer->Release();
1333
1334 free(buffer);
1335 }
1336
1337 /**
1338 * @tc.name : Test Read API via illegl state, CAPTURER_PREPARED : Read without Start.
1339 * @tc.number: Audio_Capturer_Read_004
1340 * @tc.desc : Test Read interface. Returns error code, if the capturer state is not CAPTURER_RUNNING.
1341 */
1342 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_004, TestSize.Level1)
1343 {
1344 int32_t ret = -1;
1345 bool isBlockingRead = true;
1346 AudioCapturerOptions capturerOptions;
1347
1348 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1349 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1350 ASSERT_NE(nullptr, audioCapturer);
1351
1352 size_t bufferLen;
1353 ret = audioCapturer->GetBufferSize(bufferLen);
1354 EXPECT_EQ(SUCCESS, ret);
1355
1356 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1357 ASSERT_NE(nullptr, buffer);
1358
1359 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1360 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesRead);
1361
1362 audioCapturer->Flush();
1363 audioCapturer->Stop();
1364 audioCapturer->Release();
1365
1366 free(buffer);
1367 }
1368
1369 /**
1370 * @tc.name : Test Read API via illegal input, bufferLength = 0.
1371 * @tc.number: Audio_Capturer_Read_005
1372 * @tc.desc : Test Read interface. Returns error code, if the bufferLength <= 0.
1373 */
1374 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_005, TestSize.Level1)
1375 {
1376 bool isBlockingRead = true;
1377 AudioCapturerOptions capturerOptions;
1378
1379 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1380 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1381 ASSERT_NE(nullptr, audioCapturer);
1382
1383 bool isStarted = audioCapturer->Start();
1384 EXPECT_EQ(true, isStarted);
1385
1386 size_t bufferLen = 0;
1387
1388 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1389 ASSERT_NE(nullptr, buffer);
1390
1391 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1392 EXPECT_EQ(ERR_INVALID_PARAM, bytesRead);
1393
1394 audioCapturer->Flush();
1395 audioCapturer->Stop();
1396 audioCapturer->Release();
1397
1398 free(buffer);
1399 }
1400
1401 /**
1402 * @tc.name : Test Read API via illegal state, CAPTURER_STOPPED: Read after Stop.
1403 * @tc.number: Audio_Capturer_Read_006
1404 * @tc.desc : Test Read interface. Returns error code, if the capturer state is not CAPTURER_RUNNING.
1405 */
1406 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_006, TestSize.Level1)
1407 {
1408 int32_t ret = -1;
1409 bool isBlockingRead = true;
1410 AudioCapturerOptions capturerOptions;
1411
1412 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1413 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1414 ASSERT_NE(nullptr, audioCapturer);
1415
1416 bool isStarted = audioCapturer->Start();
1417 EXPECT_EQ(true, isStarted);
1418
1419 size_t bufferLen;
1420 ret = audioCapturer->GetBufferSize(bufferLen);
1421 EXPECT_EQ(SUCCESS, ret);
1422
1423 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1424 ASSERT_NE(nullptr, buffer);
1425
1426 bool isStopped = audioCapturer->Stop();
1427 EXPECT_EQ(true, isStopped);
1428
1429 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1430 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesRead);
1431
1432 audioCapturer->Release();
1433
1434 free(buffer);
1435 }
1436
1437 /**
1438 * @tc.name : Test Read API via illegal state, CAPTURER_RELEASED: Read after Release.
1439 * @tc.number: Audio_Capturer_Read_007
1440 * @tc.desc : Test Read interface. Returns error code, if the capturer state is not CAPTURER_RUNNING.
1441 */
1442 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Read_007, TestSize.Level1)
1443 {
1444 int32_t ret = -1;
1445 bool isBlockingRead = true;
1446 AudioCapturerOptions capturerOptions;
1447
1448 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1449 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1450 ASSERT_NE(nullptr, audioCapturer);
1451
1452 bool isStarted = audioCapturer->Start();
1453 EXPECT_EQ(true, isStarted);
1454
1455 size_t bufferLen;
1456 ret = audioCapturer->GetBufferSize(bufferLen);
1457 EXPECT_EQ(SUCCESS, ret);
1458
1459 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1460 ASSERT_NE(nullptr, buffer);
1461
1462 bool isReleased = audioCapturer->Release();
1463 EXPECT_EQ(true, isReleased);
1464
1465 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1466 EXPECT_EQ(ERR_ILLEGAL_STATE, bytesRead);
1467
1468 free(buffer);
1469 }
1470
1471 /**
1472 * @tc.name : Test GetAudioTime API via legal input.
1473 * @tc.number: Audio_Capturer_GetAudioTime_001
1474 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
1475 */
1476 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_001, TestSize.Level1)
1477 {
1478 int32_t ret = -1;
1479 bool isBlockingRead = true;
1480 AudioCapturerOptions capturerOptions;
1481
1482 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1483 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1484 ASSERT_NE(nullptr, audioCapturer);
1485
1486 bool isStarted = audioCapturer->Start();
1487 EXPECT_EQ(true, isStarted);
1488
1489 size_t bufferLen;
1490 ret = audioCapturer->GetBufferSize(bufferLen);
1491 EXPECT_EQ(SUCCESS, ret);
1492
1493 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1494 ASSERT_NE(nullptr, buffer);
1495 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1496 EXPECT_GE(bytesRead, VALUE_ZERO);
1497
1498 Timestamp timeStamp;
1499 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1500 EXPECT_EQ(true, getAudioTime);
1501 EXPECT_GE(timeStamp.time.tv_sec, (const long)VALUE_ZERO);
1502 EXPECT_GE(timeStamp.time.tv_nsec, (const long)VALUE_ZERO);
1503
1504 audioCapturer->Flush();
1505 audioCapturer->Stop();
1506 audioCapturer->Release();
1507
1508 free(buffer);
1509 }
1510
1511 /**
1512 * @tc.name : Test GetAudioTime API via illegal state, CAPTURER_NEW: GetAudioTime without initializing the capturer.
1513 * @tc.number: Audio_Capturer_GetAudioTime_002
1514 * @tc.desc : Test GetAudioTime interface. Returns false, if the capturer state is CAPTURER_NEW.
1515 */
1516 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_002, TestSize.Level1)
1517 {
1518 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1519 ASSERT_NE(nullptr, audioCapturer);
1520
1521 Timestamp timeStamp;
1522 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1523 EXPECT_EQ(false, getAudioTime);
1524 }
1525
1526 /**
1527 * @tc.name : Test GetAudioTime API via legal state, CAPTURER_RUNNING.
1528 * @tc.number: Audio_Capturer_GetAudioTime_003
1529 * @tc.desc : test GetAudioTime interface. Returns true, if the getting is successful.
1530 */
1531 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_003, TestSize.Level1)
1532 {
1533 AudioCapturerOptions capturerOptions;
1534
1535 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1536 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1537 ASSERT_NE(nullptr, audioCapturer);
1538
1539 bool isStarted = audioCapturer->Start();
1540 EXPECT_EQ(true, isStarted);
1541
1542 Timestamp timeStamp;
1543 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1544 EXPECT_EQ(true, getAudioTime);
1545
1546 audioCapturer->Release();
1547 }
1548
1549 /**
1550 * @tc.name : Test GetAudioTime API via legal state, CAPTURER_STOPPED.
1551 * @tc.number: Audio_Capturer_GetAudioTime_004
1552 * @tc.desc : Test GetAudioTime interface. Returns true, if the getting is successful.
1553 */
1554 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_004, TestSize.Level1)
1555 {
1556 AudioCapturerOptions capturerOptions;
1557
1558 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1559 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1560 ASSERT_NE(nullptr, audioCapturer);
1561
1562 bool isStarted = audioCapturer->Start();
1563 EXPECT_EQ(true, isStarted);
1564
1565 bool isStopped = audioCapturer->Stop();
1566 EXPECT_EQ(true, isStopped);
1567
1568 Timestamp timeStamp;
1569 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1570 EXPECT_EQ(false, getAudioTime);
1571
1572 audioCapturer->Release();
1573 }
1574
1575 /**
1576 * @tc.name : Test GetAudioTime API via illegal state, CAPTURER_RELEASED: GetAudioTime after Release.
1577 * @tc.number: Audio_Capturer_GetAudioTime_005
1578 * @tc.desc : Test GetAudioTime interface. Returns false, if the capturer state is CAPTURER_RELEASED
1579 */
1580 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_005, TestSize.Level1)
1581 {
1582 AudioCapturerOptions capturerOptions;
1583
1584 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1585 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1586 ASSERT_NE(nullptr, audioCapturer);
1587
1588 bool isStarted = audioCapturer->Start();
1589 EXPECT_EQ(true, isStarted);
1590
1591 bool isStopped = audioCapturer->Stop();
1592 EXPECT_EQ(true, isStopped);
1593
1594 bool isReleased = audioCapturer->Release();
1595 EXPECT_EQ(true, isReleased);
1596
1597 Timestamp timeStamp;
1598 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1599 EXPECT_EQ(false, getAudioTime);
1600 }
1601
1602 /**
1603 * @tc.name : Test GetAudioTime API stability.
1604 * @tc.number: Audio_Capturer_GetAudioTime_Stability_001
1605 * @tc.desc : Test GetAudioTime interface stability.
1606 */
1607 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetAudioTime_Stability_001, TestSize.Level1)
1608 {
1609 AudioCapturerOptions capturerOptions;
1610
1611 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1612 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1613 ASSERT_NE(nullptr, audioCapturer);
1614
1615 bool isStarted = audioCapturer->Start();
1616 EXPECT_EQ(true, isStarted);
1617
1618 thread captureThread(StartCaptureThread, audioCapturer.get(), AUDIO_TIME_STABILITY_TEST_FILE);
1619
1620 for (int i = 0; i < VALUE_THOUSAND; i++) {
1621 Timestamp timeStamp;
1622 bool getAudioTime = audioCapturer->GetAudioTime(timeStamp, Timestamp::Timestampbase::MONOTONIC);
1623 EXPECT_EQ(true, getAudioTime);
1624 }
1625
1626 captureThread.join();
1627
1628 bool isStopped = audioCapturer->Stop();
1629 EXPECT_EQ(true, isStopped);
1630
1631 bool isReleased = audioCapturer->Release();
1632 EXPECT_EQ(true, isReleased);
1633 }
1634
1635 /**
1636 * @tc.name : Test Flush API.
1637 * @tc.number: Audio_Capturer_Flush_001
1638 * @tc.desc : Test Flush interface. Returns true, if the flush is successful.
1639 */
1640 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_001, TestSize.Level1)
1641 {
1642 int32_t ret = -1;
1643 bool isBlockingRead = true;
1644 AudioCapturerOptions capturerOptions;
1645
1646 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1647 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1648 ASSERT_NE(nullptr, audioCapturer);
1649
1650 bool isStarted = audioCapturer->Start();
1651 EXPECT_EQ(true, isStarted);
1652
1653 size_t bufferLen;
1654 ret = audioCapturer->GetBufferSize(bufferLen);
1655 EXPECT_EQ(SUCCESS, ret);
1656
1657 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1658 ASSERT_NE(nullptr, buffer);
1659
1660 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1661 EXPECT_GE(bytesRead, VALUE_ZERO);
1662
1663 bool isFlushed = audioCapturer->Flush();
1664 EXPECT_EQ(true, isFlushed);
1665
1666 audioCapturer->Stop();
1667 audioCapturer->Release();
1668
1669 free(buffer);
1670 }
1671
1672 /**
1673 * @tc.name : Test Flush API via illegal state, CAPTURER_NEW: Without initializing the capturer.
1674 * @tc.number: Audio_Capturer_Flush_002
1675 * @tc.desc : Test Flush interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1676 */
1677 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_002, TestSize.Level1)
1678 {
1679 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1680 ASSERT_NE(nullptr, audioCapturer);
1681
1682 bool isFlushed = audioCapturer->Flush();
1683 EXPECT_EQ(false, isFlushed);
1684
1685 audioCapturer->Release();
1686 }
1687
1688 /**
1689 * @tc.name : Test Flush API via illegal state, CAPTURER_PREPARED: Without Start.
1690 * @tc.number: Audio_Capturer_Flush_003
1691 * @tc.desc : Test Flush interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1692 */
1693 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_003, TestSize.Level1)
1694 {
1695 AudioCapturerOptions capturerOptions;
1696
1697 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1698 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1699 ASSERT_NE(nullptr, audioCapturer);
1700
1701 bool isFlushed = audioCapturer->Flush();
1702 EXPECT_EQ(false, isFlushed);
1703
1704 audioCapturer->Release();
1705 }
1706
1707 /**
1708 * @tc.name : Test Flush API: call Stop before Flush.
1709 * @tc.number: Audio_Capturer_Flush_004
1710 * @tc.desc : Test Flush interface. Returns true, if the capturer state is CAPTURER_STOPPED.
1711 */
1712 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_004, TestSize.Level1)
1713 {
1714 AudioCapturerOptions capturerOptions;
1715
1716 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1717 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1718 ASSERT_NE(nullptr, audioCapturer);
1719
1720 bool isStarted = audioCapturer->Start();
1721 EXPECT_EQ(true, isStarted);
1722
1723 bool isStopped = audioCapturer->Stop();
1724 EXPECT_EQ(true, isStopped);
1725
1726 bool isFlushed = audioCapturer->Flush();
1727 EXPECT_EQ(true, isFlushed);
1728
1729 audioCapturer->Release();
1730 }
1731
1732 /**
1733 * @tc.name : Test Flush API via illegal state, CAPTURER_RELEASED: call Release before Flush.
1734 * @tc.number: Audio_Capturer_Flush_005
1735 * @tc.desc : Test Flush interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1736 */
1737 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_005, TestSize.Level1)
1738 {
1739 AudioCapturerOptions capturerOptions;
1740
1741 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1742 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1743 ASSERT_NE(nullptr, audioCapturer);
1744
1745 bool isStarted = audioCapturer->Start();
1746 EXPECT_EQ(true, isStarted);
1747
1748 bool isReleased = audioCapturer->Release();
1749 EXPECT_EQ(true, isReleased);
1750
1751 bool isFlushed = audioCapturer->Flush();
1752 EXPECT_EQ(false, isFlushed);
1753
1754 audioCapturer->Release();
1755 }
1756
1757 /**
1758 * @tc.name : Test Flush API stability.
1759 * @tc.number: Audio_Capturer_Flush_Stability_001
1760 * @tc.desc : Test Flush interface stability.
1761 */
1762 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Flush_Stability_001, TestSize.Level1)
1763 {
1764 AudioCapturerOptions capturerOptions;
1765
1766 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1767 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1768 ASSERT_NE(nullptr, audioCapturer);
1769
1770 bool isStarted = audioCapturer->Start();
1771 EXPECT_EQ(true, isStarted);
1772
1773 thread captureThread(StartCaptureThread, audioCapturer.get(), AUDIO_FLUSH_STABILITY_TEST_FILE);
1774
1775 for (int i = 0; i < VALUE_HUNDRED; i++) {
1776 bool isFlushed = audioCapturer->Flush();
1777 EXPECT_EQ(true, isFlushed);
1778 }
1779
1780 captureThread.join();
1781
1782 bool isStopped = audioCapturer->Stop();
1783 EXPECT_EQ(true, isStopped);
1784
1785 bool isReleased = audioCapturer->Release();
1786 EXPECT_EQ(true, isReleased);
1787 }
1788
1789 /**
1790 * @tc.name : Test Stop API.
1791 * @tc.number: Audio_Capturer_Stop_001
1792 * @tc.desc : Test Stop interface. Returns true, if the stop is successful.
1793 */
1794 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Stop_001, TestSize.Level1)
1795 {
1796 int32_t ret = -1;
1797 bool isBlockingRead = true;
1798 AudioCapturerOptions capturerOptions;
1799
1800 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1801 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1802 ASSERT_NE(nullptr, audioCapturer);
1803
1804 bool isStarted = audioCapturer->Start();
1805 EXPECT_EQ(true, isStarted);
1806
1807 size_t bufferLen;
1808 ret = audioCapturer->GetBufferSize(bufferLen);
1809 EXPECT_EQ(SUCCESS, ret);
1810
1811 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1812 ASSERT_NE(nullptr, buffer);
1813
1814 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1815 EXPECT_GE(bytesRead, VALUE_ZERO);
1816
1817 audioCapturer->Flush();
1818
1819 bool isStopped = audioCapturer->Stop();
1820 EXPECT_EQ(true, isStopped);
1821
1822 audioCapturer->Release();
1823
1824 free(buffer);
1825 }
1826
1827 /**
1828 * @tc.name : Test Stop API via illegal state, CAPTURER_NEW: call Stop without Initializing the capturer.
1829 * @tc.number: Audio_Capturer_Stop_002
1830 * @tc.desc : Test Stop interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1831 */
1832 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Stop_002, TestSize.Level1)
1833 {
1834 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1835 ASSERT_NE(nullptr, audioCapturer);
1836
1837 bool isStopped = audioCapturer->Stop();
1838 EXPECT_EQ(false, isStopped);
1839 }
1840
1841 /**
1842 * @tc.name : Test Stop API via illegal state, CAPTURER_PREPARED: call Stop without Start.
1843 * @tc.number: Audio_Capturer_Stop_003
1844 * @tc.desc : Test Stop interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1845 */
1846 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Stop_003, TestSize.Level1)
1847 {
1848 AudioCapturerOptions capturerOptions;
1849
1850 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1851 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1852 ASSERT_NE(nullptr, audioCapturer);
1853
1854 bool isStopped = audioCapturer->Stop();
1855 EXPECT_EQ(false, isStopped);
1856
1857 audioCapturer->Release();
1858 }
1859
1860 /**
1861 * @tc.name : Test Stop API via illegal state, CAPTURER_RELEASED: call Stop after Release.
1862 * @tc.number: Audio_Capturer_Stop_004
1863 * @tc.desc : Test Stop interface. Returns false, if the capturer state is not CAPTURER_RUNNING.
1864 */
1865 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Stop_004, TestSize.Level1)
1866 {
1867 AudioCapturerOptions capturerOptions;
1868
1869 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1870 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1871 ASSERT_NE(nullptr, audioCapturer);
1872
1873 bool isStarted = audioCapturer->Start();
1874 EXPECT_EQ(true, isStarted);
1875
1876 bool isReleased = audioCapturer->Release();
1877 EXPECT_EQ(true, isReleased);
1878
1879 bool isStopped = audioCapturer->Stop();
1880 EXPECT_EQ(false, isStopped);
1881 }
1882
1883 /**
1884 * @tc.name : Test Stop API via legal state. call Start, Stop, Start and Stop again
1885 * @tc.number: Audio_Capturer_Stop_005
1886 * @tc.desc : Test Stop interface. Returns true , if the stop is successful.
1887 */
1888 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Stop_005, TestSize.Level1)
1889 {
1890 AudioCapturerOptions capturerOptions;
1891
1892 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1893 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1894 ASSERT_NE(nullptr, audioCapturer);
1895
1896 bool isStarted = audioCapturer->Start();
1897 EXPECT_EQ(true, isStarted);
1898
1899 bool isStopped = audioCapturer->Stop();
1900 EXPECT_EQ(true, isStopped);
1901
1902 isStarted = audioCapturer->Start();
1903 EXPECT_EQ(true, isStarted);
1904
1905 isStopped = audioCapturer->Stop();
1906 EXPECT_EQ(true, isStopped);
1907 audioCapturer->Release();
1908 }
1909
1910 /**
1911 * @tc.name : Test Release API.
1912 * @tc.number: Audio_Capturer_Release_001
1913 * @tc.desc : Test Release interface. Returns true, if the release is successful.
1914 */
1915 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Release_001, TestSize.Level1)
1916 {
1917 int32_t ret = -1;
1918 bool isBlockingRead = true;
1919 AudioCapturerOptions capturerOptions;
1920
1921 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1922 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1923 ASSERT_NE(nullptr, audioCapturer);
1924
1925 bool isStarted = audioCapturer->Start();
1926 EXPECT_EQ(true, isStarted);
1927
1928 size_t bufferLen;
1929 ret = audioCapturer->GetBufferSize(bufferLen);
1930 EXPECT_EQ(SUCCESS, ret);
1931
1932 uint8_t *buffer = (uint8_t *) malloc(bufferLen);
1933 ASSERT_NE(nullptr, buffer);
1934
1935 int32_t bytesRead = audioCapturer->Read(*buffer, bufferLen, isBlockingRead);
1936 EXPECT_GE(bytesRead, VALUE_ZERO);
1937
1938 audioCapturer->Flush();
1939 audioCapturer->Stop();
1940
1941 bool isReleased = audioCapturer->Release();
1942 EXPECT_EQ(true, isReleased);
1943
1944 free(buffer);
1945 }
1946
1947 /**
1948 * @tc.name : Test Release API via illegal state, CAPTURER_NEW: Call Release without initializing the capturer.
1949 * @tc.number: Audio_Capturer_Release_002
1950 * @tc.desc : Test Release interface, Returns false, if the state is CAPTURER_NEW.
1951 */
1952 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Release_002, TestSize.Level1)
1953 {
1954 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
1955 ASSERT_NE(nullptr, audioCapturer);
1956
1957 bool isReleased = audioCapturer->Release();
1958 EXPECT_EQ(false, isReleased);
1959 }
1960
1961 /**
1962 * @tc.name : Test Release API via illegal state, CAPTURER_RELEASED: call Release repeatedly.
1963 * @tc.number: Audio_Capturer_Release_003
1964 * @tc.desc : Test Release interface. Returns false, if the state is already CAPTURER_RELEASED.
1965 */
1966 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Release_003, TestSize.Level1)
1967 {
1968 AudioCapturerOptions capturerOptions;
1969
1970 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1971 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1972 ASSERT_NE(nullptr, audioCapturer);
1973
1974 bool isReleased = audioCapturer->Release();
1975 EXPECT_EQ(true, isReleased);
1976
1977 isReleased = audioCapturer->Release();
1978 EXPECT_EQ(false, isReleased);
1979 }
1980
1981 /**
1982 * @tc.name : Test Release API via legal state, CAPTURER_RUNNING: call Release after Start
1983 * @tc.number: Audio_Capturer_Release_004
1984 * @tc.desc : Test Release interface. Returns true, if the release is successful.
1985 */
1986 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Release_004, TestSize.Level1)
1987 {
1988 AudioCapturerOptions capturerOptions;
1989
1990 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
1991 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
1992 ASSERT_NE(nullptr, audioCapturer);
1993
1994 bool isStarted = audioCapturer->Start();
1995 EXPECT_EQ(true, isStarted);
1996
1997 bool isReleased = audioCapturer->Release();
1998 EXPECT_EQ(true, isReleased);
1999 }
2000
2001 /**
2002 * @tc.name : Test Release API via legal state, CAPTURER_STOPPED: call release after Start and Stop
2003 * @tc.number: Audio_Capturer_Release_005
2004 * @tc.desc : Test Release interface. Returns true, if the release is successful.
2005 */
2006 HWTEST(AudioCapturerUnitTest, Audio_Capturer_Release_005, TestSize.Level1)
2007 {
2008 AudioCapturerOptions capturerOptions;
2009
2010 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
2011 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2012 ASSERT_NE(nullptr, audioCapturer);
2013
2014 bool isStarted = audioCapturer->Start();
2015 EXPECT_EQ(true, isStarted);
2016
2017 bool isStopped = audioCapturer->Stop();
2018 EXPECT_EQ(true, isStopped);
2019
2020 bool isReleased = audioCapturer->Release();
2021 EXPECT_EQ(true, isReleased);
2022 }
2023
2024 /**
2025 * @tc.name : Test GetStatus API.
2026 * @tc.number: Audio_Capturer_GetStatus_001
2027 * @tc.desc : Test GetStatus interface. Returns correct state on success.
2028 */
2029 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStatus_001, TestSize.Level1)
2030 {
2031 CapturerState state = CAPTURER_INVALID;
2032 AudioCapturerOptions capturerOptions;
2033
2034 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
2035 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2036 ASSERT_NE(nullptr, audioCapturer);
2037
2038 state = audioCapturer->GetStatus();
2039 EXPECT_EQ(CAPTURER_PREPARED, state);
2040
2041 bool isStarted = audioCapturer->Start();
2042 EXPECT_EQ(true, isStarted);
2043 state = audioCapturer->GetStatus();
2044 EXPECT_EQ(CAPTURER_RUNNING, state);
2045
2046 bool isStopped = audioCapturer->Stop();
2047 EXPECT_EQ(true, isStopped);
2048 state = audioCapturer->GetStatus();
2049 EXPECT_EQ(CAPTURER_STOPPED, state);
2050
2051 bool isReleased = audioCapturer->Release();
2052 EXPECT_EQ(true, isReleased);
2053 state = audioCapturer->GetStatus();
2054 EXPECT_EQ(CAPTURER_RELEASED, state);
2055 }
2056
2057 /**
2058 * @tc.name : Test GetStatus API, call Start without Initializing the capturer
2059 * @tc.number: Audio_Capturer_GetStatus_002
2060 * @tc.desc : Test GetStatus interface. Not changes to CAPTURER_RUNNING, if the current state is CAPTURER_NEW.
2061 */
2062 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStatus_002, TestSize.Level1)
2063 {
2064 CapturerState state = CAPTURER_INVALID;
2065
2066 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2067 ASSERT_NE(nullptr, audioCapturer);
2068
2069 bool isStarted = audioCapturer->Start();
2070 EXPECT_EQ(false, isStarted);
2071 state = audioCapturer->GetStatus();
2072 EXPECT_NE(CAPTURER_RUNNING, state);
2073 EXPECT_EQ(CAPTURER_NEW, state);
2074 }
2075
2076 /**
2077 * @tc.name : Test GetStatus API, call Stop without Start
2078 * @tc.number: Audio_Capturer_GetStatus_003
2079 * @tc.desc : Test GetStatus interface. Not changes to CAPTURER_STOPPED, if the current state is CAPTURER_PREPARED.
2080 */
2081 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStatus_003, TestSize.Level1)
2082 {
2083 CapturerState state = CAPTURER_INVALID;
2084 AudioCapturerOptions capturerOptions;
2085
2086 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
2087 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2088 ASSERT_NE(nullptr, audioCapturer);
2089
2090 bool isStopped = audioCapturer->Stop();
2091 EXPECT_EQ(false, isStopped);
2092 state = audioCapturer->GetStatus();
2093 EXPECT_NE(CAPTURER_STOPPED, state);
2094 EXPECT_EQ(CAPTURER_PREPARED, state);
2095
2096 audioCapturer->Release();
2097 }
2098
2099 /**
2100 * @tc.name : Test GetStatus API, call Start, Stop and then Start again
2101 * @tc.number: Audio_Capturer_GetStatus_004
2102 * @tc.desc : Test GetStatus interface. Returns correct state on success.
2103 */
2104 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStatus_004, TestSize.Level1)
2105 {
2106 CapturerState state = CAPTURER_INVALID;
2107 AudioCapturerOptions capturerOptions;
2108
2109 AudioCapturerUnitTest::InitializeCapturerOptions(capturerOptions);
2110 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2111 ASSERT_NE(nullptr, audioCapturer);
2112
2113 bool isStarted = audioCapturer->Start();
2114 EXPECT_EQ(true, isStarted);
2115 state = audioCapturer->GetStatus();
2116 EXPECT_EQ(CAPTURER_RUNNING, state);
2117
2118 bool isStopped = audioCapturer->Stop();
2119 EXPECT_EQ(true, isStopped);
2120 state = audioCapturer->GetStatus();
2121 EXPECT_EQ(CAPTURER_STOPPED, state);
2122
2123 isStarted = audioCapturer->Start();
2124 EXPECT_EQ(true, isStarted);
2125 state = audioCapturer->GetStatus();
2126 EXPECT_EQ(CAPTURER_RUNNING, state);
2127
2128 audioCapturer->Release();
2129 }
2130
2131 /**
2132 * @tc.name : Test GetStatus API, call Release without initializing
2133 * @tc.number: Audio_Capturer_GetStatus_005
2134 * @tc.desc : Test GetStatus interface. Not changes to CAPTURER_RELEASED, if the current state is CAPTURER_NEW.
2135 */
2136 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStatus_005, TestSize.Level1)
2137 {
2138 CapturerState state = CAPTURER_INVALID;
2139
2140 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2141 ASSERT_NE(nullptr, audioCapturer);
2142
2143 bool isReleased = audioCapturer->Release();
2144 EXPECT_EQ(false, isReleased);
2145 state = audioCapturer->GetStatus();
2146 EXPECT_NE(CAPTURER_RELEASED, state);
2147 EXPECT_EQ(CAPTURER_NEW, state);
2148 }
2149
2150 /**
2151 * @tc.name : Test GetCapturerInfo API after calling create
2152 * @tc.number: Audio_Capturer_GetCapturerInfo_001
2153 * @tc.desc : Test GetCapturerInfo interface. Check whether capturer info returns proper data
2154 */
2155 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCapturerInfo_001, TestSize.Level1)
2156 {
2157 AudioCapturerOptions capturerOptions;
2158 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2159 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2160 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2161 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2162 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2163 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2164
2165 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2166 ASSERT_NE(nullptr, audioCapturer);
2167
2168 AudioCapturerInfo capturerInfo;
2169 audioCapturer->GetCapturerInfo(capturerInfo);
2170
2171 EXPECT_EQ(SourceType::SOURCE_TYPE_MIC, capturerInfo.sourceType);
2172 EXPECT_EQ(CAPTURER_FLAG, capturerInfo.capturerFlags);
2173 audioCapturer->Release();
2174 }
2175
2176 /**
2177 * @tc.name : Test GetCapturerInfo API after calling start
2178 * @tc.number: Audio_Capturer_GetCapturerInfo_002
2179 * @tc.desc : Test GetCapturerInfo interface. Check whether capturer info returns proper data
2180 */
2181 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCapturerInfo_002, TestSize.Level1)
2182 {
2183 AudioCapturerOptions capturerOptions;
2184 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2185 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2186 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2187 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2188 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2189 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2190
2191 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2192 ASSERT_NE(nullptr, audioCapturer);
2193
2194 bool isStarted = audioCapturer->Start();
2195 EXPECT_EQ(true, isStarted);
2196
2197 AudioCapturerInfo capturerInfo;
2198 audioCapturer->GetCapturerInfo(capturerInfo);
2199
2200 EXPECT_EQ(SourceType::SOURCE_TYPE_MIC, capturerInfo.sourceType);
2201 EXPECT_EQ(CAPTURER_FLAG, capturerInfo.capturerFlags);
2202
2203 audioCapturer->Stop();
2204 audioCapturer->Release();
2205 }
2206
2207 /**
2208 * @tc.name : Test GetCapturerInfo API after calling release
2209 * @tc.number: Audio_Capturer_GetCapturerInfo_003
2210 * @tc.desc : Test GetCapturerInfo interface. Check whether capturer info returns proper data
2211 */
2212 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCapturerInfo_003, TestSize.Level1)
2213 {
2214 AudioCapturerOptions capturerOptions;
2215 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2216 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2217 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2218 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2219 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2220 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2221
2222 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2223 ASSERT_NE(nullptr, audioCapturer);
2224
2225 bool isReleased = audioCapturer->Release();
2226 EXPECT_EQ(true, isReleased);
2227
2228 AudioCapturerInfo capturerInfo;
2229 audioCapturer->GetCapturerInfo(capturerInfo);
2230
2231 EXPECT_EQ(SourceType::SOURCE_TYPE_MIC, capturerInfo.sourceType);
2232 EXPECT_EQ(CAPTURER_FLAG, capturerInfo.capturerFlags);
2233 }
2234
2235 /**
2236 * @tc.name : Test GetCapturerInfo API after calling stop
2237 * @tc.number: Audio_Capturer_GetCapturerInfo_004
2238 * @tc.desc : Test GetCapturerInfo interface. Check whether capturer info returns proper data
2239 */
2240 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCapturerInfo_004, TestSize.Level1)
2241 {
2242 AudioCapturerOptions capturerOptions;
2243 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2244 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2245 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2246 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2247 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2248 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2249
2250 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2251 ASSERT_NE(nullptr, audioCapturer);
2252
2253 bool isStarted = audioCapturer->Start();
2254 EXPECT_EQ(true, isStarted);
2255
2256 bool isStopped = audioCapturer->Stop();
2257 EXPECT_EQ(true, isStopped);
2258
2259 AudioCapturerInfo capturerInfo;
2260 audioCapturer->GetCapturerInfo(capturerInfo);
2261
2262 EXPECT_EQ(SourceType::SOURCE_TYPE_MIC, capturerInfo.sourceType);
2263 EXPECT_EQ(CAPTURER_FLAG, capturerInfo.capturerFlags);
2264 audioCapturer->Release();
2265 }
2266
2267 /**
2268 * @tc.name : Test GetCapturerInfo API Stability
2269 * @tc.number: Audio_Capturer_GetCapturerInfo_Stability_001
2270 * @tc.desc : Test GetCapturerInfo interface. Check whether capturer info returns proper data
2271 */
2272 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCapturerInfo_Stability_001, TestSize.Level1)
2273 {
2274 AudioCapturerOptions capturerOptions;
2275 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2276 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2277 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2278 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2279 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2280 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2281
2282 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2283 ASSERT_NE(nullptr, audioCapturer);
2284
2285 for (int i = 0; i < VALUE_HUNDRED; i++) {
2286
2287 AudioCapturerInfo capturerInfo;
2288 audioCapturer->GetCapturerInfo(capturerInfo);
2289
2290 EXPECT_EQ(SourceType::SOURCE_TYPE_MIC, capturerInfo.sourceType);
2291 EXPECT_EQ(CAPTURER_FLAG, capturerInfo.capturerFlags);
2292 }
2293 audioCapturer->Release();
2294 }
2295
2296 /**
2297 * @tc.name : Test GetStreamInfo API after calling create
2298 * @tc.number: Audio_Capturer_GetStreamInfo_001
2299 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
2300 */
2301 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStreamInfo_001, TestSize.Level1)
2302 {
2303 AudioCapturerOptions capturerOptions;
2304 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2305 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2306 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2307 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2308 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2309 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2310
2311 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2312 ASSERT_NE(nullptr, audioCapturer);
2313
2314 AudioStreamInfo streamInfo;
2315 audioCapturer->GetStreamInfo(streamInfo);
2316
2317 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
2318 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
2319 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
2320 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
2321 audioCapturer->Release();
2322 }
2323
2324 /**
2325 * @tc.name : Test GetStreamInfo API after calling start
2326 * @tc.number: Audio_Capturer_GetStreamInfo_002
2327 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
2328 */
2329 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStreamInfo_002, TestSize.Level1)
2330 {
2331 int32_t ret = -1;
2332 AudioCapturerOptions capturerOptions;
2333
2334 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2335 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2336 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2337 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2338 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2339 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2340
2341 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2342 ASSERT_NE(nullptr, audioCapturer);
2343
2344 bool isStarted = audioCapturer->Start();
2345 EXPECT_EQ(true, isStarted);
2346
2347 AudioStreamInfo streamInfo;
2348 ret = audioCapturer->GetStreamInfo(streamInfo);
2349
2350 EXPECT_EQ(SUCCESS, ret);
2351 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
2352 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
2353 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
2354 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
2355
2356 audioCapturer->Stop();
2357 audioCapturer->Release();
2358 }
2359
2360 /**
2361 * @tc.name : Test GetStreamInfo API after calling stop
2362 * @tc.number: Audio_Capturer_GetStreamInfo_003
2363 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
2364 */
2365 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStreamInfo_003, TestSize.Level1)
2366 {
2367 int32_t ret = -1;
2368 AudioCapturerOptions capturerOptions;
2369
2370 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2371 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2372 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2373 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2374 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2375 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2376
2377 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2378 ASSERT_NE(nullptr, audioCapturer);
2379
2380 bool isStarted = audioCapturer->Start();
2381 EXPECT_EQ(true, isStarted);
2382
2383 bool isStopped = audioCapturer->Stop();
2384 EXPECT_EQ(true, isStopped);
2385
2386 AudioStreamInfo streamInfo;
2387 ret = audioCapturer->GetStreamInfo(streamInfo);
2388
2389 EXPECT_EQ(SUCCESS, ret);
2390 EXPECT_EQ(AudioSamplingRate::SAMPLE_RATE_96000, streamInfo.samplingRate);
2391 EXPECT_EQ(AudioEncodingType::ENCODING_PCM, streamInfo.encoding);
2392 EXPECT_EQ(AudioSampleFormat::SAMPLE_U8, streamInfo.format);
2393 EXPECT_EQ(AudioChannel::MONO, streamInfo.channels);
2394
2395 audioCapturer->Release();
2396 }
2397
2398 /**
2399 * @tc.name : Test GetStreamInfo API after calling release
2400 * @tc.number: Audio_Capturer_GetStreamInfo_004
2401 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
2402 */
2403 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetStreamInfo_004, TestSize.Level1)
2404 {
2405 int32_t ret = -1;
2406 AudioCapturerOptions capturerOptions;
2407
2408 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2409 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2410 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2411 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2412 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2413 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2414
2415 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2416 ASSERT_NE(nullptr, audioCapturer);
2417
2418 bool isReleased = audioCapturer->Release();
2419 EXPECT_EQ(true, isReleased);
2420
2421 AudioStreamInfo streamInfo;
2422 ret = audioCapturer->GetStreamInfo(streamInfo);
2423
2424 EXPECT_EQ(ERR_OPERATION_FAILED, ret);
2425 }
2426
2427 /**
2428 * @tc.name : Test GetStreamInfo API after calling create
2429 * @tc.number: Audio_Renderer_GetStreamInfo_Stability_001
2430 * @tc.desc : Test GetStreamInfo interface. Check whether stream related data is returned correctly
2431 */
2432 HWTEST(AudioCapturerUnitTest, Audio_Renderer_GetStreamInfo_Stability_001, TestSize.Level1)
2433 {
2434 int32_t ret = -1;
2435 AudioCapturerOptions capturerOptions;
2436
2437 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2438 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2439 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2440 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2441 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2442 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2443
2444 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2445 ASSERT_NE(nullptr, audioCapturer);
2446
2447 for (int i = 0; i < VALUE_HUNDRED; i++) {
2448 AudioStreamInfo streamInfo;
2449 ret = audioCapturer->GetStreamInfo(streamInfo);
2450 EXPECT_EQ(SUCCESS, ret);
2451 }
2452 audioCapturer->Release();
2453 }
2454
2455 /**
2456 * @tc.name : Test SetBufferDuration API
2457 * @tc.number: Audio_Capturer_SetBufferDuration_001
2458 * @tc.desc : Test SetBufferDuration interface. Check whether valid parameters are accepted.
2459 */
2460 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetBufferDuration_001, TestSize.Level1)
2461 {
2462 int32_t ret = -1;
2463
2464 AudioCapturerOptions capturerOptions;
2465 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2466 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2467 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2468 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2469 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2470 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2471
2472 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2473 ASSERT_NE(nullptr, audioCapturer);
2474
2475 ret = audioCapturer->SetBufferDuration(BUFFER_DURATION_FIVE);
2476 EXPECT_EQ(SUCCESS, ret);
2477
2478 ret = audioCapturer->SetBufferDuration(BUFFER_DURATION_TEN);
2479 EXPECT_EQ(SUCCESS, ret);
2480
2481 ret = audioCapturer->SetBufferDuration(BUFFER_DURATION_FIFTEEN);
2482 EXPECT_EQ(SUCCESS, ret);
2483
2484 ret = audioCapturer->SetBufferDuration(BUFFER_DURATION_TWENTY);
2485 EXPECT_EQ(SUCCESS, ret);
2486 }
2487
2488 /**
2489 * @tc.name : Test SetBufferDuration API
2490 * @tc.number: Audio_Capturer_SetBufferDuration_002
2491 * @tc.desc : Test SetBufferDuration interface. Check whether invalid parameters are rejected.
2492 */
2493 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetBufferDuration_002, TestSize.Level1)
2494 {
2495 int32_t ret = -1;
2496
2497 AudioCapturerOptions capturerOptions;
2498 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_96000;
2499 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2500 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_U8;
2501 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2502 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2503 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2504
2505 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2506 ASSERT_NE(nullptr, audioCapturer);
2507
2508 ret = audioCapturer->SetBufferDuration(VALUE_NEGATIVE);
2509 EXPECT_NE(SUCCESS, ret);
2510
2511 ret = audioCapturer->SetBufferDuration(VALUE_ZERO);
2512 EXPECT_NE(SUCCESS, ret);
2513
2514 ret = audioCapturer->SetBufferDuration(VALUE_HUNDRED);
2515 EXPECT_NE(SUCCESS, ret);
2516 }
2517
2518 /**
2519 * @tc.name : Test SetCapturerPositionCallback API
2520 * @tc.number: Audio_Capturer_SetCapturerPositionCallback_001
2521 * @tc.desc : Test SetCapturerPositionCallback interface to check set position callback is success for valid callback.
2522 */
2523 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPositionCallback_001, TestSize.Level1)
2524 {
2525 int32_t ret = -1;
2526
2527 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2528 ASSERT_NE(nullptr, audioCapturer);
2529
2530 shared_ptr<CapturerPositionCallbackTest> positionCB = std::make_shared<CapturerPositionCallbackTest>();
2531 ret = audioCapturer->SetCapturerPositionCallback(VALUE_THOUSAND, positionCB);
2532 EXPECT_EQ(SUCCESS, ret);
2533 }
2534
2535 /**
2536 * @tc.name : Test SetCapturerPositionCallback API
2537 * @tc.number: Audio_Capturer_SetCapturerPositionCallback_002
2538 * @tc.desc : Test SetCapturerPositionCallback interface again after unregister.
2539 */
2540 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPositionCallback_002, TestSize.Level1)
2541 {
2542 int32_t ret = -1;
2543
2544 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2545 ASSERT_NE(nullptr, audioCapturer);
2546
2547 shared_ptr<CapturerPositionCallbackTest> positionCB1 = std::make_shared<CapturerPositionCallbackTest>();
2548 ret = audioCapturer->SetCapturerPositionCallback(VALUE_THOUSAND, positionCB1);
2549 EXPECT_EQ(SUCCESS, ret);
2550
2551 audioCapturer->UnsetCapturerPositionCallback();
2552
2553 shared_ptr<CapturerPositionCallbackTest> positionCB2 = std::make_shared<CapturerPositionCallbackTest>();
2554 ret = audioCapturer->SetCapturerPositionCallback(VALUE_THOUSAND, positionCB2);
2555 EXPECT_EQ(SUCCESS, ret);
2556 }
2557
2558 /**
2559 * @tc.name : Test SetCapturerPositionCallback API
2560 * @tc.number: Audio_Capturer_SetCapturerPositionCallback_003
2561 * @tc.desc : Test SetCapturerPositionCallback interface with null callback.
2562 */
2563 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPositionCallback_003, TestSize.Level1)
2564 {
2565 int32_t ret = -1;
2566
2567 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2568 ASSERT_NE(nullptr, audioCapturer);
2569
2570 ret = audioCapturer->SetCapturerPositionCallback(VALUE_THOUSAND, nullptr);
2571 EXPECT_NE(SUCCESS, ret);
2572 }
2573
2574 /**
2575 * @tc.name : Test SetCapturerPositionCallback API
2576 * @tc.number: Audio_Capturer_SetCapturerPositionCallback_004
2577 * @tc.desc : Test SetCapturerPositionCallback interface with invalid parameter.
2578 */
2579 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPositionCallback_004, TestSize.Level1)
2580 {
2581 int32_t ret = -1;
2582
2583 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2584 ASSERT_NE(nullptr, audioCapturer);
2585
2586 shared_ptr<CapturerPositionCallbackTest> positionCB = std::make_shared<CapturerPositionCallbackTest>();
2587 ret = audioCapturer->SetCapturerPositionCallback(VALUE_ZERO, positionCB);
2588 EXPECT_NE(SUCCESS, ret);
2589
2590 ret = audioCapturer->SetCapturerPositionCallback(VALUE_NEGATIVE, positionCB);
2591 EXPECT_NE(SUCCESS, ret);
2592 }
2593
2594 /**
2595 * @tc.name : Test SetCapturerPeriodPositionCallback API
2596 * @tc.number: SetCapturerPeriodPositionCallback_001
2597 * @tc.desc : Test SetCapturerPeriodPositionCallback interface to check set period position
2598 * callback is success for valid callback.
2599 */
2600 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPeriodPositionCallback_001, TestSize.Level1)
2601 {
2602 int32_t ret = -1;
2603
2604 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2605 ASSERT_NE(nullptr, audioCapturer);
2606
2607 shared_ptr<CapturerPeriodPositionCallbackTest> positionCB = std::make_shared<CapturerPeriodPositionCallbackTest>();
2608 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_THOUSAND, positionCB);
2609 EXPECT_EQ(SUCCESS, ret);
2610 }
2611
2612 /**
2613 * @tc.name : Test SetCapturerPeriodPositionCallback API
2614 * @tc.number: Audio_Capturer_SetCapturerPeriodPositionCallback_002
2615 * @tc.desc : Test SetCapturerPeriodPositionCallback interface again after unregister.
2616 */
2617 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPeriodPositionCallback_002, TestSize.Level1)
2618 {
2619 int32_t ret = -1;
2620
2621 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2622 ASSERT_NE(nullptr, audioCapturer);
2623
2624 shared_ptr<CapturerPeriodPositionCallbackTest> positionCB1 = std::make_shared<CapturerPeriodPositionCallbackTest>();
2625 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_THOUSAND, positionCB1);
2626 EXPECT_EQ(SUCCESS, ret);
2627
2628 audioCapturer->UnsetCapturerPeriodPositionCallback();
2629
2630 shared_ptr<CapturerPeriodPositionCallbackTest> positionCB2 = std::make_shared<CapturerPeriodPositionCallbackTest>();
2631 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_THOUSAND, positionCB2);
2632 EXPECT_EQ(SUCCESS, ret);
2633 }
2634
2635 /**
2636 * @tc.name : Test SetCapturerPeriodPositionCallback API
2637 * @tc.number: Audio_Capturer_SetCapturerPeriodPositionCallback_003
2638 * @tc.desc : Test SetCapturerPeriodPositionCallback interface with null callback.
2639 */
2640 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPeriodPositionCallback_003, TestSize.Level1)
2641 {
2642 int32_t ret = -1;
2643
2644 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2645 ASSERT_NE(nullptr, audioCapturer);
2646
2647 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_THOUSAND, nullptr);
2648 EXPECT_NE(SUCCESS, ret);
2649 }
2650
2651 /**
2652 * @tc.name : Test SetCapturerPeriodPositionCallback API
2653 * @tc.number: Audio_Capturer_SetCapturerPeriodPositionCallback_004
2654 * @tc.desc : Test SetCapturerPeriodPositionCallback interface with invalid parameter.
2655 */
2656 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerPeriodPositionCallback_004, TestSize.Level1)
2657 {
2658 int32_t ret = -1;
2659
2660 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(STREAM_MUSIC);
2661 ASSERT_NE(nullptr, audioCapturer);
2662
2663 shared_ptr<CapturerPeriodPositionCallbackTest> positionCB = std::make_shared<CapturerPeriodPositionCallbackTest>();
2664 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_ZERO, positionCB);
2665 EXPECT_NE(SUCCESS, ret);
2666
2667 ret = audioCapturer->SetCapturerPeriodPositionCallback(VALUE_NEGATIVE, positionCB);
2668 EXPECT_NE(SUCCESS, ret);
2669 }
2670
2671 /**
2672 * @tc.name : Test SetCapturerCallback with null pointer.
2673 * @tc.number: Audio_Capturer_SetCapturerCallback_001
2674 * @tc.desc : Test SetCapturerCallback interface. Returns error code, if null pointer is set.
2675 */
2676 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerCallback_001, TestSize.Level1)
2677 {
2678 int32_t ret = -1;
2679
2680 AudioCapturerOptions capturerOptions;
2681 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2682 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2683 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2684 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2685 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2686 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2687
2688 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2689 ASSERT_NE(nullptr, audioCapturer);
2690
2691 ret = audioCapturer->SetCapturerCallback(nullptr);
2692 EXPECT_NE(SUCCESS, ret);
2693 EXPECT_EQ(ERR_INVALID_PARAM, ret);
2694 }
2695
2696 /**
2697 * @tc.name : Test SetCapturerCallback with valid callback pointer.
2698 * @tc.number: Audio_Capturer_SetCapturerCallback_002
2699 * @tc.desc : Test SetCapturerCallback interface. Returns success, if valid callback is set.
2700 */
2701 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerCallback_002, TestSize.Level1)
2702 {
2703 int32_t ret = -1;
2704
2705 AudioCapturerOptions capturerOptions;
2706 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2707 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2708 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2709 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2710 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2711 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2712
2713 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2714 ASSERT_NE(nullptr, audioCapturer);
2715
2716 shared_ptr<AudioCapturerCallbackTest> audioCapturerCB = std::make_shared<AudioCapturerCallbackTest>();
2717 ret = audioCapturer->SetCapturerCallback(audioCapturerCB);
2718 EXPECT_EQ(SUCCESS, ret);
2719 }
2720
2721 /**
2722 * @tc.name : Test SetCapturerCallback via illegal state, CAPTURER_RELEASED: After RELEASED
2723 * @tc.number: Audio_Capturer_SetCapturerCallback_003
2724 * @tc.desc : Test SetCapturerCallback interface. Returns error, if callback is set in released state.
2725 */
2726 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerCallback_003, TestSize.Level1)
2727 {
2728 int32_t ret = -1;
2729
2730 AudioCapturerOptions capturerOptions;
2731 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2732 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2733 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2734 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2735 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2736 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2737
2738 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2739 ASSERT_NE(nullptr, audioCapturer);
2740
2741 bool isReleased = audioCapturer->Release();
2742 EXPECT_EQ(true, isReleased);
2743
2744 CapturerState state = audioCapturer->GetStatus();
2745 EXPECT_EQ(CAPTURER_RELEASED, state);
2746
2747 shared_ptr<AudioCapturerCallbackTest> audioCapturerCB = std::make_shared<AudioCapturerCallbackTest>();
2748 ret = audioCapturer->SetCapturerCallback(audioCapturerCB);
2749 EXPECT_NE(SUCCESS, ret);
2750 EXPECT_EQ(ERR_ILLEGAL_STATE, ret);
2751 }
2752
2753 /**
2754 * @tc.name : Test SetCapturerCallback via legal state, CAPTURER_PREPARED: After PREPARED
2755 * @tc.number: Audio_Capturer_SetCapturerCallback_004
2756 * @tc.desc : Test SetCapturerCallback interface. Returns success, if callback is set in proper state.
2757 */
2758 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCapturerCallback_004, TestSize.Level1)
2759 {
2760 int32_t ret = -1;
2761
2762 AudioCapturerOptions capturerOptions;
2763 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2764 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2765 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2766 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2767 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2768 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2769
2770 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2771 ASSERT_NE(nullptr, audioCapturer);
2772
2773 CapturerState state = audioCapturer->GetStatus();
2774 EXPECT_EQ(CAPTURER_PREPARED, state);
2775
2776 shared_ptr<AudioCapturerCallbackTest> audioCapturerCB = std::make_shared<AudioCapturerCallbackTest>();
2777 ret = audioCapturer->SetCapturerCallback(audioCapturerCB);
2778 EXPECT_EQ(SUCCESS, ret);
2779 }
2780
2781 /**
2782 * @tc.name : Test SetCaptureMode via legal state.
2783 * @tc.number: Audio_Capturer_SetCaptureMode_001
2784 * @tc.desc : Test SetCaptureMode interface. Returns success, if the set capture mode is successful.
2785 */
2786 HWTEST(AudioCapturerUnitTest, Audio_Capturer_SetCaptureMode_001, TestSize.Level1)
2787 {
2788 int32_t ret = -1;
2789
2790 AudioCapturerOptions capturerOptions;
2791 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2792 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2793 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2794 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2795 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2796 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2797
2798 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2799 ASSERT_NE(nullptr, audioCapturer);
2800
2801 ret = audioCapturer->SetCaptureMode(CAPTURE_MODE_CALLBACK);
2802 EXPECT_EQ(SUCCESS, ret);
2803 }
2804
2805 /**
2806 * @tc.name : Test GetCaptureMode via legal state.
2807 * @tc.number: Audio_Capturer_GetCaptureMode_001
2808 * @tc.desc : Test GetCaptureMode interface. Returns success, if the get capture mode is successful.
2809 */
2810 HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetCaptureMode, TestSize.Level1)
2811 {
2812 int32_t ret = -1;
2813
2814 AudioCapturerOptions capturerOptions;
2815 capturerOptions.streamInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
2816 capturerOptions.streamInfo.encoding = AudioEncodingType::ENCODING_PCM;
2817 capturerOptions.streamInfo.format = AudioSampleFormat::SAMPLE_S16LE;
2818 capturerOptions.streamInfo.channels = AudioChannel::MONO;
2819 capturerOptions.capturerInfo.sourceType = SourceType::SOURCE_TYPE_MIC;
2820 capturerOptions.capturerInfo.capturerFlags = CAPTURER_FLAG;
2821
2822 unique_ptr<AudioCapturer> audioCapturer = AudioCapturer::Create(capturerOptions);
2823 ASSERT_NE(nullptr, audioCapturer);
2824
2825 ret = audioCapturer->SetCaptureMode(CAPTURE_MODE_CALLBACK);
2826 EXPECT_EQ(SUCCESS, ret);
2827
2828 AudioCaptureMode captureMode = audioCapturer->GetCaptureMode();
2829 EXPECT_EQ(CAPTURE_MODE_CALLBACK, captureMode);
2830 }
2831 } // namespace AudioStandard
2832 } // namespace OHOS
2833