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

// e32test/domainmgr/t_domain_monitor.cpp

// Overview:

// Domain manager transition monitoring feature implementation tests

//

// API Information:

// RDmDomain, RDmDomainManager CDmDomain, CDmDomainManager,CDmDomanKeepAlive

//

//  - Domain member deferral and acknowledgments tests

//  - Domain manager policy interface tests

//  - Domain member deferral requests Platsec capability checking tests

//

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32ldr_private.h>

#include <domainobserver.h>

#include "domainpolicytest.h"

#include "t_domain.h"

RTest test(_L(" T_DOMAIN_MONITOR "));

/**

   Domain member deferral requests PlatSec capability checking tests.

*/

_LIT(KSecuritySlavePath1, "t_dmslave_nocaps.exe");

_LIT(KSecuritySlavePath2, "t_dmslave_wdd.exe");

_LIT(KSecuritySlavePath3, "t_dmslave_protsrv.exe");

class CDmTestPlatSec : public CActive, public MDmTest

	{

public:

	CDmTestPlatSec(TPtrC aFileName);

	~CDmTestPlatSec()

		{

		Cancel();

		iManager.Close();

		}

	// from CActive

	void RunL();

	// from MDmTest

	void Perform();

	void Release();

	TInt TransitionNotification(MDmDomainMember&)

		{

		test(0);

		return KErrNone;

		}

	void TransitionRequestComplete()

		{}

private:

	// from CActive

	virtual void DoCancel()

		{

		test(0);

		}

private:

	RDmDomainManager iManager;

	const TPtrC iFileName;

	};

CDmTestPlatSec::CDmTestPlatSec(TPtrC aFileName)

	: CActive(CActive::EPriorityStandard), iFileName(aFileName)

	{}

void CDmTestPlatSec::Perform()

	{

	test.Next(_L("CDmTestPlatSec"));

	// 1. Set up test hierarchy/domain & join it

	TInt r = RDmDomainManager::AddDomainHierarchy(KDmHierarchyIdTestV2);

	test_KErrNone(r);

	r = iManager.Connect(KDmHierarchyIdTestV2);

	test_KErrNone(r);

	// 2. Create a child process

	RProcess proc;

	r = proc.Create(iFileName, KNullDesC);

	test_KErrNone(r);

	// Start process & wait until child has set up itself (3. & 4.)

	TRequestStatus status;

	proc.Rendezvous(status);

	proc.Resume();

	User::WaitForRequest(status);

	test_KErrNone(status.Int());

	// 5. Transition test domain to some other state (child: 6. & 7.)

	CActiveScheduler::Add(this);

	iManager.RequestDomainTransition(KDmIdTestA, EShutdownNonCritical, ETraverseDefault, iStatus);

	CActive::SetActive();

	CActiveScheduler::Start();

	// Child processes do: TC 3.1, 3.2, 3.3

	CLOSE_AND_WAIT(proc);

	}

void CDmTestPlatSec::RunL()

	{

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

	CActiveScheduler::Stop();

	}

void CDmTestPlatSec::Release()

	{

	delete this;

	}

/**

   Checks that upon transition acknowledgment, outstanding deferral is

   completed with KErrCompletion.

*/

class CDmDeferralTestCompletion : public CDmDeferralTest, public MDeferringMember

	{

public:

	CDmDeferralTestCompletion(TDmHierarchyId aId, TDmDomainState aState)

		: CDmDeferralTest(aId, aState)

		{}

	~CDmDeferralTestCompletion()

		{

		delete iKeepAlive;

		}

	void DoPerform()

		{

		test.Next(_L("CDmDeferralTestCompletion\n"));

		iMember = new CDmTestMember(iHierarchyId, KDmIdTestA, 0, this);

		test_NotNull(iMember);

		iKeepAlive = new CTestKeepAlive(iMember->iDomain);

		test_NotNull(iKeepAlive);

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

		}

	void HandleEndOfDeferrals(TInt aError)

		{

		test.Printf(_L("End of deferrals\n"));

		// This is the test (TC 1.1.1.2.1):

		test_Equal(KErrCompletion, aError);

		}

	TInt TransitionNotification(MDmDomainMember& /*aDomainMember*/)

		{

		iKeepAlive->BeginDeferrals(this, 1);

		return KErrNone;

		}

	void TransitionRequestComplete()

		{

		}

private:

	CTestKeepAlive* iKeepAlive;

	};

