diff -r 000000000000 -r 4e1aa6a622a0 sysstatemgmt/systemstateplugins/test/tintgsapolicy/src/tgsastatetranfromshutdown.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/sysstatemgmt/systemstateplugins/test/tintgsapolicy/src/tgsastatetranfromshutdown.cpp Tue Feb 02 00:53:00 2010 +0200 @@ -0,0 +1,337 @@ +// 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 "gsatestapps.h" + +#include +#include +#include +#include +#include +#include +#include + +#include "tgsastatetran_base.h" + +class CStateTranFromShutdown : public CTGsaStateTransition + { +public: + static CStateTranFromShutdown* NewL(); + ~CStateTranFromShutdown(); + void StartTestL(); + void CallStopSchedulerL(); + +private: + void ConstructL(); + CStateTranFromShutdown(); + +public: + void DoTestStateTranFromShutdownL(); + }; + +static TInt StopScheduler(TAny* aStateTranFromShutdown) + { + CStateTranFromShutdown* stateTran = reinterpret_cast(aStateTranFromShutdown); + TRAPD(err,stateTran->CallStopSchedulerL()); + return err; + } + +static TInt StartTest(TAny* aStateTranFromShutdown) + { + TInt testCompletionReason = KErrNone; + CStateTranFromShutdown* stateTran = reinterpret_cast(aStateTranFromShutdown); + TBool stateTest = stateTran->DoStartStateTranTest(); + if (stateTest) + { + RDebug::Print(_L("\nStateTran Test: Start the tgsastatetranfromshutdown test\n")); + TRAP(testCompletionReason, stateTran->DoTestStateTranFromShutdownL()); + } + + return testCompletionReason; + } + +CStateTranFromShutdown* CStateTranFromShutdown::NewL() + { + CStateTranFromShutdown* self = new(ELeave) CStateTranFromShutdown(); + self->ConstructL(); + return self; + } + +void CStateTranFromShutdown::ConstructL() + { + CTGsaStateTransition::ConstructL(KGsaTestStateTranResultFilePath); + } + +CStateTranFromShutdown::~CStateTranFromShutdown() + { + } + +CStateTranFromShutdown::CStateTranFromShutdown() + { + } + +// Tests the Shutdown state transitions under different scenarios +void CStateTranFromShutdown::DoTestStateTranFromShutdownL() + { + // This async callback is used to stop the scheduler once the system goes into fail state. + iAsyncCallbackForStopScheduler = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle); + TCallBack stopSchedulerCallback(StopScheduler, this); + iAsyncCallbackForStopScheduler->Set(stopSchedulerCallback); + + // call the callback function which keeps looping until the system state gets into fail state. + iAsyncCallbackForStopScheduler->CallBack(); + + RSsmStateManager stateMan; + TInt err = stateMan.Connect(); + if (err == KErrNone) + RDebug::Print(_L("\nStateTran Test: RSsmStateManager sess Connect %d\n"), err); + else + { + RDebug::Print(_L("\nStateTran Test: Unable to connect to RSsmStateManager sess\n")); + User::Leave(KTestAppFailure); + } + + // Creates and open the result file for streaming + err = iFileWriteStream.Replace(iFs, KGsaTestStateTranFromShutdownResult, EFileWrite); + RDebug::Print(_L("\nStateTran Test: iFileWriteStream open with %d\n"), err); + + + // Gets the Current system state before starting the test + CurrentSystemStateL(); + + //Scenario 1 - Request for state change from Normal to shutdown state to critical substate + // Cancel the request immediately + RDebug::Print(_L("\nScenario 1 \n")); + TRequestStatus status_shutdowncritsubstate; + TSsmState shutdownState_Critical(ESsmShutdown, ESsmShutdownSubStateCritical); + TSsmStateTransition stateTrans_Shutdowncritical(shutdownState_Critical, 1); + + stateMan.RequestStateTransition(stateTrans_Shutdowncritical, status_shutdowncritsubstate); + RDebug::Print(_L("\n RequestStateTransition from Normal to shutdown state critical substate %d\n "), status_shutdowncritsubstate.Int()); + + stateMan.RequestStateTransitionCancel(); + + iFileWriteStream.WriteInt32L(status_shutdowncritsubstate.Int()); + if (status_shutdowncritsubstate.Int() == KErrCancel) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n RequestStateTransition from Normal to shutdown state critical substate completed %d Expected -3\n "), status_shutdowncritsubstate.Int()); + } + else + User::Leave(KTestAppFailure); + + //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. + RDebug::Print(_L("\nScenario 2 \n")); + TRequestStatus status_shutdownanysubstate; + TSsmState shutdownState_Any(ESsmShutdown, KSsmAnySubState); + TSsmStateTransition stateTrans_shutdownAnySubState(shutdownState_Any, 1); + + stateMan.RequestStateTransition(stateTrans_shutdownAnySubState, status_shutdownanysubstate); + RDebug::Print(_L("\n RequestStateTransition from Normal to shutdown state any substate %d\n "), status_shutdownanysubstate.Int()); + + stateMan.RequestStateTransitionCancel(); + + iFileWriteStream.WriteInt32L(status_shutdownanysubstate.Int()); + if (status_shutdownanysubstate.Int() == KErrCancel) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n RequestStateTransition from Normal to shutdown state any substate completed %d Expected -3\n "), status_shutdownanysubstate.Int()); + } + else + User::Leave(KTestAppFailure); + + //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 + RDebug::Print(_L("\nScenario 3 \n")); + + TRequestStatus status; + stateMan.RequestStateTransition(stateTrans_Shutdowncritical, status); + RDebug::Print(_L("\n Start First RequestStateTransition from Normal to shutdown state %d\n "), status.Int()); + + User::WaitForRequest(status); + iFileWriteStream.WriteInt32L(status.Int()); + if (status.Int() == KErrNone) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n First RequestStateTransition from Normal to shutdown state completes with %d Expected 0\n "), status.Int()); + } + else + User::Leave(KTestAppFailure); + + TRequestStatus status1; + TSsmState state(10, KSsmAnySubState); + TSsmStateTransition stateTrans_InvalidState(state, 1); + + stateMan.RequestStateTransition(stateTrans_InvalidState, status1); + RDebug::Print(_L("\n Start Second RequestStateTransition from shutdown to invalid state %d\n "), status1.Int()); + + User::WaitForRequest(status1); + + iFileWriteStream.WriteInt32L(status1.Int()); + if (status1.Int() == KErrNotSupported) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n Second RequestStateTransition from shutdown to invalid state completes %d Expected -5\n "), status1.Int()); + } + else + User::Leave(KTestAppFailure); + + TRequestStatus status2; + state.Set(ESsmFail, KSsmAnySubState); + TSsmStateTransition stateTrans3(state, 1); + + stateMan.RequestStateTransition(stateTrans3, status2); + RDebug::Print(_L("\n Start Third RequestStateTransition from Shutdown to fail state %d\n "), status2.Int()); + + stateMan.RequestStateTransitionCancel(); + User::WaitForRequest(status2); + + iFileWriteStream.WriteInt32L(status2.Int()); + if (status2.Int() == KErrCancel) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n Third RequestStateTransitionCancel from Shutdown to fail state completes %d Expected -3\n "), status2.Int()); + } + else + User::Leave(KTestAppFailure); + + //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 + RDebug::Print(_L("\nScenario 4 \n")); + + TSsmState state_Normal(ESsmNormal, KSsmAnySubState); + TSsmStateTransition stateTrans_NormalState(state_Normal, 1); + + stateMan.RequestStateTransition(stateTrans_NormalState, status1); + RDebug::Print(_L("\n RequestStateTransition from Shutdown to normal state %d\n "), status1.Int()); + + User::WaitForRequest(status1); + + iFileWriteStream.WriteInt32L(status1.Int()); + if (status1.Int() == KErrNotSupported) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n RequestStateTransition from Shutdown to normal state completes %d Expected -5\n "), status1.Int()); + } + else + User::Leave(KTestAppFailure); + + //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 + RDebug::Print(_L("\nScenario 5 \n")); + + stateMan.RequestStateTransition(stateTrans3, status1); + RDebug::Print(_L("\n RequestStateTransition from Shutdown to fail state %d\n "), status1.Int()); + + User::WaitForRequest(status1); + + iFileWriteStream.WriteInt32L(status1.Int()); + if (status1.Int() == KErrNone) + { + CurrentSystemStateL(); + RDebug::Print(_L("\n RequestStateTransition from Shutdown to fail state completes %d Expected 0\n "), status1.Int()); + } + else + User::Leave(KTestAppFailure); + } + +void CStateTranFromShutdown::StartTestL() + { + CActiveScheduler* sched=new(ELeave) CActiveScheduler; + CleanupStack::PushL(sched); + CActiveScheduler::Install(sched); + + // Notifier used to get the notification when system gets to fail state + CSsmStateAwareSession* notif_for_failstate = CSsmStateAwareSession::NewLC(KSM2UiServicesDomain3); + notif_for_failstate->AddSubscriberL(*this); + + // This async callback is used to start the state transition test once system enters to normal state. + iAsyncCallbackForStartTest = new(ELeave) CAsyncCallBack(CActive::EPriorityIdle); + TCallBack startTestCallback(StartTest, this); + iAsyncCallbackForStartTest->Set(startTestCallback); + + // call the callback function which keeps looping until the system state gets into normal state. + iAsyncCallbackForStartTest->CallBack(); + + RProcess::Rendezvous(KErrNone); + sched->Start(); + + CleanupStack::PopAndDestroy(2); + } + +void CStateTranFromShutdown::CallStopSchedulerL() + { + TSsmState currenState; + currenState = iSsmStateAwareSess.State(); + + TUint16 currentMainState = currenState.MainState(); + // Active scheduler is stopped once the system goes into fail state, else it issues a request for callback again + if (currentMainState == ESsmFail) + { + RDebug::Print(_L("\nStateTran Test: Stop Active Scheduler\n")); + iFileWriteStream.WriteUint16L(currentMainState); + CActiveScheduler::Stop(); + } + else + { + iAsyncCallbackForStopScheduler->CallBack(); + } + } + +TInt E32Main() + { + __UHEAP_MARK; + + CTrapCleanup* cleanup=CTrapCleanup::New(); + TInt r=KErrNoMemory; + TInt testCompletionReason = KErrNone; + if (cleanup) + { + __UHEAP_MARK; + CStateTranFromShutdown* stateTran = NULL; + TRAP(r, stateTran = CStateTranFromShutdown::NewL()); + if (r == KErrNone) + { + TRAP(testCompletionReason, stateTran->StartTestL()); + // testCompletionReason is the reason with which the test case completes. + TRAP(r, stateTran->CommitTestResultsL(testCompletionReason)); + delete stateTran; + } + delete cleanup; + __UHEAP_MARKEND; + + if (r != KErrNone) + { + User::Panic(_L("tgsastatetranfromnormalPanic"), r); + } + } + + __UHEAP_MARKEND; + return r; + } + + +