// Copyright (c) 2005-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:
//

#include <e32base.h>
#include <e32test.h>
#include <e32debug.h>
#include <f32file.h>
#include <startupdomaindefs.h>
#include <ecom/ecompanics.h>

#include "EComServer.h"
#include "TestHarnessDomainMember.h"
#include "StartupStateObserverObject.h"
#include "ServerStartupManager.h"
#include "EcomTestUtils.h"
#include "EcomTestIniFileUtils.h"
#include "EcomTestCompTestabilityUtils.h"

static RFs TheFs;
static RTest TheTest(_L("T_ServerStartupMgr"));

//
//
//Test macroes and functions
//
//

static void Check(TInt aValue, TInt aLine)
	{
	if(!aValue)
		{
		TheTest(EFalse, aLine);
		}
	}

static  void Check(TInt aValue, TInt aExpected, TInt aLine)
	{
	if(aValue != aExpected)
		{
		RDebug::Print(_L("*** Expected error: %d, got: %d\r\n"), aExpected, aValue);
		TheTest(EFalse, aLine);
		}
	}
#define TEST(arg) ::Check((arg), __LINE__)
#define TEST2(aValue, aExpected) ::Check(aValue, aExpected, __LINE__)

//
//
//TServerStartupManager_StateAccessor class definition and methods
//
//
/**
@internalTechnology

Allows access to the protected and private data and operations
of CServerStartupMgr
*/
class TServerStartupManager_StateAccessor
	{
public:
	static TStartupStateIdentifier GetKnownStartupState(CServerStartupMgr& aServerStartupMgr, TDmDomainState aStartupState);
	static void SetKnownStartupState(CServerStartupMgr& aServerStartupMgr, TStartupStateIdentifier aState);
	static void TestStateAwareObjectsForState(CServerStartupMgr& aServerStartupMgr, TInt32 aState);
	static void SetStateAwareObjectsState(CServerStartupMgr& aServerStartupMgr, TInt32 aState);
	static void SetStateL(CServerStartupMgr& aServerStartupMgr, TInt aState);
	static void RunL(CServerStartupMgr& aServerStartupMgr);
	static TInt RunError(CServerStartupMgr& aServerStartupMgr, TInt aError);
	};

void TServerStartupManager_StateAccessor::TestStateAwareObjectsForState
		(CServerStartupMgr& aServerStartupMgr, TInt32 aState)
	{
	int i;
	const RPointerArray<MStartupStateObserver> observerList =
		aServerStartupMgr.iObserverList;

	for(i=0; i<observerList.Count(); i++)
		{
		CStartupStateObserver* observerObject =
			static_cast<CStartupStateObserver*>(observerList[i]);

		TEST2((TInt32)observerObject->GetState(), aState);
		}
	}

void TServerStartupManager_StateAccessor::SetStateAwareObjectsState
		(CServerStartupMgr& aServerStartupMgr, TInt32 aState)
	{
	int i;
	const RPointerArray<MStartupStateObserver> observerList =
		aServerStartupMgr.iObserverList;

	for(i=0; i<observerList.Count(); i++)
		{
		CStartupStateObserver* observerObject =
			static_cast<CStartupStateObserver*>(observerList[i]);

		observerObject->SetState((CStartupStateObserver::TSsoState)aState);
		}
	}

TStartupStateIdentifier TServerStartupManager_StateAccessor::GetKnownStartupState
		(CServerStartupMgr& aServerStartupMgr, TDmDomainState aStartupState)
	{
	return aServerStartupMgr.GetKnownStartupState(aStartupState);
	}

void TServerStartupManager_StateAccessor::SetKnownStartupState(CServerStartupMgr& aServerStartupMgr, TStartupStateIdentifier aState)
	{
	aServerStartupMgr.iCurrentStartupState = aState;
	}

void TServerStartupManager_StateAccessor::SetStateL(CServerStartupMgr& aServerStartupMgr, TInt aState)
	{
	aServerStartupMgr.ChangeStartupStateL(aState);
	}

void TServerStartupManager_StateAccessor::RunL(CServerStartupMgr& aServerStartupMgr)
	{
	aServerStartupMgr.RunL();
	}

TInt TServerStartupManager_StateAccessor::RunError(CServerStartupMgr& aServerStartupMgr,TInt aError)
	{
	return aServerStartupMgr.RunError(aError);
	}

//
//
//Helper functions
//
//

