1 /*
2 * Copyright (c) 2022-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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18 #include "audio_proxy_common_fun_test.h"
19 #include "audio_proxy_internal.h"
20
21 using namespace std;
22 using namespace comfun;
23 using namespace testing::ext;
24 namespace {
25 class AudioProxyAdapterTest : public testing::Test {
26 public:
27 struct AudioManager *managerFuncs = nullptr;
28 struct AudioManager *(*getAudioManager)(void) = NULL;
29 struct AudioAdapterDescriptor *descs = nullptr;
30 struct AudioAdapterDescriptor *desc = nullptr;
31 struct AudioAdapter *adapter = nullptr;
32 struct AudioRender *render = nullptr;
33 struct AudioCapture *capture = nullptr;
34 void *clientHandle = nullptr;
35 struct AudioDeviceDescriptor devDescRender = {};
36 struct AudioSampleAttributes attrsRender = {};
37 struct AudioDeviceDescriptor devDescCapture = {};
38 struct AudioSampleAttributes attrsCapture = {};
39 virtual void SetUp();
40 virtual void TearDown();
41 };
42
SetUp()43 void AudioProxyAdapterTest::SetUp()
44 {
45 clientHandle = GetDynamicLibHandle(RESOLVED_PATH);
46 ASSERT_NE(clientHandle, nullptr);
47 getAudioManager = (struct AudioManager *(*)())(dlsym(clientHandle, FUNCTION_NAME.c_str()));
48 ASSERT_NE(getAudioManager, nullptr);
49 managerFuncs = getAudioManager();
50 ASSERT_NE(managerFuncs, nullptr);
51 int32_t size = 0;
52 ASSERT_EQ(HDF_SUCCESS, managerFuncs->GetAllAdapters(managerFuncs, &descs, &size));
53 desc = &descs[0];
54 ASSERT_EQ(HDF_SUCCESS, managerFuncs->LoadAdapter(managerFuncs, desc, &adapter));
55 ASSERT_NE(adapter, nullptr);
56 ASSERT_EQ(HDF_SUCCESS, InitDevDesc(devDescRender));
57 ASSERT_EQ(HDF_SUCCESS, InitAttrs(attrsRender));
58 ASSERT_EQ(HDF_SUCCESS, adapter->CreateRender(adapter, &devDescRender, &attrsRender, &render));
59
60 ASSERT_EQ(HDF_SUCCESS, InitDevDescCapture(devDescCapture));
61 ASSERT_EQ(HDF_SUCCESS, InitAttrsCapture(attrsCapture));
62 ASSERT_EQ(HDF_SUCCESS, adapter->CreateCapture(adapter, &devDescCapture, &attrsCapture, &capture));
63 }
64
TearDown()65 void AudioProxyAdapterTest::TearDown()
66 {
67 if (adapter != nullptr) {
68 adapter->DestroyRender(adapter, render);
69 render = nullptr;
70 adapter->DestroyCapture(adapter, capture);
71 capture = nullptr;
72 }
73 if (managerFuncs != nullptr) {
74 managerFuncs->UnloadAdapter(managerFuncs, adapter);
75 adapter = nullptr;
76 managerFuncs->ReleaseAudioManagerObject(managerFuncs);
77 managerFuncs = nullptr;
78 }
79 if (clientHandle != nullptr) {
80 dlclose(clientHandle);
81 clientHandle = nullptr;
82 }
83 }
84
85 HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_001, TestSize.Level1)
86 {
87 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterInitAllPorts(nullptr));
88 }
89
90 HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_002, TestSize.Level1)
91 {
92 ASSERT_NE(adapter, nullptr);
93 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
94 const char *tempPtr = hwAdapter->adapterDescriptor.adapterName;
95 hwAdapter->adapterDescriptor.adapterName = nullptr;
96 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterInitAllPorts(adapter));
97 hwAdapter->adapterDescriptor.adapterName = tempPtr;
98 }
99
100 HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_003, TestSize.Level1)
101 {
102 ASSERT_NE(adapter, nullptr);
103 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
104 struct AudioPort *ports = hwAdapter->adapterDescriptor.ports;
105 hwAdapter->adapterDescriptor.ports = nullptr;
106 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterInitAllPorts(adapter));
107 hwAdapter->adapterDescriptor.ports = ports;
108 ports = nullptr;
109 }
110
111 HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_004, TestSize.Level1)
112 {
113 ASSERT_NE(adapter, nullptr);
114 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
115 uint32_t portNum = hwAdapter->adapterDescriptor.portNum;
116 hwAdapter->adapterDescriptor.portNum = 0;
117 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterInitAllPorts(adapter));
118 hwAdapter->adapterDescriptor.portNum = portNum;
119 }
120
121 HWTEST_F(AudioProxyAdapterTest, AdapterInitAllPorts_005, TestSize.Level1)
122 {
123 ASSERT_NE(adapter, nullptr);
124 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterInitAllPorts(adapter));
125 }
126
127 HWTEST_F(AudioProxyAdapterTest, AdapterCreateRender_001, TestSize.Level1)
128 {
129 ASSERT_NE(adapter, nullptr);
130 struct AudioRender *render = nullptr;
131 const struct AudioDeviceDescriptor *descTemp = nullptr;
132 const struct AudioSampleAttributes *attrsTemp = nullptr;
133 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(nullptr, descTemp, attrsTemp, &render));
134 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, nullptr, attrsTemp, &render));
135 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, descTemp, nullptr, &render));
136 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, descTemp, attrsTemp, nullptr));
137 }
138
139 HWTEST_F(AudioProxyAdapterTest, AdapterCreateRender_002, TestSize.Level1)
140 {
141 ASSERT_NE(adapter, nullptr);
142 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
143 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
144 hwAdapter->proxyRemoteHandle = nullptr;
145 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateRender(adapter, &devDescRender, &attrsRender,
146 &render));
147 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
148 }
149
150 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_001, TestSize.Level1)
151 {
152 ASSERT_NE(adapter, nullptr);
153 struct AudioRender render;
154 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(nullptr, &render));
155 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(adapter, nullptr));
156 }
157
158 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_002, TestSize.Level1)
159 {
160 ASSERT_NE(adapter, nullptr);
161 struct AudioHwRender *hwRender = (struct AudioHwRender *)render;
162 struct HdfRemoteService *proxyRemoteHandle = hwRender->proxyRemoteHandle;
163 hwRender->proxyRemoteHandle = nullptr;
164 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyRender(adapter, render));
165 hwRender->proxyRemoteHandle = proxyRemoteHandle;
166 }
167
168 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyRender_003, TestSize.Level1)
169 {
170 ASSERT_NE(adapter, nullptr);
171 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterDestroyRender(adapter, render));
172 }
173
174 HWTEST_F(AudioProxyAdapterTest, AdapterCreateCapture_001, TestSize.Level1)
175 {
176 ASSERT_NE(adapter, nullptr);
177 struct AudioCapture *capture = nullptr;
178 const struct AudioDeviceDescriptor *descTemp = nullptr;
179 const struct AudioSampleAttributes *attrsTemp = nullptr;
180 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(nullptr, descTemp, attrsTemp, &capture));
181 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, nullptr, attrsTemp, &capture));
182 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, descTemp, nullptr, &capture));
183 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, descTemp, attrsTemp, nullptr));
184 }
185
186 HWTEST_F(AudioProxyAdapterTest, AdapterCreateCapture_002, TestSize.Level1)
187 {
188 ASSERT_NE(adapter, nullptr);
189 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
190 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
191 hwAdapter->proxyRemoteHandle = nullptr;
192 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterCreateCapture(adapter, &devDescCapture, &attrsCapture,
193 &capture));
194 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
195 }
196
197 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_001, TestSize.Level1)
198 {
199 struct AudioAdapter adapter;
200 struct AudioCapture capture;
201 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyCapture(nullptr, &capture));
202 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterDestroyCapture(&adapter, nullptr));
203 }
204
205 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_002, TestSize.Level1)
206 {
207 ASSERT_NE(adapter, 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, AudioProxyAdapterDestroyCapture(adapter, capture));
212 hwCapture->proxyRemoteHandle = proxyRemoteHandle;
213 }
214
215 HWTEST_F(AudioProxyAdapterTest, AdapterDestroyCapture_003, TestSize.Level1)
216 {
217 ASSERT_NE(adapter, nullptr);
218 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterDestroyCapture(adapter, capture));
219 }
220
221 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_001, TestSize.Level1)
222 {
223 ASSERT_NE(adapter, nullptr);
224 const struct AudioPort *port = nullptr;
225 struct AudioPortCapability capability;
226 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(nullptr, port, &capability));
227 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(adapter, nullptr, &capability));
228 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPortCapability(adapter, port, nullptr));
229 }
230
231 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_002, TestSize.Level1)
232 {
233 ASSERT_NE(adapter, nullptr);
234 struct AudioPort port = {
235 .dir = PORT_OUT,
236 .portId = 0,
237 .portName = "AOP",
238 };
239 struct AudioPortCapability capability;
240 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
241 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
242 hwAdapter->proxyRemoteHandle = nullptr;
243 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability));
244 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
245 }
246
247 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_003, TestSize.Level1)
248 {
249 ASSERT_NE(adapter, nullptr);
250 struct AudioPort port = {
251 .dir = PORT_OUT,
252 .portId = 0,
253 .portName = "AOP",
254 };
255 struct AudioPortCapability capability;
256 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
257 struct AudioPortAndCapability *hwAdapterPortCapabilitys = hwAdapter->portCapabilitys;
258 hwAdapter->portCapabilitys = nullptr;
259 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability));
260 hwAdapter->portCapabilitys = hwAdapterPortCapabilitys;
261 }
262
263 HWTEST_F(AudioProxyAdapterTest, AdapterGetPortCapability_004, TestSize.Level1)
264 {
265 ASSERT_NE(adapter, nullptr);
266 struct AudioPort port = {
267 .dir = PORT_OUT,
268 .portId = 0,
269 .portName = "AOP",
270 };
271 struct AudioPortCapability capability;
272 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
273 int32_t portNum = hwAdapter->adapterDescriptor.portNum;
274 hwAdapter->adapterDescriptor.portNum = 0;
275 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPortCapability(adapter, &port, &capability));
276 hwAdapter->adapterDescriptor.portNum = portNum;
277 }
278
279 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_001, TestSize.Level1)
280 {
281 ASSERT_NE(adapter, nullptr);
282 struct AudioPort port = {
283 .dir = PORT_OUT,
284 .portId = 0,
285 .portName = "AOP",
286 };
287 int32_t ret = AudioProxyAdapterSetPassthroughMode(nullptr, &port, PORT_PASSTHROUGH_LPCM);
288 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
289 ret = AudioProxyAdapterSetPassthroughMode(adapter, nullptr, PORT_PASSTHROUGH_LPCM);
290 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
291 port.portName = nullptr;
292 ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
293 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, ret);
294 }
295
296 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_002, TestSize.Level1)
297 {
298 ASSERT_NE(adapter, nullptr);
299 struct AudioPort port;
300 port.dir = PORT_IN;
301 port.portName = nullptr;
302 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
303 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterSetPassthroughMode(adapter, &port, mode));
304 }
305
306 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_003, TestSize.Level1)
307 {
308 ASSERT_NE(adapter, nullptr);
309 int32_t ret = AudioProxyAdapterInitAllPorts(adapter);
310 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
311 struct AudioPort port;
312 port.dir = PORT_OUT;
313 port.portId = 0;
314 port.portName = "AOP";
315 ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
316 EXPECT_EQ(AUDIO_HAL_SUCCESS, ret);
317 }
318
319 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_004, TestSize.Level1)
320 {
321 ASSERT_NE(adapter, nullptr);
322 struct AudioPort port;
323 port.dir = PORT_OUT;
324 port.portId = 1;
325 port.portName = "abc";
326 int32_t ret = AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM);
327 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, ret);
328 }
329
330 HWTEST_F(AudioProxyAdapterTest, AdapterSetPassthroughMode_005, TestSize.Level1)
331 {
332 ASSERT_NE(adapter, nullptr);
333 struct AudioPort port;
334 port.dir = PORT_OUT;
335 port.portId = 1;
336 port.portName = "AOP";
337 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
338 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
339 hwAdapter->proxyRemoteHandle = nullptr;
340 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterSetPassthroughMode(adapter, &port, PORT_PASSTHROUGH_LPCM));
341 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
342 }
343
344 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_001, TestSize.Level1)
345 {
346 ASSERT_NE(adapter, nullptr);
347 struct AudioPort port;
348 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(nullptr, &port, nullptr));
349 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, nullptr, nullptr));
350 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, &port, nullptr));
351 port.portName = nullptr;
352 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetPassthroughMode(adapter, &port, nullptr));
353 }
354
355 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_002, TestSize.Level1)
356 {
357 ASSERT_NE(adapter, nullptr);
358 struct AudioPort port;
359 port.dir = PORT_IN;
360 port.portId = 1;
361 port.portName = "abc";
362 AudioPortPassthroughMode mode;
363 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode));
364 }
365
366 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_003, TestSize.Level1)
367 {
368 ASSERT_NE(adapter, nullptr);
369 struct AudioPort *port = new AudioPort;
370 port->dir = PORT_OUT;
371 port->portId = 0;
372 port->portName = "AOP";
373 AudioPortPassthroughMode mode;
374 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterInitAllPorts(adapter));
375 EXPECT_EQ(AUDIO_HAL_SUCCESS, AudioProxyAdapterGetPassthroughMode(adapter, port, &mode));
376 delete port;
377 port = nullptr;
378 }
379
380 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_004, TestSize.Level1)
381 {
382 ASSERT_NE(adapter, nullptr);
383 struct AudioPort port;
384 port.dir = PORT_OUT;
385 port.portId = 1;
386 port.portName = "abc";
387 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
388 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode));
389 }
390
391 HWTEST_F(AudioProxyAdapterTest, AdapterGetPassthroughMode_005, TestSize.Level1)
392 {
393 ASSERT_NE(adapter, nullptr);
394 struct AudioPort port;
395 port.dir = PORT_OUT;
396 port.portId = 1;
397 port.portName = "AOP";
398 AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
399 struct AudioHwAdapter *hwAdapter = (struct AudioHwAdapter *)adapter;
400 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
401 hwAdapter->proxyRemoteHandle = nullptr;
402 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetPassthroughMode(adapter, &port, &mode));
403 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
404 }
405
406 HWTEST_F(AudioProxyAdapterTest, AdapterSetExtraParams_001, TestSize.Level1)
407 {
408 ASSERT_NE(adapter, nullptr);
409 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
410 const char *condition = nullptr;
411 char value[AUDIO_ADAPTER_BUF_TEST];
412 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterSetExtraParams(nullptr, key, condition, value));
413 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterSetExtraParams(adapter, key, condition, nullptr));
414 }
415
416 HWTEST_F(AudioProxyAdapterTest, AdapterSetExtraParams_002, TestSize.Level1)
417 {
418 ASSERT_NE(adapter, nullptr);
419 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
420 const char *condition = nullptr;
421 char value[AUDIO_ADAPTER_BUF_TEST];
422 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
423 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
424 hwAdapter->proxyRemoteHandle = nullptr;
425 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterSetExtraParams(adapter, key, condition, value));
426 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
427 }
428
429 HWTEST_F(AudioProxyAdapterTest, AdapterGetExtraParams_001, TestSize.Level1)
430 {
431 ASSERT_NE(adapter, nullptr);
432 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
433 char condition[AUDIO_ADAPTER_BUF_TEST];
434 char value[AUDIO_ADAPTER_BUF_TEST];
435 int32_t length = AUDIO_ADAPTER_BUF_TEST;
436 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetExtraParams(nullptr, key, condition, value, length));
437 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetExtraParams(adapter, key, condition, nullptr, length));
438 EXPECT_EQ(AUDIO_HAL_ERR_INVALID_PARAM, AudioProxyAdapterGetExtraParams(adapter, key, condition, value, 0));
439 }
440
441 HWTEST_F(AudioProxyAdapterTest, AdapterGetExtraParams_002, TestSize.Level1)
442 {
443 ASSERT_NE(adapter, nullptr);
444 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
445 char condition[AUDIO_ADAPTER_BUF_TEST];
446 char value[AUDIO_ADAPTER_BUF_TEST];
447 int32_t length = AUDIO_ADAPTER_BUF_TEST;
448 struct AudioHwAdapter *hwAdapter = reinterpret_cast<struct AudioHwAdapter *>(adapter);
449 struct HdfRemoteService *proxyRemoteHandle = hwAdapter->proxyRemoteHandle;
450 hwAdapter->proxyRemoteHandle = nullptr;
451 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterGetExtraParams(adapter, key, condition, value, length));
452 hwAdapter->proxyRemoteHandle = proxyRemoteHandle;
453 }
454
455 HWTEST_F(AudioProxyAdapterTest, AdapterSetMicMute_001, TestSize.Level1)
456 {
457 ASSERT_NE(adapter, nullptr);
458 bool mute = false;
459 EXPECT_EQ(AUDIO_HAL_ERR_INTERNAL, AudioProxyAdapterSetMicMute(adapter, mute));
460 }
461
462 HWTEST_F(AudioProxyAdapterTest, AdapterGetMicMute_001, TestSize.Level1)
463 {
464 ASSERT_NE(adapter, nullptr);
465 bool mute = false;
466 EXPECT_EQ(AUDIO_HAL_ERR_NOT_SUPPORT, AudioProxyAdapterGetMicMute(adapter, &mute));
467 }
468 }
469