1 /*
2 * Copyright (c) 2023-2025 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 "effect_common.h"
17 #include "hdf_base.h"
18 #include "hdf_log.h"
19 #include "osal_mem.h"
20 #include "v1_0/effect_types.h"
21 #include "v1_0/ieffect_control.h"
22 #include "v1_0/ieffect_model.h"
23 #include <gtest/gtest.h>
24
25 using namespace std;
26 using namespace testing::ext;
27
28 namespace {
29 constexpr bool IS_DIRECTLY_CALL = false;
30 constexpr uint32_t MAX_DESCRIPTOR_NUM = 20;
31
32 class EffectModelTestAdditional : public testing::Test {
33 public:
34 struct IEffectModel *model_ = nullptr;
35 struct ControllerId controllerId_;
36 virtual void SetUp();
37 virtual void TearDown();
38 };
39
SetUp()40 void EffectModelTestAdditional::SetUp()
41 {
42 model_ = IEffectModelGet(IS_DIRECTLY_CALL);
43 if (model_ == nullptr) {
44 GTEST_SKIP() << "model_ is nullptr" << std::endl;
45 return;
46 }
47 }
48
TearDown()49 void EffectModelTestAdditional::TearDown()
50 {
51 if (model_ != nullptr) {
52 IEffectModelRelease(model_, IS_DIRECTLY_CALL);
53 }
54 }
55
56 /**
57 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0100
58 * @tc.name testEffectIsSupplyEffectLibs001
59 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
60 */
61 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs001, TestSize.Level2)
62 {
63 int32_t ret = model_->IsSupplyEffectLibs(nullptr, nullptr);
64 EXPECT_EQ(ret, HDF_ERR_INVALID_OBJECT);
65 }
66
67 /**
68 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0200
69 * @tc.name testEffectIsSupplyEffectLibs002
70 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
71 */
72 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs002, TestSize.Level2)
73 {
74 int32_t ret;
75 for (int i = 0; i < 50; i++) {
76 ret = model_->IsSupplyEffectLibs(nullptr, nullptr);
77 EXPECT_EQ(ret, HDF_ERR_INVALID_OBJECT);
78 }
79 }
80
81 /**
82 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0300
83 * @tc.name testEffectIsSupplyEffectLibs003
84 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
85 */
86 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs003, TestSize.Level1)
87 {
88 bool isSupport = true;
89 EXPECT_EQ(HDF_SUCCESS, model_->IsSupplyEffectLibs(model_, &isSupport));
90 }
91
92 /**
93 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0400
94 * @tc.name testEffectIsSupplyEffectLibs004
95 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
96 */
97 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs004, TestSize.Level1)
98 {
99 bool isSupport = true;
100 for (int i = 0; i < 50; i++) {
101 EXPECT_EQ(HDF_SUCCESS, model_->IsSupplyEffectLibs(model_, &isSupport));
102 }
103 }
104
105 /**
106 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0500
107 * @tc.name testEffectIsSupplyEffectLibs005
108 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
109 */
110 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs005, TestSize.Level2)
111 {
112 bool isSupport = true;
113 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->IsSupplyEffectLibs(nullptr, &isSupport));
114 }
115
116 /**
117 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0600
118 * @tc.name testEffectIsSupplyEffectLibs006
119 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
120 */
121 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs006, TestSize.Level2)
122 {
123 bool isSupport = true;
124 for (int i = 0; i < 50; i++) {
125 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->IsSupplyEffectLibs(nullptr, &isSupport));
126 }
127 }
128
129 /**
130 * @tc.number SUB_Driver_Audio_IsSupplyEffectLibs_0700
131 * @tc.name testEffectIsSupplyEffectLibs007
132 * @tc.desc supply indicates the state whether the vendor/OEM supplies effect libraries.
133 */
134 HWTEST_F(EffectModelTestAdditional, testEffectIsSupplyEffectLibs007, TestSize.Level1)
135 {
136 bool isSupport = false;
137 int32_t ret = HDF_SUCCESS;
138 for (int32_t i = 0; i < 1000; i++) {
139 ret = model_->IsSupplyEffectLibs(model_, &isSupport);
140 EXPECT_EQ(ret, HDF_SUCCESS);
141 }
142 }
143
144 /**
145 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0100
146 * @tc.name testEffectGetAllEffectDescriptors001
147 * @tc.desc Get descriptors of all supported audio effects.
148 */
149 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors001, TestSize.Level2)
150 {
151 uint32_t descsLen = MAX_DESCRIPTOR_NUM;
152 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
153 }
154
155 /**
156 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0200
157 * @tc.name testEffectGetAllEffectDescriptors002
158 * @tc.desc Get descriptors of all supported audio effects.
159 */
160 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors002, TestSize.Level2)
161 {
162 uint32_t descsLen = MAX_DESCRIPTOR_NUM;
163 for (int i = 0; i < 50; i++) {
164 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
165 }
166 }
167
168 /**
169 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0300
170 * @tc.name testEffectGetAllEffectDescriptors003
171 * @tc.desc Get descriptors of all supported audio effects.
172 */
173 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors003, TestSize.Level2)
174 {
175 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
176 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
177 }
178
179 /**
180 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0400
181 * @tc.name testEffectGetAllEffectDescriptors004
182 * @tc.desc Get descriptors of all supported audio effects.
183 */
184 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors004, TestSize.Level2)
185 {
186 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
187 for (int i = 0; i < 50; i++) {
188 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
189 }
190 }
191
192 /**
193 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0500
194 * @tc.name testEffectGetAllEffectDescriptors005
195 * @tc.desc Get descriptors of all supported audio effects.
196 */
197 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors005, TestSize.Level2)
198 {
199 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, nullptr));
200 }
201
202 /**
203 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0600
204 * @tc.name testEffectGetAllEffectDescriptors006
205 * @tc.desc Get descriptors of all supported audio effects.
206 */
207 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors006, TestSize.Level2)
208 {
209 for (int i = 0; i < 50; i++) {
210 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, nullptr));
211 }
212 }
213
214 /**
215 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0700
216 * @tc.name testEffectGetAllEffectDescriptors007
217 * @tc.desc Get descriptors of all supported audio effects.
218 */
219 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors007, TestSize.Level2)
220 {
221 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetAllEffectDescriptors(model_, nullptr, nullptr));
222 }
223
224 /**
225 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0800
226 * @tc.name testEffectGetAllEffectDescriptors008
227 * @tc.desc Get descriptors of all supported audio effects.
228 */
229 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors008, TestSize.Level2)
230 {
231 for (int i = 0; i < 50; i++) {
232 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetAllEffectDescriptors(model_, nullptr, nullptr));
233 }
234 }
235
236 /**
237 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_0900
238 * @tc.name testEffectGetAllEffectDescriptors009
239 * @tc.desc Get descriptors of all supported audio effects.
240 */
241 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors009, TestSize.Level1)
242 {
243 uint32_t descsLen = 0;
244 struct EffectControllerDescriptor descs[1];
245 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetAllEffectDescriptors(model_, descs, &descsLen));
246 }
247
248 /**
249 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1000
250 * @tc.name testEffectGetAllEffectDescriptors010
251 * @tc.desc Get descriptors of all supported audio effects.
252 */
253 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors010, TestSize.Level2)
254 {
255 struct EffectControllerDescriptor descs[0];
256 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
257 }
258
259 /**
260 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1100
261 * @tc.name testEffectGetAllEffectDescriptors011
262 * @tc.desc Get descriptors of all supported audio effects.
263 */
264 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors011, TestSize.Level2)
265 {
266 struct EffectControllerDescriptor descs[0];
267 for (int i = 0; i < 50; i++) {
268 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
269 }
270 }
271
272 /**
273 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1200
274 * @tc.name testEffectGetAllEffectDescriptors012
275 * @tc.desc Get descriptors of all supported audio effects.
276 */
277 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors012, TestSize.Level2)
278 {
279 struct EffectControllerDescriptor descs[100];
280 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
281 }
282
283 /**
284 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1300
285 * @tc.name testEffectGetAllEffectDescriptors013
286 * @tc.desc Get descriptors of all supported audio effects.
287 */
288 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors013, TestSize.Level2)
289 {
290 struct EffectControllerDescriptor descs[100];
291 for (int i = 0; i < 50; i++) {
292 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, nullptr));
293 }
294 }
295
296 /**
297 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1400
298 * @tc.name testEffectGetAllEffectDescriptors014
299 * @tc.desc Get descriptors of all supported audio effects.
300 */
301 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors014, TestSize.Level2)
302 {
303 uint32_t descsLen = 0;
304 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
305 }
306
307 /**
308 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1500
309 * @tc.name testEffectGetAllEffectDescriptors015
310 * @tc.desc Get descriptors of all supported audio effects.
311 */
312 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors015, TestSize.Level2)
313 {
314 uint32_t descsLen = 0;
315 for (int i = 0; i < 50; i++) {
316 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
317 }
318 }
319
320 /**
321 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1600
322 * @tc.name testEffectGetAllEffectDescriptors016
323 * @tc.desc Get descriptors of all supported audio effects.
324 */
325 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors016, TestSize.Level2)
326 {
327 uint32_t descsLen = 4294967295;
328 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
329 }
330
331 /**
332 * @tc.number SUB_Driver_Audio_GetAllEffectDescriptors_1700
333 * @tc.name testEffectGetAllEffectDescriptors017
334 * @tc.desc Get descriptors of all supported audio effects.
335 */
336 HWTEST_F(EffectModelTestAdditional, testEffectGetAllEffectDescriptors017, TestSize.Level2)
337 {
338 uint32_t descsLen = 4294967295;
339 for (int i = 0; i < 50; i++) {
340 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, nullptr, &descsLen));
341 }
342 }
343
344 /**
345 * @tc.number SUB_Driver_Audio_CreateEffectController_0100
346 * @tc.name testEffectCreateEffectController001
347 * @tc.desc Create an effect controller which is used to operate the effect instance.
348 */
349 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController001, TestSize.Level2)
350 {
351 struct IEffectControl *controller = NULL;
352 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->CreateEffectController(nullptr, nullptr, &controller, &controllerId_));
353 }
354
355 /**
356 * @tc.number SUB_Driver_Audio_CreateEffectController_0200
357 * @tc.name testEffectCreateEffectController002
358 * @tc.desc Create an effect controller which is used to operate the effect instance.
359 */
360 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController002, TestSize.Level2)
361 {
362 struct IEffectControl *controller = NULL;
363 for (int i = 0; i < 50; i++) {
364 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
365 model_->CreateEffectController(nullptr, nullptr, &controller, &controllerId_));
366 }
367 }
368
369 /**
370 * @tc.number SUB_Driver_Audio_CreateEffectController_0300
371 * @tc.name testEffectCreateEffectController003
372 * @tc.desc Create an effect controller which is used to operate the effect instance.
373 */
374 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController003, TestSize.Level2)
375 {
376 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, nullptr, &controllerId_));
377 }
378
379 /**
380 * @tc.number SUB_Driver_Audio_CreateEffectController_0400
381 * @tc.name testEffectCreateEffectController004
382 * @tc.desc Create an effect controller which is used to operate the effect instance.
383 */
384 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController004, TestSize.Level2)
385 {
386 for (int i = 0; i < 50; i++) {
387 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, nullptr, &controllerId_));
388 }
389 }
390
391 /**
392 * @tc.number SUB_Driver_Audio_CreateEffectController_0500
393 * @tc.name testEffectCreateEffectController005
394 * @tc.desc Create an effect controller which is used to operate the effect instance.
395 */
396 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController005, TestSize.Level2)
397 {
398 struct IEffectControl *controller = NULL;
399 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, &controller, nullptr));
400 }
401 /**
402 * @tc.number SUB_Driver_Audio_CreateEffectController_0600
403 * @tc.name testEffectCreateEffectController006
404 * @tc.desc Create an effect controller which is used to operate the effect instance.
405 */
406 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController006, TestSize.Level2)
407 {
408 struct IEffectControl *controller = NULL;
409 for (int i = 0; i < 50; i++) {
410 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, &controller, nullptr));
411 }
412 }
413
414 /**
415 * @tc.number SUB_Driver_Audio_CreateEffectController_0700
416 * @tc.name testEffectCreateEffectController007
417 * @tc.desc Create an effect controller which is used to operate the effect instance.
418 */
419 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController007, TestSize.Level1)
420 {
421 struct EffectInfo info = {
422 .libName = strdup("libmock_effect_lib"),
423 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
424 .ioDirection = 1,
425 };
426 struct IEffectControl *controller = NULL;
427 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, nullptr, &controllerId_));
428 EXPECT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
429 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
430 }
431
432 /**
433 * @tc.number SUB_Driver_Audio_CreateEffectController_0800
434 * @tc.name testEffectCreateEffectController008
435 * @tc.desc Create an effect controller which is used to operate the effect instance.
436 */
437 HWTEST_F(EffectModelTestAdditional, testEffectCreateEffectController008, TestSize.Level1)
438 {
439 struct EffectInfo info = {
440 .libName = strdup("libmock_effect_lib"),
441 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
442 .ioDirection = 1,
443 };
444 struct IEffectControl *controller = NULL;
445 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->CreateEffectController(nullptr, nullptr, &controller, &controllerId_));
446 EXPECT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
447 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
448 }
449
450 /**
451 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0100
452 * @tc.name : testGetEffectDescriptor001
453 * @tc.desc : Reliability of function(GetEffectDescriptor)
454 */
455 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor001, TestSize.Level1)
456 {
457 struct EffectControllerDescriptor desc;
458
459 EXPECT_EQ(HDF_SUCCESS,
460 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
461 }
462 /**
463 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0200
464 * @tc.name : testGetEffectDescriptor002
465 * @tc.desc : Reliability of function(GetEffectDescriptor)
466 */
467 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor002, TestSize.Level2)
468 {
469 struct EffectControllerDescriptor desc;
470
471 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
472 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
473 }
474 /**
475 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0300
476 * @tc.name : testGetEffectDescriptor003
477 * @tc.desc : Reliability of function(GetEffectDescriptor)
478 */
479 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor003, TestSize.Level2)
480 {
481 struct EffectControllerDescriptor desc;
482
483 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
484 }
485 /**
486 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0400
487 * @tc.name : testGetEffectDescriptor004
488 * @tc.desc : Reliability of function(GetEffectDescriptor)
489 */
490 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor004, TestSize.Level2)
491 {
492 EXPECT_EQ(HDF_ERR_INVALID_PARAM,
493 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
494 }
495 /**
496 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0500
497 * @tc.name : testGetEffectDescriptor005
498 * @tc.desc : Reliability of function(GetEffectDescriptor)
499 */
500 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor005, TestSize.Level1)
501 {
502 struct EffectControllerDescriptor desc;
503 int32_t i;
504 for (i = 0; i < 50; i++) {
505 EXPECT_EQ(HDF_SUCCESS,
506 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
507 }
508 }
509 /**
510 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0600
511 * @tc.name : testGetEffectDescriptor006
512 * @tc.desc : Reliability of function(GetEffectDescriptor)
513 */
514 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor006, TestSize.Level2)
515 {
516 struct EffectControllerDescriptor desc;
517 int32_t i;
518 for (i = 0; i < 50; i++) {
519 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
520 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
521 }
522 }
523 /**
524 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0700
525 * @tc.name : testGetEffectDescriptor007
526 * @tc.desc : Reliability of function(GetEffectDescriptor)
527 */
528 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor007, TestSize.Level2)
529 {
530 struct EffectControllerDescriptor desc;
531 int32_t i;
532 for (i = 0; i < 50; i++) {
533 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
534 }
535 }
536 /**
537 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0800
538 * @tc.name : testGetEffectDescriptor008
539 * @tc.desc : Reliability of function(GetEffectDescriptor)
540 */
541 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor008, TestSize.Level2)
542 {
543 int32_t i;
544 for (i = 0; i < 50; i++) {
545 EXPECT_EQ(HDF_ERR_INVALID_PARAM,
546 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
547 }
548 }
549
550 /**
551 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_0900
552 * @tc.name : testGetEffectDescriptor009
553 * @tc.desc : Reliability of function(GetEffectDescriptor)
554 */
555 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor009, TestSize.Level2)
556 {
557 struct EffectControllerDescriptor desc;
558
559 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
560 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
561 EXPECT_EQ(HDF_SUCCESS,
562 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
563 }
564 /**
565 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1000
566 * @tc.name : testGetEffectDescriptor010
567 * @tc.desc : Reliability of function(GetEffectDescriptor)
568 */
569 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor010, TestSize.Level2)
570 {
571 struct EffectControllerDescriptor desc;
572
573 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
574 EXPECT_EQ(HDF_SUCCESS,
575 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
576 }
577 /**
578 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1100
579 * @tc.name : testGetEffectDescriptor011
580 * @tc.desc : Reliability of function(GetEffectDescriptor)
581 */
582 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor011, TestSize.Level2)
583 {
584 struct EffectControllerDescriptor desc;
585
586 EXPECT_EQ(HDF_ERR_INVALID_PARAM,
587 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
588 EXPECT_EQ(HDF_SUCCESS,
589 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
590 }
591 /**
592 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1200
593 * @tc.name : testGetEffectDescriptor012
594 * @tc.desc : Reliability of function(GetEffectDescriptor)
595 */
596 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor012, TestSize.Level2)
597 {
598 struct EffectControllerDescriptor desc;
599
600 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
601 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
602 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
603 }
604 /**
605 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1300
606 * @tc.name : testGetEffectDescriptor013
607 * @tc.desc : Reliability of function(GetEffectDescriptor)
608 */
609 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor013, TestSize.Level2)
610 {
611 struct EffectControllerDescriptor desc;
612
613 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
614 EXPECT_EQ(HDF_ERR_INVALID_PARAM,
615 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
616 }
617 /**
618 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1400
619 * @tc.name : testGetEffectDescriptor014
620 * @tc.desc : Reliability of function(GetEffectDescriptor)
621 */
622 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor014, TestSize.Level2)
623 {
624 struct EffectControllerDescriptor desc;
625
626 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, nullptr));
627 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
628 }
629 /**
630 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1500
631 * @tc.name : testGetEffectDescriptor015
632 * @tc.desc : Reliability of function(GetEffectDescriptor)
633 */
634 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor015, TestSize.Level2)
635 {
636 struct EffectControllerDescriptor desc;
637
638 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
639 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
640 }
641 /**
642 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1600
643 * @tc.name : testGetEffectDescriptor016
644 * @tc.desc : Reliability of function(GetEffectDescriptor)
645 */
646 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor016, TestSize.Level2)
647 {
648 struct EffectControllerDescriptor desc;
649
650 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
651 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
652 }
653 /**
654 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1700
655 * @tc.name : testGetEffectDescriptor017
656 * @tc.desc : Reliability of function(GetEffectDescriptor)
657 */
658 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor017, TestSize.Level2)
659 {
660 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
661 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
662 }
663 /**
664 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1800
665 * @tc.name : testGetEffectDescriptor018
666 * @tc.desc : Reliability of function(GetEffectDescriptor)
667 */
668 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor018, TestSize.Level2)
669 {
670 struct EffectControllerDescriptor desc;
671
672 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
673 int32_t i;
674 for (i = 0; i < 50; i++) {
675 EXPECT_EQ(HDF_SUCCESS,
676 model_->GetEffectDescriptor(model_, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
677 }
678 }
679 /**
680 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_1900
681 * @tc.name : testGetEffectDescriptor019
682 * @tc.desc : Reliability of function(GetEffectDescriptor)
683 */
684 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor019, TestSize.Level2)
685 {
686 struct EffectControllerDescriptor desc;
687
688 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
689 int32_t i;
690 for (i = 0; i < 50; i++) {
691 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
692 }
693 }
694
695 /**
696 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2000
697 * @tc.name : testGetEffectDescriptor020
698 * @tc.desc : Reliability of function(GetEffectDescriptor)
699 */
700 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor020, TestSize.Level2)
701 {
702 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
703 int32_t i;
704 for (i = 0; i < 50; i++) {
705 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
706 }
707 }
708
709 /**
710 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2100
711 * @tc.name : testGetEffectDescriptor021
712 * @tc.desc : Reliability of function(GetEffectDescriptor)
713 */
714 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor021, TestSize.Level2)
715 {
716 struct EffectControllerDescriptor desc;
717
718 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
719 int32_t i;
720 for (i = 0; i < 50; i++) {
721 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
722 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), &desc));
723 }
724 }
725
726 /**
727 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2200
728 * @tc.name : testGetEffectDescriptor022
729 * @tc.desc : Reliability of function(GetEffectDescriptor)
730 */
731 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor022, TestSize.Level2)
732 {
733 struct EffectControllerDescriptor desc;
734
735 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
736 int32_t i;
737 for (i = 0; i < 50; i++) {
738 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
739 }
740 }
741 /**
742 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2300
743 * @tc.name : testGetEffectDescriptor023
744 * @tc.desc : Reliability of function(GetEffectDescriptor)
745 */
746 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor023, TestSize.Level2)
747 {
748 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
749 int32_t i;
750 for (i = 0; i < 50; i++) {
751 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
752 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
753 }
754 }
755 /**
756 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2400
757 * @tc.name : testGetEffectDescriptor024
758 * @tc.desc : Reliability of function(GetEffectDescriptor)
759 */
760 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor024, TestSize.Level2)
761 {
762 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
763 int32_t i;
764 for (i = 0; i < 50; i++) {
765 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, nullptr));
766 }
767 }
768 /**
769 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2500
770 * @tc.name : testGetEffectDescriptor025
771 * @tc.desc : Reliability of function(GetEffectDescriptor)
772 */
773 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor025, TestSize.Level2)
774 {
775 struct EffectControllerDescriptor desc;
776
777 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
778 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
779 EXPECT_EQ(HDF_ERR_INVALID_OBJECT,
780 model_->GetEffectDescriptor(nullptr, strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"), nullptr));
781 }
782 /**
783 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2600
784 * @tc.name : testGetEffectDescriptor026
785 * @tc.desc : Reliability of function(GetEffectDescriptor)
786 */
787 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor026, TestSize.Level2)
788 {
789 struct EffectControllerDescriptor desc;
790
791 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
792 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
793 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
794 }
795 /**
796 * @tc.number : SUB_Driver_Audio_GetEffectDescriptor_2700
797 * @tc.name : testGetEffectDescriptor027
798 * @tc.desc : Reliability of function(GetEffectDescriptor)
799 */
800 HWTEST_F(EffectModelTestAdditional, testGetEffectDescriptor027, TestSize.Level2)
801 {
802 struct EffectControllerDescriptor desc;
803
804 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, &desc));
805 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, nullptr, nullptr));
806 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, nullptr));
807 }
808 /**
809 * @tc.number : SUB_Driver_Audio_DestroyEffectController_0100
810 * @tc.name : testAudioDestroyEffectController001
811 * @tc.desc : Reliability of function(DestroyEffectController)
812 */
813 HWTEST_F(EffectModelTestAdditional, testAudioDestroyEffectController001, TestSize.Level2)
814 {
815 struct EffectInfo info = {
816 .libName = strdup("libmock_effect_lib"),
817 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
818 .ioDirection = 1,
819 };
820
821 struct IEffectControl *controller = NULL;
822 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
823 ASSERT_NE(controller, nullptr);
824 int32_t i;
825 for (i = 0; i < 50; i++) {
826 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->DestroyEffectController(nullptr, &controllerId_));
827 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->DestroyEffectController(model_, nullptr));
828 }
829 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
830 }
831 /**
832 * @tc.number : SUB_Driver_Audio_DestroyEffectController_0200
833 * @tc.name : testAudioDestroyEffectController002
834 * @tc.desc : Reliability of function(DestroyEffectController)
835 */
836 HWTEST_F(EffectModelTestAdditional, testAudioDestroyEffectController002, TestSize.Level1)
837 {
838 struct EffectInfo info = {
839 .libName = strdup("libmock_effect_lib"),
840 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
841 .ioDirection = 1,
842 };
843
844 struct IEffectControl *controller = NULL;
845 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
846 ASSERT_NE(controller, nullptr);
847 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
848 }
849 /**
850 * @tc.number : SUB_Driver_Audio_DestroyEffectController_0300
851 * @tc.name : testAudioDestroyEffectController003
852 * @tc.desc : Reliability of function(DestroyEffectController)
853 */
854 HWTEST_F(EffectModelTestAdditional, testAudioDestroyEffectController003, TestSize.Level1)
855 {
856 struct EffectInfo info = {
857 .libName = strdup("libmock_effect_lib"),
858 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
859 .ioDirection = 1,
860 };
861
862 struct IEffectControl *controller = NULL;
863 int32_t i;
864 for (i = 0; i < 50; i++) {
865 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
866 ASSERT_NE(controller, nullptr);
867 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
868 }
869 }
870 /**
871 * @tc.number : SUB_Driver_Audio_DestroyEffectController_0400
872 * @tc.name : testAudioDestroyEffectController004
873 * @tc.desc : Reliability of function(DestroyEffectController)
874 */
875 HWTEST_F(EffectModelTestAdditional, testAudioDestroyEffectController004, TestSize.Level2)
876 {
877 struct EffectInfo info = {
878 .libName = strdup("libmock_effect_lib"),
879 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
880 .ioDirection = 1,
881 };
882
883 struct IEffectControl *controller = NULL;
884 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
885 ASSERT_NE(controller, nullptr);
886
887 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->DestroyEffectController(nullptr, &controllerId_));
888 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
889 }
890 /**
891 * @tc.number : SUB_Driver_Audio_DestroyEffectController_0500
892 * @tc.name : testAudioDestroyEffectController005
893 * @tc.desc : Reliability of function(DestroyEffectController)
894 */
895 HWTEST_F(EffectModelTestAdditional, testAudioDestroyEffectController005, TestSize.Level2)
896 {
897 struct EffectInfo info = {
898 .libName = strdup("libmock_effect_lib"),
899 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
900 .ioDirection = 1,
901 };
902
903 struct IEffectControl *controller = NULL;
904 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
905 ASSERT_NE(controller, nullptr);
906
907 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->DestroyEffectController(model_, nullptr));
908 EXPECT_EQ(HDF_SUCCESS, model_->DestroyEffectController(model_, &controllerId_));
909 }
910 } // end of namespace
911