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_service_log.h"
18 #include "audio_info.h"
19 #include "audio_ring_cache.h"
20 #include "audio_process_config.h"
21 #include "linear_pos_time_model.h"
22 #include "oh_audio_buffer.h"
23 #include <thread>
24 #include <gtest/gtest.h>
25
26 using namespace testing::ext;
27 namespace OHOS {
28 namespace AudioStandard {
29 std::unique_ptr<LinearPosTimeModel> g_linearPosTimeModel;
30 std::shared_ptr<OHAudioBuffer> g_oHAudioBuffer;
31 const int32_t TEST_NUM = 1000;
32 const int32_t TEST_RET_NUM = 0;
33 const int64_t NANO_COUNT_PER_SECOND = 1000000000;
34 class AudioServiceCommonUnitTest : public testing::Test {
35 public:
36 static void SetUpTestCase(void);
37 static void TearDownTestCase(void);
38 void SetUp();
39 void TearDown();
40 };
41
SetUpTestCase(void)42 void AudioServiceCommonUnitTest::SetUpTestCase(void)
43 {
44 // input testsuit setup step，setup invoked before all testcases
45 }
46
TearDownTestCase(void)47 void AudioServiceCommonUnitTest::TearDownTestCase(void)
48 {
49 // input testsuit teardown step，teardown invoked after all testcases
50 }
51
SetUp(void)52 void AudioServiceCommonUnitTest::SetUp(void)
53 {
54 // input testcase setup step，setup invoked before each testcases
55 }
56
TearDown(void)57 void AudioServiceCommonUnitTest::TearDown(void)
58 {
59 // input testcase teardown step，teardown invoked after each testcases
60 }
61
62 /**
63 * @tc.name : Test ProcessConfig API
64 * @tc.type : FUNC
65 * @tc.number: ProcessConfigTest_001
66 * @tc.desc : Test ProcessConfig test.
67 */
68 HWTEST(AudioServiceCommonUnitTest, ProcessConfigTest_001, TestSize.Level1)
69 {
70 CaptureFilterOptions filterOptions = {{STREAM_USAGE_MUSIC}, FilterMode::INCLUDE, {0}, FilterMode::INCLUDE};
71 AudioPlaybackCaptureConfig config = {filterOptions, false};
72 std::string dumpStr = ProcessConfig::DumpInnerCapConfig(config);
73 EXPECT_NE(dumpStr, "");
74 }
75
76 /**
77 * @tc.name : Test LinearPosTimeModel API
78 * @tc.type : FUNC
79 * @tc.number: LinearPosTimeModel_001
80 * @tc.desc : Test LinearPosTimeModel interface.
81 */
82 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_001, TestSize.Level1)
83 {
84 g_linearPosTimeModel = std::make_unique<LinearPosTimeModel>();
85
86 uint64_t posInFrame = 20;
87 int64_t invalidTime = -1;
88 int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame);
89 EXPECT_EQ(invalidTime, retPos);
90
91 int32_t sampleRate = -1;
92 bool isConfig = g_linearPosTimeModel->ConfigSampleRate(sampleRate);
93 EXPECT_EQ(false, isConfig);
94
95 sampleRate = (int32_t)AudioSamplingRate::SAMPLE_RATE_44100;
96 isConfig = g_linearPosTimeModel->ConfigSampleRate(sampleRate);
97 EXPECT_EQ(true, isConfig);
98
99 isConfig = g_linearPosTimeModel->ConfigSampleRate(sampleRate);
100 EXPECT_EQ(false, isConfig);
101 }
102
103 /**
104 * @tc.name : Test LinearPosTimeModel API
105 * @tc.type : FUNC
106 * @tc.number: LinearPosTimeModel_002
107 * @tc.desc : Test LinearPosTimeModel interface.
108 */
109 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_002, TestSize.Level1)
110 {
111 int64_t deltaFrame = 0;
112 uint64_t frame = 0;
113 int64_t nanoTime = 0;
114 g_linearPosTimeModel->ResetFrameStamp(frame, nanoTime);
115
116 uint64_t spanCountInFrame = 2;
117 g_linearPosTimeModel->SetSpanCount(spanCountInFrame);
118
119 uint64_t posInFrame = 20;
120 int64_t retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame);
121
122 deltaFrame = posInFrame - frame;
123 int64_t retPosCal1 = nanoTime + deltaFrame * NANO_COUNT_PER_SECOND / (int64_t)AudioSamplingRate::SAMPLE_RATE_44100;
124 EXPECT_EQ(retPos, retPosCal1);
125
126 frame = 40;
127 nanoTime = 50;
128 g_linearPosTimeModel->UpdataFrameStamp(frame, nanoTime);
129
130 retPos = g_linearPosTimeModel->GetTimeOfPos(posInFrame);
131 deltaFrame = frame - posInFrame;
132 int64_t retPosCal2 = nanoTime + deltaFrame * NANO_COUNT_PER_SECOND / (int64_t)AudioSamplingRate::SAMPLE_RATE_44100;
133 EXPECT_NE(retPos, retPosCal2);
134 }
135
136 /**
137 * @tc.name : Test CheckPosTimeReasonable API
138 * @tc.type : FUNC
139 * @tc.number: CheckPosTimeReasonable
140 * @tc.desc : Test CheckPosTimeReasonable interface.
141 */
142 HWTEST(AudioServiceCommonUnitTest, CheckPosTimeReasonable_001, TestSize.Level1)
143 {
144 std::pair<uint64_t, int64_t> pre = std::make_pair(10, 100);
145 std::pair<uint64_t, int64_t> next = std::make_pair(5, 50);
146 bool ret = g_linearPosTimeModel->CheckPosTimeReasonable(pre, next);
147
148 EXPECT_EQ(false, ret);
149 }
150
151 /**
152 * @tc.name : Test CheckPosTimeReasonable API
153 * @tc.type : FUNC
154 * @tc.number: CheckPosTimeReasonable
155 * @tc.desc : Test CheckPosTimeReasonable interface.
156 */
157 HWTEST(AudioServiceCommonUnitTest, CheckPosTimeReasonable_002, TestSize.Level1)
158 {
159 std::pair<uint64_t, int64_t> pre = std::make_pair(10, 100);
160 std::pair<uint64_t, int64_t> next = std::make_pair(11, 50);
161 bool ret = g_linearPosTimeModel->CheckPosTimeReasonable(pre, next);
162
163 EXPECT_EQ(true, ret);
164 }
165
166 /**
167 * @tc.name : Test CheckPosTimeReasonable API
168 * @tc.type : FUNC
169 * @tc.number: CheckPosTimeReasonable
170 * @tc.desc : Test CheckPosTimeReasonable interface.
171 */
172 HWTEST(AudioServiceCommonUnitTest, CheckPosTimeReasonablel_003, TestSize.Level1)
173 {
174 std::pair<uint64_t, int64_t> pre = std::make_pair(10, 100);
175 std::pair<uint64_t, int64_t> next = std::make_pair(10, 50);
176 bool ret = g_linearPosTimeModel->CheckPosTimeReasonable(pre, next);
177
178 EXPECT_EQ(false, ret);
179 }
180
181 /**
182 * @tc.name : Test CheckReasonable API
183 * @tc.type : FUNC
184 * @tc.number: CheckReasonable
185 * @tc.desc : Test CheckReasonable interface.
186 */
187 HWTEST(AudioServiceCommonUnitTest, CheckReasonable_001, TestSize.Level1)
188 {
189 uint64_t frame = 100;
190 int64_t nanoTime = 1000000;
191 static constexpr int32_t maxCount = 5;
192 for (int i = 0; i < maxCount - 1; ++i) {
193 g_linearPosTimeModel->posTimeVec_.push_back(std::make_pair(frame + i, nanoTime + i));
194 }
195 CheckPosTimeRes result = g_linearPosTimeModel->CheckReasonable(frame + maxCount - 1, nanoTime + maxCount - 1);
196 EXPECT_EQ(result, NEED_MODIFY);
197
198 for (int i = 0; i < maxCount; ++i) {
199 g_linearPosTimeModel->posTimeVec_.push_back(std::make_pair(frame + i, nanoTime + i));
200 }
201 result = g_linearPosTimeModel->CheckReasonable(frame + maxCount, nanoTime + maxCount);
202 EXPECT_EQ(result, CHECK_FAILED);
203 }
204
205 /**
206 * @tc.name : Test OHAudioBuffer API
207 * @tc.type : FUNC
208 * @tc.number: OHAudioBuffer_001
209 * @tc.desc : Test OHAudioBuffer interface.
210 */
211 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_001, TestSize.Level1)
212 {
213 uint32_t spanSizeInFrame = 1000;
214 uint32_t totalSizeInFrame = spanSizeInFrame - 1;
215 uint32_t byteSizePerFrame = 1000;
216 g_oHAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
217 EXPECT_EQ(nullptr, g_oHAudioBuffer);
218 }
219
220 /**
221 * @tc.name : Test OHAudioBuffer API
222 * @tc.type : FUNC
223 * @tc.number: OHAudioBuffer_002
224 * @tc.desc : Test OHAudioBuffer interface.
225 */
226 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_002, TestSize.Level1)
227 {
228 uint32_t spanSizeInFrame = 1000;
229 uint32_t totalSizeInFrame = spanSizeInFrame;
230 uint32_t byteSizePerFrame = 1000;
231 g_oHAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
232 EXPECT_NE(nullptr, g_oHAudioBuffer);
233
234 uint32_t totalSizeInFrameRet;
235 uint32_t spanSizeInFrameRet;
236 uint32_t byteSizePerFrameRet;
237
238 int32_t ret = g_oHAudioBuffer->GetSizeParameter(totalSizeInFrameRet, spanSizeInFrameRet, byteSizePerFrameRet);
239 EXPECT_EQ(spanSizeInFrame, spanSizeInFrameRet);
240 EXPECT_EQ(totalSizeInFrame, totalSizeInFrameRet);
241 EXPECT_EQ(byteSizePerFrame, byteSizePerFrameRet);
242 EXPECT_EQ(SUCCESS, ret);
243 }
244
245 /**
246 * @tc.name : Test OHAudioBuffer API
247 * @tc.type : FUNC
248 * @tc.number: OHAudioBuffer_003
249 * @tc.desc : Test OHAudioBuffer interface.
250 */
251 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_003, TestSize.Level1)
252 {
253 uint64_t frames = 1000;
254 int64_t nanoTime = NANO_COUNT_PER_SECOND;
255 g_oHAudioBuffer->SetHandleInfo(frames, nanoTime);
256 bool ret = g_oHAudioBuffer->GetHandleInfo(frames, nanoTime);
257 EXPECT_EQ(true, ret);
258 }
259
260 /**
261 * @tc.name : Test OHAudioBuffer API
262 * @tc.type : FUNC
263 * @tc.number: OHAudioBuffer_004
264 * @tc.desc : Test OHAudioBuffer interface.
265 */
266 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_004, TestSize.Level1)
267 {
268 int32_t ret = -1;
269 uint64_t writeFrame = 3000;
270 uint64_t readFrame = writeFrame - 1001;
271
272 ret = g_oHAudioBuffer->ResetCurReadWritePos(readFrame, writeFrame);
273 EXPECT_EQ(ERR_INVALID_PARAM, ret);
274
275 ret = g_oHAudioBuffer->GetWritableDataFrames();
276 EXPECT_EQ(TEST_NUM, ret);
277
278 writeFrame = 1001;
279 readFrame = 1000;
280
281 ret = g_oHAudioBuffer->ResetCurReadWritePos(readFrame, writeFrame);
282 EXPECT_EQ(SUCCESS, ret);
283
284 ret = g_oHAudioBuffer->GetWritableDataFrames();
285 EXPECT_EQ(TEST_NUM - 1, ret);
286
287 uint64_t writeFrameRet = g_oHAudioBuffer->GetCurWriteFrame();
288 uint64_t readFrameRet = g_oHAudioBuffer->GetCurReadFrame();
289 EXPECT_EQ(writeFrame, writeFrameRet);
290 EXPECT_EQ(readFrame, readFrameRet);
291
292 writeFrame = 5000;
293 ret = g_oHAudioBuffer->SetCurWriteFrame(writeFrame);
294 EXPECT_EQ(ERR_INVALID_PARAM, ret);
295
296 writeFrame = readFrame - 1;
297 ret = g_oHAudioBuffer->SetCurWriteFrame(writeFrame);
298 EXPECT_EQ(ERR_INVALID_PARAM, ret);
299
300 writeFrame = 1000;
301 ret = g_oHAudioBuffer->SetCurWriteFrame(writeFrame);
302 EXPECT_LT(ret, TEST_RET_NUM);
303
304 writeFrame = 3000 + 2;
305 ret = g_oHAudioBuffer->SetCurWriteFrame(writeFrame);
306 EXPECT_LT(ret, TEST_RET_NUM);
307 }
308
309 /**
310 * @tc.name : Test OHAudioBuffer API
311 * @tc.type : FUNC
312 * @tc.number: OHAudioBuffer_005
313 * @tc.desc : Test OHAudioBuffer interface.
314 */
315 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_005, TestSize.Level1)
316 {
317 int32_t ret = -1;
318 uint64_t writeFrame = 5000;
319 ret = g_oHAudioBuffer->SetCurReadFrame(writeFrame);
320 EXPECT_EQ(ERR_INVALID_PARAM, ret);
321
322 uint64_t readFrame = 1000;
323 ret = g_oHAudioBuffer->SetCurReadFrame(readFrame);
324 EXPECT_EQ(SUCCESS, ret);
325
326 readFrame = 1000;
327 ret = g_oHAudioBuffer->SetCurReadFrame(readFrame);
328 EXPECT_EQ(SUCCESS, ret);
329
330 readFrame = 2000;
331 ret = g_oHAudioBuffer->SetCurReadFrame(readFrame);
332 EXPECT_LT(ret, TEST_RET_NUM);
333
334 readFrame = 3000 + 2;
335 ret = g_oHAudioBuffer->SetCurReadFrame(readFrame);
336 EXPECT_LT(ret, TEST_RET_NUM);
337 }
338
339 /**
340 * @tc.name : Test OHAudioBuffer API
341 * @tc.type : FUNC
342 * @tc.number: OHAudioBuffer_006
343 * @tc.desc : Test OHAudioBuffer interface.
344 */
345 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_006, TestSize.Level1)
346 {
347 int32_t ret = -1;
348 BufferDesc bufferDesc;
349 uint64_t posInFrame = 1000;
350 uint64_t spanSizeInFrame = 1000;
351
352 RingBufferWrapper ringbufferWrapper;
353 ret = g_oHAudioBuffer->ohAudioBufferBase_.GetBufferByFrame(posInFrame, spanSizeInFrame, ringbufferWrapper);
354 EXPECT_EQ(SUCCESS, ret);
355 EXPECT_EQ(true, ringbufferWrapper.IsLegal());
356
357 posInFrame = 3000 + 1;
358 ret = g_oHAudioBuffer->ohAudioBufferBase_.GetBufferByFrame(posInFrame, spanSizeInFrame, ringbufferWrapper);
359 EXPECT_LT(ret, TEST_RET_NUM);
360
361 uint64_t writePosInFrame = 1000;
362 ret = g_oHAudioBuffer->GetWriteBuffer(writePosInFrame, bufferDesc);
363 EXPECT_EQ(SUCCESS, ret);
364
365 writePosInFrame = 3000 + 1;
366 ret = g_oHAudioBuffer->GetWriteBuffer(writePosInFrame, bufferDesc);
367 EXPECT_LT(ret, TEST_RET_NUM);
368
369 uint64_t readPosInFrame = 1000;
370 ret = g_oHAudioBuffer->GetReadbuffer(readPosInFrame, bufferDesc);
371 EXPECT_EQ(SUCCESS, ret);
372
373 readPosInFrame = 3000;
374 ret = g_oHAudioBuffer->GetReadbuffer(readPosInFrame, bufferDesc);
375 EXPECT_LT(ret, TEST_RET_NUM);
376 }
377
378 /**
379 * @tc.name : Test OHAudioBuffer API
380 * @tc.type : FUNC
381 * @tc.number: OHAudioBuffer_007
382 * @tc.desc : Test OHAudioBuffer interface.
383 */
384 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_007, TestSize.Level1)
385 {
386 uint64_t posInFrame = 4000;
387 SpanInfo *spanInfo = g_oHAudioBuffer->GetSpanInfo(posInFrame);
388 EXPECT_EQ(NULL, spanInfo);
389
390 uint32_t spanIndex = 2;
391 SpanInfo *spanInfoFromIndex = g_oHAudioBuffer->GetSpanInfoByIndex(spanIndex);
392 EXPECT_EQ(NULL, spanInfoFromIndex);
393
394 uint32_t spanCount = g_oHAudioBuffer->GetSpanCount();
395 uint32_t spanCountExpect = 1;
396 EXPECT_EQ(spanCountExpect, spanCount);
397
398
399 size_t totalSize = g_oHAudioBuffer->GetDataSize();
400 EXPECT_EQ(totalSize > TEST_RET_NUM, true);
401
402 uint8_t * dataBase = g_oHAudioBuffer->GetDataBase();
403 EXPECT_NE(nullptr, dataBase);
404 }
405
406 /**
407 * @tc.name : Test OHAudioBuffer API
408 * @tc.type : FUNC
409 * @tc.number: OHAudioBuffer_008
410 * @tc.desc : Test OHAudioBuffer interface.
411 */
412 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_008, TestSize.Level1)
413 {
414 MessageParcel parcel;
415
416 int32_t ret = g_oHAudioBuffer->WriteToParcel(g_oHAudioBuffer, parcel);
417 EXPECT_EQ(SUCCESS, ret);
418
419 g_oHAudioBuffer = g_oHAudioBuffer->ReadFromParcel(parcel);
420 EXPECT_NE(nullptr, g_oHAudioBuffer);
421 }
422
423 /**
424 * @tc.name : Test OHAudioBuffer API
425 * @tc.type : FUNC
426 * @tc.number: OHAudioBuffer_009
427 * @tc.desc : Test OHAudioBuffer interface.
428 */
429 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_009, TestSize.Level1)
430 {
431 uint32_t spanSizeInFrame = 1000;
432 uint32_t totalSizeInFrame = spanSizeInFrame;
433 uint32_t byteSizePerFrame = 100;
434 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
435 EXPECT_NE(nullptr, ohAudioBuffer);
436
437 int32_t ret = ohAudioBuffer->SetCurWriteFrame(totalSizeInFrame);
438 EXPECT_EQ(ret, SUCCESS);
439
440 // 200ms
__anon38ec4ef40102() 441 FutexCode futexCode = ohAudioBuffer->WaitFor(200000000, [&ohAudioBuffer] () {
442 return ohAudioBuffer->GetWritableDataFrames() > 0;
443 });
444 EXPECT_EQ(futexCode, FUTEX_TIMEOUT);
445 }
446
447 /**
448 * @tc.name : Test OHAudioBuffer API
449 * @tc.type : FUNC
450 * @tc.number: OHAudioBuffer_010
451 * @tc.desc : Test OHAudioBuffer interface.
452 */
453 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_010, TestSize.Level1)
454 {
455 uint32_t spanSizeInFrame = 1000;
456 uint32_t totalSizeInFrame = spanSizeInFrame;
457 uint32_t byteSizePerFrame = 100;
458 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
459 EXPECT_NE(nullptr, ohAudioBuffer);
460
461 int32_t ret = ohAudioBuffer->SetCurWriteFrame(totalSizeInFrame);
462 EXPECT_EQ(ret, SUCCESS);
463
__anon38ec4ef40202() 464 std::thread threadSetReadIndex([ohAudioBuffer, totalSizeInFrame] () {
465 ohAudioBuffer->SetCurReadFrame(totalSizeInFrame);
466 });
467
468 // 200ms
__anon38ec4ef40302() 469 FutexCode futexCode = ohAudioBuffer->WaitFor(200000000, [&ohAudioBuffer] () {
470 return ohAudioBuffer->GetWritableDataFrames() > 0;
471 });
472 EXPECT_EQ(futexCode, FUTEX_SUCCESS);
473 threadSetReadIndex.join();
474 }
475
476 /**
477 * @tc.name : Test OHAudioBuffer API
478 * @tc.type : FUNC
479 * @tc.number: OHAudioBuffer_011
480 * @tc.desc : Test OHAudioBuffer interface.
481 */
482 HWTEST(AudioServiceCommonUnitTest, OHAudioBuffer_011, TestSize.Level1)
483 {
484 MessageParcel parcel;
485 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT) + 1);
486 parcel.WriteUint32(100);
487 parcel.WriteUint32(10);
488 parcel.WriteUint32(2);
489 int dataFd = 1;
490 int infoFd = 2;
491 parcel.WriteFileDescriptor(dataFd);
492 parcel.WriteFileDescriptor(infoFd);
493
494 std::shared_ptr<OHAudioBuffer> buffer = OHAudioBuffer::ReadFromParcel(parcel);
495 EXPECT_EQ(buffer, nullptr);
496 }
497
498 /**
499 * @tc.name : Test OHAudioBuffer API
500 * @tc.type : FUNC
501 * @tc.number: OHAudioBufferBase_001
502 * @tc.desc : Test OHAudioBuffer interface.
503 */
504 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_001, TestSize.Level1)
505 {
506 uint32_t totalSizeInFrame = 1000;
507 uint32_t byteSizePerFrame = 100;
508 size_t totalSizeInBytes = totalSizeInFrame * byteSizePerFrame;
509 auto ohAudioBufferBase = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
510 EXPECT_NE(nullptr, ohAudioBufferBase);
511
512 int32_t ret = ohAudioBufferBase->SetCurWriteFrame(totalSizeInFrame);
513 EXPECT_EQ(ret, SUCCESS);
514
515 RingBufferWrapper buffer;
516 ret = ohAudioBufferBase->GetAllReadableBuffer(buffer);
517 EXPECT_EQ(ret, SUCCESS);
518 EXPECT_EQ(buffer.dataLength, totalSizeInBytes);
519 EXPECT_NE(buffer.basicBufferDescs[0].buffer, nullptr);
520 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, totalSizeInBytes);
521 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
522 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
523
524 ret = ohAudioBufferBase->GetAllWritableBuffer(buffer);
525 EXPECT_EQ(ret, SUCCESS);
526 EXPECT_EQ(buffer.dataLength, 0);
527 EXPECT_EQ(buffer.basicBufferDescs[0].buffer, nullptr);
528 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, 0);
529 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
530 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
531
__anon38ec4ef40402() 532 std::thread threadSetReadIndex([ohAudioBufferBase, totalSizeInFrame] () {
533 ohAudioBufferBase->SetCurReadFrame(totalSizeInFrame);
534 });
535
536 // 200ms
__anon38ec4ef40502() 537 FutexCode futexCode = ohAudioBufferBase->WaitFor(200000000, [&ohAudioBufferBase] () {
538 return ohAudioBufferBase->GetWritableDataFrames() > 0;
539 });
540 EXPECT_EQ(futexCode, FUTEX_SUCCESS);
541 threadSetReadIndex.join();
542
543 ret = ohAudioBufferBase->GetAllReadableBuffer(buffer);
544 EXPECT_EQ(ret, SUCCESS);
545 EXPECT_EQ(buffer.dataLength, 0);
546 EXPECT_EQ(buffer.basicBufferDescs[0].buffer, nullptr);
547 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, 0);
548 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
549 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
550
551 ret = ohAudioBufferBase->GetAllWritableBuffer(buffer);
552 EXPECT_EQ(ret, SUCCESS);
553 EXPECT_EQ(buffer.dataLength, totalSizeInBytes);
554 EXPECT_NE(buffer.basicBufferDescs[0].buffer, nullptr);
555 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, totalSizeInBytes);
556 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
557 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
558 }
559
560 /**
561 * @tc.name : Test OHAudioBuffer API
562 * @tc.type : FUNC
563 * @tc.number: OHAudioBufferBase_002
564 * @tc.desc : Test OHAudioBuffer interface.
565 */
566 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_002, TestSize.Level1)
567 {
568 uint32_t totalSizeInFrame = 1000;
569 uint32_t byteSizePerFrame = 100;
570 size_t totalSizeInBytes = totalSizeInFrame * byteSizePerFrame;
571 auto ohAudioBufferBase = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
572 EXPECT_NE(nullptr, ohAudioBufferBase);
573
574 int32_t ret = ohAudioBufferBase->SetCurWriteFrame(totalSizeInFrame - 1);
575 EXPECT_EQ(ret, SUCCESS);
576
577 RingBufferWrapper buffer;
578 ret = ohAudioBufferBase->GetAllReadableBuffer(buffer);
579 EXPECT_EQ(ret, SUCCESS);
580 EXPECT_EQ(true, buffer.IsLegal());
581 EXPECT_EQ(buffer.dataLength, totalSizeInBytes - byteSizePerFrame);
582 EXPECT_NE(buffer.basicBufferDescs[0].buffer, nullptr);
583 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, totalSizeInBytes - byteSizePerFrame);
584 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
585 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
586
587 ret = ohAudioBufferBase->GetAllWritableBuffer(buffer);
588 EXPECT_EQ(ret, SUCCESS);
589 EXPECT_EQ(buffer.dataLength, byteSizePerFrame);
590 EXPECT_NE(buffer.basicBufferDescs[0].buffer, nullptr);
591 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, byteSizePerFrame);
592 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
593 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
594
__anon38ec4ef40602() 595 std::thread threadSetReadIndex([ohAudioBufferBase, totalSizeInFrame] () {
596 ohAudioBufferBase->SetCurReadFrame(totalSizeInFrame - 1);
597 });
598
599 // 200ms
__anon38ec4ef40702() 600 FutexCode futexCode = ohAudioBufferBase->WaitFor(200000000, [&ohAudioBufferBase] () {
601 return ohAudioBufferBase->GetWritableDataFrames() > 0;
602 });
603 EXPECT_EQ(futexCode, FUTEX_SUCCESS);
604 threadSetReadIndex.join();
605
606 ret = ohAudioBufferBase->GetAllReadableBuffer(buffer);
607 EXPECT_EQ(ret, SUCCESS);
608 EXPECT_EQ(buffer.dataLength, 0);
609 EXPECT_EQ(buffer.basicBufferDescs[0].buffer, nullptr);
610 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, 0);
611 EXPECT_EQ(buffer.basicBufferDescs[1].buffer, nullptr);
612 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, 0);
613
614 ret = ohAudioBufferBase->GetAllWritableBuffer(buffer);
615 EXPECT_EQ(ret, SUCCESS);
616 EXPECT_EQ(buffer.dataLength, totalSizeInBytes);
617 EXPECT_NE(buffer.basicBufferDescs[0].buffer, nullptr);
618 EXPECT_EQ(buffer.basicBufferDescs[0].bufLength, byteSizePerFrame);
619 EXPECT_NE(buffer.basicBufferDescs[1].buffer, nullptr);
620 EXPECT_EQ(buffer.basicBufferDescs[1].bufLength, totalSizeInBytes - byteSizePerFrame);
621 }
622
623 /**
624 * @tc.name : Test GetSyncWriteFrame API
625 * @tc.type : FUNC
626 * @tc.number: GetSyncWriteFrame
627 * @tc.desc : Test GetSyncWriteFrame interface.
628 */
629 HWTEST(AudioServiceCommonUnitTest, GetSyncWriteFrame_003, TestSize.Level1)
630 {
631 uint32_t spanSizeInFrame = 1000;
632 uint32_t totalSizeInFrame = spanSizeInFrame;
633 uint32_t byteSizePerFrame = 100;
634 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
635 int32_t ret = ohAudioBuffer->GetSyncWriteFrame();
636 EXPECT_EQ(ret, 0);
637 }
638
639 /**
640 * @tc.name : Test GetSynSetSyncWriteFramecWriteFrame API
641 * @tc.type : FUNC
642 * @tc.number: GetSyncWrSetSyncWriteFrameiteFrame
643 * @tc.desc : Test SetSyncWriteFrame interface.
644 */
645 HWTEST(AudioServiceCommonUnitTest, SetSyncWriteFrame_001, TestSize.Level1)
646 {
647 uint32_t spanSizeInFrame = 1000;
648 uint32_t totalSizeInFrame = spanSizeInFrame;
649 uint32_t byteSizePerFrame = 100;
650 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
651 uint32_t writeFrame = 10;
652 int32_t ret = ohAudioBuffer->SetSyncWriteFrame(writeFrame);
653 EXPECT_EQ(ret, 0);
654 }
655
656 /**
657 * @tc.name : Test GetSyncWriteFrame API
658 * @tc.type : FUNC
659 * @tc.number: GetSyncWriteFrame
660 * @tc.desc : Test GetSyncWriteFrame interface.
661 */
662 HWTEST(AudioServiceCommonUnitTest, SetMuteFactor_001, TestSize.Level1)
663 {
664 uint32_t spanSizeInFrame = 1000;
665 uint32_t totalSizeInFrame = spanSizeInFrame;
666 uint32_t byteSizePerFrame = 100;
667 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
668 float invalidMuteFactor = 0.5f;
669
670 bool result = ohAudioBuffer->SetMuteFactor(invalidMuteFactor);
671 EXPECT_FALSE(result);
672 }
673
674 /**
675 * @tc.name : Test GetDuckFactor API
676 * @tc.type : FUNC
677 * @tc.number: GetDuckFactor
678 * @tc.desc : Test GetDuckFactor interface.
679 */
680 HWTEST(AudioServiceCommonUnitTest, GetDuckFactor_001, TestSize.Level1)
681 {
682 uint32_t spanSizeInFrame = 1000;
683 uint32_t totalSizeInFrame = spanSizeInFrame;
684 uint32_t byteSizePerFrame = 100;
685 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
686
687 float result = ohAudioBuffer->GetDuckFactor();
688 EXPECT_FLOAT_EQ(result, MAX_FLOAT_VOLUME);
689 }
690
691 /**
692 * @tc.name : Test SetDuckFactor API
693 * @tc.type : FUNC
694 * @tc.number: SetDuckFactor
695 * @tc.desc : Test SetDuckFactor interface.
696 */
697 HWTEST(AudioServiceCommonUnitTest, SetDuckFactor_001, TestSize.Level1)
698 {
699 uint32_t spanSizeInFrame = 1000;
700 uint32_t totalSizeInFrame = spanSizeInFrame;
701 uint32_t byteSizePerFrame = 100;
702 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
703
704 float invalidDuckFactor = -0.1f;
705 bool result = ohAudioBuffer->SetDuckFactor(invalidDuckFactor);
706 EXPECT_FALSE(result);
707
708 invalidDuckFactor = 1.1f;
709 result = ohAudioBuffer->SetDuckFactor(invalidDuckFactor);
710 EXPECT_FALSE(result);
711
712 float validDuckFactor = 0.5f;
713 result = ohAudioBuffer->SetDuckFactor(validDuckFactor);
714 EXPECT_TRUE(result);
715
716 validDuckFactor = 0.0f;
717 result = ohAudioBuffer->SetDuckFactor(validDuckFactor);
718 EXPECT_TRUE(result);
719
720 float maxDuckFactor = 1.0f;
721 result = ohAudioBuffer->SetDuckFactor(maxDuckFactor);
722 EXPECT_TRUE(result);
723 }
724
725 /**
726 * @tc.name : Test GetStreamVolume API
727 * @tc.type : FUNC
728 * @tc.number: GetStreamVolume
729 * @tc.desc : Test GetStreamVolume interface.
730 */
731 HWTEST(AudioServiceCommonUnitTest, GetStreamVolume_001, TestSize.Level1)
732 {
733 uint32_t spanSizeInFrame = 1000;
734 uint32_t totalSizeInFrame = spanSizeInFrame;
735 uint32_t byteSizePerFrame = 100;
736 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
737
738 float result = ohAudioBuffer->GetStreamVolume();
739 EXPECT_FLOAT_EQ(result, MAX_FLOAT_VOLUME);
740 }
741
742 /**
743 * @tc.name : Test SetStreamVolume API
744 * @tc.type : FUNC
745 * @tc.number: SetStreamVolume
746 * @tc.desc : Test SetStreamVolume interface.
747 */
748 HWTEST(AudioServiceCommonUnitTest, SetStreamVolume_001, TestSize.Level1)
749 {
750 uint32_t spanSizeInFrame = 1000;
751 uint32_t totalSizeInFrame = spanSizeInFrame;
752 uint32_t byteSizePerFrame = 100;
753 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
754
755 bool result = ohAudioBuffer->SetStreamVolume(0.5f);
756 EXPECT_TRUE(result);
757
758 float invalidVolume = 1.1f;
759 result = ohAudioBuffer->SetStreamVolume(invalidVolume);
760 EXPECT_FALSE(result);
761
762 invalidVolume = -0.1f;
763 result = ohAudioBuffer->SetStreamVolume(invalidVolume);
764 EXPECT_FALSE(result);
765 }
766
767 /**
768 * @tc.name : Test GetSyncReadFrame API
769 * @tc.type : FUNC
770 * @tc.number: GetSyncReadFrame
771 * @tc.desc : Test GetSyncReadFrame interface.
772 */
773 HWTEST(AudioServiceCommonUnitTest, GetSyncReadFrame_001, TestSize.Level1)
774 {
775 uint32_t spanSizeInFrame = 1000;
776 uint32_t totalSizeInFrame = spanSizeInFrame;
777 uint32_t byteSizePerFrame = 100;
778 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
779
780 bool result = ohAudioBuffer->GetSyncReadFrame();
781 EXPECT_FALSE(result);
782 }
783
784 /**
785 * @tc.name : Test SetSyncReadFrame API
786 * @tc.type : FUNC
787 * @tc.number: SetSyncReadFrame
788 * @tc.desc : Test SetSyncReadFrame interface.
789 */
790 HWTEST(AudioServiceCommonUnitTest, SetSyncReadFrame_001, TestSize.Level1)
791 {
792 uint32_t spanSizeInFrame = 1000;
793 uint32_t totalSizeInFrame = spanSizeInFrame;
794 uint32_t byteSizePerFrame = 100;
795 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
796
797 uint32_t testValue = 123;
798 EXPECT_FALSE(ohAudioBuffer->SetSyncReadFrame(testValue));
799 }
800
801 /**
802 * @tc.name : Test GetMuteFactor API
803 * @tc.type : FUNC
804 * @tc.number: GetMuteFactor
805 * @tc.desc : Test GetMuteFactor interface.
806 */
807 HWTEST(AudioServiceCommonUnitTest, GetMuteFactor_001, TestSize.Level4)
808 {
809 uint32_t spanSizeInFrame = 1000;
810 uint32_t totalSizeInFrame = spanSizeInFrame;
811 uint32_t byteSizePerFrame = 100;
812 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
813 EXPECT_EQ(ohAudioBuffer->GetMuteFactor(), 1);
814 }
815
816 /**
817 * @tc.name : Test SetRestoreStatus API
818 * @tc.type : FUNC
819 * @tc.number: SetRestoreStatus
820 * @tc.desc : Test SetRestoreStatus interface.
821 */
822 HWTEST(AudioServiceCommonUnitTest, SetRestoreStatus_001, TestSize.Level1)
823 {
824 uint32_t spanSizeInFrame = 1000;
825 uint32_t totalSizeInFrame = spanSizeInFrame;
826 uint32_t byteSizePerFrame = 100;
827 auto ohAudioBuffer = OHAudioBuffer::CreateFromLocal(totalSizeInFrame, spanSizeInFrame, byteSizePerFrame);
828 RestoreStatus result = ohAudioBuffer->SetRestoreStatus(NEED_RESTORE);
829 EXPECT_NE(RESTORE_ERROR, result);
830 }
831
832 /**
833 * @tc.name : Test AudioRingCache API
834 * @tc.type : FUNC
835 * @tc.number: AudioRingCache_001
836 * @tc.desc : Test AudioRingCache interface.
837 */
838 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_001, TestSize.Level1)
839 {
840 size_t testSize = 3840;
841 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(testSize);
842 EXPECT_NE(nullptr, ringCache);
843
844 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(testSize);
845 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(testSize);
846
847 BufferWrap writeWrap = {writeBuffer.get(), testSize};
848 BufferWrap readWrap = {readBuffer.get(), testSize};
849
850 int32_t tryCount = 200;
851 while (tryCount-- > 0) {
852 OptResult result1 = ringCache->Enqueue(writeWrap);
853 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
854
855 OptResult result2 = ringCache->Dequeue(readWrap);
856 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
857 }
858 }
859
860 /**
861 * @tc.name : Test AudioRingCache API
862 * @tc.type : FUNC
863 * @tc.number: AudioRingCache_002
864 * @tc.desc : Test AudioRingCache interface.
865 */
866 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_002, TestSize.Level1)
867 {
868 size_t testSize = 3840;
869 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(testSize);
870 EXPECT_NE(nullptr, ringCache);
871
872 size_t tempSize = 1920;
873 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
874 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(tempSize);
875
876 BufferWrap writeWrap = {writeBuffer.get(), tempSize};
877 BufferWrap readWrap = {readBuffer.get(), tempSize};
878
879 int32_t tryCount = 200;
880 while (tryCount-- > 0) {
881 OptResult result1 = ringCache->GetWritableSize();
882 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
883 EXPECT_EQ(result1.size, testSize);
884
885 result1 = ringCache->Enqueue(writeWrap); // write 1920
886 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
887
888 result1 = ringCache->GetWritableSize();
889 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
890 EXPECT_EQ(result1.size, testSize - tempSize); // left 1920
891
892
893 OptResult result2 = ringCache->GetReadableSize();
894 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
895 EXPECT_EQ(result2.size, tempSize); // can read 1920
896
897 result2 = ringCache->Dequeue(readWrap);
898 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
899
900 result2 = ringCache->GetReadableSize();
901 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
902 EXPECT_EQ(result2.size, 0); // can read 0
903 }
904 }
905
906 /**
907 * @tc.name : Test AudioRingCache API
908 * @tc.type : FUNC
909 * @tc.number: AudioRingCache_003
910 * @tc.desc : Test AudioRingCache interface.
911 */
912 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_003, TestSize.Level1)
913 {
914 size_t cacheSize = 960;
915 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
916
917 size_t tempSize = 19200;
918 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
919 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(tempSize);
920
921 for (size_t index = 0; index < tempSize;index++) {
922 writeBuffer[index] = index;
923 }
924
925 int32_t totalCount = tempSize / cacheSize;
926 size_t offset = 0;
927 while (totalCount-- > 0) {
928 uint8_t *writePtr = writeBuffer.get() + offset;
929 BufferWrap spanWrap = {writePtr, cacheSize};
930 OptResult result1 = ringCache->Enqueue(spanWrap);
931 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
932
933 uint8_t *readPtr = readBuffer.get() + offset;
934 BufferWrap readWrap = {readPtr, cacheSize};
935 OptResult result2 = ringCache->Dequeue(readWrap);
936 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
937 offset += cacheSize;
938 }
939
940 for (size_t index = 0; index < tempSize;index++) {
941 EXPECT_EQ(writeBuffer[index], readBuffer[index]);
942 }
943 }
944
945 /**
946 * @tc.name : Test AudioRingCache API
947 * @tc.type : FUNC
948 * @tc.number: AudioRingCache_004
949 * @tc.desc : Test AudioRingCache interface.
950 */
951 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_004, TestSize.Level1)
952 {
953 size_t cacheSize = 960;
954 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
955
956 size_t tempSize = 480;
957 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
958 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(tempSize);
959
960 for (size_t index = 0; index < tempSize;index++) {
961 writeBuffer[index] = index;
962 }
963
964 BufferWrap writeWrap = {writeBuffer.get(), tempSize};
965 BufferWrap readWrap = {readBuffer.get(), tempSize};
966
967 OptResult result1 = ringCache->Enqueue(writeWrap);
968 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
969
970 result1 = ringCache->ReConfig(tempSize, true); // test copyRemained is true
971 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
972 EXPECT_EQ(result1.size, tempSize);
973
974 result1 = ringCache->Dequeue(readWrap);
975 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
976 EXPECT_EQ(result1.size, tempSize);
977
978 for (size_t index = 0; index < tempSize;index++) {
979 EXPECT_EQ(writeBuffer[index], readBuffer[index]);
980 }
981 }
982
983 /**
984 * @tc.name : Test AudioRingCache API
985 * @tc.type : FUNC
986 * @tc.number: AudioRingCache_005
987 * @tc.desc : Test AudioRingCache interface.
988 */
989 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_005, TestSize.Level1)
990 {
991 size_t cacheSize = 960;
992 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
993
994 size_t tempSize = 480;
995 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
996 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(tempSize);
997
998 for (size_t index = 0; index < tempSize;index++) {
999 writeBuffer[index] = index;
1000 }
1001
1002 BufferWrap writeWrap = {writeBuffer.get(), tempSize};
1003 BufferWrap readWrap = {readBuffer.get(), tempSize};
1004
1005 OptResult result1 = ringCache->Enqueue(writeWrap);
1006 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1007
1008 result1 = ringCache->Dequeue(readWrap);
1009 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1010 EXPECT_EQ(result1.size, tempSize);
1011
1012 result1 = ringCache->Enqueue(writeWrap);
1013 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1014
1015 result1 = ringCache->ReConfig(tempSize, true); // test copyRemained is true
1016 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1017 EXPECT_EQ(result1.size, tempSize);
1018
1019 result1 = ringCache->Dequeue(readWrap);
1020 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1021 EXPECT_EQ(result1.size, tempSize);
1022
1023 for (size_t index = 0; index < tempSize;index++) {
1024 EXPECT_EQ(writeBuffer[index], readBuffer[index]);
1025 }
1026 }
1027
1028 /**
1029 * @tc.name : Test AudioRingCache API
1030 * @tc.type : FUNC
1031 * @tc.number: AudioRingCache_006
1032 * @tc.desc : Test AudioRingCache interface.
1033 */
1034 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_006, TestSize.Level1)
1035 {
1036 size_t cacheSize = 960;
1037 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
1038
1039 size_t tempSize = 480;
1040 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
1041
1042 for (size_t index = 0; index < tempSize;index++) {
1043 writeBuffer[index] = index;
1044 }
1045
1046 BufferWrap writeWrap = {writeBuffer.get(), tempSize};
1047
1048 OptResult result1 = ringCache->Enqueue(writeWrap);
1049 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1050
1051 result1 = ringCache->Dequeue(writeWrap);
1052 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1053 EXPECT_EQ(result1.size, tempSize);
1054
1055 result1 = ringCache->Enqueue(writeWrap);
1056 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1057
1058 result1 = ringCache->ReConfig(tempSize, false); // test copyRemained is false
1059 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1060 EXPECT_EQ(result1.size, tempSize);
1061
1062 result1 = ringCache->GetReadableSize();
1063 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1064 EXPECT_EQ(result1.size, 0);
1065 }
1066
1067 /**
1068 * @tc.name : Test AudioRingCache API
1069 * @tc.type : FUNC
1070 * @tc.number: AudioRingCache_007
1071 * @tc.desc : Test AudioRingCache interface.
1072 */
1073 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_007, TestSize.Level1)
1074 {
1075 size_t cacheSize = 480;
1076 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
1077
1078 size_t tempSize = 480;
1079 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
1080
1081 for (size_t index = 0; index < tempSize;index++) {
1082 writeBuffer[index] = index;
1083 }
1084
1085 BufferWrap writeWrap = {writeBuffer.get(), tempSize};
1086
1087 OptResult result1 = ringCache->Enqueue(writeWrap);
1088 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1089
1090 size_t reSize = tempSize + tempSize;
1091 result1 = ringCache->ReConfig(reSize, false); // test copyRemained is false
1092 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1093 EXPECT_EQ(result1.size, reSize);
1094
1095 result1 = ringCache->GetReadableSize();
1096 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1097 EXPECT_EQ(result1.size, 0);
1098
1099 result1 = ringCache->GetWritableSize();
1100 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1101 EXPECT_EQ(result1.size, reSize);
1102
1103 result1 = ringCache->Enqueue(writeWrap);
1104 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1105 EXPECT_EQ(result1.size, tempSize);
1106
1107 result1 = ringCache->GetWritableSize();
1108 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1109 EXPECT_EQ(result1.size, tempSize);
1110
1111 result1 = ringCache->Enqueue(writeWrap);
1112 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1113 EXPECT_EQ(result1.size, tempSize);
1114
1115 result1 = ringCache->GetWritableSize();
1116 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1117 EXPECT_EQ(result1.size, 0);
1118 }
1119
1120 /**
1121 * @tc.name : Test AudioRingCache API
1122 * @tc.type : FUNC
1123 * @tc.number: AudioRingCache_008
1124 * @tc.desc : Test cross ring cache.
1125 */
1126 HWTEST(AudioServiceCommonUnitTest, AudioRingCache_008, TestSize.Level1)
1127 {
1128 size_t cacheSize = 480;
1129 std::unique_ptr<AudioRingCache> ringCache = AudioRingCache::Create(cacheSize);
1130
1131 size_t tempSize = 1920;
1132 std::unique_ptr<uint8_t[]> writeBuffer = std::make_unique<uint8_t[]>(tempSize);
1133 std::unique_ptr<uint8_t[]> readBuffer = std::make_unique<uint8_t[]>(tempSize);
1134
1135 for (size_t index = 0; index < tempSize;index++) {
1136 writeBuffer[index] = index % UINT8_MAX;
1137 }
1138
1139 size_t offset = 0;
1140 size_t spanSize = 320; // 480 * 2 /3
1141 int32_t totalCount = tempSize / spanSize;
1142 while (totalCount-- > 0) {
1143 uint8_t *writePtr = writeBuffer.get() + offset;
1144 BufferWrap spanWrap = {writePtr, spanSize};
1145 OptResult result1 = ringCache->Enqueue(spanWrap);
1146 EXPECT_EQ(result1.ret, OPERATION_SUCCESS);
1147
1148 uint8_t *readPtr = readBuffer.get() + offset;
1149 BufferWrap readWrap = {readPtr, spanSize};
1150 OptResult result2 = ringCache->Dequeue(readWrap);
1151 EXPECT_EQ(result2.ret, OPERATION_SUCCESS);
1152 offset += spanSize;
1153 }
1154
1155 for (size_t index = 0; index < tempSize;index++) {
1156 EXPECT_EQ(writeBuffer[index], readBuffer[index]);
1157 }
1158 }
1159 /**
1160 * @tc.name : Test AudioRingCache API
1161 * @tc.type : FUNC
1162 * @tc.number: DumpInnerCapConfig_001
1163 * @tc.desc : Test cross ring cache.
1164 */
1165 HWTEST(AudioServiceCommonUnitTest, DumpInnerCapConfig_001, TestSize.Level1)
1166 {
1167 CaptureFilterOptions filterOptions = {{STREAM_USAGE_MUSIC}, FilterMode::EXCLUDE, {0}, FilterMode::EXCLUDE};
1168 AudioPlaybackCaptureConfig config = {filterOptions, false};
1169 std::string dumpStr = ProcessConfig::DumpInnerCapConfig(config);
1170 EXPECT_NE(dumpStr, "");
1171 }
1172 /**
1173 * @tc.name : Test AudioRingCache API
1174 * @tc.type : FUNC
1175 * @tc.number: DumpInnerCapConfig_002
1176 * @tc.desc : Test cross ring cache.
1177 */
1178 HWTEST(AudioServiceCommonUnitTest, DumpInnerCapConfig_002, TestSize.Level1)
1179 {
1180 CaptureFilterOptions filterOptions = {{STREAM_USAGE_MUSIC},
1181 FilterMode::MAX_FILTER_MODE, {0}, FilterMode::MAX_FILTER_MODE};
1182 AudioPlaybackCaptureConfig config = {filterOptions, false};
1183 std::string dumpStr = ProcessConfig::DumpInnerCapConfig(config);
1184 EXPECT_NE(dumpStr, "");
1185 }
1186 /**
1187 * @tc.name : Test AudioRingCache API
1188 * @tc.type : FUNC
1189 * @tc.number: ReadInnerCapConfigFromParcel_001
1190 * @tc.desc : Test cross ring cache.
1191 */
1192 HWTEST(AudioServiceCommonUnitTest, ReadInnerCapConfigFromParcel_001, TestSize.Level1)
1193 {
1194 MessageParcel parcel;
1195 AudioPlaybackCaptureConfig config;
1196
1197 for (int i = 0; i < 31; i++) {
1198 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_MEDIA);
1199 }
1200 int ret = config.Marshalling(parcel);
1201 EXPECT_EQ(ret, SUCCESS);
1202 }
1203 /**
1204 * @tc.name : Test AudioRingCache API
1205 * @tc.type : FUNC
1206 * @tc.number: ReadInnerCapConfigFromParcel_002
1207 * @tc.desc : Test cross ring cache.
1208 */
1209 HWTEST(AudioServiceCommonUnitTest, ReadInnerCapConfigFromParcel_002, TestSize.Level1)
1210 {
1211 MessageParcel parcel;
1212 AudioPlaybackCaptureConfig config;
1213
1214 for (int i = 0; i < 29; i++) {
1215 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_CALL_ASSISTANT);
1216 }
1217 int ret = config.Marshalling(parcel);
1218 EXPECT_NE(ret, SUCCESS);
1219 }
1220 /**
1221 * @tc.name : Test AudioRingCache API
1222 * @tc.type : FUNC
1223 * @tc.number: ReadInnerCapConfigFromParcel_003
1224 * @tc.desc : Test cross ring cache.
1225 */
1226 HWTEST(AudioServiceCommonUnitTest, ReadInnerCapConfigFromParcel_003, TestSize.Level1)
1227 {
1228 MessageParcel parcel;
1229 AudioPlaybackCaptureConfig config;
1230
1231 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_ALARM);
1232 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION);
1233 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_RINGTONE);
1234
1235 int ret = config.Marshalling(parcel);
1236 EXPECT_NE(ret, SUCCESS);
1237 }
1238 /**
1239 * @tc.name : Test AudioRingCache API
1240 * @tc.type : FUNC
1241 * @tc.number: ReadInnerCapConfigFromParcel_004
1242 * @tc.desc : Test cross ring cache.
1243 */
1244 HWTEST(AudioServiceCommonUnitTest, ReadInnerCapConfigFromParcel_004, TestSize.Level1)
1245 {
1246 MessageParcel parcel;
1247 AudioPlaybackCaptureConfig config;
1248
1249 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_ALARM);
1250 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION);
1251 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_ENFORCED_TONE);
1252 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_INVALID);
1253
1254 int ret = config.Marshalling(parcel);
1255 EXPECT_NE(ret, SUCCESS);
1256 }
1257 /**
1258 * @tc.name : Test AudioRingCache API
1259 * @tc.type : FUNC
1260 * @tc.number: ReadInnerCapConfigFromParcel_005
1261 * @tc.desc : Test cross ring cache.
1262 */
1263 HWTEST(AudioServiceCommonUnitTest, ReadInnerCapConfigFromParcel_005, TestSize.Level1)
1264 {
1265 MessageParcel parcel;
1266 AudioPlaybackCaptureConfig config;
1267
1268 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_ALARM);
1269 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_VOICE_COMMUNICATION);
1270 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_MEDIA);
1271 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_MEDIA);
1272 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_MEDIA);
1273 config.filterOptions.usages.push_back(StreamUsage::STREAM_USAGE_ALARM);
1274
1275 int ret = 0;
1276 ret = config.Marshalling(parcel);
1277 EXPECT_NE(ret, SUCCESS);
1278 }
1279
1280 /**
1281 * @tc.name : Test LinearPosTimeModel API
1282 * @tc.type : FUNC
1283 * @tc.number: LinearPosTimeModel_003
1284 * @tc.desc : Test LinearPosTimeModel interface.
1285 */
1286 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_003, TestSize.Level1)
1287 {
1288 auto linearPos = std::make_unique<LinearPosTimeModel>();
1289 ASSERT_TRUE(linearPos != nullptr);
1290
1291 uint64_t frame = 0;
1292 int64_t nanoTime = 0;
1293 for (int i = 0; i < 10; i++) {
1294 linearPos->posTimeVec_.push_back(std::make_pair(frame, nanoTime));
1295 if (frame < 5) {
1296 frame++;
1297 }
1298 nanoTime++;
1299 }
1300 linearPos->sampleRate_ = 1;
1301 auto ret = linearPos->CheckReasonable(frame, nanoTime);
1302 EXPECT_EQ(ret, CHECK_FAILED);
1303 }
1304
1305 /**
1306 * @tc.name : Test LinearPosTimeModel API
1307 * @tc.type : FUNC
1308 * @tc.number: LinearPosTimeModel_004
1309 * @tc.desc : Test LinearPosTimeModel interface.
1310 */
1311 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_004, TestSize.Level1)
1312 {
1313 auto linearPos = std::make_unique<LinearPosTimeModel>();
1314 ASSERT_TRUE(linearPos != nullptr);
1315
1316 uint64_t posInFrame = 20;
1317 linearPos->isConfiged = true;
1318 linearPos->sampleRate_ = 1;
1319 auto ret = linearPos->GetTimeOfPos(posInFrame);
1320 EXPECT_NE(ret, -1);
1321 }
1322
1323 /**
1324 * @tc.name : Test LinearPosTimeModel API
1325 * @tc.type : FUNC
1326 * @tc.number: LinearPosTimeModel_005
1327 * @tc.desc : Test LinearPosTimeModel interface.
1328 */
1329 HWTEST(AudioServiceCommonUnitTest, LinearPosTimeModel_005, TestSize.Level1)
1330 {
1331 auto linearPos = std::make_unique<LinearPosTimeModel>();
1332 ASSERT_TRUE(linearPos != nullptr);
1333
1334 uint64_t posInFrame = 0;
1335 linearPos->stampFrame_ = 5;
1336 linearPos->isConfiged = true;
1337 linearPos->sampleRate_ = 1;
1338 auto ret = linearPos->GetTimeOfPos(posInFrame);
1339 EXPECT_NE(ret, -1);
1340 }
1341
1342 /**
1343 * @tc.name : Test CheckWriteOrReadFrame API
1344 * @tc.type : FUNC
1345 * @tc.number: CheckWriteOrReadFrame_001
1346 * @tc.desc : Test CheckWriteOrReadFrame interface.
1347 */
1348 HWTEST(AudioServiceCommonUnitTest, CheckWriteOrReadFrame_001, TestSize.Level1)
1349 {
1350 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 0;
1351 EXPECT_FALSE(g_oHAudioBuffer->CheckWriteOrReadFrame(100));
1352 }
1353
1354 /**
1355 * @tc.name : Test CheckWriteOrReadFrame API
1356 * @tc.type : FUNC
1357 * @tc.number: CheckWriteOrReadFrame_002
1358 * @tc.desc : Test CheckWriteOrReadFrame interface.
1359 */
1360 HWTEST(AudioServiceCommonUnitTest, CheckWriteOrReadFrame_002, TestSize.Level1)
1361 {
1362 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 10;
1363 EXPECT_FALSE(g_oHAudioBuffer->CheckWriteOrReadFrame(15));
1364 }
1365
1366 /**
1367 * @tc.name : Test CheckWriteOrReadFrame API
1368 * @tc.type : FUNC
1369 * @tc.number: CheckWriteOrReadFrame_003
1370 * @tc.desc : Test CheckWriteOrReadFrame interface.
1371 */
1372 HWTEST(AudioServiceCommonUnitTest, CheckWriteOrReadFrame_003, TestSize.Level1)
1373 {
1374 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 10;
1375 EXPECT_TRUE(g_oHAudioBuffer->CheckWriteOrReadFrame(20));
1376 }
1377
1378 /**
1379 * @tc.name : Test SizeCheck API
1380 * @tc.type : FUNC
1381 * @tc.number: SizeCheck_001
1382 * @tc.desc : Test SizeCheck interface.
1383 */
1384 HWTEST(AudioServiceCommonUnitTest, SizeCheck_001, TestSize.Level1)
1385 {
1386 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 0;
1387 g_oHAudioBuffer->spanBasicInfo_.spanSizeInByte_ = 100;
1388 g_oHAudioBuffer->spanBasicInfo_.spanConut_ = 10;
1389 uint32_t totalSizeFrame = 1000;
1390 int32_t result = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame);
1391 EXPECT_EQ(result, ERR_INVALID_PARAM);
1392 }
1393
1394 /**
1395 * @tc.name : Test SizeCheck API
1396 * @tc.type : FUNC
1397 * @tc.number: SizeCheck_002
1398 * @tc.desc : Test SizeCheck interface.
1399 */
1400 HWTEST(AudioServiceCommonUnitTest, SizeCheck_002, TestSize.Level1)
1401 {
1402 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 100;
1403 g_oHAudioBuffer->spanBasicInfo_.spanSizeInByte_ = 0;
1404 g_oHAudioBuffer->spanBasicInfo_.spanConut_ = 10;
1405 uint32_t totalSizeFrame = 1000;
1406 int32_t result = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame);
1407 EXPECT_EQ(result, ERR_INVALID_PARAM);
1408 }
1409
1410 /**
1411 * @tc.name : Test SizeCheck API
1412 * @tc.type : FUNC
1413 * @tc.number: SizeCheck_003
1414 * @tc.desc : Test SizeCheck interface.
1415 */
1416 HWTEST(AudioServiceCommonUnitTest, SizeCheck_003, TestSize.Level1)
1417 {
1418 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 100;
1419 g_oHAudioBuffer->spanBasicInfo_.spanSizeInByte_ = 100;
1420 g_oHAudioBuffer->spanBasicInfo_.spanConut_ = 10;
1421 uint32_t totalSizeFrame = 1000;
1422 int32_t result = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame);
1423 EXPECT_NE(result, ERR_INVALID_PARAM);
1424 }
1425
1426 /**
1427 * @tc.name : Test SizeCheck API
1428 * @tc.type : FUNC
1429 * @tc.number: SizeCheck_004
1430 * @tc.desc : Test SizeCheck interface.
1431 */
1432 HWTEST(AudioServiceCommonUnitTest, SizeCheck_004, TestSize.Level1)
1433 {
1434 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 100;
1435 g_oHAudioBuffer->spanBasicInfo_.spanSizeInByte_ = 100;
1436 g_oHAudioBuffer->spanBasicInfo_.spanConut_ = 10;
1437 uint32_t totalSizeFrame = 50;
1438 int32_t result = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame);
1439 EXPECT_EQ(result, ERR_INVALID_PARAM);
1440
1441 uint32_t totalSizeFrame1 = 50;
1442 int32_t ret = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame1);
1443 EXPECT_EQ(ret, ERR_INVALID_PARAM);
1444 }
1445
1446 /**
1447 * @tc.name : Test SizeCheck API
1448 * @tc.type : FUNC
1449 * @tc.number: SizeCheck_005
1450 * @tc.desc : Test SizeCheck interface.
1451 */
1452 HWTEST(AudioServiceCommonUnitTest, SizeCheck_005, TestSize.Level1)
1453 {
1454 g_oHAudioBuffer->spanBasicInfo_.spanSizeInFrame_ = 100;
1455 g_oHAudioBuffer->spanBasicInfo_.spanSizeInByte_ = 100;
1456 g_oHAudioBuffer->spanBasicInfo_.spanConut_ = 10;
1457 uint32_t totalSizeFrame = 1000;
1458 int32_t result = g_oHAudioBuffer->spanBasicInfo_.SizeCheck(totalSizeFrame);
1459 EXPECT_EQ(result, SUCCESS);
1460 }
1461
1462 /**
1463 * @tc.name : Test ReadFromParcel API
1464 * @tc.type : FUNC
1465 * @tc.number: ReadFromParcel_001
1466 * @tc.desc : Test ReadFromParcel interface.
1467 */
1468 HWTEST(AudioServiceCommonUnitTest, ReadFromParcel_001, TestSize.Level1)
1469 {
1470 MessageParcel parcel;
1471 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT));
1472 std::shared_ptr<OHAudioBuffer> buffer = OHAudioBuffer::ReadFromParcel(parcel);
1473 EXPECT_EQ(buffer, nullptr);
1474 }
1475
1476 /**
1477 * @tc.name : Test ReadFromParcel API
1478 * @tc.type : FUNC
1479 * @tc.number: ReadFromParcel_002
1480 * @tc.desc : Test ReadFromParcel interface.
1481 */
1482 HWTEST(AudioServiceCommonUnitTest, ReadFromParcel_002, TestSize.Level1)
1483 {
1484 MessageParcel parcel;
1485 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_SHARED));
1486 parcel.WriteUint32(0);
1487 int dataFd = 1;
1488 int infoFd = 2;
1489 parcel.WriteFileDescriptor(dataFd);
1490 parcel.WriteFileDescriptor(infoFd);
1491 std::shared_ptr<OHAudioBuffer> buffer = OHAudioBuffer::ReadFromParcel(parcel);
1492 EXPECT_EQ(buffer, nullptr);
1493 }
1494
1495 /**
1496 * @tc.name : Test ReadFromParcel API
1497 * @tc.type : FUNC
1498 * @tc.number: AudioSharedMemory_ReadFromParcel_001
1499 * @tc.desc : Test AudioSharedMemory::ReadFromParcel interface.
1500 */
1501 HWTEST(AudioServiceCommonUnitTest, AudioSharedMemory_ReadFromParcel_001, TestSize.Level4)
1502 {
1503 MessageParcel parcel;
1504 parcel.WriteUint64(100);
1505 parcel.WriteString("testName");
1506 auto memory = AudioSharedMemory::ReadFromParcel(parcel);
1507 EXPECT_EQ(memory, nullptr);
1508 }
1509
1510 /**
1511 * @tc.name : Test Unmarshalling API
1512 * @tc.type : FUNC
1513 * @tc.number: OHAudioBufferBase_Unmarshalling_001
1514 * @tc.desc : Test OHAudioBufferBase::Unmarshalling interface.
1515 */
1516 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_Unmarshalling_001, TestSize.Level4)
1517 {
1518 Parcel parcel;
1519 MessageParcel &messageParcel = static_cast<MessageParcel &>(parcel);
1520 messageParcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_SHARED) + 1);
1521 messageParcel.WriteUint32(10);
1522 messageParcel.WriteUint32(10);
1523 messageParcel.WriteFileDescriptor(3);
1524 messageParcel.WriteFileDescriptor(4);
1525
1526 auto buffer = OHAudioBufferBase::Unmarshalling(parcel);
1527 EXPECT_EQ(buffer, nullptr);
1528 }
1529
1530 /**
1531 * @tc.name : Test CreateFromRemote API
1532 * @tc.type : FUNC
1533 * @tc.number: OHAudioBufferBase_CreateFromRemote _001
1534 * @tc.desc : Test OHAudioBufferBase::CreateFromRemote interface.
1535 */
1536 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_CreateFromRemote_001, TestSize.Level4)
1537 {
1538 uint32_t totalSizeInFrame = 10;
1539 uint32_t byteSizePerFrame = 10;
1540 AudioBufferHolder bufferHolder = AUDIO_CLIENT;
1541 int dataFd = 3;
1542 int infoFd = 1;
1543
1544 std::shared_ptr<OHAudioBufferBase> buffer = OHAudioBufferBase::CreateFromRemote(totalSizeInFrame,
1545 byteSizePerFrame, bufferHolder, dataFd, infoFd);
1546 EXPECT_EQ(buffer, nullptr);
1547 }
1548
1549 /**
1550 * @tc.name : Test ReadFromParcel API
1551 * @tc.type : FUNC
1552 * @tc.number: OHAudioBufferBase_ReadFromParcel_001
1553 * @tc.desc : Test OHAudioBufferBase::ReadFromParcel interface.
1554 */
1555 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_ReadFromParcel_001, TestSize.Level4)
1556 {
1557 MessageParcel parcel;
1558 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_ONLY));
1559 parcel.WriteUint32(100);
1560 parcel.WriteUint32(10);
1561 int dataFd = 1;
1562 int infoFd = 2;
1563 parcel.WriteFileDescriptor(dataFd);
1564 parcel.WriteFileDescriptor(infoFd);
1565 std::shared_ptr<OHAudioBufferBase> buffer = OHAudioBufferBase::ReadFromParcel(parcel);
1566 EXPECT_EQ(buffer, nullptr);
1567 }
1568
1569 /**
1570 * @tc.name : Test ReadFromParcel API
1571 * @tc.type : FUNC
1572 * @tc.number: OHAudioBufferBase_ReadFromParcel_002
1573 * @tc.desc : Test OHAudioBufferBase::ReadFromParcel interface.
1574 */
1575 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_ReadFromParcel_002, TestSize.Level4)
1576 {
1577 MessageParcel parcel;
1578 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_INDEPENDENT));
1579 parcel.WriteUint32(100);
1580 parcel.WriteUint32(10);
1581 int dataFd = 1;
1582 int infoFd = 2;
1583 parcel.WriteFileDescriptor(dataFd);
1584 parcel.WriteFileDescriptor(infoFd);
1585 std::shared_ptr<OHAudioBufferBase> buffer = OHAudioBufferBase::ReadFromParcel(parcel);
1586 EXPECT_EQ(buffer, nullptr);
1587 }
1588
1589 /**
1590 * @tc.name : Test ReadFromParcel API
1591 * @tc.type : FUNC
1592 * @tc.number: OHAudioBufferBase_ReadFromParcel_003
1593 * @tc.desc : Test OHAudioBufferBase::ReadFromParcel interface.
1594 */
1595 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_ReadFromParcel_003, TestSize.Level4)
1596 {
1597 MessageParcel parcel;
1598 parcel.WriteUint32(static_cast<uint32_t>(AudioBufferHolder::AUDIO_SERVER_SHARED));
1599 parcel.WriteUint32(100);
1600 parcel.WriteUint32(10);
1601 int dataFd = 3;
1602 int infoFd = 4;
1603 parcel.WriteFileDescriptor(dataFd);
1604 parcel.WriteFileDescriptor(infoFd);
1605 std::shared_ptr<OHAudioBufferBase> buffer = OHAudioBufferBase::ReadFromParcel(parcel);
1606 EXPECT_EQ(buffer, nullptr);
1607 }
1608
1609 /**
1610 * @tc.name : Test GetSyncWriteFrame API
1611 * @tc.type : FUNC
1612 * @tc.number: OHAudioBufferBase_GetSyncWriteFrame_001
1613 * @tc.desc : Test GetSyncWriteFrame interface.
1614 */
1615 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetSyncWriteFrame_001, TestSize.Level1)
1616 {
1617 OHAudioBufferBase audioBufferBase(AUDIO_SERVER_ONLY_WITH_SYNC, 100, 10);
1618 audioBufferBase.bufferHolder_ = AUDIO_SERVER_ONLY_WITH_SYNC;
1619 audioBufferBase.syncWriteFrame_ = nullptr;
1620 EXPECT_EQ(audioBufferBase.GetSyncWriteFrame(), 0);
1621 }
1622
1623 /**
1624 * @tc.name : Test GetSyncWriteFrame API
1625 * @tc.type : FUNC
1626 * @tc.number: OHAudioBufferBase_GetSyncWriteFrame_002
1627 * @tc.desc : Test GetSyncWriteFrame interface.
1628 */
1629 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetSyncWriteFrame_002, TestSize.Level1)
1630 {
1631 OHAudioBufferBase audioBufferBase(AUDIO_SERVER_ONLY_WITH_SYNC, 100, 10);
1632 audioBufferBase.bufferHolder_ = AUDIO_SERVER_ONLY_WITH_SYNC;
1633 uint32_t syncWriteFrame = 50;
1634 audioBufferBase.syncWriteFrame_ = &syncWriteFrame;
1635 EXPECT_EQ(audioBufferBase.GetSyncWriteFrame(), syncWriteFrame);
1636 }
1637
1638 /**
1639 * @tc.name : Test SetSyncReadFrame API
1640 * @tc.type : FUNC
1641 * @tc.number: OHAudioBufferBase_SetSyncReadFrame_001
1642 * @tc.desc : Test SetSyncReadFrame interface.
1643 */
1644 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_SetSyncReadFrame_001, TestSize.Level1)
1645 {
1646 uint32_t syncWriteFrame = 50;
1647 OHAudioBufferBase audioBufferBase(AUDIO_SERVER_ONLY_WITH_SYNC, 100, 10);
1648 audioBufferBase.bufferHolder_ = AUDIO_SERVER_ONLY_WITH_SYNC;
1649 audioBufferBase.syncReadFrame_ = &syncWriteFrame;
1650 uint32_t readFrame = 10;
1651 EXPECT_TRUE(audioBufferBase.SetSyncReadFrame(readFrame));
1652 }
1653
1654 /**
1655 * @tc.name : Test GetFutex API
1656 * @tc.type : FUNC
1657 * @tc.number: OHAudioBufferBase_GetFutex_001
1658 * @tc.desc : Test OHAudioBufferBase::GetFutex() interface.
1659 */
1660 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetFutex_001, TestSize.Level1)
1661 {
1662 OHAudioBufferBase audioBufferBase(AUDIO_SERVER_ONLY_WITH_SYNC, 100, 10);
1663 audioBufferBase.basicBufferInfo_ = nullptr;
1664 EXPECT_EQ(audioBufferBase.GetFutex(), nullptr);
1665 }
1666
1667 /**
1668 * @tc.name : Test SetRestoreStatus API
1669 * @tc.type : FUNC
1670 * @tc.number: OHAudioBufferBase_SetRestoreStatus_001
1671 * @tc.desc : Test SetRestoreStatus interface.
1672 */
1673 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_SetRestoreStatus_001, TestSize.Level1)
1674 {
1675 uint32_t spanSizeInFrame = 1000;
1676 uint32_t totalSizeInFrame = spanSizeInFrame;
1677 uint32_t byteSizePerFrame = 100;
1678 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1679 RestoreStatus result = ohAudioBuffer->SetRestoreStatus(NO_NEED_FOR_RESTORE);
1680 EXPECT_NE(RESTORING, result);
1681 }
1682
1683 /**
1684 * @tc.name : Test GetStreamVolume API
1685 * @tc.type : FUNC
1686 * @tc.number: OHAudioBufferBase_GetStreamVolume_001
1687 * @tc.desc : Test GetStreamVolume interface.
1688 */
1689 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetStreamVolume_001, TestSize.Level1)
1690 {
1691 uint32_t spanSizeInFrame = 1000;
1692 uint32_t totalSizeInFrame = spanSizeInFrame;
1693 uint32_t byteSizePerFrame = 100;
1694 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1695 ohAudioBuffer->basicBufferInfo_->streamVolume.store(MAX_FLOAT_VOLUME + 0.1);
1696 float result = ohAudioBuffer->GetStreamVolume();
1697 EXPECT_FLOAT_EQ(result, MAX_FLOAT_VOLUME);
1698 }
1699
1700 /**
1701 * @tc.name : Test GetStreamVolume API
1702 * @tc.type : FUNC
1703 * @tc.number: OHAudioBufferBase_GetStreamVolume_002
1704 * @tc.desc : Test GetStreamVolume interface.
1705 */
1706 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetStreamVolume_002, TestSize.Level1)
1707 {
1708 uint32_t spanSizeInFrame = 1000;
1709 uint32_t totalSizeInFrame = spanSizeInFrame;
1710 uint32_t byteSizePerFrame = 100;
1711 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1712 ohAudioBuffer->basicBufferInfo_->streamVolume.store(MIN_FLOAT_VOLUME - 0.1);
1713 float result = ohAudioBuffer->GetStreamVolume();
1714 EXPECT_FLOAT_EQ(result, MIN_FLOAT_VOLUME);
1715 }
1716
1717 /**
1718 * @tc.name : Test GetMuteFactor API
1719 * @tc.type : FUNC
1720 * @tc.number: OHAudioBufferBase_GetMuteFactor_001
1721 * @tc.desc : Test GetMuteFactor interface.
1722 */
1723 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetMuteFactor_001, TestSize.Level1)
1724 {
1725 uint32_t spanSizeInFrame = 1000;
1726 uint32_t totalSizeInFrame = spanSizeInFrame;
1727 uint32_t byteSizePerFrame = 100;
1728 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1729 ohAudioBuffer->basicBufferInfo_->muteFactor.store(MAX_FLOAT_VOLUME + 0.1);
1730 float result = ohAudioBuffer->GetMuteFactor();
1731 EXPECT_FLOAT_EQ(result, MAX_FLOAT_VOLUME);
1732 }
1733
1734 /**
1735 * @tc.name : Test GetMuteFactor API
1736 * @tc.type : FUNC
1737 * @tc.number: OHAudioBufferBase_GetMuteFactor_002
1738 * @tc.desc : Test GetMuteFactor interface.
1739 */
1740 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetMuteFactor_002, TestSize.Level1)
1741 {
1742 uint32_t spanSizeInFrame = 1000;
1743 uint32_t totalSizeInFrame = spanSizeInFrame;
1744 uint32_t byteSizePerFrame = 100;
1745 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1746 ohAudioBuffer->basicBufferInfo_->muteFactor.store(MIN_FLOAT_VOLUME - 0.1);
1747 float result = ohAudioBuffer->GetMuteFactor();
1748 EXPECT_FLOAT_EQ(result, MIN_FLOAT_VOLUME);
1749 }
1750
1751 /**
1752 * @tc.name : Test GetDuckFactor API
1753 * @tc.type : FUNC
1754 * @tc.number: OHAudioBufferBase_GetDuckFactor_001
1755 * @tc.desc : Test GetDuckFactor interface.
1756 */
1757 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetDuckFactor_001, TestSize.Level1)
1758 {
1759 uint32_t spanSizeInFrame = 1000;
1760 uint32_t totalSizeInFrame = spanSizeInFrame;
1761 uint32_t byteSizePerFrame = 100;
1762 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1763 ohAudioBuffer->basicBufferInfo_->duckFactor.store(MAX_FLOAT_VOLUME + 0.1);
1764 float result = ohAudioBuffer->GetDuckFactor();
1765 EXPECT_FLOAT_EQ(result, MAX_FLOAT_VOLUME);
1766 }
1767
1768 /**
1769 * @tc.name : Test GetDuckFactor API
1770 * @tc.type : FUNC
1771 * @tc.number: OHAudioBufferBase_GetDuckFactor_002
1772 * @tc.desc : Test GetDuckFactor interface.
1773 */
1774 HWTEST(AudioServiceCommonUnitTest, OHAudioBufferBase_GetDuckFactor_002, TestSize.Level1)
1775 {
1776 uint32_t spanSizeInFrame = 1000;
1777 uint32_t totalSizeInFrame = spanSizeInFrame;
1778 uint32_t byteSizePerFrame = 100;
1779 auto ohAudioBuffer = OHAudioBufferBase::CreateFromLocal(totalSizeInFrame, byteSizePerFrame);
1780 ohAudioBuffer->basicBufferInfo_->duckFactor.store(MIN_FLOAT_VOLUME - 0.1);
1781 float result = ohAudioBuffer->GetDuckFactor();
1782 EXPECT_FLOAT_EQ(result, MIN_FLOAT_VOLUME);
1783 }
1784 } // namespace AudioStandard
1785 } // namespace OHOS