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

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include "d_prmacctst.h"

_LIT8(KTestToc, "TOC");

_LIT8(KTestTac1, "TAC1");

_LIT8(KTestTac2, "TAC2");

_LIT8(KTestTac3, "TAC3");

// The number of test values for multi-level resources

static const TInt KTestMultiLevelValues = 10;

// Bit 16 in the resource ID indicates that the resource has dependencies

static const TUint32 KTestIdHasDependencies = 0x00010000;

static const TInt    KTestMaxDependencies = 256;

static const TInt    KTestResourceNotInUse = -1;

// structure for holding ResId and ResPrty

struct SResDepInfo

	{

	TUint iResourceId;

	TUint8 iDependencyPriority;

	};

class CTestPrmAccTst : public CBase

	{

public:

	CTestPrmAccTst();

	~CTestPrmAccTst();

	TInt DoTestPreamble();

	void DoTest();

	void DoTestPostamble();

protected:

	TBool ResourceInterdependency(TInt aResourceIdOrig, TInt aCurrentResourceId, TInt aResourceIdTarget);

	void TestEnumerateResources();

	void TestSingleUserResources(TInt aResourceNo);

	void TestSharedResources(TInt aResourceNo);

	void TestBinaryResources(TInt aResourceNo);

	void TestMultilevelResources(TInt aResourceNo);

	void TestLatency(TInt aResourceNo);

	void TestSense(TInt aResourceNo);

	void TestCustomSense(TInt aResourceNo);

	void TestDefaultPowerResumption();

	void TestDependenciesAreDeclared(TInt aResourceNo);

private:

	enum TBinary

		{

		EBinaryOff = 0,

		EBinaryOn = 1

		};

protected:

	RTest test;

private:

	// The test PRM clients

	RPrmIf iToc;   // Test Observer Client (never owns any resource)

	RPrmIf iTac1;  // Active clients...

	RPrmIf iTac2;

	RPrmIf iTac3;

	RPrmIf iKextc;	// The Kernel Extension Client (owns Single User Resources)

	//

	TBool iIsPrmSupported;

	//

	RBuf8 iResources;

	TUint iNoResources;

	//

	static CTestPrmAccTst* iSingletonInstance;

	};

CTestPrmAccTst::CTestPrmAccTst()

	:test(_L("T_PRMACCTST")),

		iIsPrmSupported(EFalse),

		iNoResources(0)

	{

	}

CTestPrmAccTst::~CTestPrmAccTst()

	{

	iResources.Close();

	TInt r = User::FreeLogicalDevice(KPrmIfLddName);

	test(r==KErrNone);

#ifdef RESOURCE_MANAGER_SIMULATED_PSL

	r = User::FreePhysicalDevice(_L("resourcecontrollerextended.pdd"));

	test(r==KErrNone);

#endif

	User::After(100000);

	}

/* ----------------------------------------------------------------------------

@SYMTestCaseID		PBASE-PRMACCTST-ENUMRES-0559

@SYMTestCaseDesc	Ensure current resource state of PRM is correctly listed

@SYMREQ				REQ7751

@SYMPREQ			PREQ1398

@SYMTestPriority	Critical

@SYMTestActions

	1.	Display all resources and their properties

	2.	Ensure the resource state range is coherent

@SYMTestExpectedResults

	1.	All resources are shown with the correct properties

	2.	Min <= Default <= Max and Min < Max if Negative Sense

		Min >= Default >= Max and Max > Min if Positive Sense

		Binary resources states are '0' or '1'

*/

