diff -r 000000000000 -r dfb7c4ff071f commsfwsupport/commselements/testing/ElementServer/src/StateMachineStep.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/commsfwsupport/commselements/testing/ElementServer/src/StateMachineStep.cpp Thu Dec 17 09:22:25 2009 +0200 @@ -0,0 +1,974 @@ +// Copyright (c) 2001-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: +// This contains ESock Test cases from section 15 +// +// + +#include "StateMachineStep.h" +#include + +void CElementStateMachineTestBase::Setup() + { + iActiveScheduler = CStateMachineImpl::StartActiveSchedulerL(); + CleanupStack::PushL(iActiveScheduler); + iStateMachine = CStateMachineImpl::NewL(); + } + +void CElementStateMachineTestBase::Destroy() + { + CleanupStack::PopAndDestroy(iStateMachine); + CActiveScheduler::Install(NULL); + CleanupStack::PopAndDestroy(iActiveScheduler); + } + +CElementStateMachineStep1_1::CElementStateMachineStep1_1() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep1_1); + } + +TVerdict CElementStateMachineStep1_1::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + GetIntFromConfig(KElementStateMachineStep1_1, KElementStateMachineHistory, iHistory); + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_1::doTestStepL() +/** + * @return - TVerdict code + * Tests that the history member of a state machine can be set and retreived correctly + */ + { + INFO_PRINTF2(_L("Check history can be set and retrieved as %d."), iHistory); + iStateMachine->UpdateHistory(iHistory); + TInt returnHistory = iStateMachine->History(); + INFO_PRINTF3(_L("Expected history: %d, returned history: %d"), iHistory, returnHistory); + if (returnHistory != iHistory) + iResult = EFail; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_1::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep1_2::CElementStateMachineStep1_2() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep1_2); + } + +TVerdict CElementStateMachineStep1_2::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + GetIntFromConfig(KElementStateMachineStep1_2, KElementStateMachineLastError, iLastError); + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_2::doTestStepL() +/** + * @return - TVerdict code + * Tests that the last error member of a state machine can be set and retreived correctly + */ + { + INFO_PRINTF2(_L("Check last error can be set and retrieved as %d."), iLastError); + iStateMachine->SetLastError(iLastError); + TInt returnLastError = iStateMachine->LastError(); + INFO_PRINTF3(_L("Expected last error: %d, returned : %d"), iLastError, returnLastError); + if (returnLastError != iLastError) + iResult = EFail; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_2::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep1_3::CElementStateMachineStep1_3() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep1_3); + } + +TVerdict CElementStateMachineStep1_3::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_3::doTestStepL() +/** + * @return - TVerdict code + * Tests that the suspend reques member of a state machine can be set and retreived correctly + */ + { + INFO_PRINTF1(_L("Check suspend request can be set and retrieved.")); + iStateMachine->SetSuspendRequest(EFalse); + TBool returnBool = iStateMachine->SuspendRequest(); + if (returnBool) + iResult = EFail; + iStateMachine->SetSuspendRequest(ETrue); + returnBool = iStateMachine->SuspendRequest(); + if (!returnBool) + iResult = EFail; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_3::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep1_4::CElementStateMachineStep1_4() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep1_4); + } + +TVerdict CElementStateMachineStep1_4::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + GetIntFromConfig(KElementStateMachineStep1_4, KElementStateMachNullRAllcLngth, iNullReAllocLength); + GetIntFromConfig(KElementStateMachineStep1_4, KElementStateMachSetRAllocLngth, iSetReAllocLength); + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_4::doTestStepL() +/** + * @return - TVerdict code + * Tests that the fragment member of a state machine can be allocated and returned + */ + { + INFO_PRINTF1(_L("Check fragmentation reallocation when fragment is null.")); + iStateMachine->SetFragment(NULL); + HBufC8* fragment = iStateMachine->ReAllocL(iNullReAllocLength); + TInt fragmentLength = fragment->Des().MaxSize(); + INFO_PRINTF3(_L("Expected length at least: %d, returned length: %d"), iNullReAllocLength, fragmentLength); + //Length returned is slightly bigger initially + if (fragmentLength < iNullReAllocLength) + iResult = EFail; + INFO_PRINTF1(_L("Check fragmentation reallocation when fragment is already set.")); + fragment = iStateMachine->ReAllocL(iSetReAllocLength); + fragmentLength = fragment->Des().MaxSize(); + INFO_PRINTF3(_L("Expected length at least: %d, returned length: %d"), iSetReAllocLength, fragmentLength); + if (fragmentLength < iSetReAllocLength) + iResult = EFail; + INFO_PRINTF1(_L("Check fragmentation reallocation isn't done when new length is greater than Des().MaxLength()")); + fragment = iStateMachine->ReAllocL((fragment->Des().MaxLength() - iSetReAllocLength) + 1); + fragmentLength = fragment->Des().MaxSize(); + INFO_PRINTF3(_L("Expected length at least: %d, returned length: %d"), iSetReAllocLength, fragmentLength); + if (fragmentLength < iSetReAllocLength) + iResult = EFail; + INFO_PRINTF1(_L("Check fragment return equals expected object")); + if (fragment != iStateMachine->Fragment()) + iResult = EFail; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_4::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep1_5::CElementStateMachineStep1_5() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep1_5); + } + +TVerdict CElementStateMachineStep1_5::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_5::doTestStepL() +/** + * @return - TVerdict code + * Tests state machine notifier member can be registered and deregistered + */ + { + CStateMachineNotifyImpl stateMachineNotify = CStateMachineNotifyImpl(); + INFO_PRINTF1(_L("Check that initial state machine notifier is NULL")); + MStateMachineNotify* stateMachineNotifyReturn = iStateMachine->StateMachineNotifier(); + if (stateMachineNotifyReturn != NULL) + iResult = EFail; + INFO_PRINTF1(_L("Check that the notifier can be set")); + iStateMachine->RegisterNotify(&stateMachineNotify); + stateMachineNotifyReturn = iStateMachine->StateMachineNotifier(); + if (stateMachineNotifyReturn != &stateMachineNotify) + iResult = EFail; + INFO_PRINTF1(_L("Check that the notifier can be cleared")); + iStateMachine->DeRegisterNotify(&stateMachineNotify); + stateMachineNotifyReturn = iStateMachine->StateMachineNotifier(); + if (stateMachineNotifyReturn != NULL) + iResult = EFail; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep1_5::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_1::CElementStateMachineStep2_1() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_1); + } + +TVerdict CElementStateMachineStep2_1::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = EGreenAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_1::doTestStepL() +/** + * @return - TVerdict code + * Tests that the state machine can be started correctly and moves through a set of states + */ + { + INFO_PRINTF1(_L("Check that state machine correctly moves through states GREEN, YELLOW, RED before stopping")); + INFO_PRINTF1(_L("Create asynchronous events (states)")); + CAsyncEventImpl greenAsync = CAsyncEventImpl(EGreenAsyncEvent, this, *iStateMachine, KErrNone); + CAsyncEventImpl yellowAsync = CAsyncEventImpl(EYellowAsyncEvent, this, *iStateMachine, KErrNone); + CAsyncEventImpl redAsync = CAsyncEventImpl(ERedAsyncEvent, this, *iStateMachine, KErrNone); + greenAsync.SetNext(&yellowAsync); + yellowAsync.SetNext(&redAsync); + redAsync.SetNext(NULL); + TRequestStatus startStatus; + INFO_PRINTF1(_L("Set state machine first active event to GREEN")); + iStateMachine->SetActiveEvent(&greenAsync); + INFO_PRINTF1(_L("Start state machine")); + iStateMachine->Start(&startStatus, NULL, NULL); + iActiveScheduler->Start(); + User::WaitForRequest(startStatus); + return TestStepResult(); + } + +void CElementStateMachineStep2_1::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == EGreenAsyncEvent) + { + if (aAsyncEvent == EGreenAsyncEvent) + INFO_PRINTF1(_L("Received expected GREEN state")); + else + { + INFO_PRINTF1(_L("Did not receive expected GREEN state")); + iResult = EFail; + } + iExpectedAsyncEvent = EYellowAsyncEvent; + } + else if (iExpectedAsyncEvent == EYellowAsyncEvent) + { + if (aAsyncEvent == EYellowAsyncEvent) + INFO_PRINTF1(_L("Received expected YELLOW state")); + else + { + INFO_PRINTF1(_L("Did not receive expected YELLOW state")); + iResult = EFail; + } + iExpectedAsyncEvent = ERedAsyncEvent; + } + else if (iExpectedAsyncEvent == ERedAsyncEvent) + { + if (aAsyncEvent == ERedAsyncEvent) + INFO_PRINTF1(_L("Received expected RED state")); + else + { + INFO_PRINTF1(_L("Did not receive expected RED state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_1::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_2::CElementStateMachineStep2_2() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_2); + } + +TVerdict CElementStateMachineStep2_2::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = ERedAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_2::doTestStepL() +/** + * @return - TVerdict code + * Tests that the state machine does nothing when started without a client status, + * and runs when one is attached with KRequestPending + */ + { + INFO_PRINTF1(_L("Create asynchronous RED event (state)")); + CAsyncEventImpl redAsync = CAsyncEventImpl(ERedAsyncEvent, this, *iStateMachine, KErrNone); + redAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to RED")); + iStateMachine->SetActiveEvent(&redAsync); + INFO_PRINTF1(_L("Start state machine with NULL client status")); + iStateMachine->Start(NULL, NULL, NULL); + TRequestStatus* nullClientStatus = iStateMachine->ClientStatus(); + INFO_PRINTF1(_L("Check returned client status from state machine is NULL")); + if (nullClientStatus != NULL) + { + INFO_PRINTF1(_L("NULL TRequestStatus not recieved from state machine!")); + iResult = EFail; + } + TRequestStatus clientStatus; + clientStatus = KRequestPending; + INFO_PRINTF1(_L("Set client status of state machine to KRequestPending")); + iStateMachine->SetClientStatus(&clientStatus); + INFO_PRINTF1(_L("Start state machine")); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + return TestStepResult(); + } + +void CElementStateMachineStep2_2::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (aAsyncEvent == ERedAsyncEvent) + INFO_PRINTF1(_L("Received expected RED state")); + else + { + INFO_PRINTF1(_L("Did not receive expected RED state")); + iResult = EFail; + } + } + +TVerdict CElementStateMachineStep2_2::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_3::CElementStateMachineStep2_3() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_3); + } + +TVerdict CElementStateMachineStep2_3::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = EPanicAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_3::doTestStepL() +/** + * @return - TVerdict code + * Tests that the state machine handles error upon an active event leaving in ProcessL + */ + { + INFO_PRINTF1(_L("Create asynchronous panicing event (state)")); + CAsyncEventImpl panicAsync = CAsyncEventImpl(EPanicAsyncEvent, this, *iStateMachine, KErrNone); + panicAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to PANIC")); + iStateMachine->SetActiveEvent(&panicAsync); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, NULL, NULL); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt errorCode = iStateMachine->LastError(); + INFO_PRINTF1(_L("Check returned error is expected error (from iLastError member)")); + INFO_PRINTF3(_L("Expected error: %d, received error: %d"), KElementStateMachineError, errorCode); + if (errorCode != KElementStateMachineError) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_3::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == EPanicAsyncEvent) + { + if (aAsyncEvent == EPanicAsyncEvent) + INFO_PRINTF1(_L("Received expected PANIC state")); + else + { + INFO_PRINTF1(_L("Did not receive expected PANIC state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_3::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_4::CElementStateMachineStep2_4() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_4); + } + +TVerdict CElementStateMachineStep2_4::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = EErroringAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_4::doTestStepL() +/** + * @return - TVerdict code + * Tests that the state machine sets and runs an error event if an active event returns an error + */ + { + INFO_PRINTF1(_L("Create asynchronous erroring and error events (states)")); + CAsyncEventImpl erroringAsync = CAsyncEventImpl(EErroringAsyncEvent, this, *iStateMachine, KElementStateMachineError); + CAsyncEventImpl errorAsync = CAsyncEventImpl(EErrorAsyncEvent, this, *iStateMachine, KErrNone); + erroringAsync.SetNext(NULL); + errorAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to ERRORING")); + iStateMachine->SetActiveEvent(&erroringAsync); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, NULL, NULL); + iStateMachine->SetErrorEvent(&errorAsync); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt error = iStateMachine->LastError(); + INFO_PRINTF1(_L("Check returned error is expected error (from iLastError member)")); + INFO_PRINTF3(_L("Expected error: %d, received error: %d"), KElementStateMachineError, error); + if (error != KElementStateMachineError) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_4::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == EErroringAsyncEvent) + { + if (aAsyncEvent == EErroringAsyncEvent) + INFO_PRINTF1(_L("Received expected ERRORING state")); + else + { + INFO_PRINTF1(_L("Did not receive expected ERRORING state")); + iResult = EFail; + } + iExpectedAsyncEvent = EErrorAsyncEvent; + } + else if (iExpectedAsyncEvent == EErrorAsyncEvent) + { + if (aAsyncEvent == EErrorAsyncEvent) + INFO_PRINTF1(_L("Received expected ERROR state")); + else + { + INFO_PRINTF1(_L("Did not receive expected ERROR state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_4::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_5::CElementStateMachineStep2_5() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_5); + } + +TVerdict CElementStateMachineStep2_5::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = EForcedErrorAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_5::doTestStepL() +/** + * @return - TVerdict code + * Tests that the state machine responds to retrospective errors being set in the async event + */ + { + INFO_PRINTF1(_L("Create asynchronous erroring and error events (states)")); + CAsyncEventImpl forcedErroringAsync = CAsyncEventImpl(EForcedErrorAsyncEvent, this, *iStateMachine, KElementStateMachineError); + forcedErroringAsync.SetNext(&forcedErroringAsync); + INFO_PRINTF1(_L("Set state machine first active event to FORCEDERRORING")); + iStateMachine->SetActiveEvent(&forcedErroringAsync); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, &forcedErroringAsync, NULL); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt error = iStateMachine->LastError(); + INFO_PRINTF1(_L("Check returned error is expected error (from iLastError member)")); + INFO_PRINTF3(_L("Expected error: %d, received error: %d"), KElementStateMachineError, error); + if (error != KElementStateMachineError) + iResult = EFail; + INFO_PRINTF1(_L("Check number of runs of async ProcessL")); + TInt runs = forcedErroringAsync.iRuns; + INFO_PRINTF2(_L("Expected runs: 2, actual runs: %d"), runs); + if (runs != 2) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_5::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == EForcedErrorAsyncEvent) + { + if (aAsyncEvent == EForcedErrorAsyncEvent) + INFO_PRINTF1(_L("Received expected FORCEDERRORING state")); + else + { + INFO_PRINTF1(_L("Did not receive expected FORCEDERRORING state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_5::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_6::CElementStateMachineStep2_6() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_6); + } + +TVerdict CElementStateMachineStep2_6::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = ECancelAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_6::doTestStepL() +/** + * @return - TVerdict code + * Tests cancelling the state machine with no error + */ + { + INFO_PRINTF1(_L("Create asynchronous cancelling event (state)")); + CAsyncEventImpl cancelAsync = CAsyncEventImpl(ECancelAsyncEvent, this, *iStateMachine, KErrNone); + cancelAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to CANCEL")); + iStateMachine->SetActiveEvent(&cancelAsync); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, NULL, NULL); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt error = clientStatus.Int(); + INFO_PRINTF1(_L("Check returned error is expected error")); + INFO_PRINTF3(_L("Expected error: %d, received error: %d"), KErrNone, error); + if (error != KErrNone) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_6::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == ECancelAsyncEvent) + { + if (aAsyncEvent == ECancelAsyncEvent) + INFO_PRINTF1(_L("Received expected CANCEL state")); + else + { + INFO_PRINTF1(_L("Did not receive expected CANCEL state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_6::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_7::CElementStateMachineStep2_7() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_7); + } + +TVerdict CElementStateMachineStep2_7::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = ECancelAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_7::doTestStepL() +/** + * @return - TVerdict code + * Tests cancelling the state machine with an error + */ + { + INFO_PRINTF1(_L("Create asynchronous cancelling and error events (states)")); + CAsyncEventImpl cancelAsync = CAsyncEventImpl(ECancelAsyncEvent, this, *iStateMachine, KElementStateMachineError); + CAsyncEventImpl errorAsync = CAsyncEventImpl(EErrorAsyncEvent, this, *iStateMachine, KErrNone); + cancelAsync.SetNext(NULL); + errorAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to CANCEL")); + iStateMachine->SetActiveEvent(&cancelAsync); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, &errorAsync, NULL); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt error = clientStatus.Int(); + INFO_PRINTF1(_L("Check returned error is expected error")); + INFO_PRINTF3(_L("Expected error: %d, received error: %d"), KErrCancel, error); + if (error != KErrCancel) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_7::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == ECancelAsyncEvent) + { + if (aAsyncEvent == ECancelAsyncEvent) + INFO_PRINTF1(_L("Received expected CANCEL state")); + else + { + INFO_PRINTF1(_L("Did not receive expected CANCEL state")); + iResult = EFail; + } + iExpectedAsyncEvent = EErrorAsyncEvent; + } + else if (iExpectedAsyncEvent == EErrorAsyncEvent) + { + if (aAsyncEvent == EErrorAsyncEvent) + INFO_PRINTF1(_L("Received expected ERROR state")); + else + { + INFO_PRINTF1(_L("Did not receive expected ERROR state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_7::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + } + +CElementStateMachineStep2_8::CElementStateMachineStep2_8() +/** + * Constructor + */ + { + // Call base class method to set up the human readable name for logging + SetTestStepName(KElementStateMachineStep2_8); + } + +TVerdict CElementStateMachineStep2_8::doTestStepPreambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + SetTestStepResult(EFail); + iResult = EFail; + Setup(); + iExpectedAsyncEvent = EGreenAsyncEvent; + iResult = EPass; + return TestStepResult(); + } + +TVerdict CElementStateMachineStep2_8::doTestStepL() +/** + * @return - TVerdict code + * Tests suspending and restarting the state machine + */ + { + INFO_PRINTF1(_L("Create asynchronous green, red and suspend events (states)")); + CAsyncEventImpl greenAsync = CAsyncEventImpl(EGreenAsyncEvent, this, *iStateMachine, KErrNone); + CAsyncEventImpl suspendAsync = CAsyncEventImpl(ESuspendAsyncEvent, this, *iStateMachine, KErrNone); + CAsyncEventImpl redAsync = CAsyncEventImpl(ERedAsyncEvent, this, *iStateMachine, KErrNone); + greenAsync.SetNext(&suspendAsync); + suspendAsync.SetNext(&redAsync); + redAsync.SetNext(NULL); + INFO_PRINTF1(_L("Set state machine first active event to GREEN")); + iStateMachine->SetActiveEvent(&greenAsync); + CStateMachineNotifyImpl stateMachineNotify = CStateMachineNotifyImpl(); + INFO_PRINTF1(_L("Start state machine")); + TRequestStatus clientStatus; + iStateMachine->Start(&clientStatus, NULL, &stateMachineNotify); + iActiveScheduler->Start(); + User::WaitForRequest(clientStatus); + TInt greenRuns = greenAsync.iRuns; + INFO_PRINTF2(_L("Check that GREEN has been run once, runs: %d"), greenRuns); + if (greenRuns != 1) + iResult = EFail; + TInt suspendRuns = suspendAsync.iRuns; + INFO_PRINTF2(_L("Check that SUSPEND has been run once, runs: %d"), suspendRuns); + if (suspendRuns != 1) + iResult = EFail; + TInt redRuns = redAsync.iRuns; + INFO_PRINTF2(_L("Check that RED has been run once, runs: %d"), redRuns); + if (redRuns != 1) + iResult = EFail; + return TestStepResult(); + } + +void CElementStateMachineStep2_8::LogStateChange(TAsyncEventTest aAsyncEvent) + { + if (iExpectedAsyncEvent == EGreenAsyncEvent) + { + if (aAsyncEvent == EGreenAsyncEvent) + INFO_PRINTF1(_L("Received expected GREEN state")); + else + { + INFO_PRINTF1(_L("Did not receive expected GREEN state")); + iResult = EFail; + } + iExpectedAsyncEvent = ESuspendAsyncEvent; + } + else if (iExpectedAsyncEvent == ESuspendAsyncEvent) + { + if (aAsyncEvent == ESuspendAsyncEvent) + INFO_PRINTF1(_L("Received expected SUSPEND state")); + else + { + INFO_PRINTF1(_L("Did not receive expected SUSPEND state")); + iResult = EFail; + } + iExpectedAsyncEvent = ERedAsyncEvent; + } + else if (iExpectedAsyncEvent == ERedAsyncEvent) + { + if (aAsyncEvent == ERedAsyncEvent) + INFO_PRINTF1(_L("Received expected RED state")); + else + { + INFO_PRINTF1(_L("Did not receive expected RED state")); + iResult = EFail; + } + } + } + +TVerdict CElementStateMachineStep2_8::doTestStepPostambleL() +/** + * @return - TVerdict code + * Override of base class virtual + */ + { + Destroy(); + SetTestStepResult(iResult); + return TestStepResult(); + }