1 /*
2 * Copyright (C) 2020-2021 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15 #include "audiolite_test.h"
16 #include "codec_type.h"
17 #include "media_errors.h"
18
19 using namespace std;
20 using namespace OHOS::Audio;
21 using namespace testing::ext;
22
23
24 namespace OHOS {
25 const int32_t BUFFER_SIZE = 1024;
26 const int32_t SAMPLE_RATE = 24000;
27 const int32_t BIT_RATE = 1024;
28 const int32_t CHANNEL_COUNT = 2;
29
SetUpTestCase(void)30 void AudioliteTest::SetUpTestCase(void) {}
31
TearDownTestCase(void)32 void AudioliteTest::TearDownTestCase(void) {}
33
SetUp()34 void AudioliteTest::SetUp()
35 {
36 audioCapInfo.channelCount = CHANNEL_COUNT;
37 audioCapInfo.sampleRate = SAMPLE_RATE;
38 audioCapInfo.bitRate = BIT_RATE;
39 audioCapInfo.inputSource = AUDIO_SOURCE_DEFAULT;
40 audioCapInfo.bitWidth = BIT_WIDTH_16;
41 }
42
TearDown()43 void AudioliteTest::TearDown() {}
44
45 /*
46 * Feature: Audiolite
47 * Function: audioCapturer
48 * SubFunction: NA
49 * FunctionPoints: NA
50 * EnvConditions: NA
51 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 16; Sample Rate 8000; Bit Rate 8000
52 */
53 HWTEST_F(AudioliteTest, audio_buffer_001, TestSize.Level1)
54 {
55 AudioCapturer *audioCapturer = new AudioCapturer();
56 AudioCapturerInfo info;
57 info.inputSource = AUDIO_MIC;
58 info.audioFormat = AUDIO_DEFAULT;
59 info.sampleRate = 8000;
60 info.channelCount = 1;
61 info.bitRate = 8000;
62 info.streamType = TYPE_MEDIA;
63 info.bitWidth = BIT_WIDTH_16;
64 audioCapturer->SetCapturerInfo(info);
65 audioCapturer->Start();
66
67 uint64_t frameCnt = audioCapturer->GetFrameCount();
68 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
69 uint8_t *buffer;
70
71 audioCapturer->Read(buffer, framesize, false);
72 EXPECT_TRUE(sizeof(buffer) > 0);
73 audioCapturer->Release();
74 delete audioCapturer;
75 }
76
77 /*
78 * Feature: Audiolite
79 * Function: audioCapturer
80 * SubFunction: NA
81 * FunctionPoints: NA
82 * EnvConditions: NA
83 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 16; Sample Rate 16000; Bit Rate 16000
84 */
85 HWTEST_F(AudioliteTest, audio_buffer_002, TestSize.Level1)
86 {
87 AudioCapturer *audioCapturer = new AudioCapturer();
88 AudioCapturerInfo info;
89 info.inputSource = AUDIO_MIC;
90 info.audioFormat = AUDIO_DEFAULT;
91 info.sampleRate = 16000;
92 info.channelCount = 1;
93 info.bitRate = 16000;
94 info.streamType = TYPE_MEDIA;
95 info.bitWidth = BIT_WIDTH_16;
96 uint64_t frameCnt = audioCapturer->GetFrameCount();
97 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
98 uint8_t *buffer;
99 audioCapturer->SetCapturerInfo(info);
100 audioCapturer->Start();
101 audioCapturer->Read(buffer, framesize, false);
102 EXPECT_TRUE(sizeof(buffer) > 0);
103 audioCapturer->Release();
104 delete audioCapturer;
105 }
106
107 /*
108 * Feature: Audiolite
109 * Function: audioCapturer
110 * SubFunction: NA
111 * FunctionPoints: NA
112 * EnvConditions: NA
113 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 16; Sample Rate 32000; Bit Rate 32000
114 */
115 HWTEST_F(AudioliteTest, audioCapturer_003, TestSize.Level1)
116 {
117 AudioCapturer *audioCapturer = new AudioCapturer();
118 AudioCapturerInfo info;
119 info.inputSource = AUDIO_MIC;
120 info.audioFormat = AUDIO_DEFAULT;
121 info.sampleRate = 32000;
122 info.channelCount = 1;
123 info.bitRate = 32000;
124 info.streamType = TYPE_MEDIA;
125 info.bitWidth = BIT_WIDTH_16;
126 uint64_t frameCnt = audioCapturer->GetFrameCount();
127 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
128 uint8_t *buffer;
129 audioCapturer->SetCapturerInfo(info);
130 audioCapturer->Start();
131 audioCapturer->Read(buffer, framesize, false);
132 EXPECT_TRUE(sizeof(buffer) > 0);
133 audioCapturer->Release();
134 delete audioCapturer;
135 }
136
137 /*
138 * Feature: Audiolite
139 * Function: audioCapturer
140 * SubFunction: NA
141 * FunctionPoints: NA
142 * EnvConditions: NA
143 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 16; Sample Rate 24000; Bit Rate 24000
144 */
145 HWTEST_F(AudioliteTest, audioCapturer_004, TestSize.Level1)
146 {
147 AudioCapturer *audioCapturer = new AudioCapturer();
148 AudioCapturerInfo info;
149 info.inputSource = AUDIO_MIC;
150 info.audioFormat = AUDIO_DEFAULT;
151 info.sampleRate = 24000;
152 info.channelCount = 1;
153 info.bitRate = 24000;
154 info.streamType = TYPE_MEDIA;
155 info.bitWidth = BIT_WIDTH_16;
156 uint64_t frameCnt = audioCapturer->GetFrameCount();
157 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
158 uint8_t *buffer;
159 audioCapturer->SetCapturerInfo(info);
160 audioCapturer->Start();
161 audioCapturer->Read(buffer, framesize, false);
162 EXPECT_TRUE(sizeof(buffer) > 0);
163 audioCapturer->Release();
164 delete audioCapturer;
165 }
166
167 /*
168 * Feature: Audiolite
169 * Function: audioCapturer
170 * SubFunction: NA
171 * FunctionPoints: NA
172 * EnvConditions: NA
173 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 16; Sample Rate 48000; Bit Rate 48000
174 */
175 HWTEST_F(AudioliteTest, audioCapturer_005, TestSize.Level1)
176 {
177 AudioCapturer *audioCapturer = new AudioCapturer();
178 AudioCapturerInfo info;
179 info.inputSource = AUDIO_MIC;
180 info.audioFormat = AUDIO_DEFAULT;
181 info.sampleRate = 48000;
182 info.channelCount = 1;
183 info.bitRate = 48000;
184 info.streamType = TYPE_MEDIA;
185 info.bitWidth = BIT_WIDTH_16;
186 uint64_t frameCnt = audioCapturer->GetFrameCount();
187 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
188 uint8_t *buffer;
189 audioCapturer->SetCapturerInfo(info);
190 audioCapturer->Start();
191 audioCapturer->Read(buffer, framesize, false);
192 EXPECT_TRUE(sizeof(buffer) > 0);
193 audioCapturer->Release();
194 delete audioCapturer;
195 }
196
197 /*
198 * Feature: Audiolite
199 * Function: audioCapturer
200 * SubFunction: NA
201 * FunctionPoints: NA
202 * EnvConditions: NA
203 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 16; Sample Rate 8000; Bit Rate 8000
204 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_006,Level1)205 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_006, Level1)
206 {
207 AudioCapturer *audioCapturer = new AudioCapturer();
208 AudioCapturerInfo info;
209 info.inputSource = AUDIO_MIC;
210 info.audioFormat = AUDIO_DEFAULT;
211 info.sampleRate = 8000;
212 info.channelCount = 2;
213 info.bitRate = 8000;
214 info.streamType = TYPE_MEDIA;
215 info.bitWidth = BIT_WIDTH_16;
216 uint64_t frameCnt = audioCapturer->GetFrameCount();
217 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
218 uint8_t *buffer;
219 audioCapturer->SetCapturerInfo(info);
220 audioCapturer->Start();
221 audioCapturer->Read(buffer, framesize, false);
222 EXPECT_TRUE(sizeof(buffer) > 0);
223 audioCapturer->Release();
224 delete audioCapturer;
225 }
226
227 /*
228 * Feature: Audiolite
229 * Function: audioCapturer
230 * SubFunction: NA
231 * FunctionPoints: NA
232 * EnvConditions: NA
233 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 16; Sample Rate 16000; Bit Rate 16000
234 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_007,Level1)235 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_007, Level1)
236 {
237 AudioCapturer *audioCapturer = new AudioCapturer();
238 AudioCapturerInfo info;
239 info.inputSource = AUDIO_MIC;
240 info.audioFormat = AUDIO_DEFAULT;
241 info.sampleRate = 16000;
242 info.channelCount = 2;
243 info.bitRate = 16000;
244 info.streamType = TYPE_MEDIA;
245 info.bitWidth = BIT_WIDTH_16;
246 uint64_t frameCnt = audioCapturer->GetFrameCount();
247 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
248 uint8_t *buffer;
249 audioCapturer->SetCapturerInfo(info);
250 audioCapturer->Start();
251 audioCapturer->Read(buffer, framesize, false);
252 EXPECT_TRUE(sizeof(buffer) > 0);
253 audioCapturer->Release();
254 delete audioCapturer;
255 }
256
257 /*
258 * Feature: Audiolite
259 * Function: audioCapturer
260 * SubFunction: NA
261 * FunctionPoints: NA
262 * EnvConditions: NA
263 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 16; Sample Rate 32000; Bit Rate 32000
264 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_008,Level1)265 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_008, Level1)
266 {
267 AudioCapturer *audioCapturer = new AudioCapturer();
268 AudioCapturerInfo info;
269 info.inputSource = AUDIO_MIC;
270 info.audioFormat = AUDIO_DEFAULT;
271 info.sampleRate = 32000;
272 info.channelCount = 2;
273 info.bitRate = 32000;
274 info.streamType = TYPE_MEDIA;
275 info.bitWidth = BIT_WIDTH_16;
276 uint64_t frameCnt = audioCapturer->GetFrameCount();
277 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
278 uint8_t *buffer;
279 audioCapturer->SetCapturerInfo(info);
280 audioCapturer->Start();
281 audioCapturer->Read(buffer, framesize, false);
282 EXPECT_TRUE(sizeof(buffer) > 0);
283 audioCapturer->Release();
284 delete audioCapturer;
285 }
286
287 /*
288 * Feature: Audiolite
289 * Function: audioCapturer
290 * SubFunction: NA
291 * FunctionPoints: NA
292 * EnvConditions: NA
293 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 16; Sample Rate 24000; Bit Rate 24000
294 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_009,Level1)295 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_009, Level1)
296 {
297 AudioCapturer *audioCapturer = new AudioCapturer();
298 AudioCapturerInfo info;
299 info.inputSource = AUDIO_MIC;
300 info.audioFormat = AUDIO_DEFAULT;
301 info.sampleRate = 24000;
302 info.channelCount = 2;
303 info.bitRate = 24000;
304 info.streamType = TYPE_MEDIA;
305 info.bitWidth = BIT_WIDTH_16;
306 uint64_t frameCnt = audioCapturer->GetFrameCount();
307 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
308 uint8_t *buffer;
309 audioCapturer->SetCapturerInfo(info);
310 audioCapturer->Start();
311 audioCapturer->Read(buffer, framesize, false);
312 EXPECT_TRUE(sizeof(buffer) > 0);
313 audioCapturer->Release();
314 delete audioCapturer;
315 }
316
317 /*
318 * Feature: Audiolite
319 * Function: audioCapturer
320 * SubFunction: NA
321 * FunctionPoints: NA
322 * EnvConditions: NA
323 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 16; Sample Rate 48000; Bit Rate 48000
324 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_010,Level1)325 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_010, Level1)
326 {
327 AudioCapturer *audioCapturer = new AudioCapturer();
328 AudioCapturerInfo info;
329 info.inputSource = AUDIO_MIC;
330 info.audioFormat = AUDIO_DEFAULT;
331 info.sampleRate = 48000;
332 info.channelCount = 2;
333 info.bitRate = 48000;
334 info.streamType = TYPE_MEDIA;
335 info.bitWidth = BIT_WIDTH_16;
336 uint64_t frameCnt = audioCapturer->GetFrameCount();
337 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
338 uint8_t *buffer;
339 audioCapturer->SetCapturerInfo(info);
340 audioCapturer->Start();
341 audioCapturer->Read(buffer, framesize, false);
342 EXPECT_TRUE(sizeof(buffer) > 0);
343 audioCapturer->Release();
344 delete audioCapturer;
345 }
346
347 /*
348 * Feature: Audiolite
349 * Function: audioCapturer
350 * SubFunction: NA
351 * FunctionPoints: NA
352 * EnvConditions: NA
353 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 8; Sample Rate 8000; Bit Rate 8000
354 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_011,Level1)355 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_011, Level1)
356 {
357 AudioCapturer *audioCapturer = new AudioCapturer();
358 AudioCapturerInfo info;
359 info.inputSource = AUDIO_MIC;
360 info.audioFormat = AUDIO_DEFAULT;
361 info.sampleRate = 8000;
362 info.channelCount = 2;
363 info.bitRate = 8000;
364 info.streamType = TYPE_MEDIA;
365 info.bitWidth = BIT_WIDTH_8;
366 uint64_t frameCnt = audioCapturer->GetFrameCount();
367 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
368 uint8_t *buffer;
369 audioCapturer->SetCapturerInfo(info);
370 audioCapturer->Start();
371 audioCapturer->Read(buffer, framesize, false);
372 EXPECT_TRUE(sizeof(buffer) > 0);
373 audioCapturer->Release();
374 delete audioCapturer;
375 }
376
377 /*
378 * Feature: Audiolite
379 * Function: audioCapturer
380 * SubFunction: NA
381 * FunctionPoints: NA
382 * EnvConditions: NA
383 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 8; Sample Rate 16000; Bit Rate 16000
384 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_012,Level1)385 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_012, Level1)
386 {
387 AudioCapturer *audioCapturer = new AudioCapturer();
388 AudioCapturerInfo info;
389 info.inputSource = AUDIO_MIC;
390 info.audioFormat = AUDIO_DEFAULT;
391 info.sampleRate = 16000;
392 info.channelCount = 2;
393 info.bitRate = 16000;
394 info.streamType = TYPE_MEDIA;
395 info.bitWidth = BIT_WIDTH_8;
396 uint64_t frameCnt = audioCapturer->GetFrameCount();
397 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
398 uint8_t *buffer;
399 audioCapturer->SetCapturerInfo(info);
400 audioCapturer->Start();
401 audioCapturer->Read(buffer, framesize, false);
402 EXPECT_TRUE(sizeof(buffer) > 0);
403 audioCapturer->Release();
404 delete audioCapturer;
405 }
406
407 /*
408 * Feature: Audiolite
409 * Function: audioCapturer
410 * SubFunction: NA
411 * FunctionPoints: NA
412 * EnvConditions: NA
413 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 8; Sample Rate 32000; Bit Rate 32000
414 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_013,Level1)415 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_013, Level1)
416 {
417 AudioCapturer *audioCapturer = new AudioCapturer();
418 AudioCapturerInfo info;
419 info.inputSource = AUDIO_MIC;
420 info.audioFormat = AUDIO_DEFAULT;
421 info.sampleRate = 32000;
422 info.channelCount = 2;
423 info.bitRate = 32000;
424 info.streamType = TYPE_MEDIA;
425 info.bitWidth = BIT_WIDTH_8;
426 uint64_t frameCnt = audioCapturer->GetFrameCount();
427 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
428 uint8_t *buffer;
429 audioCapturer->SetCapturerInfo(info);
430 audioCapturer->Start();
431 audioCapturer->Read(buffer, framesize, false);
432 EXPECT_TRUE(sizeof(buffer) > 0);
433 audioCapturer->Release();
434 delete audioCapturer;
435 }
436
437 /*
438 * Feature: Audiolite
439 * Function: audioCapturer
440 * SubFunction: NA
441 * FunctionPoints: NA
442 * EnvConditions: NA
443 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 8; Sample Rate 24000; Bit Rate 24000
444 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_014,Level1)445 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_014, Level1)
446 {
447 AudioCapturer *audioCapturer = new AudioCapturer();
448 AudioCapturerInfo info;
449 info.inputSource = AUDIO_MIC;
450 info.audioFormat = AUDIO_DEFAULT;
451 info.sampleRate = 24000;
452 info.channelCount = 2;
453 info.bitRate = 24000;
454 info.streamType = TYPE_MEDIA;
455 info.bitWidth = BIT_WIDTH_8;
456 uint64_t frameCnt = audioCapturer->GetFrameCount();
457 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
458 uint8_t *buffer;
459 audioCapturer->SetCapturerInfo(info);
460 audioCapturer->Start();
461 audioCapturer->Read(buffer, framesize, false);
462 EXPECT_TRUE(sizeof(buffer) > 0);
463 audioCapturer->Release();
464 delete audioCapturer;
465 }
466
467 /*
468 * Feature: Audiolite
469 * Function: audioCapturer
470 * SubFunction: NA
471 * FunctionPoints: NA
472 * EnvConditions: NA
473 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 2; Bit_width 8; Sample Rate 48000; Bit Rate 48000
474 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_015,Level1)475 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_015, Level1)
476 {
477 AudioCapturer *audioCapturer = new AudioCapturer();
478 AudioCapturerInfo info;
479 info.inputSource = AUDIO_MIC;
480 info.audioFormat = AUDIO_DEFAULT;
481 info.sampleRate = 48000;
482 info.channelCount = 2;
483 info.bitRate = 48000;
484 info.streamType = TYPE_MEDIA;
485 info.bitWidth = BIT_WIDTH_8;
486 uint64_t frameCnt = audioCapturer->GetFrameCount();
487 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
488 uint8_t *buffer;
489 audioCapturer->SetCapturerInfo(info);
490 audioCapturer->Start();
491 audioCapturer->Read(buffer, framesize, false);
492 EXPECT_TRUE(sizeof(buffer) > 0);
493 audioCapturer->Release();
494 delete audioCapturer;
495 }
496
497 /*
498 * Feature: Audiolite
499 * Function: audioCapturer
500 * SubFunction: NA
501 * FunctionPoints: NA
502 * EnvConditions: NA
503 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 8; Sample Rate 8000; Bit Rate 8000
504 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_016,Level1)505 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_016, Level1)
506 {
507 AudioCapturer *audioCapturer = new AudioCapturer();
508 AudioCapturerInfo info;
509 info.inputSource = AUDIO_MIC;
510 info.audioFormat = AUDIO_DEFAULT;
511 info.sampleRate = 8000;
512 info.channelCount = 1;
513 info.bitRate = 8000;
514 info.streamType = TYPE_MEDIA;
515 info.bitWidth = BIT_WIDTH_8;
516 uint64_t frameCnt = audioCapturer->GetFrameCount();
517 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
518 uint8_t *buffer;
519 audioCapturer->SetCapturerInfo(info);
520 audioCapturer->Start();
521 audioCapturer->Read(buffer, framesize, false);
522 EXPECT_TRUE(sizeof(buffer) > 0);
523 audioCapturer->Release();
524 delete audioCapturer;
525 }
526
527 /*
528 * Feature: Audiolite
529 * Function: audioCapturer
530 * SubFunction: NA
531 * FunctionPoints: NA
532 * EnvConditions: NA
533 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 8; Sample Rate 16000; Bit Rate 16000
534 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_017,Level1)535 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_017, Level1)
536 {
537 AudioCapturer *audioCapturer = new AudioCapturer();
538 AudioCapturerInfo info;
539 info.inputSource = AUDIO_MIC;
540 info.audioFormat = AUDIO_DEFAULT;
541 info.sampleRate = 16000;
542 info.channelCount = 1;
543 info.bitRate = 16000;
544 info.streamType = TYPE_MEDIA;
545 info.bitWidth = BIT_WIDTH_8;
546 uint64_t frameCnt = audioCapturer->GetFrameCount();
547 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
548 uint8_t *buffer;
549 audioCapturer->SetCapturerInfo(info);
550 audioCapturer->Start();
551 audioCapturer->Read(buffer, framesize, false);
552 EXPECT_TRUE(sizeof(buffer) > 0);
553 audioCapturer->Release();
554 delete audioCapturer;
555 }
556
557 /*
558 * Feature: Audiolite
559 * Function: audioCapturer
560 * SubFunction: NA
561 * FunctionPoints: NA
562 * EnvConditions: NA
563 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 8; Sample Rate 32000; Bit Rate 32000
564 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_018,Level1)565 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_018, Level1)
566 {
567 AudioCapturer *audioCapturer = new AudioCapturer();
568 AudioCapturerInfo info;
569 info.inputSource = AUDIO_MIC;
570 info.audioFormat = AUDIO_DEFAULT;
571 info.sampleRate = 32000;
572 info.channelCount = 1;
573 info.bitRate = 32000;
574 info.streamType = TYPE_MEDIA;
575 info.bitWidth = BIT_WIDTH_8;
576 uint64_t frameCnt = audioCapturer->GetFrameCount();
577 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
578 uint8_t *buffer;
579 audioCapturer->SetCapturerInfo(info);
580 audioCapturer->Start();
581 audioCapturer->Read(buffer, framesize, false);
582 EXPECT_TRUE(sizeof(buffer) > 0);
583 audioCapturer->Release();
584 delete audioCapturer;
585 }
586
587 /*
588 * Feature: Audiolite
589 * Function: audioCapturer
590 * SubFunction: NA
591 * FunctionPoints: NA
592 * EnvConditions: NA
593 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 8; Sample Rate 24000; Bit Rate 24000
594 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_019,Level1)595 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_019, Level1)
596 {
597 AudioCapturer *audioCapturer = new AudioCapturer();
598 AudioCapturerInfo info;
599 info.inputSource = AUDIO_MIC;
600 info.audioFormat = AUDIO_DEFAULT;
601 info.sampleRate = 24000;
602 info.channelCount = 1;
603 info.bitRate = 24000;
604 info.streamType = TYPE_MEDIA;
605 info.bitWidth = BIT_WIDTH_8;
606 uint64_t frameCnt = audioCapturer->GetFrameCount();
607 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
608 uint8_t *buffer;
609 audioCapturer->SetCapturerInfo(info);
610 audioCapturer->Start();
611 audioCapturer->Read(buffer, framesize, false);
612 EXPECT_TRUE(sizeof(buffer) > 0);
613 audioCapturer->Release();
614 delete audioCapturer;
615 }
616
617 /*
618 * Feature: Audiolite
619 * Function: audioCapturer
620 * SubFunction: NA
621 * FunctionPoints: NA
622 * EnvConditions: NA
623 * CaseDescription: Audio Capture Test-Format DEFAULT; Channel 1; Bit_width 8; Sample Rate 48000; Bit Rate 48000
624 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_020,Level1)625 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_020, Level1)
626 {
627 AudioCapturer *audioCapturer = new AudioCapturer();
628 AudioCapturerInfo info;
629 info.inputSource = AUDIO_MIC;
630 info.audioFormat = AUDIO_DEFAULT;
631 info.sampleRate = 48000;
632 info.channelCount = 1;
633 info.bitRate = 48000;
634 info.streamType = TYPE_MEDIA;
635 info.bitWidth = BIT_WIDTH_8;
636 uint64_t frameCnt = audioCapturer->GetFrameCount();
637 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
638 uint8_t *buffer;
639 audioCapturer->SetCapturerInfo(info);
640 audioCapturer->Start();
641 audioCapturer->Read(buffer, framesize, false);
642 EXPECT_TRUE(sizeof(buffer) > 0);
643 audioCapturer->Release();
644 delete audioCapturer;
645 }
646
647 /*
648 * Feature: Audiolite
649 * Function: audioCapturer
650 * SubFunction: NA
651 * FunctionPoints: NA
652 * EnvConditions: NA
653 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 16; Sample Rate 8000; Bit Rate 8000
654 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_021,Level1)655 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_021, Level1)
656 {
657 AudioCapturer *audioCapturer = new AudioCapturer();
658 AudioCapturerInfo info;
659 info.inputSource = AUDIO_MIC;
660 info.audioFormat = AAC_LC;
661 info.sampleRate = 8000;
662 info.channelCount = 1;
663 info.bitRate = 8000;
664 info.streamType = TYPE_MEDIA;
665 info.bitWidth = BIT_WIDTH_16;
666 uint64_t frameCnt = audioCapturer->GetFrameCount();
667 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
668 uint8_t *buffer;
669 audioCapturer->SetCapturerInfo(info);
670 audioCapturer->Start();
671 audioCapturer->Read(buffer, framesize, false);
672 EXPECT_TRUE(sizeof(buffer) > 0);
673 audioCapturer->Release();
674 delete audioCapturer;
675 }
676
677 /*
678 * Feature: Audiolite
679 * Function: audioCapturer
680 * SubFunction: NA
681 * FunctionPoints: NA
682 * EnvConditions: NA
683 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 16; Sample Rate 16000; Bit Rate 16000
684 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_022,Level1)685 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_022, Level1)
686 {
687 AudioCapturer *audioCapturer = new AudioCapturer();
688 AudioCapturerInfo info;
689 info.inputSource = AUDIO_MIC;
690 info.audioFormat = AAC_LC;
691 info.sampleRate = 16000;
692 info.channelCount = 1;
693 info.bitRate = 16000;
694 info.streamType = TYPE_MEDIA;
695 info.bitWidth = BIT_WIDTH_16;
696 uint64_t frameCnt = audioCapturer->GetFrameCount();
697 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
698 uint8_t *buffer;
699 audioCapturer->SetCapturerInfo(info);
700 audioCapturer->Start();
701 audioCapturer->Read(buffer, framesize, false);
702 EXPECT_TRUE(sizeof(buffer) > 0);
703 audioCapturer->Release();
704 delete audioCapturer;
705 }
706
707 /*
708 * Feature: Audiolite
709 * Function: audioCapturer
710 * SubFunction: NA
711 * FunctionPoints: NA
712 * EnvConditions: NA
713 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 16; Sample Rate 32000; Bit Rate 32000
714 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_023,Level1)715 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_023, Level1)
716 {
717 AudioCapturer *audioCapturer = new AudioCapturer();
718 AudioCapturerInfo info;
719 info.inputSource = AUDIO_MIC;
720 info.audioFormat = AAC_LC;
721 info.sampleRate = 32000;
722 info.channelCount = 1;
723 info.bitRate = 32000;
724 info.streamType = TYPE_MEDIA;
725 info.bitWidth = BIT_WIDTH_16;
726 uint64_t frameCnt = audioCapturer->GetFrameCount();
727 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
728 uint8_t *buffer;
729 audioCapturer->SetCapturerInfo(info);
730 audioCapturer->Start();
731 audioCapturer->Read(buffer, framesize, false);
732 EXPECT_TRUE(sizeof(buffer) > 0);
733 audioCapturer->Release();
734 delete audioCapturer;
735 }
736
737 /*
738 * Feature: Audiolite
739 * Function: audioCapturer
740 * SubFunction: NA
741 * FunctionPoints: NA
742 * EnvConditions: NA
743 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 16; Sample Rate 24000; Bit Rate 24000
744 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_024,Level1)745 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_024, Level1)
746 {
747 AudioCapturer *audioCapturer = new AudioCapturer();
748 AudioCapturerInfo info;
749 info.inputSource = AUDIO_MIC;
750 info.audioFormat = AAC_LC;
751 info.sampleRate = 24000;
752 info.channelCount = 1;
753 info.bitRate = 24000;
754 info.streamType = TYPE_MEDIA;
755 info.bitWidth = BIT_WIDTH_16;
756 uint64_t frameCnt = audioCapturer->GetFrameCount();
757 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
758 uint8_t *buffer;
759 audioCapturer->SetCapturerInfo(info);
760 audioCapturer->Start();
761 audioCapturer->Read(buffer, framesize, false);
762 EXPECT_TRUE(sizeof(buffer) > 0);
763 audioCapturer->Release();
764 delete audioCapturer;
765 }
766
767 /*
768 * Feature: Audiolite
769 * Function: audioCapturer
770 * SubFunction: NA
771 * FunctionPoints: NA
772 * EnvConditions: NA
773 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 16; Sample Rate 48000; Bit Rate 48000
774 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_025,Level1)775 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_025, Level1)
776 {
777 AudioCapturer *audioCapturer = new AudioCapturer();
778 AudioCapturerInfo info;
779 info.inputSource = AUDIO_MIC;
780 info.audioFormat = AAC_LC;
781 info.sampleRate = 48000;
782 info.channelCount = 1;
783 info.bitRate = 48000;
784 info.streamType = TYPE_MEDIA;
785 info.bitWidth = BIT_WIDTH_16;
786 uint64_t frameCnt = audioCapturer->GetFrameCount();
787 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
788 uint8_t *buffer;
789 audioCapturer->SetCapturerInfo(info);
790 audioCapturer->Start();
791 audioCapturer->Read(buffer, framesize, false);
792 EXPECT_TRUE(sizeof(buffer) > 0);
793 audioCapturer->Release();
794 delete audioCapturer;
795 }
796
797 /*
798 * Feature: Audiolite
799 * Function: audioCapturer
800 * SubFunction: NA
801 * FunctionPoints: NA
802 * EnvConditions: NA
803 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 16; Sample Rate 8000; Bit Rate 8000
804 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_026,Level1)805 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_026, Level1)
806 {
807 AudioCapturer *audioCapturer = new AudioCapturer();
808 AudioCapturerInfo info;
809 info.inputSource = AUDIO_MIC;
810 info.audioFormat = AAC_LC;
811 info.sampleRate = 8000;
812 info.channelCount = 2;
813 info.bitRate = 8000;
814 info.streamType = TYPE_MEDIA;
815 info.bitWidth = BIT_WIDTH_16;
816 uint64_t frameCnt = audioCapturer->GetFrameCount();
817 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
818 uint8_t *buffer;
819 audioCapturer->SetCapturerInfo(info);
820 audioCapturer->Start();
821 audioCapturer->Read(buffer, framesize, false);
822 EXPECT_TRUE(sizeof(buffer) > 0);
823 audioCapturer->Release();
824 delete audioCapturer;
825 }
826
827 /*
828 * Feature: Audiolite
829 * Function: audioCapturer
830 * SubFunction: NA
831 * FunctionPoints: NA
832 * EnvConditions: NA
833 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 16; Sample Rate 16000; Bit Rate 16000
834 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_027,Level1)835 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_027, Level1)
836 {
837 AudioCapturer *audioCapturer = new AudioCapturer();
838 AudioCapturerInfo info;
839 info.inputSource = AUDIO_MIC;
840 info.audioFormat = AAC_LC;
841 info.sampleRate = 16000;
842 info.channelCount = 2;
843 info.bitRate = 16000;
844 info.streamType = TYPE_MEDIA;
845 info.bitWidth = BIT_WIDTH_16;
846 uint64_t frameCnt = audioCapturer->GetFrameCount();
847 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
848 uint8_t *buffer;
849 audioCapturer->SetCapturerInfo(info);
850 audioCapturer->Start();
851 audioCapturer->Read(buffer, framesize, false);
852 EXPECT_TRUE(sizeof(buffer) > 0);
853 audioCapturer->Release();
854 delete audioCapturer;
855 }
856
857 /*
858 * Feature: Audiolite
859 * Function: audioCapturer
860 * SubFunction: NA
861 * FunctionPoints: NA
862 * EnvConditions: NA
863 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 16; Sample Rate 32000; Bit Rate 32000
864 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_028,Level1)865 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_028, Level1)
866 {
867 AudioCapturer *audioCapturer = new AudioCapturer();
868 AudioCapturerInfo info;
869 info.inputSource = AUDIO_MIC;
870 info.audioFormat = AAC_LC;
871 info.sampleRate = 32000;
872 info.channelCount = 2;
873 info.bitRate = 32000;
874 info.streamType = TYPE_MEDIA;
875 info.bitWidth = BIT_WIDTH_16;
876 uint64_t frameCnt = audioCapturer->GetFrameCount();
877 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
878 uint8_t *buffer;
879 audioCapturer->SetCapturerInfo(info);
880 audioCapturer->Start();
881 audioCapturer->Read(buffer, framesize, false);
882 EXPECT_TRUE(sizeof(buffer) > 0);
883 audioCapturer->Release();
884 delete audioCapturer;
885 }
886
887 /*
888 * Feature: Audiolite
889 * Function: audioCapturer
890 * SubFunction: NA
891 * FunctionPoints: NA
892 * EnvConditions: NA
893 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 16; Sample Rate 24000; Bit Rate 24000
894 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_029,Level1)895 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_029, Level1)
896 {
897 AudioCapturer *audioCapturer = new AudioCapturer();
898 AudioCapturerInfo info;
899 info.inputSource = AUDIO_MIC;
900 info.audioFormat = AAC_LC;
901 info.sampleRate = 24000;
902 info.channelCount = 2;
903 info.bitRate = 24000;
904 info.streamType = TYPE_MEDIA;
905 info.bitWidth = BIT_WIDTH_16;
906 uint64_t frameCnt = audioCapturer->GetFrameCount();
907 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
908 uint8_t *buffer;
909 audioCapturer->SetCapturerInfo(info);
910 audioCapturer->Start();
911 audioCapturer->Read(buffer, framesize, false);
912 EXPECT_TRUE(sizeof(buffer) > 0);
913 audioCapturer->Release();
914 delete audioCapturer;
915 }
916
917 /*
918 * Feature: Audiolite
919 * Function: audioCapturer
920 * SubFunction: NA
921 * FunctionPoints: NA
922 * EnvConditions: NA
923 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 16; Sample Rate 48000; Bit Rate 48000
924 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_030,Level1)925 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_030, Level1)
926 {
927 AudioCapturer *audioCapturer = new AudioCapturer();
928 AudioCapturerInfo info;
929 info.inputSource = AUDIO_MIC;
930 info.audioFormat = AAC_LC;
931 info.sampleRate = 48000;
932 info.channelCount = 2;
933 info.bitRate = 48000;
934 info.streamType = TYPE_MEDIA;
935 info.bitWidth = BIT_WIDTH_16;
936 uint64_t frameCnt = audioCapturer->GetFrameCount();
937 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
938 uint8_t *buffer;
939 audioCapturer->SetCapturerInfo(info);
940 audioCapturer->Start();
941 audioCapturer->Read(buffer, framesize, false);
942 EXPECT_TRUE(sizeof(buffer) > 0);
943 audioCapturer->Release();
944 delete audioCapturer;
945 }
946
947 /*
948 * Feature: Audiolite
949 * Function: audioCapturer
950 * SubFunction: NA
951 * FunctionPoints: NA
952 * EnvConditions: NA
953 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 8; Sample Rate 8000; Bit Rate 8000
954 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_031,Level1)955 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_031, Level1)
956 {
957 AudioCapturer *audioCapturer = new AudioCapturer();
958 AudioCapturerInfo info;
959 info.inputSource = AUDIO_MIC;
960 info.audioFormat = AAC_LC;
961 info.sampleRate = 8000;
962 info.channelCount = 2;
963 info.bitRate = 8000;
964 info.streamType = TYPE_MEDIA;
965 info.bitWidth = BIT_WIDTH_8;
966 uint64_t frameCnt = audioCapturer->GetFrameCount();
967 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
968 uint8_t *buffer;
969 audioCapturer->SetCapturerInfo(info);
970 audioCapturer->Start();
971 audioCapturer->Read(buffer, framesize, false);
972 EXPECT_TRUE(sizeof(buffer) > 0);
973 audioCapturer->Release();
974 delete audioCapturer;
975 }
976
977 /*
978 * Feature: Audiolite
979 * Function: audioCapturer
980 * SubFunction: NA
981 * FunctionPoints: NA
982 * EnvConditions: NA
983 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 8; Sample Rate 16000; Bit Rate 16000
984 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_032,Level1)985 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_032, Level1)
986 {
987 AudioCapturer *audioCapturer = new AudioCapturer();
988 AudioCapturerInfo info;
989 info.inputSource = AUDIO_MIC;
990 info.audioFormat = AAC_LC;
991 info.sampleRate = 16000;
992 info.channelCount = 2;
993 info.bitRate = 16000;
994 info.streamType = TYPE_MEDIA;
995 info.bitWidth = BIT_WIDTH_8;
996 uint64_t frameCnt = audioCapturer->GetFrameCount();
997 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
998 uint8_t *buffer;
999 audioCapturer->SetCapturerInfo(info);
1000 audioCapturer->Start();
1001 audioCapturer->Read(buffer, framesize, false);
1002 EXPECT_TRUE(sizeof(buffer) > 0);
1003 audioCapturer->Release();
1004 delete audioCapturer;
1005 }
1006
1007 /*
1008 * Feature: Audiolite
1009 * Function: audioCapturer
1010 * SubFunction: NA
1011 * FunctionPoints: NA
1012 * EnvConditions: NA
1013 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 8; Sample Rate 32000; Bit Rate 32000
1014 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_033,Level1)1015 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_033, Level1)
1016 {
1017 AudioCapturer *audioCapturer = new AudioCapturer();
1018 AudioCapturerInfo info;
1019 info.inputSource = AUDIO_MIC;
1020 info.audioFormat = AAC_LC;
1021 info.sampleRate = 32000;
1022 info.channelCount = 2;
1023 info.bitRate = 32000;
1024 info.streamType = TYPE_MEDIA;
1025 info.bitWidth = BIT_WIDTH_8;
1026 uint64_t frameCnt = audioCapturer->GetFrameCount();
1027 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1028 uint8_t *buffer;
1029 audioCapturer->SetCapturerInfo(info);
1030 audioCapturer->Start();
1031 audioCapturer->Read(buffer, framesize, false);
1032 EXPECT_TRUE(sizeof(buffer) > 0);
1033 audioCapturer->Release();
1034 delete audioCapturer;
1035 }
1036
1037 /*
1038 * Feature: Audiolite
1039 * Function: audioCapturer
1040 * SubFunction: NA
1041 * FunctionPoints: NA
1042 * EnvConditions: NA
1043 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 8; Sample Rate 24000; Bit Rate 24000
1044 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_034,Level1)1045 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_034, Level1)
1046 {
1047 AudioCapturer *audioCapturer = new AudioCapturer();
1048 AudioCapturerInfo info;
1049 info.inputSource = AUDIO_MIC;
1050 info.audioFormat = AAC_LC;
1051 info.sampleRate = 24000;
1052 info.channelCount = 2;
1053 info.bitRate = 24000;
1054 info.streamType = TYPE_MEDIA;
1055 info.bitWidth = BIT_WIDTH_8;
1056 uint64_t frameCnt = audioCapturer->GetFrameCount();
1057 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1058 uint8_t *buffer;
1059 audioCapturer->SetCapturerInfo(info);
1060 audioCapturer->Start();
1061 audioCapturer->Read(buffer, framesize, false);
1062 EXPECT_TRUE(sizeof(buffer) > 0);
1063 audioCapturer->Release();
1064 delete audioCapturer;
1065 }
1066
1067 /*
1068 * Feature: Audiolite
1069 * Function: audioCapturer
1070 * SubFunction: NA
1071 * FunctionPoints: NA
1072 * EnvConditions: NA
1073 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 2; Bit_width 8; Sample Rate 48000; Bit Rate 48000
1074 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_035,Level1)1075 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_035, Level1)
1076 {
1077 AudioCapturer *audioCapturer = new AudioCapturer();
1078 AudioCapturerInfo info;
1079 info.inputSource = AUDIO_MIC;
1080 info.audioFormat = AAC_LC;
1081 info.sampleRate = 48000;
1082 info.channelCount = 2;
1083 info.bitRate = 48000;
1084 info.streamType = TYPE_MEDIA;
1085 info.bitWidth = BIT_WIDTH_8;
1086 uint64_t frameCnt = audioCapturer->GetFrameCount();
1087 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1088 uint8_t *buffer;
1089 audioCapturer->SetCapturerInfo(info);
1090 audioCapturer->Start();
1091 audioCapturer->Read(buffer, framesize, false);
1092 EXPECT_TRUE(sizeof(buffer) > 0);
1093 audioCapturer->Release();
1094 delete audioCapturer;
1095 }
1096
1097 /*
1098 * Feature: Audiolite
1099 * Function: audioCapturer
1100 * SubFunction: NA
1101 * FunctionPoints: NA
1102 * EnvConditions: NA
1103 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 8; Sample Rate 8000; Bit Rate 8000
1104 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_036,Level1)1105 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_036, Level1)
1106 {
1107 AudioCapturer *audioCapturer = new AudioCapturer();
1108 AudioCapturerInfo info;
1109 info.inputSource = AUDIO_MIC;
1110 info.audioFormat = AAC_LC;
1111 info.sampleRate = 8000;
1112 info.channelCount = 1;
1113 info.bitRate = 8000;
1114 info.streamType = TYPE_MEDIA;
1115 info.bitWidth = BIT_WIDTH_8;
1116 uint64_t frameCnt = audioCapturer->GetFrameCount();
1117 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1118 uint8_t *buffer;
1119 audioCapturer->SetCapturerInfo(info);
1120 audioCapturer->Start();
1121 audioCapturer->Read(buffer, framesize, false);
1122 EXPECT_TRUE(sizeof(buffer) > 0);
1123 audioCapturer->Release();
1124 delete audioCapturer;
1125 }
1126
1127 /*
1128 * Feature: Audiolite
1129 * Function: audioCapturer
1130 * SubFunction: NA
1131 * FunctionPoints: NA
1132 * EnvConditions: NA
1133 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 8; Sample Rate 16000; Bit Rate 16000
1134 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_037,Level1)1135 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_037, Level1)
1136 {
1137 AudioCapturer *audioCapturer = new AudioCapturer();
1138 AudioCapturerInfo info;
1139 info.inputSource = AUDIO_MIC;
1140 info.audioFormat = AAC_LC;
1141 info.sampleRate = 16000;
1142 info.channelCount = 1;
1143 info.bitRate = 16000;
1144 info.streamType = TYPE_MEDIA;
1145 info.bitWidth = BIT_WIDTH_8;
1146 uint64_t frameCnt = audioCapturer->GetFrameCount();
1147 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1148 uint8_t *buffer;
1149 audioCapturer->SetCapturerInfo(info);
1150 audioCapturer->Start();
1151 audioCapturer->Read(buffer, framesize, false);
1152 EXPECT_TRUE(sizeof(buffer) > 0);
1153 audioCapturer->Release();
1154 delete audioCapturer;
1155 }
1156
1157 /*
1158 * Feature: Audiolite
1159 * Function: audioCapturer
1160 * SubFunction: NA
1161 * FunctionPoints: NA
1162 * EnvConditions: NA
1163 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 8; Sample Rate 32000; Bit Rate 32000
1164 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_038,Level1)1165 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_038, Level1)
1166 {
1167 AudioCapturer *audioCapturer = new AudioCapturer();
1168 AudioCapturerInfo info;
1169 info.inputSource = AUDIO_MIC;
1170 info.audioFormat = AAC_LC;
1171 info.sampleRate = 32000;
1172 info.channelCount = 1;
1173 info.bitRate = 32000;
1174 info.streamType = TYPE_MEDIA;
1175 info.bitWidth = BIT_WIDTH_8;
1176 uint64_t frameCnt = audioCapturer->GetFrameCount();
1177 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1178 uint8_t *buffer;
1179 audioCapturer->SetCapturerInfo(info);
1180 audioCapturer->Start();
1181 audioCapturer->Read(buffer, framesize, false);
1182 EXPECT_TRUE(sizeof(buffer) > 0);
1183 audioCapturer->Release();
1184 delete audioCapturer;
1185 }
1186
1187 /*
1188 * Feature: Audiolite
1189 * Function: audioCapturer
1190 * SubFunction: NA
1191 * FunctionPoints: NA
1192 * EnvConditions: NA
1193 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 8; Sample Rate 24000; Bit Rate 24000
1194 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_039,Level1)1195 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_039, Level1)
1196 {
1197 AudioCapturer *audioCapturer = new AudioCapturer();
1198 AudioCapturerInfo info;
1199 info.inputSource = AUDIO_MIC;
1200 info.audioFormat = AAC_LC;
1201 info.sampleRate = 24000;
1202 info.channelCount = 1;
1203 info.bitRate = 24000;
1204 info.streamType = TYPE_MEDIA;
1205 info.bitWidth = BIT_WIDTH_8;
1206 uint64_t frameCnt = audioCapturer->GetFrameCount();
1207 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1208 uint8_t *buffer;
1209 audioCapturer->SetCapturerInfo(info);
1210 audioCapturer->Start();
1211 audioCapturer->Read(buffer, framesize, false);
1212 EXPECT_TRUE(sizeof(buffer) > 0);
1213 audioCapturer->Release();
1214 delete audioCapturer;
1215 }
1216
1217 /*
1218 * Feature: Audiolite
1219 * Function: audioCapturer
1220 * SubFunction: NA
1221 * FunctionPoints: NA
1222 * EnvConditions: NA
1223 * CaseDescription: Audio Capture Test-Format AAC_LC; Channel 1; Bit_width 8; Sample Rate 48000; Bit Rate 48000
1224 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_040,Level1)1225 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_040, Level1)
1226 {
1227 AudioCapturer *audioCapturer = new AudioCapturer();
1228 AudioCapturerInfo info;
1229 info.inputSource = AUDIO_MIC;
1230 info.audioFormat = AAC_LC;
1231 info.sampleRate = 48000;
1232 info.channelCount = 1;
1233 info.bitRate = 48000;
1234 info.streamType = TYPE_MEDIA;
1235 info.bitWidth = BIT_WIDTH_8;
1236 uint64_t frameCnt = audioCapturer->GetFrameCount();
1237 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1238 uint8_t *buffer;
1239 audioCapturer->SetCapturerInfo(info);
1240 audioCapturer->Start();
1241 audioCapturer->Read(buffer, framesize, false);
1242 EXPECT_TRUE(sizeof(buffer) > 0);
1243 audioCapturer->Release();
1244 delete audioCapturer;
1245 }
1246
1247 /*
1248 * Feature: Audiolite
1249 * Function: audioCapturer
1250 * SubFunction: NA
1251 * FunctionPoints: NA
1252 * EnvConditions: NA
1253 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 16; Sample Rate 8000; Bit Rate 8000
1254 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_041,Level1)1255 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_041, Level1)
1256 {
1257 AudioCapturer *audioCapturer = new AudioCapturer();
1258 AudioCapturerInfo info;
1259 info.inputSource = AUDIO_MIC;
1260 info.audioFormat = AAC_HE_V1;
1261 info.sampleRate = 8000;
1262 info.channelCount = 1;
1263 info.bitRate = 8000;
1264 info.streamType = TYPE_MEDIA;
1265 info.bitWidth = BIT_WIDTH_16;
1266 uint64_t frameCnt = audioCapturer->GetFrameCount();
1267 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1268 uint8_t *buffer;
1269 audioCapturer->SetCapturerInfo(info);
1270 audioCapturer->Start();
1271 audioCapturer->Read(buffer, framesize, false);
1272 EXPECT_TRUE(sizeof(buffer) > 0);
1273 audioCapturer->Release();
1274 delete audioCapturer;
1275 }
1276
1277 /*
1278 * Feature: Audiolite
1279 * Function: audioCapturer
1280 * SubFunction: NA
1281 * FunctionPoints: NA
1282 * EnvConditions: NA
1283 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 16; Sample Rate 16000; Bit Rate 16000
1284 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_042,Level1)1285 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_042, Level1)
1286 {
1287 AudioCapturer *audioCapturer = new AudioCapturer();
1288 AudioCapturerInfo info;
1289 info.inputSource = AUDIO_MIC;
1290 info.audioFormat = AAC_HE_V1;
1291 info.sampleRate = 16000;
1292 info.channelCount = 1;
1293 info.bitRate = 16000;
1294 info.streamType = TYPE_MEDIA;
1295 info.bitWidth = BIT_WIDTH_16;
1296 uint64_t frameCnt = audioCapturer->GetFrameCount();
1297 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1298 uint8_t *buffer;
1299 audioCapturer->SetCapturerInfo(info);
1300 audioCapturer->Start();
1301 audioCapturer->Read(buffer, framesize, false);
1302 EXPECT_TRUE(sizeof(buffer) > 0);
1303 audioCapturer->Release();
1304 delete audioCapturer;
1305 }
1306
1307 /*
1308 * Feature: Audiolite
1309 * Function: audioCapturer
1310 * SubFunction: NA
1311 * FunctionPoints: NA
1312 * EnvConditions: NA
1313 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 16; Sample Rate 32000; Bit Rate 32000
1314 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_043,Level1)1315 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_043, Level1)
1316 {
1317 AudioCapturer *audioCapturer = new AudioCapturer();
1318 AudioCapturerInfo info;
1319 info.inputSource = AUDIO_MIC;
1320 info.audioFormat = AAC_HE_V1;
1321 info.sampleRate = 32000;
1322 info.channelCount = 1;
1323 info.bitRate = 32000;
1324 info.streamType = TYPE_MEDIA;
1325 info.bitWidth = BIT_WIDTH_16;
1326 uint64_t frameCnt = audioCapturer->GetFrameCount();
1327 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1328 uint8_t *buffer;
1329 audioCapturer->SetCapturerInfo(info);
1330 audioCapturer->Start();
1331 audioCapturer->Read(buffer, framesize, false);
1332 EXPECT_TRUE(sizeof(buffer) > 0);
1333 audioCapturer->Release();
1334 delete audioCapturer;
1335 }
1336
1337 /*
1338 * Feature: Audiolite
1339 * Function: audioCapturer
1340 * SubFunction: NA
1341 * FunctionPoints: NA
1342 * EnvConditions: NA
1343 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 16; Sample Rate 24000; Bit Rate 24000
1344 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_044,Level1)1345 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_044, Level1)
1346 {
1347 AudioCapturer *audioCapturer = new AudioCapturer();
1348 AudioCapturerInfo info;
1349 info.inputSource = AUDIO_MIC;
1350 info.audioFormat = AAC_HE_V1;
1351 info.sampleRate = 24000;
1352 info.channelCount = 1;
1353 info.bitRate = 24000;
1354 info.streamType = TYPE_MEDIA;
1355 info.bitWidth = BIT_WIDTH_16;
1356 uint64_t frameCnt = audioCapturer->GetFrameCount();
1357 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1358 uint8_t *buffer;
1359 audioCapturer->SetCapturerInfo(info);
1360 audioCapturer->Start();
1361 audioCapturer->Read(buffer, framesize, false);
1362 EXPECT_TRUE(sizeof(buffer) > 0);
1363 audioCapturer->Release();
1364 delete audioCapturer;
1365 }
1366
1367 /*
1368 * Feature: Audiolite
1369 * Function: audioCapturer
1370 * SubFunction: NA
1371 * FunctionPoints: NA
1372 * EnvConditions: NA
1373 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 16; Sample Rate 48000; Bit Rate 48000
1374 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_045,Level1)1375 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_045, Level1)
1376 {
1377 AudioCapturer *audioCapturer = new AudioCapturer();
1378 AudioCapturerInfo info;
1379 info.inputSource = AUDIO_MIC;
1380 info.audioFormat = AAC_HE_V1;
1381 info.sampleRate = 48000;
1382 info.channelCount = 1;
1383 info.bitRate = 48000;
1384 info.streamType = TYPE_MEDIA;
1385 info.bitWidth = BIT_WIDTH_16;
1386 uint64_t frameCnt = audioCapturer->GetFrameCount();
1387 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1388 uint8_t *buffer;
1389 audioCapturer->SetCapturerInfo(info);
1390 audioCapturer->Start();
1391 audioCapturer->Read(buffer, framesize, false);
1392 EXPECT_TRUE(sizeof(buffer) > 0);
1393 audioCapturer->Release();
1394 delete audioCapturer;
1395 }
1396
1397 /*
1398 * Feature: Audiolite
1399 * Function: audioCapturer
1400 * SubFunction: NA
1401 * FunctionPoints: NA
1402 * EnvConditions: NA
1403 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 16; Sample Rate 8000; Bit Rate 8000
1404 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_046,Level1)1405 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_046, Level1)
1406 {
1407 AudioCapturer *audioCapturer = new AudioCapturer();
1408 AudioCapturerInfo info;
1409 info.inputSource = AUDIO_MIC;
1410 info.audioFormat = AAC_HE_V1;
1411 info.sampleRate = 8000;
1412 info.channelCount = 2;
1413 info.bitRate = 8000;
1414 info.streamType = TYPE_MEDIA;
1415 info.bitWidth = BIT_WIDTH_16;
1416 uint64_t frameCnt = audioCapturer->GetFrameCount();
1417 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1418 uint8_t *buffer;
1419 audioCapturer->SetCapturerInfo(info);
1420 audioCapturer->Start();
1421 audioCapturer->Read(buffer, framesize, false);
1422 EXPECT_TRUE(sizeof(buffer) > 0);
1423 audioCapturer->Release();
1424 delete audioCapturer;
1425 }
1426
1427 /*
1428 * Feature: Audiolite
1429 * Function: audioCapturer
1430 * SubFunction: NA
1431 * FunctionPoints: NA
1432 * EnvConditions: NA
1433 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 16; Sample Rate 16000; Bit Rate 16000
1434 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_047,Level1)1435 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_047, Level1)
1436 {
1437 AudioCapturer *audioCapturer = new AudioCapturer();
1438 AudioCapturerInfo info;
1439 info.inputSource = AUDIO_MIC;
1440 info.audioFormat = AAC_HE_V1;
1441 info.sampleRate = 16000;
1442 info.channelCount = 2;
1443 info.bitRate = 16000;
1444 info.streamType = TYPE_MEDIA;
1445 info.bitWidth = BIT_WIDTH_16;
1446 uint64_t frameCnt = audioCapturer->GetFrameCount();
1447 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1448 uint8_t *buffer;
1449 audioCapturer->SetCapturerInfo(info);
1450 audioCapturer->Start();
1451 audioCapturer->Read(buffer, framesize, false);
1452 EXPECT_TRUE(sizeof(buffer) > 0);
1453 audioCapturer->Release();
1454 delete audioCapturer;
1455 }
1456
1457 /*
1458 * Feature: Audiolite
1459 * Function: audioCapturer
1460 * SubFunction: NA
1461 * FunctionPoints: NA
1462 * EnvConditions: NA
1463 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 16; Sample Rate 32000; Bit Rate 32000
1464 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_048,Level1)1465 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_048, Level1)
1466 {
1467 AudioCapturer *audioCapturer = new AudioCapturer();
1468 AudioCapturerInfo info;
1469 info.inputSource = AUDIO_MIC;
1470 info.audioFormat = AAC_HE_V1;
1471 info.sampleRate = 32000;
1472 info.channelCount = 2;
1473 info.bitRate = 32000;
1474 info.streamType = TYPE_MEDIA;
1475 info.bitWidth = BIT_WIDTH_16;
1476 uint64_t frameCnt = audioCapturer->GetFrameCount();
1477 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1478 uint8_t *buffer;
1479 audioCapturer->SetCapturerInfo(info);
1480 audioCapturer->Start();
1481 audioCapturer->Read(buffer, framesize, false);
1482 EXPECT_TRUE(sizeof(buffer) > 0);
1483 audioCapturer->Release();
1484 delete audioCapturer;
1485 }
1486
1487 /*
1488 * Feature: Audiolite
1489 * Function: audioCapturer
1490 * SubFunction: NA
1491 * FunctionPoints: NA
1492 * EnvConditions: NA
1493 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 16; Sample Rate 24000; Bit Rate 24000
1494 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_049,Level1)1495 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_049, Level1)
1496 {
1497 AudioCapturer *audioCapturer = new AudioCapturer();
1498 AudioCapturerInfo info;
1499 info.inputSource = AUDIO_MIC;
1500 info.audioFormat = AAC_HE_V1;
1501 info.sampleRate = 24000;
1502 info.channelCount = 2;
1503 info.bitRate = 24000;
1504 info.streamType = TYPE_MEDIA;
1505 info.bitWidth = BIT_WIDTH_16;
1506 uint64_t frameCnt = audioCapturer->GetFrameCount();
1507 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1508 uint8_t *buffer;
1509 audioCapturer->SetCapturerInfo(info);
1510 audioCapturer->Start();
1511 audioCapturer->Read(buffer, framesize, false);
1512 EXPECT_TRUE(sizeof(buffer) > 0);
1513 audioCapturer->Release();
1514 delete audioCapturer;
1515 }
1516
1517 /*
1518 * Feature: Audiolite
1519 * Function: audioCapturer
1520 * SubFunction: NA
1521 * FunctionPoints: NA
1522 * EnvConditions: NA
1523 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 16; Sample Rate 48000; Bit Rate 48000
1524 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_050,Level1)1525 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_050, Level1)
1526 {
1527 AudioCapturer *audioCapturer = new AudioCapturer();
1528 AudioCapturerInfo info;
1529 info.inputSource = AUDIO_MIC;
1530 info.audioFormat = AAC_HE_V1;
1531 info.sampleRate = 48000;
1532 info.channelCount = 2;
1533 info.bitRate = 48000;
1534 info.streamType = TYPE_MEDIA;
1535 info.bitWidth = BIT_WIDTH_16;
1536 uint64_t frameCnt = audioCapturer->GetFrameCount();
1537 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1538 uint8_t *buffer;
1539 audioCapturer->SetCapturerInfo(info);
1540 audioCapturer->Start();
1541 audioCapturer->Read(buffer, framesize, false);
1542 EXPECT_TRUE(sizeof(buffer) > 0);
1543 audioCapturer->Release();
1544 delete audioCapturer;
1545 }
1546
1547 /*
1548 * Feature: Audiolite
1549 * Function: audioCapturer
1550 * SubFunction: NA
1551 * FunctionPoints: NA
1552 * EnvConditions: NA
1553 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 8; Sample Rate 8000; Bit Rate 8000
1554 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_051,Level1)1555 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_051, Level1)
1556 {
1557 AudioCapturer *audioCapturer = new AudioCapturer();
1558 AudioCapturerInfo info;
1559 info.inputSource = AUDIO_MIC;
1560 info.audioFormat = AAC_HE_V1;
1561 info.sampleRate = 8000;
1562 info.channelCount = 2;
1563 info.bitRate = 8000;
1564 info.streamType = TYPE_MEDIA;
1565 info.bitWidth = BIT_WIDTH_8;
1566 uint64_t frameCnt = audioCapturer->GetFrameCount();
1567 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1568 uint8_t *buffer;
1569 audioCapturer->SetCapturerInfo(info);
1570 audioCapturer->Start();
1571 audioCapturer->Read(buffer, framesize, false);
1572 EXPECT_TRUE(sizeof(buffer) > 0);
1573 audioCapturer->Release();
1574 delete audioCapturer;
1575 }
1576
1577 /*
1578 * Feature: Audiolite
1579 * Function: audioCapturer
1580 * SubFunction: NA
1581 * FunctionPoints: NA
1582 * EnvConditions: NA
1583 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 8; Sample Rate 16000; Bit Rate 16000
1584 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_052,Level1)1585 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_052, Level1)
1586 {
1587 AudioCapturer *audioCapturer = new AudioCapturer();
1588 AudioCapturerInfo info;
1589 info.inputSource = AUDIO_MIC;
1590 info.audioFormat = AAC_HE_V1;
1591 info.sampleRate = 16000;
1592 info.channelCount = 2;
1593 info.bitRate = 16000;
1594 info.streamType = TYPE_MEDIA;
1595 info.bitWidth = BIT_WIDTH_8;
1596 uint64_t frameCnt = audioCapturer->GetFrameCount();
1597 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1598 uint8_t *buffer;
1599 audioCapturer->SetCapturerInfo(info);
1600 audioCapturer->Start();
1601 audioCapturer->Read(buffer, framesize, false);
1602 EXPECT_TRUE(sizeof(buffer) > 0);
1603 audioCapturer->Release();
1604 delete audioCapturer;
1605 }
1606
1607 /*
1608 * Feature: Audiolite
1609 * Function: audioCapturer
1610 * SubFunction: NA
1611 * FunctionPoints: NA
1612 * EnvConditions: NA
1613 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 8; Sample Rate 32000; Bit Rate 32000
1614 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_053,Level1)1615 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_053, Level1)
1616 {
1617 AudioCapturer *audioCapturer = new AudioCapturer();
1618 AudioCapturerInfo info;
1619 info.inputSource = AUDIO_MIC;
1620 info.audioFormat = AAC_HE_V1;
1621 info.sampleRate = 32000;
1622 info.channelCount = 2;
1623 info.bitRate = 32000;
1624 info.streamType = TYPE_MEDIA;
1625 info.bitWidth = BIT_WIDTH_8;
1626 uint64_t frameCnt = audioCapturer->GetFrameCount();
1627 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1628 uint8_t *buffer;
1629 audioCapturer->SetCapturerInfo(info);
1630 audioCapturer->Start();
1631 audioCapturer->Read(buffer, framesize, false);
1632 EXPECT_TRUE(sizeof(buffer) > 0);
1633 audioCapturer->Release();
1634 delete audioCapturer;
1635 }
1636
1637 /*
1638 * Feature: Audiolite
1639 * Function: audioCapturer
1640 * SubFunction: NA
1641 * FunctionPoints: NA
1642 * EnvConditions: NA
1643 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 8; Sample Rate 24000; Bit Rate 24000
1644 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_054,Level1)1645 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_054, Level1)
1646 {
1647 AudioCapturer *audioCapturer = new AudioCapturer();
1648 AudioCapturerInfo info;
1649 info.inputSource = AUDIO_MIC;
1650 info.audioFormat = AAC_HE_V1;
1651 info.sampleRate = 24000;
1652 info.channelCount = 2;
1653 info.bitRate = 24000;
1654 info.streamType = TYPE_MEDIA;
1655 info.bitWidth = BIT_WIDTH_8;
1656 uint64_t frameCnt = audioCapturer->GetFrameCount();
1657 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1658 uint8_t *buffer;
1659 audioCapturer->SetCapturerInfo(info);
1660 audioCapturer->Start();
1661 audioCapturer->Read(buffer, framesize, false);
1662 EXPECT_TRUE(sizeof(buffer) > 0);
1663 audioCapturer->Release();
1664 delete audioCapturer;
1665 }
1666
1667 /*
1668 * Feature: Audiolite
1669 * Function: audioCapturer
1670 * SubFunction: NA
1671 * FunctionPoints: NA
1672 * EnvConditions: NA
1673 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 2; Bit_width 8; Sample Rate 48000; Bit Rate 48000
1674 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_055,Level1)1675 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_055, Level1)
1676 {
1677 AudioCapturer *audioCapturer = new AudioCapturer();
1678 AudioCapturerInfo info;
1679 info.inputSource = AUDIO_MIC;
1680 info.audioFormat = AAC_HE_V1;
1681 info.sampleRate = 48000;
1682 info.channelCount = 2;
1683 info.bitRate = 48000;
1684 info.streamType = TYPE_MEDIA;
1685 info.bitWidth = BIT_WIDTH_8;
1686 uint64_t frameCnt = audioCapturer->GetFrameCount();
1687 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1688 uint8_t *buffer;
1689 audioCapturer->SetCapturerInfo(info);
1690 audioCapturer->Start();
1691 audioCapturer->Read(buffer, framesize, false);
1692 EXPECT_TRUE(sizeof(buffer) > 0);
1693 audioCapturer->Release();
1694 delete audioCapturer;
1695 }
1696
1697 /*
1698 * Feature: Audiolite
1699 * Function: audioCapturer
1700 * SubFunction: NA
1701 * FunctionPoints: NA
1702 * EnvConditions: NA
1703 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 8; Sample Rate 8000; Bit Rate 8000
1704 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_056,Level1)1705 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_056, Level1)
1706 {
1707 AudioCapturer *audioCapturer = new AudioCapturer();
1708 AudioCapturerInfo info;
1709 info.inputSource = AUDIO_MIC;
1710 info.audioFormat = AAC_HE_V1;
1711 info.sampleRate = 8000;
1712 info.channelCount = 1;
1713 info.bitRate = 8000;
1714 info.streamType = TYPE_MEDIA;
1715 info.bitWidth = BIT_WIDTH_8;
1716 uint64_t frameCnt = audioCapturer->GetFrameCount();
1717 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1718 uint8_t *buffer;
1719 audioCapturer->SetCapturerInfo(info);
1720 audioCapturer->Start();
1721 audioCapturer->Read(buffer, framesize, false);
1722 EXPECT_TRUE(sizeof(buffer) > 0);
1723 audioCapturer->Release();
1724 delete audioCapturer;
1725 }
1726
1727 /*
1728 * Feature: Audiolite
1729 * Function: audioCapturer
1730 * SubFunction: NA
1731 * FunctionPoints: NA
1732 * EnvConditions: NA
1733 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 8; Sample Rate 16000; Bit Rate 16000
1734 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_057,Level1)1735 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_057, Level1)
1736 {
1737 AudioCapturer *audioCapturer = new AudioCapturer();
1738 AudioCapturerInfo info;
1739 info.inputSource = AUDIO_MIC;
1740 info.audioFormat = AAC_HE_V1;
1741 info.sampleRate = 16000;
1742 info.channelCount = 1;
1743 info.bitRate = 16000;
1744 info.streamType = TYPE_MEDIA;
1745 info.bitWidth = BIT_WIDTH_8;
1746 uint64_t frameCnt = audioCapturer->GetFrameCount();
1747 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1748 uint8_t *buffer;
1749 audioCapturer->SetCapturerInfo(info);
1750 audioCapturer->Start();
1751 audioCapturer->Read(buffer, framesize, false);
1752 EXPECT_TRUE(sizeof(buffer) > 0);
1753 audioCapturer->Release();
1754 delete audioCapturer;
1755 }
1756
1757 /*
1758 * Feature: Audiolite
1759 * Function: audioCapturer
1760 * SubFunction: NA
1761 * FunctionPoints: NA
1762 * EnvConditions: NA
1763 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 8; Sample Rate 32000; Bit Rate 32000
1764 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_058,Level1)1765 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_058, Level1)
1766 {
1767 AudioCapturer *audioCapturer = new AudioCapturer();
1768 AudioCapturerInfo info;
1769 info.inputSource = AUDIO_MIC;
1770 info.audioFormat = AAC_HE_V1;
1771 info.sampleRate = 32000;
1772 info.channelCount = 1;
1773 info.bitRate = 32000;
1774 info.streamType = TYPE_MEDIA;
1775 info.bitWidth = BIT_WIDTH_8;
1776 uint64_t frameCnt = audioCapturer->GetFrameCount();
1777 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1778 uint8_t *buffer;
1779 audioCapturer->SetCapturerInfo(info);
1780 audioCapturer->Start();
1781 audioCapturer->Read(buffer, framesize, false);
1782 EXPECT_TRUE(sizeof(buffer) > 0);
1783 audioCapturer->Release();
1784 delete audioCapturer;
1785 }
1786
1787 /*
1788 * Feature: Audiolite
1789 * Function: audioCapturer
1790 * SubFunction: NA
1791 * FunctionPoints: NA
1792 * EnvConditions: NA
1793 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 8; Sample Rate 24000; Bit Rate 24000
1794 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_059,Level1)1795 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_059, Level1)
1796 {
1797 AudioCapturer *audioCapturer = new AudioCapturer();
1798 AudioCapturerInfo info;
1799 info.inputSource = AUDIO_MIC;
1800 info.audioFormat = AAC_HE_V1;
1801 info.sampleRate = 24000;
1802 info.channelCount = 1;
1803 info.bitRate = 24000;
1804 info.streamType = TYPE_MEDIA;
1805 info.bitWidth = BIT_WIDTH_8;
1806 uint64_t frameCnt = audioCapturer->GetFrameCount();
1807 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1808 uint8_t *buffer;
1809 audioCapturer->SetCapturerInfo(info);
1810 audioCapturer->Start();
1811 audioCapturer->Read(buffer, framesize, false);
1812 EXPECT_TRUE(sizeof(buffer) > 0);
1813 audioCapturer->Release();
1814 delete audioCapturer;
1815 }
1816
1817 /*
1818 * Feature: Audiolite
1819 * Function: audioCapturer
1820 * SubFunction: NA
1821 * FunctionPoints: NA
1822 * EnvConditions: NA
1823 * CaseDescription: Audio Capture Test-Format AAC_HE_V1; Channel 1; Bit_width 8; Sample Rate 48000; Bit Rate 48000
1824 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_060,Level1)1825 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_060, Level1)
1826 {
1827 AudioCapturer *audioCapturer = new AudioCapturer();
1828 AudioCapturerInfo info;
1829 info.inputSource = AUDIO_MIC;
1830 info.audioFormat = AAC_HE_V1;
1831 info.sampleRate = 48000;
1832 info.channelCount = 1;
1833 info.bitRate = 48000;
1834 info.streamType = TYPE_MEDIA;
1835 info.bitWidth = BIT_WIDTH_8;
1836 uint64_t frameCnt = audioCapturer->GetFrameCount();
1837 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1838 uint8_t *buffer;
1839 audioCapturer->SetCapturerInfo(info);
1840 audioCapturer->Start();
1841 audioCapturer->Read(buffer, framesize, false);
1842 EXPECT_TRUE(sizeof(buffer) > 0);
1843 audioCapturer->Release();
1844 delete audioCapturer;
1845 }
1846
1847
1848 /*
1849 * Feature: Audiolite
1850 * Function: audioCapturer
1851 * SubFunction: NA
1852 * FunctionPoints: NA
1853 * EnvConditions: NA
1854 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 16; Sample Rate 8000; Bit Rate 8000
1855 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_061,Level1)1856 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_061, Level1)
1857 {
1858 AudioCapturer *audioCapturer = new AudioCapturer();
1859 AudioCapturerInfo info;
1860 info.inputSource = AUDIO_MIC;
1861 info.audioFormat = AAC_LD;
1862 info.sampleRate = 8000;
1863 info.channelCount = 1;
1864 info.bitRate = 8000;
1865 info.streamType = TYPE_MEDIA;
1866 info.bitWidth = BIT_WIDTH_16;
1867 uint64_t frameCnt = audioCapturer->GetFrameCount();
1868 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1869 uint8_t *buffer;
1870 audioCapturer->SetCapturerInfo(info);
1871 audioCapturer->Start();
1872 audioCapturer->Read(buffer, framesize, false);
1873 EXPECT_TRUE(sizeof(buffer) > 0);
1874 audioCapturer->Release();
1875 delete audioCapturer;
1876 }
1877
1878 /*
1879 * Feature: Audiolite
1880 * Function: audioCapturer
1881 * SubFunction: NA
1882 * FunctionPoints: NA
1883 * EnvConditions: NA
1884 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 16; Sample Rate 16000; Bit Rate 16000
1885 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_062,Level1)1886 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_062, Level1)
1887 {
1888 AudioCapturer *audioCapturer = new AudioCapturer();
1889 AudioCapturerInfo info;
1890 info.inputSource = AUDIO_MIC;
1891 info.audioFormat = AAC_LD;
1892 info.sampleRate = 16000;
1893 info.channelCount = 1;
1894 info.bitRate = 16000;
1895 info.streamType = TYPE_MEDIA;
1896 info.bitWidth = BIT_WIDTH_16;
1897 uint64_t frameCnt = audioCapturer->GetFrameCount();
1898 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1899 uint8_t *buffer;
1900 audioCapturer->SetCapturerInfo(info);
1901 audioCapturer->Start();
1902 audioCapturer->Read(buffer, framesize, false);
1903 EXPECT_TRUE(sizeof(buffer) > 0);
1904 audioCapturer->Release();
1905 delete audioCapturer;
1906 }
1907
1908 /*
1909 * Feature: Audiolite
1910 * Function: audioCapturer
1911 * SubFunction: NA
1912 * FunctionPoints: NA
1913 * EnvConditions: NA
1914 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 16; Sample Rate 32000; Bit Rate 32000
1915 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_063,Level1)1916 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_063, Level1)
1917 {
1918 AudioCapturer *audioCapturer = new AudioCapturer();
1919 AudioCapturerInfo info;
1920 info.inputSource = AUDIO_MIC;
1921 info.audioFormat = AAC_LD;
1922 info.sampleRate = 32000;
1923 info.channelCount = 1;
1924 info.bitRate = 32000;
1925 info.streamType = TYPE_MEDIA;
1926 info.bitWidth = BIT_WIDTH_16;
1927 uint64_t frameCnt = audioCapturer->GetFrameCount();
1928 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1929 uint8_t *buffer;
1930 audioCapturer->SetCapturerInfo(info);
1931 audioCapturer->Start();
1932 audioCapturer->Read(buffer, framesize, false);
1933 EXPECT_TRUE(sizeof(buffer) > 0);
1934 audioCapturer->Release();
1935 delete audioCapturer;
1936 }
1937
1938 /*
1939 * Feature: Audiolite
1940 * Function: audioCapturer
1941 * SubFunction: NA
1942 * FunctionPoints: NA
1943 * EnvConditions: NA
1944 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 16; Sample Rate 24000; Bit Rate 24000
1945 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_064,Level1)1946 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_064, Level1)
1947 {
1948 AudioCapturer *audioCapturer = new AudioCapturer();
1949 AudioCapturerInfo info;
1950 info.inputSource = AUDIO_MIC;
1951 info.audioFormat = AAC_LD;
1952 info.sampleRate = 24000;
1953 info.channelCount = 1;
1954 info.bitRate = 24000;
1955 info.streamType = TYPE_MEDIA;
1956 info.bitWidth = BIT_WIDTH_16;
1957 uint64_t frameCnt = audioCapturer->GetFrameCount();
1958 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1959 uint8_t *buffer;
1960 audioCapturer->SetCapturerInfo(info);
1961 audioCapturer->Start();
1962 audioCapturer->Read(buffer, framesize, false);
1963 EXPECT_TRUE(sizeof(buffer) > 0);
1964 audioCapturer->Release();
1965 delete audioCapturer;
1966 }
1967
1968 /*
1969 * Feature: Audiolite
1970 * Function: audioCapturer
1971 * SubFunction: NA
1972 * FunctionPoints: NA
1973 * EnvConditions: NA
1974 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 16; Sample Rate 48000; Bit Rate 48000
1975 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_065,Level1)1976 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_065, Level1)
1977 {
1978 AudioCapturer *audioCapturer = new AudioCapturer();
1979 AudioCapturerInfo info;
1980 info.inputSource = AUDIO_MIC;
1981 info.audioFormat = AAC_LD;
1982 info.sampleRate = 48000;
1983 info.channelCount = 1;
1984 info.bitRate = 48000;
1985 info.streamType = TYPE_MEDIA;
1986 info.bitWidth = BIT_WIDTH_16;
1987 uint64_t frameCnt = audioCapturer->GetFrameCount();
1988 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
1989 uint8_t *buffer;
1990 audioCapturer->SetCapturerInfo(info);
1991 audioCapturer->Start();
1992 audioCapturer->Read(buffer, framesize, false);
1993 EXPECT_TRUE(sizeof(buffer) > 0);
1994 audioCapturer->Release();
1995 delete audioCapturer;
1996 }
1997
1998 /*
1999 * Feature: Audiolite
2000 * Function: audioCapturer
2001 * SubFunction: NA
2002 * FunctionPoints: NA
2003 * EnvConditions: NA
2004 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 24; Sample Rate 8000; Bit Rate 8000
2005 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_066,Level1)2006 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_066, Level1)
2007 {
2008 AudioCapturer *audioCapturer = new AudioCapturer();
2009 AudioCapturerInfo info;
2010 info.inputSource = AUDIO_MIC;
2011 info.audioFormat = AAC_LD;
2012 info.sampleRate = 8000;
2013 info.channelCount = 2;
2014 info.bitRate = 8000;
2015 info.streamType = TYPE_MEDIA;
2016 info.bitWidth = BIT_WIDTH_24;
2017 uint64_t frameCnt = audioCapturer->GetFrameCount();
2018 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2019 uint8_t *buffer;
2020 audioCapturer->SetCapturerInfo(info);
2021 audioCapturer->Start();
2022 audioCapturer->Read(buffer, framesize, false);
2023 EXPECT_TRUE(sizeof(buffer) > 0);
2024 audioCapturer->Release();
2025 delete audioCapturer;
2026 }
2027
2028 /*
2029 * Feature: Audiolite
2030 * Function: audioCapturer
2031 * SubFunction: NA
2032 * FunctionPoints: NA
2033 * EnvConditions: NA
2034 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 24; Sample Rate 16000; Bit Rate 16000
2035 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_067,Level1)2036 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_067, Level1)
2037 {
2038 AudioCapturer *audioCapturer = new AudioCapturer();
2039 AudioCapturerInfo info;
2040 info.inputSource = AUDIO_MIC;
2041 info.audioFormat = AAC_LD;
2042 info.sampleRate = 16000;
2043 info.channelCount = 2;
2044 info.bitRate = 16000;
2045 info.streamType = TYPE_MEDIA;
2046 info.bitWidth = BIT_WIDTH_24;
2047 uint64_t frameCnt = audioCapturer->GetFrameCount();
2048 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2049 uint8_t *buffer;
2050 audioCapturer->SetCapturerInfo(info);
2051 audioCapturer->Start();
2052 audioCapturer->Read(buffer, framesize, false);
2053 EXPECT_TRUE(sizeof(buffer) > 0);
2054 audioCapturer->Release();
2055 delete audioCapturer;
2056 }
2057
2058 /*
2059 * Feature: Audiolite
2060 * Function: audioCapturer
2061 * SubFunction: NA
2062 * FunctionPoints: NA
2063 * EnvConditions: NA
2064 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 24; Sample Rate 32000; Bit Rate 32000
2065 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_068,Level1)2066 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_068, Level1)
2067 {
2068 AudioCapturer *audioCapturer = new AudioCapturer();
2069 AudioCapturerInfo info;
2070 info.inputSource = AUDIO_MIC;
2071 info.audioFormat = AAC_LD;
2072 info.sampleRate = 32000;
2073 info.channelCount = 2;
2074 info.bitRate = 32000;
2075 info.streamType = TYPE_MEDIA;
2076 info.bitWidth = BIT_WIDTH_24;
2077 uint64_t frameCnt = audioCapturer->GetFrameCount();
2078 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2079 uint8_t *buffer;
2080 audioCapturer->SetCapturerInfo(info);
2081 audioCapturer->Start();
2082 audioCapturer->Read(buffer, framesize, false);
2083 EXPECT_TRUE(sizeof(buffer) > 0);
2084 audioCapturer->Release();
2085 delete audioCapturer;
2086 }
2087
2088 /*
2089 * Feature: Audiolite
2090 * Function: audioCapturer
2091 * SubFunction: NA
2092 * FunctionPoints: NA
2093 * EnvConditions: NA
2094 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 24; Sample Rate 64000; Bit Rate 64000
2095 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_069,Level1)2096 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_069, Level1)
2097 {
2098 AudioCapturer *audioCapturer = new AudioCapturer();
2099 AudioCapturerInfo info;
2100 info.inputSource = AUDIO_MIC;
2101 info.audioFormat = AAC_LD;
2102 info.sampleRate = 64000;
2103 info.channelCount = 2;
2104 info.bitRate = 64000;
2105 info.streamType = TYPE_MEDIA;
2106 info.bitWidth = BIT_WIDTH_24;
2107 uint64_t frameCnt = audioCapturer->GetFrameCount();
2108 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2109 uint8_t *buffer;
2110 audioCapturer->SetCapturerInfo(info);
2111 audioCapturer->Start();
2112 audioCapturer->Read(buffer, framesize, false);
2113 EXPECT_TRUE(sizeof(buffer) > 0);
2114 audioCapturer->Release();
2115 delete audioCapturer;
2116 }
2117
2118 /*
2119 * Feature: Audiolite
2120 * Function: audioCapturer
2121 * SubFunction: NA
2122 * FunctionPoints: NA
2123 * EnvConditions: NA
2124 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 16; Sample Rate 96000; Bit Rate 96000
2125 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_070,Level1)2126 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_070, Level1)
2127 {
2128 AudioCapturer *audioCapturer = new AudioCapturer();
2129 AudioCapturerInfo info;
2130 info.inputSource = AUDIO_MIC;
2131 info.audioFormat = AAC_LD;
2132 info.sampleRate = 96000;
2133 info.channelCount = 2;
2134 info.bitRate = 96000;
2135 info.streamType = TYPE_MEDIA;
2136 info.bitWidth = BIT_WIDTH_16;
2137 uint64_t frameCnt = audioCapturer->GetFrameCount();
2138 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2139 uint8_t *buffer;
2140 audioCapturer->SetCapturerInfo(info);
2141 audioCapturer->Start();
2142 audioCapturer->Read(buffer, framesize, false);
2143 EXPECT_TRUE(sizeof(buffer) > 0);
2144 audioCapturer->Release();
2145 delete audioCapturer;
2146 }
2147
2148 /*
2149 * Feature: Audiolite
2150 * Function: audioCapturer
2151 * SubFunction: NA
2152 * FunctionPoints: NA
2153 * EnvConditions: NA
2154 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 8; Sample Rate 8000; Bit Rate 8000
2155 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_071,Level1)2156 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_071, Level1)
2157 {
2158 AudioCapturer *audioCapturer = new AudioCapturer();
2159 AudioCapturerInfo info;
2160 info.inputSource = AUDIO_MIC;
2161 info.audioFormat = AAC_LD;
2162 info.sampleRate = 8000;
2163 info.channelCount = 2;
2164 info.bitRate = 8000;
2165 info.streamType = TYPE_MEDIA;
2166 info.bitWidth = BIT_WIDTH_8;
2167 uint64_t frameCnt = audioCapturer->GetFrameCount();
2168 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2169 uint8_t *buffer;
2170 audioCapturer->SetCapturerInfo(info);
2171 audioCapturer->Start();
2172 audioCapturer->Read(buffer, framesize, false);
2173 EXPECT_TRUE(sizeof(buffer) > 0);
2174 audioCapturer->Release();
2175 delete audioCapturer;
2176 }
2177
2178 /*
2179 * Feature: Audiolite
2180 * Function: audioCapturer
2181 * SubFunction: NA
2182 * FunctionPoints: NA
2183 * EnvConditions: NA
2184 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 8; Sample Rate 16000; Bit Rate 16000
2185 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_072,Level1)2186 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_072, Level1)
2187 {
2188 AudioCapturer *audioCapturer = new AudioCapturer();
2189 AudioCapturerInfo info;
2190 info.inputSource = AUDIO_MIC;
2191 info.audioFormat = AAC_LD;
2192 info.sampleRate = 16000;
2193 info.channelCount = 2;
2194 info.bitRate = 16000;
2195 info.streamType = TYPE_MEDIA;
2196 info.bitWidth = BIT_WIDTH_8;
2197 uint64_t frameCnt = audioCapturer->GetFrameCount();
2198 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2199 uint8_t *buffer;
2200 audioCapturer->SetCapturerInfo(info);
2201 audioCapturer->Start();
2202 audioCapturer->Read(buffer, framesize, false);
2203 EXPECT_TRUE(sizeof(buffer) > 0);
2204 audioCapturer->Release();
2205 delete audioCapturer;
2206 }
2207
2208 /*
2209 * Feature: Audiolite
2210 * Function: audioCapturer
2211 * SubFunction: NA
2212 * FunctionPoints: NA
2213 * EnvConditions: NA
2214 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 8; Sample Rate 32000; Bit Rate 32000
2215 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_073,Level1)2216 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_073, Level1)
2217 {
2218 AudioCapturer *audioCapturer = new AudioCapturer();
2219 AudioCapturerInfo info;
2220 info.inputSource = AUDIO_MIC;
2221 info.audioFormat = AAC_LD;
2222 info.sampleRate = 32000;
2223 info.channelCount = 2;
2224 info.bitRate = 32000;
2225 info.streamType = TYPE_MEDIA;
2226 info.bitWidth = BIT_WIDTH_8;
2227 uint64_t frameCnt = audioCapturer->GetFrameCount();
2228 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2229 uint8_t *buffer;
2230 audioCapturer->SetCapturerInfo(info);
2231 audioCapturer->Start();
2232 audioCapturer->Read(buffer, framesize, false);
2233 EXPECT_TRUE(sizeof(buffer) > 0);
2234 audioCapturer->Release();
2235 delete audioCapturer;
2236 }
2237
2238 /*
2239 * Feature: Audiolite
2240 * Function: audioCapturer
2241 * SubFunction: NA
2242 * FunctionPoints: NA
2243 * EnvConditions: NA
2244 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 8; Sample Rate 64000; Bit Rate 64000
2245 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_074,Level1)2246 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_074, Level1)
2247 {
2248 AudioCapturer *audioCapturer = new AudioCapturer();
2249 AudioCapturerInfo info;
2250 info.inputSource = AUDIO_MIC;
2251 info.audioFormat = AAC_LD;
2252 info.sampleRate = 64000;
2253 info.channelCount = 2;
2254 info.bitRate = 64000;
2255 info.streamType = TYPE_MEDIA;
2256 info.bitWidth = BIT_WIDTH_8;
2257 uint64_t frameCnt = audioCapturer->GetFrameCount();
2258 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2259 uint8_t *buffer;
2260 audioCapturer->SetCapturerInfo(info);
2261 audioCapturer->Start();
2262 audioCapturer->Read(buffer, framesize, false);
2263 EXPECT_TRUE(sizeof(buffer) > 0);
2264 audioCapturer->Release();
2265 delete audioCapturer;
2266 }
2267
2268 /*
2269 * Feature: Audiolite
2270 * Function: audioCapturer
2271 * SubFunction: NA
2272 * FunctionPoints: NA
2273 * EnvConditions: NA
2274 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 2; Bit_width 8; Sample Rate 96000; Bit Rate 96000
2275 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_075,Level1)2276 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_075, Level1)
2277 {
2278 AudioCapturer *audioCapturer = new AudioCapturer();
2279 AudioCapturerInfo info;
2280 info.inputSource = AUDIO_MIC;
2281 info.audioFormat = AAC_LD;
2282 info.sampleRate = 96000;
2283 info.channelCount = 2;
2284 info.bitRate = 96000;
2285 info.streamType = TYPE_MEDIA;
2286 info.bitWidth = BIT_WIDTH_8;
2287 uint64_t frameCnt = audioCapturer->GetFrameCount();
2288 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2289 uint8_t *buffer;
2290 audioCapturer->SetCapturerInfo(info);
2291 audioCapturer->Start();
2292 audioCapturer->Read(buffer, framesize, false);
2293 EXPECT_TRUE(sizeof(buffer) > 0);
2294 audioCapturer->Release();
2295 delete audioCapturer;
2296 }
2297
2298 /*
2299 * Feature: Audiolite
2300 * Function: audioCapturer
2301 * SubFunction: NA
2302 * FunctionPoints: NA
2303 * EnvConditions: NA
2304 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 24; Sample Rate 8000; Bit Rate 8000
2305 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_076,Level1)2306 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_076, Level1)
2307 {
2308 AudioCapturer *audioCapturer = new AudioCapturer();
2309 AudioCapturerInfo info;
2310 info.inputSource = AUDIO_MIC;
2311 info.audioFormat = AAC_LD;
2312 info.sampleRate = 8000;
2313 info.channelCount = 1;
2314 info.bitRate = 8000;
2315 info.streamType = TYPE_MEDIA;
2316 info.bitWidth = BIT_WIDTH_24;
2317 uint64_t frameCnt = audioCapturer->GetFrameCount();
2318 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2319 uint8_t *buffer;
2320 audioCapturer->SetCapturerInfo(info);
2321 audioCapturer->Start();
2322 audioCapturer->Read(buffer, framesize, false);
2323 EXPECT_TRUE(sizeof(buffer) > 0);
2324 audioCapturer->Release();
2325 delete audioCapturer;
2326 }
2327
2328 /*
2329 * Feature: Audiolite
2330 * Function: audioCapturer
2331 * SubFunction: NA
2332 * FunctionPoints: NA
2333 * EnvConditions: NA
2334 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 24; Sample Rate 16000; Bit Rate 16000
2335 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_077,Level1)2336 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_077, Level1)
2337 {
2338 AudioCapturer *audioCapturer = new AudioCapturer();
2339 AudioCapturerInfo info;
2340 info.inputSource = AUDIO_MIC;
2341 info.audioFormat = AAC_LD;
2342 info.sampleRate = 16000;
2343 info.channelCount = 1;
2344 info.bitRate = 16000;
2345 info.streamType = TYPE_MEDIA;
2346 info.bitWidth = BIT_WIDTH_24;
2347 uint64_t frameCnt = audioCapturer->GetFrameCount();
2348 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2349 uint8_t *buffer;
2350 audioCapturer->SetCapturerInfo(info);
2351 audioCapturer->Start();
2352 audioCapturer->Read(buffer, framesize, false);
2353 EXPECT_TRUE(sizeof(buffer) > 0);
2354 audioCapturer->Release();
2355 delete audioCapturer;
2356 }
2357
2358 /*
2359 * Feature: Audiolite
2360 * Function: audioCapturer
2361 * SubFunction: NA
2362 * FunctionPoints: NA
2363 * EnvConditions: NA
2364 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 24; Sample Rate 32000; Bit Rate 32000
2365 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_078,Level1)2366 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_078, Level1)
2367 {
2368 AudioCapturer *audioCapturer = new AudioCapturer();
2369 AudioCapturerInfo info;
2370 info.inputSource = AUDIO_MIC;
2371 info.audioFormat = AAC_LD;
2372 info.sampleRate = 32000;
2373 info.channelCount = 1;
2374 info.bitRate = 32000;
2375 info.streamType = TYPE_MEDIA;
2376 info.bitWidth = BIT_WIDTH_24;
2377 uint64_t frameCnt = audioCapturer->GetFrameCount();
2378 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2379 uint8_t *buffer;
2380 audioCapturer->SetCapturerInfo(info);
2381 audioCapturer->Start();
2382 audioCapturer->Read(buffer, framesize, false);
2383 EXPECT_TRUE(sizeof(buffer) > 0);
2384 audioCapturer->Release();
2385 delete audioCapturer;
2386 }
2387
2388 /*
2389 * Feature: Audiolite
2390 * Function: audioCapturer
2391 * SubFunction: NA
2392 * FunctionPoints: NA
2393 * EnvConditions: NA
2394 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 24; Sample Rate 64000; Bit Rate 64000
2395 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_079,Level1)2396 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_079, Level1)
2397 {
2398 AudioCapturer *audioCapturer = new AudioCapturer();
2399 AudioCapturerInfo info;
2400 info.inputSource = AUDIO_MIC;
2401 info.audioFormat = AAC_LD;
2402 info.sampleRate = 64000;
2403 info.channelCount = 1;
2404 info.bitRate = 64000;
2405 info.streamType = TYPE_MEDIA;
2406 info.bitWidth = BIT_WIDTH_24;
2407 uint64_t frameCnt = audioCapturer->GetFrameCount();
2408 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2409 uint8_t *buffer;
2410 audioCapturer->SetCapturerInfo(info);
2411 audioCapturer->Start();
2412 audioCapturer->Read(buffer, framesize, false);
2413 EXPECT_TRUE(sizeof(buffer) > 0);
2414 audioCapturer->Release();
2415 delete audioCapturer;
2416 }
2417
2418 /*
2419 * Feature: Audiolite
2420 * Function: audioCapturer
2421 * SubFunction: NA
2422 * FunctionPoints: NA
2423 * EnvConditions: NA
2424 * CaseDescription: Audio Capture Test-Format AAC_LD; Channel 1; Bit_width 24; Sample Rate 96000; Bit Rate 96000
2425 */
HWTEST_F(AudioliteTest,audio_lite_audioCapturer_test_080,Level1)2426 HWTEST_F(AudioliteTest, audio_lite_audioCapturer_test_080, Level1)
2427 {
2428 AudioCapturer *audioCapturer = new AudioCapturer();
2429 AudioCapturerInfo info;
2430 info.inputSource = AUDIO_MIC;
2431 info.audioFormat = AAC_LD;
2432 info.sampleRate = 96000;
2433 info.channelCount = 1;
2434 info.bitRate = 96000;
2435 info.streamType = TYPE_MEDIA;
2436 info.bitWidth = BIT_WIDTH_24;
2437 uint64_t frameCnt = audioCapturer->GetFrameCount();
2438 uint32_t framesize = static_cast<uint32_t>((frameCnt * info.channelCount * info.bitWidth) / sizeof(uint8_t));
2439 uint8_t *buffer;
2440 audioCapturer->SetCapturerInfo(info);
2441 audioCapturer->Start();
2442 audioCapturer->Read(buffer, framesize, false);
2443 EXPECT_TRUE(sizeof(buffer) > 0);
2444 audioCapturer->Release();
2445 delete audioCapturer;
2446 }
2447 } // namespace OHOS
2448