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