// 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;

	}