1 /*
2 * Copyright (c) 2023-2025 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 "audio_speed.h"
18 #include "audio_errors.h"
19
20 using namespace testing::ext;
21 using namespace std;
22 namespace OHOS {
23 namespace AudioStandard {
24
25 class AudioSpeedUnitTest : public testing::Test {
26 public:
27 static void SetUpTestCase(void);
28 static void TearDownTestCase(void);
29 void SetUp();
30 void TearDown();
31 };
32
SetUpTestCase(void)33 void AudioSpeedUnitTest::SetUpTestCase(void)
34 {
35 // input testsuit setup step，setup invoked before all testcases
36 }
37
TearDownTestCase(void)38 void AudioSpeedUnitTest::TearDownTestCase(void)
39 {
40 // input testsuit teardown step，teardown invoked after all testcases
41 }
42
SetUp(void)43 void AudioSpeedUnitTest::SetUp(void)
44 {
45 // input testcase setup step，setup invoked before each testcases
46 }
47
TearDown(void)48 void AudioSpeedUnitTest::TearDown(void)
49 {
50 // input testcase teardown step，teardown invoked after each testcases
51 }
52
53 /**
54 * @tc.name : Test AudioSpeed API
55 * @tc.type : FUNC
56 * @tc.number: AudioSpeedUnitTest_001
57 * @tc.desc : Test LoadChangeSpeedFunc.
58 */
59 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_001, TestSize.Level1)
60 {
61 size_t rate = 0;
62 size_t format = SAMPLE_S24LE;
63 size_t channels = 1;
64 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
65 auto result = audioSpeed->LoadChangeSpeedFunc();
66 EXPECT_EQ(result, SUCCESS);
67 }
68
69 /**
70 * @tc.name : Test AudioSpeed API
71 * @tc.type : FUNC
72 * @tc.number: AudioSpeedUnitTest_002.
73 * @tc.desc : Test LoadChangeSpeedFunc.
74 */
75 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_002, TestSize.Level1)
76 {
77 size_t rate = 0;
78 size_t format = SAMPLE_S32LE;
79 size_t channels = 1;
80 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
81 auto result = audioSpeed->LoadChangeSpeedFunc();
82 EXPECT_EQ(result, SUCCESS);
83 }
84
85 /**
86 * @tc.name : Test AudioSpeed API
87 * @tc.type : FUNC
88 * @tc.number: AudioSpeedUnitTest_003.
89 * @tc.desc : Test ChangeSpeedFor24Bit.
90 */
91 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_003, TestSize.Level1)
92 {
93 size_t rate = 0;
94 size_t format = SAMPLE_S32LE;
95 size_t channels = 1;
96
97 uint8_t *buffer = nullptr;
98 int32_t bufferSize = 0;
99 std::unique_ptr<uint8_t []> outBuffer = nullptr;
100 int32_t outBufferSize;
101
102 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
103 auto result = audioSpeed->ChangeSpeedFor24Bit(buffer, bufferSize, outBuffer, outBufferSize);
104 EXPECT_EQ(result, ERR_MEMORY_ALLOC_FAILED);
105 }
106
107 /**
108 * @tc.name : Test AudioSpeed API
109 * @tc.type : FUNC
110 * @tc.number: AudioSpeedUnitTest_004.
111 * @tc.desc : Test ChangeSpeedFor24Bit.
112 */
113 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_004, TestSize.Level1)
114 {
115 size_t rate = 0;
116 size_t format = SAMPLE_S32LE;
117 size_t channels = 1;
118
119 uint8_t *buffer = nullptr;
120 int32_t bufferSize = MAX_SPEED_BUFFER_SIZE + 1;
121 std::unique_ptr<uint8_t []> outBuffer = nullptr;
122 int32_t outBufferSize;
123
124 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
125 auto result = audioSpeed->ChangeSpeedFor24Bit(buffer, bufferSize, outBuffer, outBufferSize);
126 EXPECT_EQ(result, ERR_MEMORY_ALLOC_FAILED);
127 }
128
129 /**
130 * @tc.name : Test AudioSpeed API
131 * @tc.type : FUNC
132 * @tc.number: AudioSpeedUnitTest_004.
133 * @tc.desc : Test ChangeSpeedFor24Bit.
134 */
135 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_005, TestSize.Level1)
136 {
137 size_t rate = 0;
138 size_t format = SAMPLE_S32LE;
139 size_t channels = 1;
140
141 uint8_t *buffer = nullptr;
142 int32_t bufferSize = 1;
143 std::unique_ptr<uint8_t []> outBuffer = nullptr;
144 int32_t outBufferSize = 0;
145
146 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
147 auto result = audioSpeed->ChangeSpeedFor24Bit(buffer, bufferSize, outBuffer, outBufferSize);
148 EXPECT_EQ(result, bufferSize);
149 }
150
151 /**
152 * @tc.name : Test AudioSpeed API
153 * @tc.type : FUNC
154 * @tc.number: AudioSpeedUnitTest_006.
155 * @tc.desc : Test ChangeSpeedFor32Bit.
156 */
157 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_006, TestSize.Level1)
158 {
159 size_t rate = 0;
160 size_t format = SAMPLE_S32LE;
161 size_t channels = 1;
162
163 uint8_t *buffer = nullptr;
164 int32_t bufferSize = 0;
165 std::unique_ptr<uint8_t []> outBuffer = nullptr;
166 int32_t outBufferSize;
167
168 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
169 auto result = audioSpeed->ChangeSpeedFor32Bit(buffer, bufferSize, outBuffer, outBufferSize);
170 EXPECT_EQ(result, ERR_MEMORY_ALLOC_FAILED);
171 }
172
173 /**
174 * @tc.name : Test AudioSpeed API
175 * @tc.type : FUNC
176 * @tc.number: AudioSpeedUnitTest_007.
177 * @tc.desc : Test ChangeSpeedFor32Bit.
178 */
179 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_007, TestSize.Level1)
180 {
181 size_t rate = 0;
182 size_t format = SAMPLE_S32LE;
183 size_t channels = 1;
184
185 uint8_t *buffer = nullptr;
186 int32_t bufferSize = MAX_SPEED_BUFFER_SIZE + 1;
187 std::unique_ptr<uint8_t []> outBuffer = nullptr;
188 int32_t outBufferSize;
189
190 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
191 auto result = audioSpeed->ChangeSpeedFor32Bit(buffer, bufferSize, outBuffer, outBufferSize);
192 EXPECT_EQ(result, ERR_MEMORY_ALLOC_FAILED);
193 }
194
195 /**
196 * @tc.name : Test AudioSpeed API
197 * @tc.type : FUNC
198 * @tc.number: AudioSpeedUnitTest_008.
199 * @tc.desc : Test ChangeSpeedFor32Bit.
200 */
201 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_008, TestSize.Level1)
202 {
203 size_t rate = 0;
204 size_t format = SAMPLE_S32LE;
205 size_t channels = 1;
206
207 uint8_t *buffer = nullptr;
208 int32_t bufferSize = 1;
209 std::unique_ptr<uint8_t []> outBuffer = nullptr;
210 int32_t outBufferSize = 0;
211
212 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
213 auto result = audioSpeed->ChangeSpeedFor32Bit(buffer, bufferSize, outBuffer, outBufferSize);
214 EXPECT_EQ(result, bufferSize);
215 }
216
217 /**
218 * @tc.name : Test AudioSpeed API
219 * @tc.type : FUNC
220 * @tc.number: AudioSpeedUnitTest_009.
221 * @tc.desc : Test ChangeSpeedFor32Bit.
222 */
223 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_009, TestSize.Level1)
224 {
225 size_t rate = 0;
226 size_t format = SAMPLE_F32LE;
227 size_t channels = 1;
228 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
229 auto result = audioSpeed->LoadChangeSpeedFunc();
230 EXPECT_EQ(result, SUCCESS);
231 }
232
233 /**
234 * @tc.name : Test AudioSpeed API
235 * @tc.type : FUNC
236 * @tc.number: AudioSpeedUnitTest_010.
237 * @tc.desc : Test Flush.
238 */
239 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_010, TestSize.Level1)
240 {
241 size_t rate = 0;
242 size_t format = SAMPLE_U8;
243 size_t channels = 1;
244 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
245 auto result = audioSpeed->Flush();
246 EXPECT_EQ(result, SUCCESS);
247 }
248
249 /**
250 * @tc.name : Test AudioSpeed API
251 * @tc.type : FUNC
252 * @tc.number: AudioSpeedUnitTest_011.
253 * @tc.desc : Test Flush.
254 */
255 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_011, TestSize.Level1)
256 {
257 size_t rate = 0;
258 size_t format = SAMPLE_S24LE;
259 size_t channels = 1;
260 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
261 auto result = audioSpeed->Flush();
262 EXPECT_EQ(result, SUCCESS);
263 }
264
265 /**
266 * @tc.name : Test AudioSpeed API
267 * @tc.type : FUNC
268 * @tc.number: AudioSpeedUnitTest_012.
269 * @tc.desc : Test Flush.
270 */
271 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_012, TestSize.Level1)
272 {
273 size_t rate = 0;
274 size_t format = SAMPLE_S32LE;
275 size_t channels = 1;
276 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
277 auto result = audioSpeed->Flush();
278 EXPECT_EQ(result, SUCCESS);
279 }
280
281 /**
282 * @tc.name : Test AudioSpeed API
283 * @tc.type : FUNC
284 * @tc.number: AudioSpeedUnitTest_013.
285 * @tc.desc : Test Flush.
286 */
287 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_013, TestSize.Level1)
288 {
289 size_t rate = 0;
290 size_t format = SAMPLE_F32LE;
291 size_t channels = 1;
292 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
293 auto result = audioSpeed->Flush();
294 EXPECT_EQ(result, SUCCESS);
295 }
296
297 /**
298 * @tc.name : Test AudioSpeed API
299 * @tc.type : FUNC
300 * @tc.number: AudioSpeedUnitTest_014.
301 * @tc.desc : Test Flush.
302 */
303 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_014, TestSize.Level1)
304 {
305 size_t rate = 0;
306 size_t format = SAMPLE_S16LE;
307 size_t channels = 1;
308 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
309 auto result = audioSpeed->Flush();
310 EXPECT_EQ(result, SUCCESS);
311 }
312
313 /**
314 * @tc.name : Test AudioSpeed API
315 * @tc.type : FUNC
316 * @tc.number: AudioSpeedUnitTest_015.
317 * @tc.desc : Test Flush.
318 */
319 HWTEST(AudioSpeedUnitTest, AudioSpeedUnitTest_015, TestSize.Level1)
320 {
321 size_t rate = 0;
322 size_t format = INVALID_WIDTH;
323 size_t channels = 1;
324 auto audioSpeed = std::make_shared<AudioSpeed>(rate, format, channels);
325 auto result = audioSpeed->Flush();
326 EXPECT_EQ(result, SUCCESS);
327 }
328 } // namespace AudioStandard
329 } // namespace OHOS