--- /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 <ssm/ssmstates.hrh>
+#include <ssm/ssmsubstates.hrh>
+#include <ssm/ssmstate.h>
+#include <ssm/ssmstatetransition.h>
+#include <ssm/ssmstatemanager.h>
+#include <ssm/ssmstateawaresession.h>
+#include <ssm/ssmdomaindefs.h>
+
+#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<CStateTranFromShutdown*>(aStateTranFromShutdown);
+ TRAPD(err,stateTran->CallStopSchedulerL());
+ return err;
+ }
+
+static TInt StartTest(TAny* aStateTranFromShutdown)
+ {
+ TInt testCompletionReason = KErrNone;
+ CStateTranFromShutdown* stateTran = reinterpret_cast<CStateTranFromShutdown*>(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;
+ }
+
+
+