From 90906d17ca2eb3bf9b26b37d03deb05f41733869 Mon Sep 17 00:00:00 2001 From: lengye Date: Tue, 26 Dec 2023 13:25:29 +0000 Subject: [PATCH 1/4] add tdd case Signed-off-by: lengye --- .../native/camera/test/moduletest/BUILD.gn | 2 +- .../include/camera_framework_moduletest.h | 5 + .../src/camera_framework_moduletest.cpp | 614 +++ .../native/camera/test/unittest/BUILD.gn | 4 +- .../include/camera_framework_unittest.h | 1 + .../src/v1_1/camera_framework_unittest.cpp | 4484 +++++++++++++---- .../unittest/src/v1_1/camera_ndk_unittest.cpp | 182 + .../camera/include/output/sketch_wrapper.h | 4 +- 8 files changed, 4254 insertions(+), 1042 deletions(-) diff --git a/frameworks/native/camera/test/moduletest/BUILD.gn b/frameworks/native/camera/test/moduletest/BUILD.gn index a51f0d3d3..ab6bd24cc 100644 --- a/frameworks/native/camera/test/moduletest/BUILD.gn +++ b/frameworks/native/camera/test/moduletest/BUILD.gn @@ -74,7 +74,7 @@ ohos_moduletest("camera_framework_moduletest") { "${driver_peripheral_path}/interfaces/hdi_ipc/callback/operator/include", "${driver_peripheral_path}/interfaces/hdi_ipc/callback/host/include", ] - + defines = [ "private=public" ] cflags = [ "-fPIC" ] cflags_cc = cflags sanitize = { diff --git a/frameworks/native/camera/test/moduletest/include/camera_framework_moduletest.h b/frameworks/native/camera/test/moduletest/include/camera_framework_moduletest.h index 509ef6cde..4dda3b7b0 100644 --- a/frameworks/native/camera/test/moduletest/include/camera_framework_moduletest.h +++ b/frameworks/native/camera/test/moduletest/include/camera_framework_moduletest.h @@ -22,6 +22,11 @@ #include "input/camera_manager.h" #include "session/capture_session.h" #include "session/portrait_session.h" +#include "hcamera_service_callback_proxy.h" +#include "hstream_repeat_proxy.h" +#include "hstream_capture_callback_proxy.h" +#include "hstream_repeat_callback_proxy.h" +#include "hcapture_session_callback_proxy.h" namespace OHOS { namespace CameraStandard { diff --git a/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp b/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp index 23431368b..24e20c58c 100644 --- a/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp +++ b/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp @@ -6576,6 +6576,620 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_090, TestSize.L EXPECT_EQ(session_->Release(), 0); } + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_091, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + HCameraServiceProxy *hCameraServiceProxy = new (std::nothrow) HCameraServiceProxy(object); + ASSERT_NE(hCameraServiceProxy, nullptr); + EffectParam effectParam = {0, 0, 0}; + + sptr device = nullptr; + sptr torchSvcCallback = nullptr; + bool canOpenCamera = true; + EXPECT_EQ(hCameraServiceProxy->CreateCameraDevice(cameras_[0]->GetID(), device), -1); + hCameraServiceProxy->SetTorchCallback(torchSvcCallback); + torchSvcCallback = new(std::nothrow) TorchServiceCallback(); + ASSERT_NE(torchSvcCallback, nullptr); + hCameraServiceProxy->SetTorchCallback(torchSvcCallback); + hCameraServiceProxy->MuteCamera(true); + hCameraServiceProxy->MuteCamera(false); + hCameraServiceProxy->PrelaunchCamera(); + hCameraServiceProxy->SetPrelaunchConfig(cameras_[0]->GetID(), NO_NEED_RESTORE_PARAM_OHOS, 0, effectParam); + hCameraServiceProxy->SetTorchLevel(0); + hCameraServiceProxy->AllowOpenByOHSide(cameras_[0]->GetID(), 0, canOpenCamera); + hCameraServiceProxy->NotifyCameraState(cameras_[0]->GetID(), 0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_092, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + HCameraServiceCallbackProxy *hCameraServiceCallbackProxy = new (std::nothrow) HCameraServiceCallbackProxy(object); + ASSERT_NE(hCameraServiceCallbackProxy, nullptr); + HCameraMuteServiceCallbackProxy *hCameraMuteServiceCallbackProxy = new (std::nothrow) HCameraMuteServiceCallbackProxy(object); + ASSERT_NE(hCameraMuteServiceCallbackProxy, nullptr); + HTorchServiceCallbackProxy *hTorchServiceCallbackProxy = new (std::nothrow) HTorchServiceCallbackProxy(object); + ASSERT_NE(hTorchServiceCallbackProxy, nullptr); + + hCameraServiceCallbackProxy->OnFlashlightStatusChanged(cameras_[0]->GetID(), FLASH_STATUS_OFF); + hCameraMuteServiceCallbackProxy->OnCameraMute(true); + hCameraMuteServiceCallbackProxy->OnCameraMute(false); + hTorchServiceCallbackProxy->OnTorchStatusChange(TORCH_STATUS_OFF); +} + +/* + * Feature: Framework + * Function: Test errorCode, width and height, if sketchRatio > SKETCH_RATIO_MAX_VALUE + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode, width and height, if sketchRatio > SKETCH_RATIO_MAX_VALUE with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_093, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + sptr repeat = iface_cast(object); + ASSERT_NE(repeat, nullptr); + HStreamRepeatProxy *hStreamRepeatProxy = new (std::nothrow) HStreamRepeatProxy(object); + ASSERT_NE(hStreamRepeatProxy, nullptr); + + hStreamRepeatProxy->ForkSketchStreamRepeat(0, 0, repeat, 0); + hStreamRepeatProxy->ForkSketchStreamRepeat(1, 0, repeat, 0); + hStreamRepeatProxy->ForkSketchStreamRepeat(1, 1, repeat, 0); + hStreamRepeatProxy->UpdateSketchRatio(0.0f); + hStreamRepeatProxy->UpdateSketchRatio(200.0f); + hStreamRepeatProxy->UpdateSketchRatio(90.0f); + hStreamRepeatProxy->RemoveSketchStreamRepeat(); +} + +/* + * Feature: Framework + * Function: Test errorCode, width and height, if sketchRatio > SKETCH_RATIO_MAX_VALUE + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode, width and height, if sketchRatio > SKETCH_RATIO_MAX_VALUE with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_094, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + sptr repeat = iface_cast(object); + ASSERT_NE(repeat, nullptr); + HStreamRepeatProxy *hStreamRepeatProxy = new (std::nothrow) HStreamRepeatProxy(object); + ASSERT_NE(hStreamRepeatProxy, nullptr); + + hStreamRepeatProxy->UpdateSketchRatio(0.0f); + hStreamRepeatProxy->UpdateSketchRatio(200.0f); + hStreamRepeatProxy->UpdateSketchRatio(90.0f); + hStreamRepeatProxy->RemoveSketchStreamRepeat(); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_095, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + HStreamCaptureCallbackProxy *hStreamCaptureCallbackProxy = new (std::nothrow) HStreamCaptureCallbackProxy(object); + ASSERT_NE(hStreamCaptureCallbackProxy, nullptr); + + hStreamCaptureCallbackProxy->OnCaptureStarted(0); + hStreamCaptureCallbackProxy->OnCaptureStarted(0, 0); + hStreamCaptureCallbackProxy->OnCaptureEnded(0, 0); + hStreamCaptureCallbackProxy->OnCaptureError(0, 0); + hStreamCaptureCallbackProxy->OnFrameShutter(0, 0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_096, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + HStreamRepeatCallbackProxy *hStreamRepeatCallbackProxy = new (std::nothrow) HStreamRepeatCallbackProxy(object); + ASSERT_NE(hStreamRepeatCallbackProxy, nullptr); + + hStreamRepeatCallbackProxy->OnSketchStatusChanged(SketchStatus::STOPED); + hStreamRepeatCallbackProxy->OnFrameStarted(); + hStreamRepeatCallbackProxy->OnFrameEnded(0); + hStreamRepeatCallbackProxy->OnFrameError(0); +} + + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_097, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + HCaptureSessionCallbackProxy *hCaptureSessionCallbackProxy = new (std::nothrow) HCaptureSessionCallbackProxy(object); + ASSERT_NE(hCaptureSessionCallbackProxy, nullptr); + hCaptureSessionCallbackProxy->OnError(0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_098, TestSize.Level0) +{ + auto photoOutput1 = CreatePhotoOutput(); + auto photoOutput = static_cast(photoOutput1.GetRefPtr()); + photoOutput->ConfirmCapture(); + photoOutput->SetSession(nullptr); + photoOutput->ConfirmCapture(); + photoOutput->SetSession(session_); + + int32_t intResult = session_->BeginConfig(); + EXPECT_EQ(intResult, 0); + intResult = session_->AddInput(input_); + EXPECT_EQ(intResult, 0); + sptr previewOutput = CreatePreviewOutput(); + ASSERT_NE(previewOutput, nullptr); + intResult = session_->AddOutput(previewOutput); + EXPECT_EQ(intResult, 0); + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + photoOutput->ConfirmCapture(); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_099, TestSize.Level0) +{ + auto photoOutput1 = CreatePhotoOutput(); + auto photoOutput = static_cast(photoOutput1.GetRefPtr()); + photoOutput->~PhotoOutput(); + photoOutput->ConfirmCapture(); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_100, TestSize.Level0) +{ + std::shared_ptr captureCallback = std::make_shared(); + int32_t captureId = 2001; + int32_t intResult = captureCallback->OnCaptureStarted(captureId, 0); + EXPECT_EQ(intResult, 0); +} + +/* + * Feature: Framework + * Function: Test anomalous branch. + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test GetMetaSetting with existing metaTag. + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_101, TestSize.Level0) +{ + sptr camInput = (sptr&)input_; + + std::shared_ptr metadataItem = nullptr; + metadataItem = camInput->GetMetaSetting(OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS); + ASSERT_NE(metadataItem, nullptr); + + std::vector infos = {}; + EXPECT_EQ((camInput->GetCameraAllVendorTags(infos)), CAMERA_OK); + + sptr deviceObj = camInput->GetCameraDevice(); + ASSERT_NE(deviceObj, nullptr); + + sptr camdeviceObj = nullptr; + sptr camInput_1 = new (std::nothrow) CameraInput(deviceObj, camdeviceObj); + ASSERT_NE(camInput_1, nullptr); + + metadataItem = camInput_1->GetMetaSetting(OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS); + EXPECT_EQ(metadataItem, nullptr); + + metadataItem = camInput->GetMetaSetting(-1); + EXPECT_EQ(metadataItem, nullptr); + + if (!IsSupportNow()) { + return; + } + + std::shared_ptr metadata = cameras_[1]->GetMetadata(); + + std::string cameraId = cameras_[1]->GetID(); + sptr camdeviceObj_2 = new (std::nothrow) CameraDevice(cameraId, metadata); + ASSERT_NE(camdeviceObj_2, nullptr); + + EXPECT_EQ(camdeviceObj_2->GetPosition(), CAMERA_POSITION_FRONT); +} + +/* + * Feature: Framework + * Function: Test anomalous branch. + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test Torch with anomalous branch. + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_102, TestSize.Level0) +{ + EXPECT_EQ(input_->Close(), 0); + + sptr camManagerObj = CameraManager::GetInstance(); + + if (!(manager_->IsTorchSupported())) { + return; + } + + int32_t intResult = camManagerObj->SetTorchMode(TORCH_MODE_AUTO); + EXPECT_EQ(intResult, 7400102); + + intResult = camManagerObj->SetTorchMode(TORCH_MODE_OFF); + EXPECT_EQ(intResult, 7400201); + + camManagerObj->~CameraManager(); + intResult = camManagerObj->SetTorchMode(TORCH_MODE_OFF); + EXPECT_EQ(intResult, 7400201); +} + +/* + * Feature: Framework + * Function: Test Metadata + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test Metadata + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_103, TestSize.Level0) +{ + int32_t intResult = session_->BeginConfig(); + EXPECT_EQ(intResult, 0); + + intResult = session_->AddInput(input_); + EXPECT_EQ(intResult, 0); + + sptr previewOutput = CreatePreviewOutput(); + ASSERT_NE(previewOutput, nullptr); + + intResult = session_->AddOutput(previewOutput); + EXPECT_EQ(intResult, 0); + + sptr metadatOutput = manager_->CreateMetadataOutput(); + ASSERT_NE(metadatOutput, nullptr); + + intResult = session_->AddOutput(metadatOutput); + EXPECT_EQ(intResult, 0); + + sptr metaOutput = (sptr&)metadatOutput; + std::vector metadataObjectTypes = metaOutput->GetSupportedMetadataObjectTypes(); + if (metadataObjectTypes.size() == 0) { + return; + } + + metaOutput->SetCapturingMetadataObjectTypes(std::vector { MetadataObjectType::FACE }); + + std::shared_ptr metadataObjectCallback = std::make_shared(); + metaOutput->SetCallback(metadataObjectCallback); + std::shared_ptr metadataStateCallback = std::make_shared(); + metaOutput->SetCallback(metadataStateCallback); + + pid_t pid = 0; + metaOutput->CameraServerDied(pid); +} + +/* + * Feature: Framework + * Function: Test Metadata + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test Metadata + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_104, TestSize.Level0) +{ + int32_t intResult = session_->BeginConfig(); + EXPECT_EQ(intResult, 0); + + intResult = session_->AddInput(input_); + EXPECT_EQ(intResult, 0); + + sptr previewOutput = CreatePreviewOutput(); + ASSERT_NE(previewOutput, nullptr); + + intResult = session_->AddOutput(previewOutput); + EXPECT_EQ(intResult, 0); + + sptr metadatOutput = manager_->CreateMetadataOutput(); + ASSERT_NE(metadatOutput, nullptr); + + intResult = session_->AddOutput(metadatOutput); + EXPECT_EQ(intResult, 0); + + sptr metaOutput = (sptr&)metadatOutput; + std::vector metadataObjectTypes = metaOutput->GetSupportedMetadataObjectTypes(); + if (metadataObjectTypes.size() == 0) { + return; + } + + metaOutput->SetCapturingMetadataObjectTypes(std::vector {}); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_105, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); + HCameraServiceProxy *hCameraServiceProxy = new (std::nothrow) HCameraServiceProxy(object); + ASSERT_NE(hCameraServiceProxy, nullptr); + EffectParam effectParam = {0, 0, 0}; + + sptr device = nullptr; + sptr torchSvcCallback = nullptr; + bool canOpenCamera = true; + hCameraServiceProxy->CreateCameraDevice(cameras_[0]->GetID(), device); + hCameraServiceProxy->SetTorchCallback(torchSvcCallback); + torchSvcCallback = new(std::nothrow) TorchServiceCallback(); + ASSERT_NE(torchSvcCallback, nullptr); + hCameraServiceProxy->SetTorchCallback(torchSvcCallback); + hCameraServiceProxy->MuteCamera(true); + hCameraServiceProxy->MuteCamera(false); + hCameraServiceProxy->PrelaunchCamera(); + hCameraServiceProxy->SetPrelaunchConfig(cameras_[0]->GetID(), NO_NEED_RESTORE_PARAM_OHOS, 0, effectParam); + hCameraServiceProxy->SetTorchLevel(0); + hCameraServiceProxy->AllowOpenByOHSide(cameras_[0]->GetID(), 0, canOpenCamera); + hCameraServiceProxy->NotifyCameraState(cameras_[0]->GetID(), 0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_106, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + HCameraServiceCallbackProxy *hCameraServiceCallbackProxy = new (std::nothrow) HCameraServiceCallbackProxy(object); + ASSERT_NE(hCameraServiceCallbackProxy, nullptr); + HCameraMuteServiceCallbackProxy *hCameraMuteServiceCallbackProxy = new (std::nothrow) HCameraMuteServiceCallbackProxy(object); + ASSERT_NE(hCameraMuteServiceCallbackProxy, nullptr); + HTorchServiceCallbackProxy *hTorchServiceCallbackProxy = new (std::nothrow) HTorchServiceCallbackProxy(object); + ASSERT_NE(hTorchServiceCallbackProxy, nullptr); + + hCameraServiceCallbackProxy->OnFlashlightStatusChanged(cameras_[0]->GetID(), FLASH_STATUS_OFF); + hCameraMuteServiceCallbackProxy->OnCameraMute(true); + hCameraMuteServiceCallbackProxy->OnCameraMute(false); + hTorchServiceCallbackProxy->OnTorchStatusChange(TORCH_STATUS_OFF); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_107, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + HStreamCaptureCallbackProxy *hStreamCaptureCallbackProxy = new (std::nothrow) HStreamCaptureCallbackProxy(object); + ASSERT_NE(hStreamCaptureCallbackProxy, nullptr); + + hStreamCaptureCallbackProxy->OnCaptureStarted(0); + hStreamCaptureCallbackProxy->OnCaptureStarted(0, 0); + hStreamCaptureCallbackProxy->OnCaptureEnded(0, 0); + hStreamCaptureCallbackProxy->OnCaptureError(0, 0); + hStreamCaptureCallbackProxy->OnFrameShutter(0, 0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_108, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + HStreamRepeatCallbackProxy *hStreamRepeatCallbackProxy = new (std::nothrow) HStreamRepeatCallbackProxy(object); + ASSERT_NE(hStreamRepeatCallbackProxy, nullptr); + + hStreamRepeatCallbackProxy->OnSketchStatusChanged(SketchStatus::STOPED); + hStreamRepeatCallbackProxy->OnFrameStarted(); + hStreamRepeatCallbackProxy->OnFrameEnded(0); + hStreamRepeatCallbackProxy->OnFrameError(0); +} + +/* + * Feature: Framework + * Function: Test errorCode + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test errorCode with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_109, TestSize.Level0) +{ + sptr object = nullptr; + auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); + ASSERT_NE(samgr, nullptr); + object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); + HCaptureSessionCallbackProxy *hCaptureSessionCallbackProxy = new (std::nothrow) HCaptureSessionCallbackProxy(object); + ASSERT_NE(hCaptureSessionCallbackProxy, nullptr); + hCaptureSessionCallbackProxy->OnError(0); +} + +/* Feature: Framework + * Function: Test CreateCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CreateCaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_110, TestSize.Level0) +{ + SceneMode mode = SceneMode::CAPTURE; + sptr modeManagerObj = CameraManager::GetInstance(); + ASSERT_NE(modeManagerObj, nullptr); + + sptr captureSession = modeManagerObj->CreateCaptureSession(mode); + ASSERT_NE(captureSession, nullptr); +} + +/* Feature: Framework + * Function: Test CreateCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CreateCaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_111, TestSize.Level0) +{ + SceneMode mode = SceneMode::SCAN; + sptr modeManagerObj = CameraManager::GetInstance(); + ASSERT_NE(modeManagerObj, nullptr); + + sptr captureSession = modeManagerObj->CreateCaptureSession(mode); + ASSERT_NE(captureSession, nullptr); +} + +/* Feature: Framework + * Function: Test CreateCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CreateCaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_112, TestSize.Level0) +{ + SceneMode mode = SceneMode::CAPTURE_MACRO; + sptr modeManagerObj = CameraManager::GetInstance(); + ASSERT_NE(modeManagerObj, nullptr); + + sptr captureSession = modeManagerObj->CreateCaptureSession(mode); + ASSERT_NE(captureSession, nullptr); +} + +/* Feature: Framework + * Function: Test CreateCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CreateCaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_113, TestSize.Level0) +{ + SceneMode mode = SceneMode::CAPTURE_MACRO; + sptr modeManagerObj = CameraManager::GetInstance(); + ASSERT_NE(modeManagerObj, nullptr); + + sptr captureSession = modeManagerObj->CreateCaptureSession(mode); + ASSERT_NE(captureSession, nullptr); +} + +/* Feature: Framework + * Function: Test CreateCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CreateCaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_114, TestSize.Level0) +{ + SceneMode mode = SceneMode::VIDEO; + sptr modeManagerObj = CameraManager::GetInstance(); + ASSERT_NE(modeManagerObj, nullptr); + + sptr captureSession = modeManagerObj->CreateCaptureSession(mode); + ASSERT_NE(captureSession, nullptr); +} + /* * Feature: Framework * Function: Test camera preempted. diff --git a/frameworks/native/camera/test/unittest/BUILD.gn b/frameworks/native/camera/test/unittest/BUILD.gn index e77139f30..195c8a4f2 100644 --- a/frameworks/native/camera/test/unittest/BUILD.gn +++ b/frameworks/native/camera/test/unittest/BUILD.gn @@ -132,6 +132,8 @@ ohos_unittest("camera_framework_unittest_v1_1") { "sensor:sensor_interface_native", ] + defines = [ "private=public" ] + cflags = [ "-fPIC", "-Werror=unused", @@ -215,6 +217,6 @@ ohos_unittest("camera_ndk_unittest_v1_1") { "${driver_peripheral_path}/interfaces/hdi_ipc/callback/operator/include", "${driver_peripheral_path}/interfaces/hdi_ipc/callback/host/include", ] - + defines = [ "private=public" ] cflags_cc = cflags } diff --git a/frameworks/native/camera/test/unittest/include/camera_framework_unittest.h b/frameworks/native/camera/test/unittest/include/camera_framework_unittest.h index b4a0bf001..69ae1155d 100644 --- a/frameworks/native/camera/test/unittest/include/camera_framework_unittest.h +++ b/frameworks/native/camera/test/unittest/include/camera_framework_unittest.h @@ -19,6 +19,7 @@ #include "gtest/gtest.h" #include "hcamera_service.h" #include "input/camera_manager.h" +#include "output/sketch_wrapper.h" namespace OHOS { namespace CameraStandard { diff --git a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp index 467a4256f..1686cab3e 100644 --- a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp +++ b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp @@ -402,6 +402,34 @@ public: } }; +class AppSessionCallback : public SessionCallback { +public: + void OnError(int32_t errorCode) + { + MEDIA_DEBUG_LOG("AppMetadataCallback::OnError %{public}d", errorCode); + return; + } +}; + +class AppMacroStatusCallback: public MacroStatusCallback { +public: + void OnMacroStatusChanged(MacroStatus status) { + MEDIA_DEBUG_LOG("AppMacroStatusCallback"); + } +}; + +class AppMetadataCallback : public MetadataObjectCallback, public MetadataStateCallback { +public: + void OnMetadataObjectsAvailable(std::vector> metaObjects) const + { + MEDIA_DEBUG_LOG("AppMetadataCallback::OnMetadataObjectsAvailable received"); + } + void OnError(int32_t errorCode) const + { + MEDIA_DEBUG_LOG("AppMetadataCallback::OnError %{public}d", errorCode); + } +}; + sptr CameraFrameworkUnitTest::CreatePhotoOutput(int32_t width, int32_t height) { sptr surface = IConsumerSurface::Create(); @@ -2264,235 +2292,310 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_052, TestSize.Level0 /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test cameramanager with updatetorchmode * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraDevice with anomalous branch + * CaseDescription: Test cameramanager with updatetorchmode */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_001, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_053, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0); - sptr input = cameraManager->CreateCameraInput(cameras[0]); - ASSERT_NE(input, nullptr); - - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); + SceneMode mode = PORTRAIT; + cameraManager->serviceProxy_ = nullptr; + cameraManager->CreateCaptureSession(mode); + cameraManager->InitCameraList(); + + TorchMode mode1 = TorchMode::TORCH_MODE_OFF; + TorchMode mode2 = TorchMode::TORCH_MODE_ON; + cameraManager->torchMode_ = mode1; + cameraManager->UpdateTorchMode(mode1); + cameraManager->UpdateTorchMode(mode2); +} - sptr cameraHostManager = (sptr &)mockCameraHostManager; - std::string cameraId = cameras[0]->GetID(); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); - ASSERT_NE(camDevice, nullptr); +/* + * Feature: Framework + * Function: Test cameramanager with parsebasiccapability + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager with parsebasiccapability + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_054, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0); - int32_t ret = camDevice->HCameraDevice::OpenDevice(); - EXPECT_EQ(ret, 0); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + camera_metadata_item_t item; + int ret = OHOS::Camera::FindCameraMetadataItem(metadata->get(), + OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item); + EXPECT_EQ(ret, CAM_META_SUCCESS); + cameraManager->ParseBasicCapability(ability, metadata, item); +} - std::vector result; - result.push_back(OHOS_SENSOR_EXPOSURE_TIME); +/* + * Feature: Framework + * Function: Test cameramanager with no cameraid and cameraobjlist + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager with no cameraid and cameraobjlist + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_055, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0); + + pid_t pid = 0; + cameraManager->CameraServerDied(pid); + sptr cameraServiceCallback = nullptr; + cameraManager->SetCameraServiceCallback(cameraServiceCallback); + sptr torchServiceCallback = nullptr; + cameraManager->SetTorchServiceCallback(torchServiceCallback); + sptr cameraMuteServiceCallback = nullptr; + cameraManager->SetCameraMuteServiceCallback(cameraMuteServiceCallback); + float level = 9.2; + cameraManager->SetTorchLevel(level); + string cameraId = ""; + int activeTime = 0; + EffectParam effectParam = {0, 0, 0}; + cameraManager->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSISTENT_ACTIVE_PARAM_OHOS, + activeTime, effectParam); - ret = camDevice->HCameraDevice::EnableResult(result); - EXPECT_EQ(ret, 0); + cameraManager->cameraObjList = {}; + bool isTorchSupported = cameraManager->IsTorchSupported(); + EXPECT_EQ(isTorchSupported, false); +} - ret = camDevice->HCameraDevice::DisableResult(result); - EXPECT_EQ(ret, 0); +/* + * Feature: Framework + * Function: Test cameramanager with serviceProxy_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager with serviceProxy_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_056, TestSize.Level0) +{ + sptr callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager); + cameraManager->cameraSvcCallback_ = callback; + + pid_t pid = 0; + cameraManager->serviceProxy_ = nullptr; + cameraManager->CameraServerDied(pid); + sptr cameraServiceCallback = nullptr; + cameraManager->SetCameraServiceCallback(cameraServiceCallback); + sptr torchServiceCallback = nullptr; + cameraManager->SetTorchServiceCallback(torchServiceCallback); + sptr cameraMuteServiceCallback = nullptr; + cameraManager->SetCameraMuteServiceCallback(cameraMuteServiceCallback); + + cameraManager->cameraObjList = {}; + string cameraId = ""; + cameraManager->GetCameraDeviceFromId(cameraId); + bool isTorchSupported = cameraManager->IsTorchSupported(); + EXPECT_EQ(isTorchSupported, false); +} - sptr streamOperator = camDevice->HCameraDevice::GetStreamOperator(); - EXPECT_TRUE(streamOperator != nullptr); +/* + * Feature: Framework + * Function: Test cameramanager with preswitchcamera + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager with preswitchcamera + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_057, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr ability = cameraManager->GetSupportedOutputCapability(cameras[0], 0); - ret = camDevice->HCameraDevice::OnError(REQUEST_TIMEOUT, 0); - EXPECT_EQ(ret, 0); + std::string cameraId = cameras[0]->GetID(); + cameraManager->PreSwitchCamera(cameraId); - ret = camDevice->HCameraDevice::CloseDevice(); - EXPECT_EQ(ret, 0); + cameraManager->serviceProxy_ = nullptr; + cameraManager->PreSwitchCamera(cameraId); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test cameradevice with position and zoomratiorange * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test dump with args empty + * CaseDescription: Test cameradevice with position and zoomratiorange */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_002, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_058, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); + cameras[0]->foldScreenType_ = CAMERA_FOLDSCREEN_INNER; + cameras[0]->cameraPosition_ = CAMERA_POSITION_FRONT; + cameras[0]->GetPosition(); + + cameras[0]->zoomRatioRange_ = {1.1, 2.1}; + cameras[0]->GetZoomRatioRange(); +} + +/* + * Feature: Framework + * Function: Test camerainput with cameraserverdied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test camerainput with cameraserverdied + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_059, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); - - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - - sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); - sptr camService = (sptr &)mockHCameraService; - ASSERT_NE(camService, nullptr); - - std::vector cameraIds = {}; - std::vector> cameraAbilityList = {}; - int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList); - - int fd = 0; - std::vector args = {}; - ret = camService->Dump(fd, args); - EXPECT_EQ(ret, 0); - input->Close(); + pid_t pid = 0; + camInput->CameraServerDied(pid); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test camerainput with deviceObj_ is nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch + * CaseDescription: Test camerainput with deviceObj_ is nullptr */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_003, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_060, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); - - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - - sptr cameraHostManager = (sptr &)mockCameraHostManager; - sptr streamOperatorCb = nullptr; - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - SceneMode mode = PORTRAIT; - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); - ASSERT_NE(camSession, nullptr); - - sptr cameraDevice = camInput->GetCameraDevice(); - int32_t ret = camSession->AddInput(cameraDevice); - EXPECT_EQ(ret, 10); - - ret = camSession->RemoveInput(cameraDevice); - EXPECT_EQ(ret, 10); - - ret = camSession->BeginConfig(); - EXPECT_EQ(ret, 0); - - ret = camSession->BeginConfig(); - EXPECT_EQ(ret, 10); - - cameraDevice = nullptr; - ret = camSession->AddInput(cameraDevice); - EXPECT_EQ(ret, 2); - - ret = camSession->RemoveInput(cameraDevice); - EXPECT_EQ(ret, 2); - sptr stream_2 = nullptr; - ret = camSession->AddOutput(StreamType::CAPTURE, stream_2); - EXPECT_EQ(ret, 2); - - ret = camSession->RemoveOutput(StreamType::CAPTURE, stream_2); - EXPECT_EQ(ret, 2); - - input->Close(); - camSession->Release(); + pid_t pid = 0; + std::shared_ptr setCallback = std::make_shared("InputCallback"); + camInput->deviceObj_ = nullptr; + camInput->SetErrorCallback(setCallback); + camInput->CameraServerDied(pid); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test camerainput with metadata_ is nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraService with anomalous branch + * CaseDescription: Test camerainput with metadata_ is nullptr */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_004, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_061, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); - sptr cameraService = (sptr &)mockHCameraService; - ASSERT_NE(cameraService, nullptr); + uint32_t metaTag = 0; + camInput->cameraObj_->metadata_ = nullptr; + camInput->GetMetaSetting(metaTag); +} - cameraService->OnStop(); - cameraService->OnStart(); +/* + * Feature: Framework + * Function: Test metadataoutput with cameraserverdied and stop + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test metadataoutput with cameraserverdied and stop + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_062, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr output = cameraManager->CreateMetadataOutput(); + ASSERT_NE(output, nullptr); + sptr metadatOutput = (sptr&)output; - sptr Surface = IConsumerSurface::Create(); - sptr Producer = Surface->GetProducer(); + pid_t pid = 0; + metadatOutput->CameraServerDied(pid); + metadatOutput->Stop(); +} - int32_t height = 0; - int32_t width = PHOTO_DEFAULT_WIDTH; - sptr output = nullptr; - int32_t intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output); - EXPECT_EQ(intResult, 2); +/* + * Feature: Framework + * Function: Test metadataoutput with stream_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test metadataoutput with stream_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_063, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - width = 0; - intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output); - EXPECT_EQ(intResult, 2); + sptr output = cameraManager->CreateMetadataOutput(); + ASSERT_NE(output, nullptr); + sptr metadatOutput = (sptr&)output; - Producer = nullptr; - intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); + pid_t pid = 0; + metadatOutput->stream_ = nullptr; + metadatOutput->CameraServerDied(pid); + metadatOutput->Stop(); + metadatOutput->Release(); +} - Producer = Surface->GetProducer(); - intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); +/* + * Feature: Framework + * Function: Test metadataoutput with surface_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test metadataoutput with surface_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_064, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - width = PREVIEW_DEFAULT_WIDTH; - intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); + sptr output = cameraManager->CreateMetadataOutput(); + ASSERT_NE(output, nullptr); + sptr metadatOutput = (sptr&)output; - intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); + metadatOutput->surface_ = nullptr; + metadatOutput->Release(); +} - width = 0; - intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); +/* + * Feature: Framework + * Function: Test metadataoutput with start when session_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test metadataoutput with start when session_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_065, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - Producer = nullptr; - intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); - EXPECT_EQ(intResult, 2); + sptr metadata = cameraManager->CreateMetadataOutput(); + ASSERT_NE(metadata, nullptr); + sptr metadatOutput = (sptr&)metadata; - cameraService->OnStart(); - cameraService->OnStop(); - input->Close(); + metadatOutput->session_ = nullptr; + metadatOutput->Start(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test metadataoutput with start when not commit * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraService with anomalous branch + * CaseDescription: Test metadataoutput with start when not commit */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_005, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_066, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); @@ -2505,594 +2608,2841 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_005, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); - sptr cameraService = (sptr &)mockHCameraService; - ASSERT_NE(cameraService, nullptr); - - int32_t width = 0; - int32_t height = 0; - - cameraService->OnStop(); - cameraService->OnStart(); + sptr metadata = cameraManager->CreateMetadataOutput(); + ASSERT_NE(metadata, nullptr); + sptr metadatOutput = (sptr&)metadata; - sptr Surface = IConsumerSurface::Create(); - sptr Producer = Surface->GetProducer(); - - sptr output_1 = nullptr; - int32_t intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); - EXPECT_EQ(intResult, 2); - - width = PHOTO_DEFAULT_WIDTH; - intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); - EXPECT_EQ(intResult, 2); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); - Producer = nullptr; - intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); - EXPECT_EQ(intResult, 2); + session->BeginConfig(); + session->AddInput(input); + session->AddOutput(metadata); - sptr output_2 = nullptr; - intResult = cameraService->CreateMetadataOutput(Producer, 0, output_2); - EXPECT_EQ(intResult, 2); + metadatOutput->Start(); - cameraService->OnStart(); - cameraService->OnStop(); - input->Close(); + session->CommitConfig(); + session->Start(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test metadataoutput with start when stream_ is nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraService with anomalous branch + * CaseDescription: Test metadataoutput with start when stream_ is nullptr */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_006, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_067, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); + sptr camInput = (sptr &)input; EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); - sptr cameraService = (sptr &)mockHCameraService; - ASSERT_NE(cameraService, nullptr); - - cameraService->OnStop(); - cameraService->OnStart(); - - sptr callback = nullptr; - int32_t intResult = cameraService->SetCallback(callback); - EXPECT_EQ(intResult, 2); - - callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager); - intResult = cameraService->SetCallback(callback); - EXPECT_EQ(intResult, 0); - - sptr deviceObj = camInput->GetCameraDevice(); - ASSERT_NE(deviceObj, nullptr); - - sptr callback_2 = nullptr; - intResult = cameraService->SetMuteCallback(callback_2); - EXPECT_EQ(intResult, 2); + sptr metadata = cameraManager->CreateMetadataOutput(); + ASSERT_NE(metadata, nullptr); + sptr metadatOutput = (sptr&)metadata; - callback_2 = new(std::nothrow) CameraMuteServiceCallback(cameraManager); - intResult = cameraService->SetMuteCallback(callback_2); - EXPECT_EQ(intResult, 0); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); - std::string cameraId = camInput->GetCameraId(); - int activeTime = 0; - EffectParam effectParam = {0, 0, 0}; + session->BeginConfig(); - intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSISTENT_ACTIVE_PARAM_OHOS, - activeTime, effectParam); - EXPECT_EQ(intResult, 2); + session->AddInput(input); + session->AddOutput(metadata); - cameraId = ""; - intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSISTENT_ACTIVE_PARAM_OHOS, - activeTime, effectParam); - EXPECT_EQ(intResult, 2); + session->CommitConfig(); + session->Start(); - cameraService->OnStop(); - input->Close(); + metadatOutput->stream_ = nullptr; + metadatOutput->Start(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test metadataoutput with start * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test different status with OnReceive + * CaseDescription: Test metadataoutput with start */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_007, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_068, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); + sptr camInput = (sptr &)input; EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr cameraHostManager = (sptr &)mockCameraHostManager; - HDI::ServiceManager::V1_0::ServiceStatus status; + sptr metadata = cameraManager->CreateMetadataOutput(); + ASSERT_NE(metadata, nullptr); + sptr metadatOutput = (sptr&)metadata; - status.serviceName = "1"; - cameraHostManager->OnReceive(status); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); - status.deviceClass = DEVICE_CLASS_CAMERA; - status.serviceName = "distributed_camera_service"; - status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START; - cameraHostManager->OnReceive(status); - cameraHostManager->OnReceive(status); + session->BeginConfig(); - status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP; - cameraHostManager->OnReceive(status); + session->AddInput(input); + session->AddOutput(metadata); - status.status = 4; - cameraHostManager->OnReceive(status); + session->CommitConfig(); + session->Start(); - input->Close(); + metadatOutput->Start(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test metadataoutput when destruction * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test CaptureSession with no static capability. + * CaseDescription: Test metadataoutput when destruction */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_008, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_069, TestSize.Level0) { - g_mockFlagWithoutAbt = true; - sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); - - std::vector> cameras = camManager->GetSupportedCameras(); - sptr input = camManager->CreateCameraInput(cameras[0]); - ASSERT_NE(input, nullptr); - - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - - sptr session = camManager->CreateCaptureSession(); - ASSERT_NE(session, nullptr); + std::vector> cameras = cameraManager->GetSupportedCameras(); - EXPECT_EQ(session->BeginConfig(), 0); + sptr output = cameraManager->CreateMetadataOutput(); + ASSERT_NE(output, nullptr); + sptr metadatOutput = (sptr&)output; - EXPECT_EQ(session->AddInput(input), 0); - EXPECT_EQ(session->AddOutput(photo), 0); + metadatOutput->~MetadataOutput(); + metadatOutput->Stop(); +} - EXPECT_EQ(session->CommitConfig(), 0); +/* + * Feature: Framework + * Function: Test photooutput with cameraserverdied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test photooutput with cameraserverdied + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_070, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]); + sptr photoOutput = CreatePhotoOutput(); + ASSERT_NE(photoOutput, nullptr); - std::vector videoStabilizationMode = session->GetSupportedStabilizationMode(); - EXPECT_EQ(videoStabilizationMode.empty(), true); + pid_t pid = 0; + photoOutput->CameraServerDied(pid); +} - int32_t intResult = session->GetSupportedStabilizationMode(videoStabilizationMode); - EXPECT_EQ(intResult, 0); +/* + * Feature: Framework + * Function: Test photooutput with cameraserverdied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test photooutput with cameraserverdied + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_071, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - std::vector getSupportedExpModes = session->GetSupportedExposureModes(); - EXPECT_EQ(getSupportedExpModes.empty(), true); + sptr photoOutput = CreatePhotoOutput(); + ASSERT_NE(photoOutput, nullptr); - EXPECT_EQ(session->GetSupportedExposureModes(getSupportedExpModes), 0); + pid_t pid = 0; + std::shared_ptr setCallback = std::make_shared("PhotoStateCallback"); + ((sptr&)photoOutput)->SetCallback(setCallback); + photoOutput->CameraServerDied(pid); +} - EXPECT_EQ(session->GetExposureMode(), -1); - EXPECT_EQ((session->GetMeteringPoint().x), 0); - EXPECT_EQ((session->GetMeteringPoint().y), 0); +/* + * Feature: Framework + * Function: Test photooutput with cameraserverdied when stream_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test photooutput with cameraserverdied when stream_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_072, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - float exposureValue = session->GetExposureValue(); - EXPECT_EQ(exposureValue, 0); - int32_t exposureValueGet = session->GetExposureValue(exposureValue); - EXPECT_EQ(exposureValueGet, 0); + sptr photoOutput = CreatePhotoOutput(); + ASSERT_NE(photoOutput, nullptr); - input->Close(); - session->Release(); + pid_t pid = 0; + sptr phtOutput = (sptr&)photoOutput; + phtOutput->stream_ = nullptr; + photoOutput->CameraServerDied(pid); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test photooutput with confirmcapture when stream_ is nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test CaptureSession with no static capability. + * CaseDescription: Test photooutput with confirmcapture when stream_ is nullptr */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_009, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_073, TestSize.Level0) { - g_mockFlagWithoutAbt = true; - sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); - - std::vector> cameras = camManager->GetSupportedCameras(); - - sptr input = camManager->CreateCameraInput(cameras[0]); + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); + sptr photoOutput = CreatePhotoOutput(); + ASSERT_NE(photoOutput, nullptr); + sptr phtOutput = (sptr&)photoOutput; - sptr session = camManager->CreateCaptureSession(); + sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); - EXPECT_EQ(session->BeginConfig(), 0); - - EXPECT_EQ(session->AddInput(input), 0); - EXPECT_EQ(session->AddOutput(photo), 0); + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); - EXPECT_EQ(session->CommitConfig(), 0); + ret = session->AddOutput(photoOutput); + session->CommitConfig(); - sptr cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]); + phtOutput->stream_ = nullptr; + phtOutput->ConfirmCapture(); - std::vector supportedFocusModes = session->GetSupportedFocusModes(); - EXPECT_EQ(supportedFocusModes.empty(), true); - EXPECT_EQ(session->GetSupportedFocusModes(supportedFocusModes), 0); + phtOutput->~PhotoOutput(); + phtOutput->ConfirmCapture(); - EXPECT_EQ(session->GetFocusMode(), 0); + session->Release(); +} - float focalLength = session->GetFocalLength(); - EXPECT_EQ(focalLength, 0); - EXPECT_EQ(session->GetFocalLength(focalLength), 0); +/* + * Feature: Framework + * Function: Test previewoutput + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test previewoutput + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_074, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); - std::vector supportedFlashModes = session->GetSupportedFlashModes(); - EXPECT_EQ(supportedFlashModes.empty(), true); - EXPECT_EQ(session->GetSupportedFlashModes(supportedFlashModes), 0); - EXPECT_EQ(session->GetFlashMode(), 0); - EXPECT_EQ(session->GetZoomRatio(), 0); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); - bool isSupported; - EXPECT_EQ(session->IsVideoStabilizationModeSupported(MIDDLE, isSupported), 0); - EXPECT_EQ(session->SetVideoStabilizationMode(MIDDLE), 0); - EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO), false); - EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO, isSupported), 0); + auto previewOutput = (sptr&)preview; + previewOutput->stream_ = nullptr; + previewOutput->session_ = nullptr; - sptr photoOutput = (sptr &)photo; - EXPECT_EQ(photoOutput->IsMirrorSupported(), false); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); + previewOutput->IsSketchSupported(); - input->Close(); - session->Release(); + Size previewSize = {}; + previewOutput->stream_ = nullptr; + previewOutput->CreateSketchWrapper(previewSize); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test previewoutput with callback and cameraserverdied * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test dump with no static capability. + * CaseDescription: Test previewoutput with callback and cameraserverdied */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_010, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_075, TestSize.Level0) { - g_mockFlagWithoutAbt = true; - sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); - std::vector> cameras = camManager->GetSupportedCameras(); - - sptr input = camManager->CreateCameraInput(cameras[0]); - ASSERT_NE(input, nullptr); + std::vector> cameras = cameraManager->GetSupportedCameras(); - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); - sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); - sptr camService = (sptr &)mockHCameraService; - ASSERT_NE(camService, nullptr); + auto previewOutput = (sptr&)preview; - camService->OnStart(); + std::string eventString = "sketchAvailable"; + previewOutput->sketchWrapper_ = nullptr; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); - std::vector cameraIds = {}; - std::vector> cameraAbilityList = {}; - int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList); - - int fd = 0; - std::vector args = {}; - ret = camService->Dump(fd, args); - EXPECT_EQ(ret, 0); - - std::u16string cameraServiceInfo = u""; - args.push_back(cameraServiceInfo); - ret = camService->Dump(fd, args); - EXPECT_EQ(ret, 10); - - camService->OnStop(); - input->Close(); -} + pid_t pid = 0; + previewOutput->stream_ = nullptr; + previewOutput->CameraServerDied(pid); +} /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test sketchwrapper * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamCapture SetRotation with no static capability. + * CaseDescription: Test sketchwrapper */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_011, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_076, TestSize.Level0) { - g_mockFlagWithoutAbt = true; - sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); - std::vector> cameras = camManager->GetSupportedCameras(); + std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = camManager->CreateCameraInput(cameras[0]); + sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); + sptr cameraInput = (sptr&)input; - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - - sptr session = camManager->CreateCaptureSession(); - ASSERT_NE(session, nullptr); - - int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); - - ret = session->AddInput(input); - EXPECT_EQ(ret, 0); - - ret = session->AddOutput(photo); - EXPECT_EQ(ret, 0); - - ret = session->CommitConfig(); - EXPECT_EQ(ret, 0); + std::shared_ptr deviceMetadata = cameraInput->GetCameraDeviceInfo()->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); - std::shared_ptr photoSetting = std::make_shared(); - photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90); - photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); - EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90); - EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); + int32_t width = 1440; + int32_t height = 1080; + CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP; + Size previewSize; + previewSize.width = width; + previewSize.height = height; + sptr surface = Surface::CreateSurfaceAsConsumer(); + Profile previewProfile = Profile(previewFormat, previewSize); + sptr previewOutput = cameraManager->CreatePreviewOutput(previewProfile, surface); + ASSERT_NE(previewOutput, nullptr); - EXPECT_CALL(*mockStreamOperator, Capture(_, - matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false)); - ret = ((sptr &)photo)->Capture(photoSetting); - EXPECT_EQ(ret, 0); + Size sketchSize; + sketchSize.width = 640; + sketchSize.height = 480; - input->Close(); - session->Release(); - input->Release(); + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), sketchSize); + ASSERT_NE(sketchWrapper, nullptr); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + int32_t modeName = session->GetFeaturesMode(); + int ret = sketchWrapper->Init(deviceMetadata, modeName); + EXPECT_EQ(ret, CAMERA_OK); + + sketchWrapper->sketchStream_ = nullptr; + ret = sketchWrapper->AttachSketchSurface(nullptr); + EXPECT_EQ(ret, CAMERA_INVALID_STATE); + sketchWrapper->StartSketchStream(); + + std::shared_ptr metadata; + sketchWrapper->UpdateSketchEnableRatio(metadata); + sketchWrapper->UpdateSketchReferenceFovRatio(metadata); } /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test sketchwrapper * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamRepeat with no static capability. + * CaseDescription: Test sketchwrapper */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_012, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_077, TestSize.Level0) { - g_mockFlagWithoutAbt = true; - sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); - int32_t format = CAMERA_FORMAT_YUV_420_SP; - int32_t width = PHOTO_DEFAULT_WIDTH; - int32_t height = PHOTO_DEFAULT_HEIGHT; - - std::vector> cameras = camManager->GetSupportedCameras(); + std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = camManager->CreateCameraInput(cameras[0]); + sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); + sptr cameraInput = (sptr&)input; - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); + std::shared_ptr deviceMetadata = cameraInput->GetCameraDeviceInfo()->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); + int32_t width = 1440; + int32_t height = 1080; + CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP; + Size previewSize; + previewSize.width = width; + previewSize.height = height; + sptr surface = Surface::CreateSurfaceAsConsumer(); + Profile previewProfile = Profile(previewFormat, previewSize); + sptr previewOutput = cameraManager->CreatePreviewOutput(previewProfile, surface); + ASSERT_NE(previewOutput, nullptr); - sptr metadatOutput = camManager->CreateMetadataOutput(); - ASSERT_NE(metadatOutput, nullptr); + Size sketchSize; + sketchSize.width = 640; + sketchSize.height = 480; - sptr session = camManager->CreateCaptureSession(); + sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); - - EXPECT_EQ(session->BeginConfig(), 0); - - EXPECT_EQ(session->AddInput(input), 0); - EXPECT_EQ(session->AddOutput(photo), 0); - EXPECT_EQ(session->AddOutput(metadatOutput), 0); - - EXPECT_EQ(session->CommitConfig(), 0); - - sptr Surface = IConsumerSurface::Create(); - sptr producer1 = Surface->GetProducer(); - auto streamRepeat = new (std::nothrow) HStreamRepeat(producer1, format, width, height, RepeatStreamType::PREVIEW); - - std::shared_ptr photoSetting = std::make_shared(); - photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90); - photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); - EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90); - EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); - - EXPECT_EQ(streamRepeat->LinkInput(mockStreamOperator, photoSetting->GetCaptureMetadataSetting()), 8); - - EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); - EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); - - EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE); - - EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); - EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); - - input->Close(); - session->Release(); + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), sketchSize); + ASSERT_NE(sketchWrapper, nullptr); + + int32_t modeName = session->GetFeaturesMode(); + int ret = sketchWrapper->Init(deviceMetadata, modeName); + EXPECT_EQ(ret, CAMERA_OK); + + float sketchRatio = sketchWrapper->GetSketchEnableRatio(session->GetFeaturesMode()); + sketchWrapper->hostStream_ = nullptr; + ret = sketchWrapper->UpdateSketchRatio(sketchRatio); + sketchWrapper->Destroy(); } /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test sketchwrapper * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch. + * CaseDescription: Test sketchwrapper */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_013, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_078, TestSize.Level0) { - InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); sptr input = cameraManager->CreateCameraInput(cameras[0]); ASSERT_NE(input, nullptr); + sptr cameraInput = (sptr&)input; - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); + std::shared_ptr deviceMetadata = cameraInput->GetCameraDeviceInfo()->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - SceneMode mode = PORTRAIT; - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); - ASSERT_NE(camSession, nullptr); + int32_t width = 1440; + int32_t height = 1080; + CameraFormat previewFormat = CAMERA_FORMAT_YUV_420_SP; + Size previewSize; + previewSize.width = width; + previewSize.height = height; + sptr surface = Surface::CreateSurfaceAsConsumer(); + Profile previewProfile = Profile(previewFormat, previewSize); + sptr previewOutput = cameraManager->CreatePreviewOutput(previewProfile, surface); + ASSERT_NE(previewOutput, nullptr); - std::string permissionName = "permissionName"; - uint32_t callingTokenId = 0; - Security::AccessToken::PermStateChangeScope scopeInfo; - scopeInfo.permList = {permissionName}; - scopeInfo.tokenIDs = {callingTokenId}; + Size sketchSize; + sketchSize.width = 640; + sketchSize.height = 480; - int32_t permStateChangeType = 0; - Security::AccessToken::PermStateChangeInfo info; - info.permStateChangeType = permStateChangeType; - info.tokenID = Security::AccessToken::INVALID_TOKENID; - info.permissionName = permissionName; + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), sketchSize); + ASSERT_NE(sketchWrapper, nullptr); + + int32_t modeName = session->GetFeaturesMode(); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + camera_metadata_item_t item; + OHOS::Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item); + const camera_device_metadata_tag_t tag1 = OHOS_CONTROL_ZOOM_RATIO; + sketchWrapper->OnControlMetadataDispatch(modeName, tag1, item); + const camera_device_metadata_tag_t tag2 = OHOS_CONTROL_CAMERA_MACRO; + sketchWrapper->OnControlMetadataDispatch(modeName, tag2, item); +} - int32_t permStateChangeType1 = 1; - Security::AccessToken::PermStateChangeInfo info1; - info1.permStateChangeType = permStateChangeType1; - info1.tokenID = Security::AccessToken::INVALID_TOKENID; - info1.permissionName = permissionName; +/* + * Feature: Framework + * Function: Test videooutput with cameraserverdied + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test videooutput with cameraserverdied + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_079, TestSize.Level0) +{ + int32_t width = VIDEO_DEFAULT_WIDTH; + int32_t height = VIDEO_DEFAULT_HEIGHT; + sptr surface = Surface::CreateSurfaceAsConsumer(); + CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP; + Size videoSize; + videoSize.width = width; + videoSize.height = height; + std::vector videoFramerates = {30, 30}; + VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates); + sptr video = cameraManager->CreateVideoOutput(videoProfile, surface); + ASSERT_NE(video, nullptr); - std::shared_ptr permissionStatusChangeCb = - std::make_shared(camSession, scopeInfo); - permissionStatusChangeCb->PermStateChangeCallback(info); - permissionStatusChangeCb->PermStateChangeCallback(info); - permissionStatusChangeCb->PermStateChangeCallback(info1); + pid_t pid = 0; + video->CameraServerDied(pid); +} - std::shared_ptr cameraUseStateChangeCb = - std::make_shared(camSession); - cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, false); - cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, true); - cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, false); +/* + * Feature: Framework + * Function: Test videooutput with cameraserverdied when stream_ is nullptr + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test videooutput with cameraserverdied when stream_ is nullptr + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_080, TestSize.Level0) +{ + int32_t width = VIDEO_DEFAULT_WIDTH; + int32_t height = VIDEO_DEFAULT_HEIGHT; + sptr surface = Surface::CreateSurfaceAsConsumer(); + CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP; + Size videoSize; + videoSize.width = width; + videoSize.height = height; + std::vector videoFramerates = {30, 30}; + VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates); + sptr video = cameraManager->CreateVideoOutput(videoProfile, surface); + ASSERT_NE(video, nullptr); - input->Close(); - camSession->Release(); + pid_t pid = 0; + video->stream_ = nullptr; + std::shared_ptr setCallback = std::make_shared("VideoStateCallback"); + video->SetCallback(setCallback); + video->CameraServerDied(pid); } /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test videooutput when destruction * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch. + * CaseDescription: Test videooutput when destruction */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_014, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_081, TestSize.Level0) { - InSequence s; - std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); - ASSERT_NE(input, nullptr); - - EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); - EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); - sptr camInput = (sptr &)input; - std::string cameraSettings = camInput->GetCameraSettings(); - camInput->SetCameraSettings(cameraSettings); - camInput->GetCameraDevice()->Open(); + int32_t width = VIDEO_DEFAULT_WIDTH; + int32_t height = VIDEO_DEFAULT_HEIGHT; + sptr surface = Surface::CreateSurfaceAsConsumer(); + CameraFormat videoFormat = CAMERA_FORMAT_YUV_420_SP; + Size videoSize; + videoSize.width = width; + videoSize.height = height; + std::vector videoFramerates = {30, 30}; + VideoProfile videoProfile = VideoProfile(videoFormat, videoSize, videoFramerates); + sptr video = cameraManager->CreateVideoOutput(videoProfile, surface); + ASSERT_NE(video, nullptr); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - SceneMode mode = PORTRAIT; - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); - ASSERT_NE(camSession, nullptr); + video->~VideoOutput(); +} +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_082, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + std::shared_ptr settings; + camDevice->UpdateSettingOnce(settings); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_083, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + std::shared_ptr settings = cameras[0]->GetMetadata(); + camDevice->UpdateSettingOnce(settings); + + camDevice->RegisterFoldStatusListener(); + camDevice->UnRegisterFoldStatusListener(); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_084, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + camDevice->UnRegisterFoldStatusListener(); + camDevice->RegisterFoldStatusListener(); + camDevice->UnRegisterFoldStatusListener(); + camDevice->cameraHostManager_ = nullptr; + camDevice->RegisterFoldStatusListener(); + camDevice->UnRegisterFoldStatusListener(); + + std::vector results = {}; + camDevice->EnableResult(results); + camDevice->DisableResult(results); + + std::shared_ptr metaIn; + std::shared_ptr metaOut; + camDevice->GetStatus(metaIn, metaOut); + + camDevice->Close(); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_085, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + camDevice->hdiCameraDevice_ = nullptr; + camDevice->InitStreamOperator(); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_086, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + std::vector streamInfos = {}; + camDevice->CreateStreams(streamInfos); + + std::shared_ptr deviceSettings = cameras[0]->GetMetadata(); + int32_t operationMode = 0; + camDevice->streamOperator_ = nullptr; + camDevice->CommitStreams(deviceSettings, operationMode); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_087, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + std::vector streamInfos = {}; + camDevice->UpdateStreams(streamInfos); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_088, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + int32_t captureId = 0; + const std::vector streamIds = {1, 2}; + camDevice->OnCaptureStarted(captureId, streamIds); + + HDI::Camera::V1_2::CaptureStartedInfo it1; + it1.streamId_ = 1; + it1.exposureTime_ = 1; + HDI::Camera::V1_2::CaptureStartedInfo it2; + it2.streamId_ = 2; + it2.exposureTime_ = 2; + std::vector captureStartedInfo = {}; + captureStartedInfo.push_back(it1); + captureStartedInfo.push_back(it2); + camDevice->OnCaptureStartedV1_2(captureId, captureStartedInfo); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_089, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + int32_t captureId = 0; + const std::vector streamIds = {1, 2}; + camDevice->OnCaptureStarted(captureId, streamIds); + const std::vector captureStartedInfo = {}; + camDevice->OnCaptureStartedV1_2(captureId, captureStartedInfo); + + CaptureEndedInfo it1; + it1.streamId_ = 1; + it1.frameCount_ = 1; + CaptureEndedInfo it2; + it2.streamId_ = 2; + it2.frameCount_ = 2; + std::vector captureEndedInfo = {}; + captureEndedInfo.push_back(it1); + captureEndedInfo.push_back(it2); + camDevice->OnCaptureEnded(captureId, captureEndedInfo); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_090, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + int32_t captureId = 0; + CaptureErrorInfo it1; + it1.streamId_ = 2; + it1.error_ = BUFFER_LOST; + CaptureErrorInfo it2; + it2.streamId_ = 1; + it2.error_ = BUFFER_LOST; + std::vector captureErrorInfo = {}; + captureErrorInfo.push_back(it1); + captureErrorInfo.push_back(it2); + camDevice->OnCaptureError(captureId, captureErrorInfo); + + const std::vector streamIds = {1, 2}; + uint64_t timestamp = 5; + camDevice->OnFrameShutter(captureId, streamIds, timestamp); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_091, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + + std::shared_ptr cameraResult = cameras[0]->GetMetadata(); + camDevice->CheckOnResultData(nullptr); + camDevice->CheckOnResultData(cameraResult); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_092, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + sptr streamRepeat1 = + new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW); + + SketchStatus status = SketchStatus::STARTED; + streamRepeat->repeatStreamType_ = RepeatStreamType::SKETCH; + streamRepeat->parentStreamRepeat_ = streamRepeat1; + streamRepeat->UpdateSketchStatus(status); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_093, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + + SketchStatus status = SketchStatus::STARTED; + streamRepeat->OnSketchStatusChanged(status); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_094, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + + sptr sketchStream = nullptr; + float sketchRatio = 0; + streamRepeat->ForkSketchStreamRepeat(0, 1, sketchStream, sketchRatio); + streamRepeat->ForkSketchStreamRepeat(1, 0, sketchStream, sketchRatio); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_095, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + + float sketchRatio = 0; + streamRepeat->sketchStreamRepeat_ = nullptr; + streamRepeat->RemoveSketchStreamRepeat(); + streamRepeat->UpdateSketchRatio(sketchRatio); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_096, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + + uint32_t interfaceCode = 5; + streamRepeat->OperatePermissionCheck(interfaceCode); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_097, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + std::vector streamInfos = {}; + camSession->GetCurrentStreamInfos(streamInfos); + camSession->AddOutputStream(nullptr); + camSession->RemoveOutputStream(nullptr); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_098, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + camSession->cameraDevice_ = nullptr; + camSession->LinkInputAndOutputs(); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_099, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + bool isNeedUpdate = false; + ColorSpace colorSpace = ColorSpace::SRGB; + ColorSpace captureColorSpace = ColorSpace::SRGB; + camSession->currColorSpace_ = ColorSpace::BT709; + camSession->currCaptureColorSpace_ = ColorSpace::BT709; + camSession->SetColorSpace(colorSpace, captureColorSpace, isNeedUpdate); + camSession->currColorSpace_ = ColorSpace::SRGB; + camSession->SetColorSpace(colorSpace, captureColorSpace, isNeedUpdate); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_100, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + camSession->RestartStreams(); + + ColorSpace colorSpace = ColorSpace::SRGB; + camSession->CheckIfColorSpaceMatchesFormat(colorSpace); + colorSpace = ColorSpace::BT2020_HLG ; + camSession->CheckIfColorSpaceMatchesFormat(colorSpace); + colorSpace = ColorSpace::BT2020_PQ ; + camSession->CheckIfColorSpaceMatchesFormat(colorSpace); + colorSpace = ColorSpace::BT2020_HLG_LIMIT ; + camSession->CheckIfColorSpaceMatchesFormat(colorSpace); + colorSpace = ColorSpace::BT2020_PQ_LIMIT; + camSession->CheckIfColorSpaceMatchesFormat(colorSpace); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_101, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + const uint32_t callingTokenId = 0; + const std::string permissionName = "camera"; + camSession->RegisterPermissionCallback(callingTokenId, permissionName); + camSession->StartUsingPermissionCallback(callingTokenId, permissionName); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_102, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + camSession->SetColorSpaceForStreams(); + + std::vector streamInfos = {}; + camSession->CancelStreamsAndGetStreamInfos(streamInfos); + + camSession->isSessionStarted_ = true; + camSession->RestartStreams(); + + const uint32_t callingTokenId = 0; + const std::string permissionName = "camera"; + std::shared_ptr cameraUseStateChangeCb = + std::make_shared(camSession); + camSession->cameraUseCallbackPtr_ = cameraUseStateChangeCb; + camSession->StartUsingPermissionCallback(callingTokenId, permissionName); +} + +/* + * Feature: coverage + * Function: Test HCaptureSession + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_103, TestSize.Level0) +{ + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + float currentFps = 0; + float currentZoomRatio = 0; + camSession->QueryFpsAndZoomRatio(currentFps, currentZoomRatio); + std::vector crossZoomAndTime = {0, 0}; + int32_t operationMode = 0; + camSession->QueryZoomPerformance(crossZoomAndTime, operationMode); + int32_t smoothZoomType = 0; + float targetZoomRatio = 0; + float duration = 0; + camSession->SetSmoothZoom(smoothZoomType, operationMode, targetZoomRatio, duration); +} + +/* + * Feature: Framework + * Function: Test metadataoutput + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test metadataoutput + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_104, TestSize.Level0) +{ + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr output = cameraManager->CreateMetadataOutput(); + ASSERT_NE(output, nullptr); + sptr metadatOutput = (sptr&)output; + + std::shared_ptr metadataStateCallback = std::make_shared(); + metadatOutput->SetCallback(metadataStateCallback); + + pid_t pid = 0; + metadatOutput->CameraServerDied(pid); +} + +/* + * Feature: coverage + * Function: Test HStreamRepeat + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat + */ +HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_105, TestSize.Level0) +{ + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, format, width, height, RepeatStreamType::PREVIEW); + + StreamInfo_V1_1 streamInfo; + streamRepeat->repeatStreamType_ = RepeatStreamType::SKETCH; + streamRepeat->SetStreamInfo(streamInfo); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_001, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + ASSERT_NE(camDevice, nullptr); + + int32_t ret = camDevice->HCameraDevice::OpenDevice(); + EXPECT_EQ(ret, 0); + + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + + ret = camDevice->HCameraDevice::EnableResult(result); + EXPECT_EQ(ret, 0); + + ret = camDevice->HCameraDevice::DisableResult(result); + EXPECT_EQ(ret, 0); + + sptr streamOperator = camDevice->HCameraDevice::GetStreamOperator(); + EXPECT_TRUE(streamOperator != nullptr); + + ret = camDevice->HCameraDevice::OnError(REQUEST_TIMEOUT, 0); + EXPECT_EQ(ret, 0); + + ret = camDevice->HCameraDevice::CloseDevice(); + EXPECT_EQ(ret, 0); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test dump with args empty + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_002, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); + sptr camService = (sptr &)mockHCameraService; + ASSERT_NE(camService, nullptr); + + std::vector cameraIds = {}; + std::vector> cameraAbilityList = {}; + int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList); + + int fd = 0; + std::vector args = {}; + ret = camService->Dump(fd, args); + EXPECT_EQ(ret, 0); + + input->Close(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_003, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + sptr streamOperatorCb = nullptr; + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + sptr cameraDevice = camInput->GetCameraDevice(); + int32_t ret = camSession->AddInput(cameraDevice); + EXPECT_EQ(ret, 10); + + ret = camSession->RemoveInput(cameraDevice); + EXPECT_EQ(ret, 10); + + ret = camSession->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = camSession->BeginConfig(); + EXPECT_EQ(ret, 10); + + cameraDevice = nullptr; + ret = camSession->AddInput(cameraDevice); + EXPECT_EQ(ret, 2); + + ret = camSession->RemoveInput(cameraDevice); + EXPECT_EQ(ret, 2); + + sptr stream_2 = nullptr; + ret = camSession->AddOutput(StreamType::CAPTURE, stream_2); + EXPECT_EQ(ret, 2); + + ret = camSession->RemoveOutput(StreamType::CAPTURE, stream_2); + EXPECT_EQ(ret, 2); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraService with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_004, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); + sptr cameraService = (sptr &)mockHCameraService; + ASSERT_NE(cameraService, nullptr); + + cameraService->OnStop(); + cameraService->OnStart(); + + sptr Surface = IConsumerSurface::Create(); + sptr Producer = Surface->GetProducer(); + + int32_t height = 0; + int32_t width = PHOTO_DEFAULT_WIDTH; + sptr output = nullptr; + int32_t intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output); + EXPECT_EQ(intResult, 2); + + width = 0; + intResult = cameraService->CreateDeferredPreviewOutput(0, width, height, output); + EXPECT_EQ(intResult, 2); + + Producer = nullptr; + intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + Producer = Surface->GetProducer(); + intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + width = PREVIEW_DEFAULT_WIDTH; + intResult = cameraService->CreatePreviewOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + width = 0; + intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + Producer = nullptr; + intResult = cameraService->CreateVideoOutput(Producer, 0, width, height, output); + EXPECT_EQ(intResult, 2); + + cameraService->OnStart(); + cameraService->OnStop(); + input->Close(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraService with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_005, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); + sptr cameraService = (sptr &)mockHCameraService; + ASSERT_NE(cameraService, nullptr); + + int32_t width = 0; + int32_t height = 0; + + cameraService->OnStop(); + cameraService->OnStart(); + + sptr Surface = IConsumerSurface::Create(); + sptr Producer = Surface->GetProducer(); + + sptr output_1 = nullptr; + int32_t intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); + EXPECT_EQ(intResult, 2); + + width = PHOTO_DEFAULT_WIDTH; + intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); + EXPECT_EQ(intResult, 2); + + Producer = nullptr; + intResult = cameraService->CreatePhotoOutput(Producer, 0, width, height, output_1); + EXPECT_EQ(intResult, 2); + + sptr output_2 = nullptr; + intResult = cameraService->CreateMetadataOutput(Producer, 0, output_2); + EXPECT_EQ(intResult, 2); + + cameraService->OnStart(); + cameraService->OnStop(); + input->Close(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraService with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_006, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); + sptr cameraService = (sptr &)mockHCameraService; + ASSERT_NE(cameraService, nullptr); + + cameraService->OnStop(); + cameraService->OnStart(); + + sptr callback = nullptr; + int32_t intResult = cameraService->SetCallback(callback); + EXPECT_EQ(intResult, 2); + + callback = new(std::nothrow) CameraStatusServiceCallback(cameraManager); + intResult = cameraService->SetCallback(callback); + EXPECT_EQ(intResult, 0); + + sptr deviceObj = camInput->GetCameraDevice(); + ASSERT_NE(deviceObj, nullptr); + + sptr callback_2 = nullptr; + intResult = cameraService->SetMuteCallback(callback_2); + EXPECT_EQ(intResult, 2); + + callback_2 = new(std::nothrow) CameraMuteServiceCallback(cameraManager); + intResult = cameraService->SetMuteCallback(callback_2); + EXPECT_EQ(intResult, 0); + + std::string cameraId = camInput->GetCameraId(); + int activeTime = 0; + EffectParam effectParam = {0, 0, 0}; + + intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSISTENT_ACTIVE_PARAM_OHOS, + activeTime, effectParam); + EXPECT_EQ(intResult, 2); + + cameraId = ""; + intResult = cameraService->SetPrelaunchConfig(cameraId, RestoreParamTypeOhos::TRANSISTENT_ACTIVE_PARAM_OHOS, + activeTime, effectParam); + EXPECT_EQ(intResult, 2); + + cameraService->OnStop(); + input->Close(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test different status with OnReceive + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_007, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + HDI::ServiceManager::V1_0::ServiceStatus status; + + status.serviceName = "1"; + cameraHostManager->OnReceive(status); + + status.deviceClass = DEVICE_CLASS_CAMERA; + status.serviceName = "distributed_camera_service"; + status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START; + cameraHostManager->OnReceive(status); + cameraHostManager->OnReceive(status); + + status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_STOP; + cameraHostManager->OnReceive(status); + + status.status = 4; + cameraHostManager->OnReceive(status); + + input->Close(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CaptureSession with no static capability. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_008, TestSize.Level0) +{ + g_mockFlagWithoutAbt = true; + sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); + + std::vector> cameras = camManager->GetSupportedCameras(); + sptr input = camManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = camManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + EXPECT_EQ(session->BeginConfig(), 0); + + EXPECT_EQ(session->AddInput(input), 0); + EXPECT_EQ(session->AddOutput(photo), 0); + + EXPECT_EQ(session->CommitConfig(), 0); + + sptr cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]); + + std::vector videoStabilizationMode = session->GetSupportedStabilizationMode(); + EXPECT_EQ(videoStabilizationMode.empty(), true); + + int32_t intResult = session->GetSupportedStabilizationMode(videoStabilizationMode); + EXPECT_EQ(intResult, 0); + + std::vector getSupportedExpModes = session->GetSupportedExposureModes(); + EXPECT_EQ(getSupportedExpModes.empty(), true); + + EXPECT_EQ(session->GetSupportedExposureModes(getSupportedExpModes), 0); + + EXPECT_EQ(session->GetExposureMode(), -1); + EXPECT_EQ((session->GetMeteringPoint().x), 0); + EXPECT_EQ((session->GetMeteringPoint().y), 0); + + float exposureValue = session->GetExposureValue(); + EXPECT_EQ(exposureValue, 0); + int32_t exposureValueGet = session->GetExposureValue(exposureValue); + EXPECT_EQ(exposureValueGet, 0); + + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CaptureSession with no static capability. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_009, TestSize.Level0) +{ + g_mockFlagWithoutAbt = true; + sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); + + std::vector> cameras = camManager->GetSupportedCameras(); + + sptr input = camManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = camManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + EXPECT_EQ(session->BeginConfig(), 0); + + EXPECT_EQ(session->AddInput(input), 0); + EXPECT_EQ(session->AddOutput(photo), 0); + + EXPECT_EQ(session->CommitConfig(), 0); + + sptr cameraOutputCapability = camManager->GetSupportedOutputCapability(cameras[0]); + + std::vector supportedFocusModes = session->GetSupportedFocusModes(); + EXPECT_EQ(supportedFocusModes.empty(), true); + EXPECT_EQ(session->GetSupportedFocusModes(supportedFocusModes), 0); + + EXPECT_EQ(session->GetFocusMode(), 0); + + float focalLength = session->GetFocalLength(); + EXPECT_EQ(focalLength, 0); + EXPECT_EQ(session->GetFocalLength(focalLength), 0); + + std::vector supportedFlashModes = session->GetSupportedFlashModes(); + EXPECT_EQ(supportedFlashModes.empty(), true); + EXPECT_EQ(session->GetSupportedFlashModes(supportedFlashModes), 0); + EXPECT_EQ(session->GetFlashMode(), 0); + EXPECT_EQ(session->GetZoomRatio(), 0); + + bool isSupported; + EXPECT_EQ(session->IsVideoStabilizationModeSupported(MIDDLE, isSupported), 0); + EXPECT_EQ(session->SetVideoStabilizationMode(MIDDLE), 0); + EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO), false); + EXPECT_EQ(session->IsFlashModeSupported(FLASH_MODE_AUTO, isSupported), 0); + + sptr photoOutput = (sptr &)photo; + EXPECT_EQ(photoOutput->IsMirrorSupported(), false); + + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test dump with no static capability. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_010, TestSize.Level0) +{ + g_mockFlagWithoutAbt = true; + sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); + std::vector> cameras = camManager->GetSupportedCameras(); + + sptr input = camManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr mockHCameraService = new FakeHCameraService(mockCameraHostManager); + sptr camService = (sptr &)mockHCameraService; + ASSERT_NE(camService, nullptr); + + camService->OnStart(); + + std::vector cameraIds = {}; + std::vector> cameraAbilityList = {}; + int32_t ret = camService->GetCameras(cameraIds, cameraAbilityList); + + int fd = 0; + std::vector args = {}; + ret = camService->Dump(fd, args); + EXPECT_EQ(ret, 0); + + std::u16string cameraServiceInfo = u""; + args.push_back(cameraServiceInfo); + ret = camService->Dump(fd, args); + EXPECT_EQ(ret, 10); + + camService->OnStop(); + input->Close(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamCapture SetRotation with no static capability. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_011, TestSize.Level0) +{ + g_mockFlagWithoutAbt = true; + sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); + std::vector> cameras = camManager->GetSupportedCameras(); + + sptr input = camManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = camManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + std::shared_ptr photoSetting = std::make_shared(); + photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90); + photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); + EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90); + EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); + + EXPECT_CALL(*mockStreamOperator, Capture(_, + matchCaptureSetting(photoSetting->GetCaptureMetadataSetting()), false)); + ret = ((sptr &)photo)->Capture(photoSetting); + EXPECT_EQ(ret, 0); + + input->Close(); + session->Release(); + input->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat with no static capability. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_012, TestSize.Level0) +{ + g_mockFlagWithoutAbt = true; + sptr camManager = new FakeCameraManager(new FakeHCameraService(mockCameraHostManager)); + int32_t format = CAMERA_FORMAT_YUV_420_SP; + int32_t width = PHOTO_DEFAULT_WIDTH; + int32_t height = PHOTO_DEFAULT_HEIGHT; + + std::vector> cameras = camManager->GetSupportedCameras(); + + sptr input = camManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr metadatOutput = camManager->CreateMetadataOutput(); + ASSERT_NE(metadatOutput, nullptr); + + sptr session = camManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + EXPECT_EQ(session->BeginConfig(), 0); + + EXPECT_EQ(session->AddInput(input), 0); + EXPECT_EQ(session->AddOutput(photo), 0); + EXPECT_EQ(session->AddOutput(metadatOutput), 0); + + EXPECT_EQ(session->CommitConfig(), 0); + + sptr Surface = IConsumerSurface::Create(); + sptr producer1 = Surface->GetProducer(); + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer1, format, width, height, RepeatStreamType::PREVIEW); + + std::shared_ptr photoSetting = std::make_shared(); + photoSetting->SetRotation(PhotoCaptureSetting::Rotation_90); + photoSetting->SetQuality(PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); + EXPECT_EQ(photoSetting->GetRotation(), PhotoCaptureSetting::Rotation_90); + EXPECT_EQ(photoSetting->GetQuality(), PhotoCaptureSetting::QUALITY_LEVEL_MEDIUM); + + EXPECT_EQ(streamRepeat->LinkInput(mockStreamOperator, photoSetting->GetCaptureMetadataSetting()), 8); + + EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); + EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); + + EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE); + + EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); + EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); + + input->Close(); + session->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_013, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + std::string permissionName = "permissionName"; + uint32_t callingTokenId = 0; + Security::AccessToken::PermStateChangeScope scopeInfo; + scopeInfo.permList = {permissionName}; + scopeInfo.tokenIDs = {callingTokenId}; + + int32_t permStateChangeType = 0; + Security::AccessToken::PermStateChangeInfo info; + info.permStateChangeType = permStateChangeType; + info.tokenID = Security::AccessToken::INVALID_TOKENID; + info.permissionName = permissionName; + + int32_t permStateChangeType1 = 1; + Security::AccessToken::PermStateChangeInfo info1; + info1.permStateChangeType = permStateChangeType1; + info1.tokenID = Security::AccessToken::INVALID_TOKENID; + info1.permissionName = permissionName; + + std::shared_ptr permissionStatusChangeCb = + std::make_shared(camSession, scopeInfo); + permissionStatusChangeCb->PermStateChangeCallback(info); + permissionStatusChangeCb->PermStateChangeCallback(info); + permissionStatusChangeCb->PermStateChangeCallback(info1); + + std::shared_ptr cameraUseStateChangeCb = + std::make_shared(camSession); + cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, false); + cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, true); + cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, false); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_014, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + ASSERT_NE(camSession, nullptr); + + camSession->BeginConfig(); + camSession->Start(); + + sptr cameraDevice = camInput->GetCameraDevice(); + EXPECT_EQ(camSession->AddInput(cameraDevice), 0); + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + + auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW); + auto streamRepeat1 = new (std::nothrow) HStreamRepeat(producer, 3, 640, 480, RepeatStreamType::PREVIEW); + sptr streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960); + + EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0); + EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat1), 0); + EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); + + CaptureErrorInfo it1; + it1.streamId_ = 2; + it1.error_ = BUFFER_LOST; + CaptureErrorInfo it2; + it2.streamId_ = 1; + it2.error_ = BUFFER_LOST; + std::vector info = {}; + info.push_back(it1); + info.push_back(it2); + camSession->OnCaptureError(0, info); + + std::vector streamIds = {1, 2}; + camSession->OnFrameShutter(0, streamIds, 0); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + + camSession->BeginConfig(); + camSession->Start(); + + sptr cameraDevice = camInput->GetCameraDevice(); + EXPECT_EQ(camSession->AddInput(cameraDevice), 0); + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + sptr streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960); + sptr streamCapture1 = new (std::nothrow) HStreamCapture(producer, 3, 640, 480); + sptr streamRepeat = + new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW); + + EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); + EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture1), 0); + EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0); + + CaptureErrorInfo it1; + it1.streamId_ = 2; + it1.error_ = BUFFER_LOST; + CaptureErrorInfo it2; + it2.streamId_ = 1; + it2.error_ = BUFFER_LOST; + std::vector info = {}; + info.push_back(it1); + info.push_back(it2); + camSession->OnCaptureError(0, info); + + std::vector streamIds = {1, 2}; + camSession->OnFrameShutter(0, streamIds, 0); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, PORTRAIT); + + EXPECT_EQ(camSession->CommitConfig(), CAMERA_INVALID_STATE); + camSession->BeginConfig(); + camSession->Start(); + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + sptr streamCapture= new(std::nothrow) HStreamCapture(producer, 0, 0, 0); + + sptr cameraDevice = camInput->GetCameraDevice(); + EXPECT_EQ(camSession->AddInput(cameraDevice), 0); + EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); + + camSession->CommitConfig(); + + CaptureErrorInfo it1; + it1.streamId_ = 0; + it1.error_ = BUFFER_LOST; + CaptureErrorInfo it2; + it2.streamId_ = 1; + it2.error_ = BUFFER_LOST; + std::vector info = {}; + info.push_back(it1); + info.push_back(it2); + camSession->OnCaptureError(0, info); + + std::vector streamIds = {0, 1, 2}; + camSession->OnFrameShutter(0, streamIds, 0); + camSession->BeginConfig(); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: coverage + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + sptr streamOperatorCb = nullptr; + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + SceneMode mode = PORTRAIT; + sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + sptr camSession1 = new (std::nothrow) HCaptureSession(12, mode); + ASSERT_NE(camSession, nullptr); + EXPECT_EQ(camSession->Start(), CAMERA_INVALID_STATE); + camSession1->Start(); + + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + sptr streamRepeat = new (std::nothrow) HStreamRepeat(producer, 0, 0, 0, RepeatStreamType::PREVIEW); + sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, 0); + EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE); + EXPECT_EQ(camSession->RemoveOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE); + + sptr cameraDevice = camInput->GetCameraDevice(); camSession->BeginConfig(); camSession->Start(); + camSession->AddOutput(StreamType::METADATA, streamMetadata); + camSession->AddOutput(StreamType::METADATA, streamMetadata); + camSession->RemoveOutput(StreamType::METADATA, streamMetadata); + camSession->AddInput(cameraDevice); + + camSession->AddInput(cameraDevice); + + sptr callback1 = nullptr; + camSession->SetCallback(callback1); + + std::string dumpString = "HCaptureSession"; + camSession->dumpSessionInfo(dumpString); + camSession->dumpSessions(dumpString); + + input->Close(); + camSession->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test GetExposureValue and SetExposureBias with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_018, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + session->LockForControl(); + + Point exposurePoint = {1.0, 2.0}; + session->SetMeteringPoint(exposurePoint); + session->SetMeteringPoint(exposurePoint); + + ExposureMode exposure = EXPOSURE_MODE_AUTO; + session->SetExposureMode(exposure); + + ret = session->GetExposureMode(exposure); + EXPECT_EQ(ret, 0); + + ExposureMode exposureMode = session->GetExposureMode(); + int32_t setExposureMode = session->SetExposureMode(exposureMode); + EXPECT_EQ(setExposureMode, 0); + + session->UnlockForControl(); + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test GetMeteringPoint and GetMeteringPoint with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_019, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + session->LockForControl(); + + Point exposurePointGet = session->GetMeteringPoint(); + int32_t getMeteringPoint = session->GetMeteringPoint(exposurePointGet); + EXPECT_EQ(getMeteringPoint, 0); + + float exposureValue = session->GetExposureValue(); + int32_t exposureValueGet = session->GetExposureValue(exposureValue); + EXPECT_EQ(exposureValueGet, 0); + + int32_t setExposureBias = session->SetExposureBias(exposureValue); + EXPECT_EQ(setExposureBias, 0); + + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CaptureSession with anomalous branch + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_020, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + std::shared_ptr metadata = cameras[0]->GetMetadata(); + std::shared_ptr exposureCallback = std::make_shared(); + session->SetExposureCallback(exposureCallback); + session->ProcessAutoExposureUpdates(metadata); + + std::shared_ptr focusCallback = std::make_shared(); + session->SetFocusCallback(focusCallback); + session->ProcessAutoFocusUpdates(metadata); + + std::vector getSupportedFocusModes = session->GetSupportedFocusModes(); + EXPECT_EQ(getSupportedFocusModes.empty(), false); + int32_t supportedFocusModesGet = session->GetSupportedFocusModes(getSupportedFocusModes); + EXPECT_EQ(supportedFocusModesGet, 0); + + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_021, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + std::vector getSupportedFlashModes = session->GetSupportedFlashModes(); + EXPECT_EQ(getSupportedFlashModes.empty(), false); + int32_t getSupportedFlashMode = session->GetSupportedFlashModes(getSupportedFlashModes); + EXPECT_EQ(getSupportedFlashMode, 0); + + FlashMode flashMode = session->GetFlashMode(); + int32_t flashModeGet = session->GetFlashMode(flashMode); + EXPECT_EQ(flashModeGet, 0); + int32_t setFlashMode = session->SetFlashMode(flashMode); + EXPECT_EQ(setFlashMode, 0); + + input->Close(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test SetFocusPoint & GetFousPoint with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_022, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + + ret = session->AddOutput(photo); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + EXPECT_EQ(ret, 0); + + Point FocusPoint = {1.0, 2.0}; + session->LockForControl(); + session->SetFocusPoint(FocusPoint); + session->UnlockForControl(); + + session->GetFocusPoint(FocusPoint); + + session->RemoveInput(input); + session->RemoveOutput(photo); + photo->Release(); + input->Close(); + input->Release(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch. + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test CaptureSession with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_023, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr photo = CreatePhotoOutput(); + ASSERT_NE(photo, nullptr); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + + EXPECT_EQ(session->BeginConfig(), 0); + + EXPECT_EQ(session->AddInput(input), 0); + EXPECT_EQ(session->AddOutput(photo), 0); + + EXPECT_EQ(session->CommitConfig(), 0); + + EXPECT_EQ(session->GetFocusMode(), 2); + + session->LockForControl(); + + FlashMode flash = FLASH_MODE_ALWAYS_OPEN; + session->SetFlashMode(flash); + session->SetFlashMode(flash); + + FocusMode focus = FOCUS_MODE_CONTINUOUS_AUTO; + session->SetFocusMode(focus); + session->SetFocusMode(focus); + + ExposureMode exposure = EXPOSURE_MODE_AUTO; + session->SetExposureMode(exposure); + + float zoomRatioRange = session->GetZoomRatio(); + session->SetZoomRatio(zoomRatioRange); + session->SetZoomRatio(zoomRatioRange); + + session->UnlockForControl(); + + EXPECT_EQ(session->GetFocusMode(focus), 0); + + cameraManager->GetSupportedOutputCapability(cameras[0], 0); + + VideoStabilizationMode stabilizationMode = MIDDLE; + session->GetActiveVideoStabilizationMode(); + session->GetActiveVideoStabilizationMode(stabilizationMode); + session->SetVideoStabilizationMode(stabilizationMode); + + input->Close(); + input->Release(); + session->Release(); +} + +/* + * Feature: Framework + * Function: Test IsCameraNeedClose & CheckPermission + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test IsCameraNeedClose & CheckPermission + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_024, TestSize.Level0) +{ + CamRetCode rc1 = HDI::Camera::V1_0::CAMERA_BUSY; + EXPECT_EQ(HdiToServiceError(rc1), CAMERA_DEVICE_BUSY); + CamRetCode rc2 = HDI::Camera::V1_0::INVALID_ARGUMENT; + EXPECT_EQ(HdiToServiceError(rc2), CAMERA_INVALID_ARG); + CamRetCode rc3 = HDI::Camera::V1_0::CAMERA_CLOSED; + EXPECT_EQ(HdiToServiceError(rc3), CAMERA_DEVICE_CLOSED); + CreateMsg(NULL); + + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + pid_t pid = IPCSkeleton::GetCallingPid(); + IsCameraNeedClose(callerToken, pid, pid); + IsCameraNeedClose(123, pid, pid); + CheckPermission("unittest", 0); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_025, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); - sptr cameraDevice = camInput->GetCameraDevice(); - EXPECT_EQ(camSession->AddInput(cameraDevice), 0); + sptr streamOperator = nullptr; + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr callback1 = new(std::nothrow) CameraDeviceServiceCallback(input); + + camDevice->EnableResult(result); + camDevice->DisableResult(result); + + int32_t ret = camDevice->OpenDevice(); + EXPECT_EQ(ret, 0); + camDevice->UpdateSetting(nullptr); + sptr callback = nullptr; + camDevice->SetCallback(callback); + camDevice->GetSettings(); + camDevice->SetCallback(callback1); + camDevice->OnError(REQUEST_TIMEOUT, 0) ; + camDevice->OnError(DEVICE_PREEMPT, 0) ; + camDevice->OnError(DRIVER_ERROR, 0) ; + + EXPECT_EQ(camDevice->CloseDevice(), 0); + EXPECT_EQ(camDevice->GetEnabledResults(result), 11); + EXPECT_EQ(camDevice->CloseDevice(), 0); + camDevice->~HCameraDevice(); +} + +/* + * Feature: Framework + * Function: Test HStreamRepeat & HStreamCommon + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamRepeat & HStreamCommon + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_026, TestSize.Level0) +{ + int32_t format = 0; + int32_t width = 0; + int32_t height = 0; + std::string dumpString ="HStreamRepeat"; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr callback = nullptr; + sptr producer = nullptr; + sptr Surface = IConsumerSurface::Create(); + sptr producer1 = Surface->GetProducer(); + sptr streamRepeat = + new (std::nothrow) HStreamRepeat(nullptr, format, width, height, RepeatStreamType::PREVIEW); + + EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); + EXPECT_EQ(streamRepeat->SetCallback(callback), CAMERA_INVALID_ARG); + EXPECT_EQ(streamRepeat->OnFrameError(BUFFER_LOST), 0); + EXPECT_EQ(streamRepeat->AddDeferredSurface(producer), CAMERA_INVALID_ARG); + streamRepeat->DumpStreamInfo(dumpString); + EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + std::shared_ptr metadata1 = nullptr; + EXPECT_EQ(streamRepeat->LinkInput(mockStreamOperator, metadata), CAMERA_OK); + streamRepeat->LinkInput(mockStreamOperator, metadata1); + mockStreamOperator = nullptr; + streamRepeat->LinkInput(mockStreamOperator, metadata); + streamRepeat->DumpStreamInfo(dumpString); + EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); +} +/* + * Feature: Framework + * Function: Test HStreamMetadata & HStreamCommon + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamMetadata & HStreamCommon + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_027, TestSize.Level0) +{ + int32_t format = 0; + std::string dumpString ="HStreamMetadata"; + std::vector> cameras = cameraManager->GetSupportedCameras(); sptr Surface = IConsumerSurface::Create(); sptr producer = Surface->GetProducer(); + sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, format); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + std::shared_ptr metadata1 = nullptr; + streamMetadata->LinkInput(mockStreamOperator, metadata); + streamMetadata->LinkInput(mockStreamOperator, metadata1); + mockStreamOperator = nullptr; + streamMetadata->LinkInput(mockStreamOperator, metadata); + streamMetadata->Stop(); + streamMetadata->Start(); + streamMetadata->DumpStreamInfo(dumpString); + streamMetadata->Start(); + streamMetadata->Stop(); +} - auto streamRepeat = new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW); - auto streamRepeat1 = new (std::nothrow) HStreamRepeat(producer, 3, 640, 480, RepeatStreamType::PREVIEW); - sptr streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960); +/* + * Feature: Framework + * Function: Test HStreamMetadata & HStreamCommon + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamMetadata & HStreamCommon + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_028, TestSize.Level0) +{ + int32_t format = 0; + std::string dumpString ="HStreamMetadata"; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, format); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + streamMetadata->Start(); + streamMetadata->LinkInput(mockStreamOperator, metadata); + streamMetadata->Stop(); +} - EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0); - EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat1), 0); - EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); +/* + * Feature: Framework + * Function: Test HStreamCapture & HStreamCommon + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HStreamCapture & HStreamCommon + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_029, TestSize.Level0) +{ + int32_t format = 0; + int32_t width = 0; + int32_t height = 0; + int32_t captureId = 0; + int32_t frameCount = 0; + uint64_t timestamp = 0; + std::string dumpString ="hstream_capture"; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr callback = nullptr; + sptr Surface = IConsumerSurface::Create(); + sptr producer = Surface->GetProducer(); + sptr producer1 = nullptr; + sptr streamCapture= new(std::nothrow) HStreamCapture(producer, format, width, height); + std::shared_ptr metadata = cameras[0]->GetMetadata(); + EXPECT_EQ(streamCapture->SetThumbnail(false, producer1), CAMERA_OK); + EXPECT_EQ(streamCapture->SetThumbnail(false, producer), CAMERA_OK); + EXPECT_EQ(streamCapture->SetThumbnail(true, producer1), CAMERA_OK); + streamCapture->DumpStreamInfo(dumpString); + EXPECT_EQ(streamCapture->SetThumbnail(true, producer), CAMERA_OK); + streamCapture->SetRotation(metadata); + mockStreamOperator = nullptr; + streamCapture->LinkInput(mockStreamOperator, metadata); + EXPECT_EQ(streamCapture->Capture(metadata), CAMERA_INVALID_STATE); + streamCapture->PrintDebugLog(metadata); + EXPECT_EQ(streamCapture->SetCallback(callback), CAMERA_INVALID_ARG); + EXPECT_EQ(streamCapture->OnCaptureEnded(captureId, frameCount), CAMERA_OK); + EXPECT_EQ(streamCapture->OnCaptureError(captureId, frameCount), CAMERA_OK); + EXPECT_EQ(streamCapture->OnCaptureError(captureId, BUFFER_LOST), CAMERA_OK); + EXPECT_EQ(streamCapture->OnFrameShutter(captureId, timestamp), CAMERA_OK); + streamCapture->DumpStreamInfo(dumpString); + + EXPECT_EQ(streamCapture->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test HCameraDevice + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraDevice + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_030, TestSize.Level0) +{ + std::vector result; + result.push_back(OHOS_SENSOR_EXPOSURE_TIME); + result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr cameraHostManager = (sptr &)mockCameraHostManager; + std::string cameraId = cameras[0]->GetID(); + uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); + uint32_t callerToken1 = 3; + sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + sptr camDevice1 = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken1); + + sptr streamOperator = nullptr; + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr callback1 = new(std::nothrow) CameraDeviceServiceCallback(input); + camDevice->EnableResult(result); + camDevice->DisableResult(result); + + int32_t ret = camDevice->OpenDevice(); + EXPECT_EQ(ret, 0); + camDevice->Open(); + g_getCameraAbilityerror = true; + camDevice->GetSettings(); + g_openCameraDevicerror = true; + EXPECT_EQ(camDevice->OpenDevice(), 11); + + camDevice->CloseDevice(); +} + +/* + * Feature: Framework + * Function: Test anomalous branch + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test HCameraHostManager with anomalous branch. + */ +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_031, TestSize.Level0) +{ + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + + sptr input = cameraManager->CreateCameraInput(cameras[0]); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + std::vector cameraIds = {}; + sptr cameraHostManager = (sptr &)mockCameraHostManager; + ASSERT_NE(cameraHostManager, nullptr); + + std::string cameraId = cameras[0]->GetID(); + EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameras(cameraIds), 0); + std::shared_ptr ability = cameras[0]->GetMetadata(); + EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2); + EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2); + + cameraId = "HCameraHostManager"; + + cameraHostManager->AddCameraDevice(cameraId, nullptr); + EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, true), 2); + + cameraHostManager->CloseCameraDevice(cameraId); + + ability = cameras[0]->GetMetadata(); + EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2); + + EXPECT_EQ(cameraHostManager->HCameraHostManager::GetVersionByCamera(cameraId), 0); + + sptr pDevice; + cameraHostManager->HCameraHostManager::OpenCameraDevice(cameraId, nullptr, pDevice); + + cameraId = cameras[0]->GetID(); + HDI::ServiceManager::V1_0::ServiceStatus status; + status.deviceClass = DEVICE_CLASS_CAMERA; + status.serviceName = "distributed_camera_service"; + status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START; + cameraHostManager->HCameraHostManager::OnReceive(status); + + EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2); - CaptureErrorInfo it1; - it1.streamId_ = 2; - it1.error_ = BUFFER_LOST; - CaptureErrorInfo it2; - it2.streamId_ = 1; - it2.error_ = BUFFER_LOST; - std::vector info = {}; - info.push_back(it1); - info.push_back(it2); - camSession->OnCaptureError(0, info); + std::shared_ptr mockStatusCallback = + std::make_shared(); + sptr mockCameraHostManager_2 = + new (std::nothrow) MockHCameraHostManager(mockStatusCallback); + sptr cameraHostManager_2 = (sptr &)mockCameraHostManager_2; - std::vector streamIds = {1, 2}; - camSession->OnFrameShutter(0, streamIds, 0); + cameraHostManager_2->AddCameraDevice(cameraId, nullptr); input->Close(); - camSession->Release(); } + /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch. + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_032, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); + Size previewSize = {.width = 1440, .height = 1080}; + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3102,59 +5452,76 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - SceneMode mode = PORTRAIT; - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; - camSession->BeginConfig(); - camSession->Start(); + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize); + ASSERT_NE(sketchWrapper, nullptr); - sptr cameraDevice = camInput->GetCameraDevice(); - EXPECT_EQ(camSession->AddInput(cameraDevice), 0); + previewOutput->IsSketchSupported(); + int32_t ret = session->BeginConfig(); - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr streamCapture = new (std::nothrow) HStreamCapture(producer, 4, 1280, 960); - sptr streamCapture1 = new (std::nothrow) HStreamCapture(producer, 3, 640, 480); - sptr streamRepeat = - new (std::nothrow) HStreamRepeat(producer, 4, 1280, 960, RepeatStreamType::PREVIEW); + previewOutput->AttachSketchSurface(surface); + previewOutput->StartSketch(); + previewOutput->StopSketch(); - EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); - EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture1), 0); - EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), 0); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); + previewOutput->IsSketchSupported(); - CaptureErrorInfo it1; - it1.streamId_ = 2; - it1.error_ = BUFFER_LOST; - CaptureErrorInfo it2; - it2.streamId_ = 1; - it2.error_ = BUFFER_LOST; - std::vector info = {}; - info.push_back(it1); - info.push_back(it2); - camSession->OnCaptureError(0, info); + previewOutput->CreateSketchWrapper(previewSize); + previewOutput->GetSketchRatio(); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); - std::vector streamIds = {1, 2}; - camSession->OnFrameShutter(0, streamIds, 0); + EXPECT_EQ(ret, 0); + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); - input->Close(); - camSession->Release(); + previewOutput->SetSession(session); + previewOutput->AttachSketchSurface(surface); + previewOutput->CreateSketchWrapper(previewSize); + previewOutput->GetSketchRatio(); + previewOutput->GetDeviceMetadata(); + previewOutput->FindSketchSize(); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); + previewOutput->AttachSketchSurface(surface); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + + ret = session->CommitConfig(); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + + previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + previewOutput->AttachSketchSurface(surface); + + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch. + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_033, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3164,56 +5531,45 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, PORTRAIT); - - EXPECT_EQ(camSession->CommitConfig(), CAMERA_INVALID_STATE); - camSession->BeginConfig(); - camSession->Start(); - - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr streamCapture= new(std::nothrow) HStreamCapture(producer, 0, 0, 0); - - sptr cameraDevice = camInput->GetCameraDevice(); - EXPECT_EQ(camSession->AddInput(cameraDevice), 0); - EXPECT_EQ(camSession->AddOutput(StreamType::CAPTURE, streamCapture), 0); - - camSession->CommitConfig(); - - CaptureErrorInfo it1; - it1.streamId_ = 0; - it1.error_ = BUFFER_LOST; - CaptureErrorInfo it2; - it2.streamId_ = 1; - it2.error_ = BUFFER_LOST; - std::vector info = {}; - info.push_back(it1); - info.push_back(it2); - camSession->OnCaptureError(0, info); - - std::vector streamIds = {0, 1, 2}; - camSession->OnFrameShutter(0, streamIds, 0); - camSession->BeginConfig(); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; + previewOutput->IsSketchSupported(); + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); - input->Close(); - camSession->Release(); + previewOutput->SetSession(session); + previewOutput->FindSketchSize(); + previewOutput->EnableSketch(true); + ret = session->CommitConfig(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* - * Feature: coverage - * Function: Test anomalous branch + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCaptureSession with anomalous branch. + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_034, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - + Size previewSize = {.width = 1440, .height = 1080}; sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3223,58 +5579,74 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr cameraHostManager = (sptr &)mockCameraHostManager; - sptr streamOperatorCb = nullptr; - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - SceneMode mode = PORTRAIT; - sptr camSession = new (std::nothrow) HCaptureSession(callerToken, mode); - sptr camSession1 = new (std::nothrow) HCaptureSession(12, mode); - ASSERT_NE(camSession, nullptr); - EXPECT_EQ(camSession->Start(), CAMERA_INVALID_STATE); - camSession1->Start(); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; + + previewOutput->IsSketchSupported(); + std::string eventString = "test"; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); + eventString = "sketchAvailable"; + previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); + previewOutput->CameraServerDied(0); + std::shared_ptr previewStateCallback = std::make_shared("PreviewStateCallback"); + previewOutput->SetCallback(previewStateCallback); + previewOutput->CameraServerDied(0); - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr streamRepeat = new (std::nothrow) HStreamRepeat(producer, 0, 0, 0, RepeatStreamType::PREVIEW); - sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, 0); - EXPECT_EQ(camSession->AddOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE); - EXPECT_EQ(camSession->RemoveOutput(StreamType::REPEAT, streamRepeat), CAMERA_INVALID_STATE); + int32_t ret = session->BeginConfig(); + EXPECT_EQ(ret, 0); + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); - sptr cameraDevice = camInput->GetCameraDevice(); - camSession->BeginConfig(); - camSession->Start(); - camSession->AddOutput(StreamType::METADATA, streamMetadata); - camSession->AddOutput(StreamType::METADATA, streamMetadata); - camSession->RemoveOutput(StreamType::METADATA, streamMetadata); - camSession->AddInput(cameraDevice); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); - camSession->AddInput(cameraDevice); + previewOutput->SetSession(session); + previewOutput->FindSketchSize(); - sptr callback1 = nullptr; - camSession->SetCallback(callback1); + eventString = "test"; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); + eventString = "sketchAvailable"; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); - std::string dumpString = "HCaptureSession"; - camSession->dumpSessionInfo(dumpString); - camSession->dumpSessions(dumpString); + ret = session->CommitConfig(); - input->Close(); - camSession->Release(); + eventString = "test"; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); + eventString = "sketchAvailable"; + previewOutput->OnNativeRegisterCallback(eventString); + previewOutput->OnNativeUnregisterCallback(eventString); + + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test sketchWrapper * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test GetExposureValue and SetExposureBias with anomalous branch. + * CaseDescription: Test sketchWrapper with anomalous branch */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_018, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_035, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - + Size previewSize = {.width = 1440, .height = 1080}; sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3284,59 +5656,89 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_018, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); - int32_t ret = session->BeginConfig(); + std::shared_ptr deviceMetadata = cameras[0]->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); + int32_t modeName = session->GetFeaturesMode(); + CameraFormat previewFormat = CAMERA_FORMAT_YCBCR_420_888; + Profile previewProfile = Profile(previewFormat, previewSize); + sptr preview = cameraManager->CreatePreviewOutput(previewProfile, surface); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; + + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize); + ASSERT_NE(sketchWrapper, nullptr); + std::shared_ptr setCallback = std::make_shared("PreviewStateCallback"); + ASSERT_NE(setCallback, nullptr); + camera_metadata_item_t item; + int ret = OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item); + + sketchWrapper->Init(deviceMetadata, modeName); + sketchWrapper->AttachSketchSurface(surface); + sketchWrapper->UpdateSketchRatio(1.0f); + sketchWrapper->SetPreviewStateCallback(setCallback); + sketchWrapper->OnSketchStatusChanged(0); + sketchWrapper->OnSketchStatusChanged(SketchStatus::STARTED, 0); + sketchWrapper->OnSketchStatusChanged(SketchStatus::STOPED, 0); + sketchWrapper->currentSketchStatusData_.sketchRatio = 1.0f; + sketchWrapper->OnSketchStatusChanged(modeName); + sketchWrapper->OnSketchStatusChanged(SketchStatus::STOPED, 1.0f); + sketchWrapper->UpdateSketchReferenceFovRatio(item, SketchWrapper::g_sketchReferenceFovRatioMap_); + auto sketchReferenceFovRangeVec = std::vector(5); + SketchWrapper::SketchReferenceFovRange sketchReferenceFovRange = {.zoomMin = -1.0f, .zoomMax = -1.0f, .referenceValue = -1.0f}; + sketchReferenceFovRangeVec[0] = sketchReferenceFovRange; + sketchReferenceFovRange = {.zoomMin = -1.0f, .zoomMax = 100.0f, .referenceValue = -1.0f}; + SketchWrapper::g_sketchReferenceFovRatioMap_[-1] = sketchReferenceFovRangeVec; + sketchWrapper->GetSketchReferenceFovRatio(-1, -1.0f); + sketchReferenceFovRangeVec[1] = sketchReferenceFovRange; + sketchReferenceFovRange = {.zoomMin = 100.0f, .zoomMax = 1.0f, .referenceValue = -1.0f}; + sketchReferenceFovRangeVec[2] = sketchReferenceFovRange; + sketchReferenceFovRange = {.zoomMin = 100.0f, .zoomMax = 100.0f, .referenceValue = -1.0f}; + sketchReferenceFovRangeVec[3] = sketchReferenceFovRange; + sketchReferenceFovRange = {.zoomMin = 100.0f, .zoomMax = 200.0f, .referenceValue = -1.0f}; + sketchReferenceFovRangeVec[4] = sketchReferenceFovRange; + SketchWrapper::g_sketchReferenceFovRatioMap_[100] = sketchReferenceFovRangeVec; + sketchWrapper->GetSketchReferenceFovRatio(100, -1.0f); + sketchWrapper->GetSketchReferenceFovRatio(100, 200.0f); + sketchWrapper->GetSketchReferenceFovRatio(100, 100.0f); + sketchWrapper->UpdateSketchReferenceFovRatio(item, SketchWrapper::g_sketchReferenceFovRatioMap_); + + ret = session->BeginConfig(); EXPECT_EQ(ret, 0); - ret = session->AddInput(input); EXPECT_EQ(ret, 0); - ret = session->AddOutput(photo); + ret = session->AddOutput(preview); EXPECT_EQ(ret, 0); + previewOutput->SetSession(session); ret = session->CommitConfig(); - EXPECT_EQ(ret, 0); - - session->LockForControl(); - - Point exposurePoint = {1.0, 2.0}; - session->SetMeteringPoint(exposurePoint); - session->SetMeteringPoint(exposurePoint); - - ExposureMode exposure = EXPOSURE_MODE_AUTO; - session->SetExposureMode(exposure); - - ret = session->GetExposureMode(exposure); - EXPECT_EQ(ret, 0); - - ExposureMode exposureMode = session->GetExposureMode(); - int32_t setExposureMode = session->SetExposureMode(exposureMode); - EXPECT_EQ(setExposureMode, 0); - - session->UnlockForControl(); - input->Close(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test PreviewOutput * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test GetMeteringPoint and GetMeteringPoint with anomalous branch. + * CaseDescription: Test PreviewOutput in ~PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_019, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_036, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); + Size previewSize = {.width = 1440, .height = 1080}; sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3346,55 +5748,45 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_019, TestSize.Level camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); - ret = session->AddInput(input); - EXPECT_EQ(ret, 0); - - ret = session->AddOutput(photo); + ret = session->AddOutput(preview); EXPECT_EQ(ret, 0); ret = session->CommitConfig(); - EXPECT_EQ(ret, 0); - session->LockForControl(); - - Point exposurePointGet = session->GetMeteringPoint(); - int32_t getMeteringPoint = session->GetMeteringPoint(exposurePointGet); - EXPECT_EQ(getMeteringPoint, 0); - - float exposureValue = session->GetExposureValue(); - int32_t exposureValueGet = session->GetExposureValue(exposureValue); - EXPECT_EQ(exposureValueGet, 0); - - int32_t setExposureBias = session->SetExposureBias(exposureValue); - EXPECT_EQ(setExposureBias, 0); - - input->Close(); + previewOutput->~PreviewOutput(); + previewOutput->SetSession(session); + previewOutput->AttachSketchSurface(surface); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); + previewOutput->OnNativeRegisterCallback("sketchAvailable"); + input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test CaptureSession with anomalous branch + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_020, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_037, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - + Size previewSize = {.width = 1440, .height = 1080}; sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3403,57 +5795,62 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_020, TestSize.Level std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - + + std::shared_ptr deviceMetadata = cameras[0]->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); + camera_metadata_item_t item; + OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item); sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; + SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize); + ASSERT_NE(sketchWrapper, nullptr); int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); - ret = session->AddInput(input); EXPECT_EQ(ret, 0); - - ret = session->AddOutput(photo); - EXPECT_EQ(ret, 0); - - ret = session->CommitConfig(); + ret = session->AddOutput(preview); EXPECT_EQ(ret, 0); - std::shared_ptr metadata = cameras[0]->GetMetadata(); - std::shared_ptr exposureCallback = std::make_shared(); - session->SetExposureCallback(exposureCallback); - session->ProcessAutoExposureUpdates(metadata); - - std::shared_ptr focusCallback = std::make_shared(); - session->SetFocusCallback(focusCallback); - session->ProcessAutoFocusUpdates(metadata); + item.count = 0; + previewOutput->OnMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item); + item.count = 1; + previewOutput->OnMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item); + previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); - std::vector getSupportedFocusModes = session->GetSupportedFocusModes(); - EXPECT_EQ(getSupportedFocusModes.empty(), false); - int32_t supportedFocusModesGet = session->GetSupportedFocusModes(getSupportedFocusModes); - EXPECT_EQ(supportedFocusModesGet, 0); + previewOutput->SetSession(nullptr); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); + previewOutput->OnMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item); + previewOutput->SetSession(session); + previewOutput->OnMetadataChanged(OHOS_ABILITY_BEAUTY_FACE_SLENDER_VALUES, item); + previewOutput->OnSketchStatusChanged(SketchStatus::STOPED); + + ret = session->CommitConfig(); - input->Close(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test CaptureSession with anomalous branch. + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_021, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_038, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - + Size previewSize = {.width = 1440, .height = 1080}; sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3462,55 +5859,55 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_021, TestSize.Level std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - + + std::shared_ptr deviceMetadata = cameras[0]->GetMetadata(); + ASSERT_NE(deviceMetadata, nullptr); + camera_metadata_item_t item; + OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item); sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); - + CameraFormat previewFormat = CAMERA_FORMAT_YCBCR_420_888; + Profile previewProfile = Profile(previewFormat, previewSize); + sptr preview = cameraManager->CreatePreviewOutput(previewProfile, surface); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; + previewOutput->IsSketchSupported(); + previewOutput->previewProfile_.format_ = CAMERA_FORMAT_YUV_420_SP; + previewOutput->IsSketchSupported(); + previewOutput->previewProfile_.format_ = CAMERA_FORMAT_JPEG; + previewOutput->IsSketchSupported(); + int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); - ret = session->AddInput(input); EXPECT_EQ(ret, 0); - - ret = session->AddOutput(photo); + ret = session->AddOutput(preview); EXPECT_EQ(ret, 0); ret = session->CommitConfig(); - EXPECT_EQ(ret, 0); - - std::vector getSupportedFlashModes = session->GetSupportedFlashModes(); - EXPECT_EQ(getSupportedFlashModes.empty(), false); - int32_t getSupportedFlashMode = session->GetSupportedFlashModes(getSupportedFlashModes); - EXPECT_EQ(getSupportedFlashMode, 0); - - FlashMode flashMode = session->GetFlashMode(); - int32_t flashModeGet = session->GetFlashMode(flashMode); - EXPECT_EQ(flashModeGet, 0); - int32_t setFlashMode = session->SetFlashMode(flashMode); - EXPECT_EQ(setFlashMode, 0); - input->Close(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test SetFocusPoint & GetFousPoint with anomalous branch. + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in PreviewOutput */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_022, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_039, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); + Size previewSize = {.width = 1440, .height = 1080}; EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); @@ -3518,54 +5915,52 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_022, TestSize.Level std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - + sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto previewOutput = (sptr&)preview; int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); - ret = session->AddInput(input); EXPECT_EQ(ret, 0); - - ret = session->AddOutput(photo); + ret = session->AddOutput(preview); EXPECT_EQ(ret, 0); - ret = session->CommitConfig(); - EXPECT_EQ(ret, 0); - - Point FocusPoint = {1.0, 2.0}; - session->LockForControl(); - session->SetFocusPoint(FocusPoint); - session->UnlockForControl(); - - session->GetFocusPoint(FocusPoint); + previewOutput->SetSession(session); + + previewOutput->AttachSketchSurface(surface); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); + previewOutput->AttachSketchSurface(surface); + previewOutput->AttachSketchSurface(nullptr); + previewOutput->StartSketch(); + previewOutput->StopSketch(); + previewOutput->OnNativeRegisterCallback("sketchAvailable"); + session->RemoveOutput(preview); session->RemoveInput(input); - session->RemoveOutput(photo); - photo->Release(); - input->Close(); + preview->Release(); input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch. + * Function: Test captureSession_ * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test CaptureSession with anomalous branch. + * CaseDescription: Test if captureSession_ == nullptr in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_023, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_040, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3574,312 +5969,344 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_023, TestSize.Level std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); - - sptr photo = CreatePhotoOutput(); - ASSERT_NE(photo, nullptr); - + sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto appCallback = std::make_shared(); - EXPECT_EQ(session->BeginConfig(), 0); - - EXPECT_EQ(session->AddInput(input), 0); - EXPECT_EQ(session->AddOutput(photo), 0); - - EXPECT_EQ(session->CommitConfig(), 0); - - EXPECT_EQ(session->GetFocusMode(), 2); - - session->LockForControl(); - - FlashMode flash = FLASH_MODE_ALWAYS_OPEN; - session->SetFlashMode(flash); - session->SetFlashMode(flash); - - FocusMode focus = FOCUS_MODE_CONTINUOUS_AUTO; - session->SetFocusMode(focus); - session->SetFocusMode(focus); - - ExposureMode exposure = EXPOSURE_MODE_AUTO; - session->SetExposureMode(exposure); - - float zoomRatioRange = session->GetZoomRatio(); - session->SetZoomRatio(zoomRatioRange); - session->SetZoomRatio(zoomRatioRange); - - session->UnlockForControl(); - - EXPECT_EQ(session->GetFocusMode(focus), 0); - - cameraManager->GetSupportedOutputCapability(cameras[0], 0); + session->BeginConfig(); + session->CameraServerDied(0); + session->appCallback_ = appCallback; + session->CameraServerDied(0); + session->captureSession_ = nullptr; + session->CameraServerDied(0); + session->appCallback_ = nullptr; - VideoStabilizationMode stabilizationMode = MIDDLE; - session->GetActiveVideoStabilizationMode(); - session->GetActiveVideoStabilizationMode(stabilizationMode); - session->SetVideoStabilizationMode(stabilizationMode); + session->AddInput(input); + session->AddOutput(preview); + session->CommitConfig(); - input->Close(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); input->Release(); session->Release(); } /* * Feature: Framework - * Function: Test IsCameraNeedClose & CheckPermission + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test IsCameraNeedClose & CheckPermission + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_024, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_041, TestSize.Level0) { - CamRetCode rc1 = HDI::Camera::V1_0::CAMERA_BUSY; - EXPECT_EQ(HdiToServiceError(rc1), CAMERA_DEVICE_BUSY); - CamRetCode rc2 = HDI::Camera::V1_0::INVALID_ARGUMENT; - EXPECT_EQ(HdiToServiceError(rc2), CAMERA_INVALID_ARG); - CamRetCode rc3 = HDI::Camera::V1_0::CAMERA_CLOSED; - EXPECT_EQ(HdiToServiceError(rc3), CAMERA_DEVICE_CLOSED); - CreateMsg(NULL); + InSequence s; + std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + ASSERT_NE(input, nullptr); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - pid_t pid = IPCSkeleton::GetCallingPid(); - IsCameraNeedClose(callerToken, pid, pid); - IsCameraNeedClose(123, pid, pid); - CheckPermission("unittest", 0); -} + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); -/* - * Feature: Framework - * Function: Test anomalous branch - * SubFunction: NA - * FunctionPoints: NA - * EnvConditions: NA - * CaseDescription: Test HCameraDevice with anomalous branch. - */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_025, TestSize.Level0) -{ - std::vector result; - result.push_back(OHOS_SENSOR_EXPOSURE_TIME); - result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); + session->PrepareZoom(); + session->UnPrepareZoom(); - std::vector> cameras = cameraManager->GetSupportedCameras(); + int32_t ret = session->BeginConfig(); + session->PrepareZoom(); + session->UnPrepareZoom(); - sptr cameraHostManager = (sptr &)mockCameraHostManager; - std::string cameraId = cameras[0]->GetID(); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); - sptr streamOperator = nullptr; - sptr input = cameraManager->CreateCameraInput(cameras[0]); - sptr callback1 = new(std::nothrow) CameraDeviceServiceCallback(input); + session->SetSmoothZoom(0, 0); - camDevice->EnableResult(result); - camDevice->DisableResult(result); + ret = session->CommitConfig(); + session->PrepareZoom(); + session->UnPrepareZoom(); + session->SetSmoothZoom(0, 0); - int32_t ret = camDevice->OpenDevice(); - EXPECT_EQ(ret, 0); - camDevice->UpdateSetting(nullptr); - sptr callback = nullptr; - camDevice->SetCallback(callback); - camDevice->GetSettings(); - camDevice->SetCallback(callback1); - camDevice->OnError(REQUEST_TIMEOUT, 0) ; - camDevice->OnError(DEVICE_PREEMPT, 0) ; - camDevice->OnError(DRIVER_ERROR, 0) ; + session->LockForControl(); + session->PrepareZoom(); + session->UnPrepareZoom(); + session->UnlockForControl(); - EXPECT_EQ(camDevice->CloseDevice(), 0); - EXPECT_EQ(camDevice->GetEnabledResults(result), 11); - EXPECT_EQ(camDevice->CloseDevice(), 0); - camDevice->~HCameraDevice(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test HStreamRepeat & HStreamCommon + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamRepeat & HStreamCommon + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in ~CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_026, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_042, TestSize.Level0) { - int32_t format = 0; - int32_t width = 0; - int32_t height = 0; - std::string dumpString ="HStreamRepeat"; + InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr callback = nullptr; - sptr producer = nullptr; - sptr Surface = IConsumerSurface::Create(); - sptr producer1 = Surface->GetProducer(); - sptr streamRepeat = - new (std::nothrow) HStreamRepeat(nullptr, format, width, height, RepeatStreamType::PREVIEW); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); - EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); - EXPECT_EQ(streamRepeat->SetCallback(callback), CAMERA_INVALID_ARG); - EXPECT_EQ(streamRepeat->OnFrameError(BUFFER_LOST), 0); - EXPECT_EQ(streamRepeat->AddDeferredSurface(producer), CAMERA_INVALID_ARG); - streamRepeat->DumpStreamInfo(dumpString); - EXPECT_EQ(streamRepeat->AddDeferredSurface(producer1), CAMERA_INVALID_STATE); - std::shared_ptr metadata = cameras[0]->GetMetadata(); - std::shared_ptr metadata1 = nullptr; - EXPECT_EQ(streamRepeat->LinkInput(mockStreamOperator, metadata), CAMERA_OK); - streamRepeat->LinkInput(mockStreamOperator, metadata1); - mockStreamOperator = nullptr; - streamRepeat->LinkInput(mockStreamOperator, metadata); - streamRepeat->DumpStreamInfo(dumpString); - EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + + int32_t ret = session->BeginConfig(); + ret = session->AddInput(input); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + session->~CaptureSession(); + session->PrepareZoom(); + session->UnPrepareZoom(); + session->SetSmoothZoom(0, 0); + session->SetBeauty(AUTO_TYPE, 0); + + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test HStreamMetadata & HStreamCommon + * Function: Test !IsSessionCommited() && !IsSessionConfiged() * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamMetadata & HStreamCommon + * CaseDescription: Test !IsSessionCommited() && !IsSessionConfiged() in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_027, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_043, TestSize.Level0) { - int32_t format = 0; - std::string dumpString ="HStreamMetadata"; + InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, format); - std::shared_ptr metadata = cameras[0]->GetMetadata(); - std::shared_ptr metadata1 = nullptr; - streamMetadata->LinkInput(mockStreamOperator, metadata); - streamMetadata->LinkInput(mockStreamOperator, metadata1); - mockStreamOperator = nullptr; - streamMetadata->LinkInput(mockStreamOperator, metadata); - streamMetadata->Stop(); - streamMetadata->Start(); - streamMetadata->DumpStreamInfo(dumpString); - streamMetadata->Start(); - streamMetadata->Stop(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + + session->SetBeautyValue(AUTO_TYPE, 0); + + session->SetBeauty(AUTO_TYPE, 0); + int32_t ret = session->BeginConfig(); + session->SetBeauty(AUTO_TYPE, 0); + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + session->SetBeauty(AUTO_TYPE, 0); + + session->CalculateExposureValue(100.0); + + session->LockForControl(); + session->SetBeauty(AUTO_TYPE, 0); + session->SetFilter(NONE); + session->UnlockForControl(); + + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test HStreamMetadata & HStreamCommon + * Function: Test inputDevice_ * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamMetadata & HStreamCommon + * CaseDescription: Test inputDevice_ in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_028, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_044, TestSize.Level0) { - int32_t format = 0; - std::string dumpString ="HStreamMetadata"; + InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr streamMetadata= new(std::nothrow) HStreamMetadata(producer, format); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + ASSERT_NE(input, nullptr); + + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); + auto macroStatusCallback = std::make_shared(); std::shared_ptr metadata = cameras[0]->GetMetadata(); - streamMetadata->Start(); - streamMetadata->LinkInput(mockStreamOperator, metadata); - streamMetadata->Stop(); + + session->GetColorEffect(); + session->EnableMacro(true); + + int32_t ret = session->BeginConfig(); + + ret = session->AddInput(input); + EXPECT_EQ(ret, 0); + ret = session->AddOutput(preview); + EXPECT_EQ(ret, 0); + + ret = session->CommitConfig(); + session->GetColorEffect(); + + ((sptr&)(session->inputDevice_))->cameraObj_ = nullptr; + session->GetColorEffect(); + session->IsMacroSupported(); + session->inputDevice_ = nullptr; + session->GetColorEffect(); + session->IsMacroSupported(); + session->EnableMacro(true); + + session->LockForControl(); + session->SetColorEffect(COLOR_EFFECT_NORMAL); + session->UnlockForControl(); + + session->macroStatusCallback_ = macroStatusCallback; + session->ProcessMacroStatusChange(metadata); + + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test HStreamCapture & HStreamCommon + * Function: Test HCameraService * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HStreamCapture & HStreamCommon + * CaseDescription: Test HCameraService */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_029, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_045, TestSize.Level0) { - int32_t format = 0; - int32_t width = 0; - int32_t height = 0; - int32_t captureId = 0; - int32_t frameCount = 0; - uint64_t timestamp = 0; - std::string dumpString ="hstream_capture"; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr callback = nullptr; - sptr Surface = IConsumerSurface::Create(); - sptr producer = Surface->GetProducer(); - sptr producer1 = nullptr; - sptr streamCapture= new(std::nothrow) HStreamCapture(producer, format, width, height); + auto hCameraService = new HCameraService(0, true); std::shared_ptr metadata = cameras[0]->GetMetadata(); - EXPECT_EQ(streamCapture->SetThumbnail(false, producer1), CAMERA_OK); - EXPECT_EQ(streamCapture->SetThumbnail(false, producer), CAMERA_OK); - EXPECT_EQ(streamCapture->SetThumbnail(true, producer1), CAMERA_OK); - streamCapture->DumpStreamInfo(dumpString); - EXPECT_EQ(streamCapture->SetThumbnail(true, producer), CAMERA_OK); - streamCapture->SetRotation(metadata); - mockStreamOperator = nullptr; - streamCapture->LinkInput(mockStreamOperator, metadata); - EXPECT_EQ(streamCapture->Capture(metadata), CAMERA_INVALID_STATE); - streamCapture->PrintDebugLog(metadata); - EXPECT_EQ(streamCapture->SetCallback(callback), CAMERA_INVALID_ARG); - EXPECT_EQ(streamCapture->OnCaptureEnded(captureId, frameCount), CAMERA_OK); - EXPECT_EQ(streamCapture->OnCaptureError(captureId, frameCount), CAMERA_OK); - EXPECT_EQ(streamCapture->OnCaptureError(captureId, BUFFER_LOST), CAMERA_OK); - EXPECT_EQ(streamCapture->OnFrameShutter(captureId, timestamp), CAMERA_OK); - streamCapture->DumpStreamInfo(dumpString); - EXPECT_EQ(streamCapture->Release(), 0); + hCameraService->UpdateSkinSmoothSetting(metadata, 0); + hCameraService->UpdateSkinSmoothSetting(metadata, 1); + hCameraService->UpdateSkinSmoothSetting(nullptr, 1); + hCameraService->UpdateFaceSlenderSetting(metadata, 0); + hCameraService->UpdateFaceSlenderSetting(metadata, 1); + hCameraService->UpdateFaceSlenderSetting(nullptr, 1); + hCameraService->UpdateSkinToneSetting(metadata, 0); + hCameraService->UpdateSkinToneSetting(metadata, 1); + hCameraService->UpdateSkinToneSetting(nullptr, 1); } + /* * Feature: Framework - * Function: Test HCameraDevice + * Function: Test !IsSessionConfiged() || input == nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraDevice + * CaseDescription: Test !IsSessionConfiged() || input == nullptr in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_030, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_046, TestSize.Level0) { - std::vector result; - result.push_back(OHOS_SENSOR_EXPOSURE_TIME); - result.push_back(OHOS_SENSOR_COLOR_CORRECTION_GAINS); - + InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); + sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + sptr input1 = nullptr; + ASSERT_NE(input, nullptr); - sptr cameraHostManager = (sptr &)mockCameraHostManager; - std::string cameraId = cameras[0]->GetID(); - uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - uint32_t callerToken1 = 3; - sptr camDevice = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken); - sptr camDevice1 = new(std::nothrow) HCameraDevice(cameraHostManager, cameraId, callerToken1); + EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); + EXPECT_CALL(*mockCameraDevice, SetResultMode(ON_CHANGED)); + sptr camInput = (sptr &)input; + std::string cameraSettings = camInput->GetCameraSettings(); + camInput->SetCameraSettings(cameraSettings); + camInput->GetCameraDevice()->Open(); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + ASSERT_NE(preview, nullptr); - sptr streamOperator = nullptr; - sptr input = cameraManager->CreateCameraInput(cameras[0]); - sptr callback1 = new(std::nothrow) CameraDeviceServiceCallback(input); - camDevice->EnableResult(result); - camDevice->DisableResult(result); + session->CanAddInput(input); + session->BeginConfig(); + session->CanAddInput(input); + session->CanAddInput(input1); + session->captureSession_ = nullptr; + session->CanAddInput(input); + + session->AddInput(input); + session->AddOutput(preview); - int32_t ret = camDevice->OpenDevice(); - EXPECT_EQ(ret, 0); - camDevice->Open(); - g_getCameraAbilityerror = true; - camDevice->GetSettings(); - g_openCameraDevicerror = true; - EXPECT_EQ(camDevice->OpenDevice(), 11); + session->CommitConfig(); - camDevice->CloseDevice(); + session->RemoveOutput(preview); + session->RemoveInput(input); + preview->Release(); + input->Release(); + session->Release(); } /* * Feature: Framework - * Function: Test anomalous branch + * Function: Test !IsSessionConfiged() || output == nullptr * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA - * CaseDescription: Test HCameraHostManager with anomalous branch. + * CaseDescription: Test !IsSessionConfiged() || output == nullptr in CaptureSession */ -HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_031, TestSize.Level0) +HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_047, TestSize.Level0) { InSequence s; std::vector> cameras = cameraManager->GetSupportedCameras(); - sptr input = cameraManager->CreateCameraInput(cameras[0]); + sptr surface = Surface::CreateSurfaceAsConsumer(); + ASSERT_NE(input, nullptr); EXPECT_CALL(*mockCameraHostManager, OpenCameraDevice(_, _, _)); @@ -3888,50 +6315,31 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_031, TestSize.Level std::string cameraSettings = camInput->GetCameraSettings(); camInput->SetCameraSettings(cameraSettings); camInput->GetCameraDevice()->Open(); + + sptr session = cameraManager->CreateCaptureSession(); + ASSERT_NE(session, nullptr); + sptr preview = CreatePreviewOutput(); + sptr output = nullptr; + ASSERT_NE(preview, nullptr); - std::vector cameraIds = {}; - sptr cameraHostManager = (sptr &)mockCameraHostManager; - ASSERT_NE(cameraHostManager, nullptr); - - std::string cameraId = cameras[0]->GetID(); - EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameras(cameraIds), 0); - std::shared_ptr ability = cameras[0]->GetMetadata(); - EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2); - EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2); - - cameraId = "HCameraHostManager"; - - cameraHostManager->AddCameraDevice(cameraId, nullptr); - EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, true), 2); - - cameraHostManager->CloseCameraDevice(cameraId); - - ability = cameras[0]->GetMetadata(); - EXPECT_EQ(cameraHostManager->HCameraHostManager::GetCameraAbility(cameraId, ability), 2); - - EXPECT_EQ(cameraHostManager->HCameraHostManager::GetVersionByCamera(cameraId), 0); - - sptr pDevice; - cameraHostManager->HCameraHostManager::OpenCameraDevice(cameraId, nullptr, pDevice); - - cameraId = cameras[0]->GetID(); - HDI::ServiceManager::V1_0::ServiceStatus status; - status.deviceClass = DEVICE_CLASS_CAMERA; - status.serviceName = "distributed_camera_service"; - status.status = HDI::ServiceManager::V1_0::SERVIE_STATUS_START; - cameraHostManager->HCameraHostManager::OnReceive(status); + session->CanAddOutput(preview); + session->BeginConfig(); + session->CanAddOutput(output); + preview->~CaptureOutput(); + session->CanAddOutput(preview); + + + session->AddInput(input); + session->AddOutput(preview); - EXPECT_EQ(cameraHostManager->HCameraHostManager::SetFlashlight(cameraId, false), 2); + session->CommitConfig(); - std::shared_ptr mockStatusCallback = - std::make_shared(); - sptr mockCameraHostManager_2 = - new (std::nothrow) MockHCameraHostManager(mockStatusCallback); - sptr cameraHostManager_2 = (sptr &)mockCameraHostManager_2; + session->RemoveOutput(preview); + session->RemoveInput(input); + input->Release(); + session->Release(); +} - cameraHostManager_2->AddCameraDevice(cameraId, nullptr); - input->Close(); -} } // CameraStandard } // OHOS diff --git a/frameworks/native/camera/test/unittest/src/v1_1/camera_ndk_unittest.cpp b/frameworks/native/camera/test/unittest/src/v1_1/camera_ndk_unittest.cpp index afb18e117..d839aee6f 100644 --- a/frameworks/native/camera/test/unittest/src/v1_1/camera_ndk_unittest.cpp +++ b/frameworks/native/camera/test/unittest/src/v1_1/camera_ndk_unittest.cpp @@ -248,6 +248,26 @@ void CameraNdkUnitTest::ReleaseImageReceiver(void) } } +static void OnCameraInputError(const Camera_Input* cameraInput, Camera_ErrorCode errorCode) +{ + MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__); +} + +static void CameraCaptureSessiononFocusStateChangeCb(Camera_CaptureSession* session, Camera_FocusState focusState) +{ + MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__); +} + +static void CameraCaptureSessionOnErrorCb(Camera_CaptureSession* session, Camera_ErrorCode errorCode) +{ + MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__); +} + +static void CameraManagerOnCameraStatusCb(Camera_Manager* cameraManager, Camera_StatusInfo* status) +{ + MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__); +} + static void CameraPreviewOutptOnFrameStartCb(Camera_PreviewOutput* previewOutput) { MEDIA_DEBUG_LOG("fun:%s", __FUNCTION__); @@ -2517,5 +2537,167 @@ HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_011, TestSize.Level0) EXPECT_EQ(ret, 0); cameraInput = nullptr; } + + +/* + * Feature: Framework + * Function: Test preview capture photo callback + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test preview capture photo callback + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_012, TestSize.Level0) +{ + CameraManager_Callbacks setCameraManagerResultCallback = { + .onCameraStatus = &CameraManagerOnCameraStatusCb, + }; + Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0); + EXPECT_NE(captureSession, nullptr); + CaptureSession_Callbacks setCaptureSessionResultCallback = { + .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb, + .onError = &CameraCaptureSessionOnErrorCb + }; + ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + Camera_PreviewOutput* previewOutput = CreatePreviewOutput(); + EXPECT_NE(previewOutput, nullptr); + PreviewOutput_Callbacks setPreviewResultCallback = { + .onFrameStart = &CameraPreviewOutptOnFrameStartCb, + .onFrameEnd = &CameraPreviewOutptOnFrameEndCb, + .onError = &CameraPreviewOutptOnErrorCb + }; + ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + Camera_Input *cameraInput = nullptr; + ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + CameraInput_Callbacks cameraInputCallbacks = { + .onError = OnCameraInputError + }; + ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks); + EXPECT_EQ(ret, CAMERA_OK); + ret = OH_CameraInput_Open(cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + + EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0); + EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0); + EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0); + + EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0); + Camera_PhotoOutput* photoOutput = CreatePhotoOutput(); + EXPECT_NE(photoOutput, nullptr); + PhotoOutput_Callbacks setPhotoOutputResultCallback = { + .onFrameStart = &CameraPhotoOutptOnFrameStartCb, + .onFrameShutter = &CameraPhotoOutptOnFrameShutterCb, + .onFrameEnd = &CameraPhotoOutptOnFrameEndCb, + .onError = &CameraPhotoOutptOnErrorCb + }; + ret = OH_PhotoOutput_RegisterCallback(photoOutput, &setPhotoOutputResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + EXPECT_EQ(OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput), 0); + EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0); + EXPECT_EQ(OH_PhotoOutput_Capture(photoOutput), 0); + sleep(2); + + EXPECT_EQ(OH_PhotoOutput_Release(photoOutput), 0); + EXPECT_EQ(OH_PreviewOutput_Stop(previewOutput), 0); + EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0); + EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0); + EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0); + ReleaseImageReceiver(); +} + +/* + * Feature: Framework + * Function: Test preview capture video callback + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test preview capture video callback + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_013, TestSize.Level0) +{ + CameraManager_Callbacks setCameraManagerResultCallback = { + .onCameraStatus = &CameraManagerOnCameraStatusCb, + }; + Camera_ErrorCode ret = OH_CameraManager_RegisterCallback(cameraManager, &setCameraManagerResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + EXPECT_EQ(OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession), 0); + EXPECT_NE(captureSession, nullptr); + CaptureSession_Callbacks setCaptureSessionResultCallback = { + .onFocusStateChange = &CameraCaptureSessiononFocusStateChangeCb, + .onError = &CameraCaptureSessionOnErrorCb + }; + ret = OH_CaptureSession_RegisterCallback(captureSession, &setCaptureSessionResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + Camera_PreviewOutput* previewOutput = CreatePreviewOutput(); + EXPECT_NE(previewOutput, nullptr); + PreviewOutput_Callbacks setPreviewResultCallback = { + .onFrameStart = &CameraPreviewOutptOnFrameStartCb, + .onFrameEnd = &CameraPreviewOutptOnFrameEndCb, + .onError = &CameraPreviewOutptOnErrorCb + }; + ret = OH_PreviewOutput_RegisterCallback(previewOutput, &setPreviewResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + Camera_Input *cameraInput = nullptr; + ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + CameraInput_Callbacks cameraInputCallbacks = { + .onError = OnCameraInputError + }; + ret = OH_CameraInput_RegisterCallback(cameraInput, &cameraInputCallbacks); + EXPECT_EQ(ret, CAMERA_OK); + ret = OH_CameraInput_Open(cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + + EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_AddInput(captureSession, cameraInput), 0); + EXPECT_EQ(OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput), 0); + EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0); + + EXPECT_EQ(OH_CaptureSession_Stop(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_BeginConfig(captureSession), 0); + Camera_VideoOutput* videoOutput = CreateVideoOutput(); + EXPECT_NE(videoOutput, nullptr); + VideoOutput_Callbacks setVideoResultCallback = { + .onFrameStart = &CameraVideoOutptOnFrameStartCb, + .onFrameEnd = &CameraVideoOutptOnFrameEndCb, + .onError = &CameraVideoOutptOnErrorCb + }; + ret = OH_VideoOutput_RegisterCallback(videoOutput, &setVideoResultCallback); + EXPECT_EQ(ret, CAMERA_OK); + + EXPECT_EQ(OH_CaptureSession_AddVideoOutput(captureSession, videoOutput), 0); + EXPECT_EQ(OH_CaptureSession_CommitConfig(captureSession), 0); + EXPECT_EQ(OH_CaptureSession_Start(captureSession), 0); + EXPECT_EQ(OH_VideoOutput_Start(videoOutput), 0); + sleep(2); + + EXPECT_EQ(OH_VideoOutput_Stop(videoOutput), 0); + EXPECT_EQ(OH_VideoOutput_Release(videoOutput), 0); + EXPECT_EQ(OH_PreviewOutput_Release(previewOutput), 0); + EXPECT_EQ(OH_CaptureSession_Release(captureSession), 0); + EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0); + ReleaseImageReceiver(); +} } // CameraStandard } // OHOS \ No newline at end of file diff --git a/interfaces/inner_api/native/camera/include/output/sketch_wrapper.h b/interfaces/inner_api/native/camera/include/output/sketch_wrapper.h index 11acb18e4..1e112c6a6 100644 --- a/interfaces/inner_api/native/camera/include/output/sketch_wrapper.h +++ b/interfaces/inner_api/native/camera/include/output/sketch_wrapper.h @@ -30,11 +30,11 @@ class SketchWrapper { public: static float GetSketchReferenceFovRatio(int32_t modeName, float zoomRatio); static float GetSketchEnableRatio(int32_t modeName); - static void UpdateSketchStaticInfo(std::shared_ptr deviceMetadata); + static void UpdateSketchStaticInfo(std::shared_ptr deviceMetadata); explicit SketchWrapper(sptr hostStream, const Size size); virtual ~SketchWrapper(); - int32_t Init(std::shared_ptr& deviceMetadata, int32_t modeName); + int32_t Init(std::shared_ptr& deviceMetadata, int32_t modeName); int32_t AttachSketchSurface(sptr sketchSurface); int32_t StartSketchStream(); int32_t StopSketchStream(); -- Gitee From c3db144b7c830ebf7c272b0f24f474e6f6f25dba Mon Sep 17 00:00:00 2001 From: lengye Date: Wed, 27 Dec 2023 07:45:24 +0000 Subject: [PATCH 2/4] add tdd case Signed-off-by: lengye --- .../src/camera_framework_moduletest.cpp | 10 ++++++---- .../src/v1_1/camera_framework_unittest.cpp | 19 +++++++++++-------- 2 files changed, 17 insertions(+), 12 deletions(-) diff --git a/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp b/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp index 24e20c58c..02b06de33 100644 --- a/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp +++ b/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp @@ -6628,7 +6628,7 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_092, TestSize.L object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); HCameraServiceCallbackProxy *hCameraServiceCallbackProxy = new (std::nothrow) HCameraServiceCallbackProxy(object); ASSERT_NE(hCameraServiceCallbackProxy, nullptr); - HCameraMuteServiceCallbackProxy *hCameraMuteServiceCallbackProxy = new (std::nothrow) HCameraMuteServiceCallbackProxy(object); + auto hCameraMuteServiceCallbackProxy = new (std::nothrow) HCameraMuteServiceCallbackProxy(object); ASSERT_NE(hCameraMuteServiceCallbackProxy, nullptr); HTorchServiceCallbackProxy *hTorchServiceCallbackProxy = new (std::nothrow) HTorchServiceCallbackProxy(object); ASSERT_NE(hTorchServiceCallbackProxy, nullptr); @@ -6754,7 +6754,7 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_097, TestSize.L auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); ASSERT_NE(samgr, nullptr); object = samgr->GetSystemAbility(CAMERA_SERVICE_ID); - HCaptureSessionCallbackProxy *hCaptureSessionCallbackProxy = new (std::nothrow) HCaptureSessionCallbackProxy(object); + auto hCaptureSessionCallbackProxy = new (std::nothrow) HCaptureSessionCallbackProxy(object); ASSERT_NE(hCaptureSessionCallbackProxy, nullptr); hCaptureSessionCallbackProxy->OnError(0); } @@ -7028,7 +7028,8 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_106, TestSize.L object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); HCameraServiceCallbackProxy *hCameraServiceCallbackProxy = new (std::nothrow) HCameraServiceCallbackProxy(object); ASSERT_NE(hCameraServiceCallbackProxy, nullptr); - HCameraMuteServiceCallbackProxy *hCameraMuteServiceCallbackProxy = new (std::nothrow) HCameraMuteServiceCallbackProxy(object); + HCameraMuteServiceCallbackProxy *hCameraMuteServiceCallbackProxy = + new (std::nothrow) HCameraMuteServiceCallbackProxy(object); ASSERT_NE(hCameraMuteServiceCallbackProxy, nullptr); HTorchServiceCallbackProxy *hTorchServiceCallbackProxy = new (std::nothrow) HTorchServiceCallbackProxy(object); ASSERT_NE(hTorchServiceCallbackProxy, nullptr); @@ -7100,7 +7101,8 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_109, TestSize.L auto samgr = SystemAbilityManagerClient::GetInstance().GetSystemAbilityManager(); ASSERT_NE(samgr, nullptr); object = samgr->GetSystemAbility(AUDIO_POLICY_SERVICE_ID); - HCaptureSessionCallbackProxy *hCaptureSessionCallbackProxy = new (std::nothrow) HCaptureSessionCallbackProxy(object); + HCaptureSessionCallbackProxy *hCaptureSessionCallbackProxy = + new (std::nothrow) HCaptureSessionCallbackProxy(object); ASSERT_NE(hCaptureSessionCallbackProxy, nullptr); hCaptureSessionCallbackProxy->OnError(0); } diff --git a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp index 1686cab3e..874e5a239 100644 --- a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp +++ b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp @@ -411,9 +411,10 @@ public: } }; -class AppMacroStatusCallback: public MacroStatusCallback { +class AppMacroStatusCallback : public MacroStatusCallback { public: - void OnMacroStatusChanged(MacroStatus status) { + void OnMacroStatusChanged(MacroStatus status) + { MEDIA_DEBUG_LOG("AppMacroStatusCallback"); } }; @@ -2330,9 +2331,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_054, TestSize.Level0 std::shared_ptr metadata = cameras[0]->GetMetadata(); camera_metadata_item_t item; - int ret = OHOS::Camera::FindCameraMetadataItem(metadata->get(), - OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item); - EXPECT_EQ(ret, CAM_META_SUCCESS); + OHOS::Camera::FindCameraMetadataItem(metadata->get(), OHOS_ABILITY_STREAM_AVAILABLE_BASIC_CONFIGURATIONS, &item); cameraManager->ParseBasicCapability(ability, metadata, item); } @@ -5593,8 +5592,10 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_034, TestSize.Level previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); previewOutput->OnNativeRegisterCallback(eventString); previewOutput->OnNativeUnregisterCallback(eventString); + /home/back_zhang/workspace/1226/multimedia_camera_framework_tdd/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp previewOutput->CameraServerDied(0); - std::shared_ptr previewStateCallback = std::make_shared("PreviewStateCallback"); + std::shared_ptr previewStateCallback = + std::make_shared("PreviewStateCallback"); previewOutput->SetCallback(previewStateCallback); previewOutput->CameraServerDied(0); @@ -5671,7 +5672,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_035, TestSize.Level SketchWrapper *sketchWrapper = new (std::nothrow) SketchWrapper(previewOutput->GetStream(), previewSize); ASSERT_NE(sketchWrapper, nullptr); - std::shared_ptr setCallback = std::make_shared("PreviewStateCallback"); + std::shared_ptr setCallback = + std::make_shared("PreviewStateCallback"); ASSERT_NE(setCallback, nullptr); camera_metadata_item_t item; int ret = OHOS::Camera::FindCameraMetadataItem(deviceMetadata->get(), OHOS_CONTROL_ZOOM_RATIO, &item); @@ -5688,7 +5690,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_035, TestSize.Level sketchWrapper->OnSketchStatusChanged(SketchStatus::STOPED, 1.0f); sketchWrapper->UpdateSketchReferenceFovRatio(item, SketchWrapper::g_sketchReferenceFovRatioMap_); auto sketchReferenceFovRangeVec = std::vector(5); - SketchWrapper::SketchReferenceFovRange sketchReferenceFovRange = {.zoomMin = -1.0f, .zoomMax = -1.0f, .referenceValue = -1.0f}; + SketchWrapper::SketchReferenceFovRange sketchReferenceFovRange = + {.zoomMin = -1.0f, .zoomMax = -1.0f, .referenceValue = -1.0f}; sketchReferenceFovRangeVec[0] = sketchReferenceFovRange; sketchReferenceFovRange = {.zoomMin = -1.0f, .zoomMax = 100.0f, .referenceValue = -1.0f}; SketchWrapper::g_sketchReferenceFovRatioMap_[-1] = sketchReferenceFovRangeVec; -- Gitee From a23e054f33b477205fa2f9af6ec958a9f1d39169 Mon Sep 17 00:00:00 2001 From: lengye Date: Wed, 27 Dec 2023 08:00:13 +0000 Subject: [PATCH 3/4] add tdd case Signed-off-by: lengye --- .../camera/test/unittest/src/v1_1/camera_framework_unittest.cpp | 1 - 1 file changed, 1 deletion(-) diff --git a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp index 874e5a239..19d1fbcf4 100644 --- a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp +++ b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp @@ -5592,7 +5592,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_034, TestSize.Level previewOutput->sketchWrapper_ = std::make_shared(previewOutput->GetStream(), previewSize); previewOutput->OnNativeRegisterCallback(eventString); previewOutput->OnNativeUnregisterCallback(eventString); - /home/back_zhang/workspace/1226/multimedia_camera_framework_tdd/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp previewOutput->CameraServerDied(0); std::shared_ptr previewStateCallback = std::make_shared("PreviewStateCallback"); -- Gitee From 18fc20a98c794de64fad84d0d5cdc60bbcfaead7 Mon Sep 17 00:00:00 2001 From: lengye Date: Wed, 27 Dec 2023 11:42:05 +0000 Subject: [PATCH 4/4] add tdd case Signed-off-by: lengye --- .../camera/test/unittest/src/v1_1/camera_framework_unittest.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp index 19d1fbcf4..31f87f1fa 100644 --- a/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp +++ b/frameworks/native/camera/test/unittest/src/v1_1/camera_framework_unittest.cpp @@ -2824,7 +2824,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_073, TestSize.Level0 /* * Feature: Framework - * Function: Test previewoutput + * Function: Test previewoutput * SubFunction: NA * FunctionPoints: NA * EnvConditions: NA -- Gitee