From 17ddb09ec3d8c6ed17b8f22a3e2f9296d4d06cce Mon Sep 17 00:00:00 2001 From: magekkkk Date: Thu, 11 Sep 2025 04:21:56 +0000 Subject: [PATCH] check restore in same thread first Signed-off-by: magekkkk Change-Id: I991f55768bf74e8f64db8a9db0050269f23bbdc9 --- .../include/audio_capturer_private.h | 2 + .../audiocapturer/src/audio_capturer.cpp | 15 + .../src/audio_capturer_extra_unit_test.cpp | 38 + .../include/audio_renderer_private.h | 1 + .../audiorenderer/src/audio_renderer.cpp | 15 + .../src/audio_renderer_unit_test.cpp | 37 + .../audiostream/include/fast_audio_stream.h | 2 + .../audiostream/include/i_audio_stream.h | 2 + .../client/include/audio_process_in_client.h | 2 + .../client/include/capturer_in_client_inner.h | 2 + .../include/renderer_in_client_private.h | 2 +- .../client/src/audio_process_in_client.cpp | 6 +- .../client/src/capturer_in_client.cpp | 16 + .../client/src/fast_audio_stream.cpp | 6 + .../client/src/renderer_in_client.cpp | 2 + .../common/include/oh_audio_buffer.h | 1 + .../common/src/oh_audio_buffer.cpp | 5 + .../client/capturer_in_client_unit_test.cpp | 736 ++++++++++-------- .../client/fast_audio_stream_unit_test.cpp | 1 + 19 files changed, 556 insertions(+), 335 deletions(-) diff --git a/frameworks/native/audiocapturer/include/audio_capturer_private.h b/frameworks/native/audiocapturer/include/audio_capturer_private.h index 1876696e8c..f52e1c891f 100644 --- a/frameworks/native/audiocapturer/include/audio_capturer_private.h +++ b/frameworks/native/audiocapturer/include/audio_capturer_private.h @@ -165,6 +165,8 @@ private: std::shared_ptr GenerateStreamDesc( const IAudioStream::SwitchInfo &switchInfo, const RestoreInfo &restoreInfo); int32_t HandleCreateFastStreamError(AudioStreamParams &audioStreamParams); + bool IsRestoreOrStopNeeded(); + std::shared_ptr inputDeviceChangeCallback_ = nullptr; bool isSwitching_ = false; mutable std::shared_mutex switchStreamMutex_; diff --git a/frameworks/native/audiocapturer/src/audio_capturer.cpp b/frameworks/native/audiocapturer/src/audio_capturer.cpp index 7275bc41a7..194015cf59 100644 --- a/frameworks/native/audiocapturer/src/audio_capturer.cpp +++ b/frameworks/native/audiocapturer/src/audio_capturer.cpp @@ -746,8 +746,23 @@ int32_t AudioCapturerPrivate::CheckAndRestoreAudioCapturer(std::string callingFu return SUCCESS; } +bool AudioCapturerPrivate::IsRestoreOrStopNeeded() +{ + std::unique_lock lock; + if (callbackLoopTid_ != gettid()) { // No need to add lock in callback thread to prevent deadlocks + lock = std::unique_lock(capturerMutex_); + } + CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, false, "audio stream is null"); + return audioStream_->IsRestoreNeeded() || audioStream_->GetStopFlag(); +} + int32_t AudioCapturerPrivate::AsyncCheckAudioCapturer(std::string callingFunc) { + // Check first to avoid redundant instructions consumption in thread switching + if (!IsRestoreOrStopNeeded()) { + return SUCCESS; + } + if (switchStreamInNewThreadTaskCount_.fetch_add(1) > 0) { return SUCCESS; } diff --git a/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_unit_test.cpp b/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_unit_test.cpp index a285fa913f..35d48fa7e2 100644 --- a/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_unit_test.cpp +++ b/frameworks/native/audiocapturer/test/unittest/capturer_test/src/audio_capturer_extra_unit_test.cpp @@ -1595,5 +1595,43 @@ HWTEST(AudioCapturerUnitTest, Audio_Capturer_GetOverflowCount_001, TestSize.Leve audioCapturer->Release(); } #endif + +/** + * @tc.name : AudioCapturer_IsRestoreOrStopNeeded_001 + * @tc.number: IsRestoreOrStopNeeded_001 + * @tc.desc : Test IsRestoreOrStopNeeded() for different cases + */ +HWTEST(AudioCapturerUnitTest, IsRestoreOrStopNeeded_001, TestSize.Level4) +{ + AppInfo appInfo = {}; + auto testCapturerInner = std::make_shared(STREAM_MUSIC, appInfo, true); + + int32_t curTid = gettid(); + // To test matching case + testCapturerInner->callbackLoopTid_ = curTid; + bool needRestore = testCapturerInner->IsRestoreOrStopNeeded(); + EXPECT_EQ(false, needRestore); + + // To test not matching case + testCapturerInner->callbackLoopTid_ = curTid + 1; + needRestore = testCapturerInner->IsRestoreOrStopNeeded(); + EXPECT_EQ(false, needRestore); +} + +/** + * @tc.name : AudioCapturer_AsyncCheckAudioCapturer_001 + * @tc.number: AsyncCheckAudioCapturer_001 + * @tc.desc : Test AsyncCheckAudioCapturer() for different cases + */ +HWTEST(AudioCapturerUnitTest, AsyncCheckAudioCapturer_001, TestSize.Level4) +{ + AppInfo appInfo = {}; + auto testCapturerInner = std::make_shared(STREAM_MUSIC, appInfo, true); + + // Test not need restore case + int32_t res = testCapturerInner->AsyncCheckAudioCapturer("Test"); + EXPECT_EQ(SUCCESS, res); +} + } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/native/audiorenderer/include/audio_renderer_private.h b/frameworks/native/audiorenderer/include/audio_renderer_private.h index 8f697fa87f..ac4a2cd0cc 100644 --- a/frameworks/native/audiorenderer/include/audio_renderer_private.h +++ b/frameworks/native/audiorenderer/include/audio_renderer_private.h @@ -244,6 +244,7 @@ private: bool GetFinalOffloadAllowed(bool originalAllowed); void SetReleaseFlagWithLock(bool releaseFlag); void SetReleaseFlagNoLock(bool releaseFlag); + bool IsRestoreOrStopNeeded(); std::shared_ptr audioInterruptCallback_ = nullptr; std::shared_ptr audioStreamCallback_ = nullptr; diff --git a/frameworks/native/audiorenderer/src/audio_renderer.cpp b/frameworks/native/audiorenderer/src/audio_renderer.cpp index 798fe4ff9a..447d2d88de 100644 --- a/frameworks/native/audiorenderer/src/audio_renderer.cpp +++ b/frameworks/native/audiorenderer/src/audio_renderer.cpp @@ -1024,8 +1024,23 @@ int32_t AudioRendererPrivate::CheckAndRestoreAudioRenderer(std::string callingFu return StartSwitchProcess(restoreInfo, targetClass, callingFunc); } +bool AudioRendererPrivate::IsRestoreOrStopNeeded() +{ + std::unique_lock lock; + if (callbackLoopTid_ != gettid()) { // No need to add lock in callback thread to prevent deadlocks + lock = std::unique_lock(rendererMutex_); + } + CHECK_AND_RETURN_RET_LOG(audioStream_ != nullptr, false, "audio stream is null"); + return audioStream_->IsRestoreNeeded() || audioStream_->GetStopFlag(); +} + int32_t AudioRendererPrivate::AsyncCheckAudioRenderer(std::string callingFunc) { + // Check first to avoid redundant instructions consumption in thread switching + if (!IsRestoreOrStopNeeded()) { + return SUCCESS; + } + if (switchStreamInNewThreadTaskCount_.fetch_add(1) > 0) { return SUCCESS; } diff --git a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp index beb3ac8687..40f8e70d44 100644 --- a/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp +++ b/frameworks/native/audiorenderer/test/unittest/renderer_test/src/audio_renderer_unit_test.cpp @@ -4607,5 +4607,42 @@ HWTEST(AudioRendererUnitTest, NotifyForcedEvent_001, TestSize.Level1) EXPECT_FALSE(AudioRenderer::CheckSupportedSamplingRates(RenderUT::SAMPLE_RATE_384001)); EXPECT_FALSE(AudioRenderer::CheckSupportedSamplingRates(RenderUT::SAMPLE_RATE_16001)); } + +/** + * @tc.name : AudioRenderer_IsRestoreOrStopNeeded_001 + * @tc.number: IsRestoreOrStopNeeded_001 + * @tc.desc : Test IsRestoreOrStopNeeded() for different cases + */ +HWTEST(AudioRendererUnitTest, IsRestoreOrStopNeeded_001, TestSize.Level4) +{ + AppInfo appInfo = {}; + auto testRendererInner = std::make_shared(STREAM_MUSIC, appInfo); + + int32_t curTid = gettid(); + // To test matching case + testRendererInner->callbackLoopTid_ = curTid; + bool needRestore = testRendererInner->IsRestoreOrStopNeeded(); + EXPECT_EQ(false, needRestore); + + // To test not matching case + testRendererInner->callbackLoopTid_ = curTid + 1; + needRestore = testRendererInner->IsRestoreOrStopNeeded(); + EXPECT_EQ(false, needRestore); +} + +/** + * @tc.name : AudioRenderer_AsyncCheckAudioRenderer_001 + * @tc.number: AsyncCheckAudioRenderer_001 + * @tc.desc : Test AsyncCheckAudioRenderer() for different cases + */ +HWTEST(AudioRendererUnitTest, AsyncCheckAudioRenderer_001, TestSize.Level4) +{ + AppInfo appInfo = {}; + auto testRendererInner = std::make_shared(STREAM_MUSIC, appInfo); + + // Test not need restore case + int32_t res = testRendererInner->AsyncCheckAudioRenderer("Test"); + EXPECT_EQ(SUCCESS, res); +} } // namespace AudioStandard } // namespace OHOS diff --git a/frameworks/native/audiostream/include/fast_audio_stream.h b/frameworks/native/audiostream/include/fast_audio_stream.h index 9ca51903cd..64fd1f9756 100644 --- a/frameworks/native/audiostream/include/fast_audio_stream.h +++ b/frameworks/native/audiostream/include/fast_audio_stream.h @@ -216,6 +216,8 @@ public: bool GetStopFlag() const override; void ResetFirstFrameState() override; void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override; + bool IsRestoreNeeded() override; + private: void UpdateRegisterTrackerInfo(AudioRegisterTrackerInfo ®isterTrackerInfo); int32_t InitializeAudioProcessConfig(AudioProcessConfig &config, const AudioStreamParams &info); diff --git a/frameworks/native/audiostream/include/i_audio_stream.h b/frameworks/native/audiostream/include/i_audio_stream.h index 5c0f6ef1f6..bc25b13cbd 100644 --- a/frameworks/native/audiostream/include/i_audio_stream.h +++ b/frameworks/native/audiostream/include/i_audio_stream.h @@ -335,6 +335,8 @@ public: virtual void NotifyRouteUpdate(uint32_t routeFlag, const std::string &networkId) {} virtual void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) {} + + virtual bool IsRestoreNeeded() { return false; } }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/include/audio_process_in_client.h b/services/audio_service/client/include/audio_process_in_client.h index 251a916744..abcbe0b431 100644 --- a/services/audio_service/client/include/audio_process_in_client.h +++ b/services/audio_service/client/include/audio_process_in_client.h @@ -141,6 +141,8 @@ public: virtual void JoinCallbackLoop() = 0; virtual void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) = 0; + + virtual bool IsRestoreNeeded() = 0; }; } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/include/capturer_in_client_inner.h b/services/audio_service/client/include/capturer_in_client_inner.h index 49320d4c67..a9804340c3 100644 --- a/services/audio_service/client/include/capturer_in_client_inner.h +++ b/services/audio_service/client/include/capturer_in_client_inner.h @@ -216,6 +216,8 @@ public: void SetCallbackLoopTid(int32_t tid) override; int32_t GetCallbackLoopTid() override; bool GetStopFlag() const override; + bool IsRestoreNeeded() override; + private: void RegisterTracker(const std::shared_ptr &proxyObj); void UpdateTracker(const std::string &updateCase); diff --git a/services/audio_service/client/include/renderer_in_client_private.h b/services/audio_service/client/include/renderer_in_client_private.h index 6f85c0f46b..8e4f67dbd7 100644 --- a/services/audio_service/client/include/renderer_in_client_private.h +++ b/services/audio_service/client/include/renderer_in_client_private.h @@ -221,6 +221,7 @@ public: void NotifyRouteUpdate(uint32_t routeFlag, const std::string &networkId) override; bool GetStopFlag() const override; void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override; + bool IsRestoreNeeded() override; private: void RegisterTracker(const std::shared_ptr &proxyObj); @@ -295,7 +296,6 @@ private: bool CheckBufferValid(const BufferDesc &bufDesc); - bool IsRestoreNeeded(); void RecordDropPosition(size_t dataLength); private: AudioStreamType eStreamType_ = AudioStreamType::STREAM_DEFAULT; diff --git a/services/audio_service/client/src/audio_process_in_client.cpp b/services/audio_service/client/src/audio_process_in_client.cpp index b2729a36c7..57ac562c80 100644 --- a/services/audio_service/client/src/audio_process_in_client.cpp +++ b/services/audio_service/client/src/audio_process_in_client.cpp @@ -153,6 +153,8 @@ public: void SetAudioHapticsSyncId(const int32_t &audioHapticsSyncId) override; + bool IsRestoreNeeded() override; + static const sptr GetAudioServerProxy(); static void AudioServerDied(pid_t pid, pid_t uid); @@ -201,8 +203,6 @@ private: void ExitStandByIfNeed(); - bool IsRestoreNeeded(); - void WaitForReadableSpace() const; private: static constexpr int64_t MILLISECOND_PER_SECOND = 1000; // 1000ms @@ -1656,6 +1656,8 @@ void AudioProcessInClientInner::DoFadeInOut(const BufferDesc &buffDesc) bool AudioProcessInClientInner::IsRestoreNeeded() { + CHECK_AND_RETURN_RET_LOG(audioBuffer_ != nullptr, false, "buffer null"); + RestoreStatus restoreStatus = audioBuffer_->GetRestoreStatus(); if (restoreStatus == NEED_RESTORE) { return true; diff --git a/services/audio_service/client/src/capturer_in_client.cpp b/services/audio_service/client/src/capturer_in_client.cpp index d770549fb2..4fd70a5ee6 100644 --- a/services/audio_service/client/src/capturer_in_client.cpp +++ b/services/audio_service/client/src/capturer_in_client.cpp @@ -1868,6 +1868,22 @@ bool CapturerInClientInner::GetStopFlag() const CHECK_AND_RETURN_RET_LOG(clientBuffer_ != nullptr, false, "Client OHAudioBuffer is nullptr"); return clientBuffer_->GetStopFlag(); } + +bool CapturerInClientInner::IsRestoreNeeded() +{ + CHECK_AND_RETURN_RET_LOG(clientBuffer_ != nullptr, false, "buffer null"); + + RestoreStatus restoreStatus = clientBuffer_->GetRestoreStatus(); + if (restoreStatus == NEED_RESTORE) { + return true; + } + + if (restoreStatus == NEED_RESTORE_TO_NORMAL) { + return true; + } + + return false; +} } // namespace AudioStandard } // namespace OHOS #endif // FAST_AUDIO_STREAM_H diff --git a/services/audio_service/client/src/fast_audio_stream.cpp b/services/audio_service/client/src/fast_audio_stream.cpp index 7e30e0d7b3..0ae7d9614a 100644 --- a/services/audio_service/client/src/fast_audio_stream.cpp +++ b/services/audio_service/client/src/fast_audio_stream.cpp @@ -1243,5 +1243,11 @@ bool FastAudioStream::GetStopFlag() const CHECK_AND_RETURN_RET_LOG(processClient_ != nullptr, false, "processClient_ is null"); return processClient_->GetStopFlag(); } + +bool FastAudioStream::IsRestoreNeeded() +{ + CHECK_AND_RETURN_RET_LOG(processClient_ != nullptr, false, "processClient_ is null"); + return processClient_->IsRestoreNeeded(); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/client/src/renderer_in_client.cpp b/services/audio_service/client/src/renderer_in_client.cpp index 8537a98b8c..34c060e24c 100644 --- a/services/audio_service/client/src/renderer_in_client.cpp +++ b/services/audio_service/client/src/renderer_in_client.cpp @@ -419,6 +419,8 @@ bool RendererInClientInner::CheckBufferNeedWrite() bool RendererInClientInner::IsRestoreNeeded() { + CHECK_AND_RETURN_RET_LOG(clientBuffer_ != nullptr, false, "buffer null"); + RestoreStatus restoreStatus = clientBuffer_->GetRestoreStatus(); if (restoreStatus == NEED_RESTORE) { return true; diff --git a/services/audio_service/common/include/oh_audio_buffer.h b/services/audio_service/common/include/oh_audio_buffer.h index 3bcc72d9f5..3891932b67 100644 --- a/services/audio_service/common/include/oh_audio_buffer.h +++ b/services/audio_service/common/include/oh_audio_buffer.h @@ -356,6 +356,7 @@ public: size_t GetDataSize(); RestoreStatus CheckRestoreStatus(); RestoreStatus SetRestoreStatus(RestoreStatus restoreStatus); + RestoreStatus GetRestoreStatus(); void GetRestoreInfo(RestoreInfo &restoreInfo); void SetRestoreInfo(RestoreInfo restoreInfo); diff --git a/services/audio_service/common/src/oh_audio_buffer.cpp b/services/audio_service/common/src/oh_audio_buffer.cpp index c182c10994..c64a367061 100644 --- a/services/audio_service/common/src/oh_audio_buffer.cpp +++ b/services/audio_service/common/src/oh_audio_buffer.cpp @@ -525,6 +525,11 @@ RestoreStatus OHAudioBuffer::SetRestoreStatus(RestoreStatus restoreStatus) return ohAudioBufferBase_.SetRestoreStatus(restoreStatus); } +RestoreStatus OHAudioBuffer::GetRestoreStatus() +{ + return ohAudioBufferBase_.GetRestoreStatus(); +} + void OHAudioBuffer::SetStopFlag(bool isNeedStop) { ohAudioBufferBase_.SetStopFlag(isNeedStop); diff --git a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp index b68a61ad20..047e5edf22 100644 --- a/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp +++ b/services/audio_service/test/unittest/client/capturer_in_client_unit_test.cpp @@ -262,23 +262,23 @@ void Init(std::shared_ptr capturerInClientInner) */ HWTEST(CapturerInClientUnitTest, OnOperationHandled_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); Operation operation = Operation::UPDATE_STREAM; int64_t result = 1; - int32_t ret = capturerInClientInner_->OnOperationHandled(operation, result); + int32_t ret = capturerInClientInner->OnOperationHandled(operation, result); EXPECT_EQ(ret, SUCCESS); operation = Operation::BUFFER_OVERFLOW; - ret = capturerInClientInner_->OnOperationHandled(operation, result); + ret = capturerInClientInner->OnOperationHandled(operation, result); EXPECT_EQ(ret, SUCCESS); operation = Operation::RESTORE_SESSION; - ret = capturerInClientInner_->OnOperationHandled(operation, result); + ret = capturerInClientInner->OnOperationHandled(operation, result); EXPECT_EQ(ret, SUCCESS); operation = Operation::START_STREAM; - ret = capturerInClientInner_->OnOperationHandled(operation, result); + ret = capturerInClientInner->OnOperationHandled(operation, result); EXPECT_EQ(ret, SUCCESS); } @@ -290,12 +290,12 @@ HWTEST(CapturerInClientUnitTest, OnOperationHandled_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, RegisterTracker_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->streamTrackerRegistered_ = false; + capturerInClientInner->streamTrackerRegistered_ = false; std::shared_ptr proxyObj; - capturerInClientInner_->RegisterTracker(proxyObj); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->RegisterTracker(proxyObj); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -306,13 +306,13 @@ HWTEST(CapturerInClientUnitTest, RegisterTracker_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, RegisterTracker_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = nullptr; - capturerInClientInner_->streamTrackerRegistered_ = true; + capturerInClientInner->audioStreamTracker_ = nullptr; + capturerInClientInner->streamTrackerRegistered_ = true; std::shared_ptr proxyObj; - capturerInClientInner_->RegisterTracker(proxyObj); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->RegisterTracker(proxyObj); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -323,13 +323,13 @@ HWTEST(CapturerInClientUnitTest, RegisterTracker_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, RegisterTracker_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = nullptr; - capturerInClientInner_->streamTrackerRegistered_ = false; + capturerInClientInner->audioStreamTracker_ = nullptr; + capturerInClientInner->streamTrackerRegistered_ = false; std::shared_ptr proxyObj; - capturerInClientInner_->RegisterTracker(proxyObj); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->RegisterTracker(proxyObj); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -341,14 +341,14 @@ HWTEST(CapturerInClientUnitTest, RegisterTracker_003, TestSize.Level1) HWTEST(CapturerInClientUnitTest, RegisterTracker_004, TestSize.Level1) { int32_t clientUid = 0; - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = std::make_unique(AudioMode::AUDIO_MODE_PLAYBACK, + capturerInClientInner->audioStreamTracker_ = std::make_unique(AudioMode::AUDIO_MODE_PLAYBACK, clientUid); - capturerInClientInner_->streamTrackerRegistered_ = true; + capturerInClientInner->streamTrackerRegistered_ = true; std::shared_ptr proxyObj; - capturerInClientInner_->RegisterTracker(proxyObj); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->RegisterTracker(proxyObj); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -360,14 +360,14 @@ HWTEST(CapturerInClientUnitTest, RegisterTracker_004, TestSize.Level1) HWTEST(CapturerInClientUnitTest, RegisterTracker_005, TestSize.Level1) { int32_t clientUid = 0; - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = std::make_unique(AudioMode::AUDIO_MODE_PLAYBACK, + capturerInClientInner->audioStreamTracker_ = std::make_unique(AudioMode::AUDIO_MODE_PLAYBACK, clientUid); - capturerInClientInner_->streamTrackerRegistered_ = false; + capturerInClientInner->streamTrackerRegistered_ = false; std::shared_ptr proxyObj; - capturerInClientInner_->RegisterTracker(proxyObj); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->RegisterTracker(proxyObj); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -378,12 +378,12 @@ HWTEST(CapturerInClientUnitTest, RegisterTracker_005, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, UpdateTracker_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = nullptr; + capturerInClientInner->audioStreamTracker_ = nullptr; std::string updateCase = " "; - capturerInClientInner_->UpdateTracker(updateCase); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->UpdateTracker(updateCase); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -394,9 +394,9 @@ HWTEST(CapturerInClientUnitTest, UpdateTracker_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); std::shared_ptr proxyObj; AudioStreamParams info; info.format = AudioSampleFormat::SAMPLE_U8; @@ -404,8 +404,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_001, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_NE(ret, SUCCESS); } @@ -417,7 +417,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -426,8 +426,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_002, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_NE(ret, SUCCESS); } @@ -439,7 +439,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -448,8 +448,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_003, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -461,7 +461,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_004, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -470,8 +470,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_004, TestSize.Level1) info.samplingRate = static_cast(600); info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -483,7 +483,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_004, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_005, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -492,8 +492,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_005, TestSize.Level1) info.samplingRate = static_cast(600); info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -505,7 +505,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_005, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_006, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -514,8 +514,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_006, TestSize.Level1) info.samplingRate = static_cast(600); info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -527,7 +527,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_006, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_007, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -536,8 +536,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_007, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -549,7 +549,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_007, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_008, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -558,8 +558,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_008, TestSize.Level1) info.samplingRate = static_cast(600); info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -571,7 +571,7 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_008, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_009, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); std::shared_ptr proxyObj; AudioStreamParams info; @@ -580,8 +580,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_009, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::CHANNEL_7; info.channelLayout = static_cast(99999); - capturerInClientInner_->state_ = NEW; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = NEW; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_EQ(ret, ERR_NOT_SUPPORTED); } @@ -593,9 +593,9 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_009, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_010, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); std::shared_ptr proxyObj; AudioStreamParams info; info.format = AudioSampleFormat::SAMPLE_U8; @@ -603,8 +603,8 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_010, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->state_ = INVALID; - int32_t ret = capturerInClientInner_->SetAudioStreamInfo(info, proxyObj); + capturerInClientInner->state_ = INVALID; + int32_t ret = capturerInClientInner->SetAudioStreamInfo(info, proxyObj); EXPECT_NE(ret, SUCCESS); } @@ -616,12 +616,12 @@ HWTEST(CapturerInClientUnitTest, SetAudioStreamInfo_010, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, GetAudioServerProxy_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->GetAudioServerProxy(); - capturerInClientInner_->GetAudioServerProxy(); - EXPECT_NE(capturerInClientInner_, nullptr); + Init(capturerInClientInner); + capturerInClientInner->GetAudioServerProxy(); + capturerInClientInner->GetAudioServerProxy(); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -632,17 +632,17 @@ HWTEST(CapturerInClientUnitTest, GetAudioServerProxy_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, OnHandle_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); uint32_t code = RENDERER_PERIOD_REACHED_EVENT; int64_t data = 0; - capturerInClientInner_->OnHandle(code, data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->OnHandle(code, data); + EXPECT_NE(capturerInClientInner, nullptr); code = CAPTURER_PERIOD_REACHED_EVENT; - capturerInClientInner_->OnHandle(code, data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->OnHandle(code, data); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -653,13 +653,13 @@ HWTEST(CapturerInClientUnitTest, OnHandle_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, HandleCapturerMarkReachedEvent_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->capturerPositionCallback_ = nullptr; + Init(capturerInClientInner); + capturerInClientInner->capturerPositionCallback_ = nullptr; int64_t data = 16; - capturerInClientInner_->HandleCapturerMarkReachedEvent(data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->HandleCapturerMarkReachedEvent(data); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -670,14 +670,14 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerMarkReachedEvent_001, TestSize.Le */ HWTEST(CapturerInClientUnitTest, HandleCapturerMarkReachedEvent_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->capturerPositionCallback_ = std::make_shared(); - ASSERT_TRUE(capturerInClientInner_->capturerPositionCallback_ != nullptr); + Init(capturerInClientInner); + capturerInClientInner->capturerPositionCallback_ = std::make_shared(); + ASSERT_TRUE(capturerInClientInner->capturerPositionCallback_ != nullptr); int64_t data = 16; - capturerInClientInner_->HandleCapturerMarkReachedEvent(data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->HandleCapturerMarkReachedEvent(data); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -688,13 +688,13 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerMarkReachedEvent_002, TestSize.Le */ HWTEST(CapturerInClientUnitTest, HandleCapturerPeriodReachedEvent_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->capturerPeriodPositionCallback_ = nullptr; + Init(capturerInClientInner); + capturerInClientInner->capturerPeriodPositionCallback_ = nullptr; int64_t data = 16; - capturerInClientInner_->HandleCapturerPeriodReachedEvent(data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->HandleCapturerPeriodReachedEvent(data); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -705,14 +705,14 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerPeriodReachedEvent_001, TestSize. */ HWTEST(CapturerInClientUnitTest, HandleCapturerPeriodReachedEvent_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); auto callback = std::make_shared(); int64_t data = 16; - capturerInClientInner_->SetCapturerPeriodPositionCallback(data, callback); - capturerInClientInner_->HandleCapturerPeriodReachedEvent(data); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->SetCapturerPeriodPositionCallback(data, callback); + capturerInClientInner->HandleCapturerPeriodReachedEvent(data); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -723,13 +723,13 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerPeriodReachedEvent_002, TestSize. */ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params = HANDLER_PARAM_NEW; State state; StateChangeCmdType cmdType; - int32_t ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + int32_t ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(state, NEW); EXPECT_EQ(ret, SUCCESS); } @@ -742,13 +742,13 @@ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params = HANDLER_PARAM_RELEASED; State state; StateChangeCmdType cmdType; - int32_t ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + int32_t ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(state, RELEASED); EXPECT_EQ(ret, SUCCESS); } @@ -761,28 +761,28 @@ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params = HANDLER_PARAM_STOPPING; State state; StateChangeCmdType cmdType; - int32_t ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + int32_t ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(state, STOPPING); EXPECT_EQ(ret, SUCCESS); params = HANDLER_PARAM_RUNNING_FROM_SYSTEM; - ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(cmdType, CMD_FROM_SYSTEM); EXPECT_EQ(ret, SUCCESS); params = HANDLER_PARAM_PAUSED_FROM_SYSTEM; - ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(cmdType, CMD_FROM_SYSTEM); EXPECT_EQ(ret, SUCCESS); params = HANDLER_PARAM_INVALID; - ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(ret, SUCCESS); } @@ -794,13 +794,13 @@ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_004, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params = HANDLER_PARAM_PAUSED; State state; StateChangeCmdType cmdType; - int32_t ret = capturerInClientInner_->ParamsToStateCmdType(params, state, cmdType); + int32_t ret = capturerInClientInner->ParamsToStateCmdType(params, state, cmdType); EXPECT_EQ(state, PAUSED); EXPECT_EQ(ret, SUCCESS); } @@ -813,13 +813,13 @@ HWTEST(CapturerInClientUnitTest, ParamsToStateCmdType_004, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params; State state = State::RUNNING; StateChangeCmdType cmdType = CMD_FROM_SYSTEM; - int32_t ret = capturerInClientInner_->StateCmdTypeToParams(params, state, cmdType); + int32_t ret = capturerInClientInner->StateCmdTypeToParams(params, state, cmdType); EXPECT_EQ(ret, SUCCESS); EXPECT_EQ(params, HANDLER_PARAM_RUNNING_FROM_SYSTEM); } @@ -832,13 +832,13 @@ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params; State state = State::PAUSED; StateChangeCmdType cmdType = CMD_FROM_SYSTEM; - int32_t ret = capturerInClientInner_->StateCmdTypeToParams(params, state, cmdType); + int32_t ret = capturerInClientInner->StateCmdTypeToParams(params, state, cmdType); EXPECT_EQ(ret, SUCCESS); EXPECT_EQ(params, HANDLER_PARAM_PAUSED_FROM_SYSTEM); } @@ -851,13 +851,13 @@ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); int64_t params; State state = State::NEW; StateChangeCmdType cmdType = CMD_FROM_SYSTEM; - int32_t ret = capturerInClientInner_->StateCmdTypeToParams(params, state, cmdType); + int32_t ret = capturerInClientInner->StateCmdTypeToParams(params, state, cmdType); EXPECT_EQ(ret, SUCCESS); EXPECT_EQ(params, HANDLER_PARAM_INVALID); } @@ -870,12 +870,12 @@ HWTEST(CapturerInClientUnitTest, StateCmdTypeToParams_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ConstructConfig_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->capturerInfo_.capturerFlags = 1; - AudioProcessConfig ret = capturerInClientInner_->ConstructConfig(); - EXPECT_NE(capturerInClientInner_, nullptr); + Init(capturerInClientInner); + capturerInClientInner->capturerInfo_.capturerFlags = 1; + AudioProcessConfig ret = capturerInClientInner->ConstructConfig(); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -886,11 +886,11 @@ HWTEST(CapturerInClientUnitTest, ConstructConfig_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, InitCacheBuffer_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); size_t size = 32 * 1024 * 1024; - int32_t ret = capturerInClientInner_->InitCacheBuffer(size); + int32_t ret = capturerInClientInner->InitCacheBuffer(size); EXPECT_EQ(ret, ERR_OPERATION_FAILED); } @@ -903,14 +903,14 @@ HWTEST(CapturerInClientUnitTest, InitCacheBuffer_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, GetBufferSize_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); - capturerInClientInner_->state_ = State::NEW; - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; + Init(capturerInClientInner); + capturerInClientInner->state_ = State::NEW; + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; size_t bufferSize = 0; - int32_t ret = capturerInClientInner_->GetBufferSize(bufferSize); - EXPECT_EQ(bufferSize, capturerInClientInner_->cbBufferSize_); + int32_t ret = capturerInClientInner->GetBufferSize(bufferSize); + EXPECT_EQ(bufferSize, capturerInClientInner->cbBufferSize_); EXPECT_EQ(ret, SUCCESS); } @@ -922,11 +922,11 @@ HWTEST(CapturerInClientUnitTest, GetBufferSize_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetStreamCallback_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); auto callback = std::make_shared(); callback = nullptr; - int32_t ret = capturerInClientInner_->SetStreamCallback(callback); + int32_t ret = capturerInClientInner->SetStreamCallback(callback); EXPECT_EQ(ret, ERR_INVALID_PARAM); } @@ -938,11 +938,11 @@ HWTEST(CapturerInClientUnitTest, SetStreamCallback_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetStreamCallback_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); auto callback = std::make_shared(); - capturerInClientInner_->state_ = State::RUNNING; - int32_t ret = capturerInClientInner_->SetStreamCallback(callback); + capturerInClientInner->state_ = State::RUNNING; + int32_t ret = capturerInClientInner->SetStreamCallback(callback); EXPECT_EQ(ret, SUCCESS); } @@ -954,11 +954,11 @@ HWTEST(CapturerInClientUnitTest, SetStreamCallback_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, InitCallbackBuffer_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); u_int64_t bufferDurationInUs = 3000000; - capturerInClientInner_->InitCallbackBuffer(bufferDurationInUs); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->InitCallbackBuffer(bufferDurationInUs); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -969,11 +969,11 @@ HWTEST(CapturerInClientUnitTest, InitCallbackBuffer_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetCaptureMode_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_NORMAL; - int32_t ret = capturerInClientInner_->SetCaptureMode(captureMode); + int32_t ret = capturerInClientInner->SetCaptureMode(captureMode); usleep(SHORT_SLEEP_TIME); EXPECT_EQ(ret, SUCCESS); } @@ -986,17 +986,18 @@ HWTEST(CapturerInClientUnitTest, SetCaptureMode_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetCaptureMode_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::INVALID; - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; + Init(capturerInClientInner); + capturerInClientInner->state_ = State::INVALID; + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_CALLBACK; - int32_t ret = capturerInClientInner_->SetCaptureMode(captureMode); + int32_t ret = capturerInClientInner->SetCaptureMode(captureMode); EXPECT_EQ(ret, ERR_ILLEGAL_STATE); - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_CALLBACK; + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_CALLBACK; captureMode = AudioCaptureMode::CAPTURE_MODE_NORMAL; - ret = capturerInClientInner_->SetCaptureMode(captureMode); + ret = capturerInClientInner->SetCaptureMode(captureMode); usleep(SHORT_SLEEP_TIME); EXPECT_EQ(ret, ERR_INCORRECT_MODE); } @@ -1009,18 +1010,19 @@ HWTEST(CapturerInClientUnitTest, SetCaptureMode_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetCaptureMode_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_CALLBACK; - capturerInClientInner_->state_ = State::NEW; - capturerInClientInner_->streamParams_.samplingRate = SAMPLE_RATE_11025; - capturerInClientInner_->spanSizeInFrame_ = 1; - int32_t ret = capturerInClientInner_->SetCaptureMode(captureMode); + capturerInClientInner->state_ = State::NEW; + capturerInClientInner->streamParams_.samplingRate = SAMPLE_RATE_11025; + capturerInClientInner->spanSizeInFrame_ = 1; + int32_t ret = capturerInClientInner->SetCaptureMode(captureMode); EXPECT_EQ(ret, SUCCESS); - capturerInClientInner_->state_ = State::PREPARED; - ret = capturerInClientInner_->SetCaptureMode(captureMode); + capturerInClientInner->state_ = State::PREPARED; + ret = capturerInClientInner->SetCaptureMode(captureMode); usleep(SHORT_SLEEP_TIME); EXPECT_EQ(ret, SUCCESS); } @@ -1033,14 +1035,15 @@ HWTEST(CapturerInClientUnitTest, SetCaptureMode_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetCaptureMode_004, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_CALLBACK; - capturerInClientInner_->state_ = State::PREPARED; - capturerInClientInner_->streamParams_.samplingRate = SAMPLE_RATE_11025; - capturerInClientInner_->spanSizeInFrame_ = 1; - int32_t ret = capturerInClientInner_->SetCaptureMode(captureMode); + capturerInClientInner->state_ = State::PREPARED; + capturerInClientInner->streamParams_.samplingRate = SAMPLE_RATE_11025; + capturerInClientInner->spanSizeInFrame_ = 1; + int32_t ret = capturerInClientInner->SetCaptureMode(captureMode); usleep(SHORT_SLEEP_TIME); EXPECT_EQ(ret, SUCCESS); } @@ -1053,15 +1056,16 @@ HWTEST(CapturerInClientUnitTest, SetCaptureMode_004, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, SetCaptureMode_005, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = AudioCaptureMode::CAPTURE_MODE_NORMAL; AudioCaptureMode captureMode = AudioCaptureMode::CAPTURE_MODE_CALLBACK; - capturerInClientInner_->state_ = State::NEW; - capturerInClientInner_->streamParams_.samplingRate = SAMPLE_RATE_11025; - capturerInClientInner_->cbThreadReleased_ = true; - capturerInClientInner_->spanSizeInFrame_ = 1; - int32_t ret = capturerInClientInner_->SetCaptureMode(captureMode); + capturerInClientInner->state_ = State::NEW; + capturerInClientInner->streamParams_.samplingRate = SAMPLE_RATE_11025; + capturerInClientInner->cbThreadReleased_ = true; + capturerInClientInner->spanSizeInFrame_ = 1; + int32_t ret = capturerInClientInner->SetCaptureMode(captureMode); usleep(SHORT_SLEEP_TIME); EXPECT_EQ(ret, SUCCESS); } @@ -1074,14 +1078,15 @@ HWTEST(CapturerInClientUnitTest, SetCaptureMode_005, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); BufferDesc temp; temp.buffer = nullptr; - capturerInClientInner_->cbBufferQueue_.Push(temp); - capturerInClientInner_->state_ = State::RUNNING; - auto ret = capturerInClientInner_->ReadCallbackFunc(); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->cbBufferQueue_.Push(temp); + capturerInClientInner->state_ = State::RUNNING; + auto ret = capturerInClientInner->ReadCallbackFunc(); + EXPECT_NE(capturerInClientInner, nullptr); EXPECT_EQ(ret, false); } @@ -1093,15 +1098,16 @@ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); BufferDesc temp; temp.buffer = nullptr; - capturerInClientInner_->cbBufferQueue_.Push(temp); - capturerInClientInner_->state_ = State::RUNNING; - capturerInClientInner_->cbThreadReleased_ = false; - auto ret = capturerInClientInner_->ReadCallbackFunc(); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->cbBufferQueue_.Push(temp); + capturerInClientInner->state_ = State::RUNNING; + capturerInClientInner->cbThreadReleased_ = false; + auto ret = capturerInClientInner->ReadCallbackFunc(); + EXPECT_NE(capturerInClientInner, nullptr); EXPECT_EQ(ret, false); } @@ -1113,12 +1119,13 @@ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::STOPPED; - capturerInClientInner_->cbThreadReleased_ = false; - auto ret = capturerInClientInner_->ReadCallbackFunc(); - EXPECT_NE(capturerInClientInner_, nullptr); + Init(capturerInClientInner); + capturerInClientInner->state_ = State::STOPPED; + capturerInClientInner->cbThreadReleased_ = false; + auto ret = capturerInClientInner->ReadCallbackFunc(); + EXPECT_NE(capturerInClientInner, nullptr); EXPECT_EQ(ret, true); } @@ -1130,16 +1137,17 @@ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_004, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); BufferDesc temp; uint8_t bufferTest = 10; temp.buffer = &bufferTest; - capturerInClientInner_->cbBufferQueue_.Push(temp); - capturerInClientInner_->state_ = State::RUNNING; - capturerInClientInner_->cbThreadReleased_ = false; - auto ret = capturerInClientInner_->ReadCallbackFunc(); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->cbBufferQueue_.Push(temp); + capturerInClientInner->state_ = State::RUNNING; + capturerInClientInner->cbThreadReleased_ = false; + auto ret = capturerInClientInner->ReadCallbackFunc(); + EXPECT_NE(capturerInClientInner, nullptr); EXPECT_EQ(ret, true); } @@ -1151,15 +1159,16 @@ HWTEST(CapturerInClientUnitTest, ReadCallbackFunc_004, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, GetBufferDesc_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; BufferDesc bufferDesc; - int32_t ret = capturerInClientInner_->GetBufferDesc(bufferDesc); + int32_t ret = capturerInClientInner->GetBufferDesc(bufferDesc); EXPECT_EQ(ret, SUCCESS); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; - ret = capturerInClientInner_->GetBufferDesc(bufferDesc); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_NORMAL; + ret = capturerInClientInner->GetBufferDesc(bufferDesc); EXPECT_EQ(ret, ERR_INCORRECT_MODE); } @@ -1171,15 +1180,16 @@ HWTEST(CapturerInClientUnitTest, GetBufferDesc_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, GetBufQueueState_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; BufferQueueState bufState; - int32_t ret = capturerInClientInner_->GetBufQueueState(bufState); + int32_t ret = capturerInClientInner->GetBufQueueState(bufState); EXPECT_EQ(ret, SUCCESS); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; - ret = capturerInClientInner_->GetBufQueueState(bufState); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_NORMAL; + ret = capturerInClientInner->GetBufQueueState(bufState); EXPECT_EQ(ret, ERR_INCORRECT_MODE); } @@ -1191,11 +1201,12 @@ HWTEST(CapturerInClientUnitTest, GetBufQueueState_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Enqueue_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; BufferDesc bufferDesc; - int32_t ret = capturerInClientInner_->Enqueue(bufferDesc); + int32_t ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, SUCCESS); } @@ -1207,26 +1218,27 @@ HWTEST(CapturerInClientUnitTest, Enqueue_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Enqueue_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; - capturerInClientInner_->cbBufferSize_ = 16; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + capturerInClientInner->cbBufferSize_ = 16; BufferDesc bufferDesc; bufferDesc.bufLength = 16; bufferDesc.dataLength = 16; - int32_t ret = capturerInClientInner_->Enqueue(bufferDesc); + int32_t ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, SUCCESS); bufferDesc.bufLength = VALUE_FIF; - ret = capturerInClientInner_->Enqueue(bufferDesc); + ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, ERR_INVALID_INDEX); bufferDesc.dataLength = VALUE_FIF; - ret = capturerInClientInner_->Enqueue(bufferDesc); + ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, ERR_INVALID_INDEX); bufferDesc.bufLength = 16; - ret = capturerInClientInner_->Enqueue(bufferDesc); + ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, ERR_INVALID_INDEX); } @@ -1238,21 +1250,22 @@ HWTEST(CapturerInClientUnitTest, Enqueue_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Enqueue_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; - capturerInClientInner_->cbBufferSize_ = 16; + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + capturerInClientInner->cbBufferSize_ = 16; BufferDesc bufferDesc; bufferDesc.bufLength = 16; bufferDesc.dataLength = 16; uint8_t buffer_ = 1; bufferDesc.buffer = &buffer_; - int32_t ret = capturerInClientInner_->Enqueue(bufferDesc); + int32_t ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, SUCCESS); - capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); - bufferDesc.buffer = capturerInClientInner_->cbBuffer_.get(); - ret = capturerInClientInner_->Enqueue(bufferDesc); + capturerInClientInner->cbBuffer_.reset(new uint8_t[VALUE_TEN]); + bufferDesc.buffer = capturerInClientInner->cbBuffer_.get(); + ret = capturerInClientInner->Enqueue(bufferDesc); EXPECT_EQ(ret, SUCCESS); } @@ -1264,11 +1277,12 @@ HWTEST(CapturerInClientUnitTest, Enqueue_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Clear_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; - capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); - int32_t ret = capturerInClientInner_->Clear(); + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + capturerInClientInner->cbBuffer_.reset(new uint8_t[VALUE_TEN]); + int32_t ret = capturerInClientInner->Clear(); EXPECT_NE(ret, ERR_INCORRECT_MODE); } @@ -1280,12 +1294,13 @@ HWTEST(CapturerInClientUnitTest, Clear_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StartAudioStream_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::RUNNING; + Init(capturerInClientInner); + capturerInClientInner->state_ = State::RUNNING; StateChangeCmdType cmdType = CMD_FROM_CLIENT; AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN; - bool ret = capturerInClientInner_->StartAudioStream(cmdType, reason); + bool ret = capturerInClientInner->StartAudioStream(cmdType, reason); EXPECT_EQ(ret, false); } @@ -1297,15 +1312,16 @@ HWTEST(CapturerInClientUnitTest, StartAudioStream_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StartAudioStream_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = nullptr; - capturerInClientInner_->state_ = State::PREPARED; - capturerInClientInner_->notifiedOperation_ = Operation::PAUSE_STREAM; - capturerInClientInner_->notifiedResult_ = ERR_ILLEGAL_STATE; + Init(capturerInClientInner); + capturerInClientInner->audioStreamTracker_ = nullptr; + capturerInClientInner->state_ = State::PREPARED; + capturerInClientInner->notifiedOperation_ = Operation::PAUSE_STREAM; + capturerInClientInner->notifiedResult_ = ERR_ILLEGAL_STATE; StateChangeCmdType cmdType = CMD_FROM_CLIENT; AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN; - bool ret = capturerInClientInner_->StartAudioStream(cmdType, reason); + bool ret = capturerInClientInner->StartAudioStream(cmdType, reason); EXPECT_EQ(ret, false); } @@ -1317,15 +1333,16 @@ HWTEST(CapturerInClientUnitTest, StartAudioStream_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StartAudioStream_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->audioStreamTracker_ = nullptr; - capturerInClientInner_->state_ = State::PREPARED; - capturerInClientInner_->notifiedOperation_ = Operation::PAUSE_STREAM; - capturerInClientInner_->notifiedResult_ = SUCCESS; + Init(capturerInClientInner); + capturerInClientInner->audioStreamTracker_ = nullptr; + capturerInClientInner->state_ = State::PREPARED; + capturerInClientInner->notifiedOperation_ = Operation::PAUSE_STREAM; + capturerInClientInner->notifiedResult_ = SUCCESS; StateChangeCmdType cmdType = CMD_FROM_CLIENT; AudioStreamDeviceChangeReasonExt reason = AudioStreamDeviceChangeReasonExt::ExtEnum::UNKNOWN; - bool ret = capturerInClientInner_->StartAudioStream(cmdType, reason); + bool ret = capturerInClientInner->StartAudioStream(cmdType, reason); EXPECT_EQ(ret, false); } @@ -1337,10 +1354,11 @@ HWTEST(CapturerInClientUnitTest, StartAudioStream_003, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, StopAudioStream_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::STOPPED; - bool ret = capturerInClientInner_->StopAudioStream(); + Init(capturerInClientInner); + capturerInClientInner->state_ = State::STOPPED; + bool ret = capturerInClientInner->StopAudioStream(); EXPECT_EQ(ret, true); } @@ -1352,13 +1370,13 @@ HWTEST(CapturerInClientUnitTest, StopAudioStream_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, UpdateLatencyTimestamp_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); std::string timestamp = ""; bool isRenderer = false; - capturerInClientInner_->UpdateLatencyTimestamp(timestamp, isRenderer); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->UpdateLatencyTimestamp(timestamp, isRenderer); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -1369,12 +1387,13 @@ HWTEST(CapturerInClientUnitTest, UpdateLatencyTimestamp_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, UpdateLatencyTimestamp_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); std::string timestamp = ""; bool isRenderer = false; - capturerInClientInner_->UpdateLatencyTimestamp(timestamp, isRenderer); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->UpdateLatencyTimestamp(timestamp, isRenderer); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -1385,13 +1404,14 @@ HWTEST(CapturerInClientUnitTest, UpdateLatencyTimestamp_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, HandleCapturerRead_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t readSize = VALUE_FIVE; size_t userSize = 0; uint8_t buffer = 0; bool isBlockingRead = false; - int32_t ret = capturerInClientInner_->HandleCapturerRead(readSize, userSize, buffer, isBlockingRead); + int32_t ret = capturerInClientInner->HandleCapturerRead(readSize, userSize, buffer, isBlockingRead); EXPECT_EQ(ret, 5); } @@ -1403,17 +1423,17 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerRead_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, HandleCapturerRead_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); size_t readSize = VALUE_FIVE; size_t userSize = 16; uint8_t buffer = 0; bool isBlockingRead = false; - capturerInClientInner_->ringCache_->writeIndex_ = VALUE_FIVE; - capturerInClientInner_->ringCache_->readIndex_ = 0; - capturerInClientInner_->ringCache_->cacheTotalSize_ = VALUE_SIX; - int32_t ret = capturerInClientInner_->HandleCapturerRead(readSize, userSize, buffer, isBlockingRead); + capturerInClientInner->ringCache_->writeIndex_ = VALUE_FIVE; + capturerInClientInner->ringCache_->readIndex_ = 0; + capturerInClientInner->ringCache_->cacheTotalSize_ = VALUE_SIX; + int32_t ret = capturerInClientInner->HandleCapturerRead(readSize, userSize, buffer, isBlockingRead); EXPECT_NE(ret, OPERATION_FAILED); } @@ -1425,14 +1445,15 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerRead_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Read_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::NEW; + Init(capturerInClientInner); + capturerInClientInner->state_ = State::NEW; size_t userSize = 16; uint8_t buffer = 0; bool isBlockingRead = false; - capturerInClientInner_->readLogTimes_ = MAX_TIMES; - int32_t ret = capturerInClientInner_->Read(buffer, userSize, isBlockingRead); + capturerInClientInner->readLogTimes_ = MAX_TIMES; + int32_t ret = capturerInClientInner->Read(buffer, userSize, isBlockingRead); EXPECT_EQ(ret, ERR_ILLEGAL_STATE); } @@ -1444,12 +1465,13 @@ HWTEST(CapturerInClientUnitTest, Read_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t byteRead = 1; - capturerInClientInner_->sizePerFrameInByte_ = 0; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->sizePerFrameInByte_ = 0; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -1460,15 +1482,16 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_001, TestSize.Lev */ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t byteRead = 1; - capturerInClientInner_->capturerMarkPosition_ = false; - capturerInClientInner_->totalBytesRead_ = VALUE_EIGHT; - capturerInClientInner_->sizePerFrameInByte_ = VALUE_FOUR; - capturerInClientInner_->capturerMarkPosition_ = VALUE_FOUR; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->capturerMarkPosition_ = false; + capturerInClientInner->totalBytesRead_ = VALUE_EIGHT; + capturerInClientInner->sizePerFrameInByte_ = VALUE_FOUR; + capturerInClientInner->capturerMarkPosition_ = VALUE_FOUR; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -1479,29 +1502,30 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_002, TestSize.Lev */ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_003, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t byteRead = 1; - capturerInClientInner_->capturerMarkPosition_ = true; - capturerInClientInner_->capturerPeriodRead_ = VALUE_EIGHT; - capturerInClientInner_->capturerPeriodSize_ = VALUE_FOUR; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->capturerMarkPosition_ = true; + capturerInClientInner->capturerPeriodRead_ = VALUE_EIGHT; + capturerInClientInner->capturerPeriodSize_ = VALUE_FOUR; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); - capturerInClientInner_->capturerPeriodRead_ = VALUE_EIGHT; - capturerInClientInner_->capturerPeriodSize_ = 0; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->capturerPeriodRead_ = VALUE_EIGHT; + capturerInClientInner->capturerPeriodSize_ = 0; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); - capturerInClientInner_->capturerPeriodRead_ = VALUE_FOUR; - capturerInClientInner_->capturerPeriodSize_ = VALUE_EIGHT; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->capturerPeriodRead_ = VALUE_FOUR; + capturerInClientInner->capturerPeriodSize_ = VALUE_EIGHT; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); - capturerInClientInner_->capturerPeriodRead_ = VALUE_INVALID; - capturerInClientInner_->capturerPeriodSize_ = 0; - capturerInClientInner_->HandleCapturerPositionChanges(byteRead); - EXPECT_NE(capturerInClientInner_, nullptr); + capturerInClientInner->capturerPeriodRead_ = VALUE_INVALID; + capturerInClientInner->capturerPeriodSize_ = 0; + capturerInClientInner->HandleCapturerPositionChanges(byteRead); + EXPECT_NE(capturerInClientInner, nullptr); } /** @@ -1512,15 +1536,16 @@ HWTEST(CapturerInClientUnitTest, HandleCapturerPositionChanges_003, TestSize.Lev */ HWTEST(CapturerInClientUnitTest, SetBufferSizeInMsec_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); int32_t bufferSizeInMsec = 16; - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_CALLBACK; - int32_t ret = capturerInClientInner_->SetBufferSizeInMsec(bufferSizeInMsec); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; + int32_t ret = capturerInClientInner->SetBufferSizeInMsec(bufferSizeInMsec); EXPECT_EQ(ret, SUCCESS); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; - ret = capturerInClientInner_->SetBufferSizeInMsec(bufferSizeInMsec); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_NORMAL; + ret = capturerInClientInner->SetBufferSizeInMsec(bufferSizeInMsec); EXPECT_EQ(ret, SUCCESS); } @@ -1532,11 +1557,11 @@ HWTEST(CapturerInClientUnitTest, SetBufferSizeInMsec_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, GetFastStatus_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - ASSERT_NE(capturerInClientInner_, nullptr); + Init(capturerInClientInner); - auto ret = capturerInClientInner_->GetFastStatus(); + auto ret = capturerInClientInner->GetFastStatus(); EXPECT_EQ(ret, FASTSTATUS_NORMAL); } @@ -1548,9 +1573,9 @@ HWTEST(CapturerInClientUnitTest, GetFastStatus_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, RestoreAudioStream_001, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - Init(capturerInClientInner_); + Init(capturerInClientInner); std::shared_ptr proxyObj = std::make_shared(); AudioStreamParams info; info.format = AudioSampleFormat::SAMPLE_U8; @@ -1558,26 +1583,26 @@ HWTEST(CapturerInClientUnitTest, RestoreAudioStream_001, TestSize.Level1) info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->streamParams_ = info; - capturerInClientInner_->proxyObj_ = std::make_shared(); - capturerInClientInner_->state_ = State::RUNNING; - bool ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->streamParams_ = info; + capturerInClientInner->proxyObj_ = std::make_shared(); + capturerInClientInner->state_ = State::RUNNING; + bool ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); - capturerInClientInner_->state_ = State::PAUSED; - ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->state_ = State::PAUSED; + ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); - capturerInClientInner_->state_ = State::STOPPED; - ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->state_ = State::STOPPED; + ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); - capturerInClientInner_->state_ = State::STOPPING; - ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->state_ = State::STOPPING; + ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); - capturerInClientInner_->state_ = State::PREPARED; - ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->state_ = State::PREPARED; + ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); } @@ -1589,18 +1614,19 @@ HWTEST(CapturerInClientUnitTest, RestoreAudioStream_001, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, RestoreAudioStream_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); AudioStreamParams info; info.format = AudioSampleFormat::SAMPLE_U8; info.encoding = AudioEncodingType::ENCODING_AUDIOVIVID; info.samplingRate = AudioSamplingRate::SAMPLE_RATE_8000; info.channels = AudioChannel::MONO; info.channelLayout = AudioChannelLayout::CH_LAYOUT_MONO; - capturerInClientInner_->streamParams_ = info; - capturerInClientInner_->proxyObj_ = std::make_shared(); - capturerInClientInner_->state_ = State::RUNNING; - bool ret = capturerInClientInner_->RestoreAudioStream(); + capturerInClientInner->streamParams_ = info; + capturerInClientInner->proxyObj_ = std::make_shared(); + capturerInClientInner->state_ = State::RUNNING; + bool ret = capturerInClientInner->RestoreAudioStream(); EXPECT_NE(ret, VALUE_EIGHT); } @@ -1614,6 +1640,7 @@ HWTEST(CapturerInClientUnitTest, PauseAudioStream_001, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); StateChangeCmdType cmdType = CMD_FROM_CLIENT; capturerInClientInner->state_ = PREPARED; @@ -1636,6 +1663,7 @@ HWTEST(CapturerInClientUnitTest, PauseAudioStream_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); StateChangeCmdType cmdType = CMD_FROM_CLIENT; capturerInClientInner->state_ = RUNNING; @@ -1658,6 +1686,7 @@ HWTEST(CapturerInClientUnitTest, PauseAudioStream_003, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); StateChangeCmdType cmdType = CMD_FROM_CLIENT; capturerInClientInner->state_ = RUNNING; @@ -1678,6 +1707,7 @@ HWTEST(CapturerInClientUnitTest, FlushAudioStream_001, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t size = 8 * 1024; capturerInClientInner->ringCache_ = std::make_unique(size); @@ -1703,6 +1733,7 @@ HWTEST(CapturerInClientUnitTest, FlushAudioStream_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t size = 8 * 1024; capturerInClientInner->ringCache_ = std::make_unique(size); @@ -1728,6 +1759,7 @@ HWTEST(CapturerInClientUnitTest, FlushAudioStream_003, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); size_t size = 8 * 1024; capturerInClientInner->ringCache_ = std::make_unique(size); @@ -1749,6 +1781,7 @@ HWTEST(CapturerInClientUnitTest, FlushCbBuffer_001, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; auto ret = capturerInClientInner->FlushCbBuffer(); @@ -1769,6 +1802,7 @@ HWTEST(CapturerInClientUnitTest, FlushCbBuffer_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->cbBuffer_.reset(new uint8_t[VALUE_TEN]); capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; @@ -1791,7 +1825,7 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_001, TestSize.Level1) int32_t clientUid = 0; std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - ASSERT_TRUE(capturerInClientInner != nullptr); + Init(capturerInClientInner); capturerInClientInner->audioStreamTracker_ = nullptr; capturerInClientInner->FetchDeviceForSplitStream(); @@ -1799,6 +1833,7 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_001, TestSize.Level1) capturerInClientInner->audioStreamTracker_ = std::make_unique(AudioMode::AUDIO_MODE_PLAYBACK, clientUid); capturerInClientInner->FetchDeviceForSplitStream(); + EXPECT_EQ(false, capturerInClientInner->IsRestoreNeeded()); } /** @@ -1812,7 +1847,7 @@ HWTEST(CapturerInClientUnitTest, SetSwitchInfoTimestamp_001, TestSize.Level1) // prepare object std::shared_ptr testCapturerInClientObj = std::make_shared(STREAM_DEFAULT, getpid()); - ASSERT_TRUE(testCapturerInClientObj != nullptr); + Init(testCapturerInClientObj); // start test std::vector> testLastFramePosAndTimePair = { @@ -1834,6 +1869,7 @@ HWTEST(CapturerInClientUnitTest, GetFrameCount_001, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); uint32_t frameCount = -111; int32_t result = capturerInClientInner->GetFrameCount(frameCount); @@ -1853,6 +1889,7 @@ HWTEST(CapturerInClientUnitTest, WaitForRunning_001, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->state_ = RUNNING; bool result = capturerInClientInner->WaitForRunning(); EXPECT_TRUE(result); @@ -1868,6 +1905,7 @@ HWTEST(CapturerInClientUnitTest, WaitForRunning_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->state_ = PAUSED; capturerInClientInner->cbThreadReleased_ = true; bool result = capturerInClientInner->WaitForRunning(); @@ -1884,6 +1922,7 @@ HWTEST(CapturerInClientUnitTest, StopAudioStream_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->state_ = State::INVALID; bool result = capturerInClientInner->StopAudioStream(); EXPECT_FALSE(result); @@ -1899,6 +1938,7 @@ HWTEST(CapturerInClientUnitTest, StopAudioStream_003, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->ipcStream_ = nullptr; bool result = capturerInClientInner->StopAudioStream(); EXPECT_FALSE(result); @@ -1914,6 +1954,7 @@ HWTEST(CapturerInClientUnitTest, FlushCbBuffer_003, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->cbBuffer_ = std::make_unique(10); capturerInClientInner->cbBufferSize_ = 10; auto ret = capturerInClientInner->FlushCbBuffer(); @@ -1931,6 +1972,7 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_002, TestSize.Level2) int32_t clientUid = 0; std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->SetRestoreStatus(NO_NEED_FOR_RESTORE); capturerInClientInner->FetchDeviceForSplitStream(); @@ -1948,6 +1990,7 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_003, TestSize.Level2) int32_t clientUid = 0; std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->SetRestoreStatus(NEED_RESTORE); capturerInClientInner->audioStreamTracker_ = nullptr; capturerInClientInner->FetchDeviceForSplitStream(); @@ -1963,12 +2006,13 @@ HWTEST(CapturerInClientUnitTest, FetchDeviceForSplitStream_003, TestSize.Level2) */ HWTEST(CapturerInClientUnitTest, OnOperationHandled_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); Operation operation = Operation::RESTORE_SESSION; int64_t result = 1; - capturerInClientInner_->audioStreamTracker_ = nullptr; - int32_t ret = capturerInClientInner_->OnOperationHandled(operation, result); + capturerInClientInner->audioStreamTracker_ = nullptr; + int32_t ret = capturerInClientInner->OnOperationHandled(operation, result); EXPECT_EQ(ret, SUCCESS); } @@ -1982,6 +2026,7 @@ HWTEST(CapturerInClientUnitTest, GetFrameCount_002, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); uint32_t frameCount = -111; capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; @@ -1997,11 +2042,12 @@ HWTEST(CapturerInClientUnitTest, GetFrameCount_002, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Clear_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->capturerMode_ = CAPTURE_MODE_NORMAL; - capturerInClientInner_->cbBuffer_.reset(new uint8_t[VALUE_TEN]); - int32_t ret = capturerInClientInner_->Clear(); + Init(capturerInClientInner); + capturerInClientInner->capturerMode_ = CAPTURE_MODE_NORMAL; + capturerInClientInner->cbBuffer_.reset(new uint8_t[VALUE_TEN]); + int32_t ret = capturerInClientInner->Clear(); EXPECT_EQ(ret, ERR_INCORRECT_MODE); } @@ -2015,6 +2061,7 @@ HWTEST(CapturerInClientUnitTest, StopAudioStream_004, TestSize.Level1) { std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); + Init(capturerInClientInner); capturerInClientInner->state_ = State::PAUSED; capturerInClientInner->capturerMode_ = CAPTURE_MODE_CALLBACK; capturerInClientInner->ipcStream_ = std::make_shared().get(); @@ -2031,15 +2078,40 @@ HWTEST(CapturerInClientUnitTest, StopAudioStream_004, TestSize.Level1) */ HWTEST(CapturerInClientUnitTest, Read_002, TestSize.Level1) { - std::shared_ptr capturerInClientInner_ = + std::shared_ptr capturerInClientInner = std::make_shared(STREAM_MUSIC, getpid()); - capturerInClientInner_->state_ = State::NEW; + Init(capturerInClientInner); + capturerInClientInner->state_ = State::NEW; size_t userSize = 16; uint8_t buffer = 0; bool isBlockingRead = false; - capturerInClientInner_->readLogTimes_ = VALUE_TEN; - int32_t ret = capturerInClientInner_->Read(buffer, userSize, isBlockingRead); + capturerInClientInner->readLogTimes_ = VALUE_TEN; + int32_t ret = capturerInClientInner->Read(buffer, userSize, isBlockingRead); EXPECT_EQ(ret, ERR_ILLEGAL_STATE); } + +/** + * @tc.name : CapturerInClient_IsRestoreNeeded_001 + * @tc.type : FUNC + * @tc.number: IsRestoreNeeded_001 + * @tc.desc : Test CapturerInClient IsRestoreNeeded() different cases + */ +HWTEST(CapturerInClientUnitTest, IsRestoreNeeded_001, TestSize.Level4) +{ + auto testCapturerClient = std::make_shared(STREAM_MUSIC, getpid()); + Init(testCapturerClient); + + testCapturerClient->clientBuffer_-> + ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NO_NEED_FOR_RESTORE); + EXPECT_EQ(testCapturerClient->IsRestoreNeeded(), false); + + testCapturerClient->clientBuffer_-> + ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE); + EXPECT_EQ(testCapturerClient->IsRestoreNeeded(), true); + + testCapturerClient->clientBuffer_-> + ohAudioBufferBase_.basicBufferInfo_->restoreStatus.store(NEED_RESTORE_TO_NORMAL); + EXPECT_EQ(testCapturerClient->IsRestoreNeeded(), true); +} } // namespace AudioStandard } // namespace OHOS diff --git a/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp b/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp index f19d6f84f7..feed94558b 100644 --- a/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp +++ b/services/audio_service/test/unittest/client/fast_audio_stream_unit_test.cpp @@ -87,6 +87,7 @@ public: MOCK_METHOD(bool, GetStopFlag, (), (const, override)); MOCK_METHOD(void, JoinCallbackLoop, (), (override)); MOCK_METHOD(void, SetAudioHapticsSyncId, (const int32_t &audioHapticsSyncId), (override)); + MOCK_METHOD(bool, IsRestoreNeeded, (), (override)); }; class FastSystemStreamUnitTest : public testing::Test { -- Gitee