camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxeautofocuscontrolsymbian/unittest_cxeautofocuscontrolsymbian.cpp
/*
* 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 <QDate>
#include <QTest>
#include <QDebug>
#include <QSignalSpy>
#include <QThread>
#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>("CxeError::Id");
qRegisterMetaType<CxeAutoFocusControl::State>("CxeAutoFocusControl::State");
qRegisterMetaType<CxeAutoFocusControl::Mode>("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
// prequisites: 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)
// prequisites:
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
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::testHandleCameraEvent()
{
// 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);
// cleanup and init to make sure that the dummy engine is not messed up
// and we get to initial state
cleanup();
init();
// Input 2 -----------------------------------------------------
// Notifies a change in autofocus type
eventUid = KUidECamEventCameraSettingAutoFocusType2UidValue;
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));
// cleanup and init to make sure that the dummy engine is not messed up
// and we get to initial state
cleanup();
init();
// Input 3 -----------------------------------------------------
// Focus range have changed
eventUid = KUidECamEventCameraSettingFocusRangeUidValue;
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);