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