1 /*
2 * Copyright (C) 2023 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 <string>
17 #include <sys/stat.h>
18 #include <fcntl.h>
19 #include <cinttypes>
20 #include <nativetoken_kit.h>
21 #include <token_setproc.h>
22 #include <accesstoken_kit.h>
23 #include "gtest/gtest.h"
24 #include "avcodec_errors.h"
25 #include "avcodec_info.h"
26 #include "media_description.h"
27 #include "audio_capture_module_unit_test.h"
28
29 using namespace OHOS;
30 using namespace OHOS::Media;
31 using namespace std;
32 using namespace testing::ext;
33 using namespace Security::AccessToken;
34 namespace {
35 } // namespace
36
37 /**********************************source FD**************************************/
38 namespace OHOS {
39
SetUpTestCase(void)40 void AudioCaptureModuleUnitTest::SetUpTestCase(void)
41 {
42 HapInfoParams info = {
43 .userID = 100, // 100 user ID
44 .bundleName = "com.ohos.test.audiocapturertdd",
45 .instIndex = 0, // 0 index
46 .appIDDesc = "com.ohos.test.audiocapturertdd",
47 .isSystemApp = true
48 };
49
50 HapPolicyParams policy = {
51 .apl = APL_SYSTEM_BASIC,
52 .domain = "test.audiocapturermodule",
53 .permList = { },
54 .permStateList = {
55 {
56 .permissionName = "ohos.permission.MICROPHONE",
57 .isGeneral = true,
58 .resDeviceID = { "local" },
59 .grantStatus = { PermissionState::PERMISSION_GRANTED },
60 .grantFlags = { 1 }
61 },
62 {
63 .permissionName = "ohos.permission.READ_MEDIA",
64 .isGeneral = true,
65 .resDeviceID = { "local" },
66 .grantStatus = { PermissionState::PERMISSION_GRANTED },
67 .grantFlags = { 1 }
68 },
69 {
70 .permissionName = "ohos.permission.WRITE_MEDIA",
71 .isGeneral = true,
72 .resDeviceID = { "local" },
73 .grantStatus = { PermissionState::PERMISSION_GRANTED },
74 .grantFlags = { 1 }
75 },
76 {
77 .permissionName = "ohos.permission.KEEP_BACKGROUND_RUNNING",
78 .isGeneral = true,
79 .resDeviceID = { "local" },
80 .grantStatus = { PermissionState::PERMISSION_GRANTED },
81 .grantFlags = { 1 }
82 }
83 }
84 };
85 AccessTokenIDEx tokenIdEx = { 0 };
86 tokenIdEx = AccessTokenKit::AllocHapToken(info, policy);
87 int ret = SetSelfTokenID(tokenIdEx.tokenIDEx);
88 if (ret != 0) {
89 std::cout<<"Set hap token failed"<<std::endl;
90 }
91 }
92
TearDownTestCase(void)93 void AudioCaptureModuleUnitTest::TearDownTestCase(void)
94 {
95 }
96
SetUp(void)97 void AudioCaptureModuleUnitTest::SetUp(void)
98 {
99 audioCaptureParameter_ = std::make_shared<Meta>();
100 audioCaptureParameter_->Set<Tag::APP_TOKEN_ID>(appTokenId_);
101 audioCaptureParameter_->Set<Tag::APP_UID>(appUid_);
102 audioCaptureParameter_->Set<Tag::APP_PID>(appPid_);
103 audioCaptureParameter_->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId_);
104 audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
105 audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
106 audioCaptureParameter_->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
107 audioCaptureParameter_->Set<Tag::MEDIA_BITRATE>(bitRate_);
108 audioCaptureModule_ = std::make_shared<AudioCaptureModule::AudioCaptureModule>();
109 }
110
TearDown(void)111 void AudioCaptureModuleUnitTest::TearDown(void)
112 {
113 audioCaptureParameter_ = nullptr;
114 audioCaptureModule_ = nullptr;
115 }
116 class CapturerInfoChangeCallback : public AudioStandard::AudioCapturerInfoChangeCallback {
117 public:
CapturerInfoChangeCallback()118 explicit CapturerInfoChangeCallback() { }
OnStateChange(const AudioStandard::AudioCapturerChangeInfo & info)119 void OnStateChange(const AudioStandard::AudioCapturerChangeInfo &info)
120 {
121 (void)info;
122 std::cout<<"AudioCapturerInfoChangeCallback"<<std::endl;
123 }
124 };
125
126 class AudioCaptureModuleCallbackTest : public AudioCaptureModule::AudioCaptureModuleCallback {
127 public:
AudioCaptureModuleCallbackTest()128 explicit AudioCaptureModuleCallbackTest() { }
OnInterrupt(const std::string & interruptInfo)129 void OnInterrupt(const std::string &interruptInfo) override
130 {
131 std::cout<<"AudioCaptureModuleCallback interrupt"<<interruptInfo<<std::endl;
132 }
133 };
134
135 /**
136 * @tc.name: AVSource_CreateSourceWithFD_1000
137 * @tc.desc: create source with fd, mp4
138 * @tc.type: FUNC
139 */
140 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureInit_1000, TestSize.Level0)
141 {
142 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
143 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
144 audioCaptureFormat->Set<Tag::APP_TOKEN_ID>(appTokenId_);
145 audioCaptureFormat->Set<Tag::APP_UID>(appUid_);
146 audioCaptureFormat->Set<Tag::APP_PID>(appPid_);
147 audioCaptureFormat->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId_);
148 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
149 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
150 audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
151 audioCaptureFormat->Set<Tag::MEDIA_BITRATE>(bitRate_);
152 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
153 ASSERT_TRUE(ret == Status::OK);
154 ret = audioCaptureModule_->Init();
155 ASSERT_TRUE(ret == Status::OK);
156 ret = audioCaptureModule_->Deinit();
157 ASSERT_TRUE(ret == Status::OK);
158 }
159
160 HWTEST_F(AudioCaptureModuleUnitTest, AudioCapturePrepare_1000, TestSize.Level0)
161 {
162 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
163 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
164 audioCaptureFormat->Set<Tag::APP_TOKEN_ID>(appTokenId_);
165 audioCaptureFormat->Set<Tag::APP_UID>(appUid_);
166 audioCaptureFormat->Set<Tag::APP_PID>(appPid_);
167 audioCaptureFormat->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId_);
168 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
169 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
170 audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
171 audioCaptureFormat->Set<Tag::MEDIA_BITRATE>(bitRate_);
172 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
173 ASSERT_TRUE(ret == Status::OK);
174 ret = audioCaptureModule_->Init();
175 ASSERT_TRUE(ret == Status::OK);
176 ret = audioCaptureModule_->Prepare();
177 ASSERT_TRUE(ret == Status::OK);
178 ret = audioCaptureModule_->Deinit();
179 ASSERT_TRUE(ret == Status::OK);
180 }
181
182 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureStart_1000, TestSize.Level0)
183 {
184 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
185 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
186 audioCaptureFormat->Set<Tag::APP_TOKEN_ID>(appTokenId_);
187 audioCaptureFormat->Set<Tag::APP_UID>(appUid_);
188 audioCaptureFormat->Set<Tag::APP_PID>(appPid_);
189 audioCaptureFormat->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId_);
190 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
191 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
192 audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
193 audioCaptureFormat->Set<Tag::MEDIA_BITRATE>(bitRate_);
194 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
195 ASSERT_TRUE(ret == Status::OK);
196 ret = audioCaptureModule_->Init();
197 ASSERT_TRUE(ret == Status::OK);
198 ret = audioCaptureModule_->Prepare();
199 ASSERT_TRUE(ret == Status::OK);
200 ret = audioCaptureModule_->Start();
201 ASSERT_TRUE(ret == Status::OK);
202 ret = audioCaptureModule_->Stop();
203 ASSERT_TRUE(ret == Status::OK);
204 ret = audioCaptureModule_->Deinit();
205 ASSERT_TRUE(ret == Status::OK);
206 }
207
208 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0100, TestSize.Level1)
209 {
210 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
211 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
212 audioCaptureFormat->Set<Tag::APP_TOKEN_ID>(appTokenId_);
213 audioCaptureFormat->Set<Tag::APP_UID>(appUid_);
214 audioCaptureFormat->Set<Tag::APP_PID>(appPid_);
215 audioCaptureFormat->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId_);
216 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
217 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
218 audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
219 audioCaptureFormat->Set<Tag::MEDIA_BITRATE>(bitRate_);
220 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
221 ASSERT_TRUE(ret == Status::OK);
222 ret = audioCaptureModule_->Init();
223 ASSERT_TRUE(ret == Status::OK);
224 ret = audioCaptureModule_->Prepare();
225 ASSERT_TRUE(ret == Status::OK);
226 ret = audioCaptureModule_->Start();
227 ASSERT_TRUE(ret == Status::OK);
228 uint64_t bufferSize = 0;
229 ret = audioCaptureModule_->GetSize(bufferSize);
230 ASSERT_TRUE(ret == Status::OK);
231 std::shared_ptr<AVAllocator> avAllocator =
232 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
233 int32_t capacity = 1024;
234 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
235 ret = audioCaptureModule_->Read(buffer, bufferSize);
236 ASSERT_TRUE(ret == Status::OK);
237 ret = audioCaptureModule_->Stop();
238 ASSERT_TRUE(ret == Status::OK);
239 ret = audioCaptureModule_->Deinit();
240 ASSERT_TRUE(ret == Status::OK);
241 }
242 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0200, TestSize.Level1)
243 {
244 std::shared_ptr<AVAllocator> avAllocator =
245 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
246 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator);
247 size_t bufferSize = 1024;
248 Status ret = audioCaptureModule_->Read(buffer, bufferSize);
249 EXPECT_NE(ret, Status::OK);
250 }
251 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0300, TestSize.Level1)
252 {
253 std::shared_ptr<AVAllocator> avAllocator =
254 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
255 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator);
256 buffer->meta_ = nullptr;
257 size_t bufferSize = 1024;
258 Status ret = audioCaptureModule_->Read(buffer, bufferSize);
259 EXPECT_NE(ret, Status::OK);
260 }
261 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0400, TestSize.Level1)
262 {
263 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
264 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
265 ASSERT_TRUE(ret == Status::OK);
266 ret = audioCaptureModule_->Init();
267 ASSERT_TRUE(ret == Status::OK);
268 ret = audioCaptureModule_->Prepare();
269 ASSERT_TRUE(ret == Status::OK);
270 uint64_t bufferSize = 0;
271 ret = audioCaptureModule_->GetSize(bufferSize);
272 ASSERT_TRUE(ret == Status::OK);
273 std::shared_ptr<AVAllocator> avAllocator =
274 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
275 int32_t capacity = 1024;
276 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
277 EXPECT_NE(Status::OK, audioCaptureModule_->Read(buffer, bufferSize));
278 ret = audioCaptureModule_->Deinit();
279 ASSERT_TRUE(ret == Status::OK);
280 }
281 /**
282 * @tc.name: AudioCaptureGetCurrentChangeInfo_0100
283 * @tc.desc: test GetCurrentChangeInfo
284 * @tc.type: FUNC
285 */
286 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetCurrentChangeInfo_0100, TestSize.Level1)
287 {
288 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
289 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
290 ASSERT_TRUE(ret == Status::OK);
291 ret = audioCaptureModule_->Init();
292 ASSERT_TRUE(ret == Status::OK);
293 ret = audioCaptureModule_->Prepare();
294 ASSERT_TRUE(ret == Status::OK);
295 AudioStandard::AudioCapturerChangeInfo changeInfo;
296 audioCaptureModule_->GetCurrentCapturerChangeInfo(changeInfo);
297 ret = audioCaptureModule_->Deinit();
298 ASSERT_TRUE(ret == Status::OK);
299 }
300
301 /**
302 * @tc.name: AudioCaptureGetCurrentChangeInfo_0200
303 * @tc.desc: test GetCurrentChangeInfo
304 * @tc.type: FUNC
305 */
306 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetCurrentChangeInfo_0200, TestSize.Level1)
307 {
308 AudioStandard::AudioCapturerChangeInfo changeInfo;
309 audioCaptureModule_->GetCurrentCapturerChangeInfo(changeInfo);
310 Status ret = audioCaptureModule_->Deinit();
311 ASSERT_TRUE(ret == Status::OK);
312 }
313
314 /**
315 * @tc.name: AudioCaptureSetCallingInfo_0100
316 * @tc.desc: test SetCallingInfo
317 * @tc.type: FUNC
318 */
319 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureSetCallingInfo_0100, TestSize.Level1)
320 {
321 audioCaptureModule_->SetCallingInfo(appUid_, appPid_, bundleName_, instanceId_);
322 Status ret = audioCaptureModule_->Deinit();
323 ASSERT_TRUE(ret == Status::OK);
324 }
325
326 /**
327 * @tc.name: AudioCaptureGetMaxAmplitude_0100
328 * @tc.desc: test GetMaxAmplitude
329 * @tc.type: FUNC
330 */
331 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetMaxAmplitude_0100, TestSize.Level1)
332 {
333 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
334 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
335 ASSERT_TRUE(ret == Status::OK);
336 ret = audioCaptureModule_->Init();
337 ASSERT_TRUE(ret == Status::OK);
338 ret = audioCaptureModule_->Prepare();
339 ASSERT_TRUE(ret == Status::OK);
340 ret = audioCaptureModule_->Start();
341 ASSERT_TRUE(ret == Status::OK);
342 uint64_t bufferSize = 0;
343 ret = audioCaptureModule_->GetSize(bufferSize);
344 ASSERT_TRUE(ret == Status::OK);
345 audioCaptureModule_->isTrackMaxAmplitude = false;
346 audioCaptureModule_->GetMaxAmplitude();
347 audioCaptureModule_->isTrackMaxAmplitude = true;
348 EXPECT_EQ(audioCaptureModule_->maxAmplitude_, audioCaptureModule_->GetMaxAmplitude());
349 std::shared_ptr<AVAllocator> avAllocator =
350 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
351 int32_t capacity = 1024;
352 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
353 ret = audioCaptureModule_->Read(buffer, bufferSize);
354 ASSERT_TRUE(ret == Status::OK);
355 ret = audioCaptureModule_->Stop();
356 ASSERT_TRUE(ret == Status::OK);
357 ret = audioCaptureModule_->Deinit();
358 ASSERT_TRUE(ret == Status::OK);
359 }
360 /**
361 * @tc.name: AudioSetAudioCapturerInfoChangeCallback_0100
362 * @tc.desc: test SetAudioCapturerInfoChangeCallback
363 * @tc.type: FUNC
364 */
365 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetAudioCapturerInfoChangeCallback_0100, TestSize.Level1)
366 {
367 EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
368 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
369 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
370 ASSERT_TRUE(ret == Status::OK);
371 ret = audioCaptureModule_->Init();
372 ASSERT_TRUE(ret == Status::OK);
373 EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
374 std::shared_ptr<AudioStandard::AudioCapturerInfoChangeCallback> callback =
375 std::make_shared<CapturerInfoChangeCallback>();
376 EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
377 ret = audioCaptureModule_->Deinit();
378 ASSERT_TRUE(ret == Status::OK);
379 }
380 /**
381 * @tc.name: AudioSetAudioInterruptListener_0100
382 * @tc.desc: test SetAudioInterruptListener
383 * @tc.type: FUNC
384 */
385 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetAudioInterruptListener_0100, TestSize.Level1)
386 {
387 EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioInterruptListener(nullptr));
388 std::shared_ptr<AudioCaptureModule::AudioCaptureModuleCallback> callback =
389 std::make_shared<AudioCaptureModuleCallbackTest>();
390 EXPECT_EQ(Status::OK, audioCaptureModule_->SetAudioInterruptListener(callback));
391 Status ret = audioCaptureModule_->Deinit();
392 ASSERT_TRUE(ret == Status::OK);
393 }
394 /**
395 * @tc.name: AudioGetSize_0100
396 * @tc.desc: test GetSize
397 * @tc.type: FUNC
398 */
399 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0100, TestSize.Level1)
400 {
401 uint64_t size = 0;
402 EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
403 Status ret = audioCaptureModule_->Deinit();
404 ASSERT_TRUE(ret == Status::OK);
405 }
406 /**
407 * @tc.name: AudioGetSize_0200
408 * @tc.desc: test GetSize
409 * @tc.type: FUNC
410 */
411 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0200, TestSize.Level1)
412 {
413 uint64_t size = 0;
414 EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
415 Status ret = audioCaptureModule_->Deinit();
416 ASSERT_TRUE(ret == Status::OK);
417 }
418 /**
419 * @tc.name: AudioGetSize_0300
420 * @tc.desc: test GetSize
421 * @tc.type: FUNC
422 */
423 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0300, TestSize.Level1)
424 {
425 uint64_t size = 0;
426 EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
427 Status ret = audioCaptureModule_->Deinit();
428 ASSERT_TRUE(ret == Status::OK);
429 }
430 /**
431 * @tc.name: AudioSetParameter_0100
432 * @tc.desc: test SetParameter
433 * @tc.type: FUNC
434 */
435 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0100, TestSize.Level1)
436 {
437 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
438 audioCaptureModule_->SetParameter(audioCaptureFormat);
439 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
440 audioCaptureModule_->SetParameter(audioCaptureFormat);
441 audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
442 audioCaptureModule_->SetParameter(audioCaptureFormat);
443 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
444 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
445 EXPECT_EQ(ret, Status::OK);
446 }
447 /**
448 * @tc.name: AudioSetParameter_0200
449 * @tc.desc: test SetParameter
450 * @tc.type: FUNC
451 */
452 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0200, TestSize.Level1)
453 {
454 std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
455 audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32P);
456 Status ret = audioCaptureModule_->SetParameter(audioCaptureFormat);
457 EXPECT_NE(ret, Status::OK);
458 }
459 /**
460 * @tc.name: AudioSetParameter_0300
461 * @tc.desc: test SetParameter
462 * @tc.type: FUNC
463 */
464 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0300, TestSize.Level1)
465 {
466 int32_t channel = 3;
467 audioCaptureParameter_->Set<Tag::AUDIO_CHANNEL_COUNT>(channel);
468 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
469 EXPECT_NE(ret, Status::OK);
470 }
471 /**
472 * @tc.name: AudioGetParameter_0100
473 * @tc.desc: test GetParameter
474 * @tc.type: FUNC
475 */
476 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetParameter_0100, TestSize.Level1)
477 {
478 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
479 std::shared_ptr<Meta> audioCaptureParameterTest_ = std::make_shared<Meta>();
480 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
481 EXPECT_NE(Status::OK, audioCaptureModule_->GetParameter(audioCaptureParameterTest_));
482 ASSERT_TRUE(ret == Status::OK);
483 ret = audioCaptureModule_->Init();
484 ASSERT_TRUE(ret == Status::OK);
485 ret = audioCaptureModule_->Prepare();
486 ASSERT_TRUE(ret == Status::OK);
487 audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
488
489 audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_U8);
490 audioCaptureModule_->SetParameter(audioCaptureParameter_);
491 audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
492 int32_t channel = 2;
493 audioCaptureParameter_->Set<Tag::AUDIO_CHANNEL_COUNT>(channel);
494 audioCaptureModule_->SetParameter(audioCaptureParameter_);
495 audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
496 int32_t sampleRate = 64000;
497 audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate);
498 audioCaptureModule_->SetParameter(audioCaptureParameter_);
499 audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
500 ret = audioCaptureModule_->Deinit();
501 ASSERT_TRUE(ret == Status::OK);
502 }
503 /**
504 * @tc.name: AudioReset_0100
505 * @tc.desc: test Reset
506 * @tc.type: FUNC
507 */
508 HWTEST_F(AudioCaptureModuleUnitTest, AudioReset_0100, TestSize.Level1)
509 {
510 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
511 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
512 ASSERT_TRUE(ret == Status::OK);
513 ret = audioCaptureModule_->Init();
514 ASSERT_TRUE(ret == Status::OK);
515 ret = audioCaptureModule_->Prepare();
516 ASSERT_TRUE(ret == Status::OK);
517 ret = audioCaptureModule_->Start();
518 ASSERT_TRUE(ret == Status::OK);
519 uint64_t bufferSize = 0;
520 ret = audioCaptureModule_->GetSize(bufferSize);
521 ASSERT_TRUE(ret == Status::OK);
522 std::shared_ptr<AVAllocator> avAllocator =
523 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
524 int32_t capacity = 1024;
525 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
526 ret = audioCaptureModule_->Read(buffer, bufferSize);
527 ASSERT_TRUE(ret == Status::OK);
528 ret = audioCaptureModule_->Stop();
529 ASSERT_TRUE(ret == Status::OK);
530 ret = audioCaptureModule_->Reset();
531 ASSERT_TRUE(ret == Status::OK);
532 ret = audioCaptureModule_->Deinit();
533 ASSERT_TRUE(ret == Status::OK);
534 }
535 /**
536 * @tc.name: AudioReset_0200
537 * @tc.desc: test Reset
538 * @tc.type: FUNC
539 */
540 HWTEST_F(AudioCaptureModuleUnitTest, AudioReset_0200, TestSize.Level1)
541 {
542 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
543 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
544 ASSERT_TRUE(ret == Status::OK);
545 ret = audioCaptureModule_->Init();
546 ASSERT_TRUE(ret == Status::OK);
547 ret = audioCaptureModule_->Prepare();
548 ASSERT_TRUE(ret == Status::OK);
549 ret = audioCaptureModule_->Reset();
550 ASSERT_TRUE(ret == Status::OK);
551 ret = audioCaptureModule_->Deinit();
552 ASSERT_TRUE(ret == Status::OK);
553 }
554 /**
555 * @tc.name: Audioinit_0100
556 * @tc.desc: test init
557 * @tc.type: FUNC
558 */
559 HWTEST_F(AudioCaptureModuleUnitTest, Audioinit_0100, TestSize.Level1)
560 {
561 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
562 Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
563 ASSERT_TRUE(ret == Status::OK);
564 ret = audioCaptureModule_->Init();
565 ASSERT_TRUE(ret == Status::OK);
566 ret = audioCaptureModule_->Init();
567 ASSERT_TRUE(ret == Status::OK);
568 ret = audioCaptureModule_->Deinit();
569 ASSERT_TRUE(ret == Status::OK);
570 }
571 /**
572 * @tc.name: Audioinit_0200
573 * @tc.desc: test init
574 * @tc.type: FUNC
575 */
576 HWTEST_F(AudioCaptureModuleUnitTest, Audioinit_0200, TestSize.Level1)
577 {
578 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
579 EXPECT_NE(Status::OK, audioCaptureModule_->Init());
580 Status ret = audioCaptureModule_->Deinit();
581 ASSERT_TRUE(ret == Status::OK);
582 }
583 /**
584 * @tc.name: AudioTrackMaxAmplitude_0200
585 * @tc.desc: test TrackMaxAmplitude
586 * @tc.type: FUNC
587 */
588 HWTEST_F(AudioCaptureModuleUnitTest, AudioTrackMaxAmplitude_0200, TestSize.Level1)
589 {
590 int16_t data[5] = {1, 2, 3, 4, 5};
591 audioCaptureModule_->TrackMaxAmplitude(data, 5);
592 EXPECT_EQ(audioCaptureModule_->maxAmplitude_, 5);
593 int16_t number[5] = {1, -2, 3, -4, 5};
594 audioCaptureModule_->TrackMaxAmplitude(number, 5);
595 EXPECT_EQ(audioCaptureModule_->maxAmplitude_, 5);
596 }
597 /**
598 * @tc.name: AudioGetMaxAmplitude_0200
599 * @tc.desc: test GetMaxAmplitude
600 * @tc.type: FUNC
601 */
602 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetMaxAmplitude_0200, TestSize.Level1)
603 {
604 audioCaptureModule_->isTrackMaxAmplitude = true;
605 EXPECT_EQ(audioCaptureModule_->GetMaxAmplitude(), 0);
606 }
607 } // namespace OHOS