// 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"

#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);