void CTestPrmAccTst::TestEnumerateResources()

	{

	test.Printf(_L("Id       Resource name                    C LG LS T  U  S DefltLvl MinLevel MaxLevel\n"));

	test.Printf(_L("--------+--------------------------------+-+--+--+--+--+-+--------+--------+--------\n"));

	TInt i;

	for (i = 0; i < (TInt) iNoResources; i++)

		{

		TResInfo& res = *((TResInfo*) iResources.Ptr() + i);

		// Display properties

		test.Printf(_L("%08x "), res.iResourceId);

		test_Compare(res.iResourceName->Length(), <=, KNameMaxLength);

		TBuf<KNameMaxLength> tmp;

		tmp.Copy(*res.iResourceName);

		test.Printf(_L("%-.32S "), &tmp);

		//

		if (res.iClass == TResInfo::EPhysical)

			{

			test.Printf(_L("P "));

			}

		else if (res.iClass == TResInfo::ELogical)

			{

			test.Printf(_L("L "));

			}

		else

			{

			test(EFalse);

			}

		//

		if (res.iLatencyGet == TResInfo::EInstantaneous)

			{

			test.Printf(_L("In "));

			}

		else if (res.iLatencyGet == TResInfo::ELongLatency)

			{

			test.Printf(_L("Lo "));

			}

		else

			{

			test(EFalse);

			}

		//

		if (res.iLatencySet == TResInfo::EInstantaneous)

			{

			test.Printf(_L("In "));

			}

		else if (res.iLatencySet == TResInfo::ELongLatency)

			{

			test.Printf(_L("Lo "));

			}

		else

			{

			test(EFalse);

			}

		//

		if (res.iType == TResInfo::EBinary)

			{

			test.Printf(_L("B  "));

			}

		else if (res.iType == TResInfo::EMultiLevel)

			{

			test.Printf(_L("ML "));

			}

		else if (res.iType == TResInfo::EMultiProperty)

			{

			test.Printf(_L("MP "));

			}

		else

			{

			test(EFalse);

			}

		//

		if (res.iUsage == TResInfo::ESingleUse)

			{

			test.Printf(_L("SU "));

			}

		else if (res.iUsage == TResInfo::EShared)

			{

			test.Printf(_L("Sh "));

			}

		else

			{

			test(EFalse);

			}

		//

		if (res.iSense == TResInfo::EPositive)

			{

			test.Printf(_L("+ "));

			}

		else if (res.iSense == TResInfo::ENegative)

			{

			test.Printf(_L("- "));

			}

		else if (res.iSense == TResInfo::ECustom)

			{

			test.Printf(_L("C "));

			}

		else

			{

			test(EFalse);

			}

		//

		test.Printf(_L("%08x "), res.iDefaultLevel);

		test.Printf(_L("%08x "), res.iMinLevel);

		test.Printf(_L("%08x\n"), res.iMaxLevel);

		// Retrieve resource dependencies

		if (res.iResourceId & KTestIdHasDependencies)

			{

			RBuf8 deplist;

			deplist.Create(sizeof(SResDepInfo) * KTestMaxDependencies);

			iToc.GetResourceDependencies(res.iResourceId, deplist);

			TInt j;

			test.Printf(_L("  Direct Dependencies:"));

			SResDepInfo* ptr = (SResDepInfo*)deplist.Ptr();

			for (j = 0; j < (TInt) (deplist.Length() / sizeof(SResDepInfo)); j++, ptr++)

				{

				test.Printf(_L("ResourceId: %08x"), ptr->iResourceId);

				test.Printf(_L("Resource Priority: %08x"), ptr->iDependencyPriority);

				}

			test.Printf(_L("\n"));

			deplist.Close();

			}

		test.Printf(_L("C:Class,P:Physical,L:Logical"));

		test.Printf(_L("LG/LS:Latency Get/Set,In:Instantaneous,Lo:Long Latency"));

		test.Printf(_L("T:Type,MP:Multiproperty,ML:Multilevel,B:Binary"));

		test.Printf(_L("U:Usage,SU:Single-User,Sh:Shared"));

		test.Printf(_L("S:Sense,+:Positive,-:Negative,C:Custom"));

		// Ensure the state range of the resource does not contradict its properties

		if (res.iType == TResInfo::EBinary)

			{

			if (res.iSense == TResInfo::EPositive)

				{

				test(res.iMinLevel == EBinaryOff);

				test(res.iMaxLevel == EBinaryOn);

				}

			else if (res.iSense == TResInfo::ENegative)

				{

				test(res.iMinLevel == EBinaryOn);

				test(res.iMaxLevel == EBinaryOff);

				}

			else if (res.iSense == TResInfo::ECustom)

				{

				test(res.iMinLevel == EBinaryOff || res.iMinLevel == EBinaryOn);

				test(res.iMaxLevel == EBinaryOff || res.iMaxLevel == EBinaryOn);

				test_Compare(res.iMinLevel, !=, res.iMaxLevel);

				}

			test((res.iDefaultLevel == EBinaryOff) || (res.iDefaultLevel == EBinaryOn));

			}

		// Level range must respect resource sense

		if (res.iSense == TResInfo::EPositive)

			{

			test_Compare(res.iMinLevel, <=, res.iMaxLevel);

			test_Compare(res.iMinLevel, <=, res.iDefaultLevel);

			test_Compare(res.iDefaultLevel, <=, res.iMaxLevel);

			test_Compare(res.iMinLevel, <, res.iMaxLevel);

			}

		else if (res.iSense == TResInfo::ENegative)

			{

			test_Compare(res.iMinLevel, >=, res.iMaxLevel);

			test_Compare(res.iMinLevel, >=, res.iDefaultLevel);

			test_Compare(res.iDefaultLevel, >=, res.iMaxLevel);

			test_Compare(res.iMinLevel, >, res.iMaxLevel);

			}

		}

	}

