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 "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 <gtest/gtest.h>
24 #include <gmock/gmock.h>
25 #include "hpae_renderer_stream_impl.h"
26 #include "policy_handler.h"
27 #include "hpae_adapter_manager.h"
28 #include "audio_capturer_private.h"
29 #include "audio_system_manager.h"
30 #include "audio_system_manager.h"
31
32 using namespace testing::ext;
33 using namespace testing;
34 namespace OHOS {
35 namespace AudioStandard {
36 const int32_t CAPTURER_FLAG = 10;
37 static std::shared_ptr<HpaeAdapterManager> adapterManager;
38
39 class HpaeRendererStreamUnitTest : public ::testing::Test {
40 public:
41 void SetUp();
42 void TearDown();
43 std::shared_ptr<HpaeRendererStreamImpl> CreateHpaeRendererStreamImpl();
44 };
SetUp(void)45 void HpaeRendererStreamUnitTest::SetUp(void)
46 {
47 // input testcase setup step，setup invoked before each testcases
48 }
49
TearDown(void)50 void HpaeRendererStreamUnitTest::TearDown(void)
51 {
52 // input testcase teardown step，teardown invoked after each testcases
53 }
54
GetInnerCapConfig()55 static AudioProcessConfig GetInnerCapConfig()
56 {
57 AudioProcessConfig config;
58 config.appInfo.appUid = CAPTURER_FLAG;
59 config.appInfo.appPid = CAPTURER_FLAG;
60 config.streamInfo.format = SAMPLE_S32LE;
61 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
62 config.streamInfo.channels = STEREO;
63 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
64 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
65 config.streamType = AudioStreamType::STREAM_MUSIC;
66 config.deviceType = DEVICE_TYPE_USB_HEADSET;
67 config.innerCapId = 1;
68 config.originalSessionId = 123456; // 123456: session id
69 return config;
70 }
71
CreateHpaeRendererStreamImpl()72 std::shared_ptr<HpaeRendererStreamImpl> HpaeRendererStreamUnitTest::CreateHpaeRendererStreamImpl()
73 {
74 adapterManager = std::make_shared<HpaeAdapterManager>(DUP_PLAYBACK);
75 AudioProcessConfig processConfig = GetInnerCapConfig();
76 std::string deviceName = "";
77 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, deviceName);
78 std::shared_ptr<HpaeRendererStreamImpl> rendererStreamImpl =
79 std::static_pointer_cast<HpaeRendererStreamImpl>(rendererStream);
80 return rendererStreamImpl;
81 }
82
83 /**
84 * @tc.name : Test AudioProcessProxy API
85 * @tc.type : FUNC
86 * @tc.number: GetCurrentTimeStamp_001
87 * @tc.desc : Test AudioProcessProxy interface.
88 */
89 HWTEST_F(HpaeRendererStreamUnitTest, GetCurrentTimeStamp_001, TestSize.Level1)
90 {
91 auto unit = CreateHpaeRendererStreamImpl();
92 EXPECT_NE(unit, nullptr);
93 uint64_t timestamp = 0;
94 int32_t ret = unit->GetCurrentTimeStamp(timestamp);
95 EXPECT_EQ(ret, SUCCESS);
96 }
97
98 /**
99 * @tc.name : Test GetCurrentTimeStamp
100 * @tc.type : FUNC
101 * @tc.number: GetCurrentTimeStamp_002
102 * @tc.desc : Test GetCurrentTimeStamp.
103 */
104 HWTEST_F(HpaeRendererStreamUnitTest, GetCurrentTimeStamp_002, TestSize.Level1)
105 {
106 auto unit = CreateHpaeRendererStreamImpl();
107 EXPECT_NE(unit, nullptr);
108 uint64_t timestamp = 0;
109 int32_t ret = unit->GetCurrentTimeStamp(timestamp);
110 EXPECT_EQ(ret, SUCCESS);
111 }
112
113 /**
114 * @tc.name : Test AudioProcessProxy API
115 * @tc.type : FUNC
116 * @tc.number: HpaeRenderer_001
117 * @tc.desc : Test AudioProcessProxy interface.
118 */
119 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_001, TestSize.Level1)
120 {
121 auto unit = CreateHpaeRendererStreamImpl();
122 EXPECT_NE(unit, nullptr);
123 int32_t rate = RENDER_RATE_NORMAL;
124 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
125 }
126
127 /**
128 * @tc.name : Test AudioProcessProxy API
129 * @tc.type : FUNC
130 * @tc.number: HpaeRenderer_002
131 * @tc.desc : Test AudioProcessProxy interface.
132 */
133 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_002, TestSize.Level1)
134 {
135 auto unit = CreateHpaeRendererStreamImpl();
136 EXPECT_NE(unit, nullptr);
137 int32_t rate = RENDER_RATE_DOUBLE;
138 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
139 }
140
141
142 /**
143 * @tc.name : Test AudioProcessProxy API
144 * @tc.type : FUNC
145 * @tc.number: HpaeRenderer_003
146 * @tc.desc : Test AudioProcessProxy interface.
147 */
148 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_003, TestSize.Level1)
149 {
150 auto unit = CreateHpaeRendererStreamImpl();
151 EXPECT_NE(unit, nullptr);
152 int32_t rate = RENDER_RATE_HALF;
153 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
154 }
155
156 /**
157 * @tc.name : Test GetCurrentPosition
158 * @tc.type : FUNC
159 * @tc.number: HpaeRenderer_004
160 * @tc.desc : Test GetCurrentPosition.
161 */
162 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_004, TestSize.Level1)
163 {
164 auto unit = CreateHpaeRendererStreamImpl();
165 EXPECT_NE(unit, nullptr);
166 uint64_t timestamp = 0;
167 uint64_t framePosition = 0;
168 uint64_t latency = 0;
169 int32_t ret = unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
170 EXPECT_EQ(ret, SUCCESS);
171 unit->deviceClass_ = "remote_offload";
172 ret = unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
173 EXPECT_EQ(ret, SUCCESS);
174 unit->deviceClass_ = "offload";
175 ret = unit->GetCurrentPosition(framePosition, timestamp, latency, Timestamp::MONOTONIC);
176 EXPECT_EQ(ret, SUCCESS);
177 }
178
179 /**
180 * @tc.name : Test GetCurrentPosition.
181 * @tc.type : FUNC
182 * @tc.number: HpaeRenderer_005
183 * @tc.desc : Test GetCurrentPosition.
184 */
185 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_005, TestSize.Level1)
186 {
187 auto unit = CreateHpaeRendererStreamImpl();
188 EXPECT_NE(unit, nullptr);
189 int32_t rate = RENDER_RATE_NORMAL;
190 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
191 }
192
193 /**
194 * @tc.name : Test OffloadSetVolume.
195 * @tc.type : FUNC
196 * @tc.number: HpaeRenderer_006
197 * @tc.desc : Test OffloadSetVolume.
198 */
199 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_006, TestSize.Level1)
200 {
201 auto unit = CreateHpaeRendererStreamImpl();
202 EXPECT_NE(unit, nullptr);
203 unit->offloadEnable_ = false;
204 float volume = 0.0f;
205 auto ret = unit->OffloadSetVolume(volume);
206 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
207 }
208
209 /**
210 * @tc.name : Test UpdateSpatializationState.
211 * @tc.type : FUNC
212 * @tc.number: HpaeRenderer_007
213 * @tc.desc : Test UpdateSpatializationState.
214 */
215 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_007, TestSize.Level1)
216 {
217 auto unit = CreateHpaeRendererStreamImpl();
218 EXPECT_NE(unit, nullptr);
219 bool spatializationEnabled = false;
220 bool headTrackingEnabled = false;
221 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
222 EXPECT_EQ(ret, SUCCESS);
223 }
224
225 /**
226 * @tc.name : Test UpdateSpatializationState.
227 * @tc.type : FUNC
228 * @tc.number: HpaeRenderer_008
229 * @tc.desc : Test UpdateSpatializationState.
230 */
231 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_008, TestSize.Level1)
232 {
233 auto unit = CreateHpaeRendererStreamImpl();
234 EXPECT_NE(unit, nullptr);
235 bool spatializationEnabled = false;
236 bool headTrackingEnabled = false;
237 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
238 EXPECT_EQ(ret, SUCCESS);
239 }
240
241 /**
242 * @tc.name : Test GetOffloadApproximatelyCacheTime.
243 * @tc.type : FUNC
244 * @tc.number: HpaeRenderer_009
245 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
246 */
247 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_009, TestSize.Level1)
248 {
249 auto unit = CreateHpaeRendererStreamImpl();
250 EXPECT_NE(unit, nullptr);
251 unit->offloadEnable_ = false;
252 uint64_t timestamp = 0;
253 uint64_t paWriteIndex = 0;
254 uint64_t cacheTimeDsp = 0;
255 uint64_t cacheTimePa = 0;
256 int32_t result = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
257 EXPECT_EQ(result, ERR_OPERATION_FAILED);
258 }
259
260 /**
261 * @tc.name : Test GetOffloadApproximatelyCacheTime.
262 * @tc.type : FUNC
263 * @tc.number: HpaeRenderer_010
264 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
265 */
266 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_010, TestSize.Level1)
267 {
268 auto unit = CreateHpaeRendererStreamImpl();
269 EXPECT_NE(unit, nullptr);
270 unit->offloadEnable_ = true;
271 uint64_t timestamp = 0;
272 uint64_t paWriteIndex = 0;
273 uint64_t cacheTimeDsp = 0;
274 uint64_t cacheTimePa = 0;
275 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
276 EXPECT_EQ(ret, SUCCESS);
277 }
278
279 /**
280 * @tc.name : Test GetOffloadApproximatelyCacheTime.
281 * @tc.type : FUNC
282 * @tc.number: HpaeRenderer_011
283 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
284 */
285 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_011, TestSize.Level1)
286 {
287 auto unit = CreateHpaeRendererStreamImpl();
288 EXPECT_NE(unit, nullptr);
289 unit->offloadEnable_ = true;
290 uint64_t timestamp = 0;
291 uint64_t paWriteIndex = 0;
292 uint64_t cacheTimeDsp = 0;
293 uint64_t cacheTimePa = 0;
294 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
295 EXPECT_EQ(ret, SUCCESS);
296 }
297
298 /**
299 * @tc.name : Test SetClientVolume.
300 * @tc.type : FUNC
301 * @tc.number: HpaeRenderer_012
302 * @tc.desc : Test SetClientVolume.
303 */
304 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_012, TestSize.Level1)
305 {
306 auto unit = CreateHpaeRendererStreamImpl();
307 EXPECT_NE(unit, nullptr);
308 float clientVolume = -1;
309 int32_t ret = unit->SetClientVolume(clientVolume);
310 EXPECT_EQ(ret, ERR_INVALID_PARAM);
311 }
312
313 /**
314 * @tc.name : Test SetClientVolume.
315 * @tc.type : FUNC
316 * @tc.number: HpaeRenderer_013
317 * @tc.desc : Test SetClientVolume.
318 */
319 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_013, TestSize.Level1)
320 {
321 auto unit = CreateHpaeRendererStreamImpl();
322 EXPECT_NE(unit, nullptr);
323 float clientVolume = 1.5;
324 int32_t ret = unit->SetClientVolume(clientVolume);
325 EXPECT_EQ(ret, ERR_INVALID_PARAM);
326 }
327
328 /**
329 * @tc.name : Test SetClientVolume.
330 * @tc.type : FUNC
331 * @tc.number: HpaeRenderer_014
332 * @tc.desc : Test SetClientVolume.
333 */
334 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_014, TestSize.Level1)
335 {
336 auto unit = CreateHpaeRendererStreamImpl();
337 EXPECT_NE(unit, nullptr);
338 float clientVolume = 0.5;
339 int32_t ret = unit->SetClientVolume(clientVolume);
340 EXPECT_EQ(ret, SUCCESS);
341 }
342
343 /**
344 * @tc.name : Test GetWritableSize.
345 * @tc.type : FUNC
346 * @tc.number: HpaeRenderer_015
347 * @tc.desc : Test GetWritableSize.
348 */
349 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_015, TestSize.Level1)
350 {
351 auto unit = CreateHpaeRendererStreamImpl();
352 EXPECT_NE(unit, nullptr);
353 int32_t ret = unit->GetWritableSize();
354 EXPECT_EQ(ret, 0);
355 }
356
357 /**
358 * @tc.name : Test EnqueueBuffer.
359 * @tc.type : FUNC
360 * @tc.number: HpaeRenderer_016
361 * @tc.desc : Test EnqueueBuffer.
362 */
363 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_016, TestSize.Level1)
364 {
365 auto unit = CreateHpaeRendererStreamImpl();
366 EXPECT_NE(unit, nullptr);
367 BufferDesc bufferDesc = {
368 .buffer = nullptr,
369 .bufLength = 0,
370 .dataLength = 0,
371 .metaBuffer = nullptr,
372 .metaLength = 0
373 };
374 int32_t ret = unit->EnqueueBuffer(bufferDesc);
375 EXPECT_EQ(ret, ERROR);
376 }
377
378 /**
379 * @tc.name : Test SetAudioEffectMode.
380 * @tc.type : FUNC
381 * @tc.number: HpaeRenderer_017
382 * @tc.desc : Test SetAudioEffectMode.
383 */
384 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_017, TestSize.Level1)
385 {
386 auto unit = CreateHpaeRendererStreamImpl();
387 EXPECT_NE(unit, nullptr);
388 int32_t effectMode = 0;
389 int32_t ret = unit->SetAudioEffectMode(effectMode);
390 EXPECT_EQ(ret, SUCCESS);
391 }
392
393 /**
394 * @tc.name : Test SetAudioEffectMode.
395 * @tc.type : FUNC
396 * @tc.number: HpaeRenderer_018
397 * @tc.desc : Test SetAudioEffectMode.
398 */
399 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_018, TestSize.Level1)
400 {
401 auto unit = CreateHpaeRendererStreamImpl();
402 EXPECT_NE(unit, nullptr);
403 int32_t effectMode = 0;
404 int32_t ret = unit->SetAudioEffectMode(effectMode);
405 EXPECT_EQ(ret, SUCCESS);
406 }
407
408 /**
409 * @tc.name : Test Start.
410 * @tc.type : FUNC
411 * @tc.number: HpaeRenderer_019
412 * @tc.desc : Test Start.
413 */
414 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_019, TestSize.Level1)
415 {
416 auto unit = CreateHpaeRendererStreamImpl();
417 EXPECT_NE(unit, nullptr);
418 int32_t ret = unit->Start();
419 EXPECT_EQ(ret, SUCCESS);
420 }
421
422 /**
423 * @tc.name : Test Pause.
424 * @tc.type : FUNC
425 * @tc.number: HpaeRenderer_020
426 * @tc.desc : Test Pause.
427 */
428 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_020, TestSize.Level1)
429 {
430 auto unit = CreateHpaeRendererStreamImpl();
431 EXPECT_NE(unit, nullptr);
432 bool isStandby = false;
433 int32_t ret = unit->Pause(isStandby);
434 EXPECT_EQ(ret, SUCCESS);
435 }
436
437 /**
438 * @tc.name : Test Pause.
439 * @tc.type : FUNC
440 * @tc.number: HpaeRenderer_021
441 * @tc.desc : Test Pause.
442 */
443 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_021, TestSize.Level1)
444 {
445 auto unit = CreateHpaeRendererStreamImpl();
446 EXPECT_NE(unit, nullptr);
447 bool isStandby = false;
448 int32_t ret = unit->Pause(isStandby);
449 EXPECT_EQ(ret, SUCCESS);
450 }
451
452 /**
453 * @tc.name : Test Flush.
454 * @tc.type : FUNC
455 * @tc.number: HpaeRenderer_022
456 * @tc.desc : Test Flush.
457 */
458 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_022, TestSize.Level1)
459 {
460 auto unit = CreateHpaeRendererStreamImpl();
461 EXPECT_NE(unit, nullptr);
462 int32_t ret = unit->Flush();
463 EXPECT_EQ(ret, SUCCESS);
464 }
465
466 /**
467 * @tc.name : Test Flush.
468 * @tc.type : FUNC
469 * @tc.number: HpaeRenderer_023
470 * @tc.desc : Test Flush.
471 */
472 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_023, TestSize.Level1)
473 {
474 auto unit = CreateHpaeRendererStreamImpl();
475 EXPECT_NE(unit, nullptr);
476 int32_t ret = unit->Flush();
477 EXPECT_EQ(ret, SUCCESS);
478 }
479
480 /**
481 * @tc.name : Test Stop.
482 * @tc.type : FUNC
483 * @tc.number: HpaeRenderer_024
484 * @tc.desc : Test Stop.
485 */
486 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_024, TestSize.Level1)
487 {
488 auto unit = CreateHpaeRendererStreamImpl();
489 EXPECT_NE(unit, nullptr);
490 int32_t ret = unit->Stop();
491 EXPECT_EQ(ret, SUCCESS);
492 }
493
494 /**
495 * @tc.name : Test Release.
496 * @tc.type : FUNC
497 * @tc.number: HpaeRenderer_025
498 * @tc.desc : Test Release.
499 */
500 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_025, TestSize.Level1)
501 {
502 auto unit = CreateHpaeRendererStreamImpl();
503 EXPECT_NE(unit, nullptr);
504 unit->state_ = RUNNING;
505 int32_t ret = unit->Release();
506 EXPECT_EQ(ret, SUCCESS);
507 }
508
509 /**
510 * @tc.name : Test GetLatency.
511 * @tc.type : FUNC
512 * @tc.number: HpaeRenderer_026
513 * @tc.desc : Test GetLatency.
514 */
515 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_026, TestSize.Level1)
516 {
517 auto unit = CreateHpaeRendererStreamImpl();
518 EXPECT_NE(unit, nullptr);
519 uint64_t latency = 0;
520 int32_t ret = unit->GetLatency(latency);
521 EXPECT_EQ(ret, SUCCESS);
522 unit->deviceClass_ = "remote_offload";
523 ret = unit->GetLatency(latency);
524 EXPECT_EQ(ret, SUCCESS);
525 unit->deviceClass_ = "offload";
526 ret = unit->GetLatency(latency);
527 EXPECT_EQ(ret, SUCCESS);
528 }
529
530 /**
531 * @tc.name : Test Drain.
532 * @tc.type : FUNC
533 * @tc.number: HpaeRenderer_027
534 * @tc.desc : Test Drain.
535 */
536 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_027, TestSize.Level1)
537 {
538 auto unit = CreateHpaeRendererStreamImpl();
539 EXPECT_NE(unit, nullptr);
540 int32_t ret = unit->Drain();
541 EXPECT_EQ(ret, SUCCESS);
542 }
543
544 /**
545 * @tc.name : Test SetRate.
546 * @tc.type : FUNC
547 * @tc.number: HpaeRenderer_028
548 * @tc.desc : Test SetRate.
549 */
550 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_028, TestSize.Level1)
551 {
552 auto unit = CreateHpaeRendererStreamImpl();
553 EXPECT_NE(unit, nullptr);
554 int32_t rate = RENDER_RATE_NORMAL;
555 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
556 }
557
558 /**
559 * @tc.name : Test StartWithSyncId.
560 * @tc.type : FUNC
561 * @tc.number: HpaeRenderer_029
562 * @tc.desc : Test StartWithSyncId.
563 */
564 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_029, TestSize.Level1)
565 {
566 int32_t syncId = 123;
567 auto unit = CreateHpaeRendererStreamImpl();
568 EXPECT_NE(unit, nullptr);
569 int32_t ret = unit->StartWithSyncId(syncId);
570 EXPECT_EQ(ret, SUCCESS);
571 }
572
573 /**
574 * @tc.name : Test OnDeviceClassChange.
575 * @tc.type : FUNC
576 * @tc.number: HpaeRenderer_030
577 * @tc.desc : Test OnDeviceClassChange.
578 */
579 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_030, TestSize.Level1)
580 {
581 auto unit = CreateHpaeRendererStreamImpl();
582 EXPECT_NE(unit, nullptr);
583
584 AudioCallBackStreamInfo info = {
585 .deviceClass = "remote_offload",
586 .framePosition = 10000
587 };
588 unit->deviceClass_ = "primary";
589 unit->OnDeviceClassChange(info);
590 EXPECT_EQ(unit->lastHdiFramePosition_, 10000);
591 EXPECT_EQ(unit->lastFramePosition_, 10000);
592
593 info.deviceClass = "offload";
594 unit->OnDeviceClassChange(info);
595 EXPECT_EQ(unit->lastHdiFramePosition_, 10000);
596 EXPECT_EQ(unit->lastFramePosition_, 10000);
597
598 info.hdiFramePosition = 10000;
599 unit->OnDeviceClassChange(info);
600 EXPECT_GT(unit->lastHdiFramePosition_, 10000);
601 }
602
603 /**
604 * @tc.name : Test WriteDataFromRingBuffer.
605 * @tc.type : FUNC
606 * @tc.number: HpaeRenderer_031
607 * @tc.desc : Test WriteDataFromRingBuffer.
608 */
609 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_031, TestSize.Level0)
610 {
611 std::shared_ptr<HpaeRendererStreamImpl> hpaeRenderer = CreateHpaeRendererStreamImpl();
612 EXPECT_NE(hpaeRenderer, nullptr);
613
614 // 10 bytes
615 constexpr size_t bufferSize = 10;
616
617 hpaeRenderer->ringBuffer_ = AudioRingCache::Create(bufferSize);
618 std::vector<int8_t> tmpBuffer(bufferSize, 1);
619 hpaeRenderer->ringBuffer_->Enqueue({reinterpret_cast<uint8_t *>(tmpBuffer.data()), bufferSize});
620 tmpBuffer = std::vector<int8_t>(bufferSize, 0);
621 size_t requestDataLen = bufferSize;
622 int32_t ret = hpaeRenderer->WriteDataFromRingBuffer(false, tmpBuffer.data(), requestDataLen);
623 EXPECT_EQ(ret, SUCCESS);
624 EXPECT_EQ(requestDataLen, bufferSize);
625 EXPECT_THAT(tmpBuffer, Each(Eq(1)));
626 }
627
628 /**
629 * @tc.name : Test WriteDataFromRingBuffer.
630 * @tc.type : FUNC
631 * @tc.number: HpaeRenderer_032
632 * @tc.desc : Test WriteDataFromRingBuffer.
633 */
634 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_032, TestSize.Level0)
635 {
636 std::shared_ptr<HpaeRendererStreamImpl> hpaeRenderer = CreateHpaeRendererStreamImpl();
637 EXPECT_NE(hpaeRenderer, nullptr);
638
639 // 10 bytes
640 constexpr size_t bufferSize = 10;
641
642 hpaeRenderer->ringBuffer_ = AudioRingCache::Create(bufferSize);
643 std::vector<int8_t> tmpBuffer(bufferSize, 1);
644 hpaeRenderer->ringBuffer_->Enqueue({reinterpret_cast<uint8_t *>(tmpBuffer.data()), bufferSize - 1});
645 tmpBuffer = std::vector<int8_t>(bufferSize, 0);
646 size_t requestDataLen = bufferSize;
647 int32_t ret = hpaeRenderer->WriteDataFromRingBuffer(false, tmpBuffer.data(), requestDataLen);
648 EXPECT_NE(ret, SUCCESS);
649 }
650
651 /**
652 * @tc.name : Test WriteDataFromRingBuffer.
653 * @tc.type : FUNC
654 * @tc.number: HpaeRenderer_033
655 * @tc.desc : Test WriteDataFromRingBuffer.
656 */
657 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_033, TestSize.Level0)
658 {
659 std::shared_ptr<HpaeRendererStreamImpl> hpaeRenderer = CreateHpaeRendererStreamImpl();
660 EXPECT_NE(hpaeRenderer, nullptr);
661
662 // 10 bytes
663 constexpr size_t bufferSize = 10;
664
665 hpaeRenderer->ringBuffer_ = AudioRingCache::Create(bufferSize);
666 std::vector<int8_t> tmpBuffer(bufferSize, 1);
667 hpaeRenderer->ringBuffer_->Enqueue({reinterpret_cast<uint8_t *>(tmpBuffer.data()), bufferSize - 1});
668 tmpBuffer = std::vector<int8_t>(bufferSize, 2);
669 size_t requestDataLen = bufferSize;
670 int32_t ret = hpaeRenderer->WriteDataFromRingBuffer(true, tmpBuffer.data(), requestDataLen);
671 EXPECT_EQ(ret, SUCCESS);
672 EXPECT_EQ(requestDataLen, bufferSize - 1);
673 EXPECT_THAT(std::vector<int8_t>(tmpBuffer.begin(), tmpBuffer.end() - 1), Each(Eq(1)));
674 EXPECT_EQ(tmpBuffer[bufferSize - 1], 0);
675 }
676
677 /**
678 * @tc.name : Test OnStreamData.
679 * @tc.type : FUNC
680 * @tc.number: HpaeRenderer_034
681 * @tc.desc : Test OnStreamData.
682 */
683 HWTEST_F(HpaeRendererStreamUnitTest, HpaeRenderer_034, TestSize.Level1)
684 {
685 auto unit = CreateHpaeRendererStreamImpl();
686 EXPECT_NE(nullptr, unit);
687
688 AudioCallBackStreamInfo info = {
689 .deviceClass = "remote_offload",
690 .framePosition = 10000,
691 };
692
693 unit->OnStreamData(info);
694 EXPECT_EQ(10000, unit->lastHdiFramePosition_);
695 EXPECT_EQ(10000, unit->lastFramePosition_);
696
697 unit->isCallbackMode_ = false;
698 info.needData = true;
699 info.requestDataLen = 0;
700 unit->OnStreamData(info);
701 EXPECT_EQ(OFFLOAD_DEFAULT, unit->offloadStatePolicy_);
702 EXPECT_EQ(INVALID, unit->state_);
703 }
704 }
705 }