--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sysstatemgmt/systemstateplugins/test/tunitutilityplugin/src/tutilityplugin_step.cpp	Tue Feb 02 00:53:00 2010 +0200
@@ -0,0 +1,540 @@
+// 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 <w32std.h>
+#include <e32property.h>
+#include <e32power.h>
+#include <startupdomaindefs.h>
+#include <ssm/ssmsubstates.hrh>
+#include <ssm/ssmstatemanager.h>
+#include <hal.h>
+#include <ssm/ssmpatchableconstants.h>
+#include <e32uid.h>
+
+#include "tutilityplugin_step.h"
+
+TUid TestCategory = {0x456};
+TUint TestKey = 123;
+TInt TestDefaultValue = EPwActive;
+const TUint KWaitTimer = 10000000;	// 10 seconds
+
+CShutdownNotifObserverTimer* CShutdownNotifObserverTimer::NewL()
+    {
+    CShutdownNotifObserverTimer* self = new (ELeave) CShutdownNotifObserverTimer();
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+CShutdownNotifObserverTimer::~CShutdownNotifObserverTimer()
+    {
+    Cancel();
+    delete iScheduler;
+    }
+
+void CShutdownNotifObserverTimer::StartTimer(TInt32 aTimeout)
+    {
+    After(aTimeout);
+    CActiveScheduler::Start();
+    }
+
+void CShutdownNotifObserverTimer::RunL()
+    {
+    User::LeaveIfError(RProperty::Set(TestCategory, TestKey, 0xBAD));
+    RDebug::Print(_L("CShutdownNotifObserverTimer::RunL"));
+    
+    CActiveScheduler::Stop();
+    }
+
+TInt CShutdownNotifObserverTimer::RunError(TInt aError)
+	{
+	RDebug::Print(_L("RProperty::Set for TestCategory: 0x%x, TestKey: %d failed with an error: %d"), TestCategory, TestKey, aError);
+	return KErrNone;
+	}
+
+void CShutdownNotifObserverTimer::ConstructL()
+    {
+    iScheduler = new (ELeave) CActiveScheduler();
+    CActiveScheduler::Install(iScheduler);
+    CActiveScheduler::Add(this);
+    CTimer::ConstructL();
+    }
+
+CShutdownNotifObserverTimer::CShutdownNotifObserverTimer() : CTimer(EPriorityStandard)
+    {
+    }
+
+CUtilityPluginTest::CUtilityPluginTest(const TDesC& aStepName)
+	{
+	SetTestStepName(aStepName);
+	}
+
+CUtilityPluginTest::~CUtilityPluginTest()
+	{
+	}
+
+TVerdict CUtilityPluginTest::doTestStepPreambleL()
+	{
+	TInt startupMode = GetStartUpModeL();
+	if (IsSsmGracefulShutdown()&& (startupMode!=1))
+		{
+		INFO_PRINTF1(_L("Wait for lafshutdowneventobserveradaptor.dll to load"));
+		User::After(5000000);
+		//define the test property to check the power mode, this will be set through product code.
+		_LIT_SECURITY_POLICY_PASS(KReadPolicy);
+		_LIT_SECURITY_POLICY_PASS(KWritePolicy);
+		TInt err = RProperty::Define(TestCategory, TestKey, RProperty::EInt, KReadPolicy, KWritePolicy);
+		INFO_PRINTF2(_L("Test key defined to store the power state with err : [%d]"), err);
+		SetDefaultTestKey();
+		}
+	return CTestStep::doTestStepPreambleL();
+	}
+
+TVerdict CUtilityPluginTest::doTestStepPostambleL()
+	{
+	TInt startupMode = GetStartUpModeL();
+	if (IsSsmGracefulShutdown()&& (startupMode!=1))
+		{
+		TInt err = RProperty::Delete(TestCategory, TestKey);
+		INFO_PRINTF2(_L("Test key deleted to store the power state with err : [%d]"), err);
+		}
+	return CTestStep::doTestStepPostambleL();
+	}
+
+TVerdict CUtilityPluginTest::doTestStepL()
+	{
+	TInt startupMode = GetStartUpModeL();
+	if ((IsSsmGracefulShutdown()) && (startupMode!=1))
+		{
+		__UHEAP_MARK;
+		TRAPD(err, doTest1L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doTest2L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doTest3L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doTest4L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doTest5L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doTest6L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+// OOM tests start here
+
+		__UHEAP_MARK;
+		TRAP(err, doOOMTestL(&doTest1L));
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doOOMTestL(&doTest2L));
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doOOMTestL(&doTest3L));
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doOOMTestL(&doTest5L));
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+		__UHEAP_MARK;
+		TRAP(err, doOOMTestL(&doTest6L));
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+
+/**
+ Manual test: should be uncommented to test manually.
+*/
+/*		
+		__UHEAP_MARK;
+		TRAP(err, doTest7L());
+		TEST(err == KErrNone);
+		__UHEAP_MARKEND;
+*/		}
+	else
+		{
+		INFO_PRINTF2(_L("SSM is not used for shutdown, IsSsmGracefulShutdown() returned: [%d] "), IsSsmGracefulShutdown());
+		INFO_PRINTF2(_L("SSM is not used for shutdown, startupMode is [%d] i.e textshellmode"), startupMode);
+		}
+
+	return TestStepResult();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0001
+Old Test CaseID 		DS-UTILITYPLUGINS-0008
+Old Test CaseID 		DS-UTILITYPLUGINS-0009
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest1L()
+	{
+	INFO_PRINTF1(_L("**** Test for ESwitchOff event **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ESwitchOff, ETrue, EPwStandby);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0002
+Old Test CaseID 		DS-UTILITYPLUGINS-0008
+Old Test CaseID 		DS-UTILITYPLUGINS-0009
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest2L()
+	{
+	INFO_PRINTF1(_L("**** Test for ERestartSystem event **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ERestartSystem, ETrue, EPwRestart);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0003
+Old Test CaseID 		DS-UTILITYPLUGINS-0008
+Old Test CaseID 		DS-UTILITYPLUGINS-0009
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest3L()
+	{
+	INFO_PRINTF1(_L("**** Test for ESwitchOff event **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ESwitchOff, ETrue, EPwStandby);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0004
+Old Test CaseID 		DS-UTILITYPLUGINS-0005
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest4L()
+	{
+	INFO_PRINTF1(_L("**** Test for ECaseClose event **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ECaseClose, EFalse, EPwActive);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0007
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest5L()
+	{
+	INFO_PRINTF1(_L("**** Test delaying system shutdown **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ESwitchOff, ETrue, EPwStandby, ETrue);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0006
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest6L()
+	{
+	INFO_PRINTF1(_L("**** Test Cancel system shutdown transition **** "));
+	TestNotificationAndPowerModeL(TRawEvent::ESwitchOff, ETrue, EPwStandby, EFalse, ETrue);
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Old Test CaseID 		DS-UTILITYPLUGINS-0010
+New Test CaseID 		DEVSRVS-SSPLUGINS-UTILITYPLUGINS-0001
+ */
+
+void CUtilityPluginTest::doTest7L()
+	{
+	INFO_PRINTF1(_L("**** Test system shutdown transition without acknowledgement **** "));
+	TestSystemShutdownWithoutAcknowledgementL();
+	SwitchOn();
+	SetDefaultTestKey();
+	}
+
+/**
+Used for Manual test alongwith doTest7L().
+Helper function which doesn't acknowledge a shutdown event notification.
+*/
+void CUtilityPluginTest::TestSystemShutdownWithoutAcknowledgementL()
+	{
+	//Step1: create state aware session
+	RSsmStateAwareSession stateAwareSession;
+	CleanupClosePushL(stateAwareSession); // This R-Class might leak memory in event of a leave
+	User::LeaveIfError(stateAwareSession.Connect(KUIFrameworkDomain3));
+	TRequestStatus status;
+	stateAwareSession.RequestStateNotification(status);
+
+	//Step2: connect to wserv 
+	RWsSession wsSession;
+	User::LeaveIfError(wsSession.Connect());
+	//and generate the event
+	TRawEvent wsEvent;
+	wsEvent.Set(TRawEvent::ESwitchOff);
+	wsSession.SimulateRawEvent(wsEvent);
+	wsSession.Flush();
+	wsSession.Close();
+	INFO_PRINTF2(_L("Generated Raw event : [%d]"), TRawEvent::ESwitchOff);
+
+	//Step3: don't acknowledge when state change notification is received
+	TSsmState state = stateAwareSession.State();
+	for (;;)
+		{
+		// Wait for next notification of state change
+		User::WaitForRequest(status);
+		TEST(status.Int() == KErrNone);
+		state = stateAwareSession.State();
+		TSsmStateName name = state.Name();
+		//stateAwareSession.AcknowledgeStateNotification(KErrNone);
+		INFO_PRINTF2(_L("Transtition undergoing for the state.substate : [%S]"), &name);
+		INFO_PRINTF1(_L("Will remain here till timeout occurs and system moves to Fail State"));
+		}
+
+	//Avoid "Warning:  #111-D: statement is unreachable"
+	//This statement though required will not be executed as the above for loop will wait forever and a timeout will lead the system to move to Fail state.
+	//stateAwareSession.Close();
+	//CleanupStack::PopAndDestroy(); //stateAwareSession
+	}
+
+/**
+Helper function which prints a delay 10 times.
+*/
+void CUtilityPluginTest::LogDelayAcknowledgement()
+	{
+	for (TInt i=0; i<10;)
+		{
+		INFO_PRINTF2(_L("***** Delaying Acknowledgement [%d] time(s)"), ++i);
+		}
+	}
+
+/**
+Helper function which performs following actions
+1. Create a CTimer. Set timer to 10 seconds.
+2. When timer expires RunL should publish test RProperty to '0xBAD'
+3. Get the value and check if its set as expected.
+4. Reset the key to default.
+5. Cleanup timer.
+*/
+void CUtilityPluginTest::TestStateChangeNotificationNotReceivedL()
+	{
+	CShutdownNotifObserverTimer* timer = CShutdownNotifObserverTimer::NewL();
+	CleanupStack::PushL(timer);
+	timer->StartTimer(KWaitTimer);
+
+	TInt value = 0;
+	User::LeaveIfError(RProperty::Get(TestCategory, TestKey, value));
+	if (0xBAD == value)
+		{
+		INFO_PRINTF1(_L("No Notification received as no state change occurred"));
+		}
+	else
+		{
+		INFO_PRINTF1(_L(">>>>>>>>>>>>>> Should not be here."));
+		TEST(EFalse);
+		}
+	SetDefaultTestKey();
+	CleanupStack::PopAndDestroy(timer);
+	}
+
+/**
+Helper function which performs following actions
+1. Create a state aware session
+2. Generate an event i.e. aRawEvent
+3. Check for notification depending on the aIsNotificationExpected
+4. Check for the power mode set by power off command.
+*/
+void CUtilityPluginTest::TestNotificationAndPowerModeL(TRawEvent::TType aRawEvent, TBool aIsNotificationExpected, 
+														TPowerState aExpectedPowerState, 
+														TBool aDelayAcknowledgement, TBool aCancelTransition)
+	{
+	//Step1: create state aware session
+	RSsmStateAwareSession stateAwareSession;
+	CleanupClosePushL(stateAwareSession); // This R-Class might leak memory in event of a leave
+	User::LeaveIfError(stateAwareSession.Connect(KUIFrameworkDomain3));
+	TRequestStatus status;
+	stateAwareSession.RequestStateNotification(status);
+
+	//Step2: connect to wserv 
+	RWsSession wsSession;
+	User::LeaveIfError(wsSession.Connect());
+	//and generate the event
+	TRawEvent wsEvent;
+	wsEvent.Set(aRawEvent);
+	wsSession.SimulateRawEvent(wsEvent);
+	wsSession.Flush();
+	wsSession.Close();
+	INFO_PRINTF2(_L("Generated Raw event : [%d]"), aRawEvent);
+
+	//Step3: check for notification depending on the aIsNotificationExpected
+	TSsmState state = stateAwareSession.State();
+	while (aIsNotificationExpected)
+		{
+		if (aCancelTransition)
+			{
+			RSsmStateManager stateMgr;
+			User::LeaveIfError(stateMgr.Connect());
+			INFO_PRINTF1(_L("Cancelling Shutdown State Transtition"));
+			stateMgr.RequestStateTransitionCancel();
+			stateMgr.Close();
+			}
+
+		// Wait for next notification of state change
+		User::WaitForRequest(status);
+		TEST(status.Int() == KErrNone);
+		state = stateAwareSession.State();
+		TSsmStateName name;
+		if ((state.MainState() == ESsmShutdown) && ((state.SubState() == ESsmShutdownSubStatePowerOff) || (state.SubState() == ESsmShutdownSubStateReStart)))
+			{
+			if (aDelayAcknowledgement)
+				{
+				LogDelayAcknowledgement();
+				}
+			stateAwareSession.AcknowledgeStateNotification(KErrNone);
+			TEST((state.SubState() == ESsmShutdownSubStatePowerOff) || (state.SubState() == ESsmShutdownSubStateReStart));
+			name = state.Name();
+			INFO_PRINTF2(_L("Transtition undergoing for the state.substate : [%S]"), &name);
+			break;	
+			}
+		else
+			{
+			if (aDelayAcknowledgement)
+				{
+				LogDelayAcknowledgement();
+				}
+			stateAwareSession.AcknowledgeAndRequestStateNotification(KErrNone, status);
+			TEST((state.SubState() == ESsmShutdownSubStateCritical) || (state.SubState() == ESsmShutdownSubStateNonCritical));
+			name = state.Name();
+			INFO_PRINTF2(_L("Transtition undergoing for the state.substate : [%S]"), &name);
+			}
+		}
+
+	INFO_PRINTF3(_L("Shutdown event received [%d] and expected is [%d]"), state.MainState() == ESsmShutdown, aIsNotificationExpected);
+
+	if (aIsNotificationExpected)
+		{
+		TEST(state.MainState() == ESsmShutdown);
+		TInt value = 0;
+		RProperty prop;
+		TRequestStatus propertyStatus;
+		User::LeaveIfError(prop.Get(TestCategory, TestKey, value));
+		if (aExpectedPowerState != (TPowerState)value)
+			{
+			User::LeaveIfError(prop.Attach(TestCategory, TestKey));
+			prop.Subscribe(propertyStatus);
+			User::WaitForRequest(propertyStatus);
+			User::LeaveIfError(prop.Get(TestCategory, TestKey, value));
+			}
+		//Step4: Test the power mode
+		TEST(aExpectedPowerState = (TPowerState)value);
+		INFO_PRINTF3(_L("Power state received is [%d] and expected was [%d]"), value, aExpectedPowerState);		
+		}
+	else
+		{
+		// run timer and wait for 10 seconds to see if any notification is received
+		TestStateChangeNotificationNotReceivedL();
+		stateAwareSession.RequestStateNotificationCancel();
+		}
+
+	CleanupStack::PopAndDestroy(); //stateAwareSession
+	}
+
+/**
+Helper function to switch on the Display, Keyboard and PenState. This will be switched off in case of stand-by
+*/
+void CUtilityPluginTest::SwitchOn()
+	{
+	HAL::Set(HAL::EDisplayState, 1);
+	HAL::Set(HAL::EKeyboardState, 1);
+	HAL::Set(HAL::EPenState, 1);
+	}
+
+/**
+Helper function to do the OOM testing
+*/
+void CUtilityPluginTest::doOOMTestL(ClassFuncPtrL aTestFuncL/*, const TDesC& aTestDesc*/)
+	{
+	INFO_PRINTF1(_L("*** Starting OOM test"));
+	TInt failRate = 1;
+
+	for (; ;failRate++)
+	    {
+	    __UHEAP_RESET;
+	    __UHEAP_SETFAIL(RHeap::EDeterministic,failRate);
+	    __UHEAP_MARK;
+	
+	    TRAPD(ret, (this->*aTestFuncL)());
+
+        TEST((ret==KErrNone || ret==KErrNoMemory));
+        __UHEAP_MARKEND;
+
+	    if (ret==KErrNone)
+	        {
+	        break;
+	        }
+	    }
+	__UHEAP_RESET;
+	INFO_PRINTF2(_L("*** OOM Test finished with #allocs : %d."), failRate-1);
+	}
+
+/**
+Helper function to set the default test key to TestDefaultValue
+*/
+void CUtilityPluginTest::SetDefaultTestKey()
+	{
+	TInt err = RProperty::Set(TestCategory, TestKey, TestDefaultValue);
+	INFO_PRINTF3(_L("Default power state set to TPowerState::EPwActive(%d), Published with error(%d)"), TestDefaultValue, err);
+	}
+
+ TInt CUtilityPluginTest::GetStartUpModeL()
+	{
+	TInt startUpMode;
+	TInt err;
+	TRAP(err,RProperty::Get(KUidSystemCategory, KSystemStartupModeKey, startUpMode));
+	TEST(err == KErrNone); 
+	return startUpMode;
+	}