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

// e32test\power\t_domain.cpp

// 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 <domainmember.h>

#include <domainmanager.h>

#include <domainobserver.h>

#include "domainpolicytest.h"

#include <e32debug.h>

#include <f32file.h>

#include <e32ldr.h>

#include <e32ldr_private.h>

LOCAL_D RTest test(_L(" T_DOMAIN "));

_LIT(KThreadName, "t_domain_panic_thread");

#ifdef _DEBUG

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

#else

#define __PRINT(x) 

#endif

class CDmTestMember;

// interface for test domain memebers.

// Any test memeber should derive from this interface 

class MDmDomainMember

	{

public:

	virtual TDmHierarchyId HierarchyId() = 0;

	virtual TDmDomainId	DomainId() = 0;

	virtual TDmDomainState State() = 0;

	virtual TInt Status() = 0;

	virtual TUint32 Ordinal() = 0;

	virtual TInt Notifications() = 0;

	};

class MDmTest

	{

public:

	virtual void Perform() = 0;

	virtual void Release() = 0;

	virtual TInt TransitionNotification(MDmDomainMember& aDomainMember) = 0;

	virtual void TransitionRequestComplete() = 0;

	};

// for the test hierarchy, we generate an ordinal for each domain

// each byte of which describes the exact location of the domain in the hierarchy

#define ORDINAL_FROM_DOMAINID0(id) (id)

#define ORDINAL_FROM_DOMAINID1(parent, id) ((parent << 8) | (id))

#define ORDINAL_FROM_DOMAINID2(grandparent, parent, id) ((grandparent << 16) | (parent << 8) | id)

#define ORDINAL_FROM_DOMAINID3(greatgrandparent, grandparent, parent, id) ((greatgrandparent << 24) | (grandparent << 16) | (parent << 8) | id)

#define PARENT_ORDINAL(id) (id >> 8)

#define ORDINAL_LEVEL(ordinal)			\

	((ordinal & 0xFF00) == 0) ? 1 :			\

	((ordinal & 0xFF0000) == 0) ? 2 :		\

	((ordinal & 0xFF000000) == 0) ? 3 : 4;

// get the least significant domain id character (for debugging purposes)

TBool GetDomainChar(TDmDomainId aDomainId, TChar& aChar)

	{

	TBool found = ETrue;

	switch(aDomainId)

		{

		case KDmIdTestA:	aChar = 'A'; break;

		case KDmIdTestB:	aChar = 'B'; break;

		case KDmIdTestC:	aChar = 'C'; break;

		case KDmIdTestAA:	aChar = 'A'; break;

		case KDmIdTestAB:	aChar = 'B'; break;

		case KDmIdTestBA:	aChar = 'A'; break;

		case KDmIdTestCA:	aChar = 'A'; break;

		case KDmIdTestABA:	aChar = 'A'; break;

		case KDmIdTestABB:	aChar = 'B'; break;

		case KDmIdTestCAA:	aChar = 'A'; break;

		// domain char not found 

		case KDmIdNone:

		case KDmIdRoot:		

		default:			

			found = EFalse;

		}

	return found;

	}

// prints the 4-character domain string into the passed descriptor (for debugging purposes)

// e.g. "CAA" for KDmIdTestCAA

void GetDomainDesc(TUint32 aOrdinal, TDes& aDes)

	{

	if (aOrdinal == KDmIdRoot)

		{

		aDes.Append(_L("root"));

		return;

		}

	TUint32 val =  aOrdinal;

	for (TInt n=0; n<4; n++)

		{

		TDmDomainId domainId = (TDmDomainId) (val >> 24);

		TChar ch;

		TBool found = GetDomainChar(domainId, ch);

		if (found)

			aDes.Append(ch);

		val = val << 8;

		}

	}

class CDmTestMember : public CActive, public MDmDomainMember

	{

public:	

	// from CActive

	void RunL();

	// from MDmDomainMember

	inline TDmHierarchyId HierarchyId() {return iHierarchy;};

	inline TDmDomainId	DomainId() {return iId;};

	inline TDmDomainState State() {return iState;};

	inline TInt Status() {return iStatus.Int();};

	inline TUint32 Ordinal() {return iOrdinal;};

	inline TInt Notifications() {return iNotifications;};

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

	~CDmTestMember();

	void Acknowledge();

protected:

	// from CActive

	virtual void DoCancel();

public:

	TDmHierarchyId iHierarchy;

	TDmDomainId	iId;

	TDmDomainState iState;

	TUint32		iOrdinal;

	MDmTest*	iTest;	

	TInt		iNotifications;

	RDmDomain	iDomain;

	};