/**

   Checks that after deferring a given number of times, the deferral

   after fails with KErrNotSupported.

*/

class CDmDeferralTestKErrNotSupported : public CDmDeferralTest, public MDeferringMember

	{

public:

	/**

	@param aCount Number of deferrals to attempt

	*/

	CDmDeferralTestKErrNotSupported(TDmHierarchyId aId, TDmDomainState aState, TInt aCount)

		: CDmDeferralTest(aId, aState), iCount(aCount)

		{}

	~CDmDeferralTestKErrNotSupported()

		{

		delete iKeepAlive;

		}

	// from CDmDeferralTest

	void DoPerform()

		{

		test.Next(_L("CDmDeferralTestKErrNotSupported\n"));

		test.Printf(_L("CDmDeferralTestKErrNotSupported: Hierachy %d, state %d, attempt %d deferrals\n"),

			iHierarchyId, iState, iCount);

		iMember = new CDmTestMember(iHierarchyId, KDmIdTestA, 0, this);

		test_NotNull(iMember);

		iKeepAlive = new CTestKeepAlive(iMember->iDomain);

		test_NotNull(iKeepAlive);

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

		}

	// from MDeferringMember

	void HandleEndOfDeferrals(TInt aError)

		{

		iMember->Acknowledge();

		test.Printf(_L("CDmDeferralTestKErrNotSupported: End of deferrals %d\n"), aError);

		// This is the test (TC 1.1.1.3.1, TC 1.1.1.3.2, TC 1.1.1.3.3):

		test_Equal(KErrNotSupported, aError);

		}

	// from MDmTest

	TInt TransitionNotification(MDmDomainMember& /*aDomainMember*/)

		{

		iKeepAlive->BeginDeferrals(this, iCount);

		return KErrAbort; // Don't acknowledge yet

		}

	void TransitionRequestComplete()

		{

		RDebug::Printf("CDmDeferralTestKErrNotSupported::TransitionRequestComplete()");

		test_KErrNone(iStatus.Int());

		}

private:

	CTestKeepAlive* iKeepAlive;

	const TInt iCount;

	};

/**

   DeferAcknowledgement() with status KErrNone.

   1: Client receives notification, defers once and then acknowledges after the

   next notification

   2: Client receives notification, defers twice and then acknowledges after

   the next notification

   3: Client receives notification, defers once and then fails to acknowledge

*/

class CDmDeferralTestKErrNone : public CDmDeferralTest, public MDeferringMember

	{

public:

	CDmDeferralTestKErrNone(TDmHierarchyId aId, TDmDomainState aState,

							TInt aDeferrals, TBool aAcknowledge);

	~CDmDeferralTestKErrNone();

	// from CDmDeferralTest

	void DoPerform();

	// from MDmTest

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete();

	// from MDeferringMember

	void HandleEndOfDeferrals(TInt aError);

private:

	CTestKeepAlive* iKeepAlive;

	const TInt iDeferrals;

	const TBool iAcknowledge;

	};

CDmDeferralTestKErrNone::CDmDeferralTestKErrNone(TDmHierarchyId aId,

												 TDmDomainState aState,

												 TInt aDeferrals,

												 TBool aAcknowledge)

	: CDmDeferralTest(aId, aState),

	  iDeferrals(aDeferrals),

	  iAcknowledge(aAcknowledge)

	{}

CDmDeferralTestKErrNone::~CDmDeferralTestKErrNone()

	{

	delete iKeepAlive;

	}

void CDmDeferralTestKErrNone::DoPerform()

	{

	test.Next(_L("CDmDeferralTestKErrNone"));

	iMember = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this);

	test_NotNull(iMember);

	iKeepAlive = new CTestKeepAlive(iMember->iDomain);

	test_NotNull(iKeepAlive);

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

	}

