1 /*
2 * Copyright (c) 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 <climits>
17 #include <cstring>
18 #include <gtest/gtest.h>
19 #include "hdf_dlist.h"
20 #include "osal_mem.h"
21 #include "v5_0/audio_types.h"
22 #include "v5_0/iaudio_adapter.h"
23 #include "v5_0/iaudio_manager.h"
24
25 using namespace std;
26 using namespace testing::ext;
27
28 #define AUDIO_CHANNELCOUNT 2
29 #define AUDIO_SAMPLE_RATE_48K 48000
30 #define DEEP_BUFFER_RENDER_PERIOD_SIZE 4096
31 #define INT_32_MAX 0x7fffffff
32 #define PCM_16_BIT 16
33 #define PCM_8_BIT 8
34 #define AUDIO_STREAM_NUM_MAX 10
35 namespace {
36 static const uint32_t g_audioAdapterNumMax = 5;
37 const int32_t AUDIO_ADAPTER_BUF_TEST = 1024;
38
39 class HdfAudioUtAdapterTest : public testing::Test {
40 public:
41 struct IAudioManager *manager_ = nullptr;
42 struct IAudioAdapter *adapter_ = nullptr;
43 struct AudioAdapterDescriptor *adapterDescs_ = nullptr;
44 uint32_t renderId_ = 0;
45 uint32_t captureId_ = 0;
46 virtual void SetUp();
47 virtual void TearDown();
48 void InitAttrs(struct AudioSampleAttributes &attrs);
49 void InitDevDesc(struct AudioDeviceDescriptor &devDesc);
50 void AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf);
51 void ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen);
52 };
53
AudioAdapterDescriptorFree(struct AudioAdapterDescriptor * dataBlock,bool freeSelf)54 void HdfAudioUtAdapterTest::AudioAdapterDescriptorFree(struct AudioAdapterDescriptor *dataBlock, bool freeSelf)
55 {
56 if (dataBlock == nullptr) {
57 return;
58 }
59
60 if (dataBlock->adapterName != nullptr) {
61 OsalMemFree(dataBlock->adapterName);
62 dataBlock->adapterName = nullptr;
63 }
64
65 if (dataBlock->ports != nullptr) {
66 OsalMemFree(dataBlock->ports);
67 }
68
69 if (freeSelf) {
70 OsalMemFree(dataBlock);
71 }
72 }
73
ReleaseAdapterDescs(struct AudioAdapterDescriptor ** descs,uint32_t descsLen)74 void HdfAudioUtAdapterTest::ReleaseAdapterDescs(struct AudioAdapterDescriptor **descs, uint32_t descsLen)
75 {
76 if ((descsLen > 0) && (descs != nullptr) && ((*descs) != nullptr)) {
77 for (uint32_t i = 0; i < descsLen; i++) {
78 AudioAdapterDescriptorFree(&(*descs)[i], false);
79 }
80 OsalMemFree(*descs);
81 *descs = nullptr;
82 }
83 }
84
InitAttrs(struct AudioSampleAttributes & attrs)85 void HdfAudioUtAdapterTest::InitAttrs(struct AudioSampleAttributes &attrs)
86 {
87 attrs.format = AUDIO_FORMAT_TYPE_PCM_16_BIT;
88 attrs.channelCount = AUDIO_CHANNELCOUNT;
89 attrs.sampleRate = AUDIO_SAMPLE_RATE_48K;
90 attrs.interleaved = 1;
91 attrs.type = AUDIO_IN_MEDIA;
92 attrs.period = DEEP_BUFFER_RENDER_PERIOD_SIZE;
93 attrs.frameSize = PCM_16_BIT * attrs.channelCount / PCM_8_BIT;
94 attrs.isBigEndian = false;
95 attrs.isSignedData = true;
96 attrs.startThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE / (attrs.frameSize);
97 attrs.stopThreshold = INT_32_MAX;
98 }
99
InitDevDesc(struct AudioDeviceDescriptor & devDesc)100 void HdfAudioUtAdapterTest::InitDevDesc(struct AudioDeviceDescriptor &devDesc)
101 {
102 ASSERT_NE(adapterDescs_, nullptr);
103 ASSERT_NE(adapterDescs_->ports, nullptr);
104 for (uint32_t index = 0; index < adapterDescs_->portsLen; index++) {
105 if (adapterDescs_->ports[index].dir == PORT_OUT) {
106 devDesc.portId = adapterDescs_->ports[index].portId;
107 return;
108 }
109 }
110 }
111
SetUp()112 void HdfAudioUtAdapterTest::SetUp()
113 {
114 uint32_t size = g_audioAdapterNumMax;
115 manager_ = IAudioManagerGet(false);
116 ASSERT_NE(manager_, nullptr);
117
118 adapterDescs_ = (struct AudioAdapterDescriptor *)OsalMemCalloc(
119 sizeof(struct AudioAdapterDescriptor) * (g_audioAdapterNumMax));
120 ASSERT_NE(adapterDescs_, nullptr);
121
122 ASSERT_EQ(HDF_SUCCESS, manager_->GetAllAdapters(manager_, adapterDescs_, &size));
123 if (size > g_audioAdapterNumMax) {
124 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
125 ASSERT_LT(size, g_audioAdapterNumMax);
126 }
127
128 if (manager_->LoadAdapter(manager_, &adapterDescs_[0], &adapter_) != HDF_SUCCESS) {
129 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
130 ASSERT_TRUE(false);
131 }
132 if (adapter_ == nullptr) {
133 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
134 ASSERT_TRUE(false);
135 }
136 }
137
TearDown()138 void HdfAudioUtAdapterTest::TearDown()
139 {
140 ASSERT_NE(manager_, nullptr);
141 ASSERT_NE(adapter_, nullptr);
142
143 manager_->UnloadAdapter(manager_, adapterDescs_[0].adapterName);
144 ReleaseAdapterDescs(&adapterDescs_, g_audioAdapterNumMax);
145 adapter_ = nullptr;
146 IAudioManagerRelease(manager_, false);
147 manager_ = nullptr;
148 }
149
150 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterInitAllPortsNull001, TestSize.Level1)
151 {
152 EXPECT_NE(HDF_SUCCESS, adapter_->InitAllPorts(nullptr));
153 }
154
155 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterInitAllPortsParaIsvalid001, TestSize.Level1)
156 {
157 EXPECT_EQ(HDF_SUCCESS, adapter_->InitAllPorts(adapter_));
158 }
159
160 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderNull001, TestSize.Level1)
161 {
162 EXPECT_NE(HDF_SUCCESS, adapter_->CreateRender(nullptr, nullptr, nullptr, nullptr, &renderId_));
163 }
164
165 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderNull002, TestSize.Level1)
166 {
167 struct IAudioRender *render = nullptr;
168 struct AudioDeviceDescriptor devicedesc = {};
169 struct AudioSampleAttributes attrs = {};
170 EXPECT_NE(HDF_SUCCESS, adapter_->CreateRender(nullptr, &devicedesc, &attrs, &render, &renderId_));
171 }
172
173 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderInvalid001, TestSize.Level1)
174 {
175 struct IAudioRender *render = nullptr;
176 struct AudioSampleAttributes attrs = {};
177 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, nullptr, &attrs, &render, &renderId_));
178 }
179
180 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderInvalid002, TestSize.Level1)
181 {
182 struct IAudioRender *render = nullptr;
183 struct AudioDeviceDescriptor devicedesc = {};
184 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateRender(adapter_, &devicedesc, nullptr, &render, &renderId_));
185 }
186
187 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateRenderIsvalid001, TestSize.Level0)
188 {
189 struct IAudioRender *render = nullptr;
190 struct AudioDeviceDescriptor devicedesc = {};
191 struct AudioSampleAttributes attrs = {};
192 InitDevDesc(devicedesc);
193 devicedesc.desc = const_cast<char*>("primary");
194 devicedesc.pins = PIN_OUT_SPEAKER;
195 InitAttrs(attrs);
196 attrs.silenceThreshold = 0;
197 attrs.streamId = 0;
198 int32_t ret = adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_);
199 if (ret != HDF_SUCCESS) {
200 attrs.format = AUDIO_FORMAT_TYPE_PCM_32_BIT;
201 ASSERT_EQ(HDF_SUCCESS, adapter_->CreateRender(adapter_, &devicedesc, &attrs, &render, &renderId_));
202 }
203 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyRender(adapter_, renderId_));
204 }
205
206 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyRenderNull001, TestSize.Level1)
207 {
208 EXPECT_NE(HDF_SUCCESS, adapter_->DestroyRender(nullptr, renderId_));
209 }
210
211 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyRenderNull002, TestSize.Level1)
212 {
213 uint32_t renderId = AUDIO_STREAM_NUM_MAX - 1;
214 int32_t ret = adapter_->DestroyRender(adapter_, renderId);
215 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_INVALID_PARAM);
216 }
217
218 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyRenderInvalid001, TestSize.Level1)
219 {
220 uint32_t renderId = AUDIO_STREAM_NUM_MAX;
221 int32_t ret = adapter_->DestroyRender(adapter_, renderId);
222 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_INVALID_PARAM);
223 }
224
225 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureNull001, TestSize.Level1)
226 {
227 EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(nullptr, nullptr, nullptr, nullptr, &captureId_));
228 }
229
230 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureNull002, TestSize.Level1)
231 {
232 struct IAudioCapture *capture = nullptr;
233 struct AudioDeviceDescriptor devicedesc = {};
234 struct AudioSampleAttributes attrs = {};
235 EXPECT_NE(HDF_SUCCESS, adapter_->CreateCapture(nullptr, &devicedesc, &attrs, &capture, &captureId_));
236 }
237
238 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureInvalid001, TestSize.Level1)
239 {
240 struct IAudioCapture *capture = nullptr;
241 struct AudioSampleAttributes attrs = {};
242 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateCapture(adapter_, nullptr, &attrs, &capture, &captureId_));
243 }
244
245 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureInvalid002, TestSize.Level1)
246 {
247 struct IAudioCapture *capture = nullptr;
248 struct AudioDeviceDescriptor devicedesc = {};
249 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->CreateCapture(adapter_, &devicedesc, nullptr, &capture, &captureId_));
250 }
251
252 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid001, TestSize.Level0)
253 {
254 struct IAudioCapture *capture = nullptr;
255 struct AudioDeviceDescriptor devicedesc = {};
256 struct AudioSampleAttributes attrs = {};
257 InitDevDesc(devicedesc);
258 devicedesc.desc = const_cast<char*>("primary");
259 devicedesc.pins = PIN_IN_MIC;
260 InitAttrs(attrs);
261 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
262 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
263 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
264 }
265
266 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid002, TestSize.Level0)
267 {
268 struct IAudioCapture *capture = nullptr;
269 struct AudioDeviceDescriptor devicedesc = {};
270 struct AudioSampleAttributes attrs = {};
271 InitDevDesc(devicedesc);
272 devicedesc.desc = const_cast<char*>("primary");
273 devicedesc.pins = PIN_IN_MIC;
274 InitAttrs(attrs);
275 attrs.sourceType = AUDIO_INPUT_VOICE_UPLINK_TYPE;
276 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
277 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
278 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
279 }
280
281 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid003, TestSize.Level0)
282 {
283 struct IAudioCapture *capture = nullptr;
284 struct AudioDeviceDescriptor devicedesc = {};
285 struct AudioSampleAttributes attrs = {};
286 InitDevDesc(devicedesc);
287 devicedesc.desc = const_cast<char*>("primary");
288 devicedesc.pins = PIN_IN_MIC;
289 InitAttrs(attrs);
290 attrs.sourceType = AUDIO_INPUT_VOICE_DOWNLINK_TYPE;
291 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
292 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
293 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
294 }
295
296 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid004, TestSize.Level0)
297 {
298 struct IAudioCapture *capture = nullptr;
299 struct AudioDeviceDescriptor devicedesc = {};
300 struct AudioSampleAttributes attrs = {};
301 InitDevDesc(devicedesc);
302 devicedesc.desc = const_cast<char*>("primary");
303 devicedesc.pins = PIN_IN_MIC;
304 InitAttrs(attrs);
305 attrs.sourceType = AUDIO_INPUT_VOICE_CALL_TYPE;
306 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
307 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
308 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
309 }
310
311 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid005, TestSize.Level0)
312 {
313 struct IAudioCapture *capture = nullptr;
314 struct AudioDeviceDescriptor devicedesc = {};
315 struct AudioSampleAttributes attrs = {};
316 InitDevDesc(devicedesc);
317 devicedesc.desc = const_cast<char*>("primary");
318 devicedesc.pins = PIN_IN_MIC;
319 InitAttrs(attrs);
320 attrs.sourceType = AUDIO_INPUT_CAMCORDER_TYPE;
321 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
322 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
323 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
324 }
325
326 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid006, TestSize.Level0)
327 {
328 struct IAudioCapture *capture = nullptr;
329 struct AudioDeviceDescriptor devicedesc = {};
330 struct AudioSampleAttributes attrs = {};
331 InitDevDesc(devicedesc);
332 devicedesc.desc = const_cast<char*>("primary");
333 devicedesc.pins = PIN_IN_MIC;
334 InitAttrs(attrs);
335 attrs.sourceType = AUDIO_INPUT_EC_TYPE;
336 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
337 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
338 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
339 }
340
341 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterCreateCaptureIsvalid007, TestSize.Level0)
342 {
343 struct IAudioCapture *capture = nullptr;
344 struct AudioDeviceDescriptor devicedesc = {};
345 struct AudioSampleAttributes attrs = {};
346 InitDevDesc(devicedesc);
347 devicedesc.desc = const_cast<char*>("primary");
348 devicedesc.pins = PIN_IN_MIC;
349 InitAttrs(attrs);
350 attrs.sourceType = AUDIO_INPUT_NOISE_REDUCTION_TYPE;
351 attrs.silenceThreshold = DEEP_BUFFER_RENDER_PERIOD_SIZE;
352 EXPECT_EQ(HDF_SUCCESS, adapter_->CreateCapture(adapter_, &devicedesc, &attrs, &capture, &captureId_));
353 EXPECT_EQ(HDF_SUCCESS, adapter_->DestroyCapture(adapter_, captureId_));
354 }
355
356 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyCaptureNull001, TestSize.Level1)
357 {
358 EXPECT_NE(HDF_SUCCESS, adapter_->DestroyCapture(nullptr, captureId_));
359 }
360
361 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterDestroyCaptureInvalid001, TestSize.Level1)
362 {
363 uint32_t captureId = AUDIO_STREAM_NUM_MAX;
364 int32_t ret = adapter_->DestroyCapture(adapter_, captureId);
365 ASSERT_TRUE(ret == HDF_FAILURE || ret == HDF_ERR_INVALID_PARAM);
366 }
367
368 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityNull001, TestSize.Level1)
369 {
370 EXPECT_NE(HDF_SUCCESS, adapter_->GetPortCapability(nullptr, nullptr, nullptr));
371 }
372
373 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityNull002, TestSize.Level1)
374 {
375 struct AudioPort port = {};
376 struct AudioPortCapability capability = {};
377 EXPECT_NE(HDF_SUCCESS, adapter_->GetPortCapability(nullptr, &port, &capability));
378 }
379
380 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityInvalid001, TestSize.Level1)
381 {
382 struct AudioPortCapability capability = {};
383 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->GetPortCapability(adapter_, nullptr, &capability));
384 }
385
386 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityInvalid002, TestSize.Level1)
387 {
388 struct AudioPort port = {};
389 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->GetPortCapability(adapter_, &port, nullptr));
390 }
391
392 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityInvalid003, TestSize.Level0)
393 {
394 struct AudioPort port = {};
395 struct AudioPortCapability capability = {};
396 port.dir = PORT_OUT;
397 port.portId = 0;
398 port.portName = const_cast<char*>("primary");
399 int32_t ret = adapter_->GetPortCapability(adapter_, &port, &capability);
400 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
401 }
402
403 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPortCapabilityIsvalid001, TestSize.Level1)
404 {
405 struct AudioPort port = adapterDescs_[0].ports[0];
406 struct AudioPortCapability capability = {};
407 int32_t ret = adapter_->GetPortCapability(adapter_, &port, &capability);
408 ASSERT_TRUE(ret == HDF_SUCCESS);
409 }
410
411 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetPassthroughModeNull001, TestSize.Level1)
412 {
413 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
414 EXPECT_NE(HDF_SUCCESS, adapter_->SetPassthroughMode(nullptr, nullptr, mode));
415 }
416
417 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetPassthroughModeNull002, TestSize.Level1)
418 {
419 struct AudioPort port = {};
420 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
421 EXPECT_NE(HDF_SUCCESS, adapter_->SetPassthroughMode(nullptr, &port, mode));
422 }
423
424 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetPassthroughModeInvalid001, TestSize.Level1)
425 {
426 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
427 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->SetPassthroughMode(adapter_, nullptr, mode));
428 }
429
430 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetPassthroughModeIsvalid001, TestSize.Level0)
431 {
432 struct AudioPort port = {};
433 port.dir = PORT_OUT;
434 port.portId = 0;
435 port.portName = const_cast<char*>("primary");
436 enum AudioPortPassthroughMode mode = PORT_PASSTHROUGH_LPCM;
437 int32_t ret = adapter_->SetPassthroughMode(adapter_, &port, mode);
438 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
439 }
440
441 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPassthroughModeNull001, TestSize.Level1)
442 {
443 EXPECT_NE(HDF_SUCCESS, adapter_->GetPassthroughMode(nullptr, nullptr, nullptr));
444 }
445
446 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPassthroughModeNull002, TestSize.Level1)
447 {
448 struct AudioPort port = {};
449 enum AudioPortPassthroughMode mode;
450 EXPECT_NE(HDF_SUCCESS, adapter_->GetPassthroughMode(nullptr, &port, &mode));
451 }
452
453 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPassthroughModeInvalid001, TestSize.Level1)
454 {
455 enum AudioPortPassthroughMode mode;
456 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->GetPassthroughMode(adapter_, nullptr, &mode));
457 }
458
459 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetPassthroughModeIsvalid001, TestSize.Level0)
460 {
461 struct AudioPort port = {};
462 port.dir = PORT_OUT;
463 port.portId = 0;
464 port.portName = const_cast<char*>("primary");
465 enum AudioPortPassthroughMode mode;
466 int32_t ret = adapter_->GetPassthroughMode(adapter_, &port, &mode);
467 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_FAILURE);
468 }
469
470 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetDeviceStatusNull001, TestSize.Level1)
471 {
472 EXPECT_NE(HDF_SUCCESS, adapter_->GetDeviceStatus(nullptr, nullptr));
473 }
474
475 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetDeviceStatusNull002, TestSize.Level1)
476 {
477 struct AudioDeviceStatus status = {};
478 EXPECT_NE(HDF_SUCCESS, adapter_->GetDeviceStatus(nullptr, &status));
479 }
480
481 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetDeviceStatusInvalid001, TestSize.Level0)
482 {
483 EXPECT_EQ(HDF_ERR_INVALID_PARAM, adapter_->GetDeviceStatus(adapter_, nullptr));
484 }
485
486 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetDeviceStatusIsvalid001, TestSize.Level0)
487 {
488 struct AudioDeviceStatus status = {};
489 EXPECT_EQ(HDF_SUCCESS, adapter_->GetDeviceStatus(adapter_, &status));
490 }
491
492 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetMicMuteNull001, TestSize.Level1)
493 {
494 bool mute = false;
495 EXPECT_NE(HDF_SUCCESS, adapter_->SetMicMute(nullptr, mute));
496 }
497
498 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetMicMuteIsvalid001, TestSize.Level0)
499 {
500 bool mute = false;
501 int32_t ret = adapter_->SetMicMute(adapter_, mute);
502 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
503 }
504
505 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetMicMuteNull001, TestSize.Level1)
506 {
507 EXPECT_NE(HDF_SUCCESS, adapter_->GetMicMute(nullptr, nullptr));
508 }
509
510 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetMicMuteNull002, TestSize.Level1)
511 {
512 bool mute = false;
513 EXPECT_NE(HDF_SUCCESS, adapter_->GetMicMute(nullptr, &mute));
514 }
515
516 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetMicMuteIsvalid001, TestSize.Level0)
517 {
518 bool mute = false;
519 int32_t ret = adapter_->GetMicMute(adapter_, &mute);
520 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
521 }
522
523 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetVoiceVolumeNull001, TestSize.Level1)
524 {
525 float volume = 0;
526 EXPECT_NE(HDF_SUCCESS, adapter_->SetVoiceVolume(nullptr, volume));
527 }
528
529 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetVoiceVolumeIsvalid001, TestSize.Level0)
530 {
531 float volume = 0;
532 int32_t ret = adapter_->SetVoiceVolume(adapter_, volume);
533 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
534 }
535
536 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetExtraParamsNull001, TestSize.Level1)
537 {
538 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
539 EXPECT_NE(HDF_SUCCESS, adapter_->SetExtraParams(nullptr, key, nullptr, nullptr));
540 }
541
542 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetExtraParamsNull002, TestSize.Level1)
543 {
544 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
545 char condition[AUDIO_ADAPTER_BUF_TEST];
546 char value[AUDIO_ADAPTER_BUF_TEST];
547 EXPECT_NE(HDF_SUCCESS, adapter_->SetExtraParams(nullptr, key, condition, value));
548 }
549
550 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterSetExtraParamsIsvalid001, TestSize.Level0)
551 {
552 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_LOWPOWER;
553 char condition[AUDIO_ADAPTER_BUF_TEST];
554 const char *value = "sup_sampling_rates=4800;sup_channels=1;sup_formats=2;";
555 int32_t ret = adapter_->SetExtraParams(adapter_, key, condition, value);
556 ASSERT_TRUE(ret == HDF_SUCCESS || ret == HDF_ERR_NOT_SUPPORT);
557 }
558
559 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetExtraParamsNull001, TestSize.Level1)
560 {
561 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
562 uint32_t valueLen = AUDIO_ADAPTER_BUF_TEST;
563 EXPECT_NE(HDF_SUCCESS, adapter_->GetExtraParams(nullptr, key, nullptr, nullptr, valueLen));
564 }
565
566 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetExtraParamsNull002, TestSize.Level1)
567 {
568 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
569 char condition[AUDIO_ADAPTER_BUF_TEST];
570 char value[AUDIO_ADAPTER_BUF_TEST];
571 uint32_t valueLen = AUDIO_ADAPTER_BUF_TEST;
572 EXPECT_NE(HDF_SUCCESS, adapter_->GetExtraParams(nullptr, key, condition, value, valueLen));
573 }
574
575 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetExtraParamsIsvalid001, TestSize.Level1)
576 {
577 enum AudioExtParamKey key = AUDIO_EXT_PARAM_KEY_NONE;
578 char condition[AUDIO_ADAPTER_BUF_TEST];
579 char value[AUDIO_ADAPTER_BUF_TEST] = "sup_sampling_rates=4800;sup_channels=1;sup_formats=2;";
580 uint32_t valueLen = AUDIO_ADAPTER_BUF_TEST;
581
582 int32_t ret = adapter_->GetExtraParams(adapter_, key, condition, value, valueLen);
583 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_FAILURE);
584 }
585
586 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterUpdateAudioRouteNull001, TestSize.Level1)
587 {
588 struct AudioRoute route = {};
589 int32_t routeHandle = 0;
590 EXPECT_NE(HDF_SUCCESS, adapter_->UpdateAudioRoute(nullptr, &route, &routeHandle));
591 }
592
593 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterUpdateAudioRouteIsvalid001, TestSize.Level1)
594 {
595 struct AudioRoute route = {};
596 int32_t routeHandle = 0;
597 int32_t ret = adapter_->UpdateAudioRoute(adapter_, &route, &routeHandle);
598 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_FAILURE);
599 }
600
601 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterReleaseAudioRouteNull001, TestSize.Level1)
602 {
603 int32_t routeHandle = 0;
604 EXPECT_NE(HDF_SUCCESS, adapter_->ReleaseAudioRoute(nullptr, routeHandle));
605 }
606
607 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterReleaseAudioRouteIsvalid001, TestSize.Level0)
608 {
609 int32_t routeHandle = 0;
610 int32_t ret = adapter_->ReleaseAudioRoute(adapter_, routeHandle);
611 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_FAILURE);
612 }
613
614 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetVersionNull001, TestSize.Level1)
615 {
616 uint32_t majorVer = 0;
617 uint32_t minorVer = 0;
618 EXPECT_NE(HDF_SUCCESS, adapter_->GetVersion(nullptr, &majorVer, &minorVer));
619 }
620
621 HWTEST_F(HdfAudioUtAdapterTest, HdfAudioAdapterGetVersionIsvalid001, TestSize.Level0)
622 {
623 uint32_t majorVer = 0;
624 uint32_t minorVer = 0;
625 int32_t ret = adapter_->GetVersion(adapter_, &majorVer, &minorVer);
626 ASSERT_TRUE(ret == HDF_ERR_NOT_SUPPORT || ret == HDF_SUCCESS);
627 }
628 }
629