CDmTestMember::CDmTestMember(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest* aTest) : CActive(CActive::EPriorityStandard), 

	iHierarchy(aHierarchy), iId(aId), iOrdinal(aOrdinal), iTest(aTest)

	{

	TInt r;

	if (iHierarchy == KDmHierarchyIdPower)

		 r = iDomain.Connect(iId);

	else

		 r = iDomain.Connect(iHierarchy, iId);

	test(r == KErrNone);

	CActiveScheduler::Add(this);

	iDomain.RequestTransitionNotification(CActive::iStatus);

	CActive::SetActive();

	}

CDmTestMember::~CDmTestMember()

	{

	CActive::Cancel();

	iDomain.Close();

	}

void CDmTestMember::Acknowledge()

	{

	iDomain.AcknowledgeLastState();

	}

void CDmTestMember::RunL()

	{

	iNotifications++;

	iState = iDomain.GetState();

	TInt ackError = iTest->TransitionNotification(*this);

	if (ackError == KErrNone)

		iDomain.AcknowledgeLastState();

	else if (ackError == KErrAbort)	// don't acknowledge

		;

	else

		iDomain.AcknowledgeLastState(ackError);

	// request another notification (even if we didn't acknowledge the last one)

	iDomain.RequestTransitionNotification(CActive::iStatus);

	CActive::SetActive();

	}

void CDmTestMember::DoCancel()

	{

	iDomain.CancelTransitionNotification();

	}

// CDomainMemberAo

class CDomainMemberAo : public CDmDomain, public MDmDomainMember

	{

public:	

	static CDomainMemberAo* NewL(TDmHierarchyId aHierarchy, TDmDomainId aId, TUint32 aOrdinal, MDmTest*);

	~CDomainMemberAo();

	// from CActive

	void RunL();

	// from MDmDomainMember

	inline TDmHierarchyId HierarchyId() {return iHierarchy;};

	inline TDmDomainId	DomainId() {return iId;};

	inline TDmDomainState State() {return iState;};

	inline TInt Status() {return iStatus.Int();};

	inline TUint32 Ordinal() {return iOrdinal;};

	inline TInt Notifications() {return iNotifications;};

private:

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

public:

	TDmHierarchyId iHierarchy;

	TDmDomainId	iId;

	TDmDomainState iState;

	TUint32		iOrdinal;

	MDmTest*	iTest;	

	TInt		iNotifications;

	};

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

	{

	CDomainMemberAo* self=new (ELeave) CDomainMemberAo(aHierarchy, aId, aOrdinal, aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	self->RequestTransitionNotification();

	CleanupStack::Pop();

	return self;

	}

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

	CDmDomain(aHierarchy, aId), 

	iHierarchy(aHierarchy), iId(aId), iOrdinal(aOrdinal), iTest(aTest)

	{

	}

CDomainMemberAo::~CDomainMemberAo()

	{

	Cancel();

	}

void CDomainMemberAo::RunL()

	{

	iNotifications++;

	iState = GetState();

	TInt ackError = iTest->TransitionNotification(*this);

	if (ackError == KErrNone)

		AcknowledgeLastState(ackError);

	else if (ackError == KErrAbort)	// don't acknowledge

		;

	else

		AcknowledgeLastState(ackError); 

	if (ackError != KErrAbort)	

		AcknowledgeLastState(ackError);

	// request another notification (even if we didn't acknowledge the last one)

	RequestTransitionNotification();

	}

// CDomainManagerAo

class CDomainManagerAo : public CDmDomainManager

	{

public:	

	~CDomainManagerAo();

	static CDomainManagerAo* NewL(TDmHierarchyId aHierarchy, MDmTest& aTest);

	// from CActive

	void RunL();

private:

	CDomainManagerAo(TDmHierarchyId aHierarchy, MDmTest& aTest);

private:

	MDmTest& iTest;

	};

CDomainManagerAo* CDomainManagerAo::NewL(TDmHierarchyId aHierarchy, MDmTest& aTest)

	{

	CDomainManagerAo* self=new (ELeave) CDomainManagerAo(aHierarchy, aTest);

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop();

	return self;

	}

CDomainManagerAo::CDomainManagerAo(TDmHierarchyId aHierarchy, MDmTest& aTest) : 

	CDmDomainManager(aHierarchy), iTest(aTest)

	{

	}

CDomainManagerAo::~CDomainManagerAo()

	{

	}

void CDomainManagerAo::RunL()

	{

	iTest.TransitionRequestComplete();

	}

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