diff -r f54ad444594d -r 61bc0f252b2b camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp Tue Aug 31 15:03:46 2010 +0300 @@ -0,0 +1,457 @@ +/* +* Copyright (c) 2009-2010 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ +#include +#include +#include +#include +#include + +#include "cxetestutils.h" +#include "cxefakecameradevicecontrol.h" +#include "cxefakecameradevice.h" +#include "cxefakesettings.h" +#include "cxeautofocuscontrolsymbianunit.h" +#include "unittest_cxeautofocuscontrolsymbian.h" +#include "cxenamespace.h" + +UnitTestCxeAutoFocusControlSymbian::UnitTestCxeAutoFocusControlSymbian() + : mAutoFocusControl(NULL), + mCameraDeviceControl(NULL), + mCameraDevice(NULL), + mFakeSettings(NULL) +{ + qRegisterMetaType("CxeError::Id"); + qRegisterMetaType("CxeAutoFocusControl::State"); + qRegisterMetaType("CxeAutoFocusControl::Mode"); +} + +UnitTestCxeAutoFocusControlSymbian::~UnitTestCxeAutoFocusControlSymbian() +{ +} + +// Run before each individual test case +void UnitTestCxeAutoFocusControlSymbian::init() +{ + CX_DEBUG_ENTER_FUNCTION(); + + mFakeSettings = new CxeFakeSettings(); + + mCameraDeviceControl = new CxeFakeCameraDeviceControl(); + mCameraDevice = new CxeFakeCameraDevice(); + mCameraDevice->newCamera(mCameraDeviceControl->cameraIndex(), mCameraDeviceControl); + + mAutoFocusControl = new CxeAutoFocusControlSymbianUnit(*mCameraDevice, *mFakeSettings); + + // make sure that initialization is correct + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Hyperfocal); + QCOMPARE(mAutoFocusControl->isSoundEnabled(), false); + QCOMPARE(mAutoFocusControl->supported(), true); + + CX_DEBUG_EXIT_FUNCTION(); +} + +// Run after each individual test case +void UnitTestCxeAutoFocusControlSymbian::cleanup() +{ + CX_DEBUG_ENTER_FUNCTION(); + + delete mAutoFocusControl; + mAutoFocusControl = NULL; + + delete mCameraDeviceControl; + mCameraDeviceControl = NULL; + + delete mCameraDevice; + mCameraDevice = NULL; + + delete mFakeSettings; + mFakeSettings = NULL; + + CX_DEBUG_EXIT_FUNCTION(); +} + + +void UnitTestCxeAutoFocusControlSymbian::testStart() +{ + // start takes a boolean input and returns CxeError + // functionality depends on current state and current autofocus mode + + QSignalSpy stateSpy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + + CxeError::Id returnValue = CxeError::None; + // 1) Default input after initialisation (fixed focus) -> nothing should happen + returnValue = mAutoFocusControl->start(); + // verifying the result: + QVERIFY(returnValue == CxeError::None); + QCOMPARE(mAutoFocusControl->isSoundEnabled(), true); // check for input paramete + // no state changes + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + + // 2) Input parameter false is handled correctly + // prerequisites : not fixed mode & unknown state -> normal functionality + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // non-fixed + // function call + returnValue = mAutoFocusControl->start(false); + // verifying the result: + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); + QCOMPARE(returnValue, CxeError::None); + QCOMPARE(mAutoFocusControl->isSoundEnabled(), false); // check for input parameter + + // 3) Autofocus is not ready (state is cancelling or in progress) + // prerequisites : + mAutoFocusControl->setMode(CxeAutoFocusControl::Macro); // non-fixed mode + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); + // start should return CxeError::InUse + returnValue = mAutoFocusControl->start(); + QCOMPARE(returnValue, CxeError::InUse); + + // 4) Camera has been released + // Cannot be tested like this since assertion crashes the function + // AFTER prepareForCameraDelete CALL. + /*mAutoFocusControl->prepareForCameraDelete(); + stateSpy.clear(); + returnValue = mAutoFocusControl->start(); + // result: no signal should be emitted + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(returnValue, CxeError::None); // should there be and error here? + */ +} + +void UnitTestCxeAutoFocusControlSymbian::testCancel() +{ + // create signalspy to monitor that state changed signal + QSignalSpy spy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + + // 1) after initialisation cancel does nothing + mAutoFocusControl->cancel(); + // no state changes + QCOMPARE(spy.count(), 0); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + + // 2) When in fixed focus mode, cancel does nothing + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // non fixed mode so that start works + mAutoFocusControl->start(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity); // fixed mode + spy.clear(); + mAutoFocusControl->cancel(); + QCOMPARE(spy.count(), 0); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); + + // 3) InProgress state and "normal cancel" + // set mode back to non fixed mode + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); + mAutoFocusControl->cancel(); + // -> state is changed to Canceling + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); + // -> focustype set correctly + QVERIFY(mAutoFocusControl->focusType() + == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff); + + // 4) Canceling state (reached when calling canceling twice in a row, + // now already in canceling state after previous test) + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); + mAutoFocusControl->cancel(); + // -> state or focustype is not changing + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); + QVERIFY(mAutoFocusControl->focusType() + == CCamera::CCameraAdvancedSettings::EAutoFocusTypeOff); + + // 5) Ready state (cancel called after start has been called and focus + // found) + // force state to ready in order to test canceling + mAutoFocusControl->setState(CxeAutoFocusControl::Unknown); + mAutoFocusControl->start(); // changes to in progress + sets focus type & range + mAutoFocusControl->setState(CxeAutoFocusControl::Ready); + mAutoFocusControl->cancel(); + // state is changed to canceling + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); + +} + + +void UnitTestCxeAutoFocusControlSymbian::testIsFixedFocusMode() +{ + // default value (hyperfocal) + QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), true); + + // set non fixed focus mode + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); + QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), false); + + // set fixed focus mode + mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity); + QCOMPARE(mAutoFocusControl->isFixedFocusMode(mAutoFocusControl->mode()), true); + +} + +void UnitTestCxeAutoFocusControlSymbian::testSupported() +{ + bool supported = mAutoFocusControl->supported(); + QVERIFY(supported); +} + + +void UnitTestCxeAutoFocusControlSymbian::testPrepareForCameraDelete() +{ + // prepareCameraDelete calls prepareCameraRelease plus sets advanced + // settings false (supported() will return false) + // this test is for both methods + + // 1) initial values + mAutoFocusControl->prepareForCameraDelete(); + QCOMPARE(mAutoFocusControl->supported(), false); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + + // 2) test prepareForCameraDelete with non-initial values + mAutoFocusControl->handleCameraAllocated(CxeError::None); + // force state to be something else than Unknown and check that it will be changed + mAutoFocusControl->setState(CxeAutoFocusControl::Canceling); + // force mCancelled to be false and check that it will be changed + mAutoFocusControl->mCancelled = true; + mAutoFocusControl->prepareForCameraDelete(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->mCancelled, false); + QCOMPARE(mAutoFocusControl->supported(), false); + +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleCameraAllocated() +{ + // create signalspy to monitor that state changed signal + QSignalSpy stateSpy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + + // 1) initial setup without an error (camera is allocated already) + mAutoFocusControl->handleCameraAllocated(CxeError::None); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->supported(), true); + + // 2) release camera and call with an error code + // -> supported should return false since initializeResources is not called in error case + // -> state is not changed + mAutoFocusControl->prepareForCameraDelete(); + stateSpy.clear(); + mAutoFocusControl->handleCameraAllocated(CxeError::General); + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(mAutoFocusControl->supported(), false); + + // 3) release camera and call without an error + // (prepareForCameraDelete has been called in previous test) + // -> resources are initialized i.e. supported returns true + // first force state to something else so state change can be verified + mAutoFocusControl->setState(CxeAutoFocusControl::Canceling); + mAutoFocusControl->handleCameraAllocated(CxeError::None); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->supported(), true); + +} + +void UnitTestCxeAutoFocusControlSymbian::testPrepareForRelease() +{ + // see testPrepareForCameraDelete +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleCameraEventOptimalFocus() +{ + // handleCameraEvent handles callbacks and gets information about + // focus events. handleCameraEvent calls private method handleAfEvent + // for the focusing events that CxeAutoFocusControlSymbian needs + + // testing handleAfEvent is done by calling handleCameraEvent + // and monitoring state changes after each "event" + + QSignalSpy stateSpy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + + + // Input 1 ---------------------------------------------------- + // Optimal focus was reached or couldn't be found + int eventUid = KUidECamEventCameraSettingsOptimalFocusUidValue; + int symbianError = 0; //KErrNone + + // AutofocusControl class is not InProgress or Canceling state + // => event ignored, nothing is changed + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + + // AutoFocusControl is InProgress state (waiting for the focus) + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus + mAutoFocusControl->start(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + // => state should change to Ready + QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Ready); + + // InProgress state but focus fails + mAutoFocusControl->start(); + stateSpy.clear(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + mAutoFocusControl->handleCameraEvent(eventUid, -18); // KErrNotReady + // => state should change to Failed + QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Failed); + + // AutoFocusControl is in Canceling state + mAutoFocusControl->start(); + mAutoFocusControl->cancel(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); //verify start state + stateSpy.clear(); + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + // => state should change to Unknown + QVERIFY(CxeTestUtils::waitForSignal(stateSpy, 1000)); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleCameraEventAutofocusChanged() +{ + QSignalSpy stateSpy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + // Input 2 ----------------------------------------------------- + // Notifies a change in autofocus type + int eventUid = KUidECamEventCameraSettingAutoFocusType2UidValue; + int symbianError = -18; // == KErrNotReady + + // InProgress: event is ignored + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus + mAutoFocusControl->start(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + stateSpy.clear(); + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + + // Canceling: + // error parameter is ignored, state is not changed + mAutoFocusControl->cancel(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Canceling); //verify start state + stateSpy.clear(); + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleCameraEventFocusRangeChanged() +{ + QSignalSpy stateSpy(mAutoFocusControl, + SIGNAL(stateChanged(CxeAutoFocusControl::State, + CxeError::Id))); + + // Input 3 ----------------------------------------------------- + // Focus range have changed + int eventUid = KUidECamEventCameraSettingFocusRangeUidValue; + int symbianError = -2; // == KErrGeneral + + // In any other state than InProgress this event is ignored + stateSpy.clear(); + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + QVERIFY(!CxeTestUtils::waitForSignal(stateSpy, 1000)); + + // InProgress: because of the error parameter state changes to failed + // (focus range change failed because of error) + mAutoFocusControl->setMode(CxeAutoFocusControl::Auto); // not fixed focus + mAutoFocusControl->start(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + mAutoFocusControl->handleCameraEvent(eventUid, symbianError); + // => state should change to Failed + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Failed); +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleSceneChanged() +{ + // changes the autofocus settings to match the new scene settings + QVariantMap scene; + + // changes focus if new scene setting defines fixed focus + // otherwise sets the autofocus control to Unknown state (==initial state) + + // 1) change to a scene with fixed focus mode (Infinity & Hyperfocal) + scene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Infinity); + mAutoFocusControl->handleSceneChanged(scene); + // states are changed and mode is set correctly ->Unknown->InProgress + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); // end state + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Infinity); + + // 2) change to non-fixed mode (like Macro) + scene.clear(); + scene.insert(CxeSettingIds::FOCAL_RANGE, CxeAutoFocusControl::Macro); + mAutoFocusControl->handleSceneChanged(scene); + // states are changed and mode is set correctly + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro); + + // 3) try with error input (scene does not contain focal_range) + scene.clear(); + // change the autofocuscontrol state from Unknown (last test) to + // something else calling start() for example + mAutoFocusControl->start(); + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::InProgress); //verify start state + mAutoFocusControl->handleSceneChanged(scene); + // state is changed and mode is not changed + QCOMPARE(mAutoFocusControl->state(), CxeAutoFocusControl::Unknown); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro); + +} + +void UnitTestCxeAutoFocusControlSymbian::testHandleSettingValueChanged() +{ + // Autofocus mode needs to be updated when face trackin is actived in + // scene mod which doesn't support facetracking + + QVariant on = QVariant(1); + QVariant off = QVariant(0); + + // 1) check that mode does not change when some other setting value + // than face tracking is given + mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::LIGHT_SENSITIVITY, on); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Hyperfocal); + + // 2) check turning facetracking on, when mode is fixed + mAutoFocusControl->setMode(CxeAutoFocusControl::Infinity); + mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, on); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Auto); + QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, true); + + // 3) check turning facetracking off will return the previous mode + mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, off); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Infinity); + QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, false); + + // 4) check that turning facetracking off, when it is not on, won't + // set the previous mode + mAutoFocusControl->setMode(CxeAutoFocusControl::Macro); + mAutoFocusControl->handleSettingValueChanged(CxeSettingIds::FACE_TRACKING, off); + QCOMPARE(mAutoFocusControl->mode(), CxeAutoFocusControl::Macro); + QCOMPARE(mAutoFocusControl->mFaceTrackingOverride, false); + + +} + + + +// main() function - Need event loop for waiting signals, +// so can't use QTEST_APPLESS_MAIN. +QTEST_MAIN(UnitTestCxeAutoFocusControlSymbian);