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 "audio_errors.h"
17 #include "audio_log.h"
18 #include "audio_info.h"
19 #include "linear_pos_time_model.h"
20 #include "oh_audio_buffer.h"
21 #include <gtest/gtest.h>
22
23 using namespace testing::ext;
24 namespace OHOS {
25 namespace AudioStandard {
26 std::unique_ptr<LinearPosTimeModel> linearPosTimeModel;
27 std::unique_ptr<AudioSharedMemory> audioSharedMemory;
28 std::shared_ptr<OHAudioBuffer> oHAudioBuffer;
29 const int32_t TEST_NUM = 1000;
30 const int32_t TEST_RET_NUM = 0;
31 const int64_t NANO_COUNT_PER_SECOND = 1000000000;
32 class AudioServiceCommonUnitTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void AudioServiceCommonUnitTest::SetUpTestCase(void)
41 {
42 // input testsuit setup step，setup invoked before all testcases
43 }
44
TearDownTestCase(void)45 void AudioServiceCommonUnitTest::TearDownTestCase(void)
46 {
47 // input testsuit teardown step，teardown invoked after all testcases
48 }
49
SetUp(void)50 void AudioServiceCommonUnitTest::SetUp(void)
51 {
52 // input testcase setup step，setup invoked before each testcases
53 }
54
TearDown(void)55 void AudioServiceCommonUnitTest::TearDown(void)
56 {
57 // input testcase teardown step，teardown invoked after each testcases
58 }
59
60 /**
61 * @tc.name : Test LinearPosTimeModel API
62 * @tc.type : FUNC
63 * @tc.number: LinearPosTimeModel_001
64 * @tc.desc : Test LinearPosTimeModel interface.
65 */
66 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_001, TestSize.Level1)
67 {
68 linearPosTimeModel = std::make_unique<LinearPosTimeModel>();
69
70 uint64_t posInFrame = 20;
71 int64_t invalidTime = -1;
72 int64_t retPos = linearPosTimeModel->GetTimeOfPos(posInFrame);
73 EXPECT_EQ(invalidTime, retPos);
74
75 int32_t sampleRate = -1;
76 bool isConfig = linearPosTimeModel->ConfigSampleRate(sampleRate);
77 EXPECT_EQ(false, isConfig);
78
79 sampleRate = (int32_t)AudioSamplingRate::SAMPLE_RATE_44100;
80 isConfig = linearPosTimeModel->ConfigSampleRate(sampleRate);
81 EXPECT_EQ(true, isConfig);
82
83 isConfig = linearPosTimeModel->ConfigSampleRate(sampleRate);
84 EXPECT_EQ(false, isConfig);
85 }
86
87 /**
88 * @tc.name : Test LinearPosTimeModel API
89 * @tc.type : FUNC
90 * @tc.number: LinearPosTimeModel_002
91 * @tc.desc : Test LinearPosTimeModel interface.
92 */
93 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_002, TestSize.Level1)
94 {
95 int64_t deltaFrame = 0;
96 uint64_t frame = 0;
97 int64_t nanoTime = 0;
98 linearPosTimeModel->ResetFrameStamp(frame, nanoTime);
99
100 uint64_t spanCountInFrame = 2;
101 linearPosTimeModel->SetSpanCount(spanCountInFrame);
102
103 uint64_t posInFrame = 20;
104 int64_t retPos = linearPosTimeModel->GetTimeOfPos(posInFrame);
105
106 deltaFrame = posInFrame - frame;
107 int64_t retPosCal1 = nanoTime + deltaFrame * NANO_COUNT_PER_SECOND / (int64_t)AudioSamplingRate::SAMPLE_RATE_44100;
108 EXPECT_EQ(retPos, retPosCal1);
109
110 frame = 40;
111 nanoTime = 50;
112 linearPosTimeModel->UpdataFrameStamp(frame, nanoTime);
113
114 retPos = linearPosTimeModel->GetTimeOfPos(posInFrame);
115 deltaFrame = frame - posInFrame;
116 int64_t retPosCal2 = nanoTime + deltaFrame * NANO_COUNT_PER_SECOND / (int64_t)AudioSamplingRate::SAMPLE_RATE_44100;
117 EXPECT_NE(retPos, retPosCal2);
118 }
119
120 /**
121 * @tc.name : Test OHAudioBuffer API
122 * @tc.type : FUNC
123 * @tc.number: OHAudioBuffer_001
124 * @tc.desc : Test OHAudioBuffer interface.
125 */
126 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_001, TestSize.Level1)
127 {
128 uint32_t spanSizeInFrame = 1000;
129 uint32_t totalSizeInFrame = spanSizeInFrame - 1;
130 uint32_t byteSizePerFrame = 1000;
131 oHAudioBuffer = OHAudioBuffer::CreateFormLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
132 EXPECT_EQ(nullptr, oHAudioBuffer);
133 }
134
135 /**
136 * @tc.name : Test OHAudioBuffer API
137 * @tc.type : FUNC
138 * @tc.number: OHAudioBuffer_002
139 * @tc.desc : Test OHAudioBuffer interface.
140 */
141 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_002, TestSize.Level1)
142 {
143 uint32_t spanSizeInFrame = 1000;
144 uint32_t totalSizeInFrame = spanSizeInFrame;
145 uint32_t byteSizePerFrame = 1000;
146 oHAudioBuffer = OHAudioBuffer::CreateFormLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
147 EXPECT_NE(nullptr, oHAudioBuffer);
148
149 uint32_t totalSizeInFrameRet;
150 uint32_t spanSizeInFrameRet;
151 uint32_t byteSizePerFrameRet;
152
153 int32_t ret = oHAudioBuffer->GetSizeParameter(totalSizeInFrameRet, spanSizeInFrameRet, byteSizePerFrameRet);
154 EXPECT_EQ(spanSizeInFrame, spanSizeInFrameRet);
155 EXPECT_EQ(totalSizeInFrame, totalSizeInFrameRet);
156 EXPECT_EQ(byteSizePerFrame, byteSizePerFrameRet);
157 EXPECT_EQ(SUCCESS, ret);
158 }
159
160 /**
161 * @tc.name : Test OHAudioBuffer API
162 * @tc.type : FUNC
163 * @tc.number: OHAudioBuffer_003
164 * @tc.desc : Test OHAudioBuffer interface.
165 */
166 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_003, TestSize.Level1)
167 {
168 uint64_t frames = 1000;
169 int64_t nanoTime = NANO_COUNT_PER_SECOND;
170 oHAudioBuffer->SetHandleInfo(frames, nanoTime);
171 bool ret = oHAudioBuffer->GetHandleInfo(frames, nanoTime);
172 EXPECT_EQ(true, ret);
173 }
174
175 /**
176 * @tc.name : Test OHAudioBuffer API
177 * @tc.type : FUNC
178 * @tc.number: OHAudioBuffer_004
179 * @tc.desc : Test OHAudioBuffer interface.
180 */
181 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_004, TestSize.Level1)
182 {
183 int32_t ret = -1;
184 uint64_t writeFrame = 3000;
185 uint64_t readFrame = writeFrame - 1001;
186
187 ret = oHAudioBuffer->ResetCurReadWritePos(readFrame, writeFrame);
188 EXPECT_EQ(ERR_INVALID_PARAM, ret);
189
190 ret = oHAudioBuffer->GetAvailableDataFrames();
191 EXPECT_EQ(TEST_NUM, ret);
192
193 writeFrame = 1001;
194 readFrame = 1000;
195
196 ret = oHAudioBuffer->ResetCurReadWritePos(readFrame, writeFrame);
197 EXPECT_EQ(SUCCESS, ret);
198
199 ret = oHAudioBuffer->GetAvailableDataFrames();
200 EXPECT_EQ(TEST_NUM - 1, ret);
201
202 uint64_t writeFrameRet = oHAudioBuffer->GetCurWriteFrame();
203 uint64_t readFrameRet = oHAudioBuffer->GetCurReadFrame();
204 EXPECT_EQ(writeFrame, writeFrameRet);
205 EXPECT_EQ(readFrame, readFrameRet);
206
207 writeFrame = 5000;
208 ret = oHAudioBuffer->SetCurWriteFrame(writeFrame);
209 EXPECT_EQ(ERR_INVALID_PARAM, ret);
210
211 writeFrame = readFrame - 1;
212 ret = oHAudioBuffer->SetCurWriteFrame(writeFrame);
213 EXPECT_EQ(ERR_INVALID_PARAM, ret);
214
215 writeFrame = 1000;
216 ret = oHAudioBuffer->SetCurWriteFrame(writeFrame);
217 EXPECT_LT(ret, TEST_RET_NUM);
218
219 writeFrame = 3000 + 2;
220 ret = oHAudioBuffer->SetCurWriteFrame(writeFrame);
221 EXPECT_LT(ret, TEST_RET_NUM);
222 }
223
224 /**
225 * @tc.name : Test OHAudioBuffer API
226 * @tc.type : FUNC
227 * @tc.number: OHAudioBuffer_005
228 * @tc.desc : Test OHAudioBuffer interface.
229 */
230 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_005, TestSize.Level1)
231 {
232 int32_t ret = -1;
233 uint64_t writeFrame = 5000;
234 ret = oHAudioBuffer->SetCurReadFrame(writeFrame);
235 EXPECT_EQ(ERR_INVALID_PARAM, ret);
236
237 uint64_t readFrame = 1000;
238 ret = oHAudioBuffer->SetCurReadFrame(readFrame);
239 EXPECT_EQ(SUCCESS, ret);
240
241 readFrame = 1000;
242 ret = oHAudioBuffer->SetCurReadFrame(readFrame);
243 EXPECT_EQ(SUCCESS, ret);
244
245 readFrame = 2000;
246 ret = oHAudioBuffer->SetCurReadFrame(readFrame);
247 EXPECT_LT(ret, TEST_RET_NUM);
248
249 readFrame = 3000 + 2;
250 ret = oHAudioBuffer->SetCurReadFrame(readFrame);
251 EXPECT_LT(ret, TEST_RET_NUM);
252 }
253
254 /**
255 * @tc.name : Test OHAudioBuffer API
256 * @tc.type : FUNC
257 * @tc.number: OHAudioBuffer_006
258 * @tc.desc : Test OHAudioBuffer interface.
259 */
260 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_006, TestSize.Level1)
261 {
262 int32_t ret = -1;
263 BufferDesc bufferDesc;
264 uint64_t posInFrame = 1000;
265
266 ret = oHAudioBuffer->GetBufferByFrame(posInFrame, bufferDesc);
267 EXPECT_EQ(SUCCESS, ret);
268
269 posInFrame = 3000 + 1;
270 ret = oHAudioBuffer->GetBufferByFrame(posInFrame, bufferDesc);
271 EXPECT_LT(ret, TEST_RET_NUM);
272
273 uint64_t writePosInFrame = 1000;
274 ret = oHAudioBuffer->GetWriteBuffer(writePosInFrame, bufferDesc);
275 EXPECT_EQ(SUCCESS, ret);
276
277 writePosInFrame = 3000 +1;
278 ret = oHAudioBuffer->GetWriteBuffer(writePosInFrame, bufferDesc);
279 EXPECT_LT(ret, TEST_RET_NUM);
280
281 uint64_t readPosInFrame = 1000;
282 ret = oHAudioBuffer->GetReadbuffer(readPosInFrame, bufferDesc);
283 EXPECT_EQ(SUCCESS, ret);
284
285 readPosInFrame = 3000;
286 ret = oHAudioBuffer->GetReadbuffer(readPosInFrame, bufferDesc);
287 EXPECT_LT(ret, TEST_RET_NUM);
288 }
289
290 /**
291 * @tc.name : Test OHAudioBuffer API
292 * @tc.type : FUNC
293 * @tc.number: OHAudioBuffer_007
294 * @tc.desc : Test OHAudioBuffer interface.
295 */
296 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_007, TestSize.Level1)
297 {
298 uint64_t posInFrame = 4000;
299 SpanInfo *spanInfo = oHAudioBuffer->GetSpanInfo(posInFrame);
300 EXPECT_EQ(NULL, spanInfo);
301
302 uint32_t spanIndex = 2;
303 SpanInfo *spanInfoFromIndex = oHAudioBuffer->GetSpanInfoByIndex(spanIndex);
304 EXPECT_EQ(NULL, spanInfoFromIndex);
305
306 uint32_t spanCount = oHAudioBuffer->GetSpanCount();
307 uint32_t spanCountExpect = 1;
308 EXPECT_EQ(spanCountExpect, spanCount);
309
310
311 size_t totalSize = oHAudioBuffer->GetDataSize();
312 EXPECT_EQ(totalSize > TEST_RET_NUM, true);
313
314 uint8_t * dataBase = oHAudioBuffer->GetDataBase();
315 EXPECT_NE(nullptr, dataBase);
316 }
317
318 /**
319 * @tc.name : Test OHAudioBuffer API
320 * @tc.type : FUNC
321 * @tc.number: OHAudioBuffer_008
322 * @tc.desc : Test OHAudioBuffer interface.
323 */
324 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_008, TestSize.Level1)
325 {
326 MessageParcel parcel;
327
328 int32_t ret = oHAudioBuffer->WriteToParcel(oHAudioBuffer, parcel);
329 EXPECT_EQ(SUCCESS, ret);
330
331 oHAudioBuffer = oHAudioBuffer->ReadFromParcel(parcel);
332 EXPECT_NE(nullptr, oHAudioBuffer);
333 }
334 } // namespace AudioStandard
335 } // namespace OHOS