camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestatemachine/unittest_cxestatemachine.cpp
changeset 19 d9aefe59d544
child 42 feebad15db8c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/camerauis/cameraxui/cxengine/tsrc/unit/unittest_cxestatemachine/unittest_cxestatemachine.cpp	Fri Apr 16 14:51:30 2010 +0300
@@ -0,0 +1,223 @@
+/*
+* Copyright (c) 2009 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 <QTest>
+
+#include "unittest_cxestatemachine.h"
+#include "cxestate.h"
+#include "cxestatemachineunit.h"
+#include "cxeerrormappingsymbian.h" // CxeErrorHandlingSymbian
+
+// -----------------------------------
+// CxsStateMachine
+// -----------------------------------
+UnitTestCxeStateMachine::UnitTestCxeStateMachine()
+: mStateMachine(NULL), mStartState(NULL), mMiddleState(NULL), mEndState(NULL), mIsolatedState(NULL)
+{
+}
+
+UnitTestCxeStateMachine::~UnitTestCxeStateMachine()
+{
+}
+
+// Run before each individual test case
+void UnitTestCxeStateMachine::init()
+{
+    // create instance of the unit to be tested
+    mStateMachine = new CxeStateMachineUnit("UnitTestCxeStateMachine");
+
+    // create test data (CxeState class is tested separated, so we assume it works correctly)
+    // these state classes are according to specification,
+    // error input is created in that particular test case
+    mStartState = new CxeState(StartId, "Start", MiddleId); // starting state
+    mMiddleState = new CxeState(MiddleId, "Middle", StartId|EndId|MiddleId); // middle state, "normal"
+    mEndState = new CxeState(EndId, "End", 0); // cannot transfer to other states
+    mIsolatedState = new CxeState(IsolatedId, "Isolated", MiddleId); // cannot be set after any other state
+
+    QVERIFY(mStateMachine->addState(mStartState));
+    QVERIFY(mStateMachine->addState(mMiddleState));
+    QVERIFY(mStateMachine->addState(mEndState));
+    QVERIFY(mStateMachine->addState(mIsolatedState));
+}
+
+// Run after each individual test case
+void UnitTestCxeStateMachine::cleanup()
+{
+    // state machine takes ownership of the states when states are added to statemachine
+    // those are deleted when statemachine is deleted
+    delete mStateMachine;
+    mStateMachine = NULL;
+
+    mStartState = NULL;
+    mMiddleState = NULL;
+    mEndState = NULL;
+    mIsolatedState = NULL;
+}
+
+
+void UnitTestCxeStateMachine::testAddState(){
+
+    // test error cases ( OK cases are tested in init )
+    CxeState* mErrorState = NULL;
+
+    // add same state twice -> NOK
+    QVERIFY(!mStateMachine->addState(mStartState));
+
+    // stateId should not have overlapping bits, because we need to be able to use bitwise
+    // AND operator -> NOK
+    mErrorState = new CxeState(5, "Overlapping id", StartId|MiddleId);
+    QVERIFY(!mStateMachine->addState(mErrorState));
+    delete mErrorState;
+
+    // add state with negative id -> NOK
+    mErrorState = new CxeState(-1, "Negative id", StartId|MiddleId);
+    QVERIFY(!mStateMachine->addState(mErrorState));
+    delete mErrorState;
+
+    // add null state -> NOK
+    QVERIFY(!mStateMachine->addState(NULL));
+}
+
+void UnitTestCxeStateMachine::testSetState()
+{
+
+    // CxeStateMachine::setState
+    // sets a state, verifies the that change is allowed, informs about the state change
+    // NOTE: check that handleStateChange is called, when state changes (correct parameters)
+    // NOTE: check that correct stateid is returned after change
+    // NOTE: verifyStateChange has separate testing
+
+    // reset the counter for handleStateChanged slot
+    mStateMachine->mHandleStateChangedCounter = 0;
+
+    // set state, when initial state is not set -> NOK
+    // check that handleStateChange is not called
+    // current state is undefined
+    QVERIFY(!mStateMachine->setState(StartId, 2));
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 0);
+    QCOMPARE(mStateMachine->stateId(), 0);
+
+    // set start state as initial state, change to another state (allowed change) -> OK
+    // (there should be a call to state change, check the error code)
+    mStateMachine->setInitialState(StartId);
+    QVERIFY(mStateMachine->setState(MiddleId, 0));
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 1);
+    QVERIFY(mStateMachine->mStateChangeStateId == MiddleId);
+    QVERIFY(mStateMachine->mStateChangeErrorId == CxeErrorHandlingSymbian::map(0));
+    QVERIFY(mStateMachine->stateId() == MiddleId);
+
+    // set another state (allowed change) -> OK
+    // check the error code is correct one (return value is mapped error value)
+    QVERIFY(mStateMachine->setState(EndId, -1));
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 2);
+    QVERIFY(mStateMachine->mStateChangeStateId == EndId);
+    QVERIFY(mStateMachine->mStateChangeErrorId == CxeErrorHandlingSymbian::map(-1));
+    QVERIFY(mStateMachine->stateId() == EndId);
+
+    // reset the counter for handleStateChanged slot
+    mStateMachine->mHandleStateChangedCounter = 0;
+
+    // set same state again -> OK
+    // but state change should not be called
+    QVERIFY(mStateMachine->setState(EndId, 0));
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 0);
+
+    // setstate to a state that does not exists -> NOK
+    // state has not changed
+    QVERIFY(mStateMachine->stateId() == EndId);
+    QVERIFY(!mStateMachine->setState(UnknownId));
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 0);
+    QVERIFY(mStateMachine->stateId() == EndId);
+
+    // state change verification method has own test cases
+}
+
+void UnitTestCxeStateMachine::testSetInitialState()
+{
+    // CxeStateMachine::setInitialState
+    // sets a initial state
+    // check that handleStateChange is not called
+    // check that correct state has been set
+
+    // set state, when initial state is not set -> OK
+    QVERIFY(mStateMachine->setInitialState(StartId));
+    QVERIFY(mStateMachine->stateId() == StartId);
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 0);
+
+    // set state, when initial state is already set -> NOK
+    QVERIFY(!mStateMachine->setInitialState(MiddleId));
+    QVERIFY(mStateMachine->stateId() == StartId);
+    QCOMPARE(mStateMachine->mHandleStateChangedCounter, 0);
+
+}
+
+void UnitTestCxeStateMachine::testStateId()
+{
+
+    // check state id, when initial state not set -> stateid == 0
+    QCOMPARE(mStateMachine->stateId(), 0);
+
+    // setinitialstate -> check state id
+    mStateMachine->setInitialState(StartId);
+    QVERIFY(mStateMachine->stateId() == StartId);
+
+}
+
+void UnitTestCxeStateMachine::testVerifyStateChange()
+{
+    // test change possibilities
+
+    // initial START -> MIDDLE -> OK
+    // START -> END -> NOK
+    // START -> ISOLATED -> NOK
+    // START -> 0 -> NOK
+    // START -> UnknownId -> NOK
+    // START -> START -> NOK (since START is not defined in allowed next state)
+    mStateMachine->setInitialState(StartId);
+    QVERIFY(mStateMachine->verifyStateChange(MiddleId));
+    QVERIFY(!mStateMachine->verifyStateChange(EndId));
+    QVERIFY(!mStateMachine->verifyStateChange(IsolatedId));
+    QVERIFY(!mStateMachine->verifyStateChange(0));
+    QVERIFY(!mStateMachine->verifyStateChange(UnknownId));
+    QVERIFY(!mStateMachine->verifyStateChange(StartId));
+
+    // MIDDLE -> ISOLATED -> NOK
+    // MIDDLE -> START -> OK
+    // MIDDLE -> END -> OK
+    // MIDDLE -> 0 -> NOK
+    // MIDDLE -> MIDDLE -> OK (defined in allowed next states)
+    mStateMachine->setState(MiddleId);
+    QVERIFY(!mStateMachine->verifyStateChange(IsolatedId));
+    QVERIFY(mStateMachine->verifyStateChange(StartId));
+    QVERIFY(mStateMachine->verifyStateChange(EndId));
+    QVERIFY(!mStateMachine->verifyStateChange(0));
+
+    // END -> MIDDLE -> NOK
+    // END -> START -> NOK
+    // END -> 0 -> NOK
+    // END -> UnknownId -> NOK
+    mStateMachine->setState(EndId);
+    QVERIFY(!mStateMachine->verifyStateChange(MiddleId));
+    QVERIFY(!mStateMachine->verifyStateChange(StartId));
+    QVERIFY(!mStateMachine->verifyStateChange(0));
+    QVERIFY(!mStateMachine->verifyStateChange(UnknownId));
+
+}
+
+
+// main() function non-GUI testing
+QTEST_APPLESS_MAIN(UnitTestCxeStateMachine);
+