diff -r 000000000000 -r bde4ae8d615e os/kernelhwsrv/kerneltest/e32test/resourceman/acctst/t_prmacctst.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/kernelhwsrv/kerneltest/e32test/resourceman/acctst/t_prmacctst.cpp	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,1518 @@
+// 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
+	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)
+		{
+		if (res.iUsage == TResInfo::ESingleUse)
+			{
+			test.Printf(_L("Not tested (Single-User resource already in use)\n"));
+			return;
+			}
+		if (res.iSense == TResInfo::EPositive && state == EBinaryOn)
+			{
+			test.Printf(_L("Not tested (Positive sense resource is already on)\n"));
+			return;
+			}
+		if (res.iSense == TResInfo::ENegative && state == EBinaryOff)
+			{
+			test.Printf(_L("Not tested (Negative sense resource is already off)\n"));
+			return;
+			}
+		}
+	// Test starts here
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+
+	// Turn Resource off
+	r = iTac1.ChangeResourceState(res.iResourceId, EBinaryOff);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(EBinaryOff, state);
+
+	// Turn it on
+	r = iTac1.ChangeResourceState(res.iResourceId, EBinaryOn);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(EBinaryOn, state);
+
+	// Turn it off
+	r = iTac1.ChangeResourceState(res.iResourceId, EBinaryOff);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(EBinaryOff, state);
+	//
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-MULTILEVEL-0563
+@SYMTestCaseDesc	Ensure Multi-Level Resources function as expected
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+Pre-condition:
+	If in use, resource state is not equal to max level
+	If in use, resource is not Single-User
+	Resource is not Custom Sense
+For each Multi-Level resource:
+	1.	Register TOC and TAC1
+	2.	Define a number of gradually increasing (or decreasing if negative
+		sense resource) test values across the range of valid states. Attempt
+		to change the resource state to each of these values.
+	3.	De-register TOC and TAC1
+@SYMTestExpectedResults
+	1.	Clients registered
+	2.	Resource state should be changed to the test value if this value is
+		accepted by the PSL. If not, the resource state should be changed to
+		the minimum valid value that satisfies this requirement.
+	3.	Clients de-registered
+*/
+
+void CTestPrmAccTst::TestMultilevelResources(TInt aResourceNo)
+	{
+	test.Printf(_L("---Multi-level "));
+	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)
+		{
+		if (state == res.iMaxLevel)
+			{
+			test.Printf(_L("Not tested (Resource is already at maximum level)\n"));
+			return;
+			}
+		if (res.iUsage == TResInfo::ESingleUse)
+			{
+			test.Printf(_L("Not tested (Single-User resource already in use)\n"));
+			return;
+			}
+		}
+	// Define test values
+	TInt tstval[KTestMultiLevelValues];
+	TInt i;
+	for (i = 0; i < KTestMultiLevelValues; i++)
+		{
+		if (levelowner == KTestResourceNotInUse)
+			{
+			// If resource is not in use, we can use the entire state range
+			tstval[i] = res.iMinLevel + i * (res.iMaxLevel - res.iMinLevel) / (KTestMultiLevelValues - 1);
+			}
+		else
+			{
+			// Or else we are limited to the Current State-MaxLevel range
+			tstval[i] = state + i * (res.iMaxLevel - state) / (KTestMultiLevelValues - 1);
+			}
+		}
+	test_Compare(tstval[0], !=, tstval[KTestMultiLevelValues - 1]);
+	// Test starts here
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	//
+	for (i = 0; i < KTestMultiLevelValues; i++)
+		{
+		r = iTac1.ChangeResourceState(res.iResourceId, tstval[i]);
+		test_KErrNone(r);
+		r = iToc.GetResourceState(res.iResourceId, state);
+		test_KErrNone(r);
+		// Resource state should be equal to the test value
+		// or to the first valid value that satisfies the request
+		if (res.iSense == TResInfo::EPositive)
+			{
+			test_Compare(state, >=, tstval[i]);
+			}
+		else
+			{
+			test_Compare(state, <=, tstval[i]);
+			}
+		test.Printf(_L("."));
+		}
+	//
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-LATENCY-0564
+@SYMTestCaseDesc	Ensure instantaneous resource change state instantaneously
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+Pre-condition:
+	If in use, resource is not Single-User
+	If in use, resource state is not equal to max level
+	If in use, resource is not Custom Sense
+For each Multi-Level resource:
+	1.	Register TAC1
+	2.	TAC1 changes resource state to max value (async)
+	3.	Immediately afterwards, TAC1 gets resource state (sync)
+	4.	Wait for callback function
+	5.	TAC1 changes resource state to min value (async)
+	6.	Immediately afterwards, TAC1 gets resource state (sync)
+	7.	Wait for callback function
+	8.	De-register TAC1
+@SYMTestExpectedResults
+	1.	Client registered
+	2.	No error reported.
+	3.	If resource is Instantaneous Set, then the resource state is equal to
+		the new state. If Long Latency Set, then the state is either the old or
+		the new state.
+	4.	Callback function is called.
+	5.	No error reported.
+	6.	If resource is Instantaneous Set, then the resource state is equal to
+		the new state. If Long Latency Set, then the state is either the old or
+		the new state.
+	7.	Callback function is called.
+	8.	Client de-registered.
+*/
+
+void CTestPrmAccTst::TestLatency(TInt aResourceNo)
+	{
+	test.Printf(_L("---Latency "));
+	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)
+		{
+		if (state == res.iMaxLevel)
+			{
+			test.Printf(_L("Not tested (Resource is already at maximum level)\n"));
+			return;
+			}
+		if (res.iUsage == TResInfo::ESingleUse)
+			{
+			test.Printf(_L("Not tested (Single-User resource already in use)\n"));
+			return;
+			}
+		}
+	// Define the two test values
+	TInt tstval1;
+	TInt tstval2;
+	if (levelowner != KTestResourceNotInUse)
+		{
+		// Resource in use
+		tstval1 = res.iMaxLevel;
+		tstval2 = state;
+		}
+	else
+		{
+		tstval1 = res.iMaxLevel;
+		tstval2 = res.iMinLevel;
+		}
+	// Test starts here
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	//
+	TTestResourceStateBuf buf;
+	buf().iResourceId = res.iResourceId;
+	buf().iNewState = tstval1;
+	TRequestStatus rs;
+	TInt tmpstate;
+	iTac1.ChangeResourceStateAndGetState(rs, buf, tmpstate);
+	User::WaitForRequest(rs);
+	test_KErrNone(rs.Int());
+	if (res.iLatencySet == TResInfo::EInstantaneous)
+		{
+		test_Equal(tstval1, tmpstate); // Temp state is equal to the new state
+		}
+	else if (tmpstate != state) // Temp state is not necessarily equal to the new state
+		{
+		test_Equal(tstval1, tmpstate);
+		}
+	TInt newstate;
+	r = iToc.GetResourceState(res.iResourceId, newstate);
+	test_KErrNone(r);
+	test_Equal(tstval1, newstate);
+	//
+	buf().iNewState = tstval2;
+	iTac1.ChangeResourceStateAndGetState(rs, buf, tmpstate);
+	User::WaitForRequest(rs);
+	test_KErrNone(rs.Int());
+	if (res.iLatencySet == TResInfo::EInstantaneous)
+		{
+		test_Equal(tstval2, tmpstate); // Temp state is equal to the new state
+		}
+	else if (tmpstate != tstval1) // Temp state is not necessarily equal to the new state
+		{
+		test_Equal(tstval2, tmpstate);
+		}
+	r = iToc.GetResourceState(res.iResourceId, newstate);
+	test_KErrNone(r);
+	test_Equal(tstval2, newstate);
+	//
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-SENSE-0565
+@SYMTestCaseDesc	Ensure Negative and Positive Sense resources behave as
+					expected
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+Pre-condition:
+	Resource is Shared
+	If in use, resource state is not equal to max level
+For each Positive or Negative Sense resource:
+	1.	Register TOC, TAC1, TAC2 and TAC3
+	2.	Define three distincts test values, s1, s2 and s3, that correspond to
+		actual resource states in the PSL. s1 and s3 are at opposite ends of
+		the range of states the resource can be set to. s2 is an intermediate
+		state. It might not always be possible to find a distinct value for s2
+		(if the resource is binary or if its current use is limiting the number
+		of states the resource can be set to). In this case, s2 = s1.
+	3.	TAC1 sets resource state to s1
+	4.	TAC2 sets resource state to s2
+	5.	TAC3 sets resource state to s3
+	6.	De-register TAC2
+	7.	De-register TAC3
+	8.	De-register TAC1 and register TAC1, TAC2 and TAC3 again.
+	9.	TAC1 sets resource state to s1
+	10.	TAC3 sets resource state to s3
+	11.	TAC2 sets resource state to s2
+	12.	De-register TAC3.
+	13.	TAC3 sets resource state to s3
+	14.	De-register TOC, TAC1, TAC2 and TAC3
+@SYMTestExpectedResults
+	1.	Clients registered
+	2.	s1 <= s2 < s3
+	3.	Resource state set to s1
+	4.	Resource state set to s2
+	5.	Resource state set to s3
+	6.	Resource state remains unchanged (TAC3 owns level)
+	7.	Resource state returns to s1 (TAC1 now owns level)
+	8.	Clients registered
+	9.	Resource state set to s1
+	10.	Resource state set to s3
+	11.	Resource state remains unchanged (TAC3 owns level)
+	12.	Resource state changes to s2 (TAC2 now owns level)
+	13.	Resource state set to s3
+	14. Clients de-registered
+*/
+
+void CTestPrmAccTst::TestSense(TInt aResourceNo)
+	{
+	test.Printf(_L("---Sense "));
+	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);
+	// Test pre-conditions
+	if (res.iUsage != TResInfo::EShared)
+		{
+		test.Printf(_L("Not tested: Resource is Single-User\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 three test values
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	TInt tstval1;
+	TInt tstval2;
+	TInt tstval3;
+	if (levelowner == KTestResourceNotInUse)
+		{
+		tstval1 = res.iMinLevel;
+		}
+	else
+		{
+		tstval1 = state;
+		}
+	tstval3 = res.iMaxLevel;
+	// Attempt to find a distinct intermediate value by dichotomy
+	tstval2 = tstval3;
+	while ((tstval2 - tstval1 < -1) || (tstval2 - tstval1 > 1))
+		{
+		tstval2 -= (tstval2 - tstval1 + (res.iSense == TResInfo::EPositive ? 1 : 0)) / 2;
+		r = iTac1.ChangeResourceState(res.iResourceId, tstval2);
+		test_KErrNone(r);
+		r = iTac1.GetResourceState(res.iResourceId, state);
+		test_KErrNone(r);
+		}
+	if (state == tstval1 && res.iType == TResInfo::EMultiLevel)
+		{
+		test.Printf(_L("(Could not find three distincts test values)"));
+		}
+	tstval2 = state;
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	
+	// Test starts here
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac2.Open();
+	test_KErrNone(r);
+	r = iTac3.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	r = iTac2.RegisterClient(KTestTac2);
+	test_KErrNone(r);
+	r = iTac3.RegisterClient(KTestTac3);
+	test_KErrNone(r);
+
+	// Set resource state to the first test value
+	r = iTac1.ChangeResourceState(res.iResourceId, tstval1);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval1, state);
+
+	// Set resource state to middle test value
+	r = iTac2.ChangeResourceState(res.iResourceId, tstval2);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval2, state);
+
+	// Set resource to the third test value
+	r = iTac3.ChangeResourceState(res.iResourceId, tstval3);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval3, state);
+
+	// De-register second client
+	r = iTac2.DeRegisterClient();
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval3, state); // state remains  unchanged
+
+	// De-register third client
+	r = iTac3.DeRegisterClient();
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval1, state); // state changes
+
+	// De-register and register all clients again
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	r = iTac2.RegisterClient(KTestTac2);
+	test_KErrNone(r);
+	r = iTac3.RegisterClient(KTestTac3);
+	test_KErrNone(r);
+
+	// Set resource state to the first test value
+	r = iTac1.ChangeResourceState(res.iResourceId, tstval1);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval1, state);
+
+	// Set resource to the third test value
+	r = iTac3.ChangeResourceState(res.iResourceId, tstval3);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval3, state);
+
+	// Set resource state to middle test value
+	r = iTac2.ChangeResourceState(res.iResourceId, tstval2);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval3, state); // state does not change
+
+	// De-register client holding resource
+	r = iTac3.DeRegisterClient();
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval2, state);
+
+	// Register client again
+	r = iTac3.RegisterClient(KTestTac3);
+	test_KErrNone(r);
+	r = iTac3.ChangeResourceState(res.iResourceId, tstval3);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval3, state);
+
+	//
+	r = iTac3.DeRegisterClient();
+	test_KErrNone(r);
+	r = iTac2.DeRegisterClient();
+	test_KErrNone(r);
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac3.Close();
+	iTac2.Close();
+	iTac1.Close();
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-CUSTOMSENSE-0566
+@SYMTestCaseDesc	Ensure the Custom Sense function is implemented
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+For each Custom Sense resource:
+	1.	Register TAC1
+	2.	Attempt to set the state of the resource to its current state. The
+		purpose of this test action is to ensure that the PSL's custom function
+		for this resource has been implemented. If the custom function is not
+		present, the PIL will generate a panic.
+	3.	De-register TAC1
+@SYMTestExpectedResults
+	1.	Client registered
+	2.	The resource change request does not cause a panic.
+	3.	Client de-registered
+*/
+
+void CTestPrmAccTst::TestCustomSense(TInt aResourceNo)
+	{
+	test.Printf(_L("---Custom Sense"));
+	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);
+	TInt r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+	//
+	TInt state;
+	r = iTac1.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	r = iTac1.ChangeResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	//
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-POWERRESUMPTION-0567
+@SYMTestCaseDesc	Ensure resources go back to their default state when not in
+					use
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+Pre-condition:
+	Resource not in use
+	Not a Custom Sense resource
+For each resource:
+	1.	Register TAC1
+	2.	Set resource state to something that is not the default level
+	3.	De-register TAC1
+	4.	Register TOC
+	5.	Get resource state
+	6.	De-register TOC
+@SYMTestExpectedResults
+	1.	Client registered
+	2.	Resource state changed
+	3.	Client de-registered
+	4.	Client registered
+	5.	Resource state is at the default level
+	6.	Client de-registered
+*/
+
+void CTestPrmAccTst::TestDefaultPowerResumption()
+	{
+	TInt i;
+	for (i = 0; i < (TInt) iNoResources; i++)
+		{
+		TResInfo& res = *((TResInfo*) iResources.Ptr() + i);
+		test.Printf(_L("Resource %08x "), res.iResourceId);
+		TInt levelowner;
+		TInt r = iToc.GetLevelOwner(res.iResourceId, levelowner);
+		test_KErrNone(r);
+
+		// Test pre-condition: resource not in use
+		if (levelowner != KTestResourceNotInUse)
+			{
+			test.Printf(_L("Not tested (already in use)\n"));
+			continue;
+			}
+		if (res.iSense == TResInfo::ECustom)
+			{
+			test.Printf(_L("Not tested (custom sense)\n"));
+			continue;
+			}
+		
+		// Define a test value
+		TInt tstval;
+		if (res.iDefaultLevel == res.iMaxLevel)
+			{
+			tstval = res.iMinLevel;
+			}
+		else
+			{
+			tstval = res.iMaxLevel;
+			}
+		
+		// Test starts here
+		r = iTac1.Open();
+		test_KErrNone(r);
+		r = iTac1.RegisterClient(KTestTac1);
+		test_KErrNone(r);
+		// Change resource state
+		TInt state;
+		r = iToc.GetResourceState(res.iResourceId, state);
+		test_KErrNone(r);
+		test_Equal(res.iDefaultLevel, state);
+		r = iTac1.ChangeResourceState(res.iResourceId, tstval);
+		test_KErrNone(r);
+		r = iToc.GetResourceState(res.iResourceId, state);
+		test_KErrNone(r);
+		test_Equal(tstval, state);
+		// De-register active client so resource is freed
+		r = iTac1.DeRegisterClient();
+		test_KErrNone(r);
+		iTac1.Close();
+		// Read both cached and actual values
+		TInt cached;
+		r = iToc.GetResourceStateCached(res.iResourceId, cached);
+		test_KErrNone(r);
+		r = iToc.GetResourceState(res.iResourceId, state);
+		test_KErrNone(r);
+		test_Equal(cached, state);
+		test_Equal(res.iDefaultLevel, state);
+		test.Printf(_L("\n"));
+		}
+	//
+	test.Printf(_L("\n"));
+	}
+
+/* ----------------------------------------------------------------------------
+@SYMTestCaseID		PBASE-PRMACCTST-DEPENDENCIESDECLARED-0568
+@SYMTestCaseDesc	Ensure all actual resources dependencies have been declared
+@SYMREQ				REQ7751
+@SYMPREQ			PREQ1398
+@SYMTestPriority	High
+@SYMTestActions
+Pre-condition:
+	Resource not in use
+	Not a Custom Sense resource
+For each resource:
+	1.	Register TOC & TAC1
+	2.	Get state of all resources
+	3.	Set the state of the resource under test state to something that is not
+		the default level
+	4.	Get state of all resource
+	5.	De-register TAC1 & TOC
+@SYMTestExpectedResults
+	1.	Clients registered
+	2.	None
+	3.	Resource state changed
+	4.	Only resources with a direct or indirect dependency on the resource
+		under test have changed.
+	5.	Client de-registered
+*/
+
+TBool CTestPrmAccTst::ResourceInterdependency(TInt aResourceIdOrig, TInt aCurrentResourceId, TInt aResourceIdTarget)
+	{
+	// Get Reference on current resource node
+	TBool r = EFalse;
+	if (aCurrentResourceId & KTestIdHasDependencies)
+		{
+		// Get dependencies of current resources
+		RBuf8 deplist;
+		deplist.Create(sizeof(SResDepInfo) * KTestMaxDependencies);
+		r = iToc.GetResourceDependencies(aCurrentResourceId, deplist);
+		if (r)
+			{
+			test.Printf(_L("ERROR: aCurrentResourceId==%08x"), aCurrentResourceId);
+			test_KErrNone(r);
+			}
+		TInt i;
+		SResDepInfo *ptr = (SResDepInfo*)deplist.Ptr();
+		for (i = 0; i < (TInt) (deplist.Length() / sizeof(SResDepInfo)); i++, ptr++)
+			{
+			TInt depid = ptr->iResourceId;
+			if (depid == aResourceIdTarget)
+				{
+				// We've got a match
+				r = ETrue;
+				}
+			else if (depid == aResourceIdOrig)
+				{
+				// No going back to parent node
+				continue;
+				}
+			else
+				{
+				// Recurse down the tree
+				r = ResourceInterdependency(aCurrentResourceId, depid, aResourceIdTarget);
+				}
+			if (r)
+				{
+				break;
+				}
+			}
+		deplist.Close();
+		}
+	return r;
+	}
+
+void CTestPrmAccTst::TestDependenciesAreDeclared(TInt aResourceNo)
+	{
+	test.Printf(_L("---Test all dependencies are declared\n"));
+	TResInfo& res = *((TResInfo*) iResources.Ptr() + aResourceNo);
+	//
+	TInt levelowner;
+	TInt r = iToc.GetLevelOwner(res.iResourceId, levelowner);
+	test_KErrNone(r);
+	// Test pre-condition: resource not in use
+	if (levelowner != KTestResourceNotInUse)
+		{
+		test.Printf(_L("Not tested (already in use)\n"));
+		return;
+		}
+	if (res.iSense == TResInfo::ECustom)
+		{
+		test.Printf(_L("Not tested (custom sense)\n"));
+		return;
+		}
+	// Define a test value
+	TInt tstval;
+	if (res.iDefaultLevel == res.iMaxLevel)
+		{
+		tstval = res.iMinLevel;
+		}
+	else
+		{
+		tstval = res.iMaxLevel;
+		}
+
+	// Test starts here
+	// Save current state of all resources;
+	RArray<TInt> oldstate;
+	TInt i;
+	TInt state;
+	for (i = 0; i < (TInt) iNoResources; i++)
+		{
+		TResInfo& tmpres = *((TResInfo*) iResources.Ptr() + i);
+		r = iToc.GetResourceState(tmpres.iResourceId, state);
+		test_KErrNone(r);
+		r = oldstate.Append(state);
+		test_KErrNone(r);
+		}
+	//
+	r = iTac1.Open();
+	test_KErrNone(r);
+	r = iTac1.RegisterClient(KTestTac1);
+	test_KErrNone(r);
+
+	// Change resource state
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(res.iDefaultLevel, state);
+	r = iTac1.ChangeResourceState(res.iResourceId, tstval);
+	test_KErrNone(r);
+	r = iToc.GetResourceState(res.iResourceId, state);
+	test_KErrNone(r);
+	test_Equal(tstval, state);
+
+	// Now we check that resources with no dependency on resource under test
+	// have not changed
+	for (i = 0; i < (TInt) iNoResources; i++)
+		{
+		test.Printf(_L("."));
+		if (i == aResourceNo)
+			{
+			continue;
+			}
+		TResInfo& tmpres = *((TResInfo*) iResources.Ptr() + i);
+		r = iToc.GetResourceState(tmpres.iResourceId, state);
+		test_KErrNone(r);
+		if (!ResourceInterdependency(0, res.iResourceId, tmpres.iResourceId) &&
+			(state != oldstate[i]))
+			{
+			test.Printf(_L("Resource %08x has changed!\n"), tmpres.iResourceId);
+			test_Equal(state, oldstate[i]);
+			}	
+		}
+	test.Printf(_L("\n"));
+
+	// De-register active client
+	r = iTac1.DeRegisterClient();
+	test_KErrNone(r);
+	iTac1.Close();
+	//
+	oldstate.Close();
+	}
+
+TInt CTestPrmAccTst::DoTestPreamble()
+	{
+	test.Title();
+	test.Start(_L("Preamble"));
+
+	// Load Device Driver
+	TInt r;
+#ifdef RESOURCE_MANAGER_SIMULATED_PSL
+	test.Printf(_L("Load Simulated PSL PDD\n"));
+	r = User::LoadPhysicalDevice(_L("RESOURCECONTROLLEREXTENDED.PDD"));
+	if (r == KErrNotFound)
+		{
+		test.Printf(_L("RESOURCECONTROLLEREXTENDED.PDD not found\nTest skipped\n"));
+		return r;
+		}
+	if (r)
+		{
+		test_Equal(KErrAlreadyExists, r);
+		test.Printf(_L("Already loaded\n"));
+		}
+	test.Printf(_L("Load test LDD\n"));
+	r = User::LoadLogicalDevice(_L("D_PRMACCTSTSIM.LDD"));
+	if (r)
+		{
+		test_Equal(KErrAlreadyExists, r);
+		test.Printf(_L("Already loaded\n"));
+		}
+#else
+	test.Printf(_L("Load test LDD\n"));
+	r = User::LoadLogicalDevice(_L("D_PRMACCTST.LDD"));
+	if (r)
+		{
+		test_Equal(KErrAlreadyExists, r);
+		test.Printf(_L("Already loaded\n"));
+		}
+#endif // RESOURCE_MANAGER_SIMULATED_PSL
+
+	// Check if Device Driver was loaded as a Kernel Extension
+	iKextc.Open();
+	TUint clientId;
+	r = iKextc.GetKernelExtClientId(clientId);
+	test_KErrNone(r);
+	if (!clientId)
+		{
+		test.Printf(_L("No Kernel extension PRM client\n"));
+		iKextc.Close();
+		}
+	else
+		{
+		// De-register client so Single User resources can be tested
+		r = iKextc.OpenClient(clientId);
+		test_KErrNone(r);
+		r = iKextc.DeRegisterClient();
+		test_KErrNone(r);
+		iKextc.Close();
+		}
+
+	// Register TOC (always on - de-registered in test postamble)
+	r = iToc.Open();
+	test_KErrNone(r);
+	r = iToc.RegisterClient(KTestToc);
+	test_KErrNone(r);
+
+	// Get resources info
+	r = iToc.GetTotalNumberOfResources(iNoResources);
+	test_KErrNone(r);
+	test.Printf(_L("Resources found: %d\n"), iNoResources);
+	if (iNoResources > 0)
+		{
+		r = iResources.Create(iNoResources * sizeof(TResInfo));
+		test_KErrNone(r);
+		test.Printf(_L("Retrieving information on resources\n"));
+		r = iToc.GetInfoOnResourcesInUseByClient(0, iResources);
+		test_KErrNone(r);
+		iIsPrmSupported = ETrue;
+		}
+	else
+		{
+		test.Printf(_L("No resource found.\n"));
+		}
+	return KErrNone;
+	}
+
+void CTestPrmAccTst::DoTest()
+	{
+	if (!iIsPrmSupported)
+		{
+		return;
+		}
+	//
+	test.Next(_L("Enumerate Resources"));
+	TestEnumerateResources();
+	//
+	TInt i;
+	test.Next(_L("Resource Properties"));
+	for (i = 0; i < (TInt) iNoResources; i++)
+		{
+		TResInfo& res = *((TResInfo*) iResources.Ptr() + i);
+		test.Printf(_L("+++Resource %08x\n"), res.iResourceId);
+		//
+		if (res.iUsage == TResInfo::ESingleUse)
+			{
+			TestSingleUserResources(i);
+			}
+		else if (res.iUsage == TResInfo::EShared)
+			{
+			TestSharedResources(i);
+			}
+		//
+		if (res.iType == TResInfo::EBinary)
+			{
+			TestBinaryResources(i);
+			}
+		else if (res.iType == TResInfo::EMultiLevel)
+			{
+			TestMultilevelResources(i);
+			}
+		//
+		TestLatency(i);
+		//
+		if ((res.iSense == TResInfo::EPositive) || (res.iSense == TResInfo::ENegative))
+			{
+			TestSense(i);
+			}
+		else if (res.iSense == TResInfo::ECustom)
+			{
+			TestCustomSense(i);
+			}
+		}
+	//
+	test.Next(_L("Default Power Resumption"));
+	TestDefaultPowerResumption();
+	//
+	test.Next(_L("PRM Extension - Dependencies"));
+	for (i = 0; i < (TInt) iNoResources; i++)
+		{
+		TResInfo& res = *((TResInfo*) iResources.Ptr() + i);
+		if (res.iResourceId & KTestIdHasDependencies)
+			{
+			test.Printf(_L("+++Resource %08x\n"), res.iResourceId);
+			TestDependenciesAreDeclared(i);
+			}
+		}
+	}
+
+void CTestPrmAccTst::DoTestPostamble()
+	{
+	test.Next(_L("Postamble"));
+	if (iToc.Handle())
+		{
+		TInt r = iToc.DeRegisterClient();
+		test_KErrNone(r);
+		iToc.Close();
+		}
+	test.End();
+	test.Close();
+	}
+
+GLDEF_C TInt MainL()
+	{
+	CTestPrmAccTst* testapp;
+	testapp = new (ELeave) CTestPrmAccTst();
+	CleanupStack::PushL(testapp);
+	if (testapp->DoTestPreamble() == KErrNone)
+		{
+		testapp->DoTest();
+		}
+	testapp->DoTestPostamble();
+	CleanupStack::PopAndDestroy(testapp);
+	return KErrNone;
+	}
+
+GLDEF_C TInt E32Main()
+	{
+	__UHEAP_MARK;
+	CTrapCleanup* cleanup = CTrapCleanup::New();
+	if(cleanup == NULL)
+		{
+		return KErrNoMemory;
+		}
+	TRAP_IGNORE(MainL());
+	delete cleanup;
+	__UHEAP_MARKEND;
+	return KErrNone;
+	}