diff -r 000000000000 -r a41df078684a kerneltest/e32test/resourceman/t_rescontrolcli.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/kerneltest/e32test/resourceman/t_rescontrolcli.cpp Mon Oct 19 15:55:17 2009 +0100 @@ -0,0 +1,4287 @@ +// 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: +// e32test\resourceman\t_rescontrolcli.cpp +// TestCase Description: +// This tests is intended to test the generic layer of PRM. It consists of unit testing and regression testing. +// Unit testing validates each of the API's. Regression testing performs random operation on random resource and +// currently executes 500 operations and returns. +// To run regression testing, test must be invoked with -R option. +// Testing runs only on simulated PSL. +// +// + +#include +#include +#include +#include +#include +#include "d_rescontrolcli.h" + +#define MAX_STATIC_RESOURCE_NUM 24 //Maximum number of static resources in simulated PSL +#define MAX_STATIC_DEPENDENCY_RESOURCE_NUM 7 //Maximum number of static dependency resources in simulated PSL +#define DEPENDENCY_RESOURCE_BIT_MASK 0x00010000 +#define DYNAMIC_RESOURCE_BIT_MASK 0x00020000 +#define CUSTOM_RESOURCE_NUMBER 20 + +/** Macro to push the item into the specified list. Item are pushed to the head of the list. */ +#define LIST_PUSH(list,item,link) \ + { \ + (item)->link = (list); \ + (list) = (item); \ + } + +/** Macro to pop the item from the specified list. Item are poped from the head of the list. */ +#define LIST_POP(list,item,link) \ + { \ + (item) = (list); \ + if ((item)) \ + { \ + (list) = (item)->link; \ + (item)->link = NULL; \ + } \ + } + +/** Macro to remove the item from the list. */ +#define LIST_REMOVE(list,item,link,className) \ + if (list) \ + { \ + className* current = (list); \ + if (current==(item)) \ + { \ + (list) = (item)->link; \ + (item)->link = NULL; \ + } \ + else \ + { \ + className* next = current->link; \ + while (next) \ + { \ + if ((item)==next) \ + { \ + current->link=next->link; \ + next->link = NULL; \ + break; \ + } \ + current = next; \ + next = next->link; \ + } \ + } \ + } + +#ifndef PRM_ENABLE_EXTENDED_VERSION +_LIT(KLddFileName, "D_RESCONTROLCLI.LDD"); +_LIT(KPddFileName, "resourcecontroller.pdd"); +#else +_LIT(KExtLddFileName, "D_EXTENDEDRESCONTROLCLI.LDD"); +_LIT(KExtPddFileName, "resourcecontrollerextended.pdd"); +#endif + +LOCAL_D RTest test(_L("RESOURCE_MANAGER_TEST")); +TBuf8<32> SpecialResName(_L8("SymbianSimulResource")); + +//Enum definition for resource classification. +enum TType {EMultiLevel = 0x1, EMultiProperty}; +enum TUsage {ESingle, EShared}; +enum TLatency {EInstantaneous, ELongLatency}; +enum TClass {EPhysical, ELogical}; +enum TSense {EPositive, ENegative, ECustom}; + +//Structure to get resource information +class TPowerResourceInfoV01 + { +public: + TClass iClass; + TLatency iLatencyGet; + TLatency iLatencySet; + TType iType; + TUsage iUsage; + TSense iSense; + TDesC8* iResourceName; + TUint iResourceId; + TInt iDefaultLevel; + TInt iMinLevel; + TInt iMaxLevel; + TInt iReserved1; + TInt iReserved2; + TInt iReserved3; + TInt iPslReserved1; + TInt iPslReserved2; + TInt iPslReserved3; + }; + +//Structure to get client information +struct TPowerClientInfoV01 + { + TUint iClientId; + TDesC8* iClientName; + }; + +//Structure for holding client information +struct RMClientInfo + { + TUint iClientId; + TUint iNumResources; + TUint iResourceIds[MAX_STATIC_RESOURCE_NUM]; //Each bit corresponds to a static resource. + }; + +//Structure for holding notification information +struct NotiInfo + { + TUint iClientId; + TInt iThreshold; + TInt iDirection; + TInt iPreviousLevel; + NotiInfo *iNext; + }; + +// Structure for holding client level +struct SPowerResourceClientLevel + { + TUint iClientId; + TUint iResourceId; + TInt iLevel; + SPowerResourceClientLevel* iNextInList; + }; + +//Structure for capturing resource information to be used by Idle thread. +struct SIdleResourceInfo + { + TUint iResourceId; + TInt iLevelOwnerId; + TInt iCurrentLevel; + TInt iReserved1; //Reserved for future use. + TInt iReserved2; //Reserved for future use. + TInt iReserved3; //Reserved for future use. + }; + +//Structure for holding resource information +struct RMResInfo + { + TBuf8<32> iName; + TUint iResourceId; + TInt iMaxLevel; + TInt iMinLevel; + TInt iDefaultLevel; + TInt iCurrentLevel; + TInt iCurrentClient; + TUint iNumClients; + TSense iSense; + TType iType; + TLatency iLatencyGet; + TLatency iLatencySet; + TUsage iUsage; + TUint iUnCondNotiCount; + NotiInfo *iCondNoti; + NotiInfo *iUncondNoti; + SPowerResourceClientLevel *iLevel; + }; + +//Test class. +class TestRM + { +private: + //Possible resource operation. + enum Operation + { + ERegisterClient = 0, + EGetClientName = 1, + EGetAllClientName = 2, + EGetClientId = 3, + EGetResourceId = 4, + EGetResourceInfo = 5, + EGetNumReosourceInUseByClient = 6, + EGetInfoOnResourceInUseByClient = 7, + EGetNumClientsUsingResource = 8, + EGetInfoOnClientsUsingResource = 9, + EChangeResourceStateSync = 10, + EChangeResourceStateAsync = 11, + EGetResourceStateSync = 12, + EGetResourceStateAsync = 13, + ERequestNotificationCond = 14, + ERequestNotificationUnCond = 15, + ECancelNotificationCond = 16, + ECancelNotificationUnCond = 17, + EOperationEnd = 18 + }; +public: + TestRM(); + void RegisterClient(); + void DeRegisterClient(TUint aClientId); + void GetClientName(TUint aClientId); + void GetClientId(TUint aClientId); + void GetResourceId(TUint aResId); + void GetResourceInfo(TUint aResId); + void GetNumResourcesInUseByClient(TInt aClientId); + void GetInfoOnResourcesInUseByClient(TInt aClientId, TUint aNumRes); + void GetNumClientsUsingResource(TUint aClientId, TUint aResId); + void GetInfoOnClientsUsingResource(TUint aResId, TUint aNumCli); + void AllocReserve(TUint aClientId); + void CheckNotification(TUint aResId, TInt newState); + void AddClientLevel(TUint aResId, TInt newState); + void UpdateClientInformation(TUint aResId, TInt aNewState); + void ChangeResourceStateSync(TUint aResId); + void ChangeResourceStateAsync(TUint aResId, TBool aReqCancel=EFalse); + void GetResourceStateSync(TUint aResId); + void GetResourceStateAsync(TUint aResId, TBool aReqCancel=EFalse); + void RequestNotification(TUint aResId); + void RequestNotificationCon(TUint aResId); + void ValidateClient(TUint aNumClients, TOwnerType aContext); + void CancelNotification(TUint aResId, TBool Cond); + void APIValidationTest(); + void SharedBinaryPositiveResourceTesting(TUint aResId); + void SharedBinaryNegativeResourceTesting(TUint aResId); + void CustomResourceTesting(TUint aResId); + void DeRegisterClientLevelFromResource(TInt aClientId, TUint aResId); + void RegressionTest(); + void TestStaticResourceWithDependency(); + void GetExtendedResStateAsyncAndVerify(TUint aResId, TInt aState, TInt aLevelOwnerId, TBool aReqCancel = EFalse); + void GetExtendedResStateAndVerify(TUint aResId, TInt aState, TInt aLevelOwnerId); + void TestDynamicResource(); + void TestDynamicResourceDependency(); + void CheckForDependencyInformation(TUint aClientId, TUint aResourceId, TUint aNumDependents, SResourceDependencyInfo* aDepResIdArray); + void SharedMultilevelNegativeResourceTesting(TUint aResId); + void SharedMultilevelPositiveResourceTesting(TUint aResId); +private: + RArray Clients; + RMResInfo Resources[MAX_STATIC_RESOURCE_NUM]; + TUint iStaticDependencyResources[MAX_STATIC_DEPENDENCY_RESOURCE_NUM]; + TInt iCurrentClientId; + TUint iMaxClientId; + TUint iMaxClients; + TUint iMaxStaticResources; + TUint iMaxStaticDependentResources; + TUint iPowerControllerId; + TUint iTestingExtendedVersion; + }; + +TBool NegativeTesting; //If true enables negative testing of API's +TInt r = KErrNone; +TBuf8<32> ClientName(_L8("Client?")); +RTestResMan lddChan; +TestRM RmTest; + +//Class constructor +TestRM::TestRM(): iCurrentClientId(-1),iMaxClientId(0), iMaxClients(0),iMaxStaticResources(0), iMaxStaticDependentResources(0), iTestingExtendedVersion(0) + { + test.Printf(_L("TestRM::TestRM()\n")); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0573 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the client registeration functionality of resource +//! manager.It registeres a client with resource manager and stores the relevant +//! information in Clients array. Currently allows only maximum of 50 client +//! registration. +//! @SYMTestActions 0 Returns if already maximum allowable clients are registered. +//! 1 Register a client with the resource manager with a unique name. +//! 2 Appends the client information to an array for futher reference. +//! +//! @SYMTestExpectedResults client registration is successful, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::RegisterClient() + { + TUint clientId = 0; + RMClientInfo info; + if(iMaxClientId > MAX_CLIENTS) + { + test.Printf(_L("Reached maximum client allocation. Can't allocate more\n")); + return; + } + ClientName[6] = (TUint8)('0' + iMaxClientId); + r = lddChan.RegisterClient(clientId, (const TDesC*)&ClientName); + if(r != KErrNone) + test.Printf(_L("Register Client failed with %d\n"), r); + test(r == KErrNone); + info.iClientId = clientId; + info.iNumResources = 0; + for(TUint c = 0; c< MAX_STATIC_RESOURCE_NUM; c++) + info.iResourceIds[c] = 0; + iMaxClientId++; + iMaxClients++; + r = Clients.Append(info); + if(r != KErrNone) + test.Printf(_L("Client Append failed with %d\n"), r); + test(r == KErrNone); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0574 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the client deregisteration functionality of resource +//! manager.It deregisteres a client with the resource manager, calculates +//! the resource level of each resource that the client was having requirement and +//! checks the resource level change after client deregistration. +//! @SYMTestActions 0 Deregister a client from resource manager +//! 1 Calculates the resource level of each resource the client was having requirement. +//! 2 Checks the resource level change of each resource for correctness. +//! 3 Zeros the clientId stored internally to make sure it is not referenced again. +//! +//! @SYMTestExpectedResults client deregistration is successful and also the resource level of +//! each resource the client was holding the resource level is checked +//! for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::DeRegisterClient(TUint aClientId) + { + r = lddChan.DeRegisterClient(Clients[aClientId].iClientId); + if(r != KErrNone) + test.Printf(_L("Client deregistration of %d failed with %d\n"), Clients[aClientId].iClientId, r); + test(r == KErrNone); + TUint count; + for(count = 0; count < iMaxStaticResources; count++) + { + RMResInfo *pR = &Resources[count]; + NotiInfo* pI = pR->iCondNoti; + NotiInfo* ptr = NULL; + //Remove any conditional notification that this client has on resource. + while(pI != NULL) + { + if(pI->iClientId == aClientId) + { + ptr = pI; + pI = pI->iNext; + LIST_REMOVE(pR->iCondNoti, ptr, iNext, NotiInfo); + delete ptr; + } + else + pI = pI->iNext; + } + + //Remove any unconditional notification that this client has on resource. + pI = pR->iUncondNoti; + ptr = NULL; + while(pI != NULL) + { + if(pI->iClientId == aClientId) + { + ptr = pI; + pI = pI->iNext; + LIST_REMOVE(pR->iUncondNoti, ptr, iNext, NotiInfo); + delete ptr; + } + else + pI = pI->iNext; + } + } + //Remove client level + TUint res = 0; + for(count = 0; count < Clients[aClientId].iNumResources; count++) + { + res = Clients[aClientId].iResourceIds[count]; + if(res == 0) + continue; + for(TUint c = 0; c< iMaxStaticResources; c++) + { + if(Resources[c].iResourceId == res) + { + res = c; + break; + } + } + if(Resources[res].iCurrentClient == (TInt)aClientId) + { + if(!Resources[res].iUsage) + { + Resources[res].iCurrentLevel = Resources[res].iDefaultLevel; + Resources[res].iCurrentClient = -1; + Resources[res].iNumClients = 0; + } + else if(Resources[res].iSense == ECustom) + continue; + else + { + TInt maxLevel = KMinTInt; + TInt id = -1; + for(SPowerResourceClientLevel* pCL = Resources[res].iLevel; pCL != NULL; pCL = pCL->iNextInList) + { + if(pCL->iClientId == aClientId) + continue; + if((maxLevel == KMinTInt) || (maxLevel == pCL->iLevel)) + { + maxLevel = pCL->iLevel; + id = pCL->iClientId; + continue; + } + if(Resources[res].iSense == EPositive && pCL->iLevel > maxLevel) + { + maxLevel = pCL->iLevel; + id = pCL->iClientId; + } + else if(Resources[res].iSense == ENegative && pCL->iLevel < maxLevel) + { + maxLevel = pCL->iLevel; + id = pCL->iClientId; + } + } + if(id == -1) + { + Resources[res].iCurrentLevel = Resources[res].iDefaultLevel; + Resources[res].iCurrentClient = -1; + Resources[res].iNumClients = 0; + } + else + { + Resources[res].iCurrentLevel = maxLevel; + Resources[res].iCurrentClient = id; + Resources[res].iNumClients--; + } + } + } + //Remove client list entry from resource + for(SPowerResourceClientLevel* pCL = Resources[res].iLevel; pCL != NULL; pCL = pCL->iNextInList) + { + if(pCL->iClientId == aClientId) + { + LIST_REMOVE(Resources[res].iLevel, pCL, iNextInList, SPowerResourceClientLevel); + delete pCL; + break; + } + } + } + //Verify the resource state consistency + res = 0; + TInt newState; + TInt levelOwnerId; + if(iMaxClients > 1) + { + for(TUint id = 0; id < Clients[aClientId].iNumResources; id++) + { + res = Clients[aClientId].iResourceIds[id]; + if(res == 0) + continue; + for(TUint c = 0; c< iMaxStaticResources; c++) + { + if(Resources[c].iResourceId == res) + { + res = c; + break; + } + } + r = lddChan.GetResourceStateSync(Clients[0].iClientId, Resources[res].iResourceId, ETrue, newState, levelOwnerId); + if(r != KErrNone) + test.Printf(_L("GetResourceStateSync returned with %d"), r); + test(r == KErrNone); + if(newState != Resources[res].iCurrentLevel) + test.Printf(_L("newState = %d, Resources[%d].iCurrentLevel = %d"), newState, Resources[res].iResourceId, Resources[res].iCurrentLevel); + test(newState == Resources[res].iCurrentLevel); + if(Resources[res].iCurrentClient == -1) + test(levelOwnerId == -1); + else if (levelOwnerId != (TInt)Clients[Resources[res].iCurrentClient].iClientId) + { + test.Printf(_L("levelOwnerId = 0x%x, iCurrentClient = 0x%x\n"), levelOwnerId, Resources[res].iCurrentClient); + test(0); + } + } + } + Clients[aClientId].iClientId = 0; + iMaxClients--; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0575 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the retrieval of client name functionality of resource +//! manager and compares for correctness. There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid target client Id. +//! 3 Call the API with invalid instance count of target client Id. +//! Positive tests +//! 4 Call the API with valid client Ids (both calling and target client ID) +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return with KErrNotFound, panics otherwise +//! 4 API should return KErrNone with name updated and also name +//! is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetClientName(TUint aClientId) + { + ClientName[6] = (TUint8)('0' + aClientId); + TBuf8<32> name; + if(NegativeTesting) + { + //Pass illegal client Id + r = lddChan.GetClientName(0, Clients[aClientId].iClientId, (TDes8*)&name); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (3<<16); + r = lddChan.GetClientName(id, Clients[aClientId].iClientId, (TDes8*)&name); + test(r == KErrAccessDenied); + + //Pass illegal target client id + r = lddChan.GetClientName(Clients[aClientId].iClientId, iMaxClients, (TDes8*)&name); + test(r == KErrNotFound); + + //Pass illegal instance count of target client id + id = id ^ (1<<16); + r = lddChan.GetClientName(Clients[aClientId].iClientId, 0 ,(TDes8*)&name); + test(r == KErrNotFound); + } + r = lddChan.GetClientName(Clients[aClientId].iClientId, Clients[aClientId].iClientId, (TDes8*)&name); + if(r != KErrNone) + test.Printf(_L("GetClientName of ClientId 0x%x returned with %d"), Clients[aClientId].iClientId, r); + test(r == KErrNone); + if(name.Compare(ClientName)) + test(0); + } + + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0576 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the retrieval of client ID functionality of resource +//! manager and compares for correctness. There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with client name greater than maximum allowable +//! client name (32 characters). +//! 3 Call the API with name not registered with resource manager +//! (non-existing name). +//! Positive tests +//! 4 Call the API with valid client Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrTooBig, panics otherwise +//! 3 API should return with KErrNotFound, panics otherwise +//! 4 API should return KErrNone with client Id updated and also Id +//! is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetClientId(TUint aClientId) + { + TUint clientId; + ClientName[6] = (TUint8)('0' + aClientId); + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetClientId(0, (TDesC8&)ClientName, Clients[aClientId].iClientId); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (3<<16); + r = lddChan.GetClientId(id, (TDesC8&)ClientName, Clients[aClientId].iClientId); + test(r == KErrAccessDenied); + + TBuf8<50> badName = _L8("Clientnamegreaterthan32characters"); + r = lddChan.GetClientId(Clients[aClientId].iClientId, (TDesC8&)badName, clientId); + test(r == KErrTooBig); + + ClientName[6] = (TUint8)('0' + iMaxClients + 1); + r = lddChan.GetClientId(Clients[aClientId].iClientId, (TDesC8&)ClientName, clientId); + test(r == KErrNotFound); + } + ClientName[6] = (TUint8)('0' + aClientId); + r = lddChan.GetClientId(Clients[aClientId].iClientId, (TDesC8&)ClientName, clientId); + if(r != KErrNone) + test.Printf(_L("GetClientId returned with %d"), r); + test(r == KErrNone); + if(clientId != Clients[aClientId].iClientId) + test.Printf(_L("ClientId = 0x%x, Expected ClientId = 0x%x"), clientId, Clients[aClientId].iClientId); + test(clientId == Clients[aClientId].iClientId); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0577 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the retrieval of resource ID functionality of resource +//! manager and compares for correctness. There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with resource name greater than maximum allowable +//! resource name (32 characters). +//! 3 Call the API with name not registered with resource manager +//! (non-existing name). +//! Positive tests +//! 4 Call the API with valid client Id and resource name. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrTooBig, panics otherwise +//! 3 API should return with KErrNotFound, panics otherwise +//! 4 API should return KErrNone with resource Id updated and also Id +//! is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetResourceId(TUint aResId) + { + TUint resId; + if(NegativeTesting) + { + r = lddChan.GetResourceId(iMaxClients, Resources[aResId].iName, resId); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (3<<17); + r = lddChan.GetResourceId(id, (TDesC8&)Resources[aResId].iName, resId); + test(r == KErrAccessDenied); + + TBuf8<50> badName = _L8("Resourcenamegreaterthen32characters"); + r = lddChan.GetResourceId(Clients[iCurrentClientId].iClientId, (TDesC8&)badName, resId); + test(r == KErrTooBig); + badName = Resources[aResId].iName; + badName[0] = '0' + 1; + r = lddChan.GetResourceId(Clients[iCurrentClientId].iClientId, (TDesC8&)badName, resId); + test(r == KErrNotFound); + } + r = lddChan.GetResourceId(Clients[iCurrentClientId].iClientId, (TDesC8&)Resources[aResId].iName, resId); + if(r != KErrNone) + test.Printf(_L("Return value of GetResourceId %d"), r); + test(r == KErrNone); + if(resId != Resources[aResId].iResourceId) + test.Printf(_L("resId = %d ... aResId = %d"), resId, Resources[aResId].iResourceId); + test(resId == Resources[aResId].iResourceId); + } + + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0578 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests the retrieval of resource information of a specified +//! resource functionality of resource manager and compares each info for correctness. +//! There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid resource id. +//! Positive tests +//! 3 Call the API with valid client Id and resource id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return KErrNone with resource information updated and also +//! each information is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetResourceInfo(TUint aResId) + { + RBuf8 infoBuf; + infoBuf.Create(sizeof(TPowerResourceInfoV01)); + if(NegativeTesting) + { + r = lddChan.GetResourceInfo(iMaxClients-5, aResId+1, (TAny*)(TDes8*)&infoBuf); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (5<<17); + r = lddChan.GetResourceInfo(id, aResId+1, (TAny*)infoBuf.Ptr()); + test(r == KErrAccessDenied); + + r = lddChan.GetResourceInfo(Clients[iCurrentClientId].iClientId, iMaxStaticResources + 30, (TAny*)(TDes8*)&infoBuf); + test(r == KErrNotFound); + r = lddChan.GetResourceInfo(Clients[iCurrentClientId].iClientId, 26, (TAny*)(TDes8*)&infoBuf); + test(r == KErrNotFound); + } + r = lddChan.GetResourceInfo(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, (TAny*)(TDes8*)&infoBuf); + if(r != KErrNone) + test.Printf(_L("GetResourceInfo returned with %d"), r); + test(r == KErrNone); + TPowerResourceInfoV01 *ptr = (TPowerResourceInfoV01*)infoBuf.Ptr(); + //Compare results. + test(ptr->iResourceId == Resources[aResId].iResourceId); + test(ptr->iLatencyGet == Resources[aResId].iLatencyGet); + test(ptr->iLatencySet == Resources[aResId].iLatencySet); + test(ptr->iType == Resources[aResId].iType); + test(ptr->iUsage == Resources[aResId].iUsage); + test(ptr->iSense == Resources[aResId].iSense); + test(ptr->iMaxLevel == Resources[aResId].iMaxLevel); + test(ptr->iMinLevel == Resources[aResId].iMinLevel); + test(ptr->iDefaultLevel == Resources[aResId].iDefaultLevel); + if(ptr->iUsage == ESingle && Resources[aResId].iNumClients >1) //Single user resource cannot have more than 1 client. + test(0); + infoBuf.Close(); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0579 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests retrieval of number of resources the requested client has +//! requirement functionality of resource manager and compares with stored information +//! for correctness.There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid target client Id. +//! 3 Call the API with invalid instance count of target client Id. +//! Positive tests +//! 4 Call the API with valid calling and target client Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return with KErrNotFound, panics otherwise +//! 4 API should return KErrNone with number of resources the requested client has +//! requirement updated and also is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetNumResourcesInUseByClient(TInt aClientId) + { + TUint numRes; + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetNumResourcesInUseByClient(23, Clients[aClientId].iClientId, numRes); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.GetNumResourcesInUseByClient(id, Clients[aClientId].iClientId, numRes); + test(r == KErrAccessDenied); + + //Pass illegal target client id + r = lddChan.GetNumResourcesInUseByClient(Clients[aClientId].iClientId, iMaxClients, numRes); + test(r == KErrNotFound); + + //Pass illegal instance count of target client id + id = id ^ (3<<16); + r = lddChan.GetNumResourcesInUseByClient(Clients[aClientId].iClientId, id ,numRes); + test(r == KErrNotFound); + } + + if(aClientId == -1) + { + r = lddChan.GetNumResourcesInUseByClient(Clients[0].iClientId, 0, numRes); + if(r != KErrNone) + test.Printf(_L("GetNumResourcesInUseByClient returned with %d"), r); + test(r == KErrNone); + if((!iTestingExtendedVersion) && (numRes > MAX_STATIC_RESOURCE_NUM)) + test(0); + if(iMaxStaticResources == 0) + iMaxStaticResources = numRes; + else + test(numRes == (iMaxStaticResources + iMaxStaticDependentResources)); + } + else + { + r = lddChan.GetNumResourcesInUseByClient(Clients[aClientId].iClientId, Clients[aClientId].iClientId, numRes); + if(r != KErrNone) + test.Printf(_L("GetNumResourceInUseByClient returned with %d"), r); + test(r == KErrNone); + if(numRes != Clients[aClientId].iNumResources) + test.Printf(_L("numRes = %d, iNumResources = %d"), numRes, Clients[aClientId].iNumResources); + test(numRes == Clients[aClientId].iNumResources); + } + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0580 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests retrieval of information about resources the requested client has +//! requirement functionality of resource manager and compares with stored information +//! for correctness.There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid target client Id. +//! 3 Call the API with invalid instance count of target client Id. +//! 4 Call the API with null buffer (buffer where the resource information will be updated). +//! 5 Call the API with the number of resource information to be updated as 0 (specifies the +//! size of the buffer). +//! Positive tests +//! 6 Call the API with valid calling and target client Id, buffer and its size. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return with KErrNotFound, panics otherwise +//! 4 API should return with KErrArgument, panics otherwise +//! 5 API should return with KErrArgument, panics otherwise +//! 6 API should return KErrNone with resource information about resources the requested +//! client has requirement updated and also is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetInfoOnResourcesInUseByClient(TInt aClientId, TUint aNumRes) + { + RBuf8 info; + info.Create(aNumRes * sizeof(TPowerResourceInfoV01)); + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetInfoOnResourcesInUseByClient(32, Clients[aClientId].iClientId, aNumRes, (TAny*)(TDes8*)&info); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.GetInfoOnResourcesInUseByClient(id, Clients[aClientId].iClientId, aNumRes, (TAny*)(TDes8*)&info); + test(r == KErrAccessDenied); + + //Pass illegal target client id + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[aClientId].iClientId, iMaxClients, aNumRes, (TAny*)(TDes8*)&info); + test(r == KErrNotFound); + + //Pass illegal instance count of target client id + id = id ^ (3<<16); + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[aClientId].iClientId, id ,aNumRes,(TAny*)(TDes8*)&info); + test(r == KErrNotFound); + + //Pass null buffer + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[aClientId].iClientId, Clients[aClientId].iClientId ,aNumRes, (TAny*)NULL); + test(r == KErrArgument); + + //Pass required resources as 0 + TUint tempRes = 0; + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[aClientId].iClientId, Clients[aClientId].iClientId, tempRes, (TAny*)(TDes8*)&info); + test(r == KErrArgument); + } + + if(aClientId == -1) + { + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[0].iClientId, 0, aNumRes, (TAny*)(TDes8*)&info); + if(r != KErrNone) + test.Printf(_L("GetInfoOnResourceInUseByClient returned with %d"), r); + test(r == KErrNone); + if(aNumRes != (iMaxStaticResources + iMaxStaticDependentResources)) + test.Printf(_L("aNumRes = %d, iMaxStaticResources = %d"), aNumRes, iMaxStaticResources); + test(aNumRes == (iMaxStaticResources + iMaxStaticDependentResources)); + + //Fill in the resource information + TInt newState, levelOwnerId; + TPowerResourceInfoV01 *ptr = (TPowerResourceInfoV01*)info.Ptr(); + + TUint extCount = 0; + for(TUint count = 0; count < aNumRes; count++) + { + r = lddChan.GetResourceStateSync(Clients[0].iClientId, ptr->iResourceId, ETrue, newState, levelOwnerId); + if(r != KErrNone) + test.Printf(_L("GetResourceStateSync failed for ClientId = %d, resourceId = %d with return value %d\n"), Clients[0].iClientId, count+1, r); + test(r == KErrNone); + test.Printf(_L("Info of Resource %d\n"), count+1); + test.Printf(_L("Resource Id %d\n"), ptr->iResourceId); + test.Printf(_L("Resource Type %d\n"), ptr->iType); + test.Printf(_L("Resource Sense %d\n"), ptr->iSense); + test.Printf(_L("Resource Latency Get %d\n"), ptr->iLatencyGet); + test.Printf(_L("Resource Latency Set %d\n"), ptr->iLatencySet); + test.Printf(_L("Resource usage %d\n"), ptr->iUsage); + test.Printf(_L("Resource MinLevel %d\n"), ptr->iMinLevel); + test.Printf(_L("Resource MaxLevel %d\n"), ptr->iMaxLevel); + test.Printf(_L("Resource DefaultLevel %d\n"), ptr->iDefaultLevel); + + if(iTestingExtendedVersion && (ptr->iResourceId & DEPENDENCY_RESOURCE_BIT_MASK)) + { + iStaticDependencyResources[extCount++] = ptr->iResourceId; + ptr++; + continue; + } + if(iTestingExtendedVersion && (ptr->iResourceId & DYNAMIC_RESOURCE_BIT_MASK)) + { + ptr++; + continue; + } + Resources[count].iName.Copy(*ptr->iResourceName); + Resources[count].iResourceId = ptr->iResourceId; + Resources[count].iMaxLevel = ptr->iMaxLevel; + Resources[count].iMinLevel = ptr->iMinLevel; + Resources[count].iDefaultLevel = ptr->iDefaultLevel; + Resources[count].iNumClients = 0; + Resources[count].iCurrentClient = -1; + Resources[count].iCurrentLevel = newState; + Resources[count].iType = ptr->iType; + Resources[count].iSense = ptr->iSense; + Resources[count].iLatencyGet = ptr->iLatencyGet; + Resources[count].iLatencySet = ptr->iLatencySet; + Resources[count].iUsage = ptr->iUsage; + Resources[count].iUnCondNotiCount = 0; + Resources[count].iCondNoti = NULL; + Resources[count].iUncondNoti = NULL; + Resources[count].iLevel = NULL; + ptr++; + } + iMaxStaticResources -= extCount; + iMaxStaticDependentResources = extCount; + info.Close(); + return; + } + r = lddChan.GetInfoOnResourcesInUseByClient(Clients[aClientId].iClientId, Clients[aClientId].iClientId, aNumRes, (TAny*)&info); + if(aNumRes != Clients[aClientId].iNumResources) + { + test.Printf(_L("Expected Resource Num = %d, Returned = %d\n"), Clients[aClientId].iNumResources, aNumRes); + test(0); + } + if(aNumRes == 0) + { + test((r == KErrArgument) || (r == KErrNone)); + info.Close(); + return; + } + else + test(r == KErrNone); + TPowerResourceInfoV01 *ptr = (TPowerResourceInfoV01*)info.Ptr(); + for(TUint count = 0; count < Clients[aClientId].iNumResources; count++) + { + if(Clients[aClientId].iResourceIds[count] == 0) + continue; + TUint c; + for(c = 0; c < Clients[aClientId].iNumResources; c++) + { + if(Clients[aClientId].iResourceIds[c] == ptr->iResourceId) + break; + } + if(c == Clients[aClientId].iNumResources) + test(0); + //Find the resource from resource list + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iResourceId == ptr->iResourceId) + break; + } + if(c == iMaxStaticResources) + test(0); + test(Resources[c].iResourceId == ptr->iResourceId); + test(Resources[c].iMaxLevel == ptr->iMaxLevel); + test(Resources[c].iMinLevel == ptr->iMinLevel); + test(Resources[c].iDefaultLevel == ptr->iDefaultLevel); + test(Resources[c].iType == ptr->iType); + test(Resources[c].iSense == ptr->iSense); + test(Resources[c].iLatencyGet == ptr->iLatencyGet); + test(Resources[c].iLatencySet == ptr->iLatencySet); + test(Resources[c].iUsage == ptr->iUsage); + test(!Resources[c].iName.Compare(*ptr->iResourceName)); + ptr++; + } + info.Close(); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0581 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests retrieval of number of clients holding requirement on +//! the requested resource functionality of resource manager and compares with stored +//! information for correctness.There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid resource Id. +//! Positive tests +//! 3 Call the API with valid calling client Id and resource Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return KErrNone with number of clients holding requirement on +//! the requested resource updated and also is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetNumClientsUsingResource(TUint aClientId, TUint aResId) + { + TUint clientNum = 0; + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetNumClientsUsingResource(32, 1, clientNum); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.GetNumClientsUsingResource(id, 1, clientNum); + test(r == KErrAccessDenied); + + //Invalid resource id + r = lddChan.GetNumClientsUsingResource(Clients[aClientId].iClientId, iMaxStaticResources+40, clientNum); + test(r == KErrNotFound); + } + if((TInt)aResId == -1) + r = lddChan.GetNumClientsUsingResource(Clients[aClientId].iClientId, 0, clientNum); + else + r = lddChan.GetNumClientsUsingResource(Clients[aClientId].iClientId, Resources[aResId].iResourceId, clientNum); + if(r != KErrNone) + test.Printf(_L("GetNumClientsUsingResource for client 0x%x failed with %d"), Clients[aClientId].iClientId, r); + test(r==KErrNone); + if((TInt)aResId == -1) + { + if(clientNum != (TUint)(Clients.Count() + 1)) + test.Printf(_L("ClientNum = %d, Expected clientNum = %d"), clientNum, Clients.Count()+1); + test(clientNum == (TUint)(Clients.Count() + 1)); + } + else + { + test(Resources[aResId].iNumClients == clientNum); + if(!Resources[aResId].iUsage && clientNum > 1) //Single user resource cannot have more that one client + test(0); + } + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0582 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests retrieval of information about clients holding requirement on +//! the passed resource functionality of resource manager and compares with stored information +//! for correctness.There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id (calling client Id). +//! 1 Call the API with invalid instance count of calling client Id. +//! 2 Call the API with invalid resource Id. +//! 3 Call the API with null buffer (buffer where the resource information will be updated). +//! 4 Call the API with the number of resource information to be updated as 0 (specifies the +//! size of the buffer). +//! Positive tests +//! 5 Call the API with valid calling and target client Id, buffer and its size. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panics otherwise +//! 3 API should return with KErrArgument, panics otherwise +//! 4 API should return with KErrArgument, panics otherwise +//! 5 API should return KErrNone with resource information about clients holding requirement +//! on the passed resource and also is checked for correctness, panics otherwise +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetInfoOnClientsUsingResource(TUint aResId, TUint aNumCli) + { + RBuf8 info; + info.Create(aNumCli * sizeof(TPowerClientInfoV01)); + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetInfoOnClientsUsingResource(2, 1, aNumCli, (TAny*)(TDes8*)&info); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.GetInfoOnClientsUsingResource(id, 1, aNumCli, (TAny*)(TDes8*)&info); + test(r == KErrAccessDenied); + + //Invalid resource id + r = lddChan.GetInfoOnClientsUsingResource(Clients[iCurrentClientId].iClientId, iMaxStaticResources+40, aNumCli, (TAny*)(TDes8*)&info); + test(r == KErrNotFound); + + //Pass null buffer + r = lddChan.GetInfoOnClientsUsingResource(Clients[iCurrentClientId].iClientId, 1 ,aNumCli, (TAny*)NULL); + test(r == KErrArgument); + + //Pass required resources as 0 + TUint tempCli = 0; + r = lddChan.GetInfoOnClientsUsingResource(Clients[iCurrentClientId].iClientId, 1 ,tempCli, (TAny*)(TDes8*)&info); + test(r == KErrArgument); + } + if((TInt)aResId == -1) + r = lddChan.GetInfoOnClientsUsingResource(Clients[iCurrentClientId].iClientId, 0, aNumCli, (TAny*)(TDes8*)&info); + else + r = lddChan.GetInfoOnClientsUsingResource(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, aNumCli, (TAny*)(TDes8*)&info); + if(r == KErrArgument) + { + if(aResId != 0) + test(Resources[aResId].iNumClients == 0); + info.Close(); + return; + } + test(r == KErrNone); + TPowerClientInfoV01 *ptr = (TPowerClientInfoV01*)info.Ptr(); + if((TInt)aResId == -1) + { + test(aNumCli == (TUint)(Clients.Count() + 1)); + TUint c = 0; + for(TUint count = 0; count < aNumCli; count++) + { + //Skip comparision of first client as that will be PowerController. + if(ptr->iClientId == iPowerControllerId) + { + ptr++; + continue; + } + for(c = 0; c< iMaxClients; c++) + { + if(ptr->iClientId == Clients[c].iClientId) + break; + } + if(c == iMaxClients) + test(0); + ptr++; + } + } + else + { + if(aNumCli != Resources[aResId].iNumClients) + test.Printf(_L("aNumCli = %d, Expected numClients = %d\n"), aNumCli, Resources[aResId].iNumClients); + test(aNumCli == Resources[aResId].iNumClients); + //Compare results + SPowerResourceClientLevel *level = Resources[aResId].iLevel; + TUint c = 0; + for(TUint count = 0; count < aNumCli; count++) + { + SPowerResourceClientLevel *pL = Resources[aResId].iLevel; + for(c =0;ciClientId].iClientId == ptr->iClientId) + break; + pL = pL->iNextInList; + } + if(c == aNumCli) + { + test.Printf(_L("Client Id %d is not in the resource clientlevel list\n"), Clients[level->iClientId].iClientId); + test(0); + } + level = level->iNextInList; + ptr++; + } + } + info.Close(); + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0583 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests preallocation of memory for resource manager internal +//! structure.There are negative and positive tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id +//! 1 Call the API with invalid instance count of client Id. +//! Positive tests +//! 2 Call the API with valid client Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNone, panic otherwise. Really cannot +//! test this for correctness. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::AllocReserve(TUint aClientId) + { + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.AllocReserve(11, 0, 3); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[aClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.AllocReserve(id, 0, 0); + test(r == KErrAccessDenied); + + } + r = lddChan.AllocReserve(Clients[iCurrentClientId].iClientId, 1, 0); + if(r != KErrNone) + test.Printf(_L("Alloc Reserve failed with %d"), r); + test(r == KErrNone); + } + +//This function validates the conditional and unconditional notification for the +//specified resource state change. +void TestRM::CheckNotification(TUint aResId, TInt newState) + { + if(newState == Resources[aResId].iCurrentLevel) + return; + //Return if the newState is in decreasing order with respect to sense. + if(Resources[aResId].iUsage == EShared && Resources[aResId].iCurrentClient != -1) + { + if(Resources[aResId].iSense == EPositive) + { + if(newState <= Resources[aResId].iCurrentLevel && Resources[aResId].iCurrentClient != iCurrentClientId) + return; + } + else + { + if(newState >= Resources[aResId].iCurrentLevel && Resources[aResId].iCurrentClient != iCurrentClientId) + return; + } + } + TUint notificationUnCon = Resources[aResId].iUnCondNotiCount; + TUint notificationCon =0; + for(NotiInfo* info = Resources[aResId].iCondNoti; info != NULL; info = info->iNext) + { + if((info->iDirection && (info->iPreviousLevel < info->iThreshold) && (newState >= info->iThreshold)) || + (!info->iDirection && (info->iPreviousLevel > info->iThreshold) && (newState <= info->iThreshold))) + notificationCon++; + info->iPreviousLevel = newState; + } + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, notificationUnCon, notificationCon); + if(r != KErrNone) + test.Printf(_L("Check Notifications failed with %d"), r); + test(r == KErrNone); + } + +//This function updates the client level.This will be used by other functions for validation. +void TestRM::AddClientLevel(TUint aResId, TInt newState) + { + SPowerResourceClientLevel *pCL = NULL; + if(Resources[aResId].iUsage == EShared) + { + for(pCL = Resources[aResId].iLevel;pCL != NULL; pCL = pCL->iNextInList) + { + if((TInt)pCL->iClientId == iCurrentClientId) + { + pCL->iLevel = newState; + return; + } + } + pCL = new SPowerResourceClientLevel; + test(pCL != NULL); + pCL->iClientId = iCurrentClientId; + pCL->iResourceId = Resources[aResId].iResourceId; + pCL->iLevel = newState; + LIST_PUSH(Resources[aResId].iLevel, pCL, iNextInList); + Resources[aResId].iNumClients++; + } + else + { + if(Resources[aResId].iCurrentClient == -1) + { + pCL = new SPowerResourceClientLevel; + test(pCL != NULL); + pCL->iClientId = iCurrentClientId; + pCL->iResourceId = Resources[aResId].iResourceId; + pCL->iLevel = newState; + LIST_PUSH(Resources[aResId].iLevel, pCL, iNextInList); + Resources[aResId].iNumClients++; + } + else + { + SPowerResourceClientLevel* pCL = Resources[aResId].iLevel; + pCL->iLevel = newState; + } + } + } + +//This function updates the current level and client information in corresponding resource array. +void TestRM::UpdateClientInformation(TUint aResId, TInt aNewState) + { + if(Resources[aResId].iCurrentClient == -1) + { + Resources[aResId].iCurrentLevel = aNewState; + Resources[aResId].iCurrentClient = iCurrentClientId; + return; + } + if(!Resources[aResId].iUsage) + { + Resources[aResId].iCurrentLevel = aNewState; + return; + } + if(Resources[aResId].iSense == EPositive) + { + if(aNewState > Resources[aResId].iCurrentLevel) + { + Resources[aResId].iCurrentLevel = aNewState; + Resources[aResId].iCurrentClient = iCurrentClientId; + } + else if(Resources[aResId].iCurrentClient == iCurrentClientId) + { + SPowerResourceClientLevel *pCL = NULL; + for(pCL = Resources[aResId].iLevel;pCL != NULL; pCL = pCL->iNextInList) + { + if(pCL->iLevel > aNewState) + { + Resources[aResId].iCurrentLevel = pCL->iLevel; + Resources[aResId].iCurrentClient = pCL->iClientId; + return; + } + } + Resources[aResId].iCurrentLevel = aNewState; + Resources[aResId].iCurrentClient = iCurrentClientId; + } + return; + } + if(Resources[aResId].iSense == ENegative) + { + if(aNewState < Resources[aResId].iCurrentLevel) + { + Resources[aResId].iCurrentLevel = aNewState; + Resources[aResId].iCurrentClient = iCurrentClientId; + } + else if(Resources[aResId].iCurrentClient == iCurrentClientId) + { + SPowerResourceClientLevel *pCL = NULL; + for(pCL = Resources[aResId].iLevel;pCL != NULL; pCL = pCL->iNextInList) + { + if(pCL->iLevel < aNewState) + { + Resources[aResId].iCurrentLevel = pCL->iLevel; + Resources[aResId].iCurrentClient = pCL->iClientId; + return; + } + } + Resources[aResId].iCurrentLevel = aNewState; + Resources[aResId].iCurrentClient = iCurrentClientId; + } + } + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0584 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests change resource state functionality of resource manager +//! by changing the state of the resource to random value between resource minimum +//! and maximum value synchronously.This function will add the client level if required +//! and update resource information and will check notification for correctness.There are +//! postive and negative tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id +//! 1 Call the API with invalid instance count of client Id. +//! 2 Call the API with invalid resource Id +//! Positive tests +//! 3 Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panic otherwise. +//! 3 API should return with KErrNone, panic otherwise. +//! This also checks for notifications revceived as a result of this +//! resource change and checks for correctness. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::ChangeResourceStateSync(TUint aResId) + { + TInt newState = 0; + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.ChangeResourceStateSync(434224, Resources[aResId].iResourceId, newState); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (1<<16); + r = lddChan.ChangeResourceStateSync(id, Resources[aResId].iResourceId, newState); + test(r == KErrAccessDenied); + + //Invalid resource id + r = lddChan.ChangeResourceStateSync(Clients[iCurrentClientId].iClientId, iMaxStaticResources+40, newState); + test(r == KErrNotFound); + + r = lddChan.ChangeResourceStateSync(Clients[iCurrentClientId].iClientId, 26, newState); + test(r == KErrNotFound); + } + TInt maxLevel = Resources[aResId].iMaxLevel; + TInt minLevel = Resources[aResId].iNumClients? Resources[aResId].iCurrentLevel : Resources[aResId].iMinLevel; + //Toggle current state for binary resources + if(!Resources[aResId].iType) + newState = !Resources[aResId].iCurrentLevel; + else if (Resources[aResId].iType == EMultiLevel) + { + TInt diff = Abs(maxLevel - minLevel); + if(Resources[aResId].iSense == EPositive) + { + if(minLevel == maxLevel) + newState = maxLevel - Math::Random() % diff; + else + newState = minLevel + Math::Random() % diff; + } + else + { + if(minLevel == maxLevel) + newState = maxLevel + Math::Random() % diff; + else + newState = minLevel - Math::Random() % diff; + } + } + TInt reqState = newState; + r = lddChan.ChangeResourceStateSync(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, newState); + if(r == KErrAccessDenied) + return; + if(r != KErrNone) + test.Printf(_L("Synchronous resource change returned with %d"), r); + test(r == KErrNone); + if(newState != reqState) + test.Printf(_L("NewState = %d, Expected state = %d"), newState, reqState); + if(!Resources[aResId].iUsage) + test(newState == reqState); + CheckNotification(aResId, reqState); + AddClientLevel(aResId, reqState); + UpdateClientInformation(aResId, reqState); + TUint c = 0; + for(c = 0; c< Clients[iCurrentClientId].iNumResources; c++) + { + if(Clients[iCurrentClientId].iResourceIds[c] == Resources[aResId].iResourceId) + return; + } + Clients[iCurrentClientId].iResourceIds[c] = Resources[aResId].iResourceId; + Clients[iCurrentClientId].iNumResources++; + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0585 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests change resource state functionality of resource manager +//! by changing the state of the resource to random value between resource minimum +//! and maximum value asynchronously.This function will add the client level if required +//! and update resource information and will check notification for correctness.This +//! also tests the cancellation of asynchronous function by immediately cancelling the +//! operation after requesting resource state change. This is taken care in the driver. +//! There are postive and negative tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id +//! 1 Call the API with invalid instance count of client Id. +//! 2 Call the API with invalid resource Id +//! Positive tests +//! 3 Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panic otherwise. +//! 3 API should return with KErrNone or if cancellation of this +//! API is tested then will return with KErrCancel, panic otherwise. +//! This also checks for notifications received as a result of this +//! resource change and checks for correctness. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::ChangeResourceStateAsync(TUint aResId, TBool aReqCancel) + { + TRequestStatus resChange; + TInt newState = 0; + if(NegativeTesting) + { + //Pass illegial client Id + lddChan.ChangeResourceStateAsync(434224, Resources[aResId].iResourceId, newState, resChange); + User::WaitForRequest(resChange); + test(resChange.Int() == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (1<<16); + lddChan.ChangeResourceStateAsync(id, Resources[aResId].iResourceId, newState, resChange); + User::WaitForRequest(resChange); + test(resChange.Int() == KErrAccessDenied); + + //Invalid resource id + lddChan.ChangeResourceStateAsync(Clients[iCurrentClientId].iClientId, iMaxStaticResources+40, newState, resChange); + User::WaitForRequest(resChange); + test(resChange.Int() == KErrNotFound); + + lddChan.ChangeResourceStateAsync(Clients[iCurrentClientId].iClientId, 19, newState, resChange); + User::WaitForRequest(resChange); + test(resChange.Int() == KErrNotFound); + } + TInt maxLevel = Resources[aResId].iMaxLevel; + TInt minLevel = (Resources[aResId].iCurrentClient != -1)? Resources[aResId].iCurrentLevel : Resources[aResId].iMinLevel; + //Check if the resource is positive + if(!Resources[aResId].iType) + newState = !Resources[aResId].iCurrentLevel; + else if (Resources[aResId].iType == EMultiLevel) + { + TInt diff = Abs(maxLevel - minLevel); + if( diff == 0) + diff = Abs(Resources[aResId].iMaxLevel - Resources[aResId].iMinLevel); + if(Resources[aResId].iSense == EPositive) + { + if(minLevel == maxLevel) + newState = maxLevel - Math::Random() % diff; + else + newState = minLevel + Math::Random() % diff; + } + else + { + if(minLevel == maxLevel) + newState = maxLevel + Math::Random() % diff; + else + newState = minLevel - Math::Random() % diff; + } + } + TInt reqState = newState; + //Long latency resource + lddChan.ChangeResourceStateAsync(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, newState, resChange, aReqCancel); + User::WaitForRequest(resChange); + if(aReqCancel && (resChange.Int() != KErrNone)) + { + test(resChange.Int() == KErrCancel || resChange.Int() == KErrCompletion); + return; + } + if(resChange.Int() == KErrAccessDenied) + return; + if(!Resources[aResId].iUsage) + test(newState == reqState); + CheckNotification(aResId, reqState); + AddClientLevel(aResId, reqState); + UpdateClientInformation(aResId, reqState); + TUint c = 0; + for(c = 0; c< Clients[iCurrentClientId].iNumResources; c++) + { + if(Clients[iCurrentClientId].iResourceIds[c] == Resources[aResId].iResourceId) + return; + } + Clients[iCurrentClientId].iResourceIds[c] = Resources[aResId].iResourceId; + Clients[iCurrentClientId].iNumResources++; + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0586 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests synchronous version of get resource state functionality of +//! resource manager by getting the state of the resource checks for correctness. +//! There are positive and negative tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id +//! 1 Call the API with invalid instance count of client Id. +//! 2 Call the API with invalid resource Id +//! Positive tests +//! 3 Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panic otherwise. +//! 3 API should return with KErrNone and also the state and Owner Id are checked +//! for correctness, panic otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetResourceStateSync(TUint aResId) + { + static TBool Cached; + TInt state = 0, levelOwnerId = 0; + if(NegativeTesting) + { + //Pass illegial client Id + r = lddChan.GetResourceStateSync(4342241, Resources[aResId].iResourceId, Cached, state, levelOwnerId); + test(r == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (1<<30); + r = lddChan.GetResourceStateSync(id, Resources[aResId].iResourceId, Cached, state, levelOwnerId); + test(r == KErrAccessDenied); + + //Invalid resource id + r = lddChan.GetResourceStateSync(Clients[iCurrentClientId].iClientId, iMaxStaticResources+40, Cached, state, levelOwnerId); + test(r == KErrNotFound); + + r = lddChan.GetResourceStateSync(Clients[iCurrentClientId].iClientId, 20, Cached, state, levelOwnerId); + test(r == KErrNotFound); + } + r = lddChan.GetResourceStateSync(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, Cached, state, levelOwnerId); + test(r == KErrNone); + test(state == Resources[aResId].iCurrentLevel); + if(Resources[aResId].iCurrentClient == -1) + test(levelOwnerId == -1); + else if (levelOwnerId != (TInt)Clients[Resources[aResId].iCurrentClient].iClientId) + { + test.Printf(_L("Expected ClientId = 0x%x, Returned ClientId = 0x%x\n"), Resources[aResId].iCurrentClient, levelOwnerId); + test(0); + } + Cached = !Cached; + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0587 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests get resource state functionality of resource manager +//! by getting the state of the resource asynchronously and checking for correctness. +//! This also tests the cancellation of asynchronous function by immediately cancelling the +//! operation after requesting get resource state. This is taken care in the driver. +//! There are positive and negative tests. +//! @SYMTestActions If negative testing is enabled then following tests are done +//! 0 Call the API with invalid client Id +//! 1 Call the API with invalid instance count of client Id. +//! 2 Call the API with invalid resource Id +//! Positive tests +//! 3 Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrAccessDenied, panics otherwise +//! 1 API should return with KErrAccessDenied, panics otherwise +//! 2 API should return with KErrNotFound, panic otherwise. +//! 3 API should return with KErrNone or if cancellation of this +//! API is tested then will return with KErrCancel, panic otherwise. +//! This also checks the updated level and owner Id for correctness, +//! panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::GetResourceStateAsync(TUint aResId, TBool aReqCancel) + { + static TBool Cached; + TRequestStatus resGet; + TInt state, levelOwnerId; + if(NegativeTesting) + { + //Pass illegial client Id + lddChan.GetResourceStateAsync(4342241, Resources[aResId].iResourceId, Cached, resGet, state, levelOwnerId); + User::WaitForRequest(resGet); + test(resGet.Int() == KErrAccessDenied); + + //Pass illegal instance count + TUint id = Clients[iCurrentClientId].iClientId; + id = id ^ (1<<30); + lddChan.GetResourceStateAsync(id, Resources[aResId].iResourceId, Cached, resGet, state, levelOwnerId); + User::WaitForRequest(resGet); + test(resGet.Int() == KErrAccessDenied); + + //Invalid resource id + lddChan.GetResourceStateAsync(Clients[iCurrentClientId].iClientId, iMaxStaticResources+48, Cached, resGet, state, levelOwnerId); + User::WaitForRequest(resGet); + test(resGet.Int() == KErrNotFound); + + lddChan.GetResourceStateAsync(Clients[iCurrentClientId].iClientId, 20, Cached, resGet, state, levelOwnerId); + User::WaitForRequest(resGet); + test(resGet.Int() == KErrNotFound); + } + lddChan.GetResourceStateAsync(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, Cached, resGet, state, levelOwnerId, aReqCancel); + User::WaitForRequest(resGet); + if(aReqCancel && (resGet.Int() != KErrNone)) + { + test(resGet.Int() == KErrCancel || resGet.Int() == KErrCompletion); + return; + } + test(state == Resources[aResId].iCurrentLevel); + if(Resources[aResId].iCurrentClient == -1) + test(levelOwnerId == -1); + else if (levelOwnerId != (TInt)Clients[Resources[aResId].iCurrentClient].iClientId) + { + test.Printf(_L("Expected ClientId = 0x%x, Returned ClientId = 0x%x\n"), Resources[aResId].iCurrentClient, levelOwnerId); + test(0); + } + Cached = !Cached; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0588 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests unconditional notification request functionality of resource manager. +//! @SYMTestActions Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::RequestNotification(TUint aResId) + { + //If unconditional notification is already queued for this client then dont request another one. + for(NotiInfo *pN = Resources[aResId].iUncondNoti; pN != NULL; pN = pN->iNext) + { + if((TInt)pN->iClientId == iCurrentClientId) + return; + } + r = lddChan.RequestNotification(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId); + if(r != KErrNone) + test.Printf(_L("Request Notification returned with %d"), r); + test(r == KErrNone); + //Add to resource list + NotiInfo *info = new NotiInfo; + test(info != NULL); + info->iClientId = iCurrentClientId; + LIST_PUSH(Resources[aResId].iUncondNoti, info, iNext); + Resources[aResId].iUnCondNotiCount++; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0589 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests conditional notification request functionality of resource manager. +//! Threshold and direction are chosen randomly for each resource based on the resource information. +//! @SYMTestActions Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::RequestNotificationCon(TUint aResId) + { + //Allow only one notification per client. + static TBool direction; + TInt threshold = direction; + for(NotiInfo *pN = Resources[aResId].iCondNoti; pN != NULL; pN = pN->iNext) + { + if((TInt)pN->iClientId == iCurrentClientId) + return; + } + if(Resources[aResId].iType) + { + if(Resources[aResId].iSense == EPositive) + { + threshold = Math::Random() % Resources[aResId].iMaxLevel; + if(threshold < Resources[aResId].iMinLevel) + threshold += Resources[aResId].iMinLevel; + } + else if(Resources[aResId].iSense == ENegative) + { + threshold = Math::Random() % Resources[aResId].iMinLevel; + if(threshold < Resources[aResId].iMaxLevel) + threshold += Resources[aResId].iMaxLevel; + } + } + r = lddChan.RequestNotification(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, direction, threshold); + if(r != KErrNone) + test.Printf(_L("Request Notification returned with %d for direction = %d, threshold = %d"), r, direction, threshold); + test(r == KErrNone); + NotiInfo *info = new NotiInfo; + test(info != NULL); + info->iClientId = iCurrentClientId; + info->iThreshold = threshold; + info->iDirection = direction; + info->iPreviousLevel = Resources[aResId].iCurrentLevel; + LIST_PUSH(Resources[aResId].iCondNoti, info, iNext); + direction = !direction; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0590 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests cancellation of notification functionality of resource manager. +//! @SYMTestActions Call the API with valid client and resource Id. +//! +//! @SYMTestExpectedResults API should return with KErrCancel, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::CancelNotification(TUint aResId, TBool Cond) + { + RMResInfo *pR = &Resources[aResId]; + TBool found = EFalse; + if(Cond) + { + //Remove any conditional notification this client has on resource. + for(NotiInfo* pI = pR->iCondNoti; pI != NULL; pI = pI->iNext) + { + if((TInt)pI->iClientId == iCurrentClientId) + { + LIST_REMOVE(pR->iCondNoti, pI, iNext, NotiInfo); + delete pI; + found = ETrue; + break; + } + } + } + else + { + //Remove any unconditional notification this client has on resource. + for(NotiInfo* pI = pR->iUncondNoti; pI != NULL; pI = pI->iNext) + { + if((TInt)pI->iClientId == iCurrentClientId) + { + LIST_REMOVE(pR->iUncondNoti, pI, iNext, NotiInfo); + pR->iUnCondNotiCount--; + delete pI; + found = ETrue; + break; + } + } + } + if(found) + { + r = lddChan.CancelNotification(Clients[iCurrentClientId].iClientId, Resources[aResId].iResourceId, Cond); + if(r != KErrCancel) + test.Printf(_L("CancelNotification Clients %d, return value = %d"), iCurrentClientId, r); + test(r == KErrCancel); + } + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0591 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests client registration and deregistration API of resource manager. +//! There are positive and negative tests. +//! @SYMTestActions 0 Call the client registration API with valid client name to register +//! 1 Call the client name updation API with valid client Id to get the client name +//! 2 Call the client name updation API with invalid client id. +//! 3 Call the client registration API with client name greater than maximum +//! allowable name length (32 characters) +//! 4 Call the client deregistration API by passing invalid client Id. +//! 5 Call the client deregistration API by passing invalid instance count. +//! 6 Call the client deregistration API by passing valid client Id. +//! +//! @SYMTestExpectedResults 0 API should return with KErrNone, panics otherwise. +//! 1 API should return with KErrNone and updated name is checked for +//! correctness, panics otherwise. +//! 2 API should return with KErrAccessDenied, panics otherwise. +//! 3 API should return with KErrTooBig, panics otherwise. +//! 4 API should return with KErrNotFound, panics otherwise. +//! 5 API should return with KErrNotFound, panics otherwise. +//! 6 API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::ValidateClient(TUint aNumClients, TOwnerType aContext) + { + TInt r = KErrNone; + TBuf8<32> ClientName; + ClientName.Zero(); + ClientName.Append(_L8("Clients?")); + TUint clientId[MAX_CLIENTS]; + if(aNumClients > MAX_CLIENTS) + return; + TUint c; + for(c = 0; c < aNumClients; c++) + { + ClientName[7] = (TUint8)('0' + c); + r = lddChan.RegisterClient(clientId[c], (const TDesC*)&ClientName, aContext); + if(r != KErrNone) + { + test.Printf(_L("Client registration failed with %d"), r); + test(0); + } + } + + //Validate Client + TBuf8<32> aName; + + for(c = 0; c < aNumClients; c++) + { + ClientName[7] = (TUint8)('0' + c); + r = lddChan.GetClientName(clientId[c], clientId[c], (TDes8*)&aName); + if(r != KErrNone) + { + test.Printf(_L("GetClientName API failed with error %d"), r); + test(0); + } + r = aName.Compare(ClientName); + if(r != KErrNone) + { + test.Printf(_L("Client Name is not as expected")); + test(0); + } + } + //Invalid tests + ClientName[7] = (TUint8)('0' + aNumClients+1); + r = lddChan.GetClientName(aNumClients, clientId[0], &aName); + if(r != KErrAccessDenied) + { + test.Printf(_L("RM allows illegal clients")); + test(0); + } + + //Long filename + TBuf8<50> name; + name.Zero(); + name.Append(_L8("RegisteringClientNameGreaterThan32Characters")); + TUint id =0; + r = lddChan.RegisterClient(id, (const TDesC*)&name, aContext); + if(r != KErrTooBig) + { + test.Printf(_L("RM allows big names !!!")); + test(0); + } + test.Printf(_L("Client Deregistration")); + //Deregistration of non-existing client + id = 0; + r = lddChan.DeRegisterClient(id); + if(r != KErrNotFound) + { + test.Printf(_L("RM allows invalid client ID deregistration!!!")); + test(0); + } + + //Get client Name by passing invalid client Id (changing a bit in instance count) + id = clientId[0] ^ (1<<16); + r = lddChan.DeRegisterClient(id); + if(r != KErrNotFound) + { + test.Printf(_L("RM allows invalid client ID deregistation!!!")); + test(0); + } + + //Deregister the client registered at the start of this function + for(c = 0; c < aNumClients; c++) + { + r = lddChan.DeRegisterClient(clientId[c]); + if(r != KErrNone) + { + test.Printf(_L("Deregistration of client id 0x%x failed"), clientId[c]); + test(0); + } + } + return; + } + +#ifdef PRM_ENABLE_EXTENDED_VERSION +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0597 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests dynamic resources with dependency. +//! @SYMTestActions 0 Register clients +//! 1 Register dynamic resource with dependency +//! 2 Establish dependency between resources +//! 3 Register notifications +//! 4 Check dependency information for correctness +//! 5 Change Resource State of each resource +//! 6 Get state of the resources and verify them for correctness +//! 7 Check notification count for correctness +//! 8 Deregister dependency between resources +//! 9 Deregister client level +//! 10 Deregister dynamic resource with dependency +//! 11 Deregister clients +//! +//! @SYMTestExpectedResults 0 API should return with KErrNone, panics otherwise. +//! 1 API should return with KErrNone, panics otherwise. +//! 2 API should return with KErrNone, panics otherwise. +//! 3 API should return with KErrNone, panics otherwise. +//! 4 API should return with KErrNone, panics otherwise. +//! 5 API should return with KErrNone, panics otherwise. +//! 6 API should return with KErrNone, panics otherwise. +//! 7 API should return with KErrNone, panics otherwise. +//! 8 API should return with KErrNone, panics otherwise. +//! 9 API should return with KErrNone, panics otherwise. +//! 10 API should return with KErrNone, panics otherwise. +//! 11 API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +/*This tests dynamic dependency resource. It also creates a dependency between static resource. + Below is the dependency tree + ResourceA <----------------> ResourceD <------------->ResourceE <--------------> ResourceC + | | + | | + | | + | | + | | + | | + ResourceF ResourceG <-------------> Resource H <------->Resource I + ¦ (Dynamic) (Dynamic) + ¦ + ¦ + ¦ + Resource J <-------->Resource K + (Dynamic) (Dynamic) +*/ +void TestRM::TestDynamicResourceDependency() + { + TInt state; + TRequestStatus req; + SResourceDependencyInfo info1, info2; + SResourceDependencyInfo sResDepInfo; + RArraydepResArray; + + TUint dynamicDepResId[4]; + + test.Next(_L("Testing Dynamic + static resource dependency")); + RmTest.RegisterClient(); /* Register Client 1 */ + + //Register dependency resource + dynamicDepResId[0] = 5; + r = lddChan.RegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[0]); + test(r == KErrNone); + + info1.iResourceId = iStaticDependencyResources[5]; + info1.iDependencyPriority = 3; + + info2.iResourceId = dynamicDepResId[0]; + info2.iDependencyPriority = 2; + + r = lddChan.RegisterResourceDependency(Clients[0].iClientId, info1, info2); + test(r == KErrNone); + + //Check for correctness of dependency resource information + sResDepInfo.iResourceId = iStaticDependencyResources[3]; + sResDepInfo.iDependencyPriority = 1; + depResArray.Append(sResDepInfo); + sResDepInfo.iResourceId = dynamicDepResId[0]; + sResDepInfo.iDependencyPriority = 2; + depResArray.Append(sResDepInfo); + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[5], 2, &depResArray[0]); + + depResArray[0].iResourceId = iStaticDependencyResources[5]; + depResArray[0].iDependencyPriority = 3; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 1, &depResArray[0]); + + //Change Static dependency resource to -50 + RmTest.RegisterClient(); /* Register Client 2 */ + state = -50; + lddChan.ChangeResourceStateAsync(Clients[1].iClientId, iStaticDependencyResources[0], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], -50, Clients[1].iClientId, EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[1], -11, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 73, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(dynamicDepResId[0], 80, iStaticDependencyResources[5]); + + //Register dynamic dependency resource I + dynamicDepResId[1] = 6; + r = lddChan.RegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[1]); + test(r == KErrNone); + + //Register dynamic dependency resource J + dynamicDepResId[2] = 7; + r = lddChan.RegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[2]); + test(r == KErrNone); + + //Register dynamic dependency resource K + dynamicDepResId[3] = 8; + r = lddChan.RegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[3]); + test(r == KErrNone); + + RmTest.RegisterClient(); /* Register Client3 */ + RmTest.RegisterClient(); /* Register Client4 */ + + //Register notifications + r = lddChan.RequestNotification(Clients[1].iClientId, iStaticDependencyResources[5]); + test(r == KErrNone); + r = lddChan.RequestNotification(Clients[2].iClientId, dynamicDepResId[0]); + test(r == KErrNone); + r = lddChan.RequestNotification(Clients[1].iClientId, dynamicDepResId[1]); + test(r == KErrNone); + r = lddChan.RequestNotification(Clients[2].iClientId, dynamicDepResId[2]); + test(r == KErrNone); + r = lddChan.RequestNotification(Clients[1].iClientId, dynamicDepResId[3]); + test(r == KErrNone); + + //Create depedency between H and I + info1.iResourceId = dynamicDepResId[0]; + info1.iDependencyPriority = 1; + + info2.iResourceId = dynamicDepResId[1]; + info2.iDependencyPriority = 1; + + //Register dependency between resource H and I + r = lddChan.RegisterResourceDependency(Clients[0].iClientId, info1, info2); + test(r == KErrNone); + //Validate dependency information + depResArray[0].iResourceId = dynamicDepResId[1]; + depResArray[0].iDependencyPriority = 1; + depResArray[1].iResourceId = iStaticDependencyResources[5]; + depResArray[1].iDependencyPriority = 3; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 2, &depResArray[0]); + + depResArray[0].iResourceId = dynamicDepResId[0]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[1], 1, &depResArray[0]); + + //Create depedency between H and J + info1.iResourceId = dynamicDepResId[0]; + info1.iDependencyPriority = 1; + + info2.iResourceId = dynamicDepResId[2]; + info2.iDependencyPriority = 2; + + //Register dependency between resource H and J + r = lddChan.RegisterResourceDependency(Clients[0].iClientId, info1, info2); + test(r == KErrNone); + + depResArray[0].iResourceId = dynamicDepResId[1]; + depResArray[0].iDependencyPriority = 1; + depResArray[1].iResourceId = dynamicDepResId[2]; + depResArray[1].iDependencyPriority = 2; + sResDepInfo.iResourceId = iStaticDependencyResources[5]; + sResDepInfo.iDependencyPriority = 3; + depResArray.Append(sResDepInfo); + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 3, &depResArray[0]); + + depResArray[0].iResourceId = dynamicDepResId[0]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[2], 1, &depResArray[0]); + + // Check if the priority for a new dependency is already existing. + //Create dependency between J and K + info1.iResourceId = dynamicDepResId[2]; + info1.iDependencyPriority = 1; + + info2.iResourceId = dynamicDepResId[3]; + info2.iDependencyPriority = 1; + + //Register dependency between resource J and K + r = lddChan.RegisterResourceDependency(Clients[0].iClientId, info1, info2); + test(r == KErrAlreadyExists); + + //Create depedency between J and K + info1.iResourceId = dynamicDepResId[2]; + info1.iDependencyPriority = 1; + + info2.iResourceId = dynamicDepResId[3]; + info2.iDependencyPriority = 2; + + //Register dependency between resource J and K + r = lddChan.RegisterResourceDependency(Clients[0].iClientId, info1, info2); + test(r == KErrNone); + + depResArray[0].iResourceId = dynamicDepResId[2]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[3], 1, &depResArray[0]); + + depResArray[0].iResourceId = dynamicDepResId[0]; + depResArray[0].iDependencyPriority = 1; + depResArray[1].iResourceId = dynamicDepResId[3]; + depResArray[1].iDependencyPriority = 2; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[2], 2, &depResArray[0]); + + RmTest.RegisterClient(); /* Client5 registration */ + //Change H to 85 + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, dynamicDepResId[0], 85); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], -50, Clients[1].iClientId, EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[1], -11, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 71, dynamicDepResId[0]); + GetExtendedResStateAndVerify(dynamicDepResId[0], 85, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 1, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 18, dynamicDepResId[0], EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[3], 1, dynamicDepResId[2]); + + //Check notifications + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[0], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[1], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[2], 1, 0); + test(r == KErrNone); + + //Change K to 1 + state= 1; + lddChan.ChangeResourceStateAsync(Clients[2].iClientId, dynamicDepResId[3], state, req); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 18, dynamicDepResId[0], EFalse); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[3], 1, Clients[2].iClientId, EFalse); + + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[2], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[3], 0, 0); + test(r == KErrNone); + + //Change J to 12 + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, dynamicDepResId[2],12); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 12, Clients[2].iClientId, EFalse); + + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[0], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[2], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[3], 0, 0); + test(r == KErrNone); + + //Change H to 90 + TRequestStatus reqSet; + state = 90; + lddChan.CheckParallelExecutionForChangeResState(Clients[2].iClientId, + dynamicDepResId[0],state, + 5, 0, reqSet); + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], -50, Clients[1].iClientId, EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[1], -11, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 69, dynamicDepResId[0]); + GetExtendedResStateAndVerify(dynamicDepResId[0], 90, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 1, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 11, dynamicDepResId[0], EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[3], 1, Clients[2].iClientId); + + //Check notifications + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[0], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[1], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[2], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[3], 0, 0); + test(r == KErrNone); + + state = 9; + lddChan.ChangeResourceStateAsync(Clients[1].iClientId, dynamicDepResId[2], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + GetExtendedResStateAndVerify(dynamicDepResId[0], 90, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 1, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 9, Clients[1].iClientId, EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[3], 1, Clients[2].iClientId); + + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[0], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[1], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[2], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[3], 0, 0); + test(r == KErrNone); + + //Change D to 50 + state = 50; + lddChan.ChangeResourceStateAsync(Clients[1].iClientId, iStaticDependencyResources[0], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId, EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -12, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[3], 16, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[5], 67, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[0], 90, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 1, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 9, Clients[1].iClientId, EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[3], 1, Clients[2].iClientId); + + //Check notifications + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + //DeRegister dependency between J and K + r = lddChan.DeRegisterResourceDependency(Clients[0].iClientId, dynamicDepResId[3], dynamicDepResId[2]); + test(r == KErrNone); + + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[3], 0, &depResArray[0]); + + depResArray[0].iResourceId = dynamicDepResId[0]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[2], 1, &depResArray[0]); + + //Change J t0 13 + r = lddChan.ChangeResourceStateSync(Clients[1].iClientId, dynamicDepResId[2], 13); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId, EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -12, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[3], 16, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[5], 67, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[0], 90, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 1, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 12, Clients[2].iClientId, EFalse); + GetExtendedResStateAndVerify(dynamicDepResId[3], 1, Clients[2].iClientId); + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[2], 1, 0); + test(r == KErrNone); + /* Remove client level from resource 7 */ + r = lddChan.DeRegisterClientLevelFromResource(Clients[2].iClientId, dynamicDepResId[3]); + test(r == KErrNone); + + GetExtendedResStateAndVerify(dynamicDepResId[3], 0, -1); + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[3], 1, 0); + test(r == KErrNone); + + r = lddChan.DeRegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[3], NULL); + test(r == KErrNone); + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[3], 1, 0); + test(r == KErrNone); + + //Deregister dependency between H and J + r = lddChan.DeRegisterResourceDependency(Clients[0].iClientId, dynamicDepResId[2], dynamicDepResId[0]); + test(r == KErrNone); + + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[2], 0, &depResArray[0]); + + depResArray[0].iResourceId = dynamicDepResId[1]; + depResArray[0].iDependencyPriority = 1; + depResArray[1].iResourceId = iStaticDependencyResources[5]; + depResArray[1].iDependencyPriority = 3; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 2, &depResArray[0]); + + /* Remove client level from resource 7 */ + r = lddChan.DeRegisterClientLevelFromResource(Clients[1].iClientId, dynamicDepResId[2]); + test(r == KErrNone); + + GetExtendedResStateAndVerify(dynamicDepResId[2], 12, Clients[2].iClientId); + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[2], 0, 0); + test(r == KErrNone); + + r = lddChan.DeRegisterClient(Clients[2].iClientId); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicDepResId[2], 19, -1, EFalse); + + //Deregister dependency between G and H + r = lddChan.DeRegisterResourceDependency(Clients[1].iClientId, iStaticDependencyResources[5], dynamicDepResId[0]); + test(r == KErrNone); + + depResArray[0].iResourceId = dynamicDepResId[1]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 1, &depResArray[0]); + + depResArray[0].iResourceId = iStaticDependencyResources[3]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[5], 1, &depResArray[0]); + + GetExtendedResStateAndVerify(dynamicDepResId[0], 75, -1); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 0, dynamicDepResId[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[5], 67, iStaticDependencyResources[3], EFalse); + + //Deregister dependency between I and H + r = lddChan.DeRegisterResourceDependency(Clients[1].iClientId, dynamicDepResId[1], dynamicDepResId[0]); + test(r == KErrNone); + + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[0], 0, &depResArray[0]); + + RmTest.CheckForDependencyInformation(Clients[0].iClientId, dynamicDepResId[1], 0, &depResArray[0]); + + GetExtendedResStateAndVerify(dynamicDepResId[0], 75, -1); + GetExtendedResStateAsyncAndVerify(dynamicDepResId[1], 0, -1); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[5], 67, iStaticDependencyResources[3], EFalse); + //Check notifications + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 0, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(dynamicDepResId[1], 1, 0); + test(r == KErrNone); + + r = lddChan.DeRegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[2], NULL); + test(r == KErrNone); + r = lddChan.DeRegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[1], NULL); + test(r == KErrNone); + //Check notifications + r = lddChan.CheckNotifications(dynamicDepResId[1], 1, 0); + test(r == KErrNone); + r = lddChan.DeRegisterDynamicResource(Clients[0].iClientId, dynamicDepResId[0], NULL); + test(r == KErrNone); + r = lddChan.DeRegisterClient(Clients[1].iClientId); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[0], -100, -1, EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -10, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 0, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[3], 10, iStaticDependencyResources[0], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 1, iStaticDependencyResources[3], EFalse); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[5], 75, iStaticDependencyResources[3], EFalse); + r = lddChan.DeRegisterClient(Clients[3].iClientId); + test(r == KErrNone); + + r = lddChan.DeRegisterClient(Clients[0].iClientId); + test(r == KErrNone); + + r = lddChan.DeRegisterClient(Clients[4].iClientId); + test(r == KErrNone); + + depResArray.Close(); + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0596 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests dynamic resources which does not support dependency +//! @SYMTestActions 0 Register clients +//! 1 Register dynamic resource +//! 2 Register notifications +//! 3 Change Resource State of each static resource with dependency +//! 4 Get state of the resource and check for correctness +//! 5 Check notification count for correctness +//! 6 Deregister client level +//! 7 Deregister dynamic resource +//! 8 Deregister clients +//! +//! @SYMTestExpectedResults 0 API should return with KErrNone, panics otherwise. +//! 1 API should return with KErrNone, panics otherwise. +//! 2 API should return with KErrNone, panics otherwise. +//! 3 API should return with KErrNone, panics otherwise. +//! 4 API should return with KErrNone, panics otherwise. +//! 5 API should return with KErrNone, panics otherwise. +//! 6 API should return with KErrNone, panics otherwise. +//! 7 API should return with KErrNone, panics otherwise. +//! 8 API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::TestDynamicResource() + { + TInt state; + TRequestStatus req; + TUint dynamicResId[4]; + + test.Next(_L("Testing dynamic resource")); + //Register client 1 + RmTest.RegisterClient(); + //Register client 2 + RmTest.RegisterClient(); + //Register client 3 + RmTest.RegisterClient(); + + NegativeTesting = EFalse; + dynamicResId[0] = 1; + //Register dynamic resource 1 + r = lddChan.RegisterDynamicResource(Clients[0].iClientId, dynamicResId[0]); + test(r == KErrNone); + //Deregister dynamic resource with different client id + r = lddChan.DeRegisterDynamicResource(Clients[1].iClientId, dynamicResId[0], NULL); + test(r == KErrAccessDenied); + dynamicResId[1] = 2; + //Register dynamic resource 2 + r = lddChan.RegisterDynamicResource(Clients[1].iClientId, dynamicResId[1]); + test(r == KErrNone); + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, iMaxStaticResources); + + TUint numClients; + r = lddChan.GetNumClientsUsingResource(Clients[0].iClientId, dynamicResId[0], numClients); + test(r == KErrNone); + test(numClients == 0); + + r = lddChan.RequestNotification(Clients[1].iClientId, dynamicResId[0]); + test(r == KErrNone); + //Register client 4 + RmTest.RegisterClient(); + r = lddChan.RequestNotification(Clients[2].iClientId, dynamicResId[0], 1, 1); + test(r == KErrNone); + //Change state of dynamic resource 1 and verify + state = 1; + lddChan.ChangeResourceStateAsync(Clients[0].iClientId, dynamicResId[0], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[0], 1, 1); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[0], 1, Clients[0].iClientId, EFalse); + + r = lddChan.GetNumClientsUsingResource(Clients[0].iClientId, dynamicResId[0], numClients); + test(r == KErrNone); + test(numClients == 1); + //Change state of dynamic resource 1. + r = lddChan.ChangeResourceStateSync(Clients[1].iClientId, dynamicResId[0], 0); + test(r == KErrAccessDenied); + //Deregister dynamic resource 1 and set the resource to 1. + state = 1; + r = lddChan.DeRegisterDynamicResource(Clients[0].iClientId, dynamicResId[0], &state); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[0], 1, 1); + test(r == KErrNone); + + r = lddChan.GetNumClientsUsingResource(Clients[0].iClientId, dynamicResId[0], numClients); + test(r == KErrNotFound); + //Register client 5 + RmTest.RegisterClient(); + + GetExtendedResStateAndVerify(dynamicResId[1], -5, -1); + + r = lddChan.RequestNotification(Clients[1].iClientId, dynamicResId[1]); + test(r == KErrNone); + + r = lddChan.RequestNotification(Clients[2].iClientId, dynamicResId[1], 0, -8); + test(r == KErrNone); + //Change state of dynamic resource 1 and verify + state = -7; + lddChan.ChangeResourceStateAsync(Clients[2].iClientId, dynamicResId[1], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(dynamicResId[1], -7, Clients[2].iClientId); + //Register client 6 + RmTest.RegisterClient(); + //Register client 7 + RmTest.RegisterClient(); + //Change state of dynamic resource 2 and verify + state = -9; + lddChan.ChangeResourceStateAsync(Clients[3].iClientId, dynamicResId[1], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 1); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -9, Clients[3].iClientId, EFalse); + //Change state of dynamic resource 1 and verify + state = -10; + lddChan.ChangeResourceStateAsync(Clients[4].iClientId, dynamicResId[1], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -10, Clients[4].iClientId, EFalse); + + lddChan.ChangeResourceStateSync(Clients[5].iClientId, dynamicResId[1], state); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -10, Clients[4].iClientId, EFalse); + //Change state of dynamic resource 1 and verify + state = -6; + lddChan.ChangeResourceStateSync(Clients[6].iClientId, dynamicResId[1], state); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -10, Clients[4].iClientId, EFalse); + + r = lddChan.DeRegisterClientLevelFromResource(Clients[4].iClientId, dynamicResId[1]); + test(r == KErrNone); + + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -10, Clients[5].iClientId, EFalse); + + r = lddChan.DeRegisterClientLevelFromResource(Clients[5].iClientId, dynamicResId[1]); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -9, Clients[3].iClientId, EFalse); + //Deregister client 4 + r = lddChan.DeRegisterClient(Clients[3].iClientId); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -7, Clients[2].iClientId, EFalse); + + r = lddChan.DeRegisterClientLevelFromResource(Clients[2].iClientId, dynamicResId[1]); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -6, Clients[6].iClientId, EFalse); + + r = lddChan.DeRegisterClientLevelFromResource(Clients[6].iClientId, dynamicResId[1]); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(dynamicResId[1], -5, -1, EFalse); + //Deregister dynamic resource 2 + r = lddChan.DeRegisterDynamicResource(Clients[1].iClientId, dynamicResId[1], NULL); + test(r == KErrNone); + + r = lddChan.CheckNotifications(dynamicResId[1], 1, 1); + test(r == KErrNone); + //Register dynamic resource 3 + dynamicResId[2] = 3; + r = lddChan.RegisterDynamicResource(Clients[2].iClientId, dynamicResId[2]); + test(r == KErrNone); + //Register dynamic resource 4 + dynamicResId[3] = 4; + r = lddChan.RegisterDynamicResource(Clients[6].iClientId, dynamicResId[3]); + test(r == KErrNone); + //Change state of dynamic resource 3 to 0 + r = lddChan.ChangeResourceStateSync(Clients[4].iClientId, dynamicResId[2], 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(dynamicResId[2], 0, Clients[4].iClientId); + //Change state of dynamic resource 3 to 1 + r = lddChan.ChangeResourceStateSync(Clients[5].iClientId, dynamicResId[2], 1); + test(r == KErrNone); + GetExtendedResStateAndVerify(dynamicResId[2], 0, Clients[4].iClientId); + //Deregister client 5 + r = lddChan.DeRegisterClient(Clients[4].iClientId); + test(r == KErrNone); + GetExtendedResStateAndVerify(dynamicResId[2], 1, Clients[5].iClientId); + //Deregister dynamic resource 3 + r = lddChan.DeRegisterDynamicResource(Clients[2].iClientId, dynamicResId[2], NULL); + test(r == KErrInUse); + //Deregister client 6 + r = lddChan.DeRegisterClient(Clients[5].iClientId); + test(r == KErrNone); + GetExtendedResStateAndVerify(dynamicResId[2], 1, -1); + //Deregister dynamic resource 3 + r = lddChan.DeRegisterDynamicResource(Clients[2].iClientId, dynamicResId[2], NULL); + test(r == KErrNone); + //Change state of dynamic resource 4 to 15 + r = lddChan.ChangeResourceStateSync(Clients[6].iClientId, dynamicResId[3], 15); + test(r == KErrNone); + GetExtendedResStateAndVerify(dynamicResId[3], 15, Clients[6].iClientId); + //Change state of resource and try to deregister the resource while the change is taking place + state = 17; + lddChan.ChangeResStateAndDeRegisterDynamicRes(Clients[6].iClientId, dynamicResId[3], state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == 17); + GetExtendedResStateAndVerify(dynamicResId[3], 17, Clients[6].iClientId); + //Deregister dynamic resource 4 with some other client which is not owner + r = lddChan.DeRegisterDynamicResource(Clients[2].iClientId, dynamicResId[3], NULL); + test(r == KErrAccessDenied); + //Deregister dynamic resource 4 + r = lddChan.DeRegisterDynamicResource(Clients[6].iClientId, dynamicResId[3], NULL); + test(r == KErrNone); + //Deregister client 7 + r = lddChan.DeRegisterClient(Clients[6].iClientId); + test(r == KErrNone); + //Deregister client 3 + r = lddChan.DeRegisterClient(Clients[2].iClientId); + test(r == KErrNone); + //Deregister client 2 + r = lddChan.DeRegisterClient(Clients[1].iClientId); + test(r == KErrNone); + //Deregister client 1 + r = lddChan.DeRegisterClient(Clients[0].iClientId); + test(r == KErrNone); + Clients.Close(); + } + +//This function gets extended resource state synchronously and verifies for correctness +void TestRM::GetExtendedResStateAndVerify(TUint aResId, TInt aState, TInt aLevelOwnerId) + { + static TBool cached = ETrue; + TInt state; + TInt levelOwnerId; + r = lddChan.GetResourceStateSync(Clients[0].iClientId, aResId, cached, state, levelOwnerId); + test(r == KErrNone); + test(state == aState); + test(levelOwnerId == aLevelOwnerId); + return; + } + +//This function gets extended resource state asynchronously and verifies for correctness +void TestRM::GetExtendedResStateAsyncAndVerify(TUint aResId, TInt aState, TInt aLevelOwnerId, TBool aReqCancel) + { + static TBool cached = ETrue; + TRequestStatus resGet; + TInt levelOwnerId; + TInt state; + lddChan.GetResourceStateAsync(Clients[0].iClientId, aResId, cached, resGet, state, levelOwnerId, aReqCancel); + User::WaitForRequest(resGet); + if(aReqCancel && (resGet.Int() != KErrNone)) + { + test((resGet.Int() == KErrCompletion) || (resGet.Int() == KErrCancel)); + return; + } + test(resGet.Int() == KErrNone); + test(state == aState); + test(levelOwnerId == aLevelOwnerId); + } + +//This function validates number of dependency resource and their id's for correctness +void TestRM::CheckForDependencyInformation(TUint aClientId, TUint aResourceId, TUint aNumDependents, SResourceDependencyInfo* aDepResIdArray) + { + TUint numDepResources; + + //Get the number of dependent's for the resource + r = lddChan.GetNumDependentsForResource(aClientId, aResourceId, numDepResources); + if(r != KErrNone) + test.Printf(_L("GetNumDependentsForResource returned with %d\n"), r); + test(r == KErrNone); + if(aNumDependents != numDepResources) + test.Printf(_L("aNumDependents = %d, numDepResource = %d\n"), aNumDependents, numDepResources); + test(aNumDependents == numDepResources); + if(numDepResources == 0) + return; + //Get the dependent's id + RBuf8 info; + info.Create(aNumDependents * sizeof(SResourceDependencyInfo)); + r = lddChan.GetDependentsIdForResource(aClientId, aResourceId, (TAny*)&info, numDepResources); + if(r != KErrNone) + { + test.Printf(_L("GetDependentsIdForResource returned with %d\n"), r); + info.Close(); + } + test(r == KErrNone); + if(aNumDependents != numDepResources) + { + test.Printf(_L("aNumDependents = %d, numDepResource = %d\n"), aNumDependents, numDepResources); + info.Close(); + } + test(aNumDependents == numDepResources); + SResourceDependencyInfo* sResDepInfoPtr = (SResourceDependencyInfo*)info.Ptr(); + for(TUint count = 0; count < aNumDependents; count++, sResDepInfoPtr++) + { + if(sResDepInfoPtr->iResourceId != aDepResIdArray[count].iResourceId) + { + test.Printf(_L("Expected resourceId : %d, Returned ResourceId = %d\n"),sResDepInfoPtr->iResourceId, + aDepResIdArray[count].iResourceId); + info.Close(); + test(0); + } + if(sResDepInfoPtr->iDependencyPriority != aDepResIdArray[count].iDependencyPriority) + { + test.Printf(_L("Expected resource priority : %d, Returned resource priority = %d\n"),sResDepInfoPtr->iDependencyPriority, + aDepResIdArray[count].iDependencyPriority); + info.Close(); + test(0); + } + } + info.Close(); + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0595 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests static resources with dependency. +//! @SYMTestActions 0 Register clients +//! 1 Check dependency information of each resource +//! 2 Register notifications +//! 3 Change Resource State of each static resource with dependency +//! 4 Get state of the resources and verify them for correctness +//! 5 Check notification count for correctness +//! 6 Deregister client level +//! 7 Deregister clients +//! +//! @SYMTestExpectedResults 0 API should return with KErrNone, panics otherwise. +//! 1 API should return with KErrNone, panics otherwise. +//! 2 API should return with KErrNone, panics otherwise. +//! 3 API should return with KErrNone, panics otherwise. +//! 4 API should return with KErrNone, panics otherwise. +//! 5 API should return with KErrNone, panics otherwise. +//! 6 API should return with KErrNone, panics otherwise. +//! 7 API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::TestStaticResourceWithDependency() + { + TUint count; + RArraydepResArray; + SResourceDependencyInfo sResDepInfo; + TUint numClients; // The maximum no. of dependents in the dependency tree. + + + //Register client 1. + RmTest.RegisterClient(); + iCurrentClientId = -1; + TInt state; + TRequestStatus reqSet; + + NegativeTesting = EFalse; + test.Next(_L("\nTesting static resource with dependency....")); + + //Check for resource dependency information of Resource D + sResDepInfo.iResourceId = iStaticDependencyResources[1]; + sResDepInfo.iDependencyPriority = 1; + depResArray.Append(sResDepInfo); + sResDepInfo.iResourceId = iStaticDependencyResources[3]; + sResDepInfo.iDependencyPriority = 2; + depResArray.Append(sResDepInfo); + sResDepInfo.iResourceId = iStaticDependencyResources[2]; + sResDepInfo.iDependencyPriority = 3; + depResArray.Append(sResDepInfo); + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[0], 3, &depResArray[0]); + + //Check for resource dependency information of Resource E + depResArray[0].iResourceId = iStaticDependencyResources[4]; + depResArray[0].iDependencyPriority = 1; + depResArray[1].iResourceId = iStaticDependencyResources[5]; + depResArray[1].iDependencyPriority = 2; + depResArray[2].iResourceId = iStaticDependencyResources[0]; + depResArray[2].iDependencyPriority = 3; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[3], 3, &depResArray[0]); + + //Check for resource dependency information of Resource C + depResArray[0].iResourceId = iStaticDependencyResources[3]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[4], 1, &depResArray[0]); + + //Check for resource dependency information of Resource G + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[5], 1, &depResArray[0]); + + //Check for resource dependency information of Resource F + depResArray[0].iResourceId = iStaticDependencyResources[0]; + depResArray[0].iDependencyPriority = 1; + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[2], 1, &depResArray[0]); + + //Check for resource dependency information of Resource A + RmTest.CheckForDependencyInformation(Clients[0].iClientId, iStaticDependencyResources[1], 1, &depResArray[0]); + + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, iMaxStaticResources + iMaxStaticDependentResources); + iCurrentClientId = 0; + //Get resource state of all dependent resource and verify + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -50, -1); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -11, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[3], 13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 73, iStaticDependencyResources[3]); + + r = lddChan.GetNumClientsUsingResource(Clients[0].iClientId, iStaticDependencyResources[3], numClients); + test(r == KErrNone); + test(numClients == 0); + //Request notification + for(count = 0; count < iMaxStaticDependentResources; count++) + { + r = lddChan.RequestNotification(Clients[0].iClientId, iStaticDependencyResources[count]); + test(r == KErrNone); + } + //Change state of resource A to -11 and verify + r = lddChan.ChangeResourceStateSync(Clients[0].iClientId, iStaticDependencyResources[1], -11); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -11, Clients[0].iClientId); + //Change state of resource A to -12 and verify + state = -12; + lddChan.ChangeResourceStateAsync(Clients[0].iClientId, iStaticDependencyResources[1], state, reqSet); + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[1], 1, 0); + test(r == KErrNone); + //Register client2 + RmTest.RegisterClient(); + //Change state of resource D to -49 and verify + state = -49; + lddChan.ChangeResourceStateAsync(Clients[1].iClientId, iStaticDependencyResources[0], state, reqSet); + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + //Check for notifications + r = lddChan.CheckNotifications(iStaticDependencyResources[0], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[1], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[3], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + //Get the state and verify for correctness + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 16, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 71, iStaticDependencyResources[3]); + //Change state of resource F to 1 and verify + r = lddChan.ChangeResourceStateSync(Clients[1].iClientId, iStaticDependencyResources[2], 1); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[2], 0, 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + //Register client 3 + RmTest.RegisterClient(); + //Change state of resource E to 19 and verify + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, iStaticDependencyResources[3], 19); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[3], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 19, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 69, iStaticDependencyResources[3]); + //Register client 4 + RmTest.RegisterClient(); + //Change state of resource C to 0 and verify + r = lddChan.ChangeResourceStateSync(Clients[3].iClientId, iStaticDependencyResources[4], 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[4], 0, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + //Change state of resource C to 1 and verify + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, iStaticDependencyResources[4], 1); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[4], 0, 0); + test(r == KErrNone); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + //Change state of resource G to 67 and verify + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, iStaticDependencyResources[5], 67); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 19, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 67, Clients[2].iClientId); + //Change state of resource G to 67 and verify + r = lddChan.ChangeResourceStateSync(Clients[3].iClientId, iStaticDependencyResources[5], 67); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 0, 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 19, Clients[2].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 67, Clients[2].iClientId); + + //Change the state of the resource E to 24 + state = 24; + //Register client 5 + RmTest.RegisterClient(); + lddChan.ChangeResourceStateAsync(Clients[4].iClientId, iStaticDependencyResources[3], state, reqSet); + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[3], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 24, Clients[4].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 65, iStaticDependencyResources[3]); + + //Change resource state of Resource D to -51 + r = lddChan.ChangeResourceStateSync(Clients[2].iClientId, iStaticDependencyResources[0], -51); + test(r == KErrAccessDenied); + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -49, Clients[1].iClientId); + + //DeregisterClient 5 + r = lddChan.DeRegisterClient(Clients[4].iClientId); + test(r == KErrNone); + + r = lddChan.CheckNotifications(iStaticDependencyResources[3], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 19, Clients[2].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 63, iStaticDependencyResources[3]); + + //Change resource state of resource D to 50 + state = 50; + lddChan.ChangeResourceStateAsync(Clients[1].iClientId, iStaticDependencyResources[0], state, reqSet); + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[0], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[1], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[3], 1, 0); + test(r == KErrNone); + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 1, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Change resource state of resource G to 61 + r = lddChan.ChangeResourceStateSync(Clients[3].iClientId, iStaticDependencyResources[5], 61); + test(r == KErrNone); + + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Deregister client 4; + r = lddChan.DeRegisterClient(Clients[3].iClientId); + test(r == KErrNone); + + r = lddChan.CheckNotifications(iStaticDependencyResources[5], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Deregister client 3. + r = lddChan.DeRegisterClient(Clients[2].iClientId); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Deregister client 0 from Resource A + r = lddChan.DeRegisterClientLevelFromResource(Clients[0].iClientId, iStaticDependencyResources[1]); + test(r == KErrNone); + + r = lddChan.CheckNotifications(iStaticDependencyResources[1], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, Clients[1].iClientId); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Move Resource D to default + r = lddChan.ChangeResourceStateSync(Clients[1].iClientId, iStaticDependencyResources[0], -100); + test(r == KErrPermissionDenied); + + //Deregister client 1 from Resource F + r = lddChan.DeRegisterClientLevelFromResource(Clients[1].iClientId, iStaticDependencyResources[2]); + test(r == KErrNone); + + r = lddChan.CheckNotifications(iStaticDependencyResources[1], 0, 0); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -14, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 22, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 61, iStaticDependencyResources[3]); + + //Deregister client 2 + r = lddChan.DeRegisterClient(Clients[1].iClientId); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -100, -1); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -10, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 0, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 10, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 1, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 75, iStaticDependencyResources[3]); + //Deregister client 1 + r = lddChan.DeRegisterClient(Clients[0].iClientId); + test(r == KErrNone); + Clients.Close(); //Close the array and release memory + + //Test parallel execution of RC and Dependency resource DFC's + //Register client 1 + RmTest.RegisterClient(); + //Register client 2 + RmTest.RegisterClient(); + + state = 50; + /* CheckParallelExecutionForResChageStateWithDependency */ + lddChan.CheckParallelExecutionForChangeResState(Clients[1].iClientId, + iStaticDependencyResources[0],state,5,0,reqSet); + + User::WaitForRequest(reqSet); + test(reqSet.Int() == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], 50, Clients[1].iClientId); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -11, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[2], 1, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[3], 13, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 0, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 73, iStaticDependencyResources[3]); + + TInt owner; + TBool cached = ETrue; + r = lddChan.GetResourceStateSync(Clients[1].iClientId, 4, cached, state, owner); + test(r == KErrNone); + test(state == 75); + test(owner == -1); + + r = lddChan.DeRegisterClient(Clients[1].iClientId); + test(r == KErrNone); + + GetExtendedResStateAndVerify(iStaticDependencyResources[0], -100, -1); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[1], -10, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[2], 0, iStaticDependencyResources[0]); + GetExtendedResStateAndVerify(iStaticDependencyResources[3], 10, iStaticDependencyResources[0]); + GetExtendedResStateAsyncAndVerify(iStaticDependencyResources[4], 1, iStaticDependencyResources[3]); + GetExtendedResStateAndVerify(iStaticDependencyResources[5], 75, iStaticDependencyResources[3]); + + r = lddChan.GetResourceStateSync(Clients[0].iClientId, 4, cached, state, owner); + test(r == KErrNone); + test(state == 75); + test(owner == -1); + + r = lddChan.DeRegisterClient(Clients[0].iClientId); + test(r == KErrNone); + + Clients.Close(); //Close the array and release memory + depResArray.Close(); //Close the array and release memory + } +#endif + +//This function validates each of the resource manager API's +void TestRM::APIValidationTest() + { + test.Next(_L("\nStarting API validation Test....")); + RmTest.RegisterClient(); + r = lddChan.GetResourceControllerVersion(Clients[0].iClientId, iTestingExtendedVersion); + test(r == KErrNone); + if(!iTestingExtendedVersion) + test.Printf(_L("Testing Basic Version only....")); + else + test.Printf(_L("Testing basic & extended version....")); + RmTest.ValidateClient(5, EOwnerProcess); + iCurrentClientId = -1; + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, iMaxStaticResources); + iCurrentClientId = 0; + NegativeTesting = ETrue; + if(Resources[0].iName.Compare(*(const TDesC8*)&SpecialResName)) + { + test.Printf(_L("Test runs only on simulated PSL\n")); + RmTest.DeRegisterClient(Clients[0].iClientId); + return; + } + TBuf8<32> PowerController = _L8("PowerController"); + r = lddChan.GetClientId(Clients[0].iClientId, (TDesC8&)PowerController, iPowerControllerId); + test(r == KErrNone); + r = lddChan.RegisterForIdleResourcesInfo(iPowerControllerId, 15); + test(r == KErrNone); + RmTest.GetClientName(iCurrentClientId); + RmTest.GetClientId(iCurrentClientId); + RmTest.GetResourceId(2); + RmTest.GetResourceInfo(19); + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, 3); + RmTest.GetNumClientsUsingResource(iCurrentClientId, (TUint)-1); + RmTest.GetNumClientsUsingResource(iCurrentClientId, 10); + RmTest.GetInfoOnClientsUsingResource((TUint)-1, 4); + RmTest.GetInfoOnClientsUsingResource(5, 3); + + TUint c; + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + RmTest.GetResourceStateAsync(c, ETrue); + } + User::After(2000000); //Add delay to make sure that the asynchronous request is processed in controller thread + + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + iCurrentClientId = c; + RmTest.RegisterClient(); + RmTest.AllocReserve(c); + RmTest.GetResourceStateAsync(c); + RmTest.RequestNotification(c); + RmTest.RequestNotificationCon(c); + } + + for(c=0; c< iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + iCurrentClientId = c; + RmTest.ChangeResourceStateAsync(c); + RmTest.GetResourceStateAsync(c); + RmTest.GetResourceStateSync(c); + RmTest.ChangeResourceStateSync(c); + } + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + iCurrentClientId = c; + RmTest.GetClientName(c); + RmTest.GetClientId(c); + RmTest.GetResourceId(c); + RmTest.GetResourceInfo(c); + RmTest.GetNumResourcesInUseByClient(c); + RmTest.GetInfoOnResourcesInUseByClient(c, Clients[c].iNumResources); + RmTest.GetNumClientsUsingResource(c, c); + RmTest.GetInfoOnClientsUsingResource(c, Resources[c].iNumClients); + RmTest.CancelNotification(c, ETrue); + RmTest.CancelNotification(c, EFalse); + } + + TInt clientCount = Clients.Count(); + for(c = clientCount-1; ((TInt)c) >=0; c--) + { + test.Printf(_L("DeRegister ClientId %d\n"), Clients[c].iClientId); + RmTest.DeRegisterClient(c); + } + Clients.Close(); + //Find any shared binary resource + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + if((Resources[c].iUsage == EShared) && (Resources[c].iSense == ENegative)) + { + if(Resources[c].iType == 0x0) //Binary Resource + RmTest.SharedBinaryNegativeResourceTesting(c); + else + RmTest.SharedMultilevelNegativeResourceTesting(c); + } + else if((Resources[c].iUsage == EShared) && (Resources[c].iSense == EPositive)) + { + if(Resources[c].iType == 0x0) //Binary Resource + RmTest.SharedBinaryPositiveResourceTesting(c); + else + RmTest.SharedMultilevelPositiveResourceTesting(c); + } + } + + RmTest.CustomResourceTesting(CUSTOM_RESOURCE_NUMBER); + + //Testing of Deregistration of client level for binary resource + RmTest.RegisterClient(); + for(c = 0; c < iMaxStaticResources; c++) + { + if(Resources[c].iSense == ECustom) + continue; + RmTest.DeRegisterClientLevelFromResource(-1, c); + } + for(c = 0; c < iMaxStaticResources; c++) + { + iCurrentClientId = 0; + RmTest.ChangeResourceStateSync(c); + RmTest.DeRegisterClientLevelFromResource(0, c); + } + RmTest.RegisterClient(); + for(c = 0; c < iMaxStaticResources; c++) //Test valid only for shared resources. + { + if((Resources[c].iSense == ECustom) || (Resources[c].iUsage == ESingle)) + continue; + iCurrentClientId = 0; + RmTest.ChangeResourceStateSync(c); + iCurrentClientId = 1; + RmTest.ChangeResourceStateSync(c); + if(Resources[c].iCurrentClient == 0) + { + RmTest.DeRegisterClientLevelFromResource(0, c); + RmTest.DeRegisterClientLevelFromResource(1, c); + } + else + { + RmTest.DeRegisterClientLevelFromResource(1, c); + RmTest.DeRegisterClientLevelFromResource(0, c); + } + } + //Testing of Deregistration of client level for shared resource + for(c = 0; c < iMaxStaticResources; c++) + { + if((Resources[c].iSense == ECustom) || (!Resources[c].iUsage)) + continue; + RmTest.DeRegisterClientLevelFromResource(-1, c); + } + + RmTest.DeRegisterClient(1); + RmTest.DeRegisterClient(0); + RBuf8 info; + info.Create(15 * sizeof(SIdleResourceInfo)); + r = lddChan.GetIdleResourcesInfo(15, (TAny*)(TDes8*)&info); + test(r == KErrNone); + SIdleResourceInfo* pI = (SIdleResourceInfo*)info.Ptr(); + for(c = 0; c< 15; c++) + { + test(Resources[c].iCurrentClient == pI->iLevelOwnerId); + test(Resources[c].iCurrentLevel == pI->iCurrentLevel); + test(Resources[c].iResourceId == pI->iResourceId); + pI++; + } + info.Close(); + Clients.Close(); +#ifdef PRM_ENABLE_EXTENDED_VERSION + if(iTestingExtendedVersion) + { + TestStaticResourceWithDependency(); + TestDynamicResource(); + TestDynamicResourceDependency(); + } +#endif + Clients.Close(); + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0592 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests deregistration of client level functionality. +//! @SYMTestActions 0 Register client +//! 1 Change Resource State +//! 2 Deregister client level +//! 3 Deregister client +//! +//! @SYMTestExpectedResults 0 API should return with KErrNone, panics otherwise. +//! 1 API should return with KErrNone, panics otherwise. +//! 2 API should return with KErrNone, panics otherwise. +//! 3 API should return with KErrNone, panics otherwise. +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::DeRegisterClientLevelFromResource(TInt aClientId, TUint aResId) + { + TInt state; + TInt newState; + TInt levelOwnerId; + r = lddChan.GetResourceStateSync(Clients[0].iClientId, Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + if((levelOwnerId != -1) && (levelOwnerId != (TInt)Clients[aClientId].iClientId)) + { + test.Printf(_L("Client Id does not match so not testing Deregistration of client level\n")); + return; + } + if(Resources[aResId].iUsage == ESingle) //Single user resource + { + if(levelOwnerId == -1) + { + TUint ClientId; + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId, (const TDesC*)&ClientName); + test(r == KErrNone); + newState = Resources[aResId].iMaxLevel; + r = lddChan.ChangeResourceStateSync(ClientId, Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId, Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(state == newState); + test(levelOwnerId == (TInt)ClientId); + r = lddChan.DeRegisterClientLevelFromResource(ClientId, Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId, Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + r = lddChan.DeRegisterClient(ClientId); + test(r == KErrNone); + return; + } + r = lddChan.DeRegisterClientLevelFromResource(Clients[aClientId].iClientId, Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(Clients[aClientId].iClientId, Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + //Update the local + Resources[aResId].iCurrentClient = -1; + Resources[aResId].iCurrentLevel = state; + Resources[aResId].iNumClients = 0; + delete Resources[aResId].iLevel; + Resources[aResId].iLevel = NULL; + return; + } + //Handle for Shared resources + if(levelOwnerId == -1) + { + TUint ClientId[2]; + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId+2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + newState = Resources[aResId].iMinLevel; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == (TInt)ClientId[0]); + r = lddChan.ChangeResourceStateSync(ClientId[1], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.DeRegisterClientLevelFromResource(ClientId[0], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == (TInt)ClientId[1]); + r = lddChan.DeRegisterClientLevelFromResource(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + return; + } + r = lddChan.DeRegisterClientLevelFromResource(Clients[aClientId].iClientId, Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(Clients[aClientId].iClientId, Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId != (TInt)Clients[aClientId].iClientId); + if(Resources[aResId].iNumClients == 1) + { + Resources[aResId].iNumClients--; + Resources[aResId].iCurrentClient = -1; + r = lddChan.GetResourceStateSync(Clients[aClientId].iClientId, Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + Resources[aResId].iCurrentLevel = state; + delete Resources[aResId].iLevel; + Resources[aResId].iLevel = NULL; + } + else + { + Resources[aResId].iNumClients--; + SPowerResourceClientLevel *pCL = NULL; + TInt level = KMinTInt; + TInt clientId = 0; + for(SPowerResourceClientLevel* pL = Resources[aResId].iLevel; pL != NULL; pL = pL->iNextInList) + { + if(pL->iClientId == Clients[aClientId].iClientId) + { + pCL = pL; + continue; + } + if(level == KMinTInt) + { + level = pL->iLevel; + clientId = pL->iClientId; + continue; + } + if(((Resources[aResId].iSense == EPositive) && (pL->iLevel > level)) || ((Resources[aResId].iSense == ENegative) && (pL->iLevel < level))) + { + level = pL->iLevel; + clientId = pL->iClientId; + } + } + delete pCL; + Resources[aResId].iCurrentClient = clientId; + Resources[aResId].iCurrentLevel = level; + } + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0593 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests changing resource state of shared positive resource. +//! @SYMTestActions 0 Register client1 +//! 1 Register client2 +//! 2 Register client3 +//! 3 Register client4 +//! 4 Client1 change resource state. +//! 5 Client2 change resource state. +//! 6 Client3 change resource state. +//! 7 Client4 change resource state. +//! 8 Client1 change resource state. +//! 9 Client2 change resource state. +//! 10 Deregister client2 +//! 11 Client3 change resource state. +//! 12 Deregister client1 +//! 13 Deregister client3 +//! 14 Deregister client4 +//! +//! @SYMTestExpectedResults 0 Client registered +//! 1 Client registered +//! 2 Client registered +//! 3 Client registered +//! 4 Resource state changed +//! 5 Resource state changed +//! 6 Resource state changed +//! 7 Resource state changed +//! 8 Resource state changed +//! 9 Resource state changed +//! 10 Client2 deregistered +//! 11 Resource state changed +//! 12 Client1 deregistered +//! 13 Client3 deregistered +//! 14 Client4 deregistered +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::SharedBinaryPositiveResourceTesting(TUint aResId) + { + TInt newState, levelOwnerId; + TRequestStatus req; + TUint ClientId[5]; + + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + if(levelOwnerId != -1) + { + test.Printf(_L("Not testing the shared resource as some other client is currently holding the resource\n")); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + return; + } + + ClientName[6] = (TUint8)('0' + iMaxClientId +2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +3); + r = lddChan.RegisterClient(ClientId[2], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +4); + r = lddChan.RegisterClient(ClientId[3], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +5); + r = lddChan.RegisterClient(ClientId[4], (const TDesC*)&ClientName); + test(r == KErrNone); + + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[2], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[3], Resources[aResId].iResourceId, 1, ETrue); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[2], Resources[aResId].iResourceId, 0, EFalse); + test(r == KErrNone); + newState = !newState; //State 0 + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 2, 1); + test(r == KErrNone); + newState = !newState; //State 1 + r = lddChan.ChangeResourceStateSync(ClientId[1], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 2, 1); + test(r == KErrNone); + lddChan.ChangeResourceStateAsync(ClientId[2], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); //State 1 + test(req.Int() == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + newState = !newState; //State 0 + r = lddChan.ChangeResourceStateSync(ClientId[3], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + newState = !newState; //state 1 + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + newState = !newState; //state 0 + r = lddChan.ChangeResourceStateSync(ClientId[1], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0,0); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + newState = 0; + r = lddChan.ChangeResourceStateSync(ClientId[2], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0,0); + test(r == KErrNone); + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 1,1); + test(r == KErrNone); + r = lddChan.CancelNotification(ClientId[2], Resources[aResId].iResourceId, EFalse); + test(r == KErrCancel); + r = lddChan.CancelNotification(ClientId[3], Resources[aResId].iResourceId, ETrue); + test(r == KErrCancel); + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.CancelNotification(ClientId[2], Resources[aResId].iResourceId, ETrue); + test(r == KErrCancel); + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[2]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[3]); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[4], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + r = lddChan.DeRegisterClient(ClientId[4]); + test(r == KErrNone); + return; + } + +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0594 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests changing resource state of shared negative resource. +//! @SYMTestActions 0 Register client1 +//! 1 Register client2 +//! 2 Register client3 +//! 3 Register client4 +//! 4 Client1 change resource state. +//! 5 Client2 change resource state. +//! 6 Client3 change resource state. +//! 7 Client4 change resource state. +//! 8 Client1 change resource state. +//! 9 Client2 change resource state. +//! 10 Deregister client2 +//! 11 Client3 change resource state. +//! 12 Deregister client1 +//! 13 Deregister client3 +//! 14 Deregister client4 +//! +//! @SYMTestExpectedResults 0 Client registered +//! 1 Client registered +//! 2 Client registered +//! 3 Client registered +//! 4 Resource state changed +//! 5 Resource state changed +//! 6 Resource state changed +//! 7 Resource state changed +//! 8 Resource state changed +//! 9 Resource state changed +//! 10 Client2 deregistered +//! 11 Resource state changed +//! 12 Client1 deregistered +//! 13 Client3 deregistered +//! 14 Client4 deregistered +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::SharedBinaryNegativeResourceTesting(TUint aResId) + { + TInt newState; + TInt levelOwnerId; + TRequestStatus req; + TUint ClientId[5]; + + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + if(levelOwnerId != -1) + { + test.Printf(_L("Not testing the shared resource as some other client is currently holding the resource\n")); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + return; + } + + ClientName[6] = (TUint8)('0' + iMaxClientId +2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +3); + r = lddChan.RegisterClient(ClientId[2], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +4); + r = lddChan.RegisterClient(ClientId[3], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +5); + r = lddChan.RegisterClient(ClientId[4], (const TDesC*)&ClientName); + test(r == KErrNone); + + newState = 0; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[2], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[3], Resources[aResId].iResourceId, 1, ETrue); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[2], Resources[aResId].iResourceId, 0, EFalse); + test(r == KErrNone); + newState = !newState; //State 1 + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 2, 1); + test(r == KErrNone); + newState = !newState; //State 0 + r = lddChan.ChangeResourceStateSync(ClientId[1], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 2, 1); + test(r == KErrNone); + lddChan.ChangeResourceStateAsync(ClientId[2], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); //State 0 + test(req.Int() == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + newState = !newState; //State 1 + r = lddChan.ChangeResourceStateSync(ClientId[3], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + newState = !newState; //state 0 + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + newState = !newState; //state 1 + r = lddChan.ChangeResourceStateSync(ClientId[1], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0,0); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[2], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0,0); + test(r == KErrNone); + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 1,1); + test(r == KErrNone); + r = lddChan.CancelNotification(ClientId[2], Resources[aResId].iResourceId, EFalse); + test(r == KErrCancel); + r = lddChan.CancelNotification(ClientId[3], Resources[aResId].iResourceId, ETrue); + test(r == KErrCancel); + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.CancelNotification(ClientId[2], Resources[aResId].iResourceId, ETrue); + test(r == KErrCancel); + newState = 1; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 0, 0); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[2]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[3]); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[4], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + r = lddChan.DeRegisterClient(ClientId[4]); + test(r == KErrNone); + return; + } + +//Test cases to test the shared multilevel negative resources +void TestRM::SharedMultilevelNegativeResourceTesting(TUint aResId) + { + TInt newState; + TInt levelOwnerId; + TRequestStatus req; + TUint ClientId[2]; + + //Register 1st client + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + if(levelOwnerId != -1) + { + test.Printf(_L("Not testing the shared resource as some other client is currently holding the resource\n")); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + return; + } + + test.Printf(_L("Testing %d Shared Multilevel Negative Resource\n"), Resources[aResId].iResourceId); + + //Register 2nd client + ClientName[6] = (TUint8)('0' + iMaxClientId+2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + + //Change the resource and ClientId[0] becomes the owner of the resource + newState = Resources[aResId].iMaxLevel + 10; + + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + + TInt state; + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(state == newState); + test(levelOwnerId = (TInt)ClientId[0]); + + //Second client(clientId[1]) trying to change the resource, but still + newState = state +5; + lddChan.ChangeResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + lddChan.GetResourceStateAsync(ClientId[0], Resources[aResId].iResourceId, EFalse, req, newState, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state = newState); + test(levelOwnerId == (TInt)ClientId[0]); + + newState = state + 10; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + newState = Resources[aResId].iMaxLevel + 15; + test(state == newState); + test(levelOwnerId == (TInt)ClientId[1]); + + r = lddChan.DeRegisterClientLevelFromResource(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + + state = Resources[aResId].iMaxLevel + 20; + lddChan.GetResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, ETrue, req, newState, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + test(levelOwnerId == (TInt)ClientId[0]); + + newState = Resources[aResId].iMaxLevel + 10; + lddChan.ChangeResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + + lddChan.GetResourceStateAsync(ClientId[0], Resources[aResId].iResourceId, EFalse, req, state, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + test(levelOwnerId == (TInt)ClientId[1]); + + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + + r = lddChan.DeRegisterClientLevelFromResource(ClientId[0], Resources[aResId].iResourceId); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + test(state == Resources[aResId].iDefaultLevel); + test(levelOwnerId == -1); + + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + + return; + } + +//Test cases to test the shared multilevel positive resources +void TestRM::SharedMultilevelPositiveResourceTesting(TUint aResId) + { + TInt newState; + TInt levelOwnerId; + TRequestStatus req; + TUint ClientId[2]; + + //Register 1st client + ClientName[6] = (TUint8)('0' + iMaxClientId+1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, newState, levelOwnerId); + test(r == KErrNone); + if(levelOwnerId != -1) + { + test.Printf(_L("Not testing the shared resource as some other client is currently holding the resource\n")); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + return; + } + + test.Printf(_L("Testing %d Shared Multilevel positive Resource\n"), Resources[aResId].iResourceId); + + //Register 2nd client + ClientName[6] = (TUint8)('0' + iMaxClientId+2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + + //Change the resource and ClientId[0] becomes the owner of the resource + newState = Resources[aResId].iMinLevel + 20; + + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + + TInt state; + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(state == newState); + test(levelOwnerId = (TInt)ClientId[0]); + + //Second client(clientId[1]) trying to change the resource, but still + newState = Resources[aResId].iMinLevel +10; + lddChan.ChangeResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + lddChan.GetResourceStateAsync(ClientId[0], Resources[aResId].iResourceId, EFalse, req, newState, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state = newState); + test(levelOwnerId == (TInt)ClientId[0]); + + newState = Resources[aResId].iMinLevel + 5; + r = lddChan.ChangeResourceStateSync(ClientId[0], Resources[aResId].iResourceId, newState); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + test(state == Resources[aResId].iMinLevel+10); + test(levelOwnerId == (TInt)ClientId[1]); + + r = lddChan.DeRegisterClientLevelFromResource(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + + newState = Resources[aResId].iMinLevel + 5; + lddChan.GetResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, ETrue, req, state, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + test(levelOwnerId == (TInt)ClientId[0]); + + newState = Resources[aResId].iMinLevel + 10; + lddChan.ChangeResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, newState, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + + + lddChan.GetResourceStateAsync(ClientId[0], Resources[aResId].iResourceId, EFalse, req, state, levelOwnerId); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + test(levelOwnerId == (TInt)ClientId[1]); + + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + + r = lddChan.DeRegisterClientLevelFromResource(ClientId[0], Resources[aResId].iResourceId); + test(r == KErrNone); + + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + test(state == Resources[aResId].iDefaultLevel); + test(levelOwnerId == -1); + + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + + return; + } + +//Custom resource testing. This testing is done only with simulated resources. +//Testing of shared binary positive resource. +//---------------------------------------------------------------------------------------------- +//! @SYMTestCaseID KBASE-T_RESCONTROLCLI-0593 +//! @SYMTestType UT +//! @SYMPREQ PREQ1398 +//! @SYMTestCaseDesc This test case tests changing resource state of shared positive resource. +//! @SYMTestActions 0 Register client1 +//! 1 Register client2 +//! 2 Register client3 +//! 3 Register client4 +//! 4 Client1 change resource state. +//! 5 Client2 change resource state. +//! 6 Client3 get resource state. +//! 7 Client4 get resource state. +//! 8 Client1 change resource state. +//! 9 Client2 get resource state. +//! 10 Deregister client2 +//! 11 Deregister client1 +//! 12 Deregister client3 +//! 13 Deregister client4 +//! +//! @SYMTestExpectedResults 0 Client registered +//! 1 Client registered +//! 2 Client registered +//! 3 Client registered +//! 4 Resource state changed +//! 5 Resource state changed +//! 6 Resource state read and compared for correctness +//! 7 Resource state read and compared for correctness +//! 8 Resource state changed +//! 9 Resource state read and compared for correctness +//! 10 Client2 deregistered +//! 11 Client1 deregistered +//! 12 Client3 deregistered +//! 13 Client4 deregistered +//! @SYMTestPriority High +//! @SYMTestStatus Implemented +//---------------------------------------------------------------------------------------------- +void TestRM::CustomResourceTesting(TUint aResId) + { + test.Printf(_L("Testing custom function\n")); + TInt r = KErrNone; + TRequestStatus req; + TInt state; + TInt newState; + TInt levelOwnerId; + TUint ClientId[4]; + ClientName[6] = (TUint8)('0' + iMaxClientId +1); + r = lddChan.RegisterClient(ClientId[0], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +2); + r = lddChan.RegisterClient(ClientId[1], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +3); + r = lddChan.RegisterClient(ClientId[2], (const TDesC*)&ClientName); + test(r == KErrNone); + ClientName[6] = (TUint8)('0' + iMaxClientId +4); + r = lddChan.RegisterClient(ClientId[3], (const TDesC*)&ClientName); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[0], Resources[aResId].iResourceId); + test(r == KErrNone); + r = lddChan.RequestNotification(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + newState = 1; + state = 1; + lddChan.ChangeResourceStateAsync(ClientId[2], Resources[aResId].iResourceId, state, req); + User::WaitForRequest(req); //State 1 + test(req.Int() == KErrNone); + test(state == newState); + test(r == KErrNone); + r = lddChan.CheckNotifications(Resources[aResId].iResourceId, 2, 0); + test(r == KErrNone); + state = 0; + lddChan.ChangeResourceStateAsync(ClientId[1], Resources[aResId].iResourceId, state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + test(state == 1); + lddChan.ChangeResourceStateAsync(ClientId[0], Resources[aResId].iResourceId, state, req); + User::WaitForRequest(req); + test(req.Int() == KErrNone); + test(state == newState); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test((TUint)levelOwnerId == ClientId[2]); + r = lddChan.ChangeResourceStateSync(ClientId[2], Resources[aResId].iResourceId, 0); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[0], Resources[aResId].iResourceId, EFalse, state, levelOwnerId); + test(r == KErrNone); + test(state == 1); + test((TUint)levelOwnerId == ClientId[0]); + r = lddChan.DeRegisterClient(ClientId[0]); + test(r == KErrNone); + r = lddChan.DeRegisterClientLevelFromResource(ClientId[1], Resources[aResId].iResourceId); + test(r == KErrNone); + r= lddChan.DeRegisterClient(ClientId[2]); + test(r == KErrNone); + r = lddChan.GetResourceStateSync(ClientId[3], Resources[aResId].iResourceId, ETrue, state, levelOwnerId); + test(r == KErrNone); + test(levelOwnerId == -1); + r = lddChan.DeRegisterClient(ClientId[3]); + test(r == KErrNone); + r = lddChan.DeRegisterClient(ClientId[1]); + test(r == KErrNone); + return; + } + +//Resource manager operations are chosen randomly and tested for correctness. This is done only in +//simulated resources. Currently this runs for 500 iteration. +//NOTE: Increasing the iteration to more than 500 may fail due to insufficient internal buffers. +void TestRM::RegressionTest() + { + TUint operation = 0; + TUint resourceId; + TUint count; + NegativeTesting = 0; + iMaxClientId = 0; + iMaxStaticResources = 0; + iMaxStaticDependentResources = 0; + iMaxClients = 0; + RmTest.RegisterClient(); + iCurrentClientId = -1; + r = lddChan.GetResourceControllerVersion(Clients[0].iClientId, iTestingExtendedVersion); + if(r != KErrNone) + test.Printf(_L("Return value of GetResourceControllerVersion %d\n"), r); + test(r == KErrNone); + if(!iTestingExtendedVersion) + test.Printf(_L("Testing Basic Version only....")); + else + test.Printf(_L("Testing basic & extended version....")); + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, iMaxStaticResources); + if(!(Resources[0].iName.Compare(*(const TDesC8*)&SpecialResName))) + { + TBuf8<32> PowerController = _L8("PowerController"); + r = lddChan.GetClientId(Clients[0].iClientId, (TDesC8&)PowerController, iPowerControllerId); + test(r == KErrNone); + } + else + { + test.Printf(_L("Regression testing is run only on simulator")); + return; + } + + for(count = 0; count < 500; count++) + { + operation = Math::Random() % EOperationEnd; + iCurrentClientId = Math::Random() % iMaxClients; + resourceId = Math::Random() % iMaxStaticResources; + if(operation != ERegisterClient) + { + if(Clients[iCurrentClientId].iClientId == 0) //Not a valid client + continue; + } + if(Resources[resourceId].iSense == ECustom) + continue; + test.Printf(_L("\nOperation = %d, ClientId = %d, ResourceId = %d\n"), operation, iCurrentClientId, resourceId); + switch (operation) + { + case ERegisterClient: + RmTest.RegisterClient(); + break; + case EGetClientName: + RmTest.GetClientName(iCurrentClientId); + break; + case EGetAllClientName: + RmTest.GetClientName(0); + break; + case EGetClientId: + RmTest.GetClientId(iCurrentClientId); + break; + case EGetResourceId: + RmTest.GetResourceId(resourceId); + break; + case EGetResourceInfo: + RmTest.GetResourceInfo(resourceId); + break; + case EGetNumReosourceInUseByClient: + RmTest.GetNumResourcesInUseByClient(iCurrentClientId); + break; + case EGetInfoOnResourceInUseByClient: + test.Printf(_L("NumResources = %d\n"), Clients[iCurrentClientId].iNumResources); + RmTest.GetInfoOnResourcesInUseByClient(iCurrentClientId, Clients[iCurrentClientId].iNumResources); + break; + case EGetNumClientsUsingResource: + if(resourceId == 0) + { + RmTest.GetNumClientsUsingResource(iCurrentClientId, (TUint)-1); + } + else + { + RmTest.GetNumClientsUsingResource(iCurrentClientId, resourceId); + } + break; + case EGetInfoOnClientsUsingResource: + if(resourceId == 0) + RmTest.GetInfoOnClientsUsingResource((TUint)-1, iMaxClients+1); + else + { + test.Printf(_L("NumResources = %d\n"), Resources[resourceId].iNumClients); + RmTest.GetInfoOnClientsUsingResource(resourceId, Resources[resourceId].iNumClients); + } + break; + case EChangeResourceStateSync: + RmTest.ChangeResourceStateSync(resourceId); + break; + case EChangeResourceStateAsync: + RmTest.ChangeResourceStateAsync(resourceId); + break; + case EGetResourceStateSync: + RmTest.GetResourceStateSync(resourceId); + break; + case EGetResourceStateAsync: + RmTest.GetResourceStateAsync(resourceId); + break; + case ERequestNotificationCond: + RmTest.RequestNotificationCon(resourceId); + break; + case ERequestNotificationUnCond: + RmTest.RequestNotification(resourceId); + break; + case ECancelNotificationCond: + RmTest.CancelNotification(resourceId, ETrue); + break; + case ECancelNotificationUnCond: + RmTest.CancelNotification(resourceId, EFalse); + break; + } + } + //CleanUp + test.Printf(_L("Cleanup of all Clients\n")); + TInt clientCount = Clients.Count(); + for(count = clientCount-1; ((TInt)count) >=0; count--) + { + if(Clients[count].iClientId == 0) + continue; + test.Printf(_L("ClientId deregistration of %d\n"), Clients[count].iClientId); + RmTest.DeRegisterClient(count); + } + Clients.Close(); + } + +GLDEF_C TInt E32Main() + { + test.Title(); + test.Start(_L("Testing Resource Manager...\n")); + test.Next(_L("Load Physical device")); +#ifndef PRM_ENABLE_EXTENDED_VERSION + r = User::LoadPhysicalDevice(KPddFileName); + test(r==KErrNone || r==KErrAlreadyExists); + test.Next(_L("Load Logical Device")); + r=User::LoadLogicalDevice(KLddFileName); + test(r==KErrNone || r==KErrAlreadyExists); + __KHEAP_MARK; //Heap testing is done only for basic version +#else + r = User::LoadPhysicalDevice(KExtPddFileName); + test(r==KErrNone || r==KErrAlreadyExists); + test.Next(_L("Load Logical Device")); + r=User::LoadLogicalDevice(KExtLddFileName); + test(r==KErrNone || r==KErrAlreadyExists); +#endif + r = lddChan.Open(); + test(r==KErrNone || r==KErrAlreadyExists); + //Check whether the notifications recieved as a result of postboot level setting is as expected. + r = lddChan.CheckPostBootLevelNotifications(); + test(r == KErrNone); + TBool regressionTesting = EFalse; + //Parse the command line arguments. + TBuf<0x50> cmd; + User::CommandLine(cmd); + TLex lex(cmd); + lex.SkipSpace(); + if(lex.Get() == '-') + { + TChar letter = lex.Get(); + if((letter == 'R') || (letter == 'r')) + regressionTesting = ETrue; + } + if(regressionTesting) + RmTest.RegressionTest(); + else + RmTest.APIValidationTest(); + test.Printf(_L("Closing the channel\n")); + lddChan.Close(); + test.Printf(_L("Freeing logical device\n")); +#ifndef PRM_ENABLE_EXTENDED_VERSION + __KHEAP_MARKEND; + r = User::FreeLogicalDevice(KLddFileName); + test(r==KErrNone); + r = User::FreePhysicalDevice(KPddFileName); + test(r==KErrNone); +#else + r = User::FreeLogicalDevice(KExtLddFileName); + test(r==KErrNone); + r = User::FreePhysicalDevice(KExtPddFileName); + test(r==KErrNone); +#endif + User::After(100000); + test.End(); + test.Close(); + return KErrNone; + } +