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, Timestamp::MONOTONIC);
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 InitPaStream for different adapter manager type.
276 * @tc.type : FUNC
277 * @tc.number: InitPaStream_001
278 * @tc.desc : Test InitPaStream for DUP_PLAYBACK
279 */
280 HWTEST_F(PaRendererStreamUnitTest, InitPaStream_001, TestSize.Level1)
281 {
282 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
283 adapterManager->InitPaContext();
284 uint32_t sessionId = 123456;
285 AudioProcessConfig processConfig = GetInnerCapConfig();
286 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
287
288 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, stream);
289 std::shared_ptr<PaRendererStreamImpl> rendererStreamImpl =
290 std::static_pointer_cast<PaRendererStreamImpl>(rendererStream);
291
292 int32_t rate = RENDER_RATE_NORMAL;
293 EXPECT_EQ(rendererStreamImpl->SetRate(rate), SUCCESS);
294 }
295
296 /**
297 * @tc.name : Test InitPaStream for different adapter manager type.
298 * @tc.type : FUNC
299 * @tc.number: InitPaStream_002
300 * @tc.desc : Test InitPaStream for DUAL_PLAYBACK
301 */
302 HWTEST_F(PaRendererStreamUnitTest, InitPaStream_002, TestSize.Level1)
303 {
304 adapterManager = std::make_shared<PaAdapterManager>(DUAL_PLAYBACK);
305 adapterManager->InitPaContext();
306 uint32_t sessionId = 123456;
307 AudioProcessConfig processConfig = GetInnerCapConfig();
308 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
309
310 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, stream);
311 std::shared_ptr<PaRendererStreamImpl> rendererStreamImpl =
312 std::static_pointer_cast<PaRendererStreamImpl>(rendererStream);
313
314 int32_t rate = RENDER_RATE_NORMAL;
315 EXPECT_EQ(rendererStreamImpl->SetRate(rate), SUCCESS);
316 }
317
318 /**
319 * @tc.name : Test InitPaStream for different adapter manager type.
320 * @tc.type : FUNC
321 * @tc.number: InitPaStream_003
322 * @tc.desc : Test InitPaStream for PLAYBACK
323 */
324 HWTEST_F(PaRendererStreamUnitTest, InitPaStream_003, TestSize.Level1)
325 {
326 adapterManager = std::make_shared<PaAdapterManager>(PLAYBACK);
327 adapterManager->InitPaContext();
328 uint32_t sessionId = 123456;
329 AudioProcessConfig processConfig = GetInnerCapConfig();
330 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
331
332 std::shared_ptr<IRendererStream> rendererStream = adapterManager->CreateRendererStream(processConfig, stream);
333 std::shared_ptr<PaRendererStreamImpl> rendererStreamImpl =
334 std::static_pointer_cast<PaRendererStreamImpl>(rendererStream);
335
336 int32_t rate = RENDER_RATE_NORMAL;
337 EXPECT_EQ(rendererStreamImpl->SetRate(rate), SUCCESS);
338 }
339
340 /**
341 * @tc.name : Test OffloadSetVolume.
342 * @tc.type : FUNC
343 * @tc.number: PaRenderer_013
344 * @tc.desc : Test OffloadSetVolume.
345 */
346 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_013, TestSize.Level1)
347 {
348 auto unit = CreatePaRendererStreamImpl();
349 unit->offloadEnable_ = false;
350 float volume = 0.0f;
351 auto ret = unit->OffloadSetVolume(volume);
352 EXPECT_EQ(ret, ERR_OPERATION_FAILED);
353 }
354
355 /**
356 * @tc.name : Test UpdateSpatializationState.
357 * @tc.type : FUNC
358 * @tc.number: PaRenderer_015
359 * @tc.desc : Test UpdateSpatializationState.
360 */
361 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_015, TestSize.Level1)
362 {
363 auto unit = CreatePaRendererStreamImpl();
364 unit->paStream_ = nullptr;
365 bool spatializationEnabled = false;
366 bool headTrackingEnabled = false;
367 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
368 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
369 }
370
371 /**
372 * @tc.name : Test UpdateSpatializationState.
373 * @tc.type : FUNC
374 * @tc.number: PaRenderer_016
375 * @tc.desc : Test UpdateSpatializationState.
376 */
377 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_016, TestSize.Level1)
378 {
379 auto unit = CreatePaRendererStreamImpl();
380 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
381 adapterManager->InitPaContext();
382 uint32_t sessionId = 123456;
383 AudioProcessConfig processConfig = GetInnerCapConfig();
384 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
385 unit->paStream_ = stream;
386 bool spatializationEnabled = false;
387 bool headTrackingEnabled = false;
388 int32_t ret = unit->UpdateSpatializationState(spatializationEnabled, headTrackingEnabled);
389 EXPECT_EQ(ret, SUCCESS);
390 }
391
392 /**
393 * @tc.name : Test GetOffloadApproximatelyCacheTime.
394 * @tc.type : FUNC
395 * @tc.number: PaRenderer_017
396 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
397 */
398 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_017, TestSize.Level1)
399 {
400 auto unit = CreatePaRendererStreamImpl();
401 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
402 adapterManager->InitPaContext();
403 uint32_t sessionId = 123456;
404 AudioProcessConfig processConfig = GetInnerCapConfig();
405 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
406 unit->paStream_ = stream;
407 unit->offloadEnable_ = false;
408 uint64_t timestamp = 0;
409 uint64_t paWriteIndex = 0;
410 uint64_t cacheTimeDsp = 0;
411 uint64_t cacheTimePa = 0;
412 int32_t result = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
413 EXPECT_EQ(result, ERR_OPERATION_FAILED);
414 }
415
416 /**
417 * @tc.name : Test GetOffloadApproximatelyCacheTime.
418 * @tc.type : FUNC
419 * @tc.number: PaRenderer_018
420 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
421 */
422 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_018, TestSize.Level1)
423 {
424 auto unit = CreatePaRendererStreamImpl();
425 unit->paStream_ = nullptr;
426 unit->offloadEnable_ = true;
427 uint64_t timestamp = 0;
428 uint64_t paWriteIndex = 0;
429 uint64_t cacheTimeDsp = 0;
430 uint64_t cacheTimePa = 0;
431 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
432 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
433 }
434
435 /**
436 * @tc.name : Test GetOffloadApproximatelyCacheTime.
437 * @tc.type : FUNC
438 * @tc.number: PaRenderer_019
439 * @tc.desc : Test GetOffloadApproximatelyCacheTime.
440 */
441 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_019, TestSize.Level1)
442 {
443 auto unit = CreatePaRendererStreamImpl();
444 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
445 adapterManager->InitPaContext();
446 uint32_t sessionId = 123456;
447 AudioProcessConfig processConfig = GetInnerCapConfig();
448 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
449 unit->paStream_ = stream;
450 unit->offloadEnable_ = true;
451 uint64_t timestamp = 0;
452 uint64_t paWriteIndex = 0;
453 uint64_t cacheTimeDsp = 0;
454 uint64_t cacheTimePa = 0;
455 int32_t ret = unit->GetOffloadApproximatelyCacheTime(timestamp, paWriteIndex, cacheTimeDsp, cacheTimePa);
456 EXPECT_EQ(ret, SUCCESS);
457 }
458
459 /**
460 * @tc.name : Test OffloadUpdatePolicyInWrite.
461 * @tc.type : FUNC
462 * @tc.number: PaRenderer_021
463 * @tc.desc : Test OffloadUpdatePolicyInWrite.
464 */
465 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_021, TestSize.Level1)
466 {
467 auto unit = CreatePaRendererStreamImpl();
468 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
469 adapterManager->InitPaContext();
470 uint32_t sessionId = 123456;
471 AudioProcessConfig processConfig = GetInnerCapConfig();
472 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
473 unit->paStream_ = stream;
474 unit->offloadEnable_ = true;
475 unit->lastOffloadUpdateFinishTime_ = 0;
476 int32_t ret = unit->OffloadUpdatePolicyInWrite();
477 EXPECT_EQ(ret, 0);
478 }
479
480 /**
481 * @tc.name : Test OffloadUpdatePolicy.
482 * @tc.type : FUNC
483 * @tc.number: PaRenderer_022
484 * @tc.desc : Test OffloadUpdatePolicy.
485 */
486 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_022, TestSize.Level1)
487 {
488 auto unit = CreatePaRendererStreamImpl();
489 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
490 bool force = true;
491 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
492 unit->lastOffloadUpdateFinishTime_ = 1;
493 unit->OffloadUpdatePolicy(statePolicy, force);
494 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
495 }
496
497 /**
498 * @tc.name : Test OffloadUpdatePolicy.
499 * @tc.type : FUNC
500 * @tc.number: PaRenderer_023
501 * @tc.desc : Test OffloadUpdatePolicy.
502 */
503 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_023, TestSize.Level1)
504 {
505 auto unit = CreatePaRendererStreamImpl();
506 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
507 bool force = false;
508 unit->offloadStatePolicy_ = OFFLOAD_DEFAULT;
509 unit->lastOffloadUpdateFinishTime_ = 1;
510 unit->OffloadUpdatePolicy(statePolicy, force);
511 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
512 }
513
514 /**
515 * @tc.name : Test OffloadUpdatePolicy.
516 * @tc.type : FUNC
517 * @tc.number: PaRenderer_024
518 * @tc.desc : Test OffloadUpdatePolicy.
519 */
520 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_024, TestSize.Level1)
521 {
522 auto unit = CreatePaRendererStreamImpl();
523 AudioOffloadType statePolicy = OFFLOAD_DEFAULT;
524 bool force = false;
525 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
526 unit->lastOffloadUpdateFinishTime_ = 1;
527 unit->OffloadUpdatePolicy(statePolicy, force);
528 EXPECT_EQ(0, unit->lastOffloadUpdateFinishTime_);
529 }
530
531 /**
532 * @tc.name : Test OffloadUpdatePolicy.
533 * @tc.type : FUNC
534 * @tc.number: PaRenderer_025
535 * @tc.desc : Test OffloadUpdatePolicy.
536 */
537 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_025, TestSize.Level1)
538 {
539 auto unit = CreatePaRendererStreamImpl();
540 AudioOffloadType statePolicy = OFFLOAD_ACTIVE_FOREGROUND;
541 bool force = true;
542 unit->offloadStatePolicy_ = OFFLOAD_ACTIVE_FOREGROUND;
543 unit->paStream_ = nullptr;
544 int32_t ret = unit->OffloadUpdatePolicy(statePolicy, force);
545 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
546 }
547
548 /**
549 * @tc.name : Test SetClientVolume.
550 * @tc.type : FUNC
551 * @tc.number: PaRenderer_026
552 * @tc.desc : Test SetClientVolume.
553 */
554 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_026, TestSize.Level1)
555 {
556 auto unit = CreatePaRendererStreamImpl();
557 float clientVolume = -1;
558 int32_t ret = unit->SetClientVolume(clientVolume);
559 EXPECT_EQ(ret, ERR_INVALID_PARAM);
560 }
561
562 /**
563 * @tc.name : Test SetClientVolume.
564 * @tc.type : FUNC
565 * @tc.number: PaRenderer_027
566 * @tc.desc : Test SetClientVolume.
567 */
568 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_027, TestSize.Level1)
569 {
570 auto unit = CreatePaRendererStreamImpl();
571 float clientVolume = 1.5;
572 int32_t ret = unit->SetClientVolume(clientVolume);
573 EXPECT_EQ(ret, ERR_INVALID_PARAM);
574 }
575
576 /**
577 * @tc.name : Test SetClientVolume.
578 * @tc.type : FUNC
579 * @tc.number: PaRenderer_028
580 * @tc.desc : Test SetClientVolume.
581 */
582 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_028, TestSize.Level1)
583 {
584 auto unit = CreatePaRendererStreamImpl();
585 float clientVolume = 0.5;
586 int32_t ret = unit->SetClientVolume(clientVolume);
587 EXPECT_EQ(ret, SUCCESS);
588 }
589
590 /**
591 * @tc.name : Test GetWritableSize.
592 * @tc.type : FUNC
593 * @tc.number: PaRenderer_029
594 * @tc.desc : Test GetWritableSize.
595 */
596 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_029, TestSize.Level1)
597 {
598 auto unit = CreatePaRendererStreamImpl();
599 unit->paStream_ = nullptr;
600 int32_t ret = unit->GetWritableSize();
601 EXPECT_EQ(ret, 0);
602 }
603
604 /**
605 * @tc.name : Test GetWritableSize.
606 * @tc.type : FUNC
607 * @tc.number: PaRenderer_030
608 * @tc.desc : Test GetWritableSize.
609 */
610 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_030, TestSize.Level1)
611 {
612 auto unit = CreatePaRendererStreamImpl();
613 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
614 adapterManager->InitPaContext();
615 uint32_t sessionId = 123456;
616 AudioProcessConfig processConfig = GetInnerCapConfig();
617 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
618 unit->paStream_ = stream;
619 int32_t ret = unit->GetWritableSize();
620 EXPECT_EQ(ret, pa_stream_writable_size(unit->paStream_));
621 }
622
623 /**
624 * @tc.name : Test EnqueueBuffer.
625 * @tc.type : FUNC
626 * @tc.number: PaRenderer_031
627 * @tc.desc : Test EnqueueBuffer.
628 */
629 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_031, TestSize.Level1)
630 {
631 auto unit = CreatePaRendererStreamImpl();
632 BufferDesc bufferDesc = {
633 .buffer = nullptr,
634 .bufLength = 0,
635 .dataLength = 0,
636 .metaBuffer = nullptr,
637 .metaLength = 0
638 };
639 unit->paStream_ = nullptr;
640 int32_t ret = unit->EnqueueBuffer(bufferDesc);
641 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
642 }
643
644 /**
645 * @tc.name : Test EnqueueBuffer.
646 * @tc.type : FUNC
647 * @tc.number: PaRenderer_032
648 * @tc.desc : Test EnqueueBuffer.
649 */
650 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_032, TestSize.Level1)
651 {
652 auto unit = CreatePaRendererStreamImpl();
653 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
654 adapterManager->InitPaContext();
655 uint32_t sessionId = 123456;
656 AudioProcessConfig processConfig = GetInnerCapConfig();
657 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
658 unit->paStream_ = stream;
659 BufferDesc bufferDesc = {
660 .buffer = nullptr,
661 .bufLength = 0,
662 .dataLength = 0,
663 .metaBuffer = nullptr,
664 .metaLength = 0
665 };
666 int32_t ret = unit->EnqueueBuffer(bufferDesc);
667 EXPECT_EQ(ret, SUCCESS);
668 }
669
670 /**
671 * @tc.name : Test SetAudioEffectMode.
672 * @tc.type : FUNC
673 * @tc.number: PaRenderer_033
674 * @tc.desc : Test SetAudioEffectMode.
675 */
676 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_033, TestSize.Level1)
677 {
678 auto unit = CreatePaRendererStreamImpl();
679 unit->paStream_ = nullptr;
680 int32_t effectMode = 0;
681 int32_t ret = unit->SetAudioEffectMode(effectMode);
682 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
683 }
684
685 /**
686 * @tc.name : Test SetAudioEffectMode.
687 * @tc.type : FUNC
688 * @tc.number: PaRenderer_034
689 * @tc.desc : Test SetAudioEffectMode.
690 */
691 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_034, TestSize.Level1)
692 {
693 auto unit = CreatePaRendererStreamImpl();
694 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
695 adapterManager->InitPaContext();
696 uint32_t sessionId = 123456;
697 AudioProcessConfig processConfig = GetInnerCapConfig();
698 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
699 unit->paStream_ = stream;
700 int32_t effectMode = 0;
701 int32_t ret = unit->SetAudioEffectMode(effectMode);
702 EXPECT_EQ(ret, SUCCESS);
703 }
704
705 /**
706 * @tc.name : Test Start.
707 * @tc.type : FUNC
708 * @tc.number: PaRenderer_036
709 * @tc.desc : Test Start.
710 */
711 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_036, TestSize.Level1)
712 {
713 auto unit = CreatePaRendererStreamImpl();
714 unit->paStream_ = nullptr;
715 int32_t ret = unit->Start();
716 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
717 }
718
719 /**
720 * @tc.name : Test Pause.
721 * @tc.type : FUNC
722 * @tc.number: PaRenderer_037
723 * @tc.desc : Test Pause.
724 */
725 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_037, TestSize.Level1)
726 {
727 auto unit = CreatePaRendererStreamImpl();
728 unit->paStream_ = nullptr;
729 bool isStandby = false;
730 int32_t ret = unit->Pause(isStandby);
731 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
732 }
733
734 /**
735 * @tc.name : Test Pause.
736 * @tc.type : FUNC
737 * @tc.number: PaRenderer_038
738 * @tc.desc : Test Pause.
739 */
740 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_038, TestSize.Level1)
741 {
742 auto unit = CreatePaRendererStreamImpl();
743 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
744 adapterManager->InitPaContext();
745 uint32_t sessionId = 123456;
746 AudioProcessConfig processConfig = GetInnerCapConfig();
747 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
748 unit->paStream_ = stream;
749 bool isStandby = false;
750 int32_t ret = unit->Pause(isStandby);
751 EXPECT_EQ(ret, SUCCESS);
752 }
753
754 /**
755 * @tc.name : Test Flush.
756 * @tc.type : FUNC
757 * @tc.number: PaRenderer_039
758 * @tc.desc : Test Flush.
759 */
760 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_039, TestSize.Level1)
761 {
762 auto unit = CreatePaRendererStreamImpl();
763 unit->paStream_ = nullptr;
764 int32_t ret = unit->Flush();
765 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
766 }
767
768 /**
769 * @tc.name : Test Flush.
770 * @tc.type : FUNC
771 * @tc.number: PaRenderer_040
772 * @tc.desc : Test Flush.
773 */
774 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_040, TestSize.Level1)
775 {
776 auto unit = CreatePaRendererStreamImpl();
777 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
778 adapterManager->InitPaContext();
779 uint32_t sessionId = 123456;
780 AudioProcessConfig processConfig = GetInnerCapConfig();
781 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
782 unit->paStream_ = stream;
783 int32_t ret = unit->Flush();
784 EXPECT_EQ(ret, SUCCESS);
785 }
786
787 /**
788 * @tc.name : Test Stop.
789 * @tc.type : FUNC
790 * @tc.number: PaRenderer_041
791 * @tc.desc : Test Stop.
792 */
793 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_041, TestSize.Level1)
794 {
795 auto unit = CreatePaRendererStreamImpl();
796 unit->paStream_ = nullptr;
797 int32_t ret = unit->Stop();
798 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
799 }
800
801 /**
802 * @tc.name : Test Stop.
803 * @tc.type : FUNC
804 * @tc.number: PaRenderer_042
805 * @tc.desc : Test Stop.
806 */
807 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_042, TestSize.Level1)
808 {
809 auto unit = CreatePaRendererStreamImpl();
810 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
811 adapterManager->InitPaContext();
812 uint32_t sessionId = 123456;
813 AudioProcessConfig processConfig = GetInnerCapConfig();
814 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
815 unit->paStream_ = stream;
816 int32_t ret = unit->Stop();
817 EXPECT_EQ(ret, SUCCESS);
818 }
819
820 /**
821 * @tc.name : Test Release.
822 * @tc.type : FUNC
823 * @tc.number: PaRenderer_043
824 * @tc.desc : Test Release.
825 */
826 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_043, TestSize.Level1)
827 {
828 auto unit = CreatePaRendererStreamImpl();
829 unit->paStream_ = nullptr;
830 unit->state_ = RUNNING;
831 int32_t ret = unit->Release();
832 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
833 }
834
835 /**
836 * @tc.name : Test Release.
837 * @tc.type : FUNC
838 * @tc.number: PaRenderer_044
839 * @tc.desc : Test Release.
840 */
841 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_044, TestSize.Level1)
842 {
843 auto unit = CreatePaRendererStreamImpl();
844 adapterManager = std::make_shared<PaAdapterManager>(DUP_PLAYBACK);
845 adapterManager->InitPaContext();
846 uint32_t sessionId = 123456;
847 AudioProcessConfig processConfig = GetInnerCapConfig();
848 pa_stream *stream = adapterManager->InitPaStream(processConfig, sessionId, false);
849 unit->paStream_ = stream;
850 unit->state_ = RUNNING;
851 int32_t ret = unit->Release();
852 EXPECT_EQ(ret, SUCCESS);
853 }
854
855 /**
856 * @tc.name : Test GetLatency.
857 * @tc.type : FUNC
858 * @tc.number: PaRenderer_048
859 * @tc.desc : Test GetLatency.
860 */
861 HWTEST_F(PaRendererStreamUnitTest, PaRenderer_048, TestSize.Level1)
862 {
863 auto unit = CreatePaRendererStreamImpl();
864 uint64_t latency = 0;
865 unit->firstGetLatency_= true;
866 unit->paStream_ = nullptr;
867 int32_t ret = unit->GetLatency(latency);
868 EXPECT_EQ(ret, ERR_ILLEGAL_STATE);
869 }
870 }
871 }