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 "gtest/gtest.h"
17 #include "audio_server_sink_plugin.h"
18 #include "audio_info.h"
19 #include "audio_interrupt_info.h"
20
21 using namespace OHOS::AudioStandard;
22 using namespace testing::ext;
23 using namespace OHOS::Media::Plugins;
24
25 namespace OHOS {
26 namespace Media {
27 namespace Test {
28 class TestEventReceiver : public Pipeline::EventReceiver {
29 public:
TestEventReceiver()30 explicit TestEventReceiver()
31 {
32 std::cout << "event receiver constructor" << std::endl;
33 }
34
OnEvent(const Event & event)35 void OnEvent(const Event &event)
36 {
37 std::cout << event.srcFilter << std::endl;
38 }
39
40 private:
41 };
42
CreateAudioServerSinkPlugin(const std::string & name)43 std::shared_ptr<AudioServerSinkPlugin> CreateAudioServerSinkPlugin(const std::string &name)
44 {
45 return std::make_shared<AudioServerSinkPlugin>(name);
46 }
47
48 HWTEST(TestAudioServerSinkPlugin, find_audio_server_sink_plugin, TestSize.Level1)
49 {
50 auto audioServerSinkPlugin = CreateAudioServerSinkPlugin("process");
51 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
52 auto initStatus = audioServerSinkPlugin->Init();
53 ASSERT_TRUE(initStatus == Status::OK);
54 auto freeStatus = audioServerSinkPlugin->Deinit();
55 ASSERT_TRUE(freeStatus == Status::OK);
56 }
57
58 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_parameter, TestSize.Level1)
59 {
60 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get parameter");
61 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
62 auto meta = std::make_shared<Meta>();
63 auto resGetParam = audioServerSinkPlugin->GetParameter(meta);
64 ASSERT_TRUE(resGetParam == Status::OK);
65 }
66
67 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set_parameter, TestSize.Level1)
68 {
69 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("set parameter");
70 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
71 auto meta = std::make_shared<Meta>();
72 auto resGetParam = audioServerSinkPlugin->SetParameter(meta);
73 ASSERT_TRUE(resGetParam == Status::OK);
74 }
75
76 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_life_cycle, TestSize.Level1)
77 {
78 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get allocator");
79 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
80 auto initStatus = audioServerSinkPlugin->Init();
81 ASSERT_TRUE(initStatus == Status::OK);
82 auto prepareStatus = audioServerSinkPlugin->Prepare();
83 ASSERT_TRUE(prepareStatus == Status::OK);
84 auto startStatus = audioServerSinkPlugin->Start();
85 ASSERT_TRUE(startStatus == Status::OK);
86 auto flushStatus = audioServerSinkPlugin->Flush();
87 ASSERT_TRUE(flushStatus == Status::OK);
88 auto pauseStatus = audioServerSinkPlugin->Pause();
89 ASSERT_TRUE(pauseStatus == Status::OK);
90 auto resumeStatus = audioServerSinkPlugin->Resume();
91 ASSERT_TRUE(resumeStatus == Status::OK);
92 auto pauseTransitentStatus = audioServerSinkPlugin->PauseTransitent();
93 ASSERT_TRUE(pauseTransitentStatus == Status::OK);
94 auto drainStatus = audioServerSinkPlugin->Drain();
95 ASSERT_TRUE(drainStatus == Status::OK);
96 auto stopStatus = audioServerSinkPlugin->Stop();
97 ASSERT_TRUE(stopStatus == Status::OK);
98 auto resetStatus = audioServerSinkPlugin->Reset();
99 ASSERT_TRUE(resetStatus == Status::OK);
100 auto deinitStatus = audioServerSinkPlugin->Deinit();
101 ASSERT_TRUE(deinitStatus == Status::OK);
102 }
103
104 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get, TestSize.Level1)
105 {
106 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
107 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
108 auto initStatus = audioServerSinkPlugin->Init();
109 ASSERT_TRUE(initStatus == Status::OK);
110
111 // get latency
112 uint64_t latency = 0;
113 auto getLatencyStatus = audioServerSinkPlugin->GetLatency(latency);
114 ASSERT_TRUE(getLatencyStatus == Status::OK);
115
116 // get played out duration us
117 int64_t nowUs = 0;
118 auto durationUs = audioServerSinkPlugin->GetPlayedOutDurationUs(nowUs);
119 ASSERT_TRUE(durationUs == 0);
120
121 // get frame position
122 int32_t framePos = 0;
123 auto getFramePositionStatus = audioServerSinkPlugin->GetFramePosition(framePos);
124 ASSERT_TRUE(getFramePositionStatus == Status::OK);
125
126 // get audio effect mode
127 int32_t audioEffectMode = 0;
128 auto getAudioEffectModeStatus = audioServerSinkPlugin->GetAudioEffectMode(audioEffectMode);
129 ASSERT_TRUE(getAudioEffectModeStatus == Status::OK);
130
131 // get volume
132 float volume = 0;
133 auto getVolumeStatus = audioServerSinkPlugin->GetVolume(volume);
134 ASSERT_TRUE(getVolumeStatus == Status::OK);
135
136 // get speed
137 float speed = 0;
138 auto getSpeedStatus = audioServerSinkPlugin->GetSpeed(speed);
139 ASSERT_TRUE(getSpeedStatus == Status::OK);
140 }
141
142 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_without_init, TestSize.Level1)
143 {
144 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
145 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
146
147 // get latency
148 uint64_t latency = 0;
149 auto getLatencyStatus = audioServerSinkPlugin->GetLatency(latency);
150 ASSERT_FALSE(getLatencyStatus == Status::OK);
151
152 // get played out duration us
153 int64_t nowUs = 0;
154 auto durationUs = audioServerSinkPlugin->GetPlayedOutDurationUs(nowUs);
155 ASSERT_FALSE(durationUs == 0);
156
157 // get frame position
158 int32_t framePos = 0;
159 auto getFramePositionStatus = audioServerSinkPlugin->GetFramePosition(framePos);
160 ASSERT_FALSE(getFramePositionStatus == Status::OK);
161
162 // get audio effect mode
163 int32_t audioEffectMode = 0;
164 auto getAudioEffectModeStatus = audioServerSinkPlugin->GetAudioEffectMode(audioEffectMode);
165 ASSERT_FALSE(getAudioEffectModeStatus == Status::OK);
166
167 // get volume
168 float volume = 0;
169 auto getVolumeStatus = audioServerSinkPlugin->GetVolume(volume);
170 ASSERT_FALSE(getVolumeStatus == Status::OK);
171
172 // get speed
173 float speed = 0;
174 auto getSpeedStatus = audioServerSinkPlugin->GetSpeed(speed);
175 ASSERT_FALSE(getSpeedStatus == Status::OK);
176 }
177
178 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set, TestSize.Level1)
179 {
180 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
181 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
182 auto initStatus = audioServerSinkPlugin->Init();
183 ASSERT_TRUE(initStatus == Status::OK);
184
185 // set event receiver
186 std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
187 audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
188
189 // set volume
190 float targetVolume = 0;
191 auto setVolumeStatus = audioServerSinkPlugin->SetVolume(targetVolume);
192 ASSERT_TRUE(setVolumeStatus == Status::OK);
193
194 // set volume with ramp
195 int32_t duration = 0;
196 auto setVolumeWithRampStatus = audioServerSinkPlugin->SetVolumeWithRamp(targetVolume, duration);
197 ASSERT_TRUE(setVolumeWithRampStatus == 0);
198
199 // set audio effect mode
200 int32_t audioEffectMode = 0;
201 auto setAudioEffectModeStatus = audioServerSinkPlugin->SetAudioEffectMode(audioEffectMode);
202 ASSERT_TRUE(setAudioEffectModeStatus == Status::OK);
203
204 // set speed
205 float speed = 2.0F;
206 auto setSpeedStatus = audioServerSinkPlugin->SetSpeed(speed);
207 ASSERT_TRUE(setSpeedStatus == Status::OK);
208 }
209
210 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set_without_init, TestSize.Level1)
211 {
212 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
213 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
214
215 // set event receiver
216 std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
217 audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
218
219 // set volume
220 float targetVolume = 0;
221 auto setVolumeStatus = audioServerSinkPlugin->SetVolume(targetVolume);
222 ASSERT_FALSE(setVolumeStatus == Status::OK);
223
224 // set volume with ramp
225 int32_t duration = 0;
226 auto setVolumeWithRampStatus = audioServerSinkPlugin->SetVolumeWithRamp(targetVolume, duration);
227 ASSERT_TRUE(setVolumeWithRampStatus == 0);
228
229 // set audio effect mode
230 int32_t audioEffectMode = 0;
231 auto setAudioEffectModeStatus = audioServerSinkPlugin->SetAudioEffectMode(audioEffectMode);
232 ASSERT_FALSE(setAudioEffectModeStatus == Status::OK);
233
234 // set speed
235 float speed = 2.0F;
236 auto setSpeedStatus = audioServerSinkPlugin->SetSpeed(speed);
237 ASSERT_FALSE(setSpeedStatus == Status::OK);
238 }
239
240 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_write, TestSize.Level1)
241 {
242 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("set mute");
243 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
244 AVBufferConfig config;
245 config.size = 4;
246 config.memoryType = MemoryType::SHARED_MEMORY;
247 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
248 ASSERT_TRUE(buffer != nullptr);
249 auto writeStatus = audioServerSinkPlugin->Write(buffer);
250 ASSERT_TRUE(writeStatus == Status::OK);
251
252 // WriteAudioVivid
253 auto writeVividStatus = audioServerSinkPlugin->WriteAudioVivid(buffer);
254 ASSERT_TRUE(writeVividStatus != 0);
255 }
256
257 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_start, TestSize.Level1)
258 {
259 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("start");
260 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
261 ASSERT_EQ(Status::ERROR_WRONG_STATE, audioServerSinkPlugin->Start());
262 }
263
264 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetVolumeWithRamp, TestSize.Level1)
265 {
266 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("SetVolumeWithRamp");
267 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
268 ASSERT_EQ(0, audioServerSinkPlugin->SetVolumeWithRamp(0, 1));
269 }
270
271 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignSampleRateIfSupported, TestSize.Level1)
272 {
273 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
274 CreateAudioServerSinkPlugin("AssignSampleRateIfSupported");
275 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
276 int32_t sampleRate1 = 16000;
277 int32_t sampleRate2 = 0;
278 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate1));
279 ASSERT_FALSE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate2));
280 }
281
282 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignChannelNumIfSupported, TestSize.Level1)
283 {
284 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
285 CreateAudioServerSinkPlugin("AssignChannelNumIfSupported");
286 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
287 int32_t channelNum1 = 0;
288 int32_t channelNum2 = 2;
289 ASSERT_FALSE(audioServerSinkPlugin->AssignChannelNumIfSupported(channelNum1));
290 ASSERT_TRUE(audioServerSinkPlugin->AssignChannelNumIfSupported(channelNum2));
291 }
292
293 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignSampleFmtIfSupported, TestSize.Level1)
294 {
295 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
296 CreateAudioServerSinkPlugin("AssignSampleFmtIfSupported");
297 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
298 ASSERT_FALSE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_S24P));
299 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_U8P));
300 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_U8));
301 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_F32LE));
302 }
303
304 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetInterruptMode, TestSize.Level1)
305 {
306 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
307 CreateAudioServerSinkPlugin("SetInterruptMode");
308 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
309 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
310 audioServerSinkPlugin->SetInterruptMode(AudioStandard::InterruptMode::SHARE_MODE);
311 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
312 audioServerSinkPlugin->SetInterruptMode(AudioStandard::InterruptMode::SHARE_MODE);
313 }
314
315 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetParameter, TestSize.Level1)
316 {
317 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
318 CreateAudioServerSinkPlugin("SetParameter");
319 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
320 // set event receiver
321 std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
322 audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
323 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
324 std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
325 meta1->SetData(Tag::AUDIO_SAMPLE_RATE, 16000);
326 meta1->SetData(Tag::AUDIO_OUTPUT_CHANNELS, 2);
327 meta1->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::AudioSampleFormat::SAMPLE_U8P);
328 meta1->SetData(Tag::AUDIO_RENDER_SET_FLAG, true);
329 std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
330 meta1->SetData(Tag::AUDIO_SAMPLE_RATE, 0);
331 meta1->SetData(Tag::AUDIO_OUTPUT_CHANNELS, 0);
332 meta1->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::AudioSampleFormat::SAMPLE_F32LE);
333 meta1->SetData(Tag::AUDIO_RENDER_SET_FLAG, false);
334 ASSERT_EQ(Status::OK, audioServerSinkPlugin->SetParameter(meta1));
335 ASSERT_EQ(Status::OK, audioServerSinkPlugin->SetParameter(meta2));
336 }
337
338 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DrainCacheData, TestSize.Level1)
339 {
340 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
341 CreateAudioServerSinkPlugin("DrainCacheData");
342 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
343 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
344
345 AVBufferConfig config;
346 config.size = 4;
347 config.memoryType = MemoryType::SHARED_MEMORY;
348 const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
349 ASSERT_TRUE(buffer != nullptr);
350 uint8_t* addr = buffer->memory_->GetAddr();
351 audioServerSinkPlugin->CacheData(addr, config.size);
352 audioServerSinkPlugin->CacheData(addr, config.size);
353
354 ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->DrainCacheData(true));
355 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
356
357 audioServerSinkPlugin->CacheData(addr, config.size);
358 audioServerSinkPlugin->CacheData(addr, config.size);
359 audioServerSinkPlugin->CacheData(addr, config.size);
360 audioServerSinkPlugin->CacheData(addr, config.size);
361 audioServerSinkPlugin->CacheData(addr, config.size);
362 audioServerSinkPlugin->CacheData(addr, config.size);
363 audioServerSinkPlugin->CacheData(addr, config.size);
364 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
365 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Pause());
366 ASSERT_EQ(Status::ERROR_AGAIN, audioServerSinkPlugin->DrainCacheData(true));
367 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Resume());
368 ASSERT_EQ(Status::OK, audioServerSinkPlugin->DrainCacheData(true));
369 }
370
371 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_Write, TestSize.Level1)
372 {
373 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
374 CreateAudioServerSinkPlugin("Write");
375 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
376 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
377
378 auto alloc = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
379 int32_t size = 4;
380 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(alloc, size);
381 ASSERT_TRUE(buffer != nullptr);
382 buffer->memory_->SetSize(4);
383 ASSERT_EQ(Status::ERROR_NULL_POINTER, audioServerSinkPlugin->Write(buffer));
384 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
385 ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->Write(buffer));
386 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
387 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Pause());
388 ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->Write(buffer));
389 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Resume());
390 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Write(buffer));
391 }
392
393 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetAudioDumpBySysParam, TestSize.Level1)
394 {
395 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
396 CreateAudioServerSinkPlugin("Write");
397 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
398 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
399 system("param set sys.media.sink.entiredump.enable true");
400 system("param set sys.media.sink.slicedump.enable true");
401 audioServerSinkPlugin->SetAudioDumpBySysParam();
402
403 auto alloc = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
404 int32_t size = 4;
405 std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(alloc, size);
406 ASSERT_TRUE(buffer != nullptr);
407 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
408 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
409 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Write(buffer));
410
411
412 audioServerSinkPlugin->DumpEntireAudioBuffer(buffer->memory_->GetAddr(), size);
413 audioServerSinkPlugin->DumpSliceAudioBuffer(buffer->memory_->GetAddr(), size);
414 system("param set sys.media.sink.entiredump.enable false");
415 system("param set sys.media.sink.slicedump.enable false");
416 audioServerSinkPlugin->SetAudioDumpBySysParam();
417 audioServerSinkPlugin->DumpEntireAudioBuffer(buffer->memory_->GetAddr(), size);
418 audioServerSinkPlugin->DumpSliceAudioBuffer(buffer->memory_->GetAddr(), size);
419 }
420
421 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_callback, TestSize.Level1)
422 {
423 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
424 CreateAudioServerSinkPlugin("Write");
425 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
426 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
427 std::shared_ptr<Pipeline::EventReceiver> receiver = std::make_shared<TestEventReceiver>();
428 audioServerSinkPlugin->SetEventReceiver(receiver);
429 bool isPaused = false;
430 std::shared_ptr<AudioServerSinkPlugin::AudioRendererCallbackImpl> callback =
431 std::make_shared<AudioServerSinkPlugin::AudioRendererCallbackImpl>(receiver, isPaused);
432 OHOS::AudioStandard::InterruptEvent event1{InterruptType::INTERRUPT_TYPE_BEGIN,
433 InterruptForceType::INTERRUPT_FORCE, InterruptHint::INTERRUPT_HINT_PAUSE};
434 callback->OnInterrupt(event1);
435 EXPECT_EQ(true, callback->isPaused_);
436 OHOS::AudioStandard::InterruptEvent event2{InterruptType::INTERRUPT_TYPE_BEGIN,
437 InterruptForceType::INTERRUPT_FORCE, InterruptHint::INTERRUPT_HINT_STOP};
438 callback->OnInterrupt(event2);
439 EXPECT_EQ(false, callback->isPaused_);
440 OHOS::AudioStandard::InterruptEvent event3{InterruptType::INTERRUPT_TYPE_BEGIN,
441 InterruptForceType::INTERRUPT_SHARE, InterruptHint::INTERRUPT_HINT_STOP};
442 callback->OnInterrupt(event3);
443 EXPECT_EQ(false, callback->isPaused_);
444 callback->OnStateChange(RendererState::RENDERER_INVALID, StateChangeCmdType::CMD_FROM_CLIENT);
445 }
446
447 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_init, TestSize.Level1)
448 {
449 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
450 CreateAudioServerSinkPlugin("Write");
451 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
452 audioServerSinkPlugin->audioRenderSetFlag_ = true;
453 audioServerSinkPlugin->rendererOptions_.rendererInfo.streamUsage = STREAM_USAGE_AUDIOBOOK;
454 audioServerSinkPlugin->Init();
455 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ != nullptr);
456
457 audioServerSinkPlugin->rendererOptions_.rendererInfo.streamUsage = STREAM_USAGE_GAME;
458 audioServerSinkPlugin->Init();
459 ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ != nullptr);
460 }
461
462 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_release_file, TestSize.Level1)
463 {
464 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
465 CreateAudioServerSinkPlugin("Write");
466 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
467 std::string path = "data/media/audio-sink-entire.pcm";
468 audioServerSinkPlugin->entireDumpFile_ = fopen(path.c_str(), "wb+");
469 path = "data/media/audio-sink-slice-.pcm";
470 audioServerSinkPlugin->sliceDumpFile_ = fopen(path.c_str(), "wb+");
471 ASSERT_EQ(nullptr, audioServerSinkPlugin->entireDumpFile_);
472 ASSERT_EQ(nullptr, audioServerSinkPlugin->sliceDumpFile_);
473 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Reset());
474 }
475
476 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_reset, TestSize.Level1)
477 {
478 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
479 CreateAudioServerSinkPlugin("Write");
480 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
481 audioServerSinkPlugin->resample_ = std::make_shared<Ffmpeg::Resample>();
482 float volume = 0;
483 int32_t duration = 0;
484 ASSERT_EQ(0, audioServerSinkPlugin->SetVolumeWithRamp(volume, duration));
485 ASSERT_EQ(Status::OK, audioServerSinkPlugin->Reset());
486 }
487
488 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_parameter_001, TestSize.Level1)
489 {
490 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
491 CreateAudioServerSinkPlugin("Write");
492 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
493 audioServerSinkPlugin->audioRenderSetFlag_ = true;
494 audioServerSinkPlugin->audioRenderInfo_.streamUsage = STREAM_USAGE_AUDIOBOOK;
495 audioServerSinkPlugin->Init();
496 uint32_t sampleRate = 16000;
497 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate));
498 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
499 ASSERT_EQ(Status::OK, audioServerSinkPlugin->GetParameter(meta));
500 }
501
502 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_parameter_002, TestSize.Level1)
503 {
504 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
505 CreateAudioServerSinkPlugin("Write");
506 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
507 audioServerSinkPlugin->audioRenderSetFlag_ = true;
508 audioServerSinkPlugin->audioRenderInfo_.streamUsage = STREAM_USAGE_AUDIOBOOK;
509 audioServerSinkPlugin->Init();
510 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleRateIfSupported(AudioSamplingRate::SAMPLE_RATE_11025));
511
512 uint32_t sampleRate = 16000;
513 ASSERT_TRUE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate));
514 std::shared_ptr<Meta> meta = std::make_shared<Meta>();
515 meta->Set<Tag::AUDIO_RENDER_SET_FLAG>(true);
516 ASSERT_EQ(Status::OK, audioServerSinkPlugin->SetParameter(meta));
517 audioServerSinkPlugin->GetParameter(meta);
518 }
519
520 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_cache_data, TestSize.Level1)
521 {
522 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
523 CreateAudioServerSinkPlugin("Write");
524 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
525 audioServerSinkPlugin->CacheData(nullptr, 0);
526 audioServerSinkPlugin->CacheData(nullptr, 0);
527 audioServerSinkPlugin->CacheData(nullptr, 0);
528 audioServerSinkPlugin->CacheData(nullptr, 0);
529 audioServerSinkPlugin->CacheData(nullptr, 0);
530 audioServerSinkPlugin->CacheData(nullptr, 0);
531 audioServerSinkPlugin->CacheData(nullptr, 0);
532 audioServerSinkPlugin->CacheData(nullptr, 0);
533 audioServerSinkPlugin->CacheData(nullptr, 0);
534 int32_t DEFAULT_BUFFER_NUM = 8;
535 ASSERT_EQ(DEFAULT_BUFFER_NUM, audioServerSinkPlugin->cachedBuffers_.size());
536 }
537
538 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DumpEntireAudioBuffer001, TestSize.Level1)
539 {
540 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
541 CreateAudioServerSinkPlugin("Write");
542 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
543 uint8_t data[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
544 uint8_t* buffer = data;
545 size_t bytesSingle = 10;
546 audioServerSinkPlugin->enableEntireDump_ = false;
547 audioServerSinkPlugin->DumpEntireAudioBuffer(buffer, bytesSingle);
548 audioServerSinkPlugin->enableEntireDump_ = true;
549 audioServerSinkPlugin->DumpEntireAudioBuffer(buffer, bytesSingle);
550 ASSERT_TRUE(audioServerSinkPlugin->entireDumpFile_ == nullptr);
551 }
552
553 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DumpSliceAudioBuffer001, TestSize.Level1)
554 {
555 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
556 CreateAudioServerSinkPlugin("Write");
557 ASSERT_TRUE(audioServerSinkPlugin != nullptr);
558 uint8_t data[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
559 uint8_t* buffer = data;
560 size_t bytesSingle = 10;
561 audioServerSinkPlugin->enableDumpSlice_ = false;
562 audioServerSinkPlugin->DumpSliceAudioBuffer(buffer, bytesSingle);
563 audioServerSinkPlugin->enableDumpSlice_ = true;
564 audioServerSinkPlugin->DumpSliceAudioBuffer(buffer, bytesSingle);
565 ASSERT_EQ(audioServerSinkPlugin->curCount_, audioServerSinkPlugin->sliceCount_);
566 }
567
568 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_GetWriteDurationMs001, TestSize.Level1)
569 {
570 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
571 CreateAudioServerSinkPlugin("Write");
572 int64_t duration = 100;
573 audioServerSinkPlugin->writeDuration_ = duration;
574 int64_t ret = audioServerSinkPlugin->GetWriteDurationMs();
575 ASSERT_EQ(ret, duration);
576 }
577
578 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_Drain001, TestSize.Level1)
579 {
580 std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
581 CreateAudioServerSinkPlugin("Write");
582 audioServerSinkPlugin->audioRenderer_ = nullptr;
583 Status ret = audioServerSinkPlugin->Drain();
584 ASSERT_EQ(ret, Status::ERROR_WRONG_STATE);
585 }
586 } // namespace Test
587 } // namespace Media
588 } // namespace OHOS