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