--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/resourceman/acctst/t_prmacctst.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -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;
+ }