/* ----------------------------------------------------------------------------

@SYMTestCaseID		PBASE-PRMACCTST-SINGLEUSER-0560

@SYMTestCaseDesc	Ensure Single User resources can only be used by one client

					at a time

@SYMREQ				REQ7751

@SYMPREQ			PREQ1398

@SYMTestPriority	High

@SYMTestActions

Pre-condition:

	The resource is not in use

For each Single User resource:

	1.	Register TAC1 & TAC2

	2.	TAC1 changes resource state

	3.	TAC2 changes resource state

	4.	De-register TAC1

	---

	5.	Register TAC1

	6.	TAC2 changes resource state

	7.	TAC1 changes resource state

	8.	De-register TAC1 & TAC2

@SYMTestExpectedResults

	1.	Clients registered

	2.	Resource state changed

	3.	KErrAccessDenied as there is already one registered client

	4.	Client de-registered

	---

	5.	Client registered

	6.	Resource state changed

	7.	KErrAccessDenied as there is already one registered client

	8.	Both clients de-registered

*/

void CTestPrmAccTst::TestSingleUserResources(TInt aResourceNo)

	{

	test.Printf(_L("---Single-User "));

	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);

	// Test pre-condition: resource not in use

	TInt levelowner;

	TInt r = iToc.GetLevelOwner(res.iResourceId, levelowner);

	test_KErrNone(r);

	if (levelowner != KTestResourceNotInUse)

		{

		test.Printf(_L("Not tested (Single-User resource already in use)\n"));

		return;

		}

	// Define two test values

	TInt state;

	r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	//

	TInt tstval1;

	TInt tstval2;

	if (state == res.iMinLevel)

		{

		tstval1 = res.iMaxLevel;

		tstval2 = res.iMinLevel;

		}

	else

		{

		tstval1 = res.iMinLevel;

		tstval2 = res.iMaxLevel;

		}

	// Test starts here

	r = iTac1.Open();

	test_KErrNone(r);

	r = iTac2.Open();

	test_KErrNone(r);

	r = iTac1.RegisterClient(KTestTac1);

	test_KErrNone(r);

	r = iTac2.RegisterClient(KTestTac2);

	test_KErrNone(r);

	//

	r = iTac1.ChangeResourceState(res.iResourceId, tstval1);

	test_KErrNone(r);

	r = iTac1.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval1, state);

	r = iTac2.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval1, state);

	r = iTac2.ChangeResourceState(res.iResourceId, tstval2);

	test_Equal(KErrAccessDenied, r); // TAC2 cannot change the resource state

	//

	r = iTac1.DeRegisterClient();

	test_KErrNone(r);

	r = iTac1.RegisterClient(KTestTac1);

	test_KErrNone(r);

	r = iTac2.ChangeResourceState(res.iResourceId, tstval2);

	test_KErrNone(r);

	r = iTac1.GetResourceState(res.iResourceId, state);

	test_KErrNone(r); // TAC1 can still access the resource state...

	test_Equal(tstval2, state);

	r = iTac1.ChangeResourceState(res.iResourceId, tstval1);

	test_Equal(KErrAccessDenied, r); // ... but cannot change it

	r = iTac2.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval2, state); // The resource state remains unchanged indeed

	//

	r = iTac1.DeRegisterClient();

	test_KErrNone(r);

	r = iTac2.DeRegisterClient();

	test_KErrNone(r);

	iTac1.Close();

	iTac2.Close();

	test.Printf(_L("\n"));

	}

