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
20 #include "audio_errors.h"
21 #include "offline_audio_effect_manager.h"
22 #include "offline_audio_effect_server_chain.h"
23 #include "audio_stream_info.h"
24
25 using namespace testing::ext;
26 using namespace testing;
27 using namespace std;
28 namespace OHOS {
29 namespace AudioStandard {
30 namespace {
31 const std::string INVALID_EFFECT_NAME = "0d000721";
32
33 constexpr AudioStreamInfo NORMAL_STREAM_INFO(
34 AudioSamplingRate::SAMPLE_RATE_48000, AudioEncodingType::ENCODING_PCM,
35 AudioSampleFormat::SAMPLE_S16LE, AudioChannel::STEREO, AudioChannelLayout::CH_LAYOUT_STEREO);
36 }
37 class OfflineAudioEffectManagerUnitTest : public testing::Test {
38 public:
39 static void SetUpTestCase(void);
40 static void TearDownTestCase(void);
41 void SetUp();
42 void TearDown();
43 };
44
SetUpTestCase(void)45 void OfflineAudioEffectManagerUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)46 void OfflineAudioEffectManagerUnitTest::TearDownTestCase(void) {}
SetUp(void)47 void OfflineAudioEffectManagerUnitTest::SetUp(void) {}
TearDown(void)48 void OfflineAudioEffectManagerUnitTest::TearDown(void) {}
49
50 class OfflineAudioEffectChainUnitTest : public testing::Test {
51 public:
52 static void SetUpTestCase(void);
53 static void TearDownTestCase(void);
54 void SetUp();
55 void TearDown();
56 protected:
57 shared_ptr<OfflineAudioEffectChain> chain_ = nullptr;
58 };
59
60 shared_ptr<OfflineAudioEffectManager> g_manager = nullptr;
61 string g_normalName = "";
62
SetUpTestCase(void)63 void OfflineAudioEffectChainUnitTest::SetUpTestCase(void)
64 {
65 g_manager = make_shared<OfflineAudioEffectManager>();
66 vector<string> names;
67 names = g_manager->GetOfflineAudioEffectChains();
68 if (names.size() > 0) {
69 g_normalName = names[names.size() - 1];
70 }
71 }
72
TearDownTestCase(void)73 void OfflineAudioEffectChainUnitTest::TearDownTestCase(void)
74 {
75 g_manager = nullptr;
76 }
77
SetUp(void)78 void OfflineAudioEffectChainUnitTest::SetUp(void)
79 {
80 chain_ = g_manager->CreateOfflineAudioEffectChain(g_normalName);
81 }
82
TearDown(void)83 void OfflineAudioEffectChainUnitTest::TearDown(void)
84 {
85 if (chain_ != nullptr) {
86 chain_->Release();
87 chain_ = nullptr;
88 }
89 }
90
91 class OfflineAudioEffectServerChainUnitTest : public testing::Test {
92 public:
93 static void SetUpTestCase(void);
94 static void TearDownTestCase(void);
95 void SetUp();
96 void TearDown();
97 };
SetUpTestCase(void)98 void OfflineAudioEffectServerChainUnitTest::SetUpTestCase(void) {}
TearDownTestCase(void)99 void OfflineAudioEffectServerChainUnitTest::TearDownTestCase(void) {}
SetUp(void)100 void OfflineAudioEffectServerChainUnitTest::SetUp(void) {}
TearDown(void)101 void OfflineAudioEffectServerChainUnitTest::TearDown(void) {}
102 /**
103 * @tc.name : Test GetOfflineAudioEffectChains API
104 * @tc.type : FUNC
105 * @tc.number: OfflineAudioEffectManager_001
106 * @tc.desc : Test OfflineAudioEffectManager interface.
107 */
108 HWTEST(OfflineAudioEffectManagerUnitTest, OfflineAudioEffectManager_001, TestSize.Level1)
109 {
110 auto manager = make_shared<OfflineAudioEffectManager>();
111 EXPECT_NE(nullptr, manager);
112 EXPECT_GE(manager->GetOfflineAudioEffectChains().size(), 0);
113 }
114
115 /**
116 * @tc.name : Test CreateOfflineAudioEffectChain API
117 * @tc.type : FUNC
118 * @tc.number: OfflineAudioEffectManager_002
119 * @tc.desc : Test OfflineAudioEffectManager interface.
120 */
121 HWTEST(OfflineAudioEffectManagerUnitTest, OfflineAudioEffectManager_002, TestSize.Level1)
122 {
123 auto manager = make_shared<OfflineAudioEffectManager>();
124 auto chain = manager->CreateOfflineAudioEffectChain(g_normalName);
125 if (g_normalName == "") {
126 EXPECT_EQ(nullptr, chain);
127 } else {
128 EXPECT_NE(nullptr, chain);
129 }
130 }
131
132 /**
133 * @tc.name : Test CreateOfflineAudioEffectChain API
134 * @tc.type : FUNC
135 * @tc.number: OfflineAudioEffectManager_003
136 * @tc.desc : Test OfflineAudioEffectManager interface.
137 */
138 HWTEST(OfflineAudioEffectManagerUnitTest, OfflineAudioEffectManager_003, TestSize.Level1)
139 {
140 auto manager = make_shared<OfflineAudioEffectManager>();
141 auto chain = manager->CreateOfflineAudioEffectChain(INVALID_EFFECT_NAME);
142 EXPECT_EQ(nullptr, chain);
143 }
144
145 /**
146 * @tc.name : Test OfflineAudioEffectChain API
147 * @tc.type : FUNC
148 * @tc.number: OfflineAudioEffectChain_001
149 * @tc.desc : Test OfflineAudioEffectChain interface.
150 */
151 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_001, TestSize.Level1)
152 {
153 if (chain_) {
154 int32_t ret = chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO);
155 EXPECT_EQ(SUCCESS, ret);
156 }
157 }
158
159 /**
160 * @tc.name : Test OfflineAudioEffectChain API
161 * @tc.type : FUNC
162 * @tc.number: OfflineAudioEffectChain_002
163 * @tc.desc : Test OfflineAudioEffectChain interface.
164 */
165 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_002, TestSize.Level1)
166 {
167 if (chain_) {
168 EXPECT_EQ(SUCCESS, chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO));
169 EXPECT_EQ(SUCCESS, chain_->Prepare());
170 }
171 }
172
173 /**
174 * @tc.name : Test OfflineAudioEffectChain API
175 * @tc.type : FUNC
176 * @tc.number: OfflineAudioEffectChain_003
177 * @tc.desc : Test OfflineAudioEffectChain interface.
178 */
179 HWTEST_F(OfflineAudioEffectChainUnitTest, OfflineAudioEffectChain_003, TestSize.Level1)
180 {
181 uint32_t inSize = 0;
182 uint32_t outSize = 0;
183 if (chain_) {
184 EXPECT_EQ(SUCCESS, chain_->Configure(NORMAL_STREAM_INFO, NORMAL_STREAM_INFO));
185 EXPECT_EQ(SUCCESS, chain_->Prepare());
186 EXPECT_EQ(SUCCESS, chain_->GetEffectBufferSize(inSize, outSize));
187 EXPECT_GT(inSize, 0);
188 EXPECT_GT(outSize, 0);
189 uint8_t *inBuffer = new uint8_t[inSize];
190 uint8_t *outBuffer = new uint8_t[outSize];
191 for (uint32_t i = 0; i < inSize; i++) {
192 inBuffer[i] = 1;
193 }
194 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(nullptr, inSize, outBuffer, outSize));
195 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize + 1, outBuffer, outSize));
196 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize, nullptr, outSize));
197 EXPECT_EQ(ERR_INVALID_PARAM, chain_->Process(inBuffer, inSize, outBuffer, outSize + 1));
198 EXPECT_NE(SUCCESS, chain_->Process(inBuffer, inSize, outBuffer, outSize));
199 delete []inBuffer;
200 delete []outBuffer;
201 }
202 }
203
204 HWTEST_F(OfflineAudioEffectServerChainUnitTest, Create_001, TestSize.Level1)
205 {
206 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
207 std::make_shared<OfflineAudioEffectServerChain>("test");
208 int32_t ret = serverChain->Create();
209 EXPECT_EQ(ret, ERROR);
210 }
211
212 HWTEST_F(OfflineAudioEffectServerChainUnitTest, SetParam_001, TestSize.Level1)
213 {
214 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
215 std::make_shared<OfflineAudioEffectServerChain>("test");
216
217 AudioStreamInfo inInfo;
218 inInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_44100;
219 inInfo.encoding = AudioEncodingType::ENCODING_PCM;
220 inInfo.format = AudioSampleFormat::SAMPLE_S16LE;
221 inInfo.channels = AudioChannel::MONO;
222 AudioStreamInfo outInfo;
223 outInfo.samplingRate = AudioSamplingRate::SAMPLE_RATE_48000;
224 outInfo.encoding = AudioEncodingType::ENCODING_PCM;
225 outInfo.format = AudioSampleFormat::SAMPLE_S16LE;
226 outInfo.channels = AudioChannel::MONO;
227 int32_t ret = serverChain->SetParam(inInfo, outInfo);
228 EXPECT_EQ(ret, ERROR);
229 }
230
231 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_001, TestSize.Level1)
232 {
233 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
234 std::make_shared<OfflineAudioEffectServerChain>("test");
235 uint32_t inBufferSize;
236 uint32_t outBufferSize;
237 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
238 EXPECT_EQ(ret, ERROR);
239 }
240
241 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_002, TestSize.Level1)
242 {
243 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
244 std::make_shared<OfflineAudioEffectServerChain>("test");
245 serverChain->inBufferSize_= 1;
246 uint32_t inBufferSize;
247 uint32_t outBufferSize;
248 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
249 EXPECT_EQ(ret, ERROR);
250 }
251
252 HWTEST_F(OfflineAudioEffectServerChainUnitTest, GetEffectBufferSize_003, TestSize.Level1)
253 {
254 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
255 std::make_shared<OfflineAudioEffectServerChain>("test");
256 serverChain->inBufferSize_ = 1;
257 serverChain->outBufferSize_ = 1;
258 uint32_t inBufferSize;
259 uint32_t outBufferSize;
260 int32_t ret = serverChain->GetEffectBufferSize(inBufferSize, outBufferSize);
261 EXPECT_EQ(ret, SUCCESS);
262 }
263
264 HWTEST_F(OfflineAudioEffectServerChainUnitTest, Release_001, TestSize.Level1)
265 {
266 std::shared_ptr<OfflineAudioEffectServerChain> serverChain =
267 std::make_shared<OfflineAudioEffectServerChain>("test");
268 int32_t ret = serverChain->Release();
269 EXPECT_EQ(ret, ERROR);
270 }
271 } // namespace AudioStandard
272 } // namespace OHOS
273