sysstatemgmt/systemstateplugins/test/tintgsapolicy/src/tgsa_step_statetrantodiffstates.cpp
// Copyright (c) 2008-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:
//
/**
@file
@test
@internalComponent - Internal Symbian test code
*/
#include "tgsa_step_statetrantodiffstates.h"
#include "gsatestapps.h"
#include <ssm/ssmstates.hrh>
#include <ssm/ssmstate.h>
/**
Old Test CaseID AFSS-GSA-0030
New Test CaseID DEVSRVS-SSPLUGINS-GSA-0032
New Test CaseID DEVSRVS-SSPLUGINS-GSA-0033
New Test CaseID DEVSRVS-SSPLUGINS-GSA-0034
New Test CaseID DEVSRVS-SSPLUGINS-GSA-0035
*/
void CGsaStateTranToDiffStatesTest::DoStateRequestTransitionToDiffStatesL()
{
INFO_PRINTF1(_L("DoStateRequestTransitionToDiffStates test started...."));
RFs fs;
TInt err = fs.Connect();
TEST(err == KErrNone);
User::LeaveIfError(err);
CleanupClosePushL(fs);
if (iProcessName == KTestProcTranFromNormal)
{
RFileReadStream fileReadStream;
err = fileReadStream.Open(fs, KGsaTestStateTranFromNormalResult, EFileRead);
TEST(err == KErrNone);
User::LeaveIfError(err);
CleanupClosePushL(fileReadStream);
//System state before starting the test.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 1 - Request for state change from Normal to invalid state results in KErrNotSupported
INFO_PRINTF1(_L("Request for state change from Normal to invalid state"));
TInt stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 2 - Request for state change from Normal to fail state with invalid substate results in KErrNotSupported
INFO_PRINTF1(_L("Request for state change from Normal to fail state with invalid substate"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 3 - Request for two state changes(1. fail state 2. shutdown state) one after the other without waiting
// for the first one to complete. Cancels both transition request.
INFO_PRINTF1(_L("Request for two state changes(1. fail state 2. shutdown state)"));
INFO_PRINTF1(_L("one after the other without waiting for the first one to complete."));
INFO_PRINTF1(_L("Cancel the fail state transition request."));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("First request to the fail state will be completed with %d Expected -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("Second request to transit to the shutdown state will be completed with %d Expected -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 4 - Request for two state changes one after the other without waiting for the first one to complete
// Once first and second request are completed the system will be in fail state, now issue another state transition
// request to fail state again.
// The first request to the fail state will be completed with KErrCancel
// the second request to transit to the fail state will be completed with KErrNone.
// the third request to transit to the fail state will be completed with KErrNotSupported.
INFO_PRINTF1(_L("Request for two state changes one after the other without waiting"));
INFO_PRINTF1(_L("for the first one to complete. Once first and second request are completed the system will be in"));
INFO_PRINTF1(_L("fail state, now issue another state transition request to fail state again."));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("First request to the fail state will be completed with %d Expected -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("Second request to the fail state will be completed with %d Expected 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Third request to the fail state will be completed with %d Expected -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Finally the system should be in fail state i.e., just before the test application is closed.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmFail);
INFO_PRINTF1(_L("Test Process Exit Reason"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone && stateTranResult != KTestAppFailure);
INFO_PRINTF2(_L("Test process exits with %d Expected 0"), stateTranResult);
CleanupStack::PopAndDestroy();
// Delete the result file
//err = fs.Delete(KGsaTestStateTranFromNormalResult);
}
else if (iProcessName == KTestProcTranToShutdown)
{
RFileReadStream fileReadStream;
err = fileReadStream.Open(fs, KGsaTestStateTranToShutdownResult, EFileRead);
TEST(err == KErrNone);
User::LeaveIfError(err);
CleanupClosePushL(fileReadStream);
//System state before starting the test.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 1 - Request for state transition to shutdown state - invalid substate
// request to transit to the shutdown state will be completed with KErrNotSupported
INFO_PRINTF1(_L("Request for state transition to shutdown state - invalid substate"));
TInt stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 2 - Request for state transition to shutdown state - critical substate(Restart)
// Request for state transition to shutdown state - critical substate(Standby)
// first request to transit to the shutdown state critical substate(Restart)will be completed with KErrCancel
// second request to transit to the shutdown state critical substate(Standby)will be completed with KErrNone
INFO_PRINTF1(_L("Request for state transition to shutdown state - critical substate(Standby)"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("Actual : %d Expected : 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
INFO_PRINTF1(_L("Request for state transition to shutdown state - critical substate(Restart)"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("Actual : %d Expected : -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Finally the system should be in fail state i.e., just before the test application is closed.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmShutdown);
INFO_PRINTF1(_L("Test Process Exit Reason"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone && stateTranResult != KTestAppFailure);
INFO_PRINTF2(_L("Test process exits with %d Expected 0"), stateTranResult);
CleanupStack::PopAndDestroy();
// Delete the result file
//err = fs.Delete(KGsaTestStateTranToShutdownResult);
}
else if (iProcessName == KTestProcTranFromShutdown)
{
RFileReadStream fileReadStream;
err = fileReadStream.Open(fs, KGsaTestStateTranFromShutdownResult, EFileRead);
TEST(err == KErrNone);
User::LeaveIfError(err);
CleanupClosePushL(fileReadStream);
//System state before starting the test.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 1 - Request for state change from Normal to shutdown state to critical substate
// Cancel the request immediately
INFO_PRINTF1(_L("Request for state change from Normal to shutdown critical substate and Cancel the request"));
TInt stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("Actual : %d Expected : -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 2 - Request for state change from Normal to shutdown state to any substate
// Cancel the request immediately, so that we can proceed with the next test scenario.
INFO_PRINTF1(_L("Request for state change from Normal to shutdown any substate and Cancel the request"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("Actual : %d Expected : -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
//Scenario 3 - Request for three state changes(1. shutdown state 2. invalid state 3. fail state) one after the other
// i.e., second request is issued once first one is completed and the third one is issued after the second request is completed.
// Cancel the third request.
// first request to the shutdown state will be completed with KErrNone
// second request to transit to the fail state will be completed with KErrNotSupported
// third request to transit to the fail state will be completed with KErrCancel
INFO_PRINTF1(_L("Request for 3 state changes(1. shutdown state 2. invalid state 3. fail state)"));
INFO_PRINTF1(_L("one after the other. i.e., second request is issued once first one is completed"));
INFO_PRINTF1(_L("and the third one is issued after the second request is completed."));
INFO_PRINTF1(_L("Cancel the third request."));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("First request to the shutdown state will be completed with %d Expected 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Second request to transit to the fail state will be completed with %d Expected -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmNormal);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("Third request to transit to the fail state will be completed with %d Expected -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmShutdown);
//Scenario 4 - The system is now in shutdown state, request for state transition to normal state.
// request to transit to the normal state will be completed with KErrNotSupported
INFO_PRINTF1(_L("The system is now in shutdown state, request for state transition to normal state"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Request to transit to the normal state will be completed with %d Expected -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmShutdown);
//Scenario 5 - The system is now in shutdown state, request for state transition to fail state.
// request to transit to the fail state will be completed with KErrNone
INFO_PRINTF1(_L("The system is now in shutdown state, request for state transition to fail state"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("Request to transit to the normal state will be completed with %d Expected 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmShutdown);
//Finally the system should be in fail state i.e., just before the test application is closed.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmFail);
INFO_PRINTF1(_L("Test Process Exit Reason"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone && stateTranResult != KTestAppFailure);
INFO_PRINTF2(_L("Test process exits with %d Expected 0"), stateTranResult);
CleanupStack::PopAndDestroy();
// Delete the result file
//err = fs.Delete(KGsaTestStateTranFromShutdownResult);
}
else if(iProcessName == KTestProcTranFromStartup)
{
RFileReadStream fileReadStream;
err = fileReadStream.Open(fs, KGsaTestStateTranFromStartupResult, EFileRead);
TEST(err == KErrNone);
User::LeaveIfError(err);
CleanupClosePushL(fileReadStream);
//System state before starting the test.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Scenario 1 - Request for state change from Startup to invalid state
INFO_PRINTF1(_L("Request for state change from Startup to invalid state"));
TInt stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Scenario 2 - Request for state change from Startup to fail state with invalid substate
INFO_PRINTF1(_L("Request for state change from Startup to fail state with invalid substate"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Actual : %d Expected : -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Scenario 3 - Request for state change from Startup to shutdown invalid substate
INFO_PRINTF1(_L("Request for state change from Startup to shutdown invalid substate"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNotSupported);
INFO_PRINTF2(_L("Request for state change from Startup to shutdown invalid state completed with %d Expected -5"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Scenario 4 - Request for two state changes to fail state one after the other
//The first request to the fail state will be completed with KErrCancel and the second request to transit to the fail state will be completed with KErrNone.
INFO_PRINTF1(_L("Request for two state changes to fail state one after the other"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrCancel);
INFO_PRINTF2(_L("First request to the fail state will be completed with %d Expected -3"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("Second request to the fail state will be completed with %d Expected 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Finally the system should be in fail state i.e., just before the test application is closed.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmFail);
INFO_PRINTF1(_L("Test Process Exit Reason"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone && stateTranResult != KTestAppFailure);
INFO_PRINTF2(_L("Test process exits with %d Expected 0"), stateTranResult);
CleanupStack::PopAndDestroy();
// Delete the result file
//err = fs.Delete(KGsaTestStateTranFromStartupResult);
}
else if (iProcessName == KTGsaStateTranFromStartuptoShutdownStep)
{
RFileReadStream fileReadStream;
User::LeaveIfError(fileReadStream.Open(fs, KGsaTestStateTranFromStartupResult, EFileRead));
CleanupClosePushL(fileReadStream);
//Scenario 1 - Request for state change from Startup to shutdown critical substate
INFO_PRINTF1(_L("Request for state change from Startup to shutdown critical substate"));
TInt stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone);
INFO_PRINTF2(_L("Request for state change from Startup to shutdown critical substate completed with %d Expected 0"), stateTranResult);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmStartup);
//Finally the system should be in Shutdown state i.e., just before the test application is closed.
CurrentSystemStateForStateTranTestL(fileReadStream, ESsmShutdown);
INFO_PRINTF1(_L("Test Process Exit Reason"));
stateTranResult = fileReadStream.ReadInt32L();
TEST(stateTranResult == KErrNone && stateTranResult != KTestAppFailure);
INFO_PRINTF2(_L("Test process exits with %d Expected 0"), stateTranResult);
CleanupStack::PopAndDestroy();
}
else
{
TEST(err == KErrArgument);
return;
}
CleanupStack::PopAndDestroy();
INFO_PRINTF1(_L("case completed\n"));
}
// Tests the current system state
void CGsaStateTranToDiffStatesTest::CurrentSystemStateForStateTranTestL(RFileReadStream& aFileReadStream, TInt aSystemState)
{
TInt currentState = aFileReadStream.ReadUint16L();
TSsmState currentSystemState(currentState, KSsmAnySubState);
TSsmState expectedSystemState(aSystemState, KSsmAnySubState);
TEST(currentSystemState == expectedSystemState);
TPtrC currentSystemStateName(currentSystemState.Name());
TPtrC expectedSystemStateName(expectedSystemState.Name());
INFO_PRINTF3(_L("Current system state %S Expected %S"), ¤tSystemStateName, &expectedSystemStateName);
}
//---------------- CGsaStateTranToDiffStatesTest step ---------------------------------------
CGsaStateTranToDiffStatesTest::~CGsaStateTranToDiffStatesTest()
{
}
CGsaStateTranToDiffStatesTest::CGsaStateTranToDiffStatesTest(const TDesC& aProcessName) : iProcessName(aProcessName)
{
if (iProcessName == KTestProcTranToShutdown)
SetTestStepName(KTGsaStateTranToShutdownStep);
else if (iProcessName == KTestProcTranFromShutdown)
SetTestStepName(KTGsaStateTranFromShutdownStep);
else if (iProcessName == KTestProcTranFromNormal)
SetTestStepName(KTGsaStateTranFromNormalStep);
else if (iProcessName == KTestProcTranFromStartup)
SetTestStepName(KTGsaStateTranFromStartupStep);
else if (iProcessName == KTGsaStateTranFromStartuptoShutdownStep)
SetTestStepName(KTGsaStateTranFromStartuptoShutdownStep);
else
{
// If the test script is none of the above then we would fail the test
TEST(KErrArgument);
}
}
TVerdict CGsaStateTranToDiffStatesTest::doTestStepPreambleL()
{
return CTestStep::doTestStepPreambleL();
}
TVerdict CGsaStateTranToDiffStatesTest::doTestStepPostambleL()
{
return CTestStep::doTestStepPostambleL();
}
TVerdict CGsaStateTranToDiffStatesTest::doTestStepL()
{
INFO_PRINTF1(_L("CGsaStateTranToDiffStatesTest started...."));
__UHEAP_MARK;
// Run the tests
TRAPD(err, DoStateRequestTransitionToDiffStatesL());
INFO_PRINTF2(_L("DoStateRequestTransitionToDiffStatesL completed with %d...."),err);
TEST(err == KErrNone);
__UHEAP_MARKEND;
INFO_PRINTF1(_L("....CGsaStateTranToDiffStatesTest completed!!"));
return TestStepResult();
}