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.Level1)
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.Level1)
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.Level1)
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     audioCaptureModule_->Read(buffer, bufferSize);
249 }
250 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0300, TestSize.Level1)
251 {
252     std::shared_ptr<AVAllocator> avAllocator =
253         AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
254     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator);
255     buffer->meta_ = nullptr;
256     size_t bufferSize = 1024;
257     audioCaptureModule_->Read(buffer, bufferSize);
258 }
259 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureRead_0400, TestSize.Level1)
260 {
261     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
262     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
263     ASSERT_TRUE(ret == Status::OK);
264     ret = audioCaptureModule_->Init();
265     ASSERT_TRUE(ret == Status::OK);
266     ret = audioCaptureModule_->Prepare();
267     ASSERT_TRUE(ret == Status::OK);
268     uint64_t bufferSize = 0;
269     ret = audioCaptureModule_->GetSize(bufferSize);
270     ASSERT_TRUE(ret == Status::OK);
271     std::shared_ptr<AVAllocator> avAllocator =
272     AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
273     int32_t capacity = 1024;
274     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
275     EXPECT_NE(Status::OK, audioCaptureModule_->Read(buffer, bufferSize));
276     ret = audioCaptureModule_->Deinit();
277     ASSERT_TRUE(ret == Status::OK);
278 }
279 /**
280  * @tc.name: AudioCaptureGetCurrentChangeInfo_0100
281  * @tc.desc: test GetCurrentChangeInfo
282  * @tc.type: FUNC
283  */
284 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetCurrentChangeInfo_0100, TestSize.Level1)
285 {
286     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
287     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
288     ASSERT_TRUE(ret == Status::OK);
289     ret = audioCaptureModule_->Init();
290     ASSERT_TRUE(ret == Status::OK);
291     ret = audioCaptureModule_->Prepare();
292     ASSERT_TRUE(ret == Status::OK);
293     AudioStandard::AudioCapturerChangeInfo changeInfo;
294     audioCaptureModule_->GetCurrentCapturerChangeInfo(changeInfo);
295     ret = audioCaptureModule_->Deinit();
296     ASSERT_TRUE(ret == Status::OK);
297 }
298 
299 /**
300  * @tc.name: AudioCaptureGetCurrentChangeInfo_0200
301  * @tc.desc: test GetCurrentChangeInfo
302  * @tc.type: FUNC
303  */
304 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetCurrentChangeInfo_0200, TestSize.Level1)
305 {
306     AudioStandard::AudioCapturerChangeInfo changeInfo;
307     audioCaptureModule_->GetCurrentCapturerChangeInfo(changeInfo);
308     Status ret = audioCaptureModule_->Deinit();
309     ASSERT_TRUE(ret == Status::OK);
310 }
311 
312 /**
313  * @tc.name: AudioCaptureSetCallingInfo_0100
314  * @tc.desc: test SetCallingInfo
315  * @tc.type: FUNC
316  */
317 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureSetCallingInfo_0100, TestSize.Level1)
318 {
319     audioCaptureModule_->SetCallingInfo(appUid_, appPid_, bundleName_, instanceId_);
320     Status ret = audioCaptureModule_->Deinit();
321     ASSERT_TRUE(ret == Status::OK);
322 }
323 
324 /**
325  * @tc.name: AudioCaptureGetMaxAmplitude_0100
326  * @tc.desc: test GetMaxAmplitude
327  * @tc.type: FUNC
328  */
329 HWTEST_F(AudioCaptureModuleUnitTest, AudioCaptureGetMaxAmplitude_0100, TestSize.Level1)
330 {
331     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
332     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
333     ASSERT_TRUE(ret == Status::OK);
334     ret = audioCaptureModule_->Init();
335     ASSERT_TRUE(ret == Status::OK);
336     ret = audioCaptureModule_->Prepare();
337     ASSERT_TRUE(ret == Status::OK);
338     ret = audioCaptureModule_->Start();
339     ASSERT_TRUE(ret == Status::OK);
340     uint64_t bufferSize = 0;
341     ret = audioCaptureModule_->GetSize(bufferSize);
342     ASSERT_TRUE(ret == Status::OK);
343     audioCaptureModule_->isTrackMaxAmplitude = false;
344     audioCaptureModule_->GetMaxAmplitude();
345     audioCaptureModule_->isTrackMaxAmplitude = true;
346     EXPECT_EQ(audioCaptureModule_->maxAmplitude_, audioCaptureModule_->GetMaxAmplitude());
347     std::shared_ptr<AVAllocator> avAllocator =
348         AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
349     int32_t capacity = 1024;
350     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
351     ret = audioCaptureModule_->Read(buffer, bufferSize);
352     ASSERT_TRUE(ret == Status::OK);
353     ret = audioCaptureModule_->Stop();
354     ASSERT_TRUE(ret == Status::OK);
355     ret = audioCaptureModule_->Deinit();
356     ASSERT_TRUE(ret == Status::OK);
357 }
358 /**
359  * @tc.name: AudioSetAudioCapturerInfoChangeCallback_0100
360  * @tc.desc: test SetAudioCapturerInfoChangeCallback
361  * @tc.type: FUNC
362  */
363 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetAudioCapturerInfoChangeCallback_0100, TestSize.Level1)
364 {
365     EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
366     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
367     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
368     ASSERT_TRUE(ret == Status::OK);
369     ret = audioCaptureModule_->Init();
370     ASSERT_TRUE(ret == Status::OK);
371     EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
372     std::shared_ptr<AudioStandard::AudioCapturerInfoChangeCallback> callback =
373         std::make_shared<CapturerInfoChangeCallback>();
374     EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioCapturerInfoChangeCallback(nullptr));
375     ret = audioCaptureModule_->Deinit();
376     ASSERT_TRUE(ret == Status::OK);
377 }
378 /**
379  * @tc.name: AudioSetAudioInterruptListener_0100
380  * @tc.desc: test SetAudioInterruptListener
381  * @tc.type: FUNC
382  */
383 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetAudioInterruptListener_0100, TestSize.Level1)
384 {
385     EXPECT_NE(Status::OK, audioCaptureModule_->SetAudioInterruptListener(nullptr));
386     std::shared_ptr<AudioCaptureModule::AudioCaptureModuleCallback> callback =
387         std::make_shared<AudioCaptureModuleCallbackTest>();
388     EXPECT_EQ(Status::OK, audioCaptureModule_->SetAudioInterruptListener(callback));
389     Status ret = audioCaptureModule_->Deinit();
390     ASSERT_TRUE(ret == Status::OK);
391 }
392 /**
393  * @tc.name: AudioGetSize_0100
394  * @tc.desc: test GetSize
395  * @tc.type: FUNC
396  */
397 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0100, TestSize.Level1)
398 {
399     uint64_t size = 0;
400     EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
401     Status ret = audioCaptureModule_->Deinit();
402     ASSERT_TRUE(ret == Status::OK);
403 }
404 /**
405  * @tc.name: AudioGetSize_0200
406  * @tc.desc: test GetSize
407  * @tc.type: FUNC
408  */
409 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0200, TestSize.Level1)
410 {
411     uint64_t size = 0;
412     EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
413     Status ret = audioCaptureModule_->Deinit();
414     ASSERT_TRUE(ret == Status::OK);
415 }
416 /**
417  * @tc.name: AudioGetSize_0300
418  * @tc.desc: test GetSize
419  * @tc.type: FUNC
420  */
421 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetSize_0300, TestSize.Level1)
422 {
423     uint64_t size = 0;
424     EXPECT_NE(Status::OK, audioCaptureModule_->GetSize(size));
425     Status ret = audioCaptureModule_->Deinit();
426     ASSERT_TRUE(ret == Status::OK);
427 }
428 /**
429  * @tc.name: AudioSetParameter_0100
430  * @tc.desc: test SetParameter
431  * @tc.type: FUNC
432  */
433 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0100, TestSize.Level1)
434 {
435     std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
436     audioCaptureModule_->SetParameter(audioCaptureFormat);
437     audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate_);
438     audioCaptureModule_->SetParameter(audioCaptureFormat);
439     audioCaptureFormat->Set<Tag::AUDIO_CHANNEL_COUNT>(channel_);
440     audioCaptureModule_->SetParameter(audioCaptureFormat);
441     audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
442     audioCaptureModule_->SetParameter(audioCaptureFormat);
443 }
444 /**
445  * @tc.name: AudioSetParameter_0200
446  * @tc.desc: test SetParameter
447  * @tc.type: FUNC
448  */
449 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0200, TestSize.Level1)
450 {
451     std::shared_ptr<Meta> audioCaptureFormat = std::make_shared<Meta>();
452     audioCaptureFormat->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_F32P);
453     audioCaptureModule_->SetParameter(audioCaptureFormat);
454 }
455 /**
456  * @tc.name: AudioSetParameter_0300
457  * @tc.desc: test SetParameter
458  * @tc.type: FUNC
459  */
460 HWTEST_F(AudioCaptureModuleUnitTest, AudioSetParameter_0300, TestSize.Level1)
461 {
462     int32_t channel = 3;
463     audioCaptureParameter_->Set<Tag::AUDIO_CHANNEL_COUNT>(channel);
464     audioCaptureModule_->SetParameter(audioCaptureParameter_);
465 }
466 /**
467  * @tc.name: AudioGetParameter_0100
468  * @tc.desc: test GetParameter
469  * @tc.type: FUNC
470  */
471 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetParameter_0100, TestSize.Level1)
472 {
473     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
474     std::shared_ptr<Meta> audioCaptureParameterTest_ = std::make_shared<Meta>();
475     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
476     EXPECT_NE(Status::OK, audioCaptureModule_->GetParameter(audioCaptureParameterTest_));
477     ASSERT_TRUE(ret == Status::OK);
478     ret = audioCaptureModule_->Init();
479     ASSERT_TRUE(ret == Status::OK);
480     ret = audioCaptureModule_->Prepare();
481     ASSERT_TRUE(ret == Status::OK);
482     audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
483 
484     audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_U8);
485     audioCaptureModule_->SetParameter(audioCaptureParameter_);
486     audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
487     int32_t channel = 2;
488     audioCaptureParameter_->Set<Tag::AUDIO_CHANNEL_COUNT>(channel);
489     audioCaptureModule_->SetParameter(audioCaptureParameter_);
490     audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
491     int32_t sampleRate = 64000;
492     audioCaptureParameter_->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate);
493     audioCaptureModule_->SetParameter(audioCaptureParameter_);
494     audioCaptureModule_->GetParameter(audioCaptureParameterTest_);
495     ret = audioCaptureModule_->Deinit();
496     ASSERT_TRUE(ret == Status::OK);
497 }
498 /**
499  * @tc.name: AudioReset_0100
500  * @tc.desc: test Reset
501  * @tc.type: FUNC
502  */
503 HWTEST_F(AudioCaptureModuleUnitTest, AudioReset_0100, TestSize.Level1)
504 {
505     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
506     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
507     ASSERT_TRUE(ret == Status::OK);
508     ret = audioCaptureModule_->Init();
509     ASSERT_TRUE(ret == Status::OK);
510     ret = audioCaptureModule_->Prepare();
511     ASSERT_TRUE(ret == Status::OK);
512     ret = audioCaptureModule_->Start();
513     ASSERT_TRUE(ret == Status::OK);
514     uint64_t bufferSize = 0;
515     ret = audioCaptureModule_->GetSize(bufferSize);
516     ASSERT_TRUE(ret == Status::OK);
517     std::shared_ptr<AVAllocator> avAllocator =
518         AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
519     int32_t capacity = 1024;
520     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(avAllocator, capacity);
521     ret = audioCaptureModule_->Read(buffer, bufferSize);
522     ASSERT_TRUE(ret == Status::OK);
523     ret = audioCaptureModule_->Stop();
524     ASSERT_TRUE(ret == Status::OK);
525     ret = audioCaptureModule_->Reset();
526     ASSERT_TRUE(ret == Status::OK);
527     ret = audioCaptureModule_->Deinit();
528     ASSERT_TRUE(ret == Status::OK);
529 }
530 /**
531  * @tc.name: AudioReset_0200
532  * @tc.desc: test Reset
533  * @tc.type: FUNC
534  */
535 HWTEST_F(AudioCaptureModuleUnitTest, AudioReset_0200, TestSize.Level1)
536 {
537     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
538     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
539     ASSERT_TRUE(ret == Status::OK);
540     ret = audioCaptureModule_->Init();
541     ASSERT_TRUE(ret == Status::OK);
542     ret = audioCaptureModule_->Prepare();
543     ASSERT_TRUE(ret == Status::OK);
544     ret = audioCaptureModule_->Reset();
545     ASSERT_TRUE(ret == Status::OK);
546     ret = audioCaptureModule_->Deinit();
547     ASSERT_TRUE(ret == Status::OK);
548 }
549 /**
550  * @tc.name: Audioinit_0100
551  * @tc.desc: test init
552  * @tc.type: FUNC
553  */
554 HWTEST_F(AudioCaptureModuleUnitTest, Audioinit_0100, TestSize.Level1)
555 {
556     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
557     Status ret = audioCaptureModule_->SetParameter(audioCaptureParameter_);
558     ASSERT_TRUE(ret == Status::OK);
559     ret = audioCaptureModule_->Init();
560     ASSERT_TRUE(ret == Status::OK);
561     ret = audioCaptureModule_->Init();
562     ASSERT_TRUE(ret == Status::OK);
563     ret = audioCaptureModule_->Deinit();
564     ASSERT_TRUE(ret == Status::OK);
565 }
566 /**
567  * @tc.name: Audioinit_0200
568  * @tc.desc: test init
569  * @tc.type: FUNC
570  */
571 HWTEST_F(AudioCaptureModuleUnitTest, Audioinit_0200, TestSize.Level1)
572 {
573     audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
574     EXPECT_NE(Status::OK, audioCaptureModule_->Init());
575     Status ret = audioCaptureModule_->Deinit();
576     ASSERT_TRUE(ret == Status::OK);
577 }
578 /**
579  * @tc.name: AudioTrackMaxAmplitude_0200
580  * @tc.desc: test TrackMaxAmplitude
581  * @tc.type: FUNC
582  */
583 HWTEST_F(AudioCaptureModuleUnitTest, AudioTrackMaxAmplitude_0200, TestSize.Level1)
584 {
585     int16_t data[5] = {1, 2, 3, 4, 5};
586     audioCaptureModule_->TrackMaxAmplitude(data, 5);
587     EXPECT_EQ(audioCaptureModule_->maxAmplitude_, 5);
588     int16_t number[5] = {1, -2, 3, -4, 5};
589     audioCaptureModule_->TrackMaxAmplitude(number, 5);
590     EXPECT_EQ(audioCaptureModule_->maxAmplitude_, 5);
591 }
592 /**
593  * @tc.name: AudioGetMaxAmplitude_0200
594  * @tc.desc: test GetMaxAmplitude
595  * @tc.type: FUNC
596  */
597 HWTEST_F(AudioCaptureModuleUnitTest, AudioGetMaxAmplitude_0200, TestSize.Level1)
598 {
599     audioCaptureModule_->isTrackMaxAmplitude = true;
600     EXPECT_EQ(audioCaptureModule_->GetMaxAmplitude(), 0);
601 }
602 } // namespace OHOS