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