// Copyright (c) 2002-2010 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

// Overview:

// Domain manager tests

// API Information:

// RDmDomain, RDmDomainManager CDmDomain, CDmDomainManager

// Details:

// - Test a variety of domain transitions, check the expected number of

// notifications and the first expected ordinal. Verify results are

// as expected.

// - Test system standby, check the expected number of notifications and 

// the first expected ordinal. Use a timer to request a wakeup event.

// Verify results are as expected.

// - Test domain related simple error situations, verify results are

// as expected.

// - Perform platform security tests: launch a separate process with no 

// capabilities, verify that results are as expected.

// - Test domain transitions by connecting to two domain hierarchies 

// simultaneously, add some test and power hierarchy members, verify

// the expected target state, notifications and leaf nodes. Verify results.

// - Verify that the same hierarchy can not be connected to more than once.

// - Request a positive transition and request that the test domain use 

// ETraverseParentsFirst. Verify results are as expected and verify 

// domains are in the correct state.

// - Request a negative transition and request that the test domain use 

// ETraverseChildrenFirst. Verify results are as expected.

// - Request a positive transition with zero acknowledgements. Verify 

// results are as expected.

// - Request a positive transition with error acknowledgements. Verify 

// results are as expected.

// - Perform a variety of negative tests and verify results are as expected.

// - Perform various tests on domain transitions with activated observer.

// Verify results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32debug.h>

#include <e32ldr_private.h>

_LIT(KThreadName, "t_domain_panic_thread");

#ifdef _DEBUG

#define __PRINT(x) {RDebug::Print x;}

#else

#define __PRINT(x) 

#endif

class CDmTest1 : public CActive, public MDmTest

	{

public: // from CActive

	void RunL();

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete() {};

	CDmTest1 (TDmDomainId aId, TDmDomainState aState) : CActive(CActive::EPriorityStandard), iDomainId(aId), iState((TPowerState) aState) {}

protected:

	// from CActive

	virtual void DoCancel();

private:

	enum { KMembersMax = 16 };

	CDmTestMember*		iMembers[KMembersMax]; 

	RDmDomainManager	iManager;

	TDmDomainId			iDomainId;

	TPowerState			iState;

	TBool				iAcknowledge;

	TInt				iMembersCount;

	TInt				iCount;

	TUint32				iOrdinal;

	};

void CDmTest1::Perform()

	{

	//

	// Test domain transitions

	//

	test.Next(_L("Test 1"));

	test.Printf(_L("Domain id = 0x%x Target State = 0x%x\n"), iDomainId, iState);

	iMembers[0] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

	test(iMembers[0] != NULL);

	iMembers[1] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

	test(iMembers[1] != NULL);

	iMembers[2] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

	test(iMembers[2] != NULL);

	iMembers[3] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

	test(iMembers[3] != NULL);

	iMembers[4] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

	test(iMembers[4] != NULL);

	iMembers[5] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

	test(iMembers[5] != NULL);

	// expected number of notifications

	iMembersCount = (iDomainId == KDmIdRoot) ? 6 : 2;

	// first expected ordinal

	iOrdinal = (iState == EPwActive) ? 0 : 1;

	TInt r = iManager.Connect();

	test(r == KErrNone);

	CActiveScheduler::Add(this);

	iManager.RequestDomainTransition(iDomainId, iState, CActive::iStatus);

	CActive::SetActive();

	CActiveScheduler::Start();

	}

TInt CDmTest1::TransitionNotification(MDmDomainMember& aDomainMember)

	{

	++iCount;

	if (aDomainMember.State() == EPwActive)

		{

		if(aDomainMember.Ordinal() < iOrdinal)

			{

			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d"), aDomainMember.Ordinal(), iOrdinal);

			iCount--;

			}

		}

	else

		{

		if(aDomainMember.Ordinal() > iOrdinal)

			{

			//Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d"), aDomainMember.Ordinal(), iOrdinal);

			iCount--;

			}

		}

	iOrdinal = aDomainMember.Ordinal();

	// acknowledge one from two

	iAcknowledge = !iAcknowledge;

	return iAcknowledge?KErrNone:KErrGeneral;

	}

void CDmTest1::RunL()

	{

	CActiveScheduler::Stop();

	iManager.Close();

	CDmTestMember** mp;

	for (mp = iMembers; *mp; ++mp)

		delete *mp;

	test(iCount == iMembersCount);

	}

void CDmTest1::DoCancel()

	{

	test(0);

	}

void CDmTest1::Release()

	{

	delete this;

	}