/**
*
* Function is used for each state change of InitialiseL() testing.
* It checks whether:
* 	    - For each state RequestTransitionNotification() is called
*		- For EStartupStateUndefined or EStartupStateNonCritical state
*		  Requestion of notification is cancelled .
* 	    - Each MStartupServerStateObserver object is set to their
* 	      corresponding state
* @param aServerStartupMgr the server startup manager being tested
* @param aNewState the domain state to be tested
* @param aObserverObjCurrentState the current state of all the observer objects
* registered to aServerStartupMgr
* @param aExpectedRequestTransitionNotification expected result from
* IsTransitionNotificationRequestedL() call to check whether RequestTransitionNotification()
* was called
* @param aExpectedCancelRequestNotification expected result from
* IsCancelRequestNotification() call to check whether Request of Notification
* was cancelled.
* @param aObserverObjExpectedState the expected new state for all of the MStartupServerStateObserver
* @param aExpectedStartupState the expected new state for the CServerStartupManager
* after RunL is called.
*/
void CheckForInitialiseStateChangeL(CServerStartupMgr& aServerStartupMgr,
							  TInt aNewState,
							  CStartupStateObserver::TSsoState aObserverObjCurrentState,
							  TBool aExpectedRequestTransitionNotification,
							  TBool aExpectedCancelRequestNotification,
  							  CStartupStateObserver::TSsoState aObserverObjExpectedState,
  							  TStartupStateIdentifier aExpectedStartupState,
  							  TBool aSsaEnabled)
	{
	//reset the server startup manager flags
	aServerStartupMgr.ResetRequestTransitionNotificationL();

	//set the new/tested state for server startup manager
	TServerStartupManager_StateAccessor::SetKnownStartupState
		(aServerStartupMgr, EStartupStateUndefined);

	//set the new/tested state for the domain
	TServerStartupManager_StateAccessor::SetStateL
		(aServerStartupMgr, aNewState);

	//set the current state for all of the MStartupServerStateObserver objects
	TServerStartupManager_StateAccessor::SetStateAwareObjectsState
		(aServerStartupMgr, aObserverObjCurrentState);

	//call InitialiseL()
	aServerStartupMgr.InitialiseL(aSsaEnabled);

	//test if RequestTransitionNotification() is called
	TEST2(aServerStartupMgr.IsTransitionNotificationRequestedL(), aExpectedRequestTransitionNotification);

	//test if Request of Notification is cancelled
	TEST2(aServerStartupMgr.IsRequestNotificationCancelledL(), aExpectedCancelRequestNotification);

	//test if MStartupStateObserver objects are set to expected state
	TServerStartupManager_StateAccessor::TestStateAwareObjectsForState
		(aServerStartupMgr, aObserverObjExpectedState);

	//test if CServerStartupManager is set to expected state
	TEST2(aServerStartupMgr.CurrentStartupState(), aExpectedStartupState);
	}


