1 /*
2 * Copyright (c) 2023 Shenzhen Kaihong Digital Industry Development 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 <iostream>
18 #include <thread>
19 #include <memory>
20 #include <string>
21 #include <fcntl.h>
22 #include <cstdlib>
23 #include <cstring>
24
25
26 #include "common/sharing_log.h"
27 #include "media_controller.h"
28 #include "media_channel.h"
29 #include "common/event_comm.h"
30 #include "common/media_log.h"
31 #include "media_channel_def.h"
32 #include "audio_play_controller.h"
33 #include "buffer_dispatcher.h"
34 #include "securec.h"
35
36 using namespace testing::ext;
37 using namespace OHOS::Sharing;
38
39 namespace OHOS {
40 namespace Sharing {
41 class AudioPlayControllerTestBaseImpl
42 :public Singleton<AudioPlayControllerTestBaseImpl>,
43 public IdentifierInfo {
44 private:
45 FILE *audioTestFp_;
46 std::string audioTestPath_ = "/data/mediaplayer_audio_test.wav";
47 DataBuffer::Ptr audioTestData_;
48 MediaData::Ptr mediaData_;
49 size_t audioTestDataLen_;
50
51 AudioTrack audioTrack_;
52 BufferDispatcher::Ptr dispatcher_ = nullptr;
53
54 bool playbackRun_;
55 std::unique_ptr<std::thread> playbackThread_ = nullptr;
56 public:
AudioPlayControllerTestBaseImpl()57 AudioPlayControllerTestBaseImpl()
58 {
59 dispatcher_ = std::make_shared<BufferDispatcher>(maxBufferCapacity, maxBufferCapacityIncrement);
60 EXPECT_NE(nullptr, dispatcher_);
61
62 mediaData_ = std::make_shared<MediaData>();
63 EXPECT_NE(nullptr, mediaData_);
64 mediaData_->isRaw = false;
65 mediaData_->keyFrame = false;
66 mediaData_->ssrc = 0;
67 mediaData_->pts = 0;
68 mediaData_->mediaType = MediaType::MEDIA_TYPE_AUDIO;
69 AudioTestDataLoad();
70 AudioTrackReset();
71 }
72
73 ~AudioPlayControllerTestBaseImpl() override
74 {
75 PlaybackStop();
76 AudioTestDataUnLoad();
77 BufferDispatcherReset();
78 }
79 public:
GetAudioTestData(void)80 DataBuffer::Ptr& GetAudioTestData(void)
81 {
82 return audioTestData_;
83 }
84
GetAudioTestDataLength(void) const85 size_t GetAudioTestDataLength(void) const
86 {
87 return audioTestDataLen_;
88 }
89
AudioTrackReset(void)90 void AudioTrackReset(void)
91 {
92 audioTrack_.codecId = CodecId::CODEC_AAC;
93 audioTrack_.sampleRate = defaultSampleRate;
94 audioTrack_.sampleBit = DEFAULT_SAMPLE_BIT;
95 audioTrack_.channels = defaultChannels;
96 }
97
GetAudioTrack(void)98 AudioTrack& GetAudioTrack(void)
99 {
100 return audioTrack_;
101 }
102
BufferDispatcherReset(void)103 void BufferDispatcherReset(void)
104 {
105 if (dispatcher_ != nullptr) {
106 dispatcher_->StopDispatch();
107 dispatcher_->FlushBuffer();
108 dispatcher_->ReleaseAllReceiver();
109 }
110 }
111
GetBufferDispatcher(void)112 BufferDispatcher::Ptr& GetBufferDispatcher(void)
113 {
114 return dispatcher_;
115 }
116
IsPlaybackRunning(void) const117 bool IsPlaybackRunning(void) const
118 {
119 return playbackRun_;
120 }
121
PlaybackStop(void)122 void PlaybackStop(void)
123 {
124 playbackRun_ = false;
125 playbackThread_->join();
126 playbackThread_ = nullptr;
127 }
128
AudioPlayerPlaybackStart(void)129 void AudioPlayerPlaybackStart(void)
130 {
131 EXPECT_EQ(nullptr, playbackThread_);
132 EXPECT_EQ(false, playbackRun_);
133 constexpr uint32_t waitForThread = 100;
134
135 playbackRun_ = true;
136 playbackThread_ = std::make_unique<std::thread>(
137 [this]() {
138 constexpr uint32_t interval = 20;
139 SHARING_LOGD("AudioPlayerPlayback test start\n");
140 while (IsPlaybackRunning()) {
141 SHARING_LOGD("AudioPlayerPlayback Writing\n");
142 dispatcher_->InputData(
143 mediaData_
144 );
145 std::this_thread::sleep_for(std::chrono::milliseconds(interval));
146 }
147 SHARING_LOGD("AudioPlayerPlayback test complete\n");
148 }
149 );
150 pthread_setname_np(playbackThread_->native_handle(), "AudioPlayerPlayback");
151 std::this_thread::sleep_for(std::chrono::milliseconds(waitForThread));
152 }
153
154 private:
AudioTestDataLoad(void)155 void AudioTestDataLoad(void)
156 {
157 audioTestFp_ = ::fopen(audioTestPath_.c_str(), "r");
158 EXPECT_NE(nullptr, audioTestFp_);
159
160 bool ret = fseek(audioTestFp_, 0, SEEK_END);
161 EXPECT_EQ(false, ret < 0);
162
163 size_t fileLen = ftell(audioTestFp_);
164 EXPECT_EQ(false, fileLen < 0);
165
166 audioTestDataLen_ = fileLen + 1;
167 rewind(audioTestFp_);
168 char *audioTestDataTmp = new char[audioTestDataLen_];
169 EXPECT_NE(nullptr, audioTestDataTmp);
170
171 memset_s(audioTestDataTmp, audioTestDataLen_, 0, audioTestDataLen_);
172
173 ret = fread(audioTestDataTmp, 1, fileLen, audioTestFp_);
174 EXPECT_EQ(true, ret > 0);
175
176 ::fclose(audioTestFp_);
177 audioTestData_ = std::make_shared<DataBuffer>(audioTestDataLen_);
178 audioTestData_->Assign(audioTestDataTmp, fileLen);
179 mediaData_->buff = audioTestData_;
180 audioTestFp_ = nullptr;
181 delete[] audioTestDataTmp;
182 }
183
AudioTestDataUnLoad(void)184 void AudioTestDataUnLoad(void)
185 {
186 if (nullptr != audioTestFp_) {
187 ::fclose(audioTestFp_);
188 audioTestFp_ = nullptr;
189 }
190 if (nullptr != audioTestData_) {
191 audioTestData_ = nullptr;
192 }
193 audioTestDataLen_ = 0;
194 }
195
196 public:
197 static constexpr int32_t maxBufferCapacity = ::MAX_BUFFER_CAPACITY;
198 static constexpr int32_t maxBufferCapacityIncrement = ::BUFFER_CAPACITY_INCREMENT;
199 static constexpr int32_t stabilityLoops = 100;
200 static constexpr int32_t defaultChannels = 2;
201 static constexpr int32_t defaultSampleRate = 48000;
202 static constexpr int32_t defaultBitsPerSample = 16;
203 static constexpr float defaultVolume = 1.0;
204 static constexpr float testVolume = 0.5;
205 static constexpr float testVolumeOverflow = 1.5;
206 static constexpr float testVolumeNegative = -0.5;
207 };
208
209 class AudioPlayControllerUnitTest : public testing::Test {};
210
211 namespace {
212 AudioPlayControllerTestBaseImpl& g_testBase =
213 AudioPlayControllerTestBaseImpl::GetInstance();
214
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Create_01, Function | SmallTest | Level2)215 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Create_01,
216 Function | SmallTest | Level2)
217 {
218 SHARING_LOGD("trace");
219 std::shared_ptr<ContextEventMsg> cem = std::make_shared<ContextEventMsg>();
220 std::unique_ptr<AudioPlayController> audioPlayController =
221 std::make_unique<AudioPlayController>(g_testBase.GetId());
222 EXPECT_NE(nullptr, audioPlayController);
223 }
224
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_01, Function | SmallTest | Level2)225 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_01,
226 Function | SmallTest | Level2)
227 {
228 SHARING_LOGD("trace");
229 bool ret = true;
230 std::unique_ptr<AudioPlayController> audioPlayController =
231 std::make_unique<AudioPlayController>(g_testBase.GetId());
232 EXPECT_NE(nullptr, audioPlayController);
233
234 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_PCM;
235 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
236 EXPECT_EQ(ret, false);
237
238 g_testBase.AudioTrackReset();
239 }
240
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_02, Function | SmallTest | Level2)241 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_02,
242 Function | SmallTest | Level2)
243 {
244 SHARING_LOGD("trace");
245 bool ret = true;
246 std::unique_ptr<AudioPlayController> audioPlayController =
247 std::make_unique<AudioPlayController>(g_testBase.GetId());
248 EXPECT_NE(nullptr, audioPlayController);
249
250 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_DEFAULT;
251 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
252 EXPECT_EQ(ret, false);
253
254 g_testBase.AudioTrackReset();
255 }
256
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_03, Function | SmallTest | Level2)257 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_03,
258 Function | SmallTest | Level2)
259 {
260 SHARING_LOGD("trace");
261 bool ret = true;
262 std::unique_ptr<AudioPlayController> audioPlayController =
263 std::make_unique<AudioPlayController>(g_testBase.GetId());
264 EXPECT_NE(nullptr, audioPlayController);
265
266 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_H264;
267 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
268 EXPECT_EQ(ret, false);
269
270 g_testBase.AudioTrackReset();
271 }
272
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_04, Function | SmallTest | Level2)273 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_04,
274 Function | SmallTest | Level2)
275 {
276 SHARING_LOGD("trace");
277 bool ret = true;
278 std::unique_ptr<AudioPlayController> audioPlayController =
279 std::make_unique<AudioPlayController>(g_testBase.GetId());
280 EXPECT_NE(nullptr, audioPlayController);
281
282 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_H265;
283 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
284 EXPECT_EQ(ret, false);
285
286 g_testBase.AudioTrackReset();
287 }
288
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_05, Function | SmallTest | Level2)289 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_05,
290 Function | SmallTest | Level2)
291 {
292 SHARING_LOGD("trace");
293 bool ret = true;
294 std::unique_ptr<AudioPlayController> audioPlayController =
295 std::make_unique<AudioPlayController>(g_testBase.GetId());
296 EXPECT_NE(nullptr, audioPlayController);
297
298 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_VP8;
299 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
300 EXPECT_EQ(ret, false);
301
302 g_testBase.AudioTrackReset();
303 }
304
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_06, Function | SmallTest | Level2)305 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_06,
306 Function | SmallTest | Level2)
307 {
308 SHARING_LOGD("trace");
309 bool ret = true;
310 std::unique_ptr<AudioPlayController> audioPlayController =
311 std::make_unique<AudioPlayController>(g_testBase.GetId());
312 EXPECT_NE(nullptr, audioPlayController);
313
314 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_VP9;
315 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
316 EXPECT_EQ(ret, false);
317
318 g_testBase.AudioTrackReset();
319 }
320
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_07, Function | SmallTest | Level2)321 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_07,
322 Function | SmallTest | Level2)
323 {
324 SHARING_LOGD("trace");
325 bool ret = true;
326 std::unique_ptr<AudioPlayController> audioPlayController =
327 std::make_unique<AudioPlayController>(g_testBase.GetId());
328 EXPECT_NE(nullptr, audioPlayController);
329
330 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_AV1;
331 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
332 EXPECT_EQ(ret, false);
333
334 g_testBase.AudioTrackReset();
335 }
336
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_08, Function | SmallTest | Level2)337 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_08,
338 Function | SmallTest | Level2)
339 {
340 SHARING_LOGD("trace");
341 bool ret = true;
342 std::unique_ptr<AudioPlayController> audioPlayController =
343 std::make_unique<AudioPlayController>(g_testBase.GetId());
344 EXPECT_NE(nullptr, audioPlayController);
345
346 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_AAC;
347 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
348 EXPECT_EQ(ret, true);
349
350 g_testBase.AudioTrackReset();
351 }
352
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_09, Function | SmallTest | Level2)353 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_09,
354 Function | SmallTest | Level2)
355 {
356 SHARING_LOGD("trace");
357 bool ret = true;
358 std::unique_ptr<AudioPlayController> audioPlayController =
359 std::make_unique<AudioPlayController>(g_testBase.GetId());
360 EXPECT_NE(nullptr, audioPlayController);
361
362 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_G711A;
363 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
364 EXPECT_EQ(ret, true);
365
366 g_testBase.AudioTrackReset();
367 }
368
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_10, Function | SmallTest | Level2)369 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_10,
370 Function | SmallTest | Level2)
371 {
372 SHARING_LOGD("trace");
373 bool ret = true;
374 std::unique_ptr<AudioPlayController> audioPlayController =
375 std::make_unique<AudioPlayController>(g_testBase.GetId());
376 EXPECT_NE(nullptr, audioPlayController);
377
378 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_G711U;
379 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
380 EXPECT_EQ(ret, true);
381
382 g_testBase.AudioTrackReset();
383 }
384
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_11, Function | SmallTest | Level2)385 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_11,
386 Function | SmallTest | Level2)
387 {
388 SHARING_LOGD("trace");
389 bool ret = true;
390 std::unique_ptr<AudioPlayController> audioPlayController =
391 std::make_unique<AudioPlayController>(g_testBase.GetId());
392 EXPECT_NE(nullptr, audioPlayController);
393
394 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_OPUS;
395 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
396 EXPECT_EQ(ret, false);
397
398 g_testBase.AudioTrackReset();
399 }
400
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_12, Function | SmallTest | Level2)401 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_12,
402 Function | SmallTest | Level2)
403 {
404 SHARING_LOGD("trace");
405 bool ret = true;
406 std::unique_ptr<AudioPlayController> audioPlayController =
407 std::make_unique<AudioPlayController>(g_testBase.GetId());
408 EXPECT_NE(nullptr, audioPlayController);
409
410 g_testBase.GetAudioTrack().codecId = CodecId::CODEC_L16;
411 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
412 EXPECT_EQ(ret, false);
413
414 g_testBase.AudioTrackReset();
415 }
416
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_13, Function | SmallTest | Level2)417 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Init_13,
418 Function | SmallTest | Level2)
419 {
420 SHARING_LOGD("trace");
421 bool ret = true;
422 std::unique_ptr<AudioPlayController> audioPlayController =
423 std::make_unique<AudioPlayController>(g_testBase.GetId());
424 EXPECT_NE(nullptr, audioPlayController);
425
426 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
427 EXPECT_EQ(ret, true);
428
429 g_testBase.AudioTrackReset();
430 }
431
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Playback_01, Function | SmallTest | Level2)432 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Playback_01,
433 Function | SmallTest | Level2)
434 {
435 SHARING_LOGD("trace");
436 bool ret = true;
437 std::unique_ptr<AudioPlayController> audioPlayController =
438 std::make_unique<AudioPlayController>(g_testBase.GetId());
439 EXPECT_NE(nullptr, audioPlayController);
440
441 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
442 EXPECT_EQ(ret, true);
443
444 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
445 EXPECT_EQ(ret, true);
446
447 g_testBase.AudioPlayerPlaybackStart();
448 g_testBase.PlaybackStop();
449
450 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
451 g_testBase.AudioTrackReset();
452 g_testBase.BufferDispatcherReset();
453 }
454
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_01, Function | SmallTest | Level2)455 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_01, Function | SmallTest | Level2)
456 {
457 SHARING_LOGD("trace");
458 bool ret = true;
459 std::unique_ptr<AudioPlayController> audioPlayController =
460 std::make_unique<AudioPlayController>(g_testBase.GetId());
461 EXPECT_NE(nullptr, audioPlayController);
462
463 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
464 EXPECT_EQ(ret, true);
465
466 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
467 EXPECT_EQ(ret, true);
468
469 audioPlayController->SetVolume(AudioPlayControllerTestBaseImpl::defaultVolume);
470 }
471
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_02, Function | SmallTest | Level2)472 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_02, Function | SmallTest | Level2)
473 {
474 SHARING_LOGD("trace");
475 bool ret = true;
476 std::unique_ptr<AudioPlayController> audioPlayController =
477 std::make_unique<AudioPlayController>(g_testBase.GetId());
478 EXPECT_NE(nullptr, audioPlayController);
479
480 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
481 EXPECT_EQ(ret, true);
482
483 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
484 EXPECT_EQ(ret, true);
485
486 audioPlayController->SetVolume(0);
487 audioPlayController->SetVolume(AudioPlayControllerTestBaseImpl::defaultVolume);
488 }
489
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_03, Function | SmallTest | Level2)490 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_03, Function | SmallTest | Level2)
491 {
492 SHARING_LOGD("trace");
493 bool ret = true;
494 std::unique_ptr<AudioPlayController> audioPlayController =
495 std::make_unique<AudioPlayController>(g_testBase.GetId());
496 EXPECT_NE(nullptr, audioPlayController);
497
498 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
499 EXPECT_EQ(ret, true);
500
501 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
502 EXPECT_EQ(ret, true);
503
504 audioPlayController->SetVolume(AudioPlayControllerTestBaseImpl::testVolumeNegative);
505 audioPlayController->SetVolume(AudioPlayControllerTestBaseImpl::testVolumeOverflow);
506 }
507
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_Stability_01, Function | SmallTest | Level2)508 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_SetVolume_Stability_01, Function | SmallTest | Level2)
509 {
510 SHARING_LOGD("trace");
511 bool ret = true;
512 std::unique_ptr<AudioPlayController> audioPlayController =
513 std::make_unique<AudioPlayController>(g_testBase.GetId());
514 EXPECT_NE(nullptr, audioPlayController);
515
516 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
517 EXPECT_EQ(ret, true);
518
519 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
520 EXPECT_EQ(ret, true);
521
522 g_testBase.AudioPlayerPlaybackStart();
523 for (int i = 0; i < AudioPlayControllerTestBaseImpl::stabilityLoops; ++i) {
524 audioPlayController->SetVolume(0);
525 audioPlayController->SetVolume(AudioPlayControllerTestBaseImpl::defaultVolume);
526 }
527 g_testBase.PlaybackStop();
528 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
529 }
530
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_01, Function | SmallTest | Level2)531 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_01, Function | SmallTest | Level2)
532 {
533 SHARING_LOGD("trace");
534 bool ret = true;
535 std::unique_ptr<AudioPlayController> audioPlayController =
536 std::make_unique<AudioPlayController>(g_testBase.GetId());
537 EXPECT_NE(nullptr, audioPlayController);
538
539 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
540 EXPECT_EQ(ret, true);
541
542 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
543 EXPECT_EQ(ret, true);
544 }
545
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_02, Function | SmallTest | Level2)546 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_02, Function | SmallTest | Level2)
547 {
548 SHARING_LOGD("trace");
549 bool ret = true;
550 std::unique_ptr<AudioPlayController> audioPlayController =
551 std::make_unique<AudioPlayController>(g_testBase.GetId());
552 EXPECT_NE(nullptr, audioPlayController);
553
554 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
555 EXPECT_EQ(ret, false);
556 }
557
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_03, Function | SmallTest | Level2)558 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_03, Function | SmallTest | Level2)
559 {
560 SHARING_LOGD("trace");
561 bool ret = true;
562 std::unique_ptr<AudioPlayController> audioPlayController =
563 std::make_unique<AudioPlayController>(g_testBase.GetId());
564 EXPECT_NE(nullptr, audioPlayController);
565
566 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
567 EXPECT_EQ(ret, true);
568
569 audioPlayController->Release();
570 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
571 EXPECT_EQ(ret, false);
572 }
573
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_04, Function | SmallTest | Level2)574 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_04, Function | SmallTest | Level2)
575 {
576 SHARING_LOGD("trace");
577 bool ret = true;
578 std::unique_ptr<AudioPlayController> audioPlayController =
579 std::make_unique<AudioPlayController>(g_testBase.GetId());
580 EXPECT_NE(nullptr, audioPlayController);
581
582 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
583 EXPECT_EQ(ret, true);
584
585 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
586 EXPECT_EQ(ret, true);
587
588 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
589 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
590 EXPECT_EQ(ret, true);
591 }
592
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_05, Function | SmallTest | Level2)593 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Start_05, Function | SmallTest | Level2)
594 {
595 SHARING_LOGD("trace");
596 bool ret = true;
597 std::unique_ptr<AudioPlayController> audioPlayController =
598 std::make_unique<AudioPlayController>(g_testBase.GetId());
599 EXPECT_NE(nullptr, audioPlayController);
600
601 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
602 EXPECT_EQ(ret, true);
603
604 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
605 EXPECT_EQ(ret, true);
606
607 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
608 EXPECT_EQ(ret, true);
609
610 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
611 }
612
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_01, Function | SmallTest | Level2)613 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_01, Function | SmallTest | Level2)
614 {
615 SHARING_LOGD("trace");
616 bool ret = true;
617 std::unique_ptr<AudioPlayController> audioPlayController =
618 std::make_unique<AudioPlayController>(g_testBase.GetId());
619 EXPECT_NE(nullptr, audioPlayController);
620
621 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
622 EXPECT_EQ(ret, true);
623
624 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
625 EXPECT_EQ(ret, true);
626 g_testBase.AudioPlayerPlaybackStart();
627
628 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
629 g_testBase.PlaybackStop();
630 }
631
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_02, Function | SmallTest | Level2)632 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_02, Function | SmallTest | Level2)
633 {
634 SHARING_LOGD("trace");
635 bool ret = true;
636 std::unique_ptr<AudioPlayController> audioPlayController =
637 std::make_unique<AudioPlayController>(g_testBase.GetId());
638 EXPECT_NE(nullptr, audioPlayController);
639
640 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
641 EXPECT_EQ(ret, true);
642
643 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
644 }
645
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_03, Function | SmallTest | Level2)646 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_03, Function | SmallTest | Level2)
647 {
648 SHARING_LOGD("trace");
649 std::unique_ptr<AudioPlayController> audioPlayController =
650 std::make_unique<AudioPlayController>(g_testBase.GetId());
651 EXPECT_NE(nullptr, audioPlayController);
652
653 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
654 }
655
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_04, Function | SmallTest | Level2)656 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_04, Function | SmallTest | Level2)
657 {
658 SHARING_LOGD("trace");
659 bool ret = true;
660 std::unique_ptr<AudioPlayController> audioPlayController =
661 std::make_unique<AudioPlayController>(g_testBase.GetId());
662 EXPECT_NE(nullptr, audioPlayController);
663
664 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
665 EXPECT_EQ(ret, true);
666
667 audioPlayController->Release();
668 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
669 }
670
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_05, Function | SmallTest | Level2)671 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Stop_05, Function | SmallTest | Level2)
672 {
673 SHARING_LOGD("trace");
674 bool ret = true;
675 std::unique_ptr<AudioPlayController> audioPlayController =
676 std::make_unique<AudioPlayController>(g_testBase.GetId());
677 EXPECT_NE(nullptr, audioPlayController);
678
679 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
680 EXPECT_EQ(ret, true);
681
682 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
683 EXPECT_EQ(ret, true);
684
685
686 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
687 ret = audioPlayController->Start(g_testBase.GetBufferDispatcher());
688 EXPECT_EQ(ret, true);
689
690 audioPlayController->Stop(g_testBase.GetBufferDispatcher());
691 }
692
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Release_01, Function | SmallTest | Level2)693 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Release_01, Function | SmallTest | Level2)
694 {
695 SHARING_LOGD("trace");
696 bool ret = true;
697 std::unique_ptr<AudioPlayController> audioPlayController =
698 std::make_unique<AudioPlayController>(g_testBase.GetId());
699 EXPECT_NE(nullptr, audioPlayController);
700
701 ret = audioPlayController->Init(g_testBase.GetAudioTrack());
702 EXPECT_EQ(ret, true);
703
704 audioPlayController->Release();
705 }
706
HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Release_02, Function | SmallTest | Level2)707 HWTEST_F(AudioPlayControllerUnitTest, Audio_Play_Controller_Test_Release_02, Function | SmallTest | Level2)
708 {
709 SHARING_LOGD("trace");
710 std::unique_ptr<AudioPlayController> audioPlayController =
711 std::make_unique<AudioPlayController>(g_testBase.GetId());
712 EXPECT_NE(nullptr, audioPlayController);
713
714 audioPlayController->Release();
715 }
716
717 } // namespace
718 } // namespace Sharing
719 } // namespace OHOS