class CDmTest2Timer : public CTimer

	{

public: // fomr CTimer

   void RunL();

public:

	CDmTest2Timer() : CTimer(0) 

		{

		TRAPD(r,

			ConstructL());

		test(r == KErrNone);

		CActiveScheduler::Add(this);

		}

	};

void CDmTest2Timer::RunL()

	{

	test.Printf(_L("Tick count after CDmTest2Timer::RunL() = %d\n"), User::NTickCount());

	// kick the timer again in case power down hasn't happened yet

	TTime wakeup;

	wakeup.HomeTime();

	wakeup += TTimeIntervalSeconds(3);

	At(wakeup);

	}

class CDmTest2 : public CActive, public MDmTest

	{

public: // from CActive

	void RunL();

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete() {};

	CDmTest2 (TDmDomainState aState) : CActive(CActive::EPriorityStandard), iState((TPowerState) aState) {}

protected:

	// from CActive

	virtual void DoCancel();

private:

	enum { KMembersMax = 16 };

	CDmTestMember*		iMembers[KMembersMax]; 

	RDmDomainManager	iManager;

	TPowerState			iState;

	TBool				iAcknowledge;

	TInt				iMembersCount;

	TInt				iCount;

	TUint32				iOrdinal;

	CDmTest2Timer*		iTimer;

	};

void CDmTest2::Perform()

	{

	//

	// Test system standby

	//

	test.Next(_L("Test 2"));

	test.Printf(_L("Target State = 0x%x\n"), iState);

	iMembers[0] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

	test(iMembers[0] != NULL);

	iMembers[1] = new CDmTestMember(KDmHierarchyIdPower, KDmIdRoot, 0, this);

	test(iMembers[1] != NULL);

	iMembers[2] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

	test(iMembers[2] != NULL);

	iMembers[3] = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

	test(iMembers[3] != NULL);

	iMembers[4] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

	test(iMembers[4] != NULL);

	iMembers[5] = new CDmTestMember(KDmHierarchyIdPower, KDmIdUiApps, 1, this);

	test(iMembers[5] != NULL);

	// expected number of notifications

	iMembersCount = 12;

	// first expected ordinal

	iOrdinal = (iState == EPwActive) ? 0 : 1;

	TInt r = iManager.Connect();

	test(r == KErrNone);

	CActiveScheduler::Add(this);

	// Use an absolute timer to request a wakeup event

	iTimer = new CDmTest2Timer();

	TTime wakeup;

	wakeup.HomeTime();

	wakeup += TTimeIntervalSeconds(5);

	test.Printf(_L("Tick count before timer = %d\n"), User::NTickCount());

	iTimer->At(wakeup);

	iManager.RequestSystemTransition(iState, CActive::iStatus);

	CActive::SetActive();

	CActiveScheduler::Start();

	}

TInt CDmTest2::TransitionNotification(MDmDomainMember& aDomainMember)

	{

	++iCount;

	if (aDomainMember.State() == EPwActive)

		{

		if(aDomainMember.Ordinal() < iOrdinal)

			{

			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d, State : %d"), 

																		aDomainMember.Ordinal(), iOrdinal, aDomainMember.State());

			iCount--;

			}

		}

	else

		{

		if(aDomainMember.Ordinal() > iOrdinal)

			{

			// Making the test to fail in RunL function inorder to complete the cleanup from domain manager.

			test.Printf(_L("Making test to fail as Ordinal Mismatch Expected : %d, Returned : %d, State: %d"), 

																		aDomainMember.Ordinal(), iOrdinal, aDomainMember.State());

			iCount--;

			}

		}

	iOrdinal = aDomainMember.Ordinal();

	// acknowledge one from two

	iAcknowledge = !iAcknowledge;

	return iAcknowledge?KErrNone:KErrAbort;

	}

void CDmTest2::RunL()

	{

	test.Printf(_L("Tick count after CDmTest2::RunL() = %d\n"), User::NTickCount());

	iTimer->Cancel();	

	CActiveScheduler::Stop();

	iManager.Close();

	CDmTestMember** mp;

	for (mp = iMembers; *mp; ++mp)

		delete *mp;

	test(CActive::iStatus == KErrTimedOut);

	test(iCount == iMembersCount);

	}

void CDmTest2::DoCancel()

	{

	test(0);

	}

void CDmTest2::Release()

	{

	if (iTimer)

		{

		iTimer->Cancel();

		delete iTimer;

		}

	delete this;

	}

class CDmTest3 : public MDmTest

	{

public: 

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete() {};

	};