/**
*
* Function is used for each state change of RunL() testing.
* It checks whether:
* 	    - AcknowledgeLastStateL() is called for each state.
* 	    - RequestTransitionNotification() is called for all states.
*		- For EStartupStateUndefined or EStartupStateNonCritical state
*		  Requestion of notification is cancelled.
* 	    - Each MStartupServerStateObserver object is set to their
* 	      corresponding state
* @param aServerStartupMgr the server startup manager being tested
* @param aNewState the domain state to be tested
* @param aObserverObjCurrentState the current state of all the observer objects
* registered to aServerStartupMgr
* @param aExpectedRequestTransitionNotification expected result from
* IsTransitionNotificationRequestedL() call to check whether RequestTransitionNotification()
* was called
* @param aExpectedCancelRequestNotification expected result from
* IsCancelRequestNotification() call to check whether Request of Notification
* was cancelled.
* @param aExpectedAcknowledgeLastState expected result from IsLastStateAcknowledged()
* call to check whether AcknowledgeLastStateL() was called
* @param aObserverObjExpectedState the expected new state for all of the MStartupServerStateObserver
* after RunL is called.
* @param aExpectedStartupState the expected new state for the CServerStartupManager
* after RunL is called.
*/
void CheckForRunLStateChangeL(CServerStartupMgr& aServerStartupMgr,
							  TInt aNewState,
							  CStartupStateObserver::TSsoState aObserverObjCurrentState,
							  TBool aExpectedRequestTransitionNotification,
							  TBool aExpectedCancelRequestNotification,
							  TBool aExpectedAcknowledgeLastState,
  							  CStartupStateObserver::TSsoState aObserverObjExpectedState,
  							  TStartupStateIdentifier aExpectedStartupState)
	{
	//reset the server startup manager flags
	aServerStartupMgr.ResetLastStateAcknowledgedL();
	aServerStartupMgr.ResetRequestTransitionNotificationL();

	//set the current state for CDmDomain
	TServerStartupManager_StateAccessor::SetStateL
		(aServerStartupMgr, aNewState);

	//set the current state for all of the MStartupServerStateObserver objects
	TServerStartupManager_StateAccessor::SetStateAwareObjectsState
		(aServerStartupMgr, aObserverObjCurrentState);

	//call RunL()
	TRAPD(err, TServerStartupManager_StateAccessor::
				RunL(aServerStartupMgr));
	if(aNewState == EStartupStateUndefined)
		{
		TEST2(err, KErrBadHandle);
		}
	else
		{
		TEST2(err, KErrNone);
		}

	//test if RequestTransitionNotification() is called
	TEST2(aServerStartupMgr.IsTransitionNotificationRequestedL(), aExpectedRequestTransitionNotification);

	//test if Request of Notification is cancelled
	TEST2(aServerStartupMgr.IsRequestNotificationCancelledL(), aExpectedCancelRequestNotification);

	//test if AcknowledgeLastStateL() is called
	TEST2(aServerStartupMgr.IsLastStateAcknowledgedL(), aExpectedAcknowledgeLastState);

	//test if MStartupStateObserver objects are set to expected state
	TServerStartupManager_StateAccessor::TestStateAwareObjectsForState
		(aServerStartupMgr, aObserverObjExpectedState);

	//test if CServerStartupManager is set to expected state
	TEST2(aServerStartupMgr.CurrentStartupState(), aExpectedStartupState);
	}

//
//
//Tests
//
//

/**
@SYMTestCaseID		SYSLIB-ECOM-CT-0178
@SYMTestCaseDesc 	Check that the CServerStartupMgr::GetKnownStartupState() works correctly.
@SYMTestPriority 	High
@SYMTestActions  	Set knownStartupState to EStartupStateUndefined, EStartupStateCriticalStatic,
EStartupStateCriticalDynamic, EStartupStateNonCritical. Call GetKnownStartupState() to see if
correct known startup state is returned.
@SYMTestExpectedResults The test must not fail.
@SYMPREQ PREQ967
*/
void GetKnownStartupState_TestL()
	{
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0178 "));
	TUint32 i;
	static const TUint32 KTestCount = 11;
	TInt32 testStates[] = { EStartupStateUndefined, EStartupStateUndefined+1,
							EStartupStateCriticalStatic-1, EStartupStateCriticalStatic, EStartupStateCriticalStatic+1,
							EStartupStateCriticalDynamic-1, EStartupStateCriticalDynamic, EStartupStateCriticalDynamic+1,
							EStartupStateNonCritical-1, EStartupStateNonCritical, EStartupStateNonCritical+1};
	//Test results
	TInt32 resultStates[] = {EStartupStateUndefined, EStartupStateUndefined,
							 EStartupStateUndefined, EStartupStateCriticalStatic, EStartupStateCriticalStatic,
							 EStartupStateCriticalStatic, EStartupStateCriticalDynamic, EStartupStateCriticalDynamic,
							 EStartupStateCriticalDynamic, EStartupStateNonCritical, EStartupStateNonCritical};

	EnableSsa(TheTest, TheFs);

	CServerStartupMgr* serverStartupMgr =
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KDmIdRoot, TheFs);
	CleanupStack::PushL(serverStartupMgr);

	//check for all the test states
	for(i=0; i<KTestCount; i++)
		{
		TEST2(TServerStartupManager_StateAccessor::GetKnownStartupState(*serverStartupMgr, testStates[i]),
		      resultStates[i]);
		}

	CleanupStack::Pop(serverStartupMgr);
	delete serverStartupMgr;

	ResetSsa(TheTest, TheFs);
	}

