1 /*
2 * Copyright (c) 2022 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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_proxy_common_fun_test.h"
19
20 using namespace comfun;
21 using namespace testing::ext;
22 namespace {
23 class AudioProxyCaptureTest : public testing::Test {
24 public:
25 struct AudioManager *managerFuncs = nullptr;
26 struct AudioManager *(*getAudioManager)(void) = NULL;
27 struct AudioAdapterDescriptor *descs = nullptr;
28 struct AudioAdapterDescriptor *desc = nullptr;
29 struct AudioAdapter *adapter = nullptr;
30 struct AudioCapture *capture = nullptr;
31 struct AudioPort *audioPort = nullptr;
32 void *clientHandle = nullptr;
33 struct AudioDeviceDescriptor devDescCapture = {};
34 struct AudioSampleAttributes attrsCapture = {};
35 virtual void SetUp();
36 virtual void TearDown();
37 };
38
SetUp()39 void AudioProxyCaptureTest::SetUp()
40 {
41 clientHandle = GetDynamicLibHandle(RESOLVED_PATH);
42 ASSERT_NE(clientHandle, nullptr);
43 getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str()));
44 ASSERT_NE(getAudioManager, nullptr);
45 managerFuncs = getAudioManager();
46 ASSERT_NE(managerFuncs, nullptr);
47 int32_t size = 0;
48 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
49
50 desc = &descs[0];
51 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
52 ASSERT_NE(adapter, nullptr);
53 ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDescCapture));
54 ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrsCapture));
55 ASSERT_EQ(HDF_SUCCESS, adapter->CreateCapture(adapter, &devDescCapture, &attrsCapture, &capture));
56 }
57
TearDown()58 void AudioProxyCaptureTest::TearDown()
59 {
60 if (adapter != nullptr) {
61 adapter->DestroyCapture(adapter, capture);
62 capture = nullptr;
63 }
64 if (managerFuncs != nullptr) {
65 managerFuncs->UnloadAdapter(managerFuncs, adapter);
66 adapter = nullptr;
67 managerFuncs->ReleaseAudioManagerObject(managerFuncs);
68 managerFuncs = nullptr;
69 }
70 if (clientHandle != nullptr) {
71 dlclose(clientHandle);
72 clientHandle = nullptr;
73 }
74 }
75
76 HWTEST_F(AudioProxyCaptureTest, CaptureStart_001, TestSize.Level1)
77 {
78 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStart(nullptr));
79 }
80
81 HWTEST_F(AudioProxyCaptureTest, CaptureStart_002, TestSize.Level1)
82 {
83 ASSERT_NE(capture, nullptr);
84 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
85 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
86 hwCapture->proxyRemoteHandle = nullptr;
87 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStart((AudioHandle)capture));
88 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
89 }
90
91 HWTEST_F(AudioProxyCaptureTest, CaptureStart_003, TestSize.Level1)
92 {
93 ASSERT_NE(capture, nullptr);
94 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStart((AudioHandle)capture));
95 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStop((AudioHandle)capture));
96 }
97
98 HWTEST_F(AudioProxyCaptureTest, CaptureStop_001, TestSize.Level1)
99 {
100 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStop(nullptr));
101 }
102
103 HWTEST_F(AudioProxyCaptureTest, CaptureStop_002, TestSize.Level1)
104 {
105 ASSERT_NE(capture, nullptr);
106 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
107 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
108 hwCapture->proxyRemoteHandle = nullptr;
109 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureStop((AudioHandle)capture));
110 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
111 }
112
113 HWTEST_F(AudioProxyCaptureTest, CapturePause_001, TestSize.Level1)
114 {
115 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCapturePause(nullptr));
116 }
117
118 HWTEST_F(AudioProxyCaptureTest, CapturePause_002, TestSize.Level1)
119 {
120 ASSERT_NE(capture, nullptr);
121 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
122 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
123 hwCapture->proxyRemoteHandle = nullptr;
124 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCapturePause((AudioHandle)capture));
125 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
126 }
127
128 HWTEST_F(AudioProxyCaptureTest, CaptureResume_001, TestSize.Level1)
129 {
130 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureResume(nullptr));
131 }
132
133 HWTEST_F(AudioProxyCaptureTest, CaptureResume_002, TestSize.Level1)
134 {
135 ASSERT_NE(capture, nullptr);
136 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
137 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
138 hwCapture->proxyRemoteHandle = nullptr;
139 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureResume((AudioHandle)capture));
140 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
141 }
142
143 HWTEST_F(AudioProxyCaptureTest, CaptureFlush_001, TestSize.Level1)
144 {
145 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureFlush(nullptr));
146 }
147
148 HWTEST_F(AudioProxyCaptureTest, CaptureFlush_002, TestSize.Level1)
149 {
150 ASSERT_NE(capture, nullptr);
151 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyCaptureFlush((AudioHandle)capture));
152 }
153
154 HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_001, TestSize.Level1)
155 {
156 ASSERT_NE(capture, nullptr);
157 uint64_t size = 0;
158 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize(nullptr, &size));
159 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize((AudioHandle)capture, nullptr));
160 }
161
162 HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_002, TestSize.Level1)
163 {
164 ASSERT_NE(capture, nullptr);
165 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
166 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
167 hwCapture->proxyRemoteHandle = nullptr;
168 uint64_t size = 0;
169 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameSize((AudioHandle)capture, &size));
170 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
171 }
172
173 HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameSize_003, TestSize.Level1)
174 {
175 ASSERT_NE(capture, nullptr);
176 uint64_t size = 0;
177 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetFrameSize((AudioHandle)capture, &size));
178 EXPECT_NE(size, 0);
179 }
180
181 HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameCount_001, TestSize.Level1)
182 {
183 ASSERT_NE(capture, nullptr);
184 uint64_t count = 0;
185 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount(nullptr, &count));
186 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount((AudioHandle)capture, nullptr));
187 }
188
189 HWTEST_F(AudioProxyCaptureTest, CaptureGetFrameCount_002, TestSize.Level1)
190 {
191 ASSERT_NE(capture, nullptr);
192 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
193 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
194 hwCapture->proxyRemoteHandle = nullptr;
195 uint64_t count = 0;
196 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetFrameCount((AudioHandle)capture, &count));
197 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
198 }
199
200 HWTEST_F(AudioProxyCaptureTest, CaptureSetSampleAttributes_001, TestSize.Level1)
201 {
202 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetSampleAttributes(nullptr, &attrsCapture));
203 }
204
205 HWTEST_F(AudioProxyCaptureTest, CaptureSetSampleAttributes_002, TestSize.Level1)
206 {
207 ASSERT_NE(capture, nullptr);
208 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
209 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
210 hwCapture->proxyRemoteHandle = nullptr;
211 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetSampleAttributes((AudioHandle)capture, &attrsCapture));
212 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
213 }
214
215 HWTEST_F(AudioProxyCaptureTest, CaptureGetSampleAttributes_001, TestSize.Level1)
216 {
217 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetSampleAttributes(nullptr, &attrsCapture));
218 }
219
220 HWTEST_F(AudioProxyCaptureTest, CaptureGetSampleAttributes_002, TestSize.Level1)
221 {
222 ASSERT_NE(capture, nullptr);
223 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
224 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
225 hwCapture->proxyRemoteHandle = nullptr;
226 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetSampleAttributes((AudioHandle)capture, &attrsCapture));
227 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
228 }
229
230 HWTEST_F(AudioProxyCaptureTest, CaptureGetCurrentChannelId_001, TestSize.Level1)
231 {
232 uint32_t channelId = 0;
233 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId(nullptr, &channelId));
234 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId((AudioHandle)capture, nullptr));
235 }
236
237 HWTEST_F(AudioProxyCaptureTest, CaptureGetCurrentChannelId_002, TestSize.Level1)
238 {
239 ASSERT_NE(capture, nullptr);
240 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
241 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
242 hwCapture->proxyRemoteHandle = nullptr;
243 uint32_t channelId = 0;
244 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCurrentChannelId((AudioHandle)capture, &channelId));
245 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
246 }
247
248 HWTEST_F(AudioProxyCaptureTest, CaptureCheckSceneCapability_001, TestSize.Level1)
249 {
250 ASSERT_NE(capture, nullptr);
251 struct AudioSceneDescriptor scene;
252 scene.scene.id = 0;
253 scene.desc.pins = PIN_IN_MIC;
254 bool supported = false;
255 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability(nullptr, &scene, &supported));
256 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, nullptr,
257 &supported));
258 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, &scene,
259 nullptr));
260 }
261
262 HWTEST_F(AudioProxyCaptureTest, CaptureCheckSceneCapability_002, TestSize.Level1)
263 {
264 ASSERT_NE(capture, nullptr);
265 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
266 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
267 hwCapture->proxyRemoteHandle = nullptr;
268 struct AudioSceneDescriptor scene;
269 scene.scene.id = 0;
270 scene.desc.pins = PIN_IN_MIC;
271 bool supported = false;
272 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCheckSceneCapability((AudioHandle)capture, &scene,
273 &supported));
274 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
275 }
276
277 HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_001, TestSize.Level1)
278 {
279 ASSERT_NE(capture, nullptr);
280 struct AudioSceneDescriptor scene;
281 scene.scene.id = 0;
282 scene.desc.pins = PIN_IN_MIC;
283 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene(nullptr, &scene));
284 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene((AudioHandle)capture, nullptr));
285 }
286
287 HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_002, TestSize.Level1)
288 {
289 ASSERT_NE(capture, nullptr);
290 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
291 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
292 hwCapture->proxyRemoteHandle = nullptr;
293 struct AudioSceneDescriptor scene;
294 scene.scene.id = 0;
295 scene.desc.pins = PIN_IN_MIC;
296 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSelectScene((AudioHandle)capture, &scene));
297 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
298 }
299
300 HWTEST_F(AudioProxyCaptureTest, CaptureSelectScene_003, TestSize.Level1)
301 {
302 ASSERT_NE(capture, nullptr);
303 struct AudioSceneDescriptor *scene = new AudioSceneDescriptor;
304 scene->scene.id = 0; // 0 is Media
305 scene->desc.pins = PIN_IN_HS_MIC;
306 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSelectScene((AudioHandle)capture, scene));
307 scene->desc.pins = PIN_IN_MIC;
308 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSelectScene((AudioHandle)capture, scene));
309 delete scene;
310 scene = nullptr;
311 }
312
313 HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_001, TestSize.Level1)
314 {
315 bool mute = false;
316 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetMute(nullptr, mute));
317 }
318
319 HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_002, TestSize.Level1)
320 {
321 ASSERT_NE(capture, nullptr);
322 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
323 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
324 hwCapture->proxyRemoteHandle = nullptr;
325 bool mute = false;
326 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetMute((AudioHandle)capture, mute));
327 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
328 }
329
330 HWTEST_F(AudioProxyCaptureTest, CaptureSetMute_003, TestSize.Level1)
331 {
332 ASSERT_NE(capture, nullptr);
333 bool mute;
334 mute = true;
335 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSetMute((AudioHandle)capture, mute));
336 mute = false;
337 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureSetMute((AudioHandle)capture, mute));
338 }
339
340 HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_001, TestSize.Level1)
341 {
342 ASSERT_NE(capture, nullptr);
343 bool mute = false;
344 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute(nullptr, &mute));
345 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute((AudioHandle)capture, nullptr));
346 }
347
348 HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_002, TestSize.Level1)
349 {
350 ASSERT_NE(capture, nullptr);
351 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
352 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
353 hwCapture->proxyRemoteHandle = nullptr;
354 bool mute = false;
355 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMute((AudioHandle)capture, &mute));
356 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
357 }
358
359 HWTEST_F(AudioProxyCaptureTest, CaptureGetMute_003, TestSize.Level1)
360 {
361 ASSERT_NE(capture, nullptr);
362 bool mute = false;
363 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetMute((AudioHandle)capture, &mute));
364 }
365
366 HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_001, TestSize.Level1)
367 {
368 float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half
369 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume(nullptr, volume));
370 }
371
372 HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_002, TestSize.Level1)
373 {
374 ASSERT_NE(capture, nullptr);
375 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
376 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
377 hwCapture->proxyRemoteHandle = nullptr;
378 float volume = HALF_OF_NORMAL_VALUE; // Adjust the volume to half
379 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume));
380 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
381 }
382
383 HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_003, TestSize.Level1)
384 {
385 ASSERT_NE(capture, nullptr);
386 float volume = MIN_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]
387 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume));
388 }
389
390 HWTEST_F(AudioProxyCaptureTest, CaptureSetVolume_004, TestSize.Level1)
391 {
392 float volume = MAX_VALUE_OUT_OF_BOUNDS; // The volume value is not within the threshold range [0,1]
393 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetVolume((AudioHandle)capture, volume));
394 }
395
396 HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_001, TestSize.Level1)
397 {
398 float volume = 0;
399 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetVolume(nullptr, &volume));
400 }
401
402 HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_002, TestSize.Level1)
403 {
404 ASSERT_NE(capture, nullptr);
405 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
406 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
407 hwCapture->proxyRemoteHandle = nullptr;
408 float volume = 0;
409 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetVolume((AudioHandle)capture, &volume));
410 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
411 }
412
413 HWTEST_F(AudioProxyCaptureTest, CaptureGetVolume_003, TestSize.Level1)
414 {
415 ASSERT_NE(capture, nullptr);
416 float volume = 0;
417 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureGetVolume((AudioHandle)capture, &volume));
418 }
419
420 HWTEST_F(AudioProxyCaptureTest, CaptureGetGainThreshold_001, TestSize.Level1)
421 {
422 ASSERT_NE(capture, nullptr);
423 float min = 0;
424 float max = 0;
425 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold(nullptr, &min, &max));
426 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, nullptr, &max));
427 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, &min, nullptr));
428 }
429
430 HWTEST_F(AudioProxyCaptureTest, CaptureGetGainThreshold_002, TestSize.Level1)
431 {
432 ASSERT_NE(capture, nullptr);
433 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
434 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
435 hwCapture->proxyRemoteHandle = nullptr;
436 float min = 0;
437 float max = 0;
438 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGainThreshold((AudioHandle)capture, &min, &max));
439 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
440 }
441
442 HWTEST_F(AudioProxyCaptureTest, CaptureGetGain_001, TestSize.Level1)
443 {
444 ASSERT_NE(capture, nullptr);
445 float gain = 0;
446 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain(nullptr, &gain));
447 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain((AudioHandle)capture, nullptr));
448 }
449
450 HWTEST_F(AudioProxyCaptureTest, CaptureGetGain_002, TestSize.Level1)
451 {
452 ASSERT_NE(capture, nullptr);
453 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
454 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
455 hwCapture->proxyRemoteHandle = nullptr;
456 float gain = 0;
457 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetGain((AudioHandle)capture, &gain));
458 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
459 }
460
461 HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_001, TestSize.Level1)
462 {
463 float gain = 0;
464 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain(nullptr, gain));
465 }
466
467 HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_002, TestSize.Level1)
468 {
469 ASSERT_NE(capture, nullptr);
470 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
471 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
472 hwCapture->proxyRemoteHandle = nullptr;
473 float gain = HALF_OF_NORMAL_VALUE; // The parameter is adjusted to half the threshold of 1
474 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain((AudioHandle)capture, gain));
475 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
476 }
477
478 HWTEST_F(AudioProxyCaptureTest, CaptureSetGain_003, TestSize.Level1)
479 {
480 ASSERT_NE(capture, nullptr);
481 float gain = MIN_VALUE_OUT_OF_BOUNDS;
482 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetGain((AudioHandle)capture, gain));
483 }
484
485 HWTEST_F(AudioProxyCaptureTest, CaptureFrame_001, TestSize.Level1)
486 {
487 ASSERT_NE(capture, nullptr);
488 int8_t frame[AUDIO_CAPTURE_BUF_TEST];
489 uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST;
490 uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST;
491 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(nullptr, &frame, frameLen, &requestBytes));
492 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, nullptr, frameLen, &requestBytes));
493 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, nullptr));
494 }
495
496 HWTEST_F(AudioProxyCaptureTest, CaptureFrame_002, TestSize.Level1)
497 {
498 ASSERT_NE(capture, nullptr);
499 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
500 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
501 hwCapture->proxyRemoteHandle = nullptr;
502 int8_t frame[AUDIO_CAPTURE_BUF_TEST];
503 uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST;
504 uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST;
505 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, &requestBytes));
506 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
507 }
508
509 HWTEST_F(AudioProxyCaptureTest, CaptureFrame_003, TestSize.Level1)
510 {
511 ASSERT_NE(capture, nullptr);
512 int8_t frame[AUDIO_CAPTURE_BUF_TEST ];
513 uint64_t frameLen = AUDIO_CAPTURE_BUF_TEST;
514 uint64_t requestBytes = AUDIO_CAPTURE_BUF_TEST;
515 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStart((AudioHandle)capture));
516 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureCaptureFrame(capture, &frame, frameLen, &requestBytes));
517 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyCaptureStop((AudioHandle)capture));
518 }
519
520 HWTEST_F(AudioProxyCaptureTest, CaptureGetCapturePosition_001, TestSize.Level1)
521 {
522 ASSERT_NE(capture, nullptr);
523 uint64_t frames;
524 struct AudioTimeStamp time;
525 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(nullptr, &frames, &time));
526 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, nullptr, &time));
527 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, &frames, nullptr));
528 }
529
530 HWTEST_F(AudioProxyCaptureTest, CaptureGetCapturePosition_002, TestSize.Level1)
531 {
532 ASSERT_NE(capture, nullptr);
533 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
534 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
535 hwCapture->proxyRemoteHandle = nullptr;
536 uint64_t frames;
537 struct AudioTimeStamp time;
538 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetCapturePosition(capture, &frames, &time));
539 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
540 }
541
542 HWTEST_F(AudioProxyCaptureTest, CaptureSetExtraParams_001, TestSize.Level1)
543 {
544 ASSERT_NE(capture, nullptr);
545 char keyValueList[AUDIO_CAPTURE_BUF_TEST];
546 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams(nullptr, keyValueList));
547 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams((AudioHandle)capture, nullptr));
548 }
549
550 HWTEST_F(AudioProxyCaptureTest, CaptureSetExtraParams_002, TestSize.Level1)
551 {
552 ASSERT_NE(capture, nullptr);
553 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
554 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
555 hwCapture->proxyRemoteHandle = nullptr;
556 char keyValueList[AUDIO_CAPTURE_BUF_TEST];
557 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureSetExtraParams((AudioHandle)capture, keyValueList));
558 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
559 }
560
561 HWTEST_F(AudioProxyCaptureTest, CaptureGetExtraParams_001, TestSize.Level1)
562 {
563 ASSERT_NE(capture, nullptr);
564 char keyValueList[AUDIO_CAPTURE_BUF_TEST];
565 int32_t listLenth = AUDIO_CAPTURE_BUF_TEST;
566 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams(nullptr, keyValueList, listLenth));
567 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, nullptr, listLenth));
568 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, keyValueList, 0));
569 }
570
571 HWTEST_F(AudioProxyCaptureTest, CaptureGetExtraParams_002, TestSize.Level1)
572 {
573 ASSERT_NE(capture, nullptr);
574 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
575 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
576 hwCapture->proxyRemoteHandle = nullptr;
577 char keyValueList[AUDIO_CAPTURE_BUF_TEST];
578 int32_t listLenth = AUDIO_CAPTURE_BUF_TEST;
579 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetExtraParams((AudioHandle)capture, keyValueList,
580 listLenth));
581 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
582 }
583
584 HWTEST_F(AudioProxyCaptureTest, CaptureReqMmapBuffer_001, TestSize.Level1)
585 {
586 ASSERT_NE(capture, nullptr);
587 int32_t reqSize = 0;
588 struct AudioMmapBufferDescripter desc;
589 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer(nullptr, reqSize, &desc));
590 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer((AudioHandle)capture, reqSize, nullptr));
591 }
592
593 HWTEST_F(AudioProxyCaptureTest, CaptureReqMmapBuffer_002, TestSize.Level1)
594 {
595 ASSERT_NE(capture, nullptr);
596 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
597 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
598 hwCapture->proxyRemoteHandle = nullptr;
599 int32_t reqSize = 0;
600 struct AudioMmapBufferDescripter desc;
601 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureReqMmapBuffer((AudioHandle)capture, reqSize, &desc));
602 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
603 }
604
605 HWTEST_F(AudioProxyCaptureTest, CaptureGetMmapPosition_001, TestSize.Level1)
606 {
607 ASSERT_NE(capture, nullptr);
608 uint64_t frames;
609 struct AudioTimeStamp time;
610 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition(nullptr, &frames, &time));
611 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, nullptr, &time));
612 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, &frames, nullptr));
613 }
614
615 HWTEST_F(AudioProxyCaptureTest, CaptureGetMmapPosition_002, TestSize.Level1)
616 {
617 ASSERT_NE(capture, nullptr);
618 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
619 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
620 hwCapture->proxyRemoteHandle = nullptr;
621 uint64_t frames;
622 struct AudioTimeStamp time;
623 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureGetMmapPosition((AudioHandle)capture, &frames, &time));
624 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
625 }
626
627 HWTEST_F(AudioProxyCaptureTest, CaptureTurnStandbyMode_001, TestSize.Level1)
628 {
629 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureTurnStandbyMode(nullptr));
630 }
631
632 HWTEST_F(AudioProxyCaptureTest, CaptureTurnStandbyMode_002, TestSize.Level1)
633 {
634 ASSERT_NE(capture, nullptr);
635 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
636 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
637 hwCapture->proxyRemoteHandle = nullptr;
638 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureTurnStandbyMode((AudioHandle)capture));
639 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
640 }
641
642 HWTEST_F(AudioProxyCaptureTest, CaptureAudioDevDump_001, TestSize.Level1)
643 {
644 int32_t range = 0;
645 int32_t fd = 0;
646 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureAudioDevDump(nullptr, range, fd));
647 }
648
649 HWTEST_F(AudioProxyCaptureTest, CaptureAudioDevDump_002, TestSize.Level1)
650 {
651 ASSERT_NE(capture, nullptr);
652 struct AudioHwCapture *hwCapture = (struct AudioHwCapture *)capture;
653 struct HdfRemoteService *proxyRemoteHandle = hwCapture->proxyRemoteHandle;
654 hwCapture->proxyRemoteHandle = nullptr;
655 int32_t range = 0;
656 int32_t fd = 0;
657 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyCaptureAudioDevDump((AudioHandle)capture, range, fd));
658 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
659 }
660 }
661