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 ~AudioPlayControllerTestBaseImpl()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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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