/**
@SYMTestCaseID		SYSLIB-ECOM-CT-0179
@SYMTestCaseDesc 	Check that the CServerStartupMgr::InitialiseL() works for the non SSA case correctly.
@SYMTestPriority 	High
@SYMTestActions  	Set SSA to false. Then check that all the MStartupStateObserver
objects registered to server startup manager has switched to the correct known start-up state
as a result of InitialiseL()
@SYMTestExpectedResults The test must not fail.
@SYMPREQ PREQ967
*/
void InitialiseL_NonSsa_TestL()
	{
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0179 "));
	TestEnableDisableSsaL(TheTest, TheFs);

	DisableSsa(TheTest, TheFs);

	//Create some MStartupServerStateObserver objects
	CStartupStateObserver* dummyObject1 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject2 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject3 = CStartupStateObserver::NewLC();

	CServerStartupMgr* serverStartupMgr =
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KDmIdRoot, TheFs);
	CleanupStack::PushL(serverStartupMgr);

	//Register MStartupServerStateObserver objects
	serverStartupMgr->RegisterObserverL(dummyObject1);
	serverStartupMgr->RegisterObserverL(dummyObject2);
	serverStartupMgr->RegisterObserverL(dummyObject3);

	TServerStartupManager_StateAccessor::SetKnownStartupState
		(*serverStartupMgr, EStartupStateUndefined);

	TServerStartupManager_StateAccessor::SetStateL
		(*serverStartupMgr, EStartupStateUndefined);

	serverStartupMgr->InitialiseL(EFalse);

	//Now that CDmDomain::ConstructL() is called check that each
	//MStartupServerStateObserver object is set to
	//TSsoState::SsoAllPluginsInternalized
	TServerStartupManager_StateAccessor::TestStateAwareObjectsForState
		(*serverStartupMgr, CStartupStateObserver::SsoAllPluginsInternalized);

	TEST2(serverStartupMgr->CurrentStartupState(), EStartupStateNonCritical);

	CleanupStack::Pop(serverStartupMgr);
	delete serverStartupMgr;

	CleanupStack::PopAndDestroy(dummyObject3);
	CleanupStack::PopAndDestroy(dummyObject2);
	CleanupStack::PopAndDestroy(dummyObject1);

	ResetSsa(TheTest, TheFs);
	}


/**
@SYMTestCaseID		SYSLIB-ECOM-CT-0180
@SYMTestCaseDesc 	Check that the CServerStartupMgr::InitialiseL() works for the SSA case correctly.
@SYMTestPriority 	High
@SYMTestActions  	Set SSA to true. Then check that all the MStartupStateObserver
objects registered to server startup manager has switched to the correct known start-up
state as a result of InitialiseL(). Next check that correct actions have been taken
when known startup state for server startup manager is set to all possible values
and after InitialiseL() has been called.
@SYMTestExpectedResults The test must not fail.
@SYMPREQ PREQ967
*/
void InitialiseL_Ssa_TestL()
	{
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0180 "));
	TestEnableDisableSsaL(TheTest, TheFs);

	EnableSsa(TheTest, TheFs);

	//Create some MStartupServerStateObserver objects
	CStartupStateObserver* dummyObject1 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject2 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject3 = CStartupStateObserver::NewLC();

	CServerStartupMgr* serverStartupMgr =
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KDmIdRoot, TheFs);
	CleanupStack::PushL(serverStartupMgr);

	//Register MStartupServerStateObserver objects
	serverStartupMgr->RegisterObserverL(dummyObject1);
	serverStartupMgr->RegisterObserverL(dummyObject2);
	serverStartupMgr->RegisterObserverL(dummyObject3);

	//initialise the domain
	//set the state for CDmDomain
	TServerStartupManager_StateAccessor::SetStateL
		(*serverStartupMgr, EStartupStateCriticalStatic);

	serverStartupMgr->InitialiseL(ETrue);

	//Now that CDmDomain::ConstructL() is called check that each
	//MStartupServerStateObserver object is set to
	//TSsoState::SsoCriticalPlugingsInternalized
	TServerStartupManager_StateAccessor::TestStateAwareObjectsForState
		(*serverStartupMgr, CStartupStateObserver::SsoCriticalPlugingsInternalized);

	// Following tests ensure that
	//    - For each state RequestTransitionNotification() is called
	//	  - For EStartupStateUndefined or EStartupStateNonCritical
	//	  the request of notification is cancelled.
	//    - Each MStartupServerStateObserver object is set to their
	//      corresponding state

	//Test for EStartupStateUndefined
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateUndefined,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							ETrue,
							CStartupStateObserver::SsoAllPluginsInternalized,
							EStartupStateNonCritical,ETrue);

	//Test for a user defined state
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateCriticalStatic-1,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							EFalse,
							CStartupStateObserver::SsoNoPluginsInternalized,
							EStartupStateUndefined,ETrue);

	//Test for EStartupStateCriticalStatic
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateCriticalStatic,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							EFalse,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalStatic,ETrue);

	//Test for a user defined state
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateCriticalDynamic-1,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							EFalse,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalStatic,ETrue);

	//Test for EStartupStateCriticalDynamic
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateCriticalDynamic,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							EFalse,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalDynamic,ETrue);

	//Test for a user defined state
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateNonCritical-1,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							EFalse,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalDynamic,ETrue);

	//Test for EStartupStateNonCritical
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateNonCritical,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							ETrue,
							CStartupStateObserver::SsoAllPluginsInternalized,
							EStartupStateNonCritical,ETrue);

	//Test for a user defined state
	CheckForInitialiseStateChangeL(*serverStartupMgr, EStartupStateNonCritical+1,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue,
							ETrue,
							CStartupStateObserver::SsoAllPluginsInternalized,
							EStartupStateNonCritical,ETrue);

	CleanupStack::Pop(serverStartupMgr);
	delete serverStartupMgr;

	CleanupStack::PopAndDestroy(dummyObject3);
	CleanupStack::PopAndDestroy(dummyObject2);
	CleanupStack::PopAndDestroy(dummyObject1);

	ResetSsa(TheTest, TheFs);
	}


