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 <iostream>
17 #include <gtest/gtest.h>
18 #include <gmock/gmock.h>
19 #include "audio_utils.h"
20 #include "common/hdi_adapter_info.h"
21 #include "manager/hdi_adapter_manager.h"
22
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace AudioStandard {
27 class AudioCaptureSourceUnitTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
SetUp()31 virtual void SetUp() {}
TearDown()32 virtual void TearDown() {}
33
34 void InitPrimarySource();
35 void DeInitPrimarySource();
36 void InitUsbSource();
37 void DeInitUsbSource();
38
39 protected:
40 static uint32_t primaryId_;
41 static uint32_t usbId_;
42 static std::shared_ptr<IAudioCaptureSource> primarySource_;
43 static std::shared_ptr<IAudioCaptureSource> usbSource_;
44 static IAudioSourceAttr attr_;
45 };
46
47 uint32_t AudioCaptureSourceUnitTest::primaryId_ = 0;
48 uint32_t AudioCaptureSourceUnitTest::usbId_ = 0;
49 std::shared_ptr<IAudioCaptureSource> AudioCaptureSourceUnitTest::primarySource_ = nullptr;
50 std::shared_ptr<IAudioCaptureSource> AudioCaptureSourceUnitTest::usbSource_ = nullptr;
51 IAudioSourceAttr AudioCaptureSourceUnitTest::attr_ = {};
52
SetUpTestCase()53 void AudioCaptureSourceUnitTest::SetUpTestCase()
54 {
55 HdiAdapterManager &manager = HdiAdapterManager::GetInstance();
56 primaryId_ = manager.GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_DEFAULT, true);
57 usbId_ = manager.GetId(HDI_ID_BASE_CAPTURE, HDI_ID_TYPE_PRIMARY, HDI_ID_INFO_USB, true);
58 }
59
TearDownTestCase()60 void AudioCaptureSourceUnitTest::TearDownTestCase()
61 {
62 HdiAdapterManager::GetInstance().ReleaseId(primaryId_);
63 HdiAdapterManager::GetInstance().ReleaseId(usbId_);
64 }
65
InitPrimarySource()66 void AudioCaptureSourceUnitTest::InitPrimarySource()
67 {
68 primarySource_ = HdiAdapterManager::GetInstance().GetCaptureSource(primaryId_, true);
69 if (primarySource_ == nullptr) {
70 return;
71 }
72 attr_.adapterName = "primary";
73 attr_.sampleRate = 48000; // 48000: sample rate
74 attr_.channel = 2; // 2: channel
75 attr_.format = SAMPLE_S16LE;
76 attr_.channelLayout = 3; // 3: channel layout
77 attr_.deviceType = DEVICE_TYPE_MIC;
78 attr_.openMicSpeaker = 1;
79 primarySource_->Init(attr_);
80 }
81
DeInitPrimarySource()82 void AudioCaptureSourceUnitTest::DeInitPrimarySource()
83 {
84 if (primarySource_ && primarySource_->IsInited()) {
85 primarySource_->DeInit();
86 }
87 primarySource_ = nullptr;
88 }
89
InitUsbSource()90 void AudioCaptureSourceUnitTest::InitUsbSource()
91 {
92 usbSource_ = HdiAdapterManager::GetInstance().GetCaptureSource(usbId_, true);
93 if (usbSource_ == nullptr) {
94 return;
95 }
96 attr_.adapterName = "usb";
97 attr_.channel = 2; // 2: channel
98 usbSource_->Init(attr_);
99 }
100
DeInitUsbSource()101 void AudioCaptureSourceUnitTest::DeInitUsbSource()
102 {
103 if (usbSource_ && usbSource_->IsInited()) {
104 usbSource_->DeInit();
105 }
106 usbSource_ = nullptr;
107 }
108
109 /**
110 * @tc.name : Test PrimarySource API
111 * @tc.number : PrimarySourceUnitTest_001
112 * @tc.desc : Test primary source create
113 */
114 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_001, TestSize.Level1)
115 {
116 InitPrimarySource();
117 EXPECT_TRUE(primarySource_ != nullptr);
118 DeInitPrimarySource();
119 }
120
121 /**
122 * @tc.name : Test PrimarySource API
123 * @tc.number : PrimarySourceUnitTest_002
124 * @tc.desc : Test primary source init
125 */
126 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_002, TestSize.Level1)
127 {
128 InitPrimarySource();
129 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
130 DeInitPrimarySource();
131 }
132
133 /**
134 * @tc.name : Test PrimarySource API
135 * @tc.number : PrimarySourceUnitTest_003
136 * @tc.desc : Test primary source deinit
137 */
138 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_003, TestSize.Level1)
139 {
140 InitPrimarySource();
141 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
142 primarySource_->DeInit();
143 int32_t ret = primarySource_->Init(attr_);
144 EXPECT_EQ(ret, SUCCESS);
145 ret = primarySource_->Init(attr_);
146 EXPECT_EQ(ret, SUCCESS);
147 EXPECT_TRUE(primarySource_->IsInited());
148 DeInitPrimarySource();
149 }
150
151 /**
152 * @tc.name : Test PrimarySource API
153 * @tc.number : PrimarySourceUnitTest_004
154 * @tc.desc : Test primary source start, stop, resume, pause, flush, reset
155 */
156 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_004, TestSize.Level1)
157 {
158 InitPrimarySource();
159 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
160 int32_t ret = primarySource_->Start();
161 EXPECT_EQ(ret, SUCCESS);
162 ret = primarySource_->Stop();
163 EXPECT_EQ(ret, SUCCESS);
164 ret = primarySource_->Start();
165 EXPECT_EQ(ret, SUCCESS);
166 ret = primarySource_->Resume();
167 EXPECT_EQ(ret, SUCCESS);
168 ret = primarySource_->Pause();
169 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
170 ret = primarySource_->Flush();
171 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
172 ret = primarySource_->Reset();
173 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
174 ret = primarySource_->Stop();
175 EXPECT_EQ(ret, SUCCESS);
176 DeInitPrimarySource();
177 }
178
179 /**
180 * @tc.name : Test PrimarySource API
181 * @tc.number : PrimarySourceUnitTest_005
182 * @tc.desc : Test primary source get param
183 */
184 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_005, TestSize.Level1)
185 {
186 InitPrimarySource();
187 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
188 std::string param = primarySource_->GetAudioParameter(USB_DEVICE, "");
189 EXPECT_EQ(param, "");
190 DeInitPrimarySource();
191 }
192
193 /**
194 * @tc.name : Test PrimarySource API
195 * @tc.number : PrimarySourceUnitTest_006
196 * @tc.desc : Test primary source set volume
197 */
198 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_006, TestSize.Level1)
199 {
200 InitPrimarySource();
201 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
202 int32_t ret = primarySource_->SetVolume(1.0f, 1.0f);
203 EXPECT_NE(ret, SUCCESS);
204 DeInitPrimarySource();
205 }
206
207 /**
208 * @tc.name : Test PrimarySource API
209 * @tc.number : PrimarySourceUnitTest_007
210 * @tc.desc : Test primary source set/get mute
211 */
212 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_007, TestSize.Level1)
213 {
214 InitPrimarySource();
215 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
216 int32_t ret = primarySource_->SetMute(false);
217 EXPECT_EQ(ret, SUCCESS);
218 bool mute = false;
219 ret = primarySource_->GetMute(mute);
220 EXPECT_EQ(ret, SUCCESS);
221 EXPECT_FALSE(mute);
222 DeInitPrimarySource();
223 }
224
225 /**
226 * @tc.name : Test PrimarySource API
227 * @tc.number : PrimarySourceUnitTest_008
228 * @tc.desc : Test primary source get transaction id
229 */
230 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_008, TestSize.Level1)
231 {
232 InitPrimarySource();
233 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
234 uint64_t transId = primarySource_->GetTransactionId();
235 EXPECT_NE(transId, 0);
236 DeInitPrimarySource();
237 }
238
239 /**
240 * @tc.name : Test PrimarySource API
241 * @tc.number : PrimarySourceUnitTest_009
242 * @tc.desc : Test primary source get max amplitude
243 */
244 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_009, TestSize.Level1)
245 {
246 InitPrimarySource();
247 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
248 float maxAmplitude = primarySource_->GetMaxAmplitude();
249 EXPECT_EQ(maxAmplitude, 0.0f);
250 DeInitPrimarySource();
251 }
252
253 /**
254 * @tc.name : Test PrimarySource API
255 * @tc.number : PrimarySourceUnitTest_010
256 * @tc.desc : Test primary source set audio scene
257 */
258 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_010, TestSize.Level1)
259 {
260 InitPrimarySource();
261 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
262 int32_t ret = primarySource_->SetAudioScene(AUDIO_SCENE_DEFAULT);
263 EXPECT_EQ(ret, SUCCESS);
264 DeInitPrimarySource();
265 }
266
267 /**
268 * @tc.name : Test PrimarySource API
269 * @tc.number : PrimarySourceUnitTest_011
270 * @tc.desc : Test primary source update source type
271 */
272 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_011, TestSize.Level1)
273 {
274 InitPrimarySource();
275 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
276 int32_t ret = primarySource_->UpdateSourceType(SOURCE_TYPE_MIC);
277 EXPECT_EQ(ret, SUCCESS);
278 DeInitPrimarySource();
279 }
280
281 /**
282 * @tc.name : Test PrimarySource API
283 * @tc.number : PrimarySourceUnitTest_012
284 * @tc.desc : Test primary source update apps uid
285 */
286 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_012, TestSize.Level1)
287 {
288 InitPrimarySource();
289 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
290 vector<int32_t> appsUid;
291 int32_t ret = primarySource_->UpdateAppsUid(appsUid);
292 EXPECT_EQ(ret, SUCCESS);
293 DeInitPrimarySource();
294 }
295
296 /**
297 * @tc.name : Test PrimarySource API
298 * @tc.number : PrimarySourceUnitTest_013
299 * @tc.desc : Test primary source IsCaptureInvalid
300 */
301 HWTEST_F(AudioCaptureSourceUnitTest, PrimarySourceUnitTest_013, TestSize.Level1)
302 {
303 InitPrimarySource();
304 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
305 EXPECT_TRUE(primarySource_->IsCaptureInvalid());
306 primarySource_->DeInit();
307 EXPECT_FALSE(primarySource_->IsCaptureInvalid());
308 DeInitPrimarySource();
309 }
310
311 /**
312 * @tc.name : Test SetDmDeviceType API
313 * @tc.number : SetDmDeviceType_001
314 * @tc.desc : Test SetDmDeviceType
315 */
316 HWTEST_F(AudioCaptureSourceUnitTest, SetDmDeviceType_001, TestSize.Level1)
317 {
318 InitPrimarySource();
319 EXPECT_TRUE(primarySource_ && primarySource_->IsInited());
320 primarySource_->UpdateActiveDevice(DEVICE_TYPE_MIC);
321 primarySource_->SetDmDeviceType(DM_DEVICE_TYPE_DEFAULT, DEVICE_TYPE_MIC);
322 primarySource_->SetDmDeviceType(DM_DEVICE_TYPE_NEARLINK_SCO, DEVICE_TYPE_MIC);
323 DeInitPrimarySource();
324 }
325
326 /**
327 * @tc.name : Test UsbSource API
328 * @tc.number : UsbSourceUnitTest_001
329 * @tc.desc : Test usb source create
330 */
331 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_001, TestSize.Level1)
332 {
333 InitUsbSource();
334 EXPECT_TRUE(usbSource_);
335 DeInitUsbSource();
336 }
337
338 /**
339 * @tc.name : Test UsbSource API
340 * @tc.number : UsbSourceUnitTest_002
341 * @tc.desc : Test usb source init
342 */
343 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_002, TestSize.Level1)
344 {
345 InitUsbSource();
346 EXPECT_TRUE(usbSource_);
347 DeInitUsbSource();
348 }
349
350 /**
351 * @tc.name : Test UsbSource API
352 * @tc.number : UsbSourceUnitTest_003
353 * @tc.desc : Test usb source deinit
354 */
355 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_003, TestSize.Level1)
356 {
357 InitUsbSource();
358 EXPECT_TRUE(usbSource_);
359 usbSource_->DeInit();
360 int32_t ret = usbSource_->Init(attr_);
361 EXPECT_NE(ret, SUCCESS);
362 ret = usbSource_->Init(attr_);
363 EXPECT_NE(ret, SUCCESS);
364 DeInitUsbSource();
365 }
366
367 /**
368 * @tc.name : Test UsbSource API
369 * @tc.number : UsbSourceUnitTest_004
370 * @tc.desc : Test usb source start, stop, resume, pause, flush, reset
371 */
372 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_004, TestSize.Level1)
373 {
374 InitUsbSource();
375 EXPECT_TRUE(usbSource_);
376 int32_t ret = usbSource_->Start();
377 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
378 ret = usbSource_->Stop();
379 EXPECT_EQ(ret, SUCCESS);
380 ret = usbSource_->Resume();
381 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
382 ret = usbSource_->Pause();
383 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
384 ret = usbSource_->Flush();
385 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
386 ret = usbSource_->Reset();
387 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
388 ret = usbSource_->Stop();
389 EXPECT_EQ(ret, SUCCESS);
390 DeInitUsbSource();
391 }
392
393 } // namespace AudioStandard
394 } // namespace OHOS
395