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 
19 using namespace testing::ext;
20 using namespace OHOS::Media::Plugins;
21 
22 namespace OHOS {
23 namespace Media {
24 namespace Test {
25 class TestEventReceiver : public Pipeline::EventReceiver {
26 public:
TestEventReceiver()27     explicit TestEventReceiver()
28     {
29         std::cout << "event receiver constructor" << std::endl;
30     }
31 
OnEvent(const Event & event)32     void OnEvent(const Event &event)
33     {
34         std::cout << event.srcFilter << std::endl;
35     }
36 
37 private:
38 };
39 
CreateAudioServerSinkPlugin(const std::string & name)40 std::shared_ptr<AudioServerSinkPlugin> CreateAudioServerSinkPlugin(const std::string &name)
41 {
42     return std::make_shared<AudioServerSinkPlugin>(name);
43 }
44 
45 HWTEST(TestAudioServerSinkPlugin, find_audio_server_sink_plugin, TestSize.Level1)
46 {
47     auto audioServerSinkPlugin = CreateAudioServerSinkPlugin("process");
48     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
49     auto initStatus = audioServerSinkPlugin->Init();
50     ASSERT_TRUE(initStatus == Status::OK);
51     auto freeStatus = audioServerSinkPlugin->Deinit();
52     ASSERT_TRUE(freeStatus == Status::OK);
53 }
54 
55 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_parameter, TestSize.Level1)
56 {
57     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get parameter");
58     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
59     auto meta = std::make_shared<Meta>();
60     auto resGetParam = audioServerSinkPlugin->GetParameter(meta);
61     ASSERT_TRUE(resGetParam == Status::OK);
62 }
63 
64 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set_parameter, TestSize.Level1)
65 {
66     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("set parameter");
67     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
68     auto meta = std::make_shared<Meta>();
69     auto resGetParam = audioServerSinkPlugin->SetParameter(meta);
70     ASSERT_TRUE(resGetParam == Status::OK);
71 }
72 
73 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_life_cycle, TestSize.Level1)
74 {
75     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get allocator");
76     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
77     auto initStatus = audioServerSinkPlugin->Init();
78     ASSERT_TRUE(initStatus == Status::OK);
79     auto prepareStatus = audioServerSinkPlugin->Prepare();
80     ASSERT_TRUE(prepareStatus == Status::OK);
81     auto startStatus = audioServerSinkPlugin->Start();
82     ASSERT_TRUE(startStatus == Status::OK);
83     auto flushStatus = audioServerSinkPlugin->Flush();
84     ASSERT_TRUE(flushStatus == Status::OK);
85     auto pauseStatus = audioServerSinkPlugin->Pause();
86     ASSERT_TRUE(pauseStatus == Status::OK);
87     auto resumeStatus = audioServerSinkPlugin->Resume();
88     ASSERT_TRUE(resumeStatus == Status::OK);
89     auto pauseTransitentStatus = audioServerSinkPlugin->PauseTransitent();
90     ASSERT_TRUE(pauseTransitentStatus == Status::OK);
91     auto drainStatus = audioServerSinkPlugin->Drain();
92     ASSERT_TRUE(drainStatus == Status::OK);
93     auto stopStatus = audioServerSinkPlugin->Stop();
94     ASSERT_TRUE(stopStatus == Status::OK);
95     auto resetStatus = audioServerSinkPlugin->Reset();
96     ASSERT_TRUE(resetStatus == Status::OK);
97     auto deinitStatus = audioServerSinkPlugin->Deinit();
98     ASSERT_TRUE(deinitStatus == Status::OK);
99 }
100 
101 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get, TestSize.Level1)
102 {
103     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
104     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
105     auto initStatus = audioServerSinkPlugin->Init();
106     ASSERT_TRUE(initStatus == Status::OK);
107 
108     // get latency
109     uint64_t latency = 0;
110     auto getLatencyStatus = audioServerSinkPlugin->GetLatency(latency);
111     ASSERT_TRUE(getLatencyStatus == Status::OK);
112 
113     // get played out duration us
114     int64_t nowUs = 0;
115     auto durationUs = audioServerSinkPlugin->GetPlayedOutDurationUs(nowUs);
116     ASSERT_TRUE(durationUs == 0);
117 
118     // get frame position
119     int32_t framePos = 0;
120     auto getFramePositionStatus = audioServerSinkPlugin->GetFramePosition(framePos);
121     ASSERT_TRUE(getFramePositionStatus == Status::OK);
122 
123     // get audio effect mode
124     int32_t audioEffectMode = 0;
125     auto getAudioEffectModeStatus = audioServerSinkPlugin->GetAudioEffectMode(audioEffectMode);
126     ASSERT_TRUE(getAudioEffectModeStatus == Status::OK);
127 
128     // get volume
129     float volume = 0;
130     auto getVolumeStatus = audioServerSinkPlugin->GetVolume(volume);
131     ASSERT_TRUE(getVolumeStatus == Status::OK);
132 
133     // get speed
134     float speed = 0;
135     auto getSpeedStatus = audioServerSinkPlugin->GetSpeed(speed);
136     ASSERT_TRUE(getSpeedStatus == Status::OK);
137 }
138 
139 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_get_without_init, TestSize.Level1)
140 {
141     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
142     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
143 
144     // get latency
145     uint64_t latency = 0;
146     auto getLatencyStatus = audioServerSinkPlugin->GetLatency(latency);
147     ASSERT_FALSE(getLatencyStatus == Status::OK);
148 
149     // get played out duration us
150     int64_t nowUs = 0;
151     auto durationUs = audioServerSinkPlugin->GetPlayedOutDurationUs(nowUs);
152     ASSERT_FALSE(durationUs == 0);
153 
154     // get frame position
155     int32_t framePos = 0;
156     auto getFramePositionStatus = audioServerSinkPlugin->GetFramePosition(framePos);
157     ASSERT_FALSE(getFramePositionStatus == Status::OK);
158 
159     // get audio effect mode
160     int32_t audioEffectMode = 0;
161     auto getAudioEffectModeStatus = audioServerSinkPlugin->GetAudioEffectMode(audioEffectMode);
162     ASSERT_FALSE(getAudioEffectModeStatus == Status::OK);
163 
164     // get volume
165     float volume = 0;
166     auto getVolumeStatus = audioServerSinkPlugin->GetVolume(volume);
167     ASSERT_FALSE(getVolumeStatus == Status::OK);
168 
169     // get speed
170     float speed = 0;
171     auto getSpeedStatus = audioServerSinkPlugin->GetSpeed(speed);
172     ASSERT_FALSE(getSpeedStatus == Status::OK);
173 }
174 
175 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set, TestSize.Level1)
176 {
177     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
178     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
179     auto initStatus = audioServerSinkPlugin->Init();
180     ASSERT_TRUE(initStatus == Status::OK);
181 
182     // set event receiver
183     std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
184     audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
185 
186     // set volume
187     float targetVolume = 0;
188     auto setVolumeStatus = audioServerSinkPlugin->SetVolume(targetVolume);
189     ASSERT_TRUE(setVolumeStatus == Status::OK);
190 
191     // set volume with ramp
192     int32_t duration = 0;
193     auto setVolumeWithRampStatus = audioServerSinkPlugin->SetVolumeWithRamp(targetVolume, duration);
194     ASSERT_TRUE(setVolumeWithRampStatus == 0);
195 
196     // set audio effect mode
197     int32_t audioEffectMode = 0;
198     auto setAudioEffectModeStatus = audioServerSinkPlugin->SetAudioEffectMode(audioEffectMode);
199     ASSERT_TRUE(setAudioEffectModeStatus == Status::OK);
200 
201     // set speed
202     float speed = 2.0F;
203     auto setSpeedStatus = audioServerSinkPlugin->SetSpeed(speed);
204     ASSERT_TRUE(setSpeedStatus == Status::OK);
205 }
206 
207 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_set_without_init, TestSize.Level1)
208 {
209     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("get");
210     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
211 
212     // set event receiver
213     std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
214     audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
215 
216     // set volume
217     float targetVolume = 0;
218     auto setVolumeStatus = audioServerSinkPlugin->SetVolume(targetVolume);
219     ASSERT_FALSE(setVolumeStatus == Status::OK);
220 
221     // set volume with ramp
222     int32_t duration = 0;
223     auto setVolumeWithRampStatus = audioServerSinkPlugin->SetVolumeWithRamp(targetVolume, duration);
224     ASSERT_TRUE(setVolumeWithRampStatus == 0);
225 
226     // set audio effect mode
227     int32_t audioEffectMode = 0;
228     auto setAudioEffectModeStatus = audioServerSinkPlugin->SetAudioEffectMode(audioEffectMode);
229     ASSERT_FALSE(setAudioEffectModeStatus == Status::OK);
230 
231     // set speed
232     float speed = 2.0F;
233     auto setSpeedStatus = audioServerSinkPlugin->SetSpeed(speed);
234     ASSERT_FALSE(setSpeedStatus == Status::OK);
235 }
236 
237 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_write, TestSize.Level1)
238 {
239     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("set mute");
240     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
241     AVBufferConfig config;
242     config.size = 4;
243     config.memoryType = MemoryType::SHARED_MEMORY;
244     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
245     ASSERT_TRUE(buffer != nullptr);
246     auto writeStatus = audioServerSinkPlugin->Write(buffer);
247     ASSERT_TRUE(writeStatus == Status::OK);
248 
249     // WriteAudioVivid
250     auto writeVividStatus = audioServerSinkPlugin->WriteAudioVivid(buffer);
251     ASSERT_TRUE(writeVividStatus != 0);
252 }
253 
254 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_start, TestSize.Level1)
255 {
256     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("start");
257     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
258     ASSERT_EQ(Status::ERROR_WRONG_STATE, audioServerSinkPlugin->Start());
259 }
260 
261 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetVolumeWithRamp, TestSize.Level1)
262 {
263     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin = CreateAudioServerSinkPlugin("SetVolumeWithRamp");
264     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
265     ASSERT_EQ(0, audioServerSinkPlugin->SetVolumeWithRamp(0, 1));
266 }
267 
268 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignSampleRateIfSupported, TestSize.Level1)
269 {
270     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
271         CreateAudioServerSinkPlugin("AssignSampleRateIfSupported");
272     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
273     int32_t sampleRate1 = 16000;
274     int32_t sampleRate2 = 0;
275     ASSERT_TRUE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate1));
276     ASSERT_FALSE(audioServerSinkPlugin->AssignSampleRateIfSupported(sampleRate2));
277 }
278 
279 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignChannelNumIfSupported, TestSize.Level1)
280 {
281     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
282         CreateAudioServerSinkPlugin("AssignChannelNumIfSupported");
283     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
284     int32_t channelNum1 = 0;
285     int32_t channelNum2 = 2;
286     ASSERT_FALSE(audioServerSinkPlugin->AssignChannelNumIfSupported(channelNum1));
287     ASSERT_TRUE(audioServerSinkPlugin->AssignChannelNumIfSupported(channelNum2));
288 }
289 
290 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_AssignSampleFmtIfSupported, TestSize.Level1)
291 {
292     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
293         CreateAudioServerSinkPlugin("AssignSampleFmtIfSupported");
294     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
295     ASSERT_FALSE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_S24P));
296     ASSERT_TRUE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_U8P));
297     ASSERT_TRUE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_U8));
298     ASSERT_FALSE(audioServerSinkPlugin->AssignSampleFmtIfSupported(Plugins::AudioSampleFormat::SAMPLE_F32LE));
299 }
300 
301 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetInterruptMode, TestSize.Level1)
302 {
303     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
304         CreateAudioServerSinkPlugin("SetInterruptMode");
305     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
306     ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
307     audioServerSinkPlugin->SetInterruptMode(AudioStandard::InterruptMode::SHARE_MODE);
308     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
309     audioServerSinkPlugin->SetInterruptMode(AudioStandard::InterruptMode::SHARE_MODE);
310 }
311 
312 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetParameter, TestSize.Level1)
313 {
314     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
315         CreateAudioServerSinkPlugin("SetParameter");
316     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
317         // set event receiver
318     std::shared_ptr<Pipeline::EventReceiver> testEventReceiver = std::make_shared<TestEventReceiver>();
319     audioServerSinkPlugin->SetEventReceiver(testEventReceiver);
320     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
321     std::shared_ptr<Meta> meta1 = std::make_shared<Meta>();
322     meta1->SetData(Tag::AUDIO_SAMPLE_RATE, 16000);
323     meta1->SetData(Tag::AUDIO_OUTPUT_CHANNELS, 2);
324     meta1->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::AudioSampleFormat::SAMPLE_U8P);
325     meta1->SetData(Tag::AUDIO_RENDER_SET_FLAG, true);
326     std::shared_ptr<Meta> meta2 = std::make_shared<Meta>();
327     meta1->SetData(Tag::AUDIO_SAMPLE_RATE, 0);
328     meta1->SetData(Tag::AUDIO_OUTPUT_CHANNELS, 0);
329     meta1->SetData(Tag::AUDIO_SAMPLE_FORMAT, Plugins::AudioSampleFormat::SAMPLE_F32LE);
330     meta1->SetData(Tag::AUDIO_RENDER_SET_FLAG, false);
331     ASSERT_EQ(Status::OK, audioServerSinkPlugin->SetParameter(meta1));
332     ASSERT_EQ(Status::OK, audioServerSinkPlugin->SetParameter(meta2));
333 }
334 
335 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DrainCacheData, TestSize.Level1)
336 {
337     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
338         CreateAudioServerSinkPlugin("DrainCacheData");
339     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
340     ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
341 
342     AVBufferConfig config;
343     config.size = 4;
344     config.memoryType = MemoryType::SHARED_MEMORY;
345     const std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(config);
346     ASSERT_TRUE(buffer != nullptr);
347     uint8_t* addr = buffer->memory_->GetAddr();
348     audioServerSinkPlugin->CacheData(addr, config.size);
349     audioServerSinkPlugin->CacheData(addr, config.size);
350 
351     ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->DrainCacheData(true));
352     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
353 
354     audioServerSinkPlugin->CacheData(addr, config.size);
355     audioServerSinkPlugin->CacheData(addr, config.size);
356     audioServerSinkPlugin->CacheData(addr, config.size);
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     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
362     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Pause());
363     ASSERT_EQ(Status::ERROR_AGAIN, audioServerSinkPlugin->DrainCacheData(true));
364     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Resume());
365     ASSERT_EQ(Status::OK, audioServerSinkPlugin->DrainCacheData(true));
366 }
367 
368 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_Write, TestSize.Level1)
369 {
370     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
371         CreateAudioServerSinkPlugin("Write");
372     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
373     ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
374 
375     auto alloc = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
376     int32_t size = 4;
377     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(alloc, size);
378     ASSERT_TRUE(buffer != nullptr);
379     buffer->memory_->SetSize(4);
380     ASSERT_EQ(Status::ERROR_NULL_POINTER, audioServerSinkPlugin->Write(buffer));
381     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
382     ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->Write(buffer));
383     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
384     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Pause());
385     ASSERT_EQ(Status::ERROR_UNKNOWN, audioServerSinkPlugin->Write(buffer));
386     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Resume());
387     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Write(buffer));
388 }
389 
390 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_SetAudioDumpBySysParam, TestSize.Level1)
391 {
392     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
393         CreateAudioServerSinkPlugin("Write");
394     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
395     ASSERT_TRUE(audioServerSinkPlugin->audioRenderer_ == nullptr);
396     system("param set sys.media.sink.entiredump.enable true");
397     system("param set sys.media.sink.slicedump.enable true");
398     audioServerSinkPlugin->SetAudioDumpBySysParam();
399 
400     auto alloc = AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
401     int32_t size = 4;
402     std::shared_ptr<AVBuffer> buffer = AVBuffer::CreateAVBuffer(alloc, size);
403     ASSERT_TRUE(buffer != nullptr);
404     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Init());
405     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Start());
406     ASSERT_EQ(Status::OK, audioServerSinkPlugin->Write(buffer));
407 
408 
409     audioServerSinkPlugin->DumpEntireAudioBuffer(buffer->memory_->GetAddr(), size);
410     audioServerSinkPlugin->DumpSliceAudioBuffer(buffer->memory_->GetAddr(), size);
411     system("param set sys.media.sink.entiredump.enable false");
412     system("param set sys.media.sink.slicedump.enable false");
413     audioServerSinkPlugin->SetAudioDumpBySysParam();
414     audioServerSinkPlugin->DumpEntireAudioBuffer(buffer->memory_->GetAddr(), size);
415     audioServerSinkPlugin->DumpSliceAudioBuffer(buffer->memory_->GetAddr(), size);
416 }
417 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DumpEntireAudioBuffer001, TestSize.Level1)
418 {
419     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
420         CreateAudioServerSinkPlugin("Write");
421     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
422     uint8_t data[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
423     uint8_t* buffer = data;
424     size_t bytesSingle = 10;
425     audioServerSinkPlugin->enableEntireDump_ = false;
426     audioServerSinkPlugin->DumpEntireAudioBuffer(buffer, bytesSingle);
427     audioServerSinkPlugin->enableEntireDump_ = true;
428     audioServerSinkPlugin->DumpEntireAudioBuffer(buffer, bytesSingle);
429 }
430 
431 HWTEST(TestAudioServerSinkPlugin, audio_sink_plugin_DumpSliceAudioBuffer001, TestSize.Level1)
432 {
433     std::shared_ptr<AudioServerSinkPlugin> audioServerSinkPlugin =
434         CreateAudioServerSinkPlugin("Write");
435     ASSERT_TRUE(audioServerSinkPlugin != nullptr);
436     uint8_t data[10] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0A};
437     uint8_t* buffer = data;
438     size_t bytesSingle = 10;
439     audioServerSinkPlugin->enableDumpSlice_ = false;
440     audioServerSinkPlugin->DumpSliceAudioBuffer(buffer, bytesSingle);
441     audioServerSinkPlugin->enableDumpSlice_ = true;
442     audioServerSinkPlugin->DumpSliceAudioBuffer(buffer, bytesSingle);
443     ASSERT_EQ(audioServerSinkPlugin->curCount_, audioServerSinkPlugin->sliceCount_);
444 }
445 }  // namespace Test
446 }  // namespace Media
447 }  // namespace OHOS