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 c42c86166d5ff71373951bd0540ae86376f0719f..3a75b3bac20b246d695b1f4f31588ad002b4f4e6 100644 --- a/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp +++ b/frameworks/native/camera/test/moduletest/src/camera_framework_moduletest.cpp @@ -933,8 +933,9 @@ HWTEST_F(CameraFrameworkModuleTest, Camera_ResultCallback_moduletest, TestSize.L // Register error callback std::shared_ptr callback = std::make_shared(); + std::shared_ptr resultCallback = callback; sptr camInput = (sptr&)input_; - camInput->SetResultCallback(callback); + camInput->SetResultCallback(resultCallback); EXPECT_EQ(g_camInputOnError, false); sptr previewOutput = CreatePreviewOutput(); @@ -1503,8 +1504,8 @@ HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_025, TestSize.Le sleep(WAIT_TIME_AFTER_START); - ((sptr&)previewOutput1)->Release(); - ((sptr&)previewOutput2)->Release(); + ((sptr&)previewOutput1)->Release(); + ((sptr&)previewOutput2)->Release(); } /* @@ -1569,8 +1570,8 @@ HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_026, TestSize.Le ((sptr&)previewOutput)->Stop(); session_->Stop(); - ((sptr&)videoOutput1)->Release(); - ((sptr&)videoOutput2)->Release(); + ((sptr&)videoOutput1)->Release(); + ((sptr&)videoOutput2)->Release(); } /* @@ -2769,7 +2770,7 @@ HWTEST_F(CameraFrameworkModuleTest, camera_framework_moduletest_scan_050, TestSi intResult = scanSession_->CommitConfig(); EXPECT_NE(intResult, 0); - ((sptr &) phtotOutput)->Release(); + ((sptr &) phtotOutput)->Release(); ((sptr &) videoOutput)->Release(); MEDIA_INFO_LOG("teset050 end"); } @@ -6249,6 +6250,382 @@ HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_072, TestSize.L EXPECT_EQ(streamCapture->OnFrameShutter(captureId, timestamp), CAMERA_OK); } + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_078, 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); + uint64_t timestamp = 0; + std::shared_ptr result = nullptr; + session_->ProcessFaceRecUpdates(timestamp, result); + EXPECT_EQ(session_->VerifyAbility(0), CAMERA_INVALID_ARG); + EXPECT_EQ((session_->GetSupportedColorEffects()).empty(), true); + session_->inputDevice_ = nullptr; + session_->ProcessFaceRecUpdates(timestamp, result); + EXPECT_EQ(session_->GetFilter(), FilterType::NONE); + EXPECT_EQ(session_->GetSupportedFilters().empty(), true); + EXPECT_EQ(session_->GetSupportedBeautyTypes().empty(), true); + session_->SetBeauty(AUTO_TYPE, 0); + EXPECT_EQ(session_->GetBeauty(AUTO_TYPE), -1); + session_->SetFilter(NONE); + EXPECT_EQ(session_->SetColorSpace(COLOR_SPACE_UNKNOWN), CAMERA_OK); + EXPECT_EQ(session_->VerifyAbility(0), CAMERA_INVALID_ARG); + + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + session_->SetBeauty(AUTO_TYPE, 0); + EXPECT_EQ(session_->GetBeauty(AUTO_TYPE), -1); + session_->SetFilter(NONE); + EXPECT_EQ(session_->SetColorSpace(COLOR_SPACE_UNKNOWN), CAMERA_OK); + EXPECT_EQ((session_->GetSupportedColorEffects()).empty(), true); + intResult = session_->Release(); + EXPECT_EQ(intResult, 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_079, 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); + + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + + session_->inputDevice_ = nullptr; + + EXPECT_EQ(session_->GetSupportedFilters().empty(), true); + EXPECT_EQ(session_->GetFilter(), FilterType::NONE); + EXPECT_EQ(session_->GetSupportedBeautyTypes().empty(), true); + + BeautyType beautyType = AUTO_TYPE; + EXPECT_EQ(session_->GetSupportedBeautyRange(beautyType).empty(), true); + EXPECT_EQ(session_->GetBeauty(beautyType), -1); + EXPECT_EQ(session_->GetColorEffect(), ColorEffect::COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->GetSupportedColorEffects().empty(), true); + + intResult = session_->Release(); + EXPECT_EQ(intResult, 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_080, TestSize.Level0) +{ + EXPECT_EQ(session_->GetSupportedFilters().empty(), true); + EXPECT_EQ(session_->GetFilter(), FilterType::NONE); + EXPECT_EQ(session_->GetSupportedBeautyTypes().empty(), true); + 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); + EXPECT_EQ(session_->GetSupportedFilters().empty(), true); + EXPECT_EQ(session_->GetFilter(), FilterType::NONE); + EXPECT_EQ(session_->GetSupportedBeautyTypes().empty(), true); + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + session_->inputDevice_ = nullptr; + EXPECT_EQ(session_->GetSupportedFilters().empty(), true); + EXPECT_EQ(session_->GetFilter(), FilterType::NONE); + EXPECT_EQ(session_->GetSupportedBeautyTypes().empty(), true); + EXPECT_EQ(session_->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test Commited() || Configed() with abnormal branches in CaptureSession in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_081, TestSize.Level0) +{ + sptr camSession = manager_->CreateCaptureSession(); + ASSERT_NE(camSession, nullptr); + ColorSpace colorSpace = COLOR_SPACE_UNKNOWN; + camSession->~CaptureSession(); + EXPECT_EQ(camSession->GetSupportedFilters().empty(), true); + EXPECT_EQ(camSession->GetFilter(), FilterType::NONE); + EXPECT_EQ(camSession->GetSupportedBeautyTypes().empty(), true); + BeautyType beautyType = AUTO_TYPE; + EXPECT_EQ(camSession->GetSupportedBeautyRange(beautyType).empty(), true); + EXPECT_EQ(camSession->GetBeauty(AUTO_TYPE), CameraErrorCode::SESSION_NOT_CONFIG); + EXPECT_EQ(camSession->GetColorEffect(), ColorEffect::COLOR_EFFECT_NORMAL); + EXPECT_EQ(camSession->GetSupportedColorEffects().empty(), true); + camSession->SetFilter(NONE); + camSession->SetBeauty(beautyType, 0); + EXPECT_EQ(camSession->GetSupportedColorSpaces().empty(), true); + EXPECT_EQ(camSession->SetColorSpace(COLOR_SPACE_UNKNOWN), CameraErrorCode::SESSION_NOT_CONFIG); + camSession->SetMode(0); + EXPECT_EQ(camSession->VerifyAbility(0), CAMERA_INVALID_ARG); + EXPECT_EQ(camSession->GetActiveColorSpace(colorSpace), CameraErrorCode::SESSION_NOT_CONFIG); + camSession->SetColorEffect(COLOR_EFFECT_NORMAL); + EXPECT_EQ(camSession->IsMacroSupported(), false); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_082, TestSize.Level0) +{ + ColorSpace colorSpace = COLOR_SPACE_UNKNOWN; + 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); + session_->SetMode(3); + EXPECT_EQ(session_->VerifyAbility(0), CAMERA_INVALID_ARG); + EXPECT_EQ(session_->GetActiveColorSpace(colorSpace), SESSION_NOT_CONFIG); + session_->SetColorEffect(COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->IsMacroSupported(), false); + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + EXPECT_EQ(session_->GetActiveColorSpace(colorSpace), CAMERA_OK); + session_->SetColorEffect(COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->IsMacroSupported(), false); + session_->inputDevice_ = nullptr; + EXPECT_EQ(session_->VerifyAbility(0), CAMERA_INVALID_ARG); + EXPECT_EQ(session_->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in NightSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_083, TestSize.Level0) +{ + auto nightSession = static_cast(session_.GetRefPtr()); + ASSERT_NE(nightSession, nullptr); + int32_t intResult = nightSession->BeginConfig(); + EXPECT_EQ(intResult, 0); + intResult = nightSession->AddInput(input_); + EXPECT_EQ(intResult, 0); + sptr previewOutput = CreatePreviewOutput(); + ASSERT_NE(previewOutput, nullptr); + intResult = nightSession->AddOutput(previewOutput); + EXPECT_EQ(intResult, 0); + std::vector exposureRange; + uint32_t exposureValue = 0; + EXPECT_EQ(nightSession->GetExposureRange(exposureRange), SESSION_NOT_CONFIG); + EXPECT_EQ(nightSession->SetExposure(0), SESSION_NOT_CONFIG); + EXPECT_EQ(nightSession->GetExposure(exposureValue), SESSION_NOT_CONFIG); + intResult = nightSession->CommitConfig(); + EXPECT_EQ(intResult, 0); + nightSession->inputDevice_ = nullptr; + EXPECT_EQ(nightSession->GetExposureRange(exposureRange), INVALID_ARGUMENT); + EXPECT_EQ(nightSession->SetExposure(0), SUCCESS); + EXPECT_EQ(nightSession->GetExposure(exposureValue), INVALID_ARGUMENT); + EXPECT_EQ(nightSession->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in NightSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_084, TestSize.Level0) +{ + sptr camSession = manager_->CreateCaptureSession(); + ASSERT_NE(camSession, nullptr); + auto nightSession = static_cast(camSession.GetRefPtr()); + nightSession->~NightSession(); + uint32_t exposureValue = 0; + std::vector exposureRange; + EXPECT_EQ(nightSession->GetExposureRange(exposureRange), SESSION_NOT_CONFIG); + EXPECT_EQ(nightSession->GetExposure(exposureValue), SESSION_NOT_CONFIG); + EXPECT_EQ(nightSession->SetExposure(0), SESSION_NOT_CONFIG); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in PortraitSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_087, TestSize.Level0) +{ + auto portraitSession = static_cast(session_.GetRefPtr()); + ASSERT_NE(portraitSession, nullptr); + EXPECT_EQ(portraitSession->GetSupportedPortraitEffects().empty(), true); + EXPECT_EQ(portraitSession->GetPortraitEffect(), OFF_EFFECT); + portraitSession->SetPortraitEffect(OFF_EFFECT); + int32_t intResult = portraitSession->BeginConfig(); + EXPECT_EQ(intResult, 0); + intResult = portraitSession->AddInput(input_); + EXPECT_EQ(intResult, 0); + sptr previewOutput = CreatePreviewOutput(); + ASSERT_NE(previewOutput, nullptr); + intResult = portraitSession->AddOutput(previewOutput); + EXPECT_EQ(intResult, 0); + EXPECT_EQ(portraitSession->GetSupportedPortraitEffects().empty(), true); + EXPECT_EQ(portraitSession->GetPortraitEffect(), OFF_EFFECT); + portraitSession->SetPortraitEffect(OFF_EFFECT); + intResult = portraitSession->CommitConfig(); + EXPECT_EQ(intResult, 0); + portraitSession->inputDevice_ = nullptr; + EXPECT_EQ(portraitSession->GetSupportedPortraitEffects().empty(), true); + EXPECT_EQ(portraitSession->GetPortraitEffect(), OFF_EFFECT); + portraitSession->SetPortraitEffect(OFF_EFFECT); + EXPECT_EQ(portraitSession->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test IsSessionCommited() || IsSessionConfiged() with abnormal branches in PortraitSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_088, TestSize.Level0) +{ + auto portraitSession = static_cast(session_.GetRefPtr()); + ASSERT_NE(portraitSession, nullptr); + portraitSession->~PortraitSession(); + EXPECT_EQ(portraitSession->GetSupportedPortraitEffects().empty(), true); + EXPECT_EQ(portraitSession->GetPortraitEffect(), OFF_EFFECT); + portraitSession->SetPortraitEffect(OFF_EFFECT); +} + +/* + * Feature: Framework + * Function: Test OnSketchStatusChanged + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test PreviewOutputCallbackImpl:OnSketchStatusChanged with abnormal branches + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_089, 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 previewOutput_1 = (sptr&)previewOutput; + ASSERT_NE(previewOutput_1, nullptr); + auto previewOutputCallbackImpl = new (std::nothrow) PreviewOutputCallbackImpl(previewOutput_1.GetRefPtr()); + ASSERT_NE(previewOutputCallbackImpl, nullptr); + EXPECT_EQ(previewOutputCallbackImpl->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_OK); + auto previewOutputCallbackImpl1 = new (std::nothrow) PreviewOutputCallbackImpl(); + ASSERT_NE(previewOutputCallbackImpl1, nullptr); + EXPECT_EQ(previewOutputCallbackImpl1->OnSketchStatusChanged(SketchStatus::STOPED), CAMERA_OK); + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + session_->inputDevice_ = nullptr; + EXPECT_EQ(session_->Release(), 0); +} + +/* + * Feature: Framework + * Function: Test !IsSessionCommited() && !IsSessionConfiged() + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: test !IsSessionCommited() && !IsSessionConfiged() with abnormal branches in CaptureSession + */ +HWTEST_F(CameraFrameworkModuleTest, camera_fwcoverage_moduletest_090, TestSize.Level0) +{ + BeautyType beautyType = AUTO_TYPE; + EXPECT_EQ(session_->GetSupportedBeautyRange(beautyType).empty(), true); + EXPECT_EQ(session_->GetBeauty(beautyType), CameraErrorCode::SESSION_NOT_CONFIG); + EXPECT_EQ(session_->GetColorEffect(), ColorEffect::COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->GetSupportedColorEffects().empty(), true); + EXPECT_EQ(session_->GetSupportedColorSpaces().empty(), true); + session_->SetBeauty(beautyType, 0); + session_->SetFilter(NONE); + EXPECT_EQ(session_->SetColorSpace(COLOR_SPACE_UNKNOWN), SESSION_NOT_CONFIG); + 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); + EXPECT_EQ(session_->GetSupportedBeautyRange(beautyType).empty(), true); + EXPECT_EQ(session_->GetBeauty(beautyType), -1); + EXPECT_EQ(session_->GetColorEffect(), COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->GetSupportedColorEffects().empty(), true); + EXPECT_EQ(session_->GetSupportedColorSpaces().empty(), true); + session_->SetBeauty(beautyType, 0); + session_->SetFilter(NONE); + EXPECT_EQ(session_->SetColorSpace(COLOR_SPACE_UNKNOWN), CAMERA_OK); + intResult = session_->CommitConfig(); + EXPECT_EQ(intResult, 0); + session_->inputDevice_ = nullptr; + EXPECT_EQ(session_->GetSupportedBeautyRange(beautyType).empty(), true); + EXPECT_EQ(session_->GetBeauty(beautyType), -1); + EXPECT_EQ(session_->GetColorEffect(), COLOR_EFFECT_NORMAL); + EXPECT_EQ(session_->GetSupportedColorEffects().empty(), true); + EXPECT_EQ(session_->GetSupportedColorSpaces().empty(), true); + session_->SetBeauty(beautyType, 0); + session_->SetFilter(NONE); + EXPECT_EQ(session_->SetColorSpace(COLOR_SPACE_UNKNOWN), CAMERA_OK); + EXPECT_EQ(session_->Release(), 0); +} + /* * Feature: Framework * Function: Test camera preempted. 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 957db891f82ee604d472ad902978b516d4f5f2b1..ffb648dc9b6dd273ea7d8e2df94a490077e5b9a2 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 @@ -2113,8 +2113,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_046, TestSize.Level0 ret = portraitSession->CommitConfig(); EXPECT_EQ(ret, 0); - EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)); - PortraitSessionControlParams(portraitSession); portraitSession->Release(); @@ -2287,8 +2285,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_050, TestSize.Level0 ret = portraitSession->CommitConfig(); EXPECT_EQ(ret, 0); - EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)); - PortraitSessionEffectParams(portraitSession); portraitSession->Release(); @@ -2356,8 +2352,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_051, TestSize.Level0 ret = portraitSession->CommitConfig(); EXPECT_EQ(ret, 0); - EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)); - PortraitSessionFilterParams(portraitSession); portraitSession->Release(); @@ -2426,8 +2420,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_framework_unittest_052, TestSize.Level0 ret = portraitSession->CommitConfig(); EXPECT_EQ(ret, 0); - EXPECT_CALL(*mockCameraHostManager, GetCameraAbility(_, _)); - PortraitSessionBeautyParams(portraitSession); portraitSession->Release(); @@ -2525,6 +2517,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_002, TestSize.Level std::vector args = {}; ret = camService->Dump(fd, args); EXPECT_EQ(ret, 0); + + input->Close(); } /* @@ -2587,6 +2581,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_003, TestSize.Level ret = camSession->RemoveOutput(StreamType::CAPTURE, stream_2); EXPECT_EQ(ret, 2); + input->Close(); camSession->Release(0); } @@ -2660,6 +2655,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_004, TestSize.Level cameraService->OnStart(); cameraService->OnStop(); + input->Close(); } /* @@ -2718,6 +2714,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_005, TestSize.Level cameraService->OnStart(); cameraService->OnStop(); + input->Close(); } /* @@ -2780,6 +2777,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_006, TestSize.Level EXPECT_EQ(intResult, 2); cameraService->OnStop(); + input->Close(); } /* @@ -2824,6 +2822,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_007, TestSize.Level status.status = 4; cameraHostManager->OnReceive(status); + + input->Close(); } /* @@ -2892,6 +2892,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_008, TestSize.Level int32_t exposureValueGet = session->GetExposureValue(exposureValue); EXPECT_EQ(exposureValueGet, 0); + input->Close(); session->Release(); } @@ -2958,15 +2959,15 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_009, TestSize.Level EXPECT_EQ(session->GetZoomRatio(), 0); bool isSupported; - VideoStabilizationMode stabilizationMode = MIDDLE; EXPECT_EQ(session->IsVideoStabilizationModeSupported(MIDDLE, isSupported), 0); - EXPECT_EQ(session->SetVideoStabilizationMode(stabilizationMode), 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(); } @@ -3015,6 +3016,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_010, TestSize.Level EXPECT_EQ(ret, 10); camService->OnStop(); + input->Close(); } /* @@ -3077,6 +3079,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_011, TestSize.Level ret = ((sptr &)photo)->Capture(photoSetting); EXPECT_EQ(ret, 0); + input->Close(); session->Release(); input->Release(); } @@ -3120,8 +3123,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_012, TestSize.Level sptr session = cameraManager->CreateCaptureSession(); ASSERT_NE(session, nullptr); - int32_t ret = session->BeginConfig(); - EXPECT_EQ(ret, 0); + EXPECT_EQ(session->BeginConfig(), 0); EXPECT_CALL(*mockCameraHostManager, GetVersionByCamera(_)); EXPECT_CALL(*mockCameraDevice, GetStreamOperator_V1_1(_, _)); @@ -3153,6 +3155,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_012, TestSize.Level EXPECT_EQ(streamRepeat->Start(), CAMERA_INVALID_STATE); EXPECT_EQ(streamRepeat->Stop(), CAMERA_INVALID_STATE); + + input->Close(); session->Release(); } @@ -3220,6 +3224,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_013, TestSize.Level cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, true); cameraUseStateChangeCb->StateChangeNotify(Security::AccessToken::INVALID_TOKENID, false); + input->Close(); camSession->Release(0); } @@ -3290,6 +3295,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_014, TestSize.Level std::vector streamIds = {1, 2}; streamOperatorCallback->OnFrameShutter(0, streamIds, 0); + input->Close(); camSession->Release(0); } @@ -3323,7 +3329,6 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level CameraMode mode = PORTRAIT; sptr camSession = new(std::nothrow) HCaptureSession(cameraHostManager, streamOperatorCb, callerToken, mode); - ASSERT_NE(camSession, nullptr); camSession->BeginConfig(); EXPECT_CALL(*mockCameraHostManager, GetVersionByCamera(_)); @@ -3360,6 +3365,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_015, TestSize.Level std::vector streamIds = {1, 2}; streamOperatorCallback->OnFrameShutter(0, streamIds, 0); + input->Close(); camSession->Release(0); } @@ -3391,9 +3397,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level sptr cameraHostManager = (sptr &)mockCameraHostManager; sptr streamOperatorCb = new StreamOperatorCallback();; uint32_t callerToken = IPCSkeleton::GetCallingTokenID(); - CameraMode mode = PORTRAIT; sptr camSession = new(std::nothrow) HCaptureSession(cameraHostManager, - streamOperatorCb, callerToken, mode); + streamOperatorCb, callerToken, PORTRAIT); EXPECT_EQ(camSession->CommitConfig(), CAMERA_INVALID_STATE); camSession->BeginConfig(); @@ -3431,6 +3436,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_016, TestSize.Level streamOperatorCallback->OnFrameShutter(0, streamIds, 0); camSession->BeginConfig(); + input->Close(); camSession->Release(0); } @@ -3487,8 +3493,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level int32_t ret = camSession->AddInput(cameraDevice); EXPECT_EQ(ret, 2); - ret = camSession->AddInput(cameraDevice); - EXPECT_EQ(ret, 8); + EXPECT_EQ(camSession->AddInput(cameraDevice), 8); wptr callback = nullptr; ret = camSession->SetDeviceOperatorsCallback(callback); @@ -3500,6 +3505,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_017, TestSize.Level std::string dumpString = "HCaptureSession"; camSession->dumpSessionInfo(dumpString); camSession->dumpSessions(dumpString); + + input->Close(); camSession->Release(0); } @@ -3568,6 +3575,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_018, TestSize.Level EXPECT_EQ(setExposureMode, 0); session->UnlockForControl(); + input->Close(); session->Release(); } @@ -3632,6 +3640,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_019, TestSize.Level int32_t setExposureBias = session->SetExposureBias(exposureValue); EXPECT_EQ(setExposureBias, 0); + input->Close(); session->Release(); } @@ -3697,6 +3706,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_020, TestSize.Level int32_t supportedFocusModesGet = session->GetSupportedFocusModes(getSupportedFocusModes); EXPECT_EQ(supportedFocusModesGet, 0); + input->Close(); session->Release(); } @@ -3759,6 +3769,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_021, TestSize.Level int32_t setFlashMode = session->SetFlashMode(flashMode); EXPECT_EQ(setFlashMode, 0); + input->Close(); session->Release(); } @@ -3820,6 +3831,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_022, TestSize.Level session->RemoveInput(input); session->RemoveOutput(photo); photo->Release(); + input->Close(); input->Release(); session->Release(); } @@ -3897,7 +3909,7 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_023, TestSize.Level session->GetActiveVideoStabilizationMode(stabilizationMode); session->SetVideoStabilizationMode(stabilizationMode); - photo->Release(); + input->Close(); input->Release(); session->Release(); } @@ -4148,6 +4160,9 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_030, TestSize.Level camDevice->GetSettings(); g_openCameraDevicerror = true; EXPECT_EQ(camDevice->OpenDevice(), 0); + + camDevice->CloseDevice(); + camDevice1->CloseDevice(); } /* @@ -4217,6 +4232,8 @@ HWTEST_F(CameraFrameworkUnitTest, camera_fwcoverage_unittest_031, TestSize.Level sptr cameraHostManager_2 = (sptr &)mockCameraHostManager_2; 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 438d7417b46b84f1d6bcdd60e00ecb217e1e2114..afb18e11736508ab583b1b57526a94ccc698e2fc 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 @@ -157,8 +157,6 @@ void CameraNdkUnitTest::SessionControlParams(Camera_CaptureSession *captureSessi float minZoom = 0.0f, maxZoom = 0.0f; Camera_ErrorCode ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom); EXPECT_EQ(ret, CAMERA_OK); - ASSERT_NE(minZoom, 0.0f); - ASSERT_NE(maxZoom, 0.0f); ret = OH_CaptureSession_SetZoomRatio(captureSession, minZoom); EXPECT_EQ(ret, CAMERA_OK); @@ -169,15 +167,20 @@ void CameraNdkUnitTest::SessionControlParams(Camera_CaptureSession *captureSessi ASSERT_NE(maxExposureBias, 0.0f); ASSERT_NE(step, 0.0f); + Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + bool* isSupportedExposureMode = nullptr; + ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, isSupportedExposureMode); + EXPECT_EQ(ret, CAMERA_OK); + ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias); EXPECT_EQ(ret, CAMERA_OK); - Camera_FlashMode flash = (Camera_FlashMode)FLASH_MODE_ALWAYS_OPEN; + Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN; ret = OH_CaptureSession_SetFlashMode(captureSession, flash); EXPECT_EQ(ret, CAMERA_OK); - Camera_FocusMode focus = (Camera_FocusMode)FOCUS_MODE_AUTO; + Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO; ret = OH_CaptureSession_SetFocusMode(captureSession, focus); EXPECT_EQ(ret, CAMERA_OK); - Camera_ExposureMode exposure = (Camera_ExposureMode)EXPOSURE_MODE_AUTO; + Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO; ret = OH_CaptureSession_SetExposureMode(captureSession, exposure); EXPECT_EQ(ret, CAMERA_OK); @@ -2178,5 +2181,341 @@ HWTEST_F(CameraNdkUnitTest, camera_frameworkndk_unittest_064, TestSize.Level0) EXPECT_EQ(OH_CameraInput_Release(cameraInput), 0); ReleaseImageReceiver(); } + +/* + * Feature: Framework + * Function: Test cameramanager create input with position and type + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager create input with position and type + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_001, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_Input *camInputPosAndType = nullptr; + Camera_Position cameraPosition = Camera_Position::CAMERA_POSITION_BACK; + Camera_Type cameraType = Camera_Type::CAMERA_TYPE_DEFAULT; + ret = OH_CameraManager_CreateCameraInput_WithPositionAndType(cameraManager, + cameraPosition, cameraType, &camInputPosAndType); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(&camInputPosAndType, nullptr); + + cameraPosition = Camera_Position::CAMERA_POSITION_UNSPECIFIED; + ret = OH_CameraManager_CreateCameraInput_WithPositionAndType(cameraManager, + cameraPosition, cameraType, &camInputPosAndType); + EXPECT_EQ(ret, CAMERA_OK); +} + +/* + * Feature: Framework + * Function: Test cameramanager delete supported cameras, output capability and manager + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager delete supported cameras, output capability and manager + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_002, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + Camera_OutputCapability *OutputCapability = nullptr; + + ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability); + EXPECT_EQ(ret, CAMERA_OK); + + ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize); + EXPECT_EQ(ret, 0); + + ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability); + EXPECT_EQ(ret, 0); + + ret = OH_Camera_DeleteCameraManager(cameraManager); + EXPECT_EQ(ret, 0); +} + +/* + * Feature: Framework + * Function: Test cameramanager delete supported without profiles + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager delete supported without profiles + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_004, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + Camera_OutputCapability *OutputCapability = nullptr; + + ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability); + EXPECT_EQ(ret, CAMERA_OK); + + OutputCapability->previewProfiles = nullptr; + OutputCapability->photoProfiles = nullptr; + OutputCapability->videoProfiles = nullptr; + OutputCapability->supportedMetadataObjectTypes = nullptr; + ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability); + EXPECT_EQ(ret, 0); + + ret = OH_Camera_DeleteCameraManager(cameraManager); + EXPECT_EQ(ret, 0); +} + +/* + * Feature: Framework + * Function: Test cameramanager delete supported without cameraDevice and cameraOutputCapability + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test cameramanager delete supported without cameraDevice and cameraOutputCapability + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_005, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + Camera_OutputCapability *OutputCapability = nullptr; + + ret = OH_CameraManager_GetSupportedCameraOutputCapability(cameraManager, cameraDevice, &OutputCapability); + EXPECT_EQ(ret, CAMERA_OK); + + cameraDevice = nullptr; + ret = OH_CameraManager_DeleteSupportedCameras(cameraManager, cameraDevice, cameraDeviceSize); + EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT); + + OutputCapability = nullptr; + ret = OH_CameraManager_DeleteSupportedCameraOutputCapability(cameraManager, OutputCapability); + EXPECT_EQ(ret, CAMERA_INVALID_ARGUMENT); + + ret = OH_Camera_DeleteCameraManager(cameraManager); + EXPECT_EQ(ret, 0); +} + +/* + * Feature: Framework + * Function: Test capture session about zoom and mode with not commit + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test capture session about zoom and mode with not commit + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_008, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + + float minZoom = 0.0f, maxZoom = 0.0f; + ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom); + EXPECT_EQ(ret, 0); + + float zoom = 0.0f; + ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO; + bool isSupportedFocusMode = true; + ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO; + ret = OH_CaptureSession_SetFocusMode(captureSession, focus); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_Point FocusPointSet = {1.0, 2.0}; + ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet); + + Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN; + ret = OH_CaptureSession_SetFlashMode(captureSession, flash); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + bool isSupportedExposureMode = true; + ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + ret = OH_CaptureSession_SetExposureMode(captureSession, exposure); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_Point exposurePointSet = {1.0, 2.0}; + ret = OH_CaptureSession_SetMeteringPoint(captureSession, exposurePointSet); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + float minExposureBias = 0.0f; + ret = OH_CaptureSession_SetExposureBias(captureSession, minExposureBias); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); +} + +/* + * Feature: Framework + * Function: Test capture session about zoom and mode with commit + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test capture session about zoom and mode with commit + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_009, TestSize.Level0) +{ + Camera_PhotoOutput *photoOutput = CreatePhotoOutput(); + EXPECT_NE(photoOutput, nullptr); + Camera_CaptureSession* captureSession = nullptr; + Camera_ErrorCode ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + Camera_Input *cameraInput = nullptr; + ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(&cameraInput, nullptr); + + ret = OH_CameraInput_Open(cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + ret = OH_CaptureSession_BeginConfig(captureSession); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_AddInput(captureSession, cameraInput); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_AddPhotoOutput(captureSession, photoOutput); + EXPECT_EQ(ret, 0); + + ret = OH_CaptureSession_CommitConfig(captureSession); + EXPECT_EQ(ret, 0); + + ret = OH_CaptureSession_Start(captureSession); + EXPECT_EQ(ret, 0); + + float minZoom = 0.0f, maxZoom = 0.0f; + ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom); + EXPECT_EQ(ret, 0); + + float zoom = 0.0f; + ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom); + EXPECT_EQ(ret, 0); + + Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_MANUAL; + bool isSupportedFocusMode = true; + ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode); + EXPECT_EQ(ret, 0); + + Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO; + ret = OH_CaptureSession_SetFocusMode(captureSession, focus); + EXPECT_EQ(ret, 0); + + Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN; + ret = OH_CaptureSession_SetFlashMode(captureSession, flash); + EXPECT_EQ(ret, 0); + + Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + bool isSupportedExposureMode = true; + ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode); + EXPECT_EQ(ret, 0); + + Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + ret = OH_CaptureSession_SetExposureMode(captureSession, exposure); + EXPECT_EQ(ret, 0); + + ret = OH_CaptureSession_Release(captureSession); + EXPECT_EQ(ret, 0); + ReleaseImageReceiver(); +} + +/* + * Feature: Framework + * Function: Test capture session about zoom and mode with not commit + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test capture session about zoom and mode with not commit + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_010, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + + float minZoom = 0.0f, maxZoom = 0.0f; + ret = OH_CaptureSession_GetZoomRatioRange(captureSession, &minZoom, &maxZoom); + EXPECT_EQ(ret, 0); + + float zoom = 0.0f; + ret = OH_CaptureSession_SetZoomRatio(captureSession, zoom); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_FocusMode focusMode = Camera_FocusMode::FOCUS_MODE_AUTO; + bool isSupportedFocusMode = true; + ret = OH_CaptureSession_IsFocusModeSupported(captureSession, focusMode, &isSupportedFocusMode); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_FocusMode focus = Camera_FocusMode::FOCUS_MODE_AUTO; + ret = OH_CaptureSession_SetFocusMode(captureSession, focus); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_Point FocusPointSet = {1.0, 2.0}; + ret = OH_CaptureSession_SetFocusPoint(captureSession, FocusPointSet); + + Camera_FlashMode flash = Camera_FlashMode::FLASH_MODE_ALWAYS_OPEN; + ret = OH_CaptureSession_SetFlashMode(captureSession, flash); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_ExposureMode exposureMode = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + bool isSupportedExposureMode = true; + ret = OH_CaptureSession_IsExposureModeSupported(captureSession, exposureMode, &isSupportedExposureMode); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); + + Camera_ExposureMode exposure = Camera_ExposureMode::EXPOSURE_MODE_AUTO; + ret = OH_CaptureSession_SetExposureMode(captureSession, exposure); + EXPECT_EQ(ret, CAMERA_SERVICE_FATAL_ERROR); +} + +/* + * Feature: Framework + * Function: Test capture session remove input + * SubFunction: NA + * FunctionPoints: NA + * EnvConditions: NA + * CaseDescription: Test capture session remove input + */ +HWTEST_F(CameraNdkUnitTest, camera_fwcoveragendk_unittest_011, TestSize.Level0) +{ + Camera_ErrorCode ret = CAMERA_OK; + Camera_Input *cameraInput = nullptr; + ret = OH_CameraManager_CreateCameraInput(cameraManager, cameraDevice, &cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + ret = OH_CameraInput_Open(cameraInput); + EXPECT_EQ(ret, CAMERA_OK); + Camera_CaptureSession* captureSession = nullptr; + ret = OH_CameraManager_CreateCaptureSession(cameraManager, &captureSession); + EXPECT_EQ(ret, CAMERA_OK); + EXPECT_NE(captureSession, nullptr); + ret = OH_CaptureSession_BeginConfig(captureSession); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_AddInput(captureSession, cameraInput); + EXPECT_EQ(ret, 0); + Camera_PreviewOutput* previewOutput = CreatePreviewOutput(); + EXPECT_NE(previewOutput, nullptr); + ret = OH_CaptureSession_AddPreviewOutput(captureSession, previewOutput); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_CommitConfig(captureSession); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_BeginConfig(captureSession); + EXPECT_EQ(ret, 0); + ret = OH_CaptureSession_RemoveInput(captureSession, cameraInput); + EXPECT_EQ(ret, 0); + ret = OH_CameraInput_Release(cameraInput); + EXPECT_EQ(ret, 0); + cameraInput = nullptr; +} } // CameraStandard } // OHOS \ No newline at end of file diff --git a/services/camera_service/src/hcamera_device.cpp b/services/camera_service/src/hcamera_device.cpp index 489f464ef7c2d9c2a6913c0817afaeebb2fd65a4..dbc6ad2f8cd09f520336580a9a10c4391d8833e3 100644 --- a/services/camera_service/src/hcamera_device.cpp +++ b/services/camera_service/src/hcamera_device.cpp @@ -687,10 +687,11 @@ int32_t HCameraDevice::GetStreamOperator(sptr callback, CamRetCode rc; sptr hdiCameraDeviceV1_1; sptr hdiCameraDeviceV1_2; - if (cameraHostManager_->GetVersionByCamera(cameraID_) >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) { + int32_t versionRes = cameraHostManager_->GetVersionByCamera(cameraID_); + if (versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) { MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_1"); hdiCameraDeviceV1_2 = OHOS::HDI::Camera::V1_2::ICameraDevice::CastFrom(hdiCameraDevice_); - } else if (cameraHostManager_->GetVersionByCamera(cameraID_) == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) { + } else if (versionRes == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) { MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice cast to V1_1"); hdiCameraDeviceV1_1 = OHOS::HDI::Camera::V1_1::ICameraDevice::CastFrom(hdiCameraDevice_); if (hdiCameraDeviceV1_1 == nullptr) { @@ -699,7 +700,7 @@ int32_t HCameraDevice::GetStreamOperator(sptr callback, } } if (hdiCameraDeviceV1_2 != nullptr && - cameraHostManager_->GetVersionByCamera(cameraID_) >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) { + versionRes >= GetVersionId(HDI_VERSION_1, HDI_VERSION_2)) { MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice V1_2"); sptr streamOperator_v1_2; sptr callback_v1_2 = @@ -707,7 +708,7 @@ int32_t HCameraDevice::GetStreamOperator(sptr callback, rc = (CamRetCode)(hdiCameraDeviceV1_2->GetStreamOperator_V1_2(callback_v1_2, streamOperator_v1_2)); streamOperator = static_cast(streamOperator_v1_2.GetRefPtr()); } else if (hdiCameraDeviceV1_1 != nullptr && - cameraHostManager_->GetVersionByCamera(cameraID_) == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) { + versionRes == GetVersionId(HDI_VERSION_1, HDI_VERSION_1)) { MEDIA_DEBUG_LOG("HCameraDevice::GetStreamOperator ICameraDevice V1_1"); sptr streamOperator_v1_1; rc = (CamRetCode)(hdiCameraDeviceV1_1->GetStreamOperator_V1_1(callback, streamOperator_v1_1));