void CDmTest3::Perform()

	{

	//

	// Test simple error situation

	//

	RDmDomainManager manager;

	TInt r = manager.Connect();

	test(r == KErrNone);

	RDmDomainManager manager1;

	r = manager1.Connect();

	test(r == KErrInUse);

	RDmDomain domain;

	r = domain.Connect(KDmIdNone);

	test(r == KDmErrBadDomainId);

	CDmTestMember*		testMember;

	testMember = new CDmTestMember(KDmHierarchyIdPower, KDmIdApps, 1, this);

	test (testMember != NULL);

	TRequestStatus status;

	manager.RequestDomainTransition(KDmIdApps, EPwStandby, status);

	test(status.Int() == KRequestPending);

	TRequestStatus status1;

	manager.RequestDomainTransition(KDmIdApps, EPwActive, status1);

	User::WaitForRequest(status1);

	test(status1.Int() == KDmErrBadSequence);

	User::WaitForRequest(status);

	test(status.Int() == KErrTimedOut);

	// Since this test doesn't start the active scheduler, a domain member's RunL() will 

	// not get called so we need to re-request a domain transition notification manually

	User::WaitForRequest(testMember->iStatus);

	test(testMember->iStatus.Int() == KErrNone);

	testMember->iDomain.RequestTransitionNotification(testMember->iStatus);

	manager.RequestDomainTransition(KDmIdApps, EPwActive, status);

	test(status.Int() == KRequestPending);

	manager.CancelTransition();

	test(status.Int() == KErrCancel);

	manager.CancelTransition();

	User::WaitForRequest(status);

	test(status.Int() == KErrCancel);

	testMember->iDomain.CancelTransitionNotification();

	delete testMember;

	domain.Close();

	manager.Close();

	}

TInt CDmTest3::TransitionNotification(MDmDomainMember& /*aDomainMember*/)

	{

	test(0);

	return KErrAbort;	// don't acknowledge

	}

void CDmTest3::Release()

	{

	delete this;

	}

class CDmTest4 : public MDmTest

	{

public: 

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete() {};

private:

	void ExecSlave(TUint arg);

	};

_LIT(KSecuritySlavePath, "t_domain_slave.exe");

void CDmTest4::ExecSlave(TUint aArg)

	{

	RProcess proc;

	TInt r = proc.Create(KSecuritySlavePath, TPtrC((TUint16*) &aArg, sizeof(aArg)/sizeof(TUint16)));

	test(r == KErrNone);

	TRequestStatus status;

	proc.Logon(status);

	proc.Resume();

	User::WaitForRequest(status);

    RDebug::Printf("CDmTest4::ExecSlave(%d) ExitType %d", aArg, proc.ExitType() );

    RDebug::Printf("CDmTest4::ExecSlave(%d) ExitReason %d", aArg, proc.ExitReason() );

	test(proc.ExitType() == EExitKill);

//	test(proc.ExitReason() == KErrPermissionDenied);

	CLOSE_AND_WAIT(proc);

	}

//! @SYMTestCaseID PBASE-T_DOMAIN-4

//! @SYMTestType CT

//! @SYMTestCaseDesc Dmain manager security tests

//! @SYMREQ 3722

//! @SYMTestActions Launches a separate process with no capabilities

//! @SYMTestExpectedResults  DM APIs should fail with KErrPermissionDenied

//! @SYMTestPriority High

//! @SYMTestStatus Defined

void CDmTest4::Perform()

	{

	//

	// Security tests

	//

	ExecSlave(0);

    ExecSlave(1);

	}

TInt CDmTest4::TransitionNotification(MDmDomainMember& /*aDomainMember*/)

	{

	test(0);

	return KErrNone;

	}

void CDmTest4::Release()

	{

	delete this;

	}

// Test hierarchy tests

class CDmTestStartupMember : public CDmTestMember

	{

public:

	CDmTestStartupMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

public:

private:

	};

CDmTestStartupMember::CDmTestStartupMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest) 

	: CDmTestMember(aHierarchy, aId, aOrdinal, aTest)

	{

	}

// Simultaneously testing of test domain defined in DomainPolicy99.dll

// and the power domain defined in DomainPolicy.dll

class CDmTest5 : public CActive, public MDmTest

	{

public: 

	// from CActive

	void RunL();

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete();	

	void RunTestOnGetTransitionFailures(RArray<const TTransitionFailure>& aTransitionFailure);

	CDmTest5(TDmDomainId aPowerId, TDmDomainId aTestId, TDmDomainState aPowerState, TDmDomainState aTestState) : 

		CActive(CActive::EPriorityStandard), 

		iPowerDomainId(aPowerId), iTestDomainId(aTestId), iPowerState(aPowerState), iTestState(aTestState) {}

protected:

	// from CActive

	virtual void DoCancel();

private:

	enum { KMembersMax = 16 };