1 /*
2 * Copyright (C) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "audio_capture_module_unittest.h"
17 #include "buffer/avbuffer_common.h"
18
19 using namespace OHOS;
20 using namespace OHOS::Media;
21 using namespace OHOS::Media::AudioCaptureModule;
22 using namespace testing;
23 using namespace testing::ext;
24
25 const static int32_t CONFIG_SIZE = 1024;
26 const static int32_t CONFIG_CAPACITY = 1024;
27 const static int32_t READ_LEN = 0;
28 const static int32_t TIMES_TWO = 2;
29 const static int32_t EXPECTED_LEN = 1024;
30 const static int32_t STATUS_OK = 0;
31 const static int32_t STATUS_UNKNOWN = -1;
32
33 namespace OHOS {
34 namespace Media {
SetUpTestCase(void)35 void AudioCaptureModuleUnitTest::SetUpTestCase(void)
36 {
37 }
38
TearDownTestCase(void)39 void AudioCaptureModuleUnitTest::TearDownTestCase(void)
40 {
41 }
42
SetUp(void)43 void AudioCaptureModuleUnitTest::SetUp(void)
44 {
45 mockAudioCapturer_ = std::make_unique<MockAudioCapturer>();
46 audioCaptureModule_ = std::make_shared<AudioCaptureModule::AudioCaptureModule>();
47 }
48
TearDown(void)49 void AudioCaptureModuleUnitTest::TearDown(void)
50 {
51 mockAudioCapturer_ = nullptr;
52 audioCaptureModule_ = nullptr;
53 }
54
InitMeta(std::shared_ptr<Meta> meta)55 void AudioCaptureModuleUnitTest::InitMeta(std::shared_ptr<Meta> meta)
56 {
57 int32_t appTokenId = 0;
58 int32_t appUid = 0;
59 int32_t appPid = 0;
60 int64_t appFullTokenId = 0;
61 int32_t sampleRate = 48000;
62 int32_t channel = 1;
63 int64_t bitRate = 48000;
64
65 meta->Set<Tag::APP_TOKEN_ID>(appTokenId);
66 meta->Set<Tag::APP_UID>(appUid);
67 meta->Set<Tag::APP_PID>(appPid);
68 meta->Set<Tag::APP_FULL_TOKEN_ID>(appFullTokenId);
69 meta->Set<Tag::AUDIO_SAMPLE_FORMAT>(Plugins::AudioSampleFormat::SAMPLE_S16LE);
70 meta->Set<Tag::AUDIO_SAMPLE_RATE>(sampleRate);
71 meta->Set<Tag::AUDIO_CHANNEL_COUNT>(channel);
72 meta->Set<Tag::MEDIA_BITRATE>(bitRate);
73 }
74
75 /**
76 * @tc.name : Test DoDeinit
77 * @tc.number: DoDeinit_001
78 * @tc.desc : Test DoDeinit audioCapturer_->GetStatus() == AudioStandard::CapturerState::CAPTURER_RUNNING
79 */
80 HWTEST_F(AudioCaptureModuleUnitTest, DoDeinit_001, TestSize.Level1)
81 {
82 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
83 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_RUNNING));
84 EXPECT_CALL(*mockAudioCapturer_, Stop())
85 .WillOnce(Return(true));
86 EXPECT_CALL(*mockAudioCapturer_, Release())
87 .WillOnce(Return(true));
88 EXPECT_CALL(*mockAudioCapturer_, RemoveAudioCapturerInfoChangeCallback(_))
89 .WillOnce(Return(true));
90 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
91 EXPECT_EQ(audioCaptureModule_->DoDeinit(), Status::OK);
92 }
93
94 /**
95 * @tc.name : Test Reset
96 * @tc.number: Reset_001
97 * @tc.desc : Test Reset audioCapturer_->GetStatus() == AudioStandard::CapturerState::CAPTURER_RUNNING
98 */
99 HWTEST_F(AudioCaptureModuleUnitTest, Reset_001, TestSize.Level1)
100 {
101 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
102 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_RUNNING));
103 EXPECT_CALL(*mockAudioCapturer_, Stop())
104 .WillOnce(Return(true));
105 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
106 audioCaptureModule_->Reset();
107 audioCaptureModule_->audioCapturer_.reset();
108 }
109
110 /**
111 * @tc.name : Test Start
112 * @tc.number: Start_001
113 * @tc.desc : Test Start audioCapturer_->GetStatus() == AudioStandard::CapturerState::CAPTURER_RUNNING
114 */
115 HWTEST_F(AudioCaptureModuleUnitTest, Start_001, TestSize.Level1)
116 {
117 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
118 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_RUNNING));
119 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
120 audioCaptureModule_->Start();
121 audioCaptureModule_->audioCapturer_.reset();
122 }
123
124 /**
125 * @tc.name : Test Start
126 * @tc.number: Start_002
127 * @tc.desc : Test Start audioCapturer_->Start() == false
128 */
129 HWTEST_F(AudioCaptureModuleUnitTest, Start_002, TestSize.Level1)
130 {
131 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
132 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_INVALID));
133 EXPECT_CALL(*mockAudioCapturer_, Start())
134 .WillOnce(Return(false));
135 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
136 audioCaptureModule_->Start();
137 audioCaptureModule_->audioCapturer_.reset();
138 }
139
140 /**
141 * @tc.name : Test Stop
142 * @tc.number: Stop_001
143 * @tc.desc : Test Stop audioCapturer_->Stop() == false
144 */
145 HWTEST_F(AudioCaptureModuleUnitTest, Stop_001, TestSize.Level1)
146 {
147 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
148 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_RUNNING));
149 EXPECT_CALL(*mockAudioCapturer_, Stop())
150 .WillOnce(Return(false));
151 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
152 audioCaptureModule_->Stop();
153 audioCaptureModule_->audioCapturer_.reset();
154 }
155
156 /**
157 * @tc.name : Test Read
158 * @tc.number: Read_001
159 * @tc.desc : Test Read audioCapturer_ == nullptr
160 */
161 HWTEST_F(AudioCaptureModuleUnitTest, Read_001, TestSize.Level1)
162 {
163 uint8_t *ptr = new uint8_t[EXPECTED_LEN];
164 int32_t capacity = CONFIG_CAPACITY;
165 int32_t size = CONFIG_SIZE;
166 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(ptr, capacity, size);
167 size_t expectedLen = EXPECTED_LEN;
168 audioCaptureModule_->audioCapturer_ = nullptr;
169 EXPECT_EQ(audioCaptureModule_->Read(buffer, expectedLen), Status::ERROR_WRONG_STATE);
170 }
171
172 /**
173 * @tc.name : Test Read
174 * @tc.number: Read_002
175 * @tc.desc : Test Read isTrackMaxAmplitude == true
176 */
177 HWTEST_F(AudioCaptureModuleUnitTest, Read_002, TestSize.Level1)
178 {
179 EXPECT_CALL(*mockAudioCapturer_, GetStatus())
180 .WillOnce(Return(AudioStandard::CapturerState::CAPTURER_RUNNING));
181 EXPECT_CALL(*mockAudioCapturer_, Read(_, _, _))
182 .WillOnce(Return(READ_LEN));
183 audioCaptureModule_->isTrackMaxAmplitude = true;
184 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
185 uint8_t *cacheAudioData = new uint8_t[EXPECTED_LEN];
186 size_t expectedLen = EXPECTED_LEN;
187 audioCaptureModule_->Read(cacheAudioData, expectedLen);
188 audioCaptureModule_->audioCapturer_.reset();
189 }
190
191 /**
192 * @tc.name : Test SetWillMuteWhenInterrupted
193 * @tc.number: SetWillMuteWhenInterrupted_001
194 * @tc.desc : Test SetWillMuteWhenInterrupted audioCapturer_->SetInterruptStrategy
195 */
196 HWTEST_F(AudioCaptureModuleUnitTest, SetWillMuteWhenInterrupted_001, TestSize.Level1)
197 {
198 EXPECT_CALL(*mockAudioCapturer_, SetInterruptStrategy(_))
199 .Times(TIMES_TWO)
200 .WillOnce(Return(STATUS_OK))
201 .WillOnce(Return(STATUS_UNKNOWN));
202 bool muteWhenInterrupted = true;
203 audioCaptureModule_->audioCapturer_ = std::move(mockAudioCapturer_);
204 EXPECT_EQ(audioCaptureModule_->SetWillMuteWhenInterrupted(muteWhenInterrupted), Status::OK);
205 EXPECT_EQ(audioCaptureModule_->SetWillMuteWhenInterrupted(muteWhenInterrupted), Status::ERROR_UNKNOWN);
206 audioCaptureModule_->audioCapturer_.reset();
207 }
208
209 /**
210 * @tc.name : Test OnInterrupt
211 * @tc.number: OnInterrupt_001
212 * @tc.desc : Test OnInterrupt interruptEvent.hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_MUTE
213 * Test OnInterrupt interruptEvent.hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_UNMUTE
214 * Test OnInterrupt interruptEvent.hintType != AudioStandard::InterruptHint::INTERRUPT_HINT_NONE
215 * && interruptEvent.hintType != AudioStandard::InterruptHint::INTERRUPT_HINT_UNMUTE
216 */
217 HWTEST_F(AudioCaptureModuleUnitTest, OnInterrupt_001, TestSize.Level1)
218 {
219 auto audioCaptureParameter_ = std::make_shared<Meta>();
220 InitMeta(audioCaptureParameter_);
221 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
222 Status status = audioCaptureModule_->SetParameter(audioCaptureParameter_);
223 status = audioCaptureModule_->Init();
224
225 // Test OnInterrupt interruptEvent.hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_MUTE
226 AudioStandard::InterruptEvent interruptEvent = {};
227 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_MUTE;
228 audioCaptureModule_->audioInterruptCallback_->OnInterrupt(interruptEvent);
229
230 // Test OnInterrupt interruptEvent.hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_UNMUTE
231 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_UNMUTE;
232 audioCaptureModule_->audioInterruptCallback_->OnInterrupt(interruptEvent);
233
234 // Test OnInterrupt interruptEvent.hintType == AudioStandard::InterruptHint::INTERRUPT_HINT_NONE
235 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_NONE;
236 audioCaptureModule_->audioInterruptCallback_->OnInterrupt(interruptEvent);
237
238 EXPECT_EQ(status, Status::OK);
239 }
240
241 /**
242 * @tc.name : Test OnInterrupt
243 * @tc.number: OnInterrupt_002
244 * @tc.desc : Test OnInterrupt audioCaptureModuleCallback_ == nullptr
245 * Test OnInterrupt audioCaptureModuleCallback_ != nullptr
246 */
247 HWTEST_F(AudioCaptureModuleUnitTest, OnInterrupt_002, TestSize.Level1)
248 {
249 auto audioCaptureParameter_ = std::make_shared<Meta>();
250 InitMeta(audioCaptureParameter_);
251 audioCaptureModule_->SetAudioSource(AudioStandard::SourceType::SOURCE_TYPE_MIC);
252 Status status = audioCaptureModule_->SetParameter(audioCaptureParameter_);
253 status = audioCaptureModule_->Init();
254
255 // Test OnInterrupt audioCaptureModuleCallback_ == nullptr
256 audioCaptureModule_->audioCaptureModuleCallback_ = nullptr;
257 AudioStandard::InterruptEvent interruptEvent = {};
258 interruptEvent.hintType = AudioStandard::InterruptHint::INTERRUPT_HINT_NONE;
259 audioCaptureModule_->audioInterruptCallback_->OnInterrupt(interruptEvent);
260
261 // Test OnInterrupt audioCaptureModuleCallback_ != nullptr
262 std::shared_ptr<MockAudioCaptureModuleCallback> mockCallback =
263 std::make_shared<MockAudioCaptureModuleCallback>();
264 audioCaptureModule_->audioCapturer_.reset(nullptr);
265 audioCaptureModule_->audioCaptureModuleCallback_ = mockCallback;
266 status = audioCaptureModule_->Init();
267 audioCaptureModule_->audioInterruptCallback_->OnInterrupt(interruptEvent);
268 EXPECT_EQ(status, Status::OK);
269 }
270 } // namespace Media
271 } // namespace OHOS