/**
@SYMTestCaseID		SYSLIB-ECOM-CT-0181
@SYMTestCaseDesc 	Check that the CServerStartupMgr::RunL() works correctly.
@SYMTestPriority 	High
@SYMTestActions  	Set SSA to true. Then check that correct actions have
been taken when known startup state for server startup manager is set to all
possible values and after InitialiseL() has been called.
@SYMTestExpectedResults The test must not fail.
@SYMPREQ PREQ967
*/
void RunL_TestL()
	{
	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-0181 "));
	EnableSsa(TheTest, TheFs);

	//Create some MStartupServerStateObserver objects
	CStartupStateObserver* dummyObject1 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject2 = CStartupStateObserver::NewLC();
	CStartupStateObserver* dummyObject3 = CStartupStateObserver::NewLC();

	CServerStartupMgr* serverStartupMgr =
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KDmIdRoot, TheFs);
	CleanupStack::PushL(serverStartupMgr);

	//Register MStartupServerStateObserver objects
	serverStartupMgr->RegisterObserverL(dummyObject1);
	serverStartupMgr->RegisterObserverL(dummyObject2);
	serverStartupMgr->RegisterObserverL(dummyObject3);

	serverStartupMgr->InitialiseL(ETrue);

	//Following tests ensure that:
	//    - AcknowledgeLastStateL() is called for each state.
	//    - RequestTransitionNotification() is called for all states
	//	  - For EStartupStateUndefined or EStartupStateNonCritical
	//	  the request of notification is cancelled.
	//    - Each MStartupServerStateObserver object is set to their
	//      corresponding state
	//Test for EStartupStateUndefined
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateUndefined,
							CStartupStateObserver::SsoUndefined,
							ETrue, ETrue, ETrue,
							CStartupStateObserver::SsoUndefined,
							EStartupStateUndefined);

	//Test for a user defined state
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateCriticalStatic-1,
							CStartupStateObserver::SsoUndefined,
							ETrue, EFalse, ETrue,
							CStartupStateObserver::SsoUndefined,
							EStartupStateUndefined);

	//Test for EStartupStateCriticalStatic
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateCriticalStatic,
							CStartupStateObserver::SsoNoPluginsInternalized,
							ETrue, EFalse, ETrue,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalStatic);

	//Test for EStartupStateCriticalStatic
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateCriticalDynamic-1,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							ETrue, EFalse,ETrue,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalStatic);

	//Test for EStartupStateCriticalDynamic
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateCriticalDynamic,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							ETrue, EFalse, ETrue,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalDynamic);

	//Test for EStartupStateCriticalDynamic
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateNonCritical-1,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							ETrue, EFalse, ETrue,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							EStartupStateCriticalDynamic);

	//Test for EStartupStateNonCritical
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateNonCritical,
							CStartupStateObserver::SsoCriticalPlugingsInternalized,
							ETrue,ETrue, ETrue,
							CStartupStateObserver::SsoAllPluginsInternalized,
							EStartupStateNonCritical);

	//Test for EStartupStateNonCritical
	CheckForRunLStateChangeL(*serverStartupMgr, EStartupStateNonCritical+1,
							CStartupStateObserver::SsoAllPluginsInternalized,
							ETrue, ETrue, ETrue,
							CStartupStateObserver::SsoAllPluginsInternalized,
							EStartupStateNonCritical);

	CleanupStack::Pop(serverStartupMgr);
	delete serverStartupMgr;

	CleanupStack::PopAndDestroy(dummyObject3);
	CleanupStack::PopAndDestroy(dummyObject2);
	CleanupStack::PopAndDestroy(dummyObject1);

	ResetSsa(TheTest, TheFs);
	}

