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 "pa_renderer_stream_impl.h"
25 #include "policy_handler.h"
26 #include "pa_adapter_manager.h"
27 #include "audio_capturer_private.h"
28 #include "audio_system_manager.h"
29 #include "audio_system_manager.h"
30
31 using namespace testing::ext;
32 namespace OHOS {
33 namespace AudioStandard {
34 const int32_t CAPTURER_FLAG = 10;
35 static std::shared_ptr<PaAdapterManager> adapterManager;
36
37 class PaRendererStreamUnitTest : public ::testing::Test {
38 public:
39 void SetUp();
40 void TearDown();
41 std::shared_ptr<PaRendererStreamImpl> CreatePaRendererStreamImpl();
42 };
SetUp(void)43 void PaRendererStreamUnitTest::SetUp(void)
44 {
45 // input testcase setup step，setup invoked before each testcases
46 }
47
TearDown(void)48 void PaRendererStreamUnitTest::TearDown(void)
49 {
50 // input testcase teardown step，teardown invoked after each testcases
51 }
52
53 #ifdef HAS_FEATURE_INNERCAPTURER
LoadPaPort()54 void LoadPaPort()
55 {
56 AudioPlaybackCaptureConfig checkConfig;
57 int32_t checkInnerCapId = 0;
58 AudioSystemManager::GetInstance()->CheckCaptureLimit(checkConfig, checkInnerCapId);
59 }
60
ReleasePaPort()61 void ReleasePaPort()
62 {
63 AudioSystemManager::GetInstance()->ReleaseCaptureLimit(1);
64 }
65 #endif
66
GetInnerCapConfig()67 static AudioProcessConfig GetInnerCapConfig()
68 {
69 AudioProcessConfig config;
70 config.appInfo.appUid = CAPTURER_FLAG;
71 config.appInfo.appPid = CAPTURER_FLAG;
72 config.streamInfo.format = SAMPLE_S32LE;
73 config.streamInfo.samplingRate = SAMPLE_RATE_48000;
74 config.streamInfo.channels = STEREO;
75 config.streamInfo.channelLayout = AudioChannelLayout::CH_LAYOUT_STEREO;
76 config.audioMode = AudioMode::AUDIO_MODE_PLAYBACK;
77 config.streamType = AudioStreamType::STREAM_MUSIC;
78 config.deviceType = DEVICE_TYPE_USB_HEADSET;
79 config.innerCapId = 1;
80 return config;
81 }
82
CreatePaRendererStreamImpl()83 std::shared_ptr<PaRendererStreamImpl> PaRendererStreamUnitTest::CreatePaRendererStreamImpl()
84 {
85 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
86 adapterManager->InitPaContext();
87 AudioProcessConfig processConfig = GetInnerCapConfig();
88 uint32_t sessionId = 123456;
89 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
90 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, stream);
91 std::shared_ptr<PaRendererStreamImpl> rendererStreamImpl =
92 std::static_pointer_cast<PaRendererStreamImpl>(rendererStream);
93 return rendererStreamImpl;
94 }
95
96 /**
97 * @tc.name : Test AudioProcessProxy API
98 * @tc.type : FUNC
99 * @tc.number: GetCurrentTimeStamp_001
100 * @tc.desc : Test AudioProcessProxy interface.
101 */
102 HWTEST_F(PaRendererStreamUnitTest, GetCurrentTimeStamp_001, TestSize.Level1)
103 {
104 #ifdef HAS_FEATURE_INNERCAPTURER
105 LoadPaPort();
106 #endif
107 auto unit = CreatePaRendererStreamImpl();
108 unit->paStream_ = nullptr;
109 uint64_t timestamp = 0;
110 int32_t ret = unit->GetCurrentTimeStamp(timestamp);
111 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
112 }
113
114 /**
115 * @tc.name : Test GetCurrentTimeStamp
116 * @tc.type : FUNC
117 * @tc.number: GetCurrentTimeStamp_002
118 * @tc.desc : Test GetCurrentTimeStamp.
119 */
120 HWTEST_F(PaRendererStreamUnitTest, GetCurrentTimeStamp_002, TestSize.Level1)
121 {
122 auto unit = CreatePaRendererStreamImpl();
123 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
124 adapterManager->InitPaContext();
125 uint32_t sessionId = 123456;
126 uint64_t timestamp = 0;
127 AudioProcessConfig processConfig = GetInnerCapConfig();
128 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
129 unit->paStream_ = stream;
130 int32_t ret = unit->GetCurrentTimeStamp(timestamp);
131 EXPECT_EQ(ret, SUCCESS);
132 }
133
134 /**
135 * @tc.name : Test GetEffectModeName
136 * @tc.type : FUNC
137 * @tc.number: GetEffectModeName_003
138 * @tc.desc : Test GetEffectModeName.
139 */
140 HWTEST_F(PaRendererStreamUnitTest, GetEffectModeName_003, TestSize.Level1)
141 {
142 auto unit = CreatePaRendererStreamImpl();
143 int32_t effectMode = 0;
144 EXPECT_EQ("EFFECT_NONE", unit->GetEffectModeName(effectMode));
145 }
146
147 /**
148 * @tc.name : Test GetEffectModeName
149 * @tc.type : FUNC
150 * @tc.number: GetEffectModeName_004
151 * @tc.desc : Test GetEffectModeName.
152 */
153 HWTEST_F(PaRendererStreamUnitTest, GetEffectModeName_004, TestSize.Level1)
154 {
155 auto unit = CreatePaRendererStreamImpl();
156 int32_t effectMode = 1;
157 EXPECT_EQ("EFFECT_DEFAULT", unit->GetEffectModeName(effectMode));
158 }
159
160 /**
161 * @tc.name : Test AudioProcessProxy API
162 * @tc.type : FUNC
163 * @tc.number: PaRenderer_006
164 * @tc.desc : Test AudioProcessProxy interface.
165 */
166 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_006, TestSize.Level1)
167 {
168 auto unit = CreatePaRendererStreamImpl();
169 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
170 adapterManager->InitPaContext();
171 uint32_t sessionId = 123456;
172 AudioProcessConfig processConfig = GetInnerCapConfig();
173 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
174 unit->paStream_ = stream;
175 int32_t rate = RENDER_RATE_NORMAL;
176 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
177 }
178
179 /**
180 * @tc.name : Test AudioProcessProxy API
181 * @tc.type : FUNC
182 * @tc.number: PaRenderer_007
183 * @tc.desc : Test AudioProcessProxy interface.
184 */
185 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_007, TestSize.Level1)
186 {
187 auto unit = CreatePaRendererStreamImpl();
188 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
189 adapterManager->InitPaContext();
190 uint32_t sessionId = 123456;
191 AudioProcessConfig processConfig = GetInnerCapConfig();
192 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
193 unit->paStream_ = stream;
194 int32_t rate = RENDER_RATE_DOUBLE;
195 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
196 }
197
198
199 /**
200 * @tc.name : Test AudioProcessProxy API
201 * @tc.type : FUNC
202 * @tc.number: PaRenderer_008
203 * @tc.desc : Test AudioProcessProxy interface.
204 */
205 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_008, TestSize.Level1)
206 {
207 auto unit = CreatePaRendererStreamImpl();
208 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
209 adapterManager->InitPaContext();
210 uint32_t sessionId = 123456;
211 AudioProcessConfig processConfig = GetInnerCapConfig();
212 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
213 unit->paStream_ = stream;
214 int32_t rate = RENDER_RATE_HALF;
215 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
216 }
217
218 /**
219 * @tc.name : Test AudioProcessProxy API
220 * @tc.type : FUNC
221 * @tc.number: PaRenderer_009
222 * @tc.desc : Test AudioProcessProxy interface.
223 */
224 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_009, TestSize.Level1)
225 {
226 auto unit = CreatePaRendererStreamImpl();
227 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
228 adapterManager->InitPaContext();
229 uint32_t sessionId = 123456;
230 AudioProcessConfig processConfig = GetInnerCapConfig();
231 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
232 unit->paStream_ = stream;
233 int32_t rate = 999;
234 EXPECT_EQ(unit->SetRate(rate), ERR_INVALID_PARAM);
235 }
236
237 /**
238 * @tc.name : Test GetCurrentPosition
239 * @tc.type : FUNC
240 * @tc.number: PaRenderer_010
241 * @tc.desc : Test GetCurrentPosition.
242 */
243 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_010, TestSize.Level1)
244 {
245 auto unit = CreatePaRendererStreamImpl();
246 unit->paStream_ = nullptr;
247 uint64_t timestamp = 0;
248 uint64_t framePosition = 0;
249 uint64_t latency = 0;
250 int32_t ret = unit->GetCurrentPosition(framePosition, timestamp, latency);
251 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
252 }
253
254 /**
255 * @tc.name : Test GetCurrentPosition.
256 * @tc.type : FUNC
257 * @tc.number: PaRenderer_011
258 * @tc.desc : Test GetCurrentPosition.
259 */
260 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_011, TestSize.Level1)
261 {
262 auto unit = CreatePaRendererStreamImpl();
263 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
264 adapterManager->InitPaContext();
265 uint32_t sessionId = 123456;
266 AudioProcessConfig processConfig = GetInnerCapConfig();
267 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
268 unit->paStream_ = stream;
269 unit->firstGetLatency_ = true;
270 int32_t rate = RENDER_RATE_NORMAL;
271 EXPECT_EQ(unit->SetRate(rate), SUCCESS);
272 }
273
274 /**
275 * @tc.name : Test OffloadSetVolume.
276 * @tc.type : FUNC
277 * @tc.number: PaRenderer_013
278 * @tc.desc : Test OffloadSetVolume.
279 */
280 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_013, TestSize.Level1)
281 {
282 auto unit = CreatePaRendererStreamImpl();
283 unit->offloadEnable_ = false;
284 float volume = 0.0f;
285 auto ret = unit->OffloadSetVolume(volume);
286 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
287 }
288
289 /**
290 * @tc.name : Test UpdateSpatializationState.
291 * @tc.type : FUNC
292 * @tc.number: PaRenderer_015
293 * @tc.desc : Test UpdateSpatializationState.
294 */
295 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_015, TestSize.Level1)
296 {
297 auto unit = CreatePaRendererStreamImpl();
298 unit->paStream_ = nullptr;
299 bool spatializationEnabled = false;
300 bool headTrackingEnabled = false;
301 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
302 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
303 }
304
305 /**
306 * @tc.name : Test UpdateSpatializationState.
307 * @tc.type : FUNC
308 * @tc.number: PaRenderer_016
309 * @tc.desc : Test UpdateSpatializationState.
310 */
311 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_016, TestSize.Level1)
312 {
313 auto unit = CreatePaRendererStreamImpl();
314 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
315 adapterManager->InitPaContext();
316 uint32_t sessionId = 123456;
317 AudioProcessConfig processConfig = GetInnerCapConfig();
318 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
319 unit->paStream_ = stream;
320 bool spatializationEnabled = false;
321 bool headTrackingEnabled = false;
322 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
323 EXPECT_EQ(ret, SUCCESS);
324 }
325
326 /**
327 * @tc.name : Test GetOffloadApproximatelyCacheTime.
328 * @tc.type : FUNC
329 * @tc.number: PaRenderer_017
330 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
331 */
332 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_017, TestSize.Level1)
333 {
334 auto unit = CreatePaRendererStreamImpl();
335 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
336 adapterManager->InitPaContext();
337 uint32_t sessionId = 123456;
338 AudioProcessConfig processConfig = GetInnerCapConfig();
339 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
340 unit->paStream_ = stream;
341 unit->offloadEnable_ = false;
342 uint64_t timestamp = 0;
343 uint64_t paWriteIndex = 0;
344 uint64_t cacheTimeDsp = 0;
345 uint64_t cacheTimePa = 0;
346 int32_t result = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
347 EXPECT_EQ(result, ERR_OPERATION_FAILED);
348 }
349
350 /**
351 * @tc.name : Test GetOffloadApproximatelyCacheTime.
352 * @tc.type : FUNC
353 * @tc.number: PaRenderer_018
354 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
355 */
356 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_018, TestSize.Level1)
357 {
358 auto unit = CreatePaRendererStreamImpl();
359 unit->paStream_ = nullptr;
360 unit->offloadEnable_ = true;
361 uint64_t timestamp = 0;
362 uint64_t paWriteIndex = 0;
363 uint64_t cacheTimeDsp = 0;
364 uint64_t cacheTimePa = 0;
365 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
366 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
367 }
368
369 /**
370 * @tc.name : Test GetOffloadApproximatelyCacheTime.
371 * @tc.type : FUNC
372 * @tc.number: PaRenderer_019
373 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
374 */
375 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_019, TestSize.Level1)
376 {
377 auto unit = CreatePaRendererStreamImpl();
378 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
379 adapterManager->InitPaContext();
380 uint32_t sessionId = 123456;
381 AudioProcessConfig processConfig = GetInnerCapConfig();
382 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
383 unit->paStream_ = stream;
384 unit->offloadEnable_ = true;
385 uint64_t timestamp = 0;
386 uint64_t paWriteIndex = 0;
387 uint64_t cacheTimeDsp = 0;
388 uint64_t cacheTimePa = 0;
389 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
390 EXPECT_EQ(ret, SUCCESS);
391 }
392
393 /**
394 * @tc.name : Test OffloadUpdatePolicyInWrite.
395 * @tc.type : FUNC
396 * @tc.number: PaRenderer_021
397 * @tc.desc : Test OffloadUpdatePolicyInWrite.
398 */
399 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_021, TestSize.Level1)
400 {
401 auto unit = CreatePaRendererStreamImpl();
402 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
403 adapterManager->InitPaContext();
404 uint32_t sessionId = 123456;
405 AudioProcessConfig processConfig = GetInnerCapConfig();
406 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
407 unit->paStream_ = stream;
408 unit->offloadEnable_ = true;
409 unit->lastOffloadUpdateFinishTime_ = 0;
410 int32_t ret = unit->OffloadUpdatePolicyInWrite();
411 EXPECT_EQ(ret, 0);
412 }
413
414 /**
415 * @tc.name : Test OffloadUpdatePolicy.
416 * @tc.type : FUNC
417 * @tc.number: PaRenderer_022
418 * @tc.desc : Test OffloadUpdatePolicy.
419 */
420 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_022, TestSize.Level1)
421 {
422 auto unit = CreatePaRendererStreamImpl();
423 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
424 bool force = true;
425 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
426 unit->lastOffloadUpdateFinishTime_ = 1;
427 unit->OffloadUpdatePolicy(statePolicy, force);
428 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
429 }
430
431 /**
432 * @tc.name : Test OffloadUpdatePolicy.
433 * @tc.type : FUNC
434 * @tc.number: PaRenderer_023
435 * @tc.desc : Test OffloadUpdatePolicy.
436 */
437 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_023, TestSize.Level1)
438 {
439 auto unit = CreatePaRendererStreamImpl();
440 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
441 bool force = false;
442 unit->offloadStatePolicy_ = OFFLOAD_DEFAULT;
443 unit->lastOffloadUpdateFinishTime_ = 1;
444 unit->OffloadUpdatePolicy(statePolicy, force);
445 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
446 }
447
448 /**
449 * @tc.name : Test OffloadUpdatePolicy.
450 * @tc.type : FUNC
451 * @tc.number: PaRenderer_024
452 * @tc.desc : Test OffloadUpdatePolicy.
453 */
454 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_024, TestSize.Level1)
455 {
456 auto unit = CreatePaRendererStreamImpl();
457 AudioOffloadType statePolicy = OFFLOAD_DEFAULT;
458 bool force = false;
459 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
460 unit->lastOffloadUpdateFinishTime_ = 1;
461 unit->OffloadUpdatePolicy(statePolicy, force);
462 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
463 }
464
465 /**
466 * @tc.name : Test OffloadUpdatePolicy.
467 * @tc.type : FUNC
468 * @tc.number: PaRenderer_025
469 * @tc.desc : Test OffloadUpdatePolicy.
470 */
471 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_025, TestSize.Level1)
472 {
473 auto unit = CreatePaRendererStreamImpl();
474 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
475 bool force = true;
476 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
477 unit->paStream_ = nullptr;
478 int32_t ret = unit->OffloadUpdatePolicy(statePolicy, force);
479 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
480 }
481
482 /**
483 * @tc.name : Test SetClientVolume.
484 * @tc.type : FUNC
485 * @tc.number: PaRenderer_026
486 * @tc.desc : Test SetClientVolume.
487 */
488 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_026, TestSize.Level1)
489 {
490 auto unit = CreatePaRendererStreamImpl();
491 float clientVolume = -1;
492 int32_t ret = unit->SetClientVolume(clientVolume);
493 EXPECT_EQ(ret, ERR_INVALID_PARAM);
494 }
495
496 /**
497 * @tc.name : Test SetClientVolume.
498 * @tc.type : FUNC
499 * @tc.number: PaRenderer_027
500 * @tc.desc : Test SetClientVolume.
501 */
502 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_027, TestSize.Level1)
503 {
504 auto unit = CreatePaRendererStreamImpl();
505 float clientVolume = 1.5;
506 int32_t ret = unit->SetClientVolume(clientVolume);
507 EXPECT_EQ(ret, ERR_INVALID_PARAM);
508 }
509
510 /**
511 * @tc.name : Test SetClientVolume.
512 * @tc.type : FUNC
513 * @tc.number: PaRenderer_028
514 * @tc.desc : Test SetClientVolume.
515 */
516 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_028, TestSize.Level1)
517 {
518 auto unit = CreatePaRendererStreamImpl();
519 float clientVolume = 0.5;
520 int32_t ret = unit->SetClientVolume(clientVolume);
521 EXPECT_EQ(ret, SUCCESS);
522 }
523
524 /**
525 * @tc.name : Test GetWritableSize.
526 * @tc.type : FUNC
527 * @tc.number: PaRenderer_029
528 * @tc.desc : Test GetWritableSize.
529 */
530 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_029, TestSize.Level1)
531 {
532 auto unit = CreatePaRendererStreamImpl();
533 unit->paStream_ = nullptr;
534 int32_t ret = unit->GetWritableSize();
535 EXPECT_EQ(ret, 0);
536 }
537
538 /**
539 * @tc.name : Test GetWritableSize.
540 * @tc.type : FUNC
541 * @tc.number: PaRenderer_030
542 * @tc.desc : Test GetWritableSize.
543 */
544 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_030, TestSize.Level1)
545 {
546 auto unit = CreatePaRendererStreamImpl();
547 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
548 adapterManager->InitPaContext();
549 uint32_t sessionId = 123456;
550 AudioProcessConfig processConfig = GetInnerCapConfig();
551 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
552 unit->paStream_ = stream;
553 int32_t ret = unit->GetWritableSize();
554 EXPECT_EQ(ret, pa_stream_writable_size(unit->paStream_));
555 }
556
557 /**
558 * @tc.name : Test EnqueueBuffer.
559 * @tc.type : FUNC
560 * @tc.number: PaRenderer_031
561 * @tc.desc : Test EnqueueBuffer.
562 */
563 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_031, TestSize.Level1)
564 {
565 auto unit = CreatePaRendererStreamImpl();
566 BufferDesc bufferDesc = {
567 .buffer = nullptr,
568 .bufLength = 0,
569 .dataLength = 0,
570 .metaBuffer = nullptr,
571 .metaLength = 0
572 };
573 unit->paStream_ = nullptr;
574 int32_t ret = unit->EnqueueBuffer(bufferDesc);
575 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
576 }
577
578 /**
579 * @tc.name : Test EnqueueBuffer.
580 * @tc.type : FUNC
581 * @tc.number: PaRenderer_032
582 * @tc.desc : Test EnqueueBuffer.
583 */
584 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_032, TestSize.Level1)
585 {
586 auto unit = CreatePaRendererStreamImpl();
587 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
588 adapterManager->InitPaContext();
589 uint32_t sessionId = 123456;
590 AudioProcessConfig processConfig = GetInnerCapConfig();
591 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
592 unit->paStream_ = stream;
593 BufferDesc bufferDesc = {
594 .buffer = nullptr,
595 .bufLength = 0,
596 .dataLength = 0,
597 .metaBuffer = nullptr,
598 .metaLength = 0
599 };
600 int32_t ret = unit->EnqueueBuffer(bufferDesc);
601 EXPECT_EQ(ret, SUCCESS);
602 }
603
604 /**
605 * @tc.name : Test SetAudioEffectMode.
606 * @tc.type : FUNC
607 * @tc.number: PaRenderer_033
608 * @tc.desc : Test SetAudioEffectMode.
609 */
610 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_033, TestSize.Level1)
611 {
612 auto unit = CreatePaRendererStreamImpl();
613 unit->paStream_ = nullptr;
614 int32_t effectMode = 0;
615 int32_t ret = unit->SetAudioEffectMode(effectMode);
616 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
617 }
618
619 /**
620 * @tc.name : Test SetAudioEffectMode.
621 * @tc.type : FUNC
622 * @tc.number: PaRenderer_034
623 * @tc.desc : Test SetAudioEffectMode.
624 */
625 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_034, TestSize.Level1)
626 {
627 auto unit = CreatePaRendererStreamImpl();
628 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
629 adapterManager->InitPaContext();
630 uint32_t sessionId = 123456;
631 AudioProcessConfig processConfig = GetInnerCapConfig();
632 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
633 unit->paStream_ = stream;
634 int32_t effectMode = 0;
635 int32_t ret = unit->SetAudioEffectMode(effectMode);
636 EXPECT_EQ(ret, SUCCESS);
637 }
638
639 /**
640 * @tc.name : Test Start.
641 * @tc.type : FUNC
642 * @tc.number: PaRenderer_036
643 * @tc.desc : Test Start.
644 */
645 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_036, TestSize.Level1)
646 {
647 auto unit = CreatePaRendererStreamImpl();
648 unit->paStream_ = nullptr;
649 int32_t ret = unit->Start();
650 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
651 }
652
653 /**
654 * @tc.name : Test Pause.
655 * @tc.type : FUNC
656 * @tc.number: PaRenderer_037
657 * @tc.desc : Test Pause.
658 */
659 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_037, TestSize.Level1)
660 {
661 auto unit = CreatePaRendererStreamImpl();
662 unit->paStream_ = nullptr;
663 bool isStandby = false;
664 int32_t ret = unit->Pause(isStandby);
665 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
666 }
667
668 /**
669 * @tc.name : Test Pause.
670 * @tc.type : FUNC
671 * @tc.number: PaRenderer_038
672 * @tc.desc : Test Pause.
673 */
674 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_038, TestSize.Level1)
675 {
676 auto unit = CreatePaRendererStreamImpl();
677 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
678 adapterManager->InitPaContext();
679 uint32_t sessionId = 123456;
680 AudioProcessConfig processConfig = GetInnerCapConfig();
681 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
682 unit->paStream_ = stream;
683 bool isStandby = false;
684 int32_t ret = unit->Pause(isStandby);
685 EXPECT_EQ(ret, SUCCESS);
686 }
687
688 /**
689 * @tc.name : Test Flush.
690 * @tc.type : FUNC
691 * @tc.number: PaRenderer_039
692 * @tc.desc : Test Flush.
693 */
694 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_039, TestSize.Level1)
695 {
696 auto unit = CreatePaRendererStreamImpl();
697 unit->paStream_ = nullptr;
698 int32_t ret = unit->Flush();
699 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
700 }
701
702 /**
703 * @tc.name : Test Flush.
704 * @tc.type : FUNC
705 * @tc.number: PaRenderer_040
706 * @tc.desc : Test Flush.
707 */
708 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_040, TestSize.Level1)
709 {
710 auto unit = CreatePaRendererStreamImpl();
711 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
712 adapterManager->InitPaContext();
713 uint32_t sessionId = 123456;
714 AudioProcessConfig processConfig = GetInnerCapConfig();
715 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
716 unit->paStream_ = stream;
717 int32_t ret = unit->Flush();
718 EXPECT_EQ(ret, SUCCESS);
719 }
720
721 /**
722 * @tc.name : Test Stop.
723 * @tc.type : FUNC
724 * @tc.number: PaRenderer_041
725 * @tc.desc : Test Stop.
726 */
727 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_041, TestSize.Level1)
728 {
729 auto unit = CreatePaRendererStreamImpl();
730 unit->paStream_ = nullptr;
731 int32_t ret = unit->Stop();
732 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
733 }
734
735 /**
736 * @tc.name : Test Stop.
737 * @tc.type : FUNC
738 * @tc.number: PaRenderer_042
739 * @tc.desc : Test Stop.
740 */
741 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_042, TestSize.Level1)
742 {
743 auto unit = CreatePaRendererStreamImpl();
744 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
745 adapterManager->InitPaContext();
746 uint32_t sessionId = 123456;
747 AudioProcessConfig processConfig = GetInnerCapConfig();
748 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
749 unit->paStream_ = stream;
750 int32_t ret = unit->Stop();
751 EXPECT_EQ(ret, SUCCESS);
752 }
753
754 /**
755 * @tc.name : Test Release.
756 * @tc.type : FUNC
757 * @tc.number: PaRenderer_043
758 * @tc.desc : Test Release.
759 */
760 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_043, TestSize.Level1)
761 {
762 auto unit = CreatePaRendererStreamImpl();
763 unit->paStream_ = nullptr;
764 unit->state_ = RUNNING;
765 int32_t ret = unit->Release();
766 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
767 }
768
769 /**
770 * @tc.name : Test Release.
771 * @tc.type : FUNC
772 * @tc.number: PaRenderer_044
773 * @tc.desc : Test Release.
774 */
775 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_044, TestSize.Level1)
776 {
777 auto unit = CreatePaRendererStreamImpl();
778 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
779 adapterManager->InitPaContext();
780 uint32_t sessionId = 123456;
781 AudioProcessConfig processConfig = GetInnerCapConfig();
782 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
783 unit->paStream_ = stream;
784 unit->state_ = RUNNING;
785 int32_t ret = unit->Release();
786 EXPECT_EQ(ret, SUCCESS);
787 }
788
789 /**
790 * @tc.name : Test GetLatency.
791 * @tc.type : FUNC
792 * @tc.number: PaRenderer_048
793 * @tc.desc : Test GetLatency.
794 */
795 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_048, TestSize.Level1)
796 {
797 auto unit = CreatePaRendererStreamImpl();
798 uint64_t latency = 0;
799 unit->firstGetLatency_= true;
800 unit->paStream_ = nullptr;
801 int32_t ret = unit->GetLatency(latency);
802 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
803 }
804
805 /**
806 * @tc.name : Test GetLatency.
807 * @tc.type : FUNC
808 * @tc.number: PaRenderer_049
809 * @tc.desc : Test GetLatency.
810 */
811 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_049, TestSize.Level1)
812 {
813 auto unit = CreatePaRendererStreamImpl();
814 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
815 adapterManager->InitPaContext();
816 uint32_t sessionId = 123456;
817 AudioProcessConfig processConfig = GetInnerCapConfig();
818 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
819 unit->paStream_ = stream;
820 uint64_t latency = 0;
821 unit->firstGetLatency_= true;
822 int32_t ret = unit->GetLatency(latency);
823 EXPECT_EQ(ret, SUCCESS);
824 }
825 /**
826 * @tc.name : Test Drain.
827 * @tc.type : FUNC
828 * @tc.number: PaRenderer_050
829 * @tc.desc : Test Drain.
830 */
831 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_050, TestSize.Level1)
832 {
833 auto unit = CreatePaRendererStreamImpl();
834 unit->paStream_ = nullptr;
835 int32_t ret = unit->Drain();
836 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
837 }
838
839 /**
840 * @tc.name : Test SetRate.
841 * @tc.type : FUNC
842 * @tc.number: PaRenderer_051
843 * @tc.desc : Test SetRate.
844 */
845 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_051, TestSize.Level1)
846 {
847 auto unit = CreatePaRendererStreamImpl();
848 unit->paStream_ = nullptr;
849 int32_t rate = RENDER_RATE_NORMAL;
850 EXPECT_EQ(unit->SetRate(rate), ERR_ILLEGAL_STATE);
851 #ifdef HAS_FEATURE_INNERCAPTURER
852 ReleasePaPort();
853 #endif
854 }
855 }
856 }