/* ----------------------------------------------------------------------------

@SYMTestCaseID		PBASE-PRMACCTST-SHARED-0561

@SYMTestCaseDesc	Ensure a Shared Resources can be changed by several

					clients

@SYMREQ				REQ7751

@SYMPREQ			PREQ1398

@SYMTestPriority	High

@SYMTestActions

Pre-conditions: 

	If in use, resource state is not equal to max level

	Resource is not Custom Sense

For each Shared resource:

	1.	Register TOC, TAC1 & TAC2

	2.	TAC1 changes resource state to level1

	3.	TAC2 changes resource state to level2

	4.	TAC2 changes resource state to level1

	5.	TAC1 changes resource state to level2

	6.	De-register TOC, TAC1 & TAC2

@SYMTestExpectedResults

	1.	Clients registered

	2.	Resource state changed

	3.	Resource state changed

	4.	Resource state changed

	5.	Resource state changed

	6.	Clients de-registered

*/

void CTestPrmAccTst::TestSharedResources(TInt aResourceNo)

	{

	test.Printf(_L("---Shared "));

	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);

	// Test pre-conditions

	if (res.iSense == TResInfo::ECustom)

		{

		test.Printf(_L("Not tested (Custom sense resource)\n"));

		return;

		}

	//

	TInt state;

	TInt r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	TInt levelowner;

	r = iToc.GetLevelOwner(res.iResourceId, levelowner);

	test_KErrNone(r);

	//

	if (levelowner != KTestResourceNotInUse && state == res.iMaxLevel)

		{

		test.Printf(_L("Not tested: Resource is already at maximum level\n"));

		return;

		}

	// Define two test values

	TInt tstval1;

	TInt tstval2;

	if (levelowner != KTestResourceNotInUse)

		{

		// Resource already in use

		tstval1 = state;

		tstval2 = res.iMaxLevel;

		}

	else

		{

		// Resource not in use

		tstval1 = res.iMinLevel;

		tstval2 = res.iMaxLevel;

		}

	// Test starts here

	r = iTac1.Open();

	test_KErrNone(r);

	r = iTac2.Open();

	test_KErrNone(r);

	r = iTac1.RegisterClient(KTestTac1);

	test_KErrNone(r);

	r = iTac2.RegisterClient(KTestTac2);

	test_KErrNone(r);

	//

	r = iTac1.ChangeResourceState(res.iResourceId, tstval1);

	test_KErrNone(r);

	r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval1, state);

	//

	r = iTac2.ChangeResourceState(res.iResourceId, tstval2);

	test_KErrNone(r);

	r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval2, state);

	//

	r = iTac2.ChangeResourceState(res.iResourceId, tstval1);

	test_KErrNone(r);

	r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval1, state);

	//

	r = iTac1.ChangeResourceState(res.iResourceId, tstval2);

	test_KErrNone(r);

	r = iToc.GetResourceState(res.iResourceId, state);

	test_KErrNone(r);

	test_Equal(tstval2, state);

	//

	r = iTac1.DeRegisterClient();

	test_KErrNone(r);

	r = iTac2.DeRegisterClient();

	test_KErrNone(r);

	//

	iTac1.Close();

	iTac2.Close();

	test.Printf(_L("\n"));

	}

/* ----------------------------------------------------------------------------

@SYMTestCaseID		PBASE-PRMACCTST-BINARY-0562

@SYMTestCaseDesc	Ensure Binary Resources function as expected

@SYMREQ				REQ7751

@SYMPREQ			PREQ1398

@SYMTestPriority	High

@SYMTestActions

Pre-conditions:

Resource not in use, or...

	If Shared/Positive Sense, current resource must be off

	If Shared/Negative Sense, current resource must be on

Resource is not Custom Sense

For each Binary resource:

	1.	Register TAC1

	2.	Turn resource off and toggle resource state several times

	3.	De-register TAC1

@SYMTestExpectedResults

	1.	Client registered

	2.	Resource state changes as expected

	3.	De-register TAC1

*/

void CTestPrmAccTst::TestBinaryResources(TInt aResourceNo)

	{

	test.Printf(_L("---Binary "));

	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);

	// Test pre-conditions