void CDmDeferralTestKErrNone::HandleEndOfDeferrals(TInt aError)

	{

	test.Printf(_L("HandleEndOfDeferrals(): %d\n"), aError);

	// This is the test (TC 1.1.1.1.1, TC 1.1.1.1.2 , TC 1.1.1.1.3):

	test_Equal(KErrNone, aError);

	if (iAcknowledge)

		{

		RDebug::Printf(" Calling AcknowledgeLastState()");

		iMember->iDomain.AcknowledgeLastState();

		}

	}

TInt CDmDeferralTestKErrNone::TransitionNotification(MDmDomainMember&)

	{

	iKeepAlive->BeginDeferrals(this, iDeferrals);

	// don't acknowledge yet

	return KErrAbort;

	}

void CDmDeferralTestKErrNone::TransitionRequestComplete()

	{

	}

/**

   Test mix of deferral and non-deferral clients (1.3)

   1: Three clients receive notification.

   2: One makes three deferrals and then acknowledges after the next notification

   3: The other two non-deferral clients acknowledge without making a deferral      

*/

class CDmDeferralMixed : public CDmDeferralTest, public MDeferringMember

	{

public:

	CDmDeferralMixed(TDmHierarchyId aId, TDmDomainState aState, TInt aDeferrals, TBool aAcknowledge, TBool aDelayAck);

	~CDmDeferralMixed();

	// from CDmDeferralTest

	void DoPerform();

	// from MDmTest

	TInt TransitionNotification(MDmDomainMember& aDomainMember);

	void TransitionRequestComplete();

	// from MDeferringMember

	void HandleEndOfDeferrals(TInt aError);

private:

	CTestKeepAlive* iKeepAlive;	

	CDmTestMember* iMixedDeferralTestMember[2];

	const TInt iDeferrals;

	const TBool iAcknowledge;

	TBool iDoneDeferral;	

	const TBool iDelayAck;

	TBool iNonMemberAck[2];

	MDmDomainMember* iFirstMemberToCompleteAddr;

	};

CDmDeferralMixed::CDmDeferralMixed(TDmHierarchyId aId, 

								   TDmDomainState aState,

								   TInt aDeferrals,

								   TBool aAcknowledge,

								   TBool aDelayAck)	

    :CDmDeferralTest(aId, aState),

 	 iDeferrals(aDeferrals),

	 iAcknowledge(aAcknowledge),

	 iDelayAck(aDelayAck)

	{

	iDoneDeferral=EFalse; 	

	iFirstMemberToCompleteAddr = NULL;

	iNonMemberAck[0]=EFalse;

	iNonMemberAck[1]=EFalse;

	}

CDmDeferralMixed::~CDmDeferralMixed()

	{

	delete iKeepAlive;	

	delete iMixedDeferralTestMember[0];

	delete iMixedDeferralTestMember[1];	   

	}

void CDmDeferralMixed::DoPerform()

	{

	test.Next(_L("CDmDeferralMixed"));	

	// Attach three test members to the same domain (KDmIdTestCAA). One of the test

	// member is a deferring member while the other two are non deferring members.

	iMember = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this);

	test_NotNull(iMember);

	iMixedDeferralTestMember[0] = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this);

	test_NotNull(iMixedDeferralTestMember[0]);

	iMixedDeferralTestMember[1] = new CDmTestMember(iHierarchyId, KDmIdTestCAA, 0, this); 

	test_NotNull(iMixedDeferralTestMember[1]);

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

	}

void CDmDeferralMixed::HandleEndOfDeferrals(TInt aError)

	{

	test.Printf(_L("HandleEndOfDeferrals(): %d\n"), aError);

	test_Equal(KErrNone, aError);

	if (iAcknowledge)

		{

		RDebug::Printf(" Calling AcknowledgeLastState()");

		//iFirstMemberToCompleteAddr is the first member to complete and is deferred 

		static_cast<CDmTestMember*>(iFirstMemberToCompleteAddr)->iDomain.AcknowledgeLastState();		

		iDoneDeferral = ETrue;

		}

	}

