1 /*
2 * Copyright (c) 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 <iostream>
17 #include <thread>
18 #include <gtest/gtest.h>
19 #include "gmock/gmock.h"
20 #include "audio_errors.h"
21 #include "offline_audio_effect_manager.h"
22 #include "offline_audio_effect_server_chain.h"
23 #include "offline_audio_effect_chain_impl.h"
24 #include "offline_stream_in_client.h"
25 #include "audio_stream_info.h"
26 #include "audio_shared_memory.h"
27 #include "audio_log.h"
28 #include "v1_0/effect_types.h"
29 #include "v1_0/ieffect_control.h"
30 #include "v1_0/ieffect_model.h"
31 #include "audio_utils.h"
32
33 using namespace testing::ext;
34 using namespace testing;
35 using namespace std;
36 namespace OHOS {
37 namespace AudioStandard {
38 namespace {
39 const std::string INVALID_EFFECT_NAME = "0d000721";
40
41 AudioStreamInfo NORMAL_STREAM_INFO(
42 AudioSamplingRate::SAMPLE_RATE_48000, AudioEncodingType::ENCODING_PCM,
43 AudioSampleFormat::SAMPLE_S16LE, AudioChannel::STEREO, AudioChannelLayout::CH_LAYOUT_STEREO);
44 }
45 class IpcOfflineStreamMock : public IIpcOfflineStream {
46 public:
47 MOCK_METHOD(int32_t, CreateOfflineEffectChain, (const std::string &chainName));
48 MOCK_METHOD(int32_t, ConfigureOfflineEffectChain, (const AudioStreamInfo& inInfo, const AudioStreamInfo& outInfo));
49 MOCK_METHOD(int32_t, SetParamOfflineEffectChain, (const std::vector<uint8_t>& param));
50 MOCK_METHOD(int32_t, PrepareOfflineEffectChain, (shared_ptr<AudioSharedMemory>& inBuffer,
51 shared_ptr<AudioSharedMemory>& outBuffer));
52 MOCK_METHOD(int32_t, ProcessOfflineEffectChain, (uint32_t inSize, uint32_t outSize));
53 MOCK_METHOD(int32_t, ReleaseOfflineEffectChain, ());
54 MOCK_METHOD(sptr<IRemoteObject>, AsObject, ());
55 };
56 class OfflineAudioEffectManagerUnitTest : public testing::Test {
57 public:
58 static void SetUpTestCase(void);
59 static void TearDownTestCase(void);
60 void SetUp();
61 void TearDown();
62 };
63
SetUpTestCase(void)64 void OfflineAudioEffectManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)65 void OfflineAudioEffectManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)66 void OfflineAudioEffectManagerUnitTest::SetUp(void) {}
TearDown(void)67 void OfflineAudioEffectManagerUnitTest::TearDown(void) {}
68
69 class OfflineAudioEffectChainUnitTest : public testing::Test {
70 public:
71 static void SetUpTestCase(void);
72 static void TearDownTestCase(void);
73 void SetUp();
74 void TearDown();
75 protected:
76 shared_ptr<OfflineAudioEffectChain> chain_ = nullptr;
77 };
78
79 shared_ptr<OfflineAudioEffectManager> g_manager = nullptr;
80 string g_normalName = "";
81
SetUpTestCase(void)82 void OfflineAudioEffectChainUnitTest::SetUpTestCase(void)
83 {
84 g_manager = make_shared<OfflineAudioEffectManager>();
85 vector<string> names;
86 names = g_manager->GetOfflineAudioEffectChains();
87 if (names.size() > 0) {
88 g_normalName = names[names.size() - 1];
89 }
90 }
91
CreateOfflineAudioEffectChainMock(const std::string & chainName)92 unique_ptr<OfflineAudioEffectChain> CreateOfflineAudioEffectChainMock(
93 const std::string &chainName)
94 {
95 sptr<IpcOfflineStreamMock> mockProxy = new IpcOfflineStreamMock();
96 EXPECT_CALL(*mockProxy, PrepareOfflineEffectChain(_, _)).WillOnce(DoAll(
97 SetArgReferee<0>(AudioSharedMemory::CreateFormLocal(1, "testEffect")),
98 SetArgReferee<1>(AudioSharedMemory::CreateFormLocal(1, "testEffect")),
99 Return(0)
100 ));
101 unique_ptr<OfflineAudioEffectChainImpl> chain = std::make_unique<OfflineAudioEffectChainImpl>();
102 chain->chainName_ = chainName;
103 chain->offlineStreamInClient_ = make_shared<OfflineStreamInClient>(mockProxy);
104 int32_t ret = chain->CreateEffectChain();
105 CHECK_AND_RETURN_RET_LOG(ret == SUCCESS, nullptr, "create OfflineEffectChain failed, errcode is %{public}d", ret);
106 return chain;
107 }
108
EffectProcess(struct IEffectControl * self,const struct AudioEffectBuffer * input,struct AudioEffectBuffer * output)109 int32_t EffectProcess(struct IEffectControl *self, const struct AudioEffectBuffer* input,
110 struct AudioEffectBuffer* output)
111 {
112 return SUCCESS;
113 }
114
SendCommand(struct IEffectControl * self,uint32_t cmdId,const int8_t * cmdData,uint32_t cmdDataLen,int8_t * replyData,uint32_t * replyDataLen)115 int32_t SendCommand(struct IEffectControl *self, uint32_t cmdId, const int8_t* cmdData, uint32_t cmdDataLen,
116 int8_t* replyData, uint32_t* replyDataLen)
117 {
118 return SUCCESS;
119 }
120
GetEffectDescriptor(struct IEffectControl * self,struct EffectControllerDescriptor * desc)121 int32_t GetEffectDescriptor(struct IEffectControl *self, struct EffectControllerDescriptor* desc)
122 {
123 return SUCCESS;
124 }
125
EffectReverse(struct IEffectControl * self,const struct AudioEffectBuffer * input,struct AudioEffectBuffer * output)126 int32_t EffectReverse(struct IEffectControl *self, const struct AudioEffectBuffer* input,
127 struct AudioEffectBuffer* output)
128 {
129 return SUCCESS;
130 }
131
GetVersion(struct IEffectControl * self,uint32_t * majorVer,uint32_t * minorVer)132 int32_t GetVersion(struct IEffectControl *self, uint32_t* majorVer, uint32_t* minorVer)
133 {
134 return SUCCESS;
135 }
136
IsSupplyEffectLibs(struct IEffectModel * self,bool * supply)137 int32_t IsSupplyEffectLibs(struct IEffectModel *self, bool* supply)
138 {
139 return SUCCESS;
140 }
141
GetAllEffectDescriptors(struct IEffectModel * self,struct EffectControllerDescriptor * descs,uint32_t * descsLen)142 int32_t GetAllEffectDescriptors(struct IEffectModel *self, struct EffectControllerDescriptor* descs,
143 uint32_t* descsLen)
144 {
145 return SUCCESS;
146 }
147
CreateEffectController(struct IEffectModel * self,const struct EffectInfo * info,struct IEffectControl ** contoller,struct ControllerId * id)148 int32_t CreateEffectController(struct IEffectModel *self, const struct EffectInfo* info,
149 struct IEffectControl** contoller, struct ControllerId* id)
150 {
151 return SUCCESS;
152 }
153
DestroyEffectController(struct IEffectModel * self,const struct ControllerId * id)154 int32_t DestroyEffectController(struct IEffectModel *self, const struct ControllerId* id)
155 {
156 return SUCCESS;
157 }
158
GetEffectDescriptor(struct IEffectModel * self,const char * effectId,struct EffectControllerDescriptor * desc)159 int32_t GetEffectDescriptor(struct IEffectModel *self, const char* effectId,
160 struct EffectControllerDescriptor* desc)
161 {
162 return SUCCESS;
163 }
164
GetVersion(struct IEffectModel * self,uint32_t * majorVer,uint32_t * minorVer)165 int32_t GetVersion(struct IEffectModel *self, uint32_t* majorVer, uint32_t* minorVer)
166 {
167 return SUCCESS;
168 }
169
TearDownTestCase(void)170 void OfflineAudioEffectChainUnitTest::TearDownTestCase(void)
171 {
172 g_manager = nullptr;
173 }
174
SetUp(void)175 void OfflineAudioEffectChainUnitTest::SetUp(void)
176 {
177 chain_ = CreateOfflineAudioEffectChainMock(g_normalName);
178 }
179
TearDown(void)180 void OfflineAudioEffectChainUnitTest::TearDown(void)
181 {
182 if (chain_ != nullptr) {
183 chain_->Release();
184 chain_ = nullptr;
185 }
186 }
187
188 class OfflineAudioEffectServerChainUnitTest : public testing::Test {
189 public:
190 static void SetUpTestCase(void);
191 static void TearDownTestCase(void);
192 void SetUp();
193 void TearDown();
194 };
SetUpTestCase(void)195 void OfflineAudioEffectServerChainUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)196 void OfflineAudioEffectServerChainUnitTest::TearDownTestCase(void) {}
SetUp(void)197 void OfflineAudioEffectServerChainUnitTest::SetUp(void) {}
TearDown(void)198 void OfflineAudioEffectServerChainUnitTest::TearDown(void) {}
199 /**
200 * @tc.name : Test GetOfflineAudioEffectChains API
201 * @tc.type : FUNC
202 * @tc.number: OfflineAudioEffectManager_001
203 * @tc.desc : Test OfflineAudioEffectManager interface.
204 */
205 HWTEST(OfflineAudioEffectManagerUnitTest, OfflineAudioEffectManager_001, TestSize.Level0)
206 {
207 auto manager = make_shared<OfflineAudioEffectManager>();
208 EXPECT_NE(nullptr, manager);
209 EXPECT_GE(manager->GetOfflineAudioEffectChains().size(), 0);
210 }
211
212 /**
213 * @tc.name : Test CreateOfflineAudioEffectChain API
214 * @tc.type : FUNC
215 * @tc.number: OfflineAudioEffectManager_002
216 * @tc.desc : Test OfflineAudioEffectManager interface.
217 */
218 HWTEST(OfflineAudioEffectManagerUnitTest, OfflineAudioEffectManager_002, TestSize.Level0)
219 {
220 auto chain = CreateOfflineAudioEffectChainMock(g_normalName);
221 EXPECT_NE(nullptr, chain);
222 EXPECT_EQ(SUCCESS, chain->Prepare());
223 }
224
225 /**
226 * @tc.name : Test OfflineAudioEffectChain API
227 * @tc.type : FUNC
228 * @tc.number: OfflineAudioEffectChain_001
229 * @tc.desc : Test OfflineAudioEffectChain interface.
230 */
231 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_001, TestSize.Level1)
232 {
233 int32_t ret = chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO);
234 EXPECT_EQ(SUCCESS, ret);
235 EXPECT_EQ(SUCCESS, chain_->Prepare());
236 }
237
238 /**
239 * @tc.name : Test OfflineAudioEffectChain API
240 * @tc.type : FUNC
241 * @tc.number: OfflineAudioEffectChain_002
242 * @tc.desc : Test OfflineAudioEffectChain interface.
243 */
244 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_002, TestSize.Level1)
245 {
246 EXPECT_EQ(SUCCESS, chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO));
247 EXPECT_EQ(SUCCESS, chain_->Prepare());
248 }
249
250 /**
251 * @tc.name : Test OfflineAudioEffectChain API
252 * @tc.type : FUNC
253 * @tc.number: OfflineAudioEffectChain_003
254 * @tc.desc : Test OfflineAudioEffectChain interface.
255 */
256 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_003, TestSize.Level1)
257 {
258 uint32_t inSize = 0;
259 uint32_t outSize = 0;
260 EXPECT_EQ(SUCCESS, chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO));
261 EXPECT_EQ(SUCCESS, chain_->Prepare());
262 EXPECT_EQ(SUCCESS, chain_->GetEffectBufferSize(inSize, outSize));
263 EXPECT_GT(inSize, 0);
264 EXPECT_GT(outSize, 0);
265 uint8_t *inBuffer = new uint8_t[inSize];
266 uint8_t *outBuffer = new uint8_t[outSize];
267 for (uint32_t i = 0; i < inSize; i++) {
268 inBuffer[i] = 1;
269 }
270 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(nullptr, inSize, outBuffer, outSize));
271 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize + 1, outBuffer, outSize));
272 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize, nullptr, outSize));
273 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize, outBuffer, outSize + 1));
274 delete []inBuffer;
275 delete []outBuffer;
276 }
277
278 /**
279 * @tc.name : Test OfflineAudioEffectChain API
280 * @tc.type : FUNC
281 * @tc.number: OfflineAudioEffectChain_004
282 * @tc.desc : Test OfflineAudioEffectChain interface.
283 */
284 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_004, TestSize.Level1)
285 {
286 std::vector<uint8_t> param(0);
287 int32_t ret = chain_->SetParam(param);
288 EXPECT_EQ(SUCCESS, ret);
289 EXPECT_EQ(SUCCESS, chain_->Prepare());
290 }
291
292 HWTEST_F(OfflineAudioEffectServerChainUnitTest, Create_001, TestSize.Level1)
293 {
294 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
295 std::make_shared<OfflineAudioEffectServerChain>("test");
296 IEffectControl *mockControl = new IEffectControl();
297 mockControl->EffectProcess = EffectProcess;
298 mockControl->SendCommand = SendCommand;
299 mockControl->GetEffectDescriptor = GetEffectDescriptor;
300 mockControl->EffectReverse = EffectReverse;
301 mockControl->GetVersion = GetVersion;
302 serverChain->controller_=mockControl;
303 int32_t ret = serverChain->Create();
304 EXPECT_EQ(ret, ERROR);
305 }
306
307 HWTEST_F(OfflineAudioEffectServerChainUnitTest, SetConfig_001, TestSize.Level1)
308 {
309 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
310 std::make_shared<OfflineAudioEffectServerChain>("test");
311
312 AudioStreamInfo inInfo;
313 inInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
314 inInfo.encoding = AudioEncodingType::ENCODING_PCM;
315 inInfo.format = AudioSampleFormat::SAMPLE_S16LE;
316 inInfo.channels = AudioChannel::MONO;
317 AudioStreamInfo outInfo;
318 outInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
319 outInfo.encoding = AudioEncodingType::ENCODING_PCM;
320 outInfo.format = AudioSampleFormat::SAMPLE_S16LE;
321 outInfo.channels = AudioChannel::MONO;
322
323 int32_t ret = serverChain->SetConfig(inInfo, outInfo);
324 EXPECT_EQ(ret, ERROR);
325 IEffectControl *mockControl = new IEffectControl();
326 mockControl->EffectProcess = EffectProcess;
327 mockControl->SendCommand = SendCommand;
328 mockControl->GetEffectDescriptor = GetEffectDescriptor;
329 mockControl->EffectReverse = EffectReverse;
330 mockControl->GetVersion = GetVersion;
331 serverChain->controller_=mockControl;
332 ret = serverChain->SetConfig(inInfo, outInfo);
333 EXPECT_EQ(ret, SUCCESS);
334 }
335
336 HWTEST_F(OfflineAudioEffectServerChainUnitTest, SetParam_001, TestSize.Level1)
337 {
338 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
339 std::make_shared<OfflineAudioEffectServerChain>("test");
340 std::vector<uint8_t> param(0);
341
342 int32_t ret = serverChain->SetParam(param);
343 EXPECT_EQ(ret, ERROR);
344 IEffectControl *mockControl = new IEffectControl();
345 mockControl->EffectProcess = EffectProcess;
346 mockControl->SendCommand = SendCommand;
347 mockControl->GetEffectDescriptor = GetEffectDescriptor;
348 mockControl->EffectReverse = EffectReverse;
349 mockControl->GetVersion = GetVersion;
350 serverChain->controller_=mockControl;
351 ret = serverChain->SetParam(param);
352 EXPECT_EQ(ret, SUCCESS);
353 }
354
355 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_001, TestSize.Level1)
356 {
357 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
358 std::make_shared<OfflineAudioEffectServerChain>("test");
359 uint32_t inBufferSize;
360 uint32_t outBufferSize;
361 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
362 EXPECT_EQ(ret, ERROR);
363 }
364
365 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_002, TestSize.Level1)
366 {
367 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
368 std::make_shared<OfflineAudioEffectServerChain>("test");
369 serverChain->inBufferSize_= 1;
370 uint32_t inBufferSize;
371 uint32_t outBufferSize;
372 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
373 EXPECT_EQ(ret, ERROR);
374 }
375
376 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_003, TestSize.Level1)
377 {
378 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
379 std::make_shared<OfflineAudioEffectServerChain>("test");
380 serverChain->inBufferSize_ = 1;
381 serverChain->outBufferSize_ = 1;
382 uint32_t inBufferSize;
383 uint32_t outBufferSize;
384 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
385 EXPECT_EQ(ret, SUCCESS);
386 }
387
388 HWTEST_F(OfflineAudioEffectServerChainUnitTest, Release_001, TestSize.Level1)
389 {
390 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
391 std::make_shared<OfflineAudioEffectServerChain>("test");
392
393 IEffectControl *mockControl = new IEffectControl();
394 mockControl->EffectProcess = EffectProcess;
395 mockControl->SendCommand = SendCommand;
396 mockControl->GetEffectDescriptor = GetEffectDescriptor;
397 mockControl->EffectReverse = EffectReverse;
398 mockControl->GetVersion = GetVersion;
399 serverChain->controller_=mockControl;
400 int32_t ret = serverChain->Release();
401 EXPECT_EQ(ret, ERROR);
402 }
403 } // namespace AudioStandard
404 } // namespace OHOS
405