diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstateplugins/test/tintgsapolicy/src/tgsa_step_statetrantodiffstates.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstateplugins/test/tintgsapolicy/src/tgsa_step_statetrantodiffstates.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,408 @@ +// 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 +#include + +/** +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(); + } + + + + +