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 "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 constexpr bool IS_DIRECTLY_CALL = false;
28 /* the input buffer len of the send command */
29 constexpr uint32_t SEND_COMMAND_LEN = 10;
30 constexpr uint32_t SEND_COMMAND_LEN_TEST1 = 0;
31 /* the output buffer len of the command */
32 constexpr uint32_t GET_BUFFER_LEN = 10;
33
34 namespace {
35 class EffectControlTestAdditional : public testing::Test {
36 public:
37 struct IEffectControl *controller_ = nullptr;
38 struct IEffectModel *model_ = nullptr;
39 struct ControllerId contollerId_;
40 virtual void SetUp();
41 virtual void TearDown();
42 };
43
SetUp()44 void EffectControlTestAdditional::SetUp()
45 {
46 struct EffectInfo info = {
47 .libName = strdup("libmock_effect_lib"),
48 .effectId = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff"),
49 .ioDirection = 1,
50 };
51
52 model_ = IEffectModelGet(IS_DIRECTLY_CALL);
53 ASSERT_NE(model_, nullptr);
54
55 int32_t ret = model_->CreateEffectController(model_, &info, &controller_, &contollerId_);
56 ASSERT_EQ(ret, HDF_SUCCESS);
57 ASSERT_NE(controller_, nullptr);
58 }
59
TearDown()60 void EffectControlTestAdditional::TearDown()
61 {
62 if (controller_ != nullptr && model_ != nullptr) {
63 int32_t ret = model_->DestroyEffectController(model_, &contollerId_);
64 EXPECT_EQ(ret, HDF_SUCCESS);
65 }
66
67 if (model_ != nullptr) {
68 IEffectModelRelease(model_, IS_DIRECTLY_CALL);
69 }
70 }
71
72 /**
73 * @tc.number: SUB_Driver_Audio_EffectProcess_0400
74 * @tc.name: testEffectProcess001
75 * @tc.desc: Verify the EffectControlEffectProcess function when the input parameter is invalid.
76 */
HWTEST_F(EffectControlTestAdditional, testEffectProcess001, TestSize.Level2)77 HWTEST_F(EffectControlTestAdditional, testEffectProcess001, TestSize.Level2)
78 {
79 EXPECT_NE(HDF_SUCCESS, controller_->EffectProcess(controller_, nullptr, nullptr));
80 }
81
82 /**
83 * @tc.number: SUB_Driver_Audio_EffectProcess_0500
84 * @tc.name: testEffectProcess002
85 * @tc.desc: Verify the reliability of the EffectControlEffectProcess function.
86 */
HWTEST_F(EffectControlTestAdditional, testEffectProcess002, TestSize.Level1)87 HWTEST_F(EffectControlTestAdditional, testEffectProcess002, TestSize.Level1)
88 {
89 struct AudioEffectBuffer input = {0};
90 struct AudioEffectBuffer output = {0};
91 int32_t ret = HDF_SUCCESS;
92
93 for (int32_t i = 0; i < 1000; i++) {
94 ret = controller_->EffectProcess(controller_, &input, &output);
95 EXPECT_EQ(ret, HDF_SUCCESS);
96 }
97 }
98
99 /**
100 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1000
101 * @tc.name: testEffectSendCommand001
102 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is
103 * AUDIO_EFFECT_COMMAND_INIT_CONTOLLER.
104 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand001, TestSize.Level1)105 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand001, TestSize.Level1)
106 {
107 int8_t input[SEND_COMMAND_LEN] = {0};
108 int8_t output[GET_BUFFER_LEN] = {0};
109 uint32_t replyLen = GET_BUFFER_LEN;
110 int32_t ret = HDF_SUCCESS;
111
112 for (int32_t i = 0; i < 1000; i++) {
113 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER, input, SEND_COMMAND_LEN,
114 output, &replyLen);
115 EXPECT_EQ(ret, HDF_SUCCESS);
116 }
117 }
118
119 /**
120 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1100
121 * @tc.name: testEffectSendCommand002
122 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_INIT_CONTOLLER.
123 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand002, TestSize.Level2)124 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand002, TestSize.Level2)
125 {
126 int8_t input[SEND_COMMAND_LEN] = {0};
127 int8_t output[GET_BUFFER_LEN] = {0};
128 uint32_t replyLen = GET_BUFFER_LEN;
129
130 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER, input,
131 SEND_COMMAND_LEN_TEST1, output, &replyLen);
132 EXPECT_NE(ret, HDF_SUCCESS);
133 }
134
135 /**
136 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1300
137 * @tc.name: testEffectSendCommand004
138 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
139 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand004, TestSize.Level2)140 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand004, TestSize.Level2)
141 {
142 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER, nullptr, SEND_COMMAND_LEN,
143 nullptr, nullptr);
144 EXPECT_NE(ret, HDF_SUCCESS);
145 }
146
147 /**
148 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1400
149 * @tc.name: testEffectSendCommand005
150 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is
151 * AUDIO_EFFECT_COMMAND_SET_PARAM.
152 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand005, TestSize.Level1)153 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand005, TestSize.Level1)
154 {
155 int8_t input[SEND_COMMAND_LEN] = {0};
156 int8_t output[GET_BUFFER_LEN] = {0};
157 uint32_t replyLen = GET_BUFFER_LEN;
158 int32_t ret = HDF_SUCCESS;
159
160 for (int32_t i = 0; i < 1000; i++) {
161 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, input, SEND_COMMAND_LEN, output,
162 &replyLen);
163 EXPECT_EQ(ret, HDF_SUCCESS);
164 }
165 }
166
167 /**
168 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1500
169 * @tc.name: testEffectSendCommand006
170 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_SET_PARAM.
171 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand006, TestSize.Level2)172 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand006, TestSize.Level2)
173 {
174 int8_t input[SEND_COMMAND_LEN] = {0};
175 int8_t output[GET_BUFFER_LEN] = {0};
176 uint32_t replyLen = GET_BUFFER_LEN;
177
178 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, input, SEND_COMMAND_LEN_TEST1,
179 output, &replyLen);
180 EXPECT_NE(ret, HDF_SUCCESS);
181 }
182
183 /**
184 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1600
185 * @tc.name: testEffectSendCommand007
186 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
187 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand007, TestSize.Level2)188 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand007, TestSize.Level2)
189 {
190 int8_t output[GET_BUFFER_LEN] = {0};
191 uint32_t replyLen = GET_BUFFER_LEN;
192
193 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, nullptr, SEND_COMMAND_LEN,
194 output, &replyLen);
195 EXPECT_NE(ret, HDF_SUCCESS);
196 }
197
198 /**
199 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1700
200 * @tc.name: testEffectSendCommand008
201 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
202 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand008, TestSize.Level2)203 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand008, TestSize.Level2)
204 {
205 int8_t input[SEND_COMMAND_LEN] = {0};
206 uint32_t replyLen = GET_BUFFER_LEN;
207
208 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, input, SEND_COMMAND_LEN,
209 nullptr, &replyLen);
210 EXPECT_NE(ret, HDF_SUCCESS);
211 }
212
213 /**
214 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1800
215 * @tc.name: testEffectSendCommand009
216 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
217 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand009, TestSize.Level2)218 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand009, TestSize.Level2)
219 {
220 int8_t input[SEND_COMMAND_LEN] = {0};
221 int8_t output[GET_BUFFER_LEN] = {0};
222
223 int32_t ret =
224 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, input, SEND_COMMAND_LEN, output, nullptr);
225 EXPECT_NE(ret, HDF_SUCCESS);
226 }
227
228 /**
229 * @tc.number: SUB_Driver_Audio_EffectSendCommand_1900
230 * @tc.name: testEffectSendCommand010
231 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
232 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand010, TestSize.Level2)233 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand010, TestSize.Level2)
234 {
235 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM, nullptr, SEND_COMMAND_LEN,
236 nullptr, nullptr);
237 EXPECT_NE(ret, HDF_SUCCESS);
238 }
239
240 /**
241 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2000
242 * @tc.name: testEffectSendCommand011
243 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is
244 * AUDIO_EFFECT_COMMAND_SET_CONFIG.
245 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand011, TestSize.Level1)246 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand011, TestSize.Level1)
247 {
248 int8_t input[SEND_COMMAND_LEN] = {0};
249 int8_t output[GET_BUFFER_LEN] = {0};
250 uint32_t replyLen = GET_BUFFER_LEN;
251 int32_t ret = HDF_SUCCESS;
252
253 for (int32_t i = 0; i < 1000; i++) {
254 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, input, SEND_COMMAND_LEN, output,
255 &replyLen);
256 EXPECT_EQ(ret, HDF_SUCCESS);
257 }
258 }
259
260 /**
261 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2100
262 * @tc.name: testEffectSendCommand012
263 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_SET_CONFIG.
264 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand012, TestSize.Level2)265 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand012, TestSize.Level2)
266 {
267 int8_t input[SEND_COMMAND_LEN] = {0};
268 int8_t output[GET_BUFFER_LEN] = {0};
269 uint32_t replyLen = GET_BUFFER_LEN;
270
271 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, input, SEND_COMMAND_LEN_TEST1,
272 output, &replyLen);
273 EXPECT_NE(ret, HDF_SUCCESS);
274 }
275
276 /**
277 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2200
278 * @tc.name: testEffectSendCommand013
279 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
280 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand013, TestSize.Level2)281 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand013, TestSize.Level2)
282 {
283 int8_t output[GET_BUFFER_LEN] = {0};
284 uint32_t replyLen = GET_BUFFER_LEN;
285
286 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, nullptr, SEND_COMMAND_LEN,
287 output, &replyLen);
288 EXPECT_NE(ret, HDF_SUCCESS);
289 }
290
291 /**
292 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2300
293 * @tc.name: testEffectSendCommand014
294 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
295 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand014, TestSize.Level2)296 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand014, TestSize.Level2)
297 {
298 int8_t input[SEND_COMMAND_LEN] = {0};
299 uint32_t replyLen = GET_BUFFER_LEN;
300
301 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, input, SEND_COMMAND_LEN,
302 nullptr, &replyLen);
303 EXPECT_NE(ret, HDF_SUCCESS);
304 }
305
306 /**
307 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2400
308 * @tc.name: testEffectSendCommand015
309 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
310 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand015, TestSize.Level2)311 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand015, TestSize.Level2)
312 {
313 int8_t input[SEND_COMMAND_LEN] = {0};
314 int8_t output[GET_BUFFER_LEN] = {0};
315
316 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, input, SEND_COMMAND_LEN,
317 output, nullptr);
318 EXPECT_NE(ret, HDF_SUCCESS);
319 }
320
321 /**
322 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2500
323 * @tc.name: testEffectSendCommand016
324 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
325 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand016, TestSize.Level2)326 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand016, TestSize.Level2)
327 {
328 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG, nullptr, SEND_COMMAND_LEN,
329 nullptr, nullptr);
330 EXPECT_NE(ret, HDF_SUCCESS);
331 }
332
333 /**
334 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2600
335 * @tc.name: testEffectSendCommand017
336 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is
337 * AUDIO_EFFECT_COMMAND_GET_CONFIG.
338 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand017, TestSize.Level1)339 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand017, TestSize.Level1)
340 {
341 int8_t input[SEND_COMMAND_LEN] = {0};
342 int8_t output[GET_BUFFER_LEN] = {0};
343 uint32_t replyLen = GET_BUFFER_LEN;
344 int32_t ret = HDF_SUCCESS;
345
346 for (int32_t i = 0; i < 1000; i++) {
347 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, input, SEND_COMMAND_LEN, output,
348 &replyLen);
349 EXPECT_EQ(ret, HDF_SUCCESS);
350 }
351 }
352
353 /**
354 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2700
355 * @tc.name: testEffectSendCommand018
356 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_GET_CONFIG.
357 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand018, TestSize.Level2)358 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand018, TestSize.Level2)
359 {
360 int8_t input[SEND_COMMAND_LEN] = {0};
361 int8_t output[GET_BUFFER_LEN] = {0};
362 uint32_t replyLen = GET_BUFFER_LEN;
363
364 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, input, SEND_COMMAND_LEN_TEST1,
365 output, &replyLen);
366 EXPECT_NE(ret, HDF_SUCCESS);
367 }
368
369 /**
370 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2800
371 * @tc.name: testEffectSendCommand019
372 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
373 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand019, TestSize.Level2)374 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand019, TestSize.Level2)
375 {
376 int8_t output[GET_BUFFER_LEN] = {0};
377 uint32_t replyLen = GET_BUFFER_LEN;
378
379 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, nullptr, SEND_COMMAND_LEN,
380 output, &replyLen);
381 EXPECT_NE(ret, HDF_SUCCESS);
382 }
383
384 /**
385 * @tc.number: SUB_Driver_Audio_EffectSendCommand_2900
386 * @tc.name: testEffectSendCommand020
387 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
388 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand020, TestSize.Level2)389 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand020, TestSize.Level2)
390 {
391 int8_t input[SEND_COMMAND_LEN] = {0};
392 uint32_t replyLen = GET_BUFFER_LEN;
393
394 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, input, SEND_COMMAND_LEN,
395 nullptr, &replyLen);
396 EXPECT_NE(ret, HDF_SUCCESS);
397 }
398
399 /**
400 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3000
401 * @tc.name: testEffectSendCommand021
402 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
403 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand021, TestSize.Level2)404 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand021, TestSize.Level2)
405 {
406 int8_t input[SEND_COMMAND_LEN] = {0};
407 int8_t output[GET_BUFFER_LEN] = {0};
408
409 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, input, SEND_COMMAND_LEN,
410 output, nullptr);
411 EXPECT_NE(ret, HDF_SUCCESS);
412 }
413
414 /**
415 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3100
416 * @tc.name: testEffectSendCommand022
417 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
418 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand022, TestSize.Level2)419 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand022, TestSize.Level2)
420 {
421 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG, nullptr, SEND_COMMAND_LEN,
422 nullptr, nullptr);
423 EXPECT_NE(ret, HDF_SUCCESS);
424 }
425
426 /**
427 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3200
428 * @tc.name: testEffectSendCommand023
429 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_RESET.
430 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand023, TestSize.Level1)431 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand023, TestSize.Level1)
432 {
433 int8_t input[SEND_COMMAND_LEN] = {0};
434 int8_t output[GET_BUFFER_LEN] = {0};
435 uint32_t replyLen = GET_BUFFER_LEN;
436 int32_t ret = HDF_SUCCESS;
437
438 for (int32_t i = 0; i < 1000; i++) {
439 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, input, SEND_COMMAND_LEN, output,
440 &replyLen);
441 EXPECT_EQ(ret, HDF_SUCCESS);
442 }
443 }
444
445 /**
446 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3300
447 * @tc.name: testEffectSendCommand024
448 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_RESET.
449 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand024, TestSize.Level2)450 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand024, TestSize.Level2)
451 {
452 int8_t input[SEND_COMMAND_LEN] = {0};
453 int8_t output[GET_BUFFER_LEN] = {0};
454 uint32_t replyLen = GET_BUFFER_LEN;
455
456 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, input, SEND_COMMAND_LEN_TEST1,
457 output, &replyLen);
458 EXPECT_NE(ret, HDF_SUCCESS);
459 }
460
461 /**
462 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3400
463 * @tc.name: testEffectSendCommand025
464 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
465 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand025, TestSize.Level2)466 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand025, TestSize.Level2)
467 {
468 int8_t output[GET_BUFFER_LEN] = {0};
469 uint32_t replyLen = GET_BUFFER_LEN;
470
471 int32_t ret =
472 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, nullptr, SEND_COMMAND_LEN, output, &replyLen);
473 EXPECT_NE(ret, HDF_SUCCESS);
474 }
475
476 /**
477 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3500
478 * @tc.name: testEffectSendCommand026
479 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
480 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand026, TestSize.Level2)481 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand026, TestSize.Level2)
482 {
483 int8_t input[SEND_COMMAND_LEN] = {0};
484 uint32_t replyLen = GET_BUFFER_LEN;
485
486 int32_t ret =
487 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, input, SEND_COMMAND_LEN, nullptr, &replyLen);
488 EXPECT_NE(ret, HDF_SUCCESS);
489 }
490
491 /**
492 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3600
493 * @tc.name: testEffectSendCommand027
494 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
495 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand027, TestSize.Level2)496 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand027, TestSize.Level2)
497 {
498 int8_t input[SEND_COMMAND_LEN] = {0};
499 int8_t output[GET_BUFFER_LEN] = {0};
500
501 int32_t ret =
502 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, input, SEND_COMMAND_LEN, output, nullptr);
503 EXPECT_NE(ret, HDF_SUCCESS);
504 }
505
506 /**
507 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3700
508 * @tc.name: testEffectSendCommand028
509 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
510 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand028, TestSize.Level2)511 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand028, TestSize.Level2)
512 {
513 int32_t ret =
514 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET, nullptr, SEND_COMMAND_LEN, nullptr, nullptr);
515 EXPECT_NE(ret, HDF_SUCCESS);
516 }
517
518 /**
519 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3800
520 * @tc.name: testEffectSendCommand029
521 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_ENABLE.
522 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand029, TestSize.Level1)523 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand029, TestSize.Level1)
524 {
525 int8_t input[SEND_COMMAND_LEN] = {0};
526 int8_t output[GET_BUFFER_LEN] = {0};
527 uint32_t replyLen = GET_BUFFER_LEN;
528 int32_t ret = HDF_SUCCESS;
529
530 for (int32_t i = 0; i < 1000; i++) {
531 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, input, SEND_COMMAND_LEN, output,
532 &replyLen);
533 EXPECT_EQ(ret, HDF_SUCCESS);
534 }
535 }
536
537 /**
538 * @tc.number: SUB_Driver_Audio_EffectSendCommand_3900
539 * @tc.name: testEffectSendCommand030
540 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_ENABLE.
541 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand030, TestSize.Level2)542 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand030, TestSize.Level2)
543 {
544 int8_t input[SEND_COMMAND_LEN] = {0};
545 int8_t output[GET_BUFFER_LEN] = {0};
546 uint32_t replyLen = GET_BUFFER_LEN;
547
548 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, input, SEND_COMMAND_LEN_TEST1,
549 output, &replyLen);
550 EXPECT_NE(ret, HDF_SUCCESS);
551 }
552
553 /**
554 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4000
555 * @tc.name: testEffectSendCommand031
556 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
557 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand031, TestSize.Level2)558 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand031, TestSize.Level2)
559 {
560 int8_t output[GET_BUFFER_LEN] = {0};
561 uint32_t replyLen = GET_BUFFER_LEN;
562
563 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, nullptr, SEND_COMMAND_LEN, output,
564 &replyLen);
565 EXPECT_NE(ret, HDF_SUCCESS);
566 }
567
568 /**
569 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4100
570 * @tc.name: testEffectSendCommand032
571 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
572 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand032, TestSize.Level2)573 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand032, TestSize.Level2)
574 {
575 int8_t input[SEND_COMMAND_LEN] = {0};
576 uint32_t replyLen = GET_BUFFER_LEN;
577
578 int32_t ret =
579 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, input, SEND_COMMAND_LEN, nullptr, &replyLen);
580 EXPECT_NE(ret, HDF_SUCCESS);
581 }
582
583 /**
584 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4200
585 * @tc.name: testEffectSendCommand033
586 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
587 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand033, TestSize.Level2)588 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand033, TestSize.Level2)
589 {
590 int8_t input[SEND_COMMAND_LEN] = {0};
591 int8_t output[GET_BUFFER_LEN] = {0};
592
593 int32_t ret =
594 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, input, SEND_COMMAND_LEN, output, nullptr);
595 EXPECT_NE(ret, HDF_SUCCESS);
596 }
597
598 /**
599 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4300
600 * @tc.name: testEffectSendCommand034
601 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
602 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand034, TestSize.Level2)603 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand034, TestSize.Level2)
604 {
605 int32_t ret =
606 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE, nullptr, SEND_COMMAND_LEN, nullptr, nullptr);
607 EXPECT_NE(ret, HDF_SUCCESS);
608 }
609
610 /**
611 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4400
612 * @tc.name: testEffectSendCommand035
613 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_DISABLE.
614 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand035, TestSize.Level1)615 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand035, TestSize.Level1)
616 {
617 int8_t input[SEND_COMMAND_LEN] = {0};
618 int8_t output[GET_BUFFER_LEN] = {0};
619 uint32_t replyLen = GET_BUFFER_LEN;
620 int32_t ret = HDF_SUCCESS;
621
622 for (int32_t i = 0; i < 1000; i++) {
623 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, output,
624 &replyLen);
625 EXPECT_EQ(ret, HDF_SUCCESS);
626 }
627 }
628
629 /**
630 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4500
631 * @tc.name: testEffectSendCommand036
632 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_DISABLE.
633 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand036, TestSize.Level2)634 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand036, TestSize.Level2)
635 {
636 int8_t input[SEND_COMMAND_LEN] = {0};
637 int8_t output[GET_BUFFER_LEN] = {0};
638 uint32_t replyLen = GET_BUFFER_LEN;
639
640 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN_TEST1,
641 output, &replyLen);
642 EXPECT_NE(ret, HDF_SUCCESS);
643 }
644
645 /**
646 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4600
647 * @tc.name: testEffectSendCommand037
648 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
649 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand037, TestSize.Level2)650 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand037, TestSize.Level2)
651 {
652 int8_t output[GET_BUFFER_LEN] = {0};
653 uint32_t replyLen = GET_BUFFER_LEN;
654
655 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, nullptr, SEND_COMMAND_LEN, output,
656 &replyLen);
657 EXPECT_NE(ret, HDF_SUCCESS);
658 }
659
660 /**
661 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4700
662 * @tc.name: testEffectSendCommand038
663 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
664 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand038, TestSize.Level2)665 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand038, TestSize.Level2)
666 {
667 int8_t input[SEND_COMMAND_LEN] = {0};
668 uint32_t replyLen = GET_BUFFER_LEN;
669
670 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, nullptr,
671 &replyLen);
672 EXPECT_NE(ret, HDF_SUCCESS);
673 }
674
675 /**
676 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4800
677 * @tc.name: testEffectSendCommand039
678 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
679 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand039, TestSize.Level2)680 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand039, TestSize.Level2)
681 {
682 int8_t input[SEND_COMMAND_LEN] = {0};
683 int8_t output[GET_BUFFER_LEN] = {0};
684
685 int32_t ret =
686 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, output, nullptr);
687 EXPECT_NE(ret, HDF_SUCCESS);
688 }
689
690 /**
691 * @tc.number: SUB_Driver_Audio_EffectSendCommand_4900
692 * @tc.name: testEffectSendCommand040
693 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
694 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand040, TestSize.Level2)695 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand040, TestSize.Level2)
696 {
697 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, nullptr, SEND_COMMAND_LEN,
698 nullptr, nullptr);
699 EXPECT_NE(ret, HDF_SUCCESS);
700 }
701
702 /**
703 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5000
704 * @tc.name: testEffectSendCommand041
705 * @tc.desc: Verify the reliability of the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_DISABLE.
706 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand041, TestSize.Level1)707 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand041, TestSize.Level1)
708 {
709 int8_t input[SEND_COMMAND_LEN] = {0};
710 int8_t output[GET_BUFFER_LEN] = {0};
711 uint32_t replyLen = GET_BUFFER_LEN;
712 int32_t ret = HDF_SUCCESS;
713
714 for (int32_t i = 0; i < 1000; i++) {
715 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, output,
716 &replyLen);
717 EXPECT_EQ(ret, HDF_SUCCESS);
718 }
719 }
720
721 /**
722 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5100
723 * @tc.name: testEffectSendCommand042
724 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_DISABLE.
725 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand042, TestSize.Level2)726 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand042, TestSize.Level2)
727 {
728 int8_t input[SEND_COMMAND_LEN] = {0};
729 int8_t output[GET_BUFFER_LEN] = {0};
730 uint32_t replyLen = GET_BUFFER_LEN;
731
732 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN_TEST1,
733 output, &replyLen);
734 EXPECT_NE(ret, HDF_SUCCESS);
735 }
736
737 /**
738 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5200
739 * @tc.name: testEffectSendCommand043
740 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
741 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand043, TestSize.Level2)742 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand043, TestSize.Level2)
743 {
744 int8_t output[GET_BUFFER_LEN] = {0};
745 uint32_t replyLen = GET_BUFFER_LEN;
746
747 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, nullptr, SEND_COMMAND_LEN, output,
748 &replyLen);
749 EXPECT_NE(ret, HDF_SUCCESS);
750 }
751
752 /**
753 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5300
754 * @tc.name: testEffectSendCommand044
755 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
756 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand044, TestSize.Level2)757 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand044, TestSize.Level2)
758 {
759 int8_t input[SEND_COMMAND_LEN] = {0};
760 uint32_t replyLen = GET_BUFFER_LEN;
761
762 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, nullptr,
763 &replyLen);
764 EXPECT_NE(ret, HDF_SUCCESS);
765 }
766
767 /**
768 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5400
769 * @tc.name: testEffectSendCommand045
770 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
771 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand045, TestSize.Level2)772 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand045, TestSize.Level2)
773 {
774 int8_t input[SEND_COMMAND_LEN] = {0};
775 int8_t output[GET_BUFFER_LEN] = {0};
776
777 int32_t ret =
778 controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, input, SEND_COMMAND_LEN, output, nullptr);
779 EXPECT_NE(ret, HDF_SUCCESS);
780 }
781
782 /**
783 * @tc.number: SUB_Driver_Audio_EffectSendCommand_5500
784 * @tc.name: testEffectSendCommand046
785 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
786 */
HWTEST_F(EffectControlTestAdditional, testEffectSendCommand046, TestSize.Level2)787 HWTEST_F(EffectControlTestAdditional, testEffectSendCommand046, TestSize.Level2)
788 {
789 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE, nullptr, SEND_COMMAND_LEN,
790 nullptr, nullptr);
791 EXPECT_NE(ret, HDF_SUCCESS);
792 }
793
794 /**
795 * @tc.number: SUB_Driver_Audio_GetEffectDescriptor_0300
796 * @tc.name: testEffectGetEffectDescriptor001
797 * @tc.desc: Verify the GetEffectDescriptor function when the input parameter is invalid.
798 */
HWTEST_F(EffectControlTestAdditional, testEffectGetEffectDescriptor001, TestSize.Level2)799 HWTEST_F(EffectControlTestAdditional, testEffectGetEffectDescriptor001, TestSize.Level2)
800 {
801 EXPECT_NE(HDF_SUCCESS, controller_->GetEffectDescriptor(nullptr, nullptr));
802 }
803
804 /**
805 * @tc.number: SUB_Driver_Audio_GetEffectDescriptor_0400
806 * @tc.name: testEffectGetEffectDescriptor002
807 * @tc.desc: Verify the reliability of the GetEffectDescriptor function.
808 */
HWTEST_F(EffectControlTestAdditional, testEffectGetEffectDescriptor002, TestSize.Level1)809 HWTEST_F(EffectControlTestAdditional, testEffectGetEffectDescriptor002, TestSize.Level1)
810 {
811 struct EffectControllerDescriptor desc;
812 int32_t ret = HDF_SUCCESS;
813 for (int32_t i = 0; i < 1000; i++) {
814 ret = controller_->GetEffectDescriptor(controller_, &desc);
815 EXPECT_EQ(ret, HDF_SUCCESS);
816 }
817 }
818
819 /**
820 * @tc.number: SUB_Driver_Audio_EffectReverse_0300
821 * @tc.name: testEffectEffectReverse001
822 * @tc.desc: Verify the EffectReverse function when the input parameter is invalid.
823 */
HWTEST_F(EffectControlTestAdditional, testEffectEffectReverse001, TestSize.Level2)824 HWTEST_F(EffectControlTestAdditional, testEffectEffectReverse001, TestSize.Level2)
825 {
826 EXPECT_NE(HDF_SUCCESS, controller_->EffectReverse(nullptr, nullptr, nullptr));
827 }
828
829 /**
830 * @tc.number: SUB_Driver_Audio_EffectReverse_0400
831 * @tc.name: testEffectEffectReverse002
832 * @tc.desc: Verify the reliability of the EffectReverse function.
833 */
HWTEST_F(EffectControlTestAdditional, testEffectEffectReverse002, TestSize.Level1)834 HWTEST_F(EffectControlTestAdditional, testEffectEffectReverse002, TestSize.Level1)
835 {
836 struct AudioEffectBuffer input = {0};
837 struct AudioEffectBuffer output = {0};
838 int32_t ret = HDF_SUCCESS;
839 for (int32_t i = 0; i < 1000; i++) {
840 ret = controller_->EffectReverse(controller_, &input, &output);
841 EXPECT_EQ(ret, HDF_SUCCESS);
842 }
843 }
844 } // end of namespace
845