/**
Creates and installs active scheduler for this thread,
creates a CServerStartupMgr instance and calls
TServerStartupManager_StateAccessor::RunError

*/
TInt DoRunError_TestL()
	{
	// create and install the active scheduler we need
	CActiveScheduler* scheduler=new(ELeave) CActiveScheduler;
	CleanupStack::PushL(scheduler);

	CActiveScheduler::Install(scheduler);

	//create a new ServerStartupMgr
	CServerStartupMgr* serverStartupMgr =
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KDmIdRoot, TheFs);

	CleanupStack::PushL(serverStartupMgr);

	//call the RunError method which should panic
	TInt result = TServerStartupManager_StateAccessor::RunError(*serverStartupMgr,KErrNoMemory);

	// Cleanup the server and scheduler
	CleanupStack::PopAndDestroy(2, scheduler);

	return result;

	}

/**
Thread entry point for the test thread.  Creates a CTrapCleanup and
calls  DoRunError_TestL to carry out the test

*/
TInt RunErrorThreadEntry(TAny* /*a*/)
	{

	CTrapCleanup* tc = CTrapCleanup::New();

	TRAPD(err,DoRunError_TestL());

	delete tc;

	return err;

	}


/**
@SYMTestCaseID		SYSLIB-ECOM-CT-3164
@SYMTestCaseDesc 	Check that the CServerStartupMgr::RunError() works correctly.
@SYMTestPriority 	High
@SYMTestActions  	Create a new thread which will call RunError.  Wait for the
					thread to exit and check the thread exit type and reason to
					verify behaviour
@SYMTestExpectedResults The test must not fail.
@SYMDEF DEF094675
*/
void RunError_Test()
	{
	__UHEAP_MARK;
	_LIT(KStartThreadName,"CServerStartupMgr RunError Thread");

	TheTest.Next(_L(" @SYMTestCaseID:SYSLIB-ECOM-CT-3164 CServerStartupMgr RunError test "));

	//Disable JIT so that the Panic doesn't bring up a dialog
	//and stop the test
	TBool jitEnabled = User::JustInTime();
	User::SetJustInTime(EFalse);

	//Create a new thread to run the test
	RThread testThread;
	testThread.Create(KStartThreadName, RunErrorThreadEntry,
					KDefaultStackSize,KMinHeapSize,KMinHeapSize,NULL);
	TRequestStatus status;
	testThread.Logon(status);
	testThread.Resume();

	//Wait for the thread to exit
	User::WaitForRequest(status);

	//Obtain exit type and reason for test thread
	TExitType exitType = testThread.ExitType();
	TInt exitReason = testThread.ExitReason();

	//close the thread handle
	testThread.Close();

	//Set JIT back to original state
	User::SetJustInTime(jitEnabled);

	//Verify the exit reason and exit code
	TEST(exitType == EExitPanic);
	TEST(exitReason == EEComPanic_CServerStartupMgr_RunError);

	__UHEAP_MARKEND;

	}

LOCAL_C void CreateDelete_TestL()
	{
	CServerStartupMgr* serverStartupMgr =
#ifdef SYMBIAN_SYSTEM_STATE_MANAGEMENT
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KSM2OSServicesDomain3, TheFs);
#else
		new(ELeave) CServerStartupMgr(KDmHierarchyIdStartup, KBaseServicesDomain3, TheFs);
#endif //SYMBIAN_SYSTEM_STATE_MANAGEMENT

	TEST(serverStartupMgr != NULL);

	delete serverStartupMgr;
	}


