We need a way to pass flags to rombuilds in Raptor via extension flm interfaces, so that the CPP pass
of the rom input files can be informed what toolchain we are building with and conditionally
include or exclude files depending on whether the toolchain could build them.
// 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 <e32test.h>
#include <e32hal.h>
#include <e32math.h>
#include <e32def.h>
#include <e32def_private.h>
#include "d_rescontrolcli.h"
#include <drivers/resourcecontrol_clientsettings.h>
#include <drivers/resourcecontrol_settings.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<RMClientInfo> 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;c<aNumCli;c++)
{
if(Clients[pL->iClientId].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;
RArray<SResourceDependencyInfo>depResArray;
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);
User::WaitForRequest(req);
test(req.Int() == 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;
RArray<SResourceDependencyInfo>depResArray;
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);
RBuf8 info;
TUint c;
r = info.Create((iMaxStaticResources) * sizeof(SIdleResourceInfo));
test(r == KErrNone);
SIdleResourceInfo* pI = (SIdleResourceInfo*)info.Ptr();
for(c = 0; c < iMaxStaticResources; c++)
{
pI->iResourceId = Resources[c].iResourceId;
pI++;
}
pI = (SIdleResourceInfo*)info.Ptr();
r = lddChan.RegisterForIdleResourcesInfo(iPowerControllerId, iMaxStaticResources, (TAny*)info.Ptr());
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);
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);
info.Create(15 * sizeof(SIdleResourceInfo));
r = lddChan.GetIdleResourcesInfo(15, (TAny*)(TDes8*)&info);
test(r == KErrNone);
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();
}
void TestClientSettings(TInt aClientToken, TUint aExpectedBase)
{
TUint clientBase = ElementId_ClientSettingBase(aClientToken);
test(clientBase == aExpectedBase);
HCR::TElementId Id;
Id = ElementId_ClientName(aClientToken);
test(Id == aExpectedBase);
Id = ElementId_ClientPropertyFlag(aClientToken);
test(Id == (aExpectedBase + 1));
Id = ElementId_ClientPreallocation(aClientToken);
test(Id == (aExpectedBase + 2));
TInt firstResource = 0;
Id = ElementId_ClientStaticResource(aClientToken, firstResource);
test(Id == (aExpectedBase + 3));
TInt thirdResource = 2;
Id = ElementId_ClientStaticResource(aClientToken, thirdResource);
test(Id == (aExpectedBase + 5));
}
void TestDynamicResourceSettings(TInt aDynamicResource, TUint aExpectedBase)
{
TUint dynamicResourceBase = ElementId_DynamicResourceBase(aDynamicResource);
test(dynamicResourceBase == aExpectedBase);
HCR::TElementId Id;
Id = ElementId_DynamicResourceName(aDynamicResource);
test(Id == aExpectedBase);
Id = ElementId_DynamicResourcePropertyFlag(aDynamicResource);
test(Id == (aExpectedBase + 1));
Id = ElementId_DynamicResourceMaxLevel(aDynamicResource);
test(Id == (aExpectedBase + 2));
Id = ElementId_DynamicResourceMinLevel(aDynamicResource);
test(Id == (aExpectedBase + 3));
Id = ElementId_DynamicResourceDefaultLevel(aDynamicResource);
test(Id == (aExpectedBase + 4));
Id = ElementId_DynamicResourceDependencyMask1(aDynamicResource);
test(Id == (aExpectedBase + 5));
Id = ElementId_DynamicResourceDependencyMask2(aDynamicResource);
test(Id == (aExpectedBase + 6));
Id = ElementId_DynamicResourceDependencyMask3(aDynamicResource);
test(Id == (aExpectedBase + 7));
}
void TestClientHCRSettingMacros()
{
TInt clientToken = 2; // Random token number
TUint expectedBase = 80; // refer resourcecontrol_clientsettings.h for calculations
TestClientSettings(clientToken, expectedBase);
clientToken = 0;
expectedBase = 16; // refer resourcecontrol_clientsettings.h for calculations
TestClientSettings(clientToken, expectedBase);
// Dynamic Resource settings
TUint dynamicResource = 3; // Random token number
expectedBase = 131168; // refer resourcecontrol_clientsettings.h for calculations
TestDynamicResourceSettings(dynamicResource, expectedBase);
test.Printf(_L("Testing HCR client setting Macro's for Resource Manager successful \n"));
}
GLDEF_C TInt E32Main()
{
test.Title();
test.Start(_L("Testing Resource Manager...\n"));
test.Printf(_L("Testing HCR client setting Macro's for Resource Manager \n"));
TestClientHCRSettingMacros();
//
test.Printf(_L("TEST SKIPPED UNTIL FIX FOR DEF145087 IS AVAILABLE TO PREVENT CRASHING\n"));
test(0);
//
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;
}