1 /*
2 * Copyright (c) 2023-2024 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 "hdf_base.h"
18 #include "hdf_log.h"
19 #include "v1_0/effect_types.h"
20 #include "v1_0/ieffect_control.h"
21 #include "v1_0/ieffect_model.h"
22 #include "effect_common.h"
23 #include "osal_mem.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 /* the output buffer len of the command */
31 constexpr uint32_t GET_BUFFER_LEN = 10;
32 # define AUDIO_EFFECT_COMMAND_INVALID_LARGE 20
33
34 namespace {
35 class EffectControlTest : 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 char *libName_ = nullptr;
43 char *effectId_ = nullptr;
44 };
45
SetUp()46 void EffectControlTest::SetUp()
47 {
48 // input testcase setup step,setup invoked before each testcases
49 libName_ = strdup("libmock_effect_lib");
50 effectId_ = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff");
51 struct EffectInfo info = {
52 .libName = libName_,
53 .effectId = effectId_,
54 .ioDirection = 1,
55 };
56
57 model_ = IEffectModelGet(IS_DIRECTLY_CALL);
58 ASSERT_NE(model_, nullptr);
59
60 int32_t ret = model_->CreateEffectController(model_, &info, &controller_, &contollerId_);
61 ASSERT_EQ(ret, HDF_SUCCESS);
62 ASSERT_NE(controller_, nullptr);
63 }
64
TearDown()65 void EffectControlTest::TearDown()
66 {
67 // input testcase teardown step,teardown invoked after each testcases
68 if (libName_ != nullptr) {
69 free(libName_);
70 libName_ = nullptr;
71 }
72
73 if (effectId_ != nullptr) {
74 free(effectId_);
75 effectId_ = nullptr;
76 }
77
78 if (controller_ != nullptr && model_ != nullptr) {
79 int32_t ret = model_->DestroyEffectController(model_, &contollerId_);
80 EXPECT_EQ(ret, HDF_SUCCESS);
81 }
82
83 if (model_ != nullptr) {
84 IEffectModelRelease(model_, IS_DIRECTLY_CALL);
85 }
86 }
87
88 /**
89 * @tc.number: SUB_Driver_Audio_EffectControl_0100
90 * @tc.name: HdfAudioEffectProcess001
91 * @tc.desc: Verify the EffectControlEffectProcess function when the input parameter is invalid.
92 * @tc.type: FUNC
93 * @tc.require: I6I658
94 */
HWTEST_F(EffectControlTest, HdfAudioEffectProcess001, TestSize.Level1)95 HWTEST_F(EffectControlTest, HdfAudioEffectProcess001, TestSize.Level1)
96 {
97 struct AudioEffectBuffer input = {0};
98 struct AudioEffectBuffer output = {0};
99
100 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, controller_->EffectProcess(nullptr, &input, &output));
101 EXPECT_EQ(HDF_ERR_INVALID_PARAM, controller_->EffectProcess(controller_, nullptr, &output));
102 EXPECT_EQ(HDF_ERR_INVALID_PARAM, controller_->EffectProcess(controller_, &input, nullptr));
103 }
104
105 /**
106 * @tc.number: SUB_Driver_Audio_EffectControl_0200
107 * @tc.name: HdfAudioEffectProcess002
108 * @tc.desc: Verify the EffectControlEffectProcess function.
109 * @tc.type: FUNC
110 * @tc.require: I6I658
111 */
HWTEST_F(EffectControlTest, HdfAudioEffectProcess002, TestSize.Level1)112 HWTEST_F(EffectControlTest, HdfAudioEffectProcess002, TestSize.Level1)
113 {
114 struct AudioEffectBuffer input = {0};
115 struct AudioEffectBuffer output = {0};
116
117 int32_t ret = controller_->EffectProcess(controller_, &input, &output);
118 EXPECT_EQ(ret, HDF_SUCCESS);
119 }
120
121 /**
122 * @tc.number: SUB_Driver_Audio_EffectControl_0300
123 * @tc.name: HdfAudioEffectProcess003
124 * @tc.desc: Verify the value of EffectControlEffectProcess function's datatag.
125 * @tc.type: FUNC
126 * @tc.require: I6I658
127 */
HWTEST_F(EffectControlTest, HdfAudioEffectProcess003, TestSize.Level1)128 HWTEST_F(EffectControlTest, HdfAudioEffectProcess003, TestSize.Level1)
129 {
130 struct AudioEffectBuffer input = {0};
131 struct AudioEffectBuffer output = {0};
132
133 int32_t ret = controller_->EffectProcess(controller_, &input, &output);
134 EXPECT_EQ(ret, HDF_SUCCESS);
135
136 int tag = output.datatag;
137 if (tag == 0 || tag == 1 || tag == 2 || tag == 4 || tag == 8)
138 {
139 EXPECT_TRUE(true);
140 } else {
141 EXPECT_TRUE(false);
142 }
143 }
144
145 /**
146 * @tc.number: SUB_Driver_Audio_EffectControl_0400
147 * @tc.name: HdfAudioSendCommand001
148 * @tc.desc: Verify the EffectControlSendCommand function when the input parameter is invalid.
149 * @tc.type: FUNC
150 * @tc.require: I6I658
151 */
HWTEST_F(EffectControlTest, HdfAudioSendCommand001, TestSize.Level1)152 HWTEST_F(EffectControlTest, HdfAudioSendCommand001, TestSize.Level1)
153 {
154 int8_t input[SEND_COMMAND_LEN] = {0};
155 int8_t output[GET_BUFFER_LEN] = {0};
156 uint32_t replyLen = GET_BUFFER_LEN;
157
158 int32_t ret = controller_->SendCommand(nullptr, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
159 input, SEND_COMMAND_LEN, output, &replyLen);
160 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, ret);
161
162 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
163 nullptr, SEND_COMMAND_LEN, output, &replyLen);
164 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
165
166 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
167 input, SEND_COMMAND_LEN, nullptr, &replyLen);
168 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
169
170 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
171 input, SEND_COMMAND_LEN, output, nullptr);
172 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
173
174 ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INVALID_LARGE,
175 input, SEND_COMMAND_LEN, nullptr, &replyLen);
176 EXPECT_EQ(HDF_ERR_INVALID_PARAM, ret);
177 }
178
179 /**
180 * @tc.number: SUB_Driver_Audio_EffectControl_0500
181 * @tc.name: HdfAudioSendCommandInit001
182 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_INIT_CONTOLLER.
183 * @tc.type: FUNC
184 * @tc.require: I6I658
185 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandInit001, TestSize.Level1)186 HWTEST_F(EffectControlTest, HdfAudioSendCommandInit001, TestSize.Level1)
187 {
188 int8_t input[SEND_COMMAND_LEN] = {0};
189 int8_t output[GET_BUFFER_LEN] = {0};
190 uint32_t replyLen = GET_BUFFER_LEN;
191
192 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_INIT_CONTOLLER,
193 input, SEND_COMMAND_LEN, output, &replyLen);
194 EXPECT_EQ(ret, HDF_SUCCESS);
195 }
196
197 /**
198 * @tc.number: SUB_Driver_Audio_EffectControl_0600
199 * @tc.name: HdfAudioSendCommandSetConf001
200 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_SET_CONFIG.
201 * @tc.type: FUNC
202 * @tc.require: I6I658
203 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandSetConf001, TestSize.Level1)204 HWTEST_F(EffectControlTest, HdfAudioSendCommandSetConf001, TestSize.Level1)
205 {
206 int8_t input[SEND_COMMAND_LEN] = {0};
207 int8_t output[GET_BUFFER_LEN] = {0};
208 uint32_t replyLen = GET_BUFFER_LEN;
209
210 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_CONFIG,
211 input, SEND_COMMAND_LEN, output, &replyLen);
212 EXPECT_EQ(ret, HDF_SUCCESS);
213 }
214
215 /**
216 * @tc.number: SUB_Driver_Audio_EffectControl_0700
217 * @tc.name: HdfAudioSendCommandGetConf001
218 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_GET_CONFIG.
219 * @tc.type: FUNC
220 * @tc.require: I6I658
221 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandGetConf001, TestSize.Level1)222 HWTEST_F(EffectControlTest, HdfAudioSendCommandGetConf001, TestSize.Level1)
223 {
224 int8_t input[SEND_COMMAND_LEN] = {0};
225 int8_t output[GET_BUFFER_LEN] = {0};
226 uint32_t replyLen = GET_BUFFER_LEN;
227
228 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_CONFIG,
229 input, SEND_COMMAND_LEN, output, &replyLen);
230 EXPECT_EQ(ret, HDF_SUCCESS);
231 }
232
233 /**
234 * @tc.number: SUB_Driver_Audio_EffectControl_0800
235 * @tc.name: HdfAudioSendCommandRest001
236 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_RESET.
237 * @tc.type: FUNC
238 * @tc.require: I6I658
239 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandRest001, TestSize.Level1)240 HWTEST_F(EffectControlTest, HdfAudioSendCommandRest001, TestSize.Level1)
241 {
242 int8_t input[SEND_COMMAND_LEN] = {0};
243 int8_t output[GET_BUFFER_LEN] = {0};
244 uint32_t replyLen = GET_BUFFER_LEN;
245
246 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_RESET,
247 input, SEND_COMMAND_LEN, output, &replyLen);
248 EXPECT_EQ(ret, HDF_SUCCESS);
249 }
250
251 /**
252 * @tc.number: SUB_Driver_Audio_EffectControl_0900
253 * @tc.name: HdfAudioSendCommandEnable001
254 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_ENABLE.
255 * @tc.type: FUNC
256 * @tc.require: I6I658
257 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandEnable001, TestSize.Level1)258 HWTEST_F(EffectControlTest, HdfAudioSendCommandEnable001, TestSize.Level1)
259 {
260 int8_t input[SEND_COMMAND_LEN] = {0};
261 int8_t output[GET_BUFFER_LEN] = {0};
262 uint32_t replyLen = GET_BUFFER_LEN;
263
264 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_ENABLE,
265 input, SEND_COMMAND_LEN, output, &replyLen);
266 EXPECT_EQ(ret, HDF_SUCCESS);
267 }
268
269 /**
270 * @tc.number: SUB_Driver_Audio_EffectControl_1000
271 * @tc.name: HdfAudioSendCommandDisable001
272 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_DISABLE.
273 * @tc.type: FUNC
274 * @tc.require: I6I658
275 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandDisable001, TestSize.Level1)276 HWTEST_F(EffectControlTest, HdfAudioSendCommandDisable001, TestSize.Level1)
277 {
278 int8_t input[SEND_COMMAND_LEN] = {0};
279 int8_t output[GET_BUFFER_LEN] = {0};
280 uint32_t replyLen = GET_BUFFER_LEN;
281 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_DISABLE,
282 input, SEND_COMMAND_LEN, output, &replyLen);
283 EXPECT_EQ(ret, HDF_SUCCESS);
284 }
285
286 /**
287 * @tc.number: SUB_Driver_Audio_EffectControl_1100
288 * @tc.name: HdfAudioSendCommandSetParam001
289 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_SET_PARAM.
290 * @tc.type: FUNC
291 * @tc.require: I6I658
292 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam001, TestSize.Level1)293 HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam001, TestSize.Level1)
294 {
295 int8_t input[SEND_COMMAND_LEN] = {0};
296 int8_t output[GET_BUFFER_LEN] = {0};
297 uint32_t replyLen = GET_BUFFER_LEN;
298
299 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM,
300 input, SEND_COMMAND_LEN, output, &replyLen);
301 EXPECT_EQ(ret, HDF_SUCCESS);
302 }
303
304 /**
305 * @tc.number: SUB_Driver_Audio_EffectControl_1700
306 * @tc.name: HdfAudioSendCommandSetParam002
307 * @tc.desc: Verify the EffectControlSendCommand function when distribute volume parameters.
308 * @tc.type: FUNC
309 * @tc.require: I6I658
310 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam002, TestSize.Level1)311 HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam002, TestSize.Level1)
312 {
313 int8_t input[SEND_COMMAND_LEN] = {7, 0};
314 int8_t output[GET_BUFFER_LEN] = {0};
315 uint32_t replyLen = GET_BUFFER_LEN;
316
317 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM,
318 input, SEND_COMMAND_LEN, output, &replyLen);
319 EXPECT_EQ(ret, HDF_SUCCESS);
320 }
321
322 /**
323 * @tc.number: SUB_Driver_Audio_EffectControl_1800
324 * @tc.name: HdfAudioSendCommandSetParam003
325 * @tc.desc: Verify the EffectControlSendCommand function when distribute rotating screen parameters.
326 * @tc.type: FUNC
327 * @tc.require: I6I658
328 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam003, TestSize.Level1)329 HWTEST_F(EffectControlTest, HdfAudioSendCommandSetParam003, TestSize.Level1)
330 {
331 int8_t input[SEND_COMMAND_LEN] = {8, 0};
332 int8_t output[GET_BUFFER_LEN] = {0};
333 uint32_t replyLen = GET_BUFFER_LEN;
334
335 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_SET_PARAM,
336 input, SEND_COMMAND_LEN, output, &replyLen);
337 EXPECT_EQ(ret, HDF_SUCCESS);
338 }
339
340 /**
341 * @tc.number: SUB_Driver_Audio_EffectControl_1200
342 * @tc.name: HdfAudioSendCommandGetParam001
343 * @tc.desc: Verify the EffectControlSendCommand function when cmdId is AUDIO_EFFECT_COMMAND_GET_PARAM.
344 * @tc.type: FUNC
345 * @tc.require: I6I658
346 */
HWTEST_F(EffectControlTest, HdfAudioSendCommandGetParam001, TestSize.Level1)347 HWTEST_F(EffectControlTest, HdfAudioSendCommandGetParam001, TestSize.Level1)
348 {
349 int8_t input[SEND_COMMAND_LEN] = {0};
350 int8_t output[GET_BUFFER_LEN] = {0};
351 uint32_t replyLen = GET_BUFFER_LEN;
352
353 int32_t ret = controller_->SendCommand(controller_, AUDIO_EFFECT_COMMAND_GET_PARAM,
354 input, SEND_COMMAND_LEN, output, &replyLen);
355 EXPECT_EQ(ret, HDF_SUCCESS);
356 }
357
358 /**
359 * @tc.number: SUB_Driver_Audio_EffectControl_1300
360 * @tc.name: HdfAudioGetDescriptor001
361 * @tc.desc: Verify the EffectGetOwnDescriptor function when the input parameter is invalid.
362 * @tc.type: FUNC
363 * @tc.require: I6I658
364 */
HWTEST_F(EffectControlTest, HdfAudioGetDescriptor001, TestSize.Level1)365 HWTEST_F(EffectControlTest, HdfAudioGetDescriptor001, TestSize.Level1)
366 {
367 struct EffectControllerDescriptor desc;
368
369 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, controller_->GetEffectDescriptor(nullptr, &desc));
370 EXPECT_EQ(HDF_ERR_INVALID_PARAM, controller_->GetEffectDescriptor(controller_, nullptr));
371 }
372
373 /**
374 * @tc.number: SUB_Driver_Audio_EffectControl_1400
375 * @tc.name: HdfAudioGetDescriptor002
376 * @tc.desc: Verify the EffectGetOwnDescriptor function.
377 * @tc.type: FUNC
378 * @tc.require: I6I658
379 */
HWTEST_F(EffectControlTest, HdfAudioGetDescriptor002, TestSize.Level1)380 HWTEST_F(EffectControlTest, HdfAudioGetDescriptor002, TestSize.Level1)
381 {
382 struct EffectControllerDescriptor desc;
383 int32_t ret = controller_->GetEffectDescriptor(controller_, &desc);
384 ASSERT_EQ(ret, HDF_SUCCESS);
385 EXPECT_STREQ(desc.effectId, effectId_);
386 EXPECT_STREQ(desc.effectName, "mock_effect");
387 EXPECT_STREQ(desc.libName, libName_);
388 EXPECT_STREQ(desc.supplier, "mock");
389 EffectControllerReleaseDesc(&desc);
390 }
391
392
393 /**
394 * @tc.number: SUB_Driver_Audio_EffectControl_1500
395 * @tc.name: HdfAudioEffectReverse001
396 * @tc.desc: Verify the EffectControlEffectReverse function when the input parameter is invalid.
397 * @tc.type: FUNC
398 * @tc.require: I7ASKC
399 */
HWTEST_F(EffectControlTest, HdfAudioEffectReverse001, TestSize.Level1)400 HWTEST_F(EffectControlTest, HdfAudioEffectReverse001, TestSize.Level1)
401 {
402 struct AudioEffectBuffer input = {0};
403 struct AudioEffectBuffer output = {0};
404
405 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, controller_->EffectReverse(nullptr, &input, &output));
406 EXPECT_EQ(HDF_ERR_INVALID_PARAM, controller_->EffectReverse(controller_, nullptr, &output));
407 EXPECT_EQ(HDF_ERR_INVALID_PARAM, controller_->EffectReverse(controller_, &input, nullptr));
408 }
409
410 /**
411 * @tc.number: SUB_Driver_Audio_EffectControl_1600
412 * @tc.name: HdfAudioEffectReverse002
413 * @tc.desc: Verify the EffectControlEffectReverse function.
414 * @tc.type: FUNC
415 * @tc.require: I7ASKC
416 */
HWTEST_F(EffectControlTest, HdfAudioEffectReverse002, TestSize.Level1)417 HWTEST_F(EffectControlTest, HdfAudioEffectReverse002, TestSize.Level1)
418 {
419 struct AudioEffectBuffer input = {0};
420 struct AudioEffectBuffer output = {0};
421
422 int32_t ret = controller_->EffectReverse(controller_, &input, &output);
423 EXPECT_EQ(ret, HDF_SUCCESS);
424 }
425 } // end of namespace
426