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

// Framework code for Domain Manager tests.

//

#include <e32base.h>

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include "domainpolicytest.h"

#include "t_domain.h"

extern RTest test;

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

		}

	}

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()

	{

	RDebug::Printf("CDmTestMember::RunL(): %d", iStatus.Int());

	iNotifications++;

	if (iHierarchy == KDmHierarchyIdPower)

		{

		iState = (TDmDomainState) iDomain.GetPowerState();

		}

	else

		{

		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* 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()

	{

	RDebug::Printf("CDomainMemberAo::RunL(): %d", iStatus.Int());

	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* 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()

	{

	RDebug::Printf("CDomainManagerAo::RunL(): %d", iStatus.Int());

	iTest.TransitionRequestComplete();

	}

//

// Deferral Test code

//

//

// CDmDeferralTest

//

CDmDeferralTest::CDmDeferralTest(TDmHierarchyId aId, TDmDomainState aState)

	: CActive(CActive::EPriorityStandard), iHierarchyId(aId), iState(aState)

	{

	CActiveScheduler::Add(this);

	}

CDmDeferralTest::~CDmDeferralTest()

	{

	iManager.Close();

	delete iMember;

	}

/**

Basic test setup : load and connect to appropriate hierarchy

*/

void CDmDeferralTest::Perform()

	{

	TInt r = RDmDomainManager::AddDomainHierarchy(iHierarchyId);

	test_KErrNone(r);

	r = iManager.Connect(iHierarchyId);

	test_KErrNone(r);

	DoPerform();

	CActive::SetActive();

	CActiveScheduler::Start();

	}

void CDmDeferralTest::Release()

	{

	delete this;

	}

/**

aDomainMember has recieved a transition notification

*/

TInt CDmDeferralTest::TransitionNotification(MDmDomainMember& aDomainMember)

	{

	test.Printf(_L("MDmDomainMember notified of transition, Domain ID=%d"),

				aDomainMember.DomainId());

	return KErrNone;

	}

/**

A transition has completed

*/

void CDmDeferralTest::TransitionRequestComplete()

	{}

void CDmDeferralTest::RunL()

	{

	RDebug::Printf("CDmDeferralTest::RunL(): %d", iStatus.Int());

	TransitionRequestComplete();

	CActiveScheduler::Stop();

	}

void CDmDeferralTest::DoCancel()

	{

	test(0);

	}

//

//

// CTestKeepAlive

//

CTestKeepAlive::CTestKeepAlive(RDmDomain& aDomain)

	: CActive(CActive::EPriorityHigh), iDomain(aDomain), iCount(0)

	{

	CActiveScheduler::Add(this);

	}

CTestKeepAlive::~CTestKeepAlive()

	{

	Cancel();

	}

/**

Begin deferrals

@param aMember The object to notify when deferrals cease

@param aDeferralCount Number of times to defer

*/

void CTestKeepAlive::BeginDeferrals(MDeferringMember* aMember, TInt aDeferralCount)

	{

	iDeferringMember = aMember;

	iCount = aDeferralCount;

	if(iCount > 0)

		DeferAcknowledgement();

	}

void CTestKeepAlive::DeferAcknowledgement()

	{

	test.Printf(_L("DeferAcknowledgement() iCount %d\n"), iCount);

	iDomain.DeferAcknowledgement(iStatus);

	SetActive();

	}

void CTestKeepAlive::RunL()

	{

	RDebug::Printf("CTestKeepAlive::RunL(): %d", iStatus.Int());

	test(iCount>0);

	--iCount;

	TInt err = iStatus.Int();

	if((iCount == 0) || (KErrNone != err))

		{

		iDeferringMember->HandleEndOfDeferrals(err);

		iDeferringMember = NULL;

		}

	else

		{

		DeferAcknowledgement();

		}

	}

void CTestKeepAlive::DoCancel()

	{

	iDomain.CancelDeferral();

	}