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 constexpr uint32_t MAX_DESCRIPTOR_NUM = 20;
29
30 namespace {
31 class EffectModelTest : public testing::Test {
32 public:
33 struct IEffectModel *model_ = nullptr;
34 struct ControllerId controllerId_;
35 char *libName_ = nullptr;
36 char *effectId_ = nullptr;
37 virtual void SetUp();
38 virtual void TearDown();
39 };
40
SetUp()41 void EffectModelTest::SetUp()
42 {
43 // input testcase setup step,setup invoked before each testcases
44 libName_ = strdup("libmock_effect_lib");
45 effectId_ = strdup("aaaabbbb-8888-9999-6666-aabbccdd9966ff");
46 model_ = IEffectModelGet(IS_DIRECTLY_CALL);
47 ASSERT_NE(nullptr, model_);
48 }
49
TearDown()50 void EffectModelTest::TearDown()
51 {
52 // input testcase teardown step,teardown invoked after each testcases
53 if (libName_ != nullptr) {
54 free(libName_);
55 libName_ = nullptr;
56 }
57
58 if (effectId_ != nullptr) {
59 free(effectId_);
60 effectId_ = nullptr;
61 }
62
63 if (model_ != nullptr) {
64 IEffectModelRelease(model_, IS_DIRECTLY_CALL);
65 }
66 }
67
68 /**
69 * @tc.number: SUB_Driver_Audio_EffectModel_0100
70 * @tc.name: HdfAudioIsSupplyEffectLibs001
71 * @tc.desc: Verify the EffectModelIsSupplyEffectLibs function when the input parameter is invalid.
72 * @tc.type: FUNC
73 * @tc.require: I6I658
74 */
HWTEST_F(EffectModelTest, HdfAudioIsSupplyEffectLibs001, TestSize.Level1)75 HWTEST_F(EffectModelTest, HdfAudioIsSupplyEffectLibs001, TestSize.Level1)
76 {
77 bool isSupport = false;
78 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->IsSupplyEffectLibs(nullptr, &isSupport));
79 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->IsSupplyEffectLibs(model_, nullptr));
80 }
81
82 /**
83 * @tc.number: SUB_Driver_Audio_EffectModel_0200
84 * @tc.name: HdfAudioIsSupplyEffectLibs002
85 * @tc.desc: Verify the EffectModelIsSupplyEffectLibs function.
86 * @tc.type: FUNC
87 * @tc.require: I6I658
88 */
HWTEST_F(EffectModelTest, HdfAudioIsSupplyEffectLibs002, TestSize.Level1)89 HWTEST_F(EffectModelTest, HdfAudioIsSupplyEffectLibs002, TestSize.Level1)
90 {
91 bool isSupport = false;
92 int32_t ret = model_->IsSupplyEffectLibs(model_, &isSupport);
93 EXPECT_EQ(ret, HDF_SUCCESS);
94 }
95
96 /**
97 * @tc.number: SUB_Driver_Audio_EffectModel_0300
98 * @tc.name: HdfAudioGetAllEffectDescriptors001
99 * @tc.desc: Verify the EffectModelGetAllEffectDescriptors function when the input parameter is invalid.
100 * @tc.type: FUNC
101 * @tc.require: I6I658
102 */
HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors001, TestSize.Level1)103 HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors001, TestSize.Level1)
104 {
105 uint32_t descsLen = MAX_DESCRIPTOR_NUM;
106 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
107
108 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetAllEffectDescriptors(nullptr, descs, &descsLen));
109 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetAllEffectDescriptors(model_, nullptr, &descsLen));
110 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetAllEffectDescriptors(model_, descs, nullptr));
111 }
112
113 /**
114 * @tc.number: SUB_Driver_Audio_EffectModel_0400
115 * @tc.name: HdfAudioGetAllEffectDescriptors002
116 * @tc.desc: Verify the EffectModelGetAllEffectDescriptors function.
117 * @tc.type: FUNC
118 * @tc.require: I6I658
119 */
HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors002, TestSize.Level1)120 HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors002, TestSize.Level1)
121 {
122 uint32_t descsLen = MAX_DESCRIPTOR_NUM;
123 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
124
125 int32_t ret = model_->GetAllEffectDescriptors(model_, descs, &descsLen);
126 ASSERT_EQ(ret, HDF_SUCCESS);
127 EXPECT_GE(MAX_DESCRIPTOR_NUM, descsLen);
128 }
129
130 /**
131 * @tc.number: SUB_Driver_Audio_EffectModel_0500
132 * @tc.name: HdfAudioGetAllEffectDescriptors003
133 * @tc.desc: Verify the descs of EffectModelGetAllEffectDescriptors function.
134 * @tc.type: FUNC
135 * @tc.require: I6I658
136 */
HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors003, TestSize.Level1)137 HWTEST_F(EffectModelTest, HdfAudioGetAllEffectDescriptors003, TestSize.Level1)
138 {
139 uint32_t descsLen = MAX_DESCRIPTOR_NUM;
140 struct EffectControllerDescriptor descs[MAX_DESCRIPTOR_NUM];
141
142 int32_t ret = model_->GetAllEffectDescriptors(model_, descs, &descsLen);
143 ASSERT_EQ(ret, HDF_SUCCESS);
144 EXPECT_GE(MAX_DESCRIPTOR_NUM, descsLen);
145
146 for (uint32_t i = 0; i < descsLen; i++) {
147 EXPECT_NE(nullptr, descs[i].effectId);
148 }
149
150 EffectControllerReleaseDescs(descs, &descsLen);
151 }
152
153 /**
154 * @tc.number: SUB_Driver_Audio_EffectModel_0600
155 * @tc.name: HdfAudioCreateEffectController001
156 * @tc.desc: Verify the CreateEffectController function when the input parameter is invalid.
157 * @tc.type: FUNC
158 * @tc.require: I6I658
159 */
HWTEST_F(EffectModelTest, HdfAudioCreateEffectController001, TestSize.Level1)160 HWTEST_F(EffectModelTest, HdfAudioCreateEffectController001, TestSize.Level1)
161 {
162 struct EffectInfo info = {
163 .libName = libName_,
164 .effectId = effectId_,
165 .ioDirection = 1,
166 };
167
168 struct IEffectControl *controller = NULL;
169 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->CreateEffectController(nullptr, &info, &controller, &controllerId_));
170 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, nullptr, &controller, &controllerId_));
171 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->CreateEffectController(model_, &info, &controller, nullptr));
172 }
173
174 /**
175 * @tc.number: SUB_Driver_Audio_EffectModel_0700
176 * @tc.name: HdfAudioDestroyEffectController001
177 * @tc.desc: Verify the DestroyEffectController function when the input parameter is invalid.
178 * @tc.type: FUNC
179 * @tc.require: I6I658
180 */
HWTEST_F(EffectModelTest, HdfAudioDestroyEffectController001, TestSize.Level1)181 HWTEST_F(EffectModelTest, HdfAudioDestroyEffectController001, TestSize.Level1)
182 {
183 struct EffectInfo info = {
184 .libName = libName_,
185 .effectId = effectId_,
186 .ioDirection = 1,
187 };
188
189 struct IEffectControl *controller = NULL;
190 ASSERT_EQ(HDF_SUCCESS, model_->CreateEffectController(model_, &info, &controller, &controllerId_));
191 ASSERT_NE(controller, nullptr);
192
193 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->DestroyEffectController(nullptr, &controllerId_));
194 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->DestroyEffectController(model_, nullptr));
195 }
196
197 /**
198 * @tc.number: SUB_Driver_Audio_EffectModel_0800
199 * @tc.name: HdfAudioCreateDestroyController001
200 * @tc.desc: Verify the EffectModelCreateEffectController and EffectModelDestroyEffectController function.
201 * @tc.type: FUNC
202 * @tc.require: I6I658
203 */
HWTEST_F(EffectModelTest, HdfAudioCreateDestroyController001, TestSize.Level1)204 HWTEST_F(EffectModelTest, HdfAudioCreateDestroyController001, TestSize.Level1)
205 {
206 struct EffectInfo info = {
207 .libName = libName_,
208 .effectId = effectId_,
209 .ioDirection = 1,
210 };
211
212 struct IEffectControl *controller = NULL;
213 int32_t ret = model_->CreateEffectController(model_, &info, &controller, &controllerId_);
214 if (ret == HDF_SUCCESS) {
215 ASSERT_NE(controller, nullptr);
216 }
217
218 if (controller != nullptr) {
219 ret = model_->DestroyEffectController(model_, &controllerId_);
220 }
221 }
222
223 /**
224 * @tc.number: SUB_Driver_Audio_EffectModel_0900
225 * @tc.name: HdfAudioGetEffectDescriptor001
226 * @tc.desc: Verify the EffectModelGetEffectDescriptor function when the input parameter is invalid.
227 * @tc.type: FUNC
228 * @tc.require: I6I658
229 */
HWTEST_F(EffectModelTest, HdfAudioGetEffectDescriptor001, TestSize.Level1)230 HWTEST_F(EffectModelTest, HdfAudioGetEffectDescriptor001, TestSize.Level1)
231 {
232 struct EffectControllerDescriptor desc;
233
234 EXPECT_EQ(HDF_ERR_INVALID_OBJECT, model_->GetEffectDescriptor(nullptr, effectId_, &desc));
235 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, nullptr, &desc));
236 EXPECT_EQ(HDF_ERR_INVALID_PARAM, model_->GetEffectDescriptor(model_, effectId_, nullptr));
237 }
238
239 /**
240 * @tc.number: SUB_Driver_Audio_EffectModel_1000
241 * @tc.name: HdfAudioGetEffectDescriptor002
242 * @tc.desc: Verify the EffectModelGetEffectDescriptor function.
243 * @tc.type: FUNC
244 * @tc.require: I6I658
245 */
HWTEST_F(EffectModelTest, HdfAudioGetEffectDescriptor002, TestSize.Level1)246 HWTEST_F(EffectModelTest, HdfAudioGetEffectDescriptor002, TestSize.Level1)
247 {
248 struct EffectControllerDescriptor desc;
249
250 int32_t ret = model_->GetEffectDescriptor(model_, effectId_, &desc);
251 ASSERT_EQ(ret, HDF_SUCCESS);
252 EXPECT_STREQ(desc.effectId, effectId_);
253 EXPECT_STREQ(desc.effectName, "mock_effect");
254 EXPECT_STREQ(desc.libName, libName_);
255 EXPECT_STREQ(desc.supplier, "mock");
256 EffectControllerReleaseDesc(&desc);
257 }
258 } // end of namespace
259