TInt CDmDeferralMixed::TransitionNotification(MDmDomainMember& aDomainMember)

	{

	RDebug::Printf("CDmDeferralMixed::TransitionNotification()");

	// if first member to complete, take note of this member and defer.

	if (iFirstMemberToCompleteAddr ==  NULL)

		{

		iFirstMemberToCompleteAddr =  &aDomainMember; // Get address of first member to complete		

		iKeepAlive = new CTestKeepAlive(static_cast<CDmTestMember*>(iFirstMemberToCompleteAddr)->iDomain);

		test_NotNull(iKeepAlive);		

		}

	if  ( (!iDoneDeferral) && (&aDomainMember == iFirstMemberToCompleteAddr) ) // Defer 

		{

		//TC 1.3.1 Define a client to defer 3 times and then acknowledge and include 2 non deferring clients 	

		test.Printf(_L("CDmDeferralMixed Attempting %d deferrals\n"), iDeferrals);

		iKeepAlive->BeginDeferrals(this, iDeferrals);		

		return KErrAbort;// don't acknowledge yet

		}

	else if (iNonMemberAck[0]== EFalse) 

		{//One of the two non deferring clients which acknowledges without any delay

		iNonMemberAck[0]= ETrue;

		test.Printf(_L("CDmDeferralMixed acknowledging iMixedDeferralTestMember - 1 \n"));	

		return KErrNone;  // Non deferral memeber acknowledges on time

		}

	else if (iNonMemberAck[1]== EFalse ) 

		{//One of the two non deferring clients which acknowledges with and without a delay based on the state of iDelayAck

		iNonMemberAck[1]= ETrue;

		if(!iDelayAck)

			{

			test.Printf(_L("CDmDeferralMixed acknowledging iMixedDeferralTestMember - 2 \n"));

			return KErrNone; // Non deferral member acknowledges on time

			}

		else

			{

			test.Printf(_L("CDmDeferralMixed delaying acknowledgement for iMixedDeferralTestMember - 2  \n"));

			//TC 1.3.2 - 1 fails to acknowledge in time

			return KErrAbort; // Delay acknowlegdement

			}			

		}

	test(EFalse);

	//default

	return KErrNone;

	}					

void CDmDeferralMixed::TransitionRequestComplete()

	{

	RDebug::Printf("CDmDeferralMixed::TransitionRequestComplete()");

	}

/////////////////////////////////////////////// CDmKeepAlive Test cases ///////////////////////////////////////////////

//-------------------------------------------------

// Domain member deferral and acknowledgments tests

//-------------------------------------------------

class MDomainMemberTests;

class CDomainMemberKeepAlive;

const TUint KMembersMax = 32;

// Policy related service functions user by the CDmDomainKeepAlive tests

SDmStateSpecV1 Get0DeferralState()

	{

	TUint i = 0;

	for (i=0; i<StateSpecificationSize; i++)

		{

		if(StateSpecification[i].iDeferralLimit != 0)

			continue;

		return StateSpecification[i];

		}

	// We could not find any state that has a 0 deferral specified in the policy

	test(0);

	return StateSpecification[i]; // get rid of compiler warnings

	}

// Get the first minimal deferral state from the policy greater than 0

SDmStateSpecV1 GetMinDeferralState() 

	{

	SDmStateSpecV1 maxState, minState;

	maxState = StateSpecification[0];

	minState = StateSpecification[0];

	for (TUint i=0; i<StateSpecificationSize; i++)

		{

		if(StateSpecification[i].iDeferralLimit != 0)

			{

			if(StateSpecification[i].iDeferralLimit > maxState.iDeferralLimit)

				maxState = StateSpecification[i];

			if(StateSpecification[i].iDeferralLimit < minState.iDeferralLimit)

				{

				minState = StateSpecification[i];

				}

			else if(minState.iDeferralLimit == 0)

				minState = StateSpecification[i];

			}

		continue;

		}

	test.Printf(_L("minState's TimeoutMs = %d , count = %d\n"), minState.iTimeoutMs, minState.iDeferralLimit );

	// Test whether there exists atleast one minimal deferral state that is greater than 0 deferrals and less than max deferrals

	test(minState.iDeferralLimit > 0 && minState.iDeferralLimit < maxState.iDeferralLimit);