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 <gtest/gtest.h>
17 #include "osal_mem.h"
18 #include "hdi_service_common.h"
19
20 using namespace std;
21 using namespace testing::ext;
22 using namespace OHOS::Audio;
23
24 namespace {
25 class AudioIdlHdiManagerTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 static TestAudioManager *manager;
32 };
33
34 TestAudioManager *AudioIdlHdiManagerTest::manager = nullptr;
35
SetUpTestCase(void)36 void AudioIdlHdiManagerTest::SetUpTestCase(void)
37 {
38 manager = IAudioManagerGet(IS_STUB);
39 ASSERT_NE(nullptr, manager);
40 }
41
TearDownTestCase(void)42 void AudioIdlHdiManagerTest::TearDownTestCase(void)
43 {
44 if (manager != nullptr) {
45 (void)IAudioManagerRelease(manager, IS_STUB);
46 }
47 }
48
SetUp(void)49 void AudioIdlHdiManagerTest::SetUp(void) {}
TearDown(void)50 void AudioIdlHdiManagerTest::TearDown(void) {}
51
52 /**
53 * @tc.name AudioGetAllAdapters_001
54 * @tc.desc test GetAllAdapters interface，Returns 0 if the list is obtained successfully
55 * @tc.type: FUNC
56 */
57 HWTEST_F(AudioIdlHdiManagerTest, AudioGetAllAdapters_001, TestSize.Level1)
58 {
59 int32_t ret = -1;
60 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
61 struct AudioAdapterDescriptor *descs = nullptr;
62 descs = (struct AudioAdapterDescriptor*)OsalMemCalloc(
63 sizeof(struct AudioAdapterDescriptor) * (AUDIO_ADAPTER_MAX_NUM));
64 ASSERT_NE(nullptr, descs);
65 ASSERT_NE(nullptr, manager);
66
67 ret = manager->GetAllAdapters(manager, descs, &descsLen);
68 EXPECT_EQ(HDF_SUCCESS, ret);
69 EXPECT_EQ((uint32_t)AUDIO_ADAPTER_MAX_NUM, descsLen);
70
71 TestReleaseAdapterDescs(&descs, descsLen);
72 }
73
74 /**
75 * @tc.name AudioGetAllAdaptersNull_002
76 * @tc.desc test GetAllAdapters interface，Returns -3/-4 if the incoming parameter manager is nullptr
77 * @tc.type: FUNC
78 */
79 HWTEST_F(AudioIdlHdiManagerTest, AudioGetAllAdaptersNull_002, TestSize.Level1)
80 {
81 int32_t ret = -1;
82 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
83 struct AudioAdapterDescriptor *descs = nullptr;
84 descs = (struct AudioAdapterDescriptor*)OsalMemCalloc(
85 sizeof(struct AudioAdapterDescriptor) * (AUDIO_ADAPTER_MAX_NUM));
86 TestAudioManager *managerNull = nullptr;
87 ASSERT_NE(nullptr, descs);
88 ASSERT_NE(nullptr, manager);
89
90 ret = manager->GetAllAdapters(managerNull, descs, &descsLen);
91 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
92 OsalMemFree(descs);
93 descs = nullptr;
94 }
95 #ifdef AUDIO_ADM_PASSTHROUGH
96 /**
97 * @tc.name AudioGetAllAdapters_003
98 * @tc.desc test GetAllAdapters interface，Returns -3 if the incoming parameter descs is nullptr
99 * @tc.type: FUNC
100 */
101 HWTEST_F(AudioIdlHdiManagerTest, AudioGetAllAdaptersNull_003, TestSize.Level1)
102 {
103 int32_t ret = -1;
104 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
105 struct AudioAdapterDescriptor *descs = nullptr;
106 ASSERT_NE(nullptr, manager);
107
108 ret = manager->GetAllAdapters(manager, descs, &descsLen);
109 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
110 }
111 /**
112 * @tc.name AudioGetAllAdaptersNull_004
113 * @tc.desc test GetAllAdapters interface，Returns -3/-4 if the incoming parameter descsLen is nullptr
114 * @tc.type: FUNC
115 */
116
117 HWTEST_F(AudioIdlHdiManagerTest, AudioGetAllAdaptersNull_004, TestSize.Level1)
118 {
119 int32_t ret = -1;
120 uint32_t* descsLen = nullptr;
121 struct AudioAdapterDescriptor *descs = nullptr;
122 descs = (struct AudioAdapterDescriptor*)OsalMemCalloc(
123 sizeof(struct AudioAdapterDescriptor) * (AUDIO_ADAPTER_MAX_NUM));
124 ASSERT_NE(nullptr, descs);
125 ASSERT_NE(nullptr, manager);
126
127 ret = manager->GetAllAdapters(manager, descs, descsLen);
128 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
129 OsalMemFree(descs);
130 descs = nullptr;
131 }
132 #endif
133 /**
134 * @tc.name AudioGetAllAdapters_005
135 * @tc.desc test GetAllAdapters interface，Returns -7001 if the incoming parameter descsLen is too small
136 * @tc.type: FUNC
137 */
138 HWTEST_F(AudioIdlHdiManagerTest, AudioGetAllAdapters_005, TestSize.Level1)
139 {
140 int32_t ret = -1;
141 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
142 struct AudioAdapterDescriptor *descs = nullptr;
143 descs = (struct AudioAdapterDescriptor*)OsalMemCalloc(
144 sizeof(struct AudioAdapterDescriptor) * (AUDIO_ADAPTER_MAX_NUM));
145 ASSERT_NE(nullptr, descs);
146 ASSERT_NE(nullptr, manager);
147
148 descsLen = 2; // invalid descsLen
149 ret = manager->GetAllAdapters(manager, descs, &descsLen);
150 EXPECT_EQ(AUDIO_HAL_ERR_NOTREADY, ret);
151 OsalMemFree(descs);
152 descs = nullptr;
153 }
154
155 /**
156 * @tc.name AudioLoadAdapter_001
157 * @tc.desc test LoadAdapter interface，Returns 0 if the driver is loaded successfully
158 * @tc.type: FUNC
159 */
160 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapter_001, TestSize.Level1)
161 {
162 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
163 struct AudioAdapterDescriptor *descs = nullptr;
164 struct IAudioAdapter *adapter = nullptr;
165 ASSERT_NE(nullptr, manager);
166
167 int32_t ret = GetAdapters(manager, descs, descsLen);
168 ASSERT_EQ(HDF_SUCCESS, ret);
169 struct AudioAdapterDescriptor *desc = &descs[0];
170 ASSERT_TRUE(desc != nullptr);
171 ret = manager->LoadAdapter(manager, desc, &adapter);
172 ASSERT_EQ(HDF_SUCCESS, ret);
173 ret = -1;
174 if (adapter != nullptr) {
175 if (adapter->InitAllPorts != nullptr && adapter->CreateRender != nullptr &&
176 adapter->DestroyRender != nullptr && adapter->CreateCapture != nullptr &&
177 adapter->DestroyCapture != nullptr && adapter->GetPortCapability != nullptr &&
178 adapter->SetPassthroughMode != nullptr && adapter->GetPassthroughMode != nullptr) {
179 ret = 0;
180 }
181 }
182 EXPECT_EQ(HDF_SUCCESS, ret);
183 ret = manager->UnloadAdapter(manager, desc->adapterName);
184 EXPECT_EQ(HDF_SUCCESS, ret);
185 TestReleaseAdapterDescs(&descs, descsLen);
186 IAudioAdapterRelease(adapter, IS_STUB);
187 }
188
189 /**
190 * @tc.name AudioLoadAdapterNull_002
191 * @tc.desc test LoadAdapter interface，Returns -3/-4 if the incoming parameter manager is nullptr
192 * @tc.type: FUNC
193 */
194 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapterNull_002, TestSize.Level1)
195 {
196 int32_t ret = -1;
197 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
198 struct AudioAdapterDescriptor *descs = nullptr;
199 TestAudioManager *managerNull = nullptr;
200 struct IAudioAdapter *adapter = nullptr;
201 ASSERT_NE(nullptr, manager);
202
203 ret = GetAdapters(manager, descs, descsLen);
204 ASSERT_EQ(HDF_SUCCESS, ret);
205 struct AudioAdapterDescriptor *desc = &descs[0];
206 ASSERT_TRUE(desc != nullptr);
207 ret = manager->LoadAdapter(managerNull, desc, &adapter);
208 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
209 TestReleaseAdapterDescs(&descs, descsLen);
210 }
211 #ifdef AUDIO_ADM_PASSTHROUGH
212 /**
213 * @tc.name AudioLoadAdapterNull_003
214 * @tc.desc test LoadAdapter interface，Returns -3 if the incoming parameter desc is nullptr
215 * @tc.type: FUNC
216 */
217 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapterNull_003, TestSize.Level1)
218 {
219 int32_t ret = -1;
220 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
221 struct AudioAdapterDescriptor *desc = nullptr;
222 struct AudioAdapterDescriptor *descs = nullptr;
223 struct IAudioAdapter *adapter = nullptr;
224 ASSERT_NE(nullptr, manager);
225
226 ret = GetAdapters(manager, descs, descsLen);
227 ASSERT_EQ(HDF_SUCCESS, ret);
228
229 ret = manager->LoadAdapter(manager, desc, &adapter);
230 ASSERT_EQ(HDF_ERR_INVALID_PARAM, ret);
231 TestReleaseAdapterDescs(&descs, descsLen);
232 }
233 /**
234 * @tc.name AudioLoadAdapterNull_004
235 * @tc.desc test LoadAdapter interface，Returns -3/-4 if the incoming parameter adapter is nullptr
236 * @tc.type: FUNC
237 */
238 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapterNull_004, TestSize.Level1)
239 {
240 int32_t ret = -1;
241 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
242 struct AudioAdapterDescriptor *descs = nullptr;
243 struct IAudioAdapter **adapter = nullptr;
244 ASSERT_NE(nullptr, manager);
245
246 ret = GetAdapters(manager, descs, descsLen);
247 ASSERT_EQ(HDF_SUCCESS, ret);
248 struct AudioAdapterDescriptor *desc = &descs[0];
249 ASSERT_TRUE(desc != nullptr);
250
251 ret = manager->LoadAdapter(manager, desc, adapter);
252 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
253 TestReleaseAdapterDescs(&descs, descsLen);
254 }
255 #endif
256 /**
257 * @tc.name AudioLoadAdapter_005
258 * @tc.desc test LoadAdapter interface，Returns -3 if the adapterName of incoming parameter desc is not support
259 * @tc.type: FUNC
260 */
261
262 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapter_005, TestSize.Level1)
263 {
264 uint32_t descsLen = AUDIO_ADAPTER_MAX_NUM;
265 struct AudioAdapterDescriptor *descs = nullptr;
266 struct IAudioAdapter *adapter = nullptr;
267 ASSERT_NE(nullptr, manager);
268
269 int32_t ret = GetAdapters(manager, descs, descsLen);
270 ASSERT_EQ(HDF_SUCCESS, ret);
271 struct AudioAdapterDescriptor *desc = &descs[0];
272 ASSERT_TRUE(desc != nullptr);
273 desc->adapterName = strdup("illegal");
274 ret = manager->LoadAdapter(manager, desc, &adapter);
275 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
276 TestReleaseAdapterDescs(&descs, descsLen);
277 }
278
279 /**
280 * @tc.name AudioLoadAdapter_006
281 * @tc.desc test LoadAdapter interface，Returns -3 if the adapterName of incoming parameter desc is illegal
282 * @tc.type: FUNC
283 */
284 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapter_006, TestSize.Level1)
285 {
286 int32_t ret = -1;
287 struct AudioAdapterDescriptor desc = {
288 .adapterName = strdup("illegal"),
289 .ports = nullptr,
290 .portsLen = 0,
291 };
292 struct IAudioAdapter *adapter = nullptr;
293 ASSERT_NE(nullptr, manager);
294
295 ret = manager->LoadAdapter(manager, &desc, &adapter);
296 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
297 free(desc.adapterName);
298 }
299
300 /**
301 * @tc.name AudioLoadAdapter_007
302 * @tc.desc test LoadAdapter interface，Returns 0 if If two different sound cards are loaded at the same time
303 * @tc.type: FUNC
304 */
305 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapter_007, TestSize.Level1)
306 {
307 int32_t ret = -1;
308 struct AudioPort audioPort = {};
309 struct AudioPort secondAudioPort = {};
310 struct IAudioAdapter *firstAdapter = nullptr;
311 struct IAudioAdapter *secondAdapter = nullptr;
312 ASSERT_NE(nullptr, manager);
313
314 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &firstAdapter, audioPort);
315 EXPECT_EQ(HDF_SUCCESS, ret);
316 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME_OUT, &secondAdapter, secondAudioPort);
317 EXPECT_EQ(HDF_SUCCESS, ret);
318
319 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
320 EXPECT_EQ(HDF_SUCCESS, ret);
321 ret = manager->UnloadAdapter(manager, ADAPTER_NAME_OUT.c_str());
322 EXPECT_EQ(HDF_SUCCESS, ret);
323 IAudioAdapterRelease(firstAdapter, IS_STUB);
324 IAudioAdapterRelease(secondAdapter, IS_STUB);
325 if (audioPort.portName != nullptr) {
326 free(audioPort.portName);
327 }
328 if (secondAudioPort.portName != nullptr) {
329 free(secondAudioPort.portName);
330 }
331 }
332 /**
333 * @tc.name AudioLoadAdapter_008
334 * @tc.desc test LoadAdapter interface，Load two sound cards at the same time, Returns 0 If the loading is successful,
335 Return - 1 If the loading fails.
336 */
337 HWTEST_F(AudioIdlHdiManagerTest, AudioLoadAdapter_008, TestSize.Level1)
338 {
339 int32_t ret = -1;
340 struct AudioPort audioPort = {};
341 struct AudioPort secondAudioPort = {};
342 struct IAudioAdapter *firstAdapter = nullptr;
343 struct IAudioAdapter *secondAdapter = nullptr;
344 ASSERT_NE(nullptr, manager);
345
346 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &firstAdapter, audioPort);
347 EXPECT_EQ(HDF_SUCCESS, ret);
348 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &secondAdapter, secondAudioPort);
349 EXPECT_EQ(HDF_FAILURE, ret);
350
351 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
352 EXPECT_EQ(HDF_SUCCESS, ret);
353 IAudioAdapterRelease(firstAdapter, IS_STUB);
354 if (audioPort.portName != nullptr) {
355 free(audioPort.portName);
356 }
357 if (secondAudioPort.portName != nullptr) {
358 free(secondAudioPort.portName);
359 }
360 }
361 /**
362 * @tc.name AudioUnloadAdapter_001
363 * @tc.desc test UnloadAdapter interface，Returns 0 if If the sound card can be successfully uninstalled
364 * @tc.type: FUNC
365 */
366 HWTEST_F(AudioIdlHdiManagerTest, AudioUnloadAdapter_001, TestSize.Level1)
367 {
368 int32_t ret = -1;
369 struct AudioPort audioPort = {};
370 struct IAudioAdapter *adapter = nullptr;
371 ASSERT_NE(nullptr, manager);
372
373 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
374 EXPECT_EQ(HDF_SUCCESS, ret);
375 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
376 EXPECT_EQ(HDF_SUCCESS, ret);
377 IAudioAdapterRelease(adapter, IS_STUB);
378 if (audioPort.portName != nullptr) {
379 free(audioPort.portName);
380 }
381 }
382 /**
383 * @tc.name AudioUnloadAdapterNull_002
384 * @tc.desc test UnloadAdapter interface，Returns -3/-4 if the incoming parameter manager is nullptr
385 * @tc.type: FUNC
386 */
387 HWTEST_F(AudioIdlHdiManagerTest, AudioUnloadAdapterNull_002, TestSize.Level1)
388 {
389 int32_t ret = -1;
390 struct AudioPort audioPort = {};
391 struct IAudioAdapter *adapter = nullptr;
392 ASSERT_NE(nullptr, manager);
393
394 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
395 EXPECT_EQ(HDF_SUCCESS, ret);
396 TestAudioManager *managerNull = nullptr;
397 ret = manager->UnloadAdapter(managerNull, ADAPTER_NAME.c_str());
398 EXPECT_EQ(ret == HDF_ERR_INVALID_PARAM || ret == HDF_ERR_INVALID_OBJECT, true);
399 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
400 EXPECT_EQ(HDF_SUCCESS, ret);
401 IAudioAdapterRelease(adapter, IS_STUB);
402 if (audioPort.portName != nullptr) {
403 free(audioPort.portName);
404 }
405 }
406
407 /**
408 * @tc.name AudioUnloadAdapterNull_003
409 * @tc.desc test UnloadAdapter interface，Returns -3 if the incoming parameter adapterName is nullptr
410 * @tc.type: FUNC
411 */
412 HWTEST_F(AudioIdlHdiManagerTest, AudioUnloadAdapterNull_003, TestSize.Level1)
413 {
414 int32_t ret = -1;
415 struct AudioPort audioPort = {};
416 struct IAudioAdapter *adapter = nullptr;
417 ASSERT_NE(nullptr, manager);
418
419 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
420 EXPECT_EQ(HDF_SUCCESS, ret);
421 char *adapterName = nullptr;
422 ret = manager->UnloadAdapter(manager, adapterName);
423 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
424 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
425 EXPECT_EQ(HDF_SUCCESS, ret);
426 IAudioAdapterRelease(adapter, IS_STUB);
427 if (audioPort.portName != nullptr) {
428 free(audioPort.portName);
429 }
430 }
431
432 /**
433 * @tc.name AudioUnloadAdapter_004
434 * @tc.desc test UnloadAdapter interface，Returns -1 if The name of the adapterName is not supported
435 * @tc.type: FUNC
436 */
437 HWTEST_F(AudioIdlHdiManagerTest, AudioUnloadAdapter_004, TestSize.Level1)
438 {
439 int32_t ret = -1;
440 struct AudioPort audioPort = {};
441 struct IAudioAdapter *adapter = nullptr;
442 ASSERT_NE(nullptr, manager);
443
444 ret = GetLoadAdapter(manager, PORT_OUT, ADAPTER_NAME, &adapter, audioPort);
445 EXPECT_EQ(HDF_SUCCESS, ret);
446 ret = manager->UnloadAdapter(manager, ADAPTER_NAME_OUT.c_str());
447 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
448 ret = manager->UnloadAdapter(manager, ADAPTER_NAME.c_str());
449 EXPECT_EQ(HDF_SUCCESS, ret);
450 IAudioAdapterRelease(adapter, IS_STUB);
451 if (audioPort.portName != nullptr) {
452 free(audioPort.portName);
453 }
454 }
455 }