// Type definition for pointer to member function.
// Used in calling t_ServerStartupMgr test functions.
typedef void (*ClassFuncPtrL) (void);

/**
Wrapper function to call all test functions
@param		testFunc pointer to test function
@param		aTestDesc test function name
*/
LOCAL_C void DoBasicTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
	{
	TheTest.Next(aTestDesc);

	__UHEAP_MARK;
  	// find out the number of open handles
	TInt startProcessHandleCount;
	TInt startThreadHandleCount;
	RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

	testFuncL();

	// check that no handles have leaked
	TInt endProcessHandleCount;
	TInt endThreadHandleCount;
	RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

	TEST(startProcessHandleCount == endProcessHandleCount);
	TEST(startThreadHandleCount  == endThreadHandleCount);

	__UHEAP_MARKEND;
	}

/**
Wrapper function to call all OOM test functions
@param		testFuncL pointer to OOM test function
@param		aTestDesc test function name
*/
LOCAL_C void DoOOMTestL(ClassFuncPtrL testFuncL, const TDesC& aTestDesc)
	{
	TheTest.Next(aTestDesc);

	TInt err;
	TInt tryCount = 0;
	do
		{
		__UHEAP_MARK;
  		// find out the number of open handles
		TInt startProcessHandleCount;
		TInt startThreadHandleCount;
		RThread().HandleCount(startProcessHandleCount, startThreadHandleCount);

		__UHEAP_SETFAIL(RHeap::EDeterministic, ++tryCount);

		TRAP(err, testFuncL());

		__UHEAP_SETFAIL(RHeap::ENone, 0);

		// check that no handles have leaked
		TInt endProcessHandleCount;
		TInt endThreadHandleCount;
		RThread().HandleCount(endProcessHandleCount, endThreadHandleCount);

		TEST(startProcessHandleCount == endProcessHandleCount);
		TEST(startThreadHandleCount  == endThreadHandleCount);

		__UHEAP_MARKEND;
		} while(err == KErrNoMemory);

 	TEST2(err, KErrNone);
	TheTest.Printf(_L("- server succeeded at heap failure rate of %i\n"), tryCount);
	}

LOCAL_C void DoTestsL()
	{
	DoBasicTestL(&CreateDelete_TestL, _L("CreateDelete_TestL"));
	DoBasicTestL(&GetKnownStartupState_TestL, _L("GetKnownStartupState_TestL"));
	DoBasicTestL(&InitialiseL_NonSsa_TestL, _L("InitialiseL_NonSsa_TestL"));
	DoBasicTestL(&InitialiseL_Ssa_TestL, _L("InitialiseL_Ssa_TestL"));
	DoBasicTestL(&RunL_TestL, _L("RunL_TestL"));

	DoOOMTestL(&CreateDelete_TestL, _L("OOM CreateDelete_TestL"));
	DoOOMTestL(&GetKnownStartupState_TestL, _L("OOM GetKnownStartupState_TestL"));
	DoOOMTestL(&InitialiseL_NonSsa_TestL, _L("OOM InitialiseL_NonSsa_TestL"));
	DoOOMTestL(&InitialiseL_Ssa_TestL, _L("OOM InitialiseL_Ssa_TestL"));
	DoOOMTestL(&RunL_TestL, _L("OOM RunL_TestL"));

	RunError_Test();
	}

GLDEF_C TInt E32Main()
	{
	__UHEAP_MARK;
	TheTest.Printf(_L("\n"));
	TheTest.Title();
	TheTest.Start(_L("ServerStartupMgr Tests."));

	TEST2(TheFs.Connect(), KErrNone);

	// get clean-up stack
	CTrapCleanup* cleanup = CTrapCleanup::New();
	// Construct and install the Active Scheduler. The Active Scheduler is needed
	// by components used by this test as they are ActiveObjects.
	CActiveScheduler*	activeScheduler = new(ELeave)CActiveScheduler;
	CActiveScheduler::Install(activeScheduler);

	EnableEcomTestBehaviour(TheTest, TheFs);

	TRAPD(err,DoTestsL());
	ResetSsa(TheTest, TheFs);
	TheTest(err==KErrNone);

	DisableEcomTestBehaviour(TheTest, TheFs);

	TheTest.End();
	TheTest.Close();

	//delete scheduler;
	delete activeScheduler;
	delete cleanup;

	TheFs.Close();

	__UHEAP_MARKEND;

	User::Heap().Check();

	return KErrNone;
	}