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, DEVICE_TYPE_SPEAKER);
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 UsbSource API
298 * @tc.number : UsbSourceUnitTest_001
299 * @tc.desc : Test usb source create
300 */
301 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_001, TestSize.Level1)
302 {
303 InitUsbSource();
304 EXPECT_TRUE(usbSource_);
305 DeInitUsbSource();
306 }
307
308 /**
309 * @tc.name : Test UsbSource API
310 * @tc.number : UsbSourceUnitTest_002
311 * @tc.desc : Test usb source init
312 */
313 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_002, TestSize.Level1)
314 {
315 InitUsbSource();
316 EXPECT_TRUE(usbSource_);
317 DeInitUsbSource();
318 }
319
320 /**
321 * @tc.name : Test UsbSource API
322 * @tc.number : UsbSourceUnitTest_003
323 * @tc.desc : Test usb source deinit
324 */
325 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_003, TestSize.Level1)
326 {
327 InitUsbSource();
328 EXPECT_TRUE(usbSource_);
329 usbSource_->DeInit();
330 int32_t ret = usbSource_->Init(attr_);
331 EXPECT_NE(ret, SUCCESS);
332 ret = usbSource_->Init(attr_);
333 EXPECT_NE(ret, SUCCESS);
334 DeInitUsbSource();
335 }
336
337 /**
338 * @tc.name : Test UsbSource API
339 * @tc.number : UsbSourceUnitTest_004
340 * @tc.desc : Test usb source start, stop, resume, pause, flush, reset
341 */
342 HWTEST_F(AudioCaptureSourceUnitTest, UsbSourceUnitTest_004, TestSize.Level1)
343 {
344 InitUsbSource();
345 EXPECT_TRUE(usbSource_);
346 int32_t ret = usbSource_->Start();
347 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
348 ret = usbSource_->Stop();
349 EXPECT_EQ(ret, SUCCESS);
350 ret = usbSource_->Resume();
351 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
352 ret = usbSource_->Pause();
353 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
354 ret = usbSource_->Flush();
355 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
356 ret = usbSource_->Reset();
357 EXPECT_EQ(ret, ERR_INVALID_HANDLE);
358 ret = usbSource_->Stop();
359 EXPECT_EQ(ret, SUCCESS);
360 DeInitUsbSource();
361 }
362
363 } // namespace AudioStandard
364 } // namespace OHOS
365