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

 //

 #include <e32test.h>

 #include <e32def.h>

 #include <e32def_private.h>

 #include <d32resmanus.h>

 #ifdef PRM_ENABLE_EXTENDED_VERSION

 #define LDD_NAME _L("resourcecontrollerextended.ldd")

 #else

 #define LDD_NAME _L("resourcecontrol.ldd")

 #endif

 #ifdef PRM_ENABLE_EXTENDED_VERSION

 #define PDD_NAME _L("resourcecontrollerextended.pdd")

 #else

 #define PDD_NAME _L("resourcecontroller.pdd")

 #endif

 //#define PIRATE_THREAD_TESTS

 _LIT(testableResourceName,"SymbianSimulResource");

 #ifdef RESMANUS_KERN

 _LIT(testName,"t_resmanuskern");

 #else

 _LIT(testName,"t_resmanus");

 #endif

 TBuf<16> gTestName(testName);

 GLDEF_D RTest gTest(testName);

 GLDEF_D RBusDevResManUs gChannel;

 TUint8 KNoOfGetStateRequests = 5;

 TUint8 KNoOfSetStateRequests = 4;

 TUint8 KNoOfNotifyRequests = 7;

 #define MAX_NUM_REQUESTS 8		// Must be (at least) one greater than the largest of 

 								// KNoOfGetStateRequests, KNoOfSetStateRequests, KNoOfNotifyRequests

 #ifdef _DEBUG

 TUint gLongLatencyResource;

 TBool gHaveAsyncRes = EFalse;

 TInt gAsyncResStateDelta = 0;

 TUint gSharedResource;

 TBool gHaveSharedRes = EFalse;

 TInt gSharedResStateDelta = 0;

 #else

 // The UREL version of the driver will not implement the arrays and functionality required

 // to determine the async and shared resources to use at runtime. The values provided here

 // have been pre-determined to operate successfully with the simulated PSL.

 //

 TUint gLongLatencyResource = 6;

 TBool gHaveAsyncRes = ETrue;

 TInt gAsyncResStateDelta = -1;

 TUint gSharedResource = 12;

 TBool gHaveSharedRes = ETrue;

 TInt gSharedResStateDelta = -1;

 #endif

 TBool gUseCached = EFalse;

 LOCAL_C TInt OpenChannel(TDesC16& aName, RBusDevResManUs& aChannel)

 	{

 	TInt r = KErrNone;

 	// API accepts 8-bit descriptors, only - so convert name accordingly

 	TBuf8<MAX_RESOURCE_NAME_LENGTH+1>EightBitName;

 	EightBitName.Copy(aName);

     r=(aChannel.Open(EightBitName));

     if (r!=KErrNone)

 		gTest.Printf(_L("OpenChannel: Handle for channel %S error code =0x%x\n"),&aName,r);

 	else

 		gTest.Printf(_L("OpenChannel: Handle for channel %S =0x%x\n"),&aName,aChannel.Handle());

 	return r;

 	}

 LOCAL_C TInt HelperResources()

 //

 // Helper method to support OpenAndRegisterChannel

 // Invokes GetNoOfResources, GetAllResourcesInfo and GetResourceIdByName

 //

 	{

 	TInt r = KErrNone;

 	__KHEAP_MARK;

 	// Check what resources are available

     gTest.Printf(_L("**Test GetNoOfResources\n"));

 	TUint numResources=0;

 	if((r=gChannel.GetNoOfResources(numResources))!=KErrNone)

 		{

 		gTest.Printf(_L("GetNoOfResources for test channel returned %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("Number of resources = %d (=0x%x)\n"),numResources,numResources);

 	// Read the resource information

     gTest.Printf(_L("**Test GetAllResourcesInfo\n"));

 	// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects

 	// and reference via an RSimplePointerArray

 	TUint bufSize = numResources;

 	RSimplePointerArray<TResourceInfoBuf> infoPtrs(bufSize);

 	for(TUint i=0;i<bufSize;i++)

 		{

 		TResourceInfoBuf *info = new TResourceInfoBuf();

 		if((r=infoPtrs.Insert(info, i))!=KErrNone)

 			{

 			gTest.Printf(_L("GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),i,r);

 			}

 		}

 	TUint updateNumResources=numResources;

 	if((r=gChannel.GetAllResourcesInfo(&infoPtrs,updateNumResources))!=KErrNone)

 		{

 		gTest.Printf(_L("GetAllResourcesInfo for channel returned %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("Updated number of resources = %d\n"),updateNumResources);

 #ifdef _DEBUG

 	// Print resource names

 	{

 	TBuf16<MAX_RESOURCE_NAME_LENGTH+1>name;

 	for(TUint i=0; i<updateNumResources; i++)

 		{

 		TResourceInfoBuf* currRes = infoPtrs[i];

 		name.Copy((*currRes)().iName);

 		name.PtrZ();

 		gTest.Printf(_L("Resource %d name = %S \n"),i,&name);

 		};

 	}

 #endif

 	// Select a resource to use, then pass its name to GetResourceIdByName

 	// to check that the corresponding resource ID is acquired.

 	TResourceInfo currRes = (*infoPtrs[0])(); 

 	if(updateNumResources>1)

 		currRes=(*infoPtrs[1])();// First resource may be a dummy

 	TUint resourceId;

 	gTest.Printf(_L("Invoking GetResourceIdByName for last resource name extracted \n"));

 	if((r=gChannel.GetResourceIdByName(currRes.iName, resourceId))!=KErrNone)

 		{

 		gTest.Printf(_L("GetResourceIdByName for channel returned %d \n"),r);

 		return r;

 		}

 	gTest.Printf(_L("GetResourceIdByName gave ID = %d\n"),resourceId);

 	infoPtrs.Close();

 	__KHEAP_MARKEND;

 	return r;

 	}

 LOCAL_C TInt CheckForSimulatedResources()

 //

 // Get the name of the first resource - if it does not match the expected name

 // then the testing must not proceed, so return the relevant error code

 //

 	{

     TInt r = KErrNone;

 	TResourceInfoBuf buffer;

 	if((r=gChannel.GetResourceInfo(1, &buffer))!=KErrNone)	// first resource ID = 1

 		{

 		gTest.Printf(_L("CheckForSimulatedResources, candidate get resource info returned %d\n"),r);

 		return r;

 		}

 	// Check the name of the resource

 	TBuf16<MAX_RESOURCE_NAME_LENGTH+1>name;

 	name.Copy(buffer().iName);

 	name.PtrZ();

 	if((r=name.Compare(testableResourceName))!=KErrNone)

 		{

 		gTest.Printf(_L("Resource name = %S, require %S \n"),&name,&testableResourceName);

 		r=KErrNotSupported;

 		}

 	return r;

 	}

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0607

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests channel opening and initialisation APIs.

 //! @SYMTestActions     0) Call Open API with a valid name.

 //! 

 //!						1) Call Open API for two more channels 

 //!						(to demonstrate multiple clients (channels) can be supported concurrently).

 //! 

 //!						2) Call Open with an oversized name. 

 //! 

 //!						3) Call GetNoOfResources API

 //! 

 //!						4) Call GetAllResourcesInfo API

 //! 

 //!						5) Call GetResourceIdByName API for last of resource names gathered

 //!						in previous step

 //! 

 //!						6) Call Initialise API on the channel originally created, with non-zero arguments.

 //!

 //! @SYMTestExpectedResults 0) API should return with KErrNone, exits otherwise.

 //!						1) API should return with KErrNone, exits otherwise.

 //!						2) API should return with KErrBadName, exits otherwise.

 //!						3) API should return with KErrNone, exits otherwise.

 //!						4) API should return with KErrNone, exits otherwise.

 //!						5) API should return with KErrNone, exits otherwise.

 //!						6) API should return with KErrNone, exits otherwise.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt OpenAndRegisterChannel()

 //

 // Test Open and Initialise functionality

 // Also invokes Resource inspection methods via HelperResource

 //

     {

     TInt r;

 	if((r=OpenChannel(gTestName, gChannel))!=KErrNone)

 		return r;

 	// Check that the simulated resources required to support this testing are present

 	// If not, close the channel and return the propagated error code.

 	if((r=CheckForSimulatedResources())!=KErrNone)

 		{

 		gChannel.Close();

 		return r;

 		}

 	__KHEAP_MARK; // gTestName will remain open (allocated) when heap is checked

 	// Open a couple of additional channels to prove that more than one

 	// can exist

 	_LIT(tempStr1,"temp1");

 	TBufC<16> tempName1(tempStr1);

 	_LIT(tempStr2,"temp2");

 	TBufC<16> tempName2(tempStr2);

 	RBusDevResManUs channelTwo;

 	RBusDevResManUs channelThree;

 	if((r=OpenChannel(tempName1, channelTwo))!=KErrNone)

 		return r;

 	if((r=OpenChannel(tempName2, channelThree))!=KErrNone)

 		return r;

 	// The following test requires manual enabling in resource controller of macro

 	// DEBUG_VERSION - this is not done by default, so test is deactivated here.

 	//

 #if 0

 	// Test rejection if try a name already in use

 	//

 	// (For UREL builds, duplicate names are allowed; but

 	//  for UDEB builds, they are monitored and rejected)

 	//

 	RBusDevResManUs channelSameName;

 	r=OpenChannel(tempName1, channelSameName);

 	channelSameName.Close(); // Channel not used after here

     if (r==KErrNone)

 		{

 		gTest.Printf(_L("Error: Handle for re-used name channel =0x%x\n"),channelSameName.Handle());

 		return KErrGeneral;

 		}

 	else if(r!=KErrCouldNotConnect)

 		{

 		gTest.Printf(_L("Error: re-used name gave unexpected error code =0x%x\n"),r);

 		return r;

 		}

 	else // if(r==KErrCouldNotConnect)

 		{

 		gTest.Printf(_L("Re-used channel name rejected with correct error code\n"));

 		}

 #endif // if 0

 	// Test oversized name rejection

 	_LIT(longStr,"1abcdefghijklmnopqrstuvwxyz2abcdefghijklmnopqrstuvwxyz3abcdefghijklmnopqrstuvwxyz4abcdefghijklmnopqrstuvwxyz5abcdefghijklmnopqrstuvwxyz6abcdefghijklmnopqrstuvwxyz7abcdefghijklmnopqrstuvwxyz8abcdefghijklmnopqrstuvwxyz9abcdefghijklmnopqrstuvwxyz10abcdefghijklmnopqrstuvwxyz");

 	TBufC<271> longName(longStr);

 	// API accepts 8-bit descriptors for names, only

 	TBuf8<271>longName_8Bit;

 	longName_8Bit.Copy(longName);

 	RBusDevResManUs channelLong;

     r=(channelLong.Open(longName_8Bit));

 	channelLong.Close(); // Channel not used after here

     if (r==KErrNone)

 		{

 		gTest.Printf(_L("Error: Handle for oversize name channel =0x%x\n"),channelLong.Handle());

 		return KErrGeneral;

 		}

 	else if(r!=KErrBadName)

 		{

 		gTest.Printf(_L("Error: oversized name gave unexpected error code =0x%x\n"),r);

 		return r;

 		}

 	else // if(r==KErrBadName)

 		{

 		gTest.Printf(_L("Oversized name for channel rejected with correct error code\n"));

 		}

 	// Invokes GetNoOfResources, GetAllResourcesInfo and GetResourceIdByName

 	if((r=HelperResources())!=KErrNone)

 		return r;

 	// Close the temporary channels

 	// Do this before  channel registration to enable valid check of kernel heap

 	channelTwo.Close();

 	channelThree.Close();

 	__KHEAP_MARKEND;

 	// Channel registration

     gTest.Printf(_L("Invoking Initialise with values 0x%x, 0x%x, 0x%x\n"),KNoOfGetStateRequests,KNoOfSetStateRequests,KNoOfNotifyRequests);

     if ((r=gChannel.Initialise(KNoOfGetStateRequests,KNoOfSetStateRequests,KNoOfNotifyRequests))!=KErrNone)

 		{

 		gTest.Printf(_L("Initialise for channel returned %d\n"),r);

 		return r;

 		}

     return KErrNone;

     }

 LOCAL_C TInt HelperClients()

 //

 // Helper method to support TestGetClientGetResourceInfo

 // Invokes GetNoOfClients and GetNamesAllClients

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	TUint numClients = 0;

 	TUint numAllClients = 0;

 	//

 	// GetNoOfClients - with aIncludeKern=EFalse

 	//

 	if((r=gChannel.GetNoOfClients(numClients, EFalse)) != KErrNone)

 		{

 		gTest.Printf(_L("GetNoOfClients (aIncludeKern==EFalse) returned %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("GetNoOfClients (aIncludeKern==EFalse) gave 0x%x clients\n"),numClients);

 	//

 	// GetNoOfClients - with aIncludeKern=ETrue

 	//

 	r=gChannel.GetNoOfClients(numAllClients, ETrue);

 #ifdef RESMANUS_KERN

 	if(r==KErrNone)

 		gTest.Printf(_L("GetNoOfClients (aIncludeKern==ETrue) returned KErrNone\n"));

 #else

 	if(r==KErrPermissionDenied)

 		gTest.Printf(_L("GetNoOfClients (aIncludeKern==ETrue) returned KErrPermissionDenied\n"));

 #endif

 	else

 		{

 		gTest.Printf(_L("GetNoOfClients (aIncludeKern==ETrue) returned %d"),r);

 		return KErrGeneral;

 		}

 	// To support the GetNamesAllClients testing, instantiate TClientName objects

 	// and reference via an RSimplePointerArray

 	TUint bufSize = (numAllClients>numClients)?numAllClients:numClients;

 	RSimplePointerArray<TClientName> infoPtrs(bufSize);

 	for(TUint i=0;i<bufSize;i++)

 		{

 		TClientName *info = new TClientName();

 		if((r=infoPtrs.Insert(info, i))!=KErrNone)

 			{

 			gTest.Printf(_L("GetNamesAllClients infoPtrs.Insert at index %d returned %d\n"),i,r);

 			}

 		}

 	//

 	// GetNamesAllClients - with aIncludeKern=EFalse

 	//

 	if((r=gChannel.GetNamesAllClients(&infoPtrs, numClients, EFalse)) != KErrNone)

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==EFalse) returned %d\n"),r);

 		return r;

 		}

 #ifdef _DEBUG

 	else

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==EFalse) returned KErrNone, names follow\n"));

 		for(TUint i=0;i<numClients;i++)

 			{

 			TClientName *currName = infoPtrs[i];

 			TBuf16<sizeof(TClientName)> name;

 			name.Copy(*currName);

 			gTest.Printf(_L("Client name %d = %S\n"),i,&name);

 			}

 		}

 #endif

 	//

 	// GetNamesAllClients - with aIncludeKern=ETrue

 	//

 #ifdef RESMANUS_KERN

 	if((r=gChannel.GetNamesAllClients(&infoPtrs, numAllClients, ETrue)) != KErrNone)

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==ETrue) returned %d\n"),r);

 		return r;

 		}

 #ifdef _DEBUG

 	else

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==ETrue) returned KErrNone, names follow\n"));

 		for(TUint i=0;i<numAllClients;i++)

 			{

 			TClientName *currName = infoPtrs[i];

 			TBuf16<sizeof(TClientName)> name;

 			name.Copy(*currName);

 			gTest.Printf(_L("Client name %d = %S\n"),i,&name);

 			}

 		}

 #endif

 #else

 	if((r=gChannel.GetNamesAllClients(&infoPtrs, numClients, ETrue)) == KErrPermissionDenied)

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==ETrue) returned KErrPermissionDenied\n"));

 		r=KErrNone; // Ensure misleading status is not returned

 		}

 	else

 		{

 		gTest.Printf(_L("GetNamesAllClients (aIncludeKern==ETrue) returned %d"),r);

 		return r;

 		}

 #endif

 	infoPtrs.Close();

 	__KHEAP_MARKEND;

 	return r;

 	}

 LOCAL_C TInt HelperClientsUsingResource(TUint aResourceId)

 //

 // Helper method to support TestGetClientGetResourceInfo

 // Invokes GetNumClientsUsingResource and GetInfoOnClientsUsingResource

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	//

 	// GetNumClientsUsingResource - with aIncludeKern=ETrue

 	//

 	TUint resourceAllClients = 0;

 	if((r=gChannel.GetNumClientsUsingResource(aResourceId, resourceAllClients, ETrue)) == KErrPermissionDenied)

 		{

 		gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==ETrue) returned KErrPermissionDenied\n"));

 #ifdef RESMANUS_KERN

 		return r;

 		}

 	else

 		{

 		if(r!=KErrNone)

 			{

 			gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==ETrue) returned %d\n"),r);

 			return r;

 			}

 		else

 			gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==ETrue) reported 0x%x clients\n"),resourceAllClients);

 		}

 #else

 		}

 	else

 		{

 		gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==ETrue) returned %d\n"),r);

 		return r;

 		}

 #endif

 	//

 	// GetNumClientsUsingResource - with aIncludeKern=EFalse

 	//

 	TUint resourceClients = 0;

 	if((r=gChannel.GetNumClientsUsingResource(aResourceId, resourceClients, EFalse)) != KErrNone)

 		{

 		// If there are no clients that have requested a level then the Resource Controller will

 		// the client ID as a bad argument

 		if(!((resourceClients==0)&&(r==KErrArgument)))

 			{

 			gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==EFalse) returned %d\n"),r);

 			return r;

 			}

 		else

 			r=KErrNone;	// Ensure expected error is not misinterpeted

 		}

 	else

 		gTest.Printf(_L("GetNumClientsUsingResource (aIncludeKern==EFalse) reported 0x%x clients\n"),resourceClients);

 	// To support the GetInfoOnClientsUsingResource testing, instantiate TClientInfoBuf objects

 	// and reference via an RSimplePointerArray

 	TUint bufSize = (resourceAllClients>resourceClients)?resourceAllClients:resourceClients;

 	if(bufSize>0)

 		{

 		RSimplePointerArray<TClientInfoBuf> infoPtrs(bufSize);

 		for(TUint i=0;i<bufSize;i++)

 			{

 			TClientInfoBuf *info = new TClientInfoBuf();

 			if((r=infoPtrs.Insert(info, i))!=KErrNone)

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource infoPtrs.Insert at index %d returned %d\n"),i,r);

 				}

 			}

 		//

 		// GetInfoOnClientsUsingResource - with aIncludeKern=EFalse

 		//

 		if((r=gChannel.GetInfoOnClientsUsingResource(aResourceId, resourceClients, &infoPtrs, EFalse)) != KErrNone)

 			{

 			// If there are no clients that have requested a level then the resource will not

 			// have been found

 			if(!((resourceClients==0)&&(r==KErrNotFound)))

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==EFalse) returned %d\n"),r);

 				return r;

 				}

 			}

 #ifdef _DEBUG

 		else

 			{

 			gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==EFalse) returned KErrNone, info follows\n"));

 			for(TUint i=0;i<resourceClients;i++)

 				{

 				TClientInfoBuf* currInfoBuf = infoPtrs[i];

 				TClientInfo currInfo=(*currInfoBuf)();

 				TBuf16<sizeof(TClientName)> name;

 				name.Copy(currInfo.iName);

 				gTest.Printf(_L("Client name %d = %S, ID=0x%x\n"),i,&name,currInfo.iId);

 				}

 			}

 #endif

 		//

 		// GetInfoOnClientsUsingResource - with aIncludeKern=ETrue

 		//

 		r=gChannel.GetInfoOnClientsUsingResource(aResourceId, resourceAllClients, &infoPtrs, ETrue);

 			{

 #ifdef RESMANUS_KERN

 			if(r != KErrNone)

 				{

 				// If there are no clients that have requested a level then the Resource Controller

 				// will report a request for information on 0 clients as a bad argument

 				if(!((resourceClients==0)&&(r==KErrArgument)))

 					{

 					gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==ETrue) returned %d\n"),r);

 					return r;

 					}

 				else

 					r=KErrNone; // Ensure misleading result is not returned

 				}

 #ifdef _DEBUG

 			else

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==ETrue) returned KErrNone, info follows\n"));

 				for(TUint i=0;i<resourceClients;i++)

 					{

 					TClientInfoBuf* currInfoBuf = infoPtrs[i];

 					TClientInfo currInfo=(*currInfoBuf)();

 					TBuf16<sizeof(TClientName)> name;

 					name.Copy(currInfo.iName);

 					gTest.Printf(_L("Client name %d = %S, ID=0x%x\n"),i,&name,currInfo.iId);

 					}

 				}

 #endif

 #else

 			if(r == KErrNone)

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==ETrue) returned KErrNone"));

 				return KErrGeneral;

 				}

 			else if(r==KErrPermissionDenied)

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==ETrue) returned KErrPermissionDenied\n"));

 				r=KErrNone; // Ensure that misleading result is not propagated

 				}

 			else

 				{

 				gTest.Printf(_L("GetInfoOnClientsUsingResource (aIncludeKern==ETrue) returned %d\n"),r);

 				// If there are no clients that have requested a level then the Resource Controller

 				// will report a request for information on 0 clients as a bad argument

 				if(!((resourceClients==0)&&(r==KErrArgument)))

 					return r;

 				}

 #endif

 			}

 		}

 	__KHEAP_MARKEND;

 	return r;

 	}

 LOCAL_C TInt HelperResourcesInUseByClient()

 //

 // Helper method to supportTestGetClientGetResourceInfo

 // Invokes GetNumResourcesInUseByClient and GetInfoOnResourcesInUseByClient

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	//

 	// GetNumResourcesInUseByClient

 	//

 	// API accepts 8-bit descriptors, only - so convert name accordingly

 	TBuf8<MAX_RESOURCE_NAME_LENGTH+1>name8Bit;

 	name8Bit.Copy(gTestName);

 	TClientName* clientName = (TClientName*)&name8Bit;

 #if _DEBUG

 	TBuf <MAX_CLIENT_NAME_LENGTH> clientName16Bit;

 	clientName16Bit.Copy(*clientName);

 	clientName16Bit.SetLength(clientName->Length());

 	gTest.Printf(_L("Invoking GetNumResourcesInUseByClient with %S (expect KErrPermissionDenied if no levels requested yet)\n"),&clientName16Bit);

 #endif

 	TUint numResourcesForClient;

 	if((r=gChannel.GetNumResourcesInUseByClient(*clientName, numResourcesForClient)) != KErrNone)

 		{

 		gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("GetNumResourcesInUseByClient gave number of resources = %d\n"),numResourcesForClient);

 	//

 	// In addition, check response when the name of an unknown client is passed

 	//

 	// Negative test - ensure that an unknown client name fails

 	_LIT(dumName,"DoesNotExist");

 	TBuf<16> dumNameBuf(dumName);

 	TBuf8<MAX_RESOURCE_NAME_LENGTH+1>dumName8Bit;

 	dumName8Bit.Copy(dumNameBuf);

 	TClientName* dumClientName = (TClientName*)&dumName8Bit;

 #if _DEBUG

 	gTest.Printf(_L("Invoking GetNumResourcesInUseByClient with %S\n"),&dumNameBuf);

 #endif

 	TUint numResForDumClient;

 	if((r=gChannel.GetNumResourcesInUseByClient(*dumClientName, numResForDumClient)) != KErrNotFound)

 		{

 		gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);

 		if(r==KErrNone)

 			r=KErrGeneral;

 		return r;

 		}

 	gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);

 	r=KErrNone;	// Ensure misleading error code is not propagated

 	//

 	// GetInfoOnResourcesInUseByClient

 	//

 	// If the (TUint) number of resources in use by the client is zero skip the attempt to read the resource information

 	TUint updatedNumResourcesForClient = numResourcesForClient;

 	if(numResourcesForClient!=0)

 		{

 		TUint bufSize = numResourcesForClient;

 		RSimplePointerArray<TResourceInfoBuf> infoPtrs(bufSize);

 		for(TUint i=0;i<bufSize;i++)

 			{

 			TResourceInfoBuf *info = new TResourceInfoBuf();

 			if((r=infoPtrs.Insert(info, i))!=KErrNone)

 				{

 				gTest.Printf(_L("GetInfoOnResourcesInUseByClient infoPtrs.Insert at index %d returned %d\n"),i,r);

 				}

 			}

 		if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, updatedNumResourcesForClient, &infoPtrs)) != KErrNone)

 			{

 			gTest.Printf(_L("GetInfoOnResourcesInUseByClient returned %d\n"),r);

 			// If there are no clients that have requested a level then the Resource Controller

 			// will report a request for information on 0 clients as a bad argument

 			if(!((updatedNumResourcesForClient==0)&&(r==KErrArgument)))

 				return r;

 			else

 				r=KErrNone; // Ensure misleading value is not returned by this function

 			}

 		else

 			{

 			gTest.Printf(_L("GetInfoOnResourcesInUseByClient gave updated number of resources %d\n"),updatedNumResourcesForClient);

 #ifdef _DEBUG

 			// Print resource names

 			TBuf16<MAX_RESOURCE_NAME_LENGTH+1>name;

 			for(TUint i=0; i<updatedNumResourcesForClient; i++)

 				{

 				TResourceInfoBuf* currRes = infoPtrs[i];

 				name.Copy((*currRes)().iName);

 				name.PtrZ();

 				gTest.Printf(_L("Resource %d name = %S \n"),i,&name);

 				};

 #endif

 			}

 		//

 		// In addition, check response when the name of an unknown client is passed

 		//

 		// Negative test - ensure that an unknown client name fails

 		r=gChannel.GetInfoOnResourcesInUseByClient(*dumClientName, updatedNumResourcesForClient, &infoPtrs);

 		gTest.Printf(_L("GetInfoOnResourcesInUseByClient for dummy client returned %d\n"),r);

 		if(r==KErrNone)

 			return KErrGeneral;

 		else if(r!=KErrNotFound)

 			return r;

 		// Ensure that misleading information is not returned to the calling function

 		r=KErrNone;

 		infoPtrs.Close();

 		}

 	__KHEAP_MARKEND;

 	return r;

 	}

 LOCAL_C TInt HelperGetClientResourceInfo()

 //

 // Test methods to access information about clients and resources

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	// Invokes GetNoOfClients and GetNamesAllClients

 	if((r=HelperClients())!=KErrNone)

 		return r;

 	// Invokes GetNumClientsUsingResource and GetInfoOnClientsUsingResource

 	//

 	// First invoke on the Async resource

 	TUint resourceId = 1;	// Arbitrary

 	if(gHaveAsyncRes)

 		{

 		resourceId = gLongLatencyResource;

 		gTest.Printf(_L("Invoking HelperClientsUsinResource for Async resource ID %d\n"),resourceId);

 		}

 	else

 		{

 		gTest.Printf(_L("Invoking HelperClientsUsinResource for default resource ID %d (Async resource not yet accessed)\n"),resourceId);

 		}

 	if((r=HelperClientsUsingResource(resourceId))!=KErrNone)

 		return r;

 	//

 	// Second invoke on the Shared resource - skip if not available

 	if(gHaveSharedRes)

 		{

 		resourceId = gSharedResource;

 		gTest.Printf(_L("Invoking HelperClientsUsinResource for Shared resource ID %d\n"),resourceId);

 		if((r=HelperClientsUsingResource(resourceId))!=KErrNone)

 			return r;

 		}

 	// Invokes GetNumResourcesInUseByClient and GetInfoOnResourcesInUseByClient

 	if((r=HelperResourcesInUseByClient())!=KErrNone)

 		return r;

 	__KHEAP_MARKEND;

 	return r;

 	}

 #ifdef _DEBUG

 LOCAL_C TInt SetAsyncResource()

 //

 // Support function for tests of asynchronous API methods

 //

 	{

 	if(!gHaveAsyncRes)

 		{

 		gTest.Printf(_L("SetAsyncResource, Find Async resource to use\n"));

 		TRequestStatus status;

 		TBool cached = gUseCached;

 		TInt readValue = 0;

 		TInt levelOwnerId = 0;

 		TUint numPotentialResources;

 		TUint index=0;

 		TInt r=gChannel.GetNumCandidateAsyncResources(numPotentialResources);

 		if(r!=KErrNone)

 			{

 			gTest.Printf(_L("SetAsyncResource, GetNumCandidateAsyncResources returned %d\n"),r);

 			return r;

 			}

 		gTest.Printf(_L("SetAsyncResource, GetNumCandidateAsyncResources found %d resources\n"),numPotentialResources);

 		while((numPotentialResources>0) && !gHaveAsyncRes)

 			{

 			TUint tryResourceId=0;

 			r=gChannel.GetCandidateAsyncResourceId(index,tryResourceId);

 			if(r!=KErrNone)

 				{

 				gTest.Printf(_L("SetAsyncResource, GetCandidateAsyncResourceId returned %d\n"),r);

 				break;

 				}

 			gTest.Printf(_L("SetAsyncResource, GetNumCandidateAsyncResources index %d, resource ID %d\n"),index,tryResourceId);

 			// For the candidate resource to be usable, we need its current state

 			// to be sufficiently less the maximum for positive sense (or sufficiently

 			// more than the greater than the minimum for negative sense - but the current 

 			// version of the code only considers positive sense).

 			gChannel.GetResourceState(status,tryResourceId,cached,&readValue,&levelOwnerId);

 			User::WaitForRequest(status);

 			if(status.Int() != KErrNone)

 				{

 				gTest.Printf(_L("SetAsyncResource, candidate get state returned %d\n"),r);

 				return r;

 				}

 			gTest.Printf(_L("SetAsyncResource, candidate get state gave %d, levelOwnerId = %d\n"),readValue,levelOwnerId);

 			TResourceInfoBuf buffer;

 			if((r=gChannel.GetResourceInfo(tryResourceId, &buffer))!=KErrNone)

 				{

 				gTest.Printf(_L("SetAsyncResource, candidate get resource info returned %d\n"),r);

 				return r;

 				}

 			// Print resource info

 			TBuf16<MAX_RESOURCE_NAME_LENGTH+1>name;

 			TResourceInfo* infoPtr = &(buffer());

 			name.Copy(infoPtr->iName);

 			gTest.Printf(_L("SetAsyncResource: Resource name = %S \n"),&name);

 			gTest.Printf(_L("SetAsyncResource: Resource Class =%d\n"),infoPtr->iClass);

 			gTest.Printf(_L("SetAsyncResource: Resource Type =%d\n"), infoPtr->iType);

 			gTest.Printf(_L("SetAsyncResource: Resource Usage =%d\n"), infoPtr->iUsage);

 			gTest.Printf(_L("SetAsyncResource: Resource Sense =%d\n"), infoPtr->iSense);

 			gTest.Printf(_L("SetAsyncResource: Resource MinLevel =%d\n"),infoPtr->iMinLevel);

 			gTest.Printf(_L("SetAsyncResource: Resource MaxLevel =%d\n"),infoPtr->iMaxLevel);

 			if((infoPtr->iMaxLevel - readValue) > LEVEL_GAP_REQUIRED_FOR_ASYNC_TESTING)

 				{

 				gLongLatencyResource = tryResourceId;

 				gAsyncResStateDelta = 1;  // Will change resource level in positive direction

 				gHaveAsyncRes = ETrue;

 				}

 			else if((readValue - infoPtr->iMinLevel) > LEVEL_GAP_REQUIRED_FOR_ASYNC_TESTING)

 				{

 				gLongLatencyResource = tryResourceId;

 				gAsyncResStateDelta = -1;  // Will change resource level in negative direction

 				gHaveAsyncRes = ETrue;

 				}

 			else

 				{

 				++index;

 				--numPotentialResources;

 				}

 			};

 		}

 	if(!gHaveAsyncRes)

 		{

 	    gTest.Printf(_L("**Test SetAsyncResource - don't have suitable resource ... exiting\n"));

 		return KErrNotReady;

 		}

 	return KErrNone;

 	}

 LOCAL_C TInt SetSharedResource()

 //

 // Support function for tests of shareable resources

 //

 	{

 	__KHEAP_MARK;

 	if(!gHaveSharedRes)

 		{

 		TRequestStatus status;

 		TBool cached = gUseCached;

 		TInt readValue = 0;

 		TUint numPotentialResources;

 		TUint index=0;

 		TInt r=gChannel.GetNumCandidateSharedResources(numPotentialResources);

 		if(r!=KErrNone)

 			{

 			gTest.Printf(_L("SetSharedResource, GetNumCandidateSharedResources returned %d\n"),r);

 			return r;

 			}

 		gTest.Printf(_L("SetSharedResource, GetNumCandidateSharedResources found %d resources\n"),numPotentialResources);

 		while((numPotentialResources>0) && !gHaveSharedRes)

 			{

 			TUint tryResourceId=0;

 			r=gChannel.GetCandidateSharedResourceId(index,tryResourceId);

 			if(r!=KErrNone)

 				{

 				gTest.Printf(_L("SetSharedResource, GetCandidateSharedResourceId returned %d\n"),r);

 				break;

 				}

 			gTest.Printf(_L("SetSharedResource, GetNumCandidateSharedResources index %d, resource ID %d\n"),index,tryResourceId);

 			// To support the tests, the selected shareable resource must not be the same

 			// resource as that selected for asynchronous testing

 			if(gHaveAsyncRes)

 				if(tryResourceId==gLongLatencyResource)

 					{

 					gTest.Printf(_L("SetSharedResource - skipping candidate resource %d - already used for async testing\n"),tryResourceId);

 					continue;

 					}

 			// For the candidate resource to be usable, we need its current state

 			// to be sufficiently less the maximum for positive sense (or sufficiently

 			// more than the greater than the minimum for negative sense - but the current 

 			// version of the code only considers positive sense).

 			TInt levelOwnerId = 0;

 			gChannel.GetResourceState(status,tryResourceId,cached,&readValue,&levelOwnerId);

 			User::WaitForRequest(status);

 			if(status.Int() != KErrNone)

 				{

 				gTest.Printf(_L("SetSharedResource, candidate get state returned %d\n"),r);

 				return r;

 				}

 			gTest.Printf(_L("SetSharedResource, candidate get state gave %d, levelOwnerId = %d\n"),readValue,levelOwnerId);

 			TResourceInfoBuf buffer;

 			if((r=gChannel.GetResourceInfo(tryResourceId, &buffer))!=KErrNone)

 				{

 				gTest.Printf(_L("SetSharedResource, candidate get resource info returned %d\n"),r);

 				return r;

 				}

 			// Print resource info

 			TBuf16<MAX_RESOURCE_NAME_LENGTH+1>name;

 			TResourceInfo* infoPtr = &buffer();

 			name.Copy(infoPtr->iName);

 			gTest.Printf(_L("SetSharedResource: Resource name = %S \n"),&name);

 			gTest.Printf(_L("SetSharedResource: Resource Class =%d\n"),infoPtr->iClass);

 			gTest.Printf(_L("SetSharedResource: Resource Type =%d\n"), infoPtr->iType);

 			gTest.Printf(_L("SetSharedResource: Resource Usage =%d\n"), infoPtr->iUsage);

 			gTest.Printf(_L("SetSharedResource: Resource Sense =%d\n"), infoPtr->iSense);

 			gTest.Printf(_L("SetSharedResource: Resource MinLevel =%d\n"),infoPtr->iMinLevel);

 			gTest.Printf(_L("SetSharedResource: Resource MaxLevel =%d\n"),infoPtr->iMaxLevel);

 			if((infoPtr->iMaxLevel - readValue) > LEVEL_GAP_REQUIRED_FOR_ASYNC_TESTING)

 				{

 				gSharedResource = tryResourceId;

 				gSharedResStateDelta = 1;  // Will change resource level in positive direction

 				gHaveSharedRes = ETrue;

 				}

 			else if((readValue - infoPtr->iMinLevel) > LEVEL_GAP_REQUIRED_FOR_ASYNC_TESTING)

 				{

 				gSharedResource = tryResourceId;

 				gSharedResStateDelta = -1;  // Will change resource level in negative direction

 				gHaveSharedRes = ETrue;

 				}

 			else

 				{

 				++index;

 				--numPotentialResources;

 				}

 			};

 		}

 	if(!gHaveSharedRes)

 		{

 	    gTest.Printf(_L("**Test SetSharedResource - don't have suitable resource ... exiting\n"));

 		return KErrNotReady;

 		}

 	__KHEAP_MARKEND;

 	return KErrNone;

 	}

 #endif

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0609

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests APIs for retrieving information about 

 //!						(1) clients of the channel and 

 //!						(2) power resources. 

 //!						Since the client lacks the ReadDeviceData PlatSec capability it will not

 //!						be permitted to access information about kernel-side clients

 //! 

 //!						The tests are invoked a number of times:

 //!						-	first, to examine the starting state

 //!						-	then, to examine the effect of adding a new client (channel)

 //!						-	then, the examine the effect of adding a new client that requests a

 //|							level on a resource

 //!						-	then, to test the effect of the original client requesting a level 

 //!							on a resource

 //! 

 //! @SYMTestActions     0) Call GetNoOfClients API with default aIncludeKern=EFalse.

 //! 

 //!						1) Call GetNoOfClients API with aIncludeKern=ETrue.

 //!

 //!						2) Call GetNamesAllClients API with default aIncludeKern=EFalse.

 //!

 //!						3) Call GetNamesAllClients API with aIncludeKern=ETrue.

 //!

 //!						4) Call GetNumClientsUsingResource API with aIncludeKern=ETrue.

 //!

 //!						5) Call GetNumClientsUsingResource API with default aIncludeKern=EFalse.

 //!

 //!						6) Call GetInfoOnClientsUsingResource API with default aIncludeKern=EFalse.

 //!

 //!						7) Call GetInfoOnClientsUsingResource API with aIncludeKern=ETrue.

 //!

 //!						8) GetNumResourcesInUseByClient for the original client

 //!

 //!						9) GetNumResourcesInUseByClient for a non-existent client

 //!

 //!						10) GetInfoOnResourcesInUseByClient for the original client

 //!

 //!						11) GetInfoOnResourcesInUseByClient for a non-existent client

 //!

 //! @SYMTestExpectedResults 0) API should return with KErrNone, exits otherwise.

 //!

 //!						1) If client exhibits PlatSec capability ReadDeviceData, API should return with KErrNone, exits otherwise.

 //!						   If client lacks PlatSec capability ReadDeviceData, API should return with KErrPermissionDenied, exits otherwise.

 //!

 //!						2) API should return with KErrNone, exits otherwise.

 //!

 //!						3) If client exhibits PlatSec capability ReadDeviceData, API should return with KErrNone, exits otherwise

 //!						   If client lacks PlatSec capability ReadDeviceData, API should return with KErrPermissionDenied, exits otherwise

 //!

 //!						4) If client exhibits PlatSec capability ReadDeviceData, API should return with KErrNone, exits otherwise.

 //!						   If client lacks PlatSec capability ReadDeviceData, API should return with KErrPermissionDenied, exits otherwise.

 //!

 //!						5) API should return with KErrNone, exits otherwise

 //!

 //!						6) API should return with KErrNone, exits otherwise.

 //!

 //!						7) If client exhibits PlatSec capability ReadDeviceData, API should return with KErrNone, exits otherwise

 //!						   If client lacks PlatSec capability ReadDeviceData, API should return with KErrPermissionDenied, exits otherwise

 //!

 //!						8) API should return with KErrNone, exits otherwise.

 //!

 //!						9) API should return with KErrNotFound, exits otherwise.

 //!

 //!						10) API should return with KErrNone, exits otherwise.

 //!

 //!						11) API should return with KErrNotFound, exits otherwise.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt TestGetClientGetResourceInfo()

 //

 // Test methods to access information about clients and resources

 //

 	{

 	TInt r = KErrNone;

 	// Open a couple of additional channels  

 	_LIT(tempStr1,"ExtraChan1");

 	TBufC<16> tempName1(tempStr1);

 	_LIT(tempStr2,"ExtraChan2");

 	TBufC<16> tempName2(tempStr2);

 	RBusDevResManUs channelTwo;

 	RBusDevResManUs channelThree;

 	if((r=OpenChannel(tempName1, channelTwo))!=KErrNone)

 		return r;

 	if((r=OpenChannel(tempName2, channelThree))!=KErrNone)

 		return r;

 	// Test the tracking of the client and resource info

 	//

 	// First invocation to establish starting state

 #ifdef _DEBUG

 	gTest.Printf(_L("TestGetClientGetResourceInfo: First HelperGetClientResourceInfo call (starting state):\n"));

 #endif

 	if((r=HelperGetClientResourceInfo())!=KErrNone)

 		return r;

 	// Second invocation - examine effect of adding a client

 	_LIT(tempStr3,"ExtraChan3");

 	TBufC<16> tempName3(tempStr3);

 	RBusDevResManUs channelFour;

 	if((r=OpenChannel(tempName3, channelFour))!=KErrNone)

 		return r;

 #ifdef _DEBUG

 	gTest.Printf(_L("TestGetClientGetResourceInfo: Second HelperGetClientResourceInfo call (added client ExtraChan3):\n"));

 #endif

 	if((r=HelperGetClientResourceInfo())!=KErrNone)

 		return r;

 	// Third invocation  - examine effect of new client requesting a level for a resource

 	// (This relies on getting and setting the state of gSharedResource - so skip the 

 	// test if this has not yet been identified

 	//

 	TUint startingLevel = 0;

 #ifdef _DEBUG

 	if((r=SetSharedResource())!=KErrNone)

 		return r;

 #endif

 	if(!gHaveSharedRes)

 		{

 		gTest.Printf(_L("TestGetClientGetResourceInfo: no suitable shareable resource, so skipping third call:\n"));

 		}

 	else

 		{

 		// Channel registration

 		gTest.Printf(_L("Initialise for temporary channel with arguments 1,1,0\n"));

 		if ((r=channelFour.Initialise(1,1,0))!=KErrNone)  // Just need 1 get and 1 set state

 			{

 			gTest.Printf(_L("Initialise for channel returned %d\n"),r);

 			return r;

 			}

 		// Get initial state

 		TRequestStatus status;

 		TBool cached = gUseCached;

 		TInt readValue;

 		TInt levelOwnerId = 0;

 		channelFour.GetResourceState(status,gSharedResource,cached,&readValue,&levelOwnerId);

 		User::WaitForRequest(status);

 		r=status.Int();

 		if(r != KErrNone)

 			{

 			gTest.Printf(_L("TestGetClientGetResourceInfo, first get state for shareable returned %d\n"),r);

 			return r;

 			}

 		startingLevel = (TUint)readValue;

 		// Write updated state

 		TUint newLevel = (TUint)(readValue + gSharedResStateDelta);

 		gTest.Printf(_L("TestGetClientGetResourceInfo: levelOwnerId = %d\n"), levelOwnerId);

 		gTest.Printf(_L("TestGetClientGetResourceInfo: shareable resource startingLevel=0x%x, writing 0x%x\n"), startingLevel, newLevel);

 		channelFour.ChangeResourceState(status,gSharedResource,newLevel);

 		User::WaitForRequest(status);

 		r=status.Int();

 		if(r != KErrNone)

 			{

 			gTest.Printf(_L("TestGetClientGetResourceInfo, first change state for shareable resource returned %d\n"),r);

 			return r;

 			}

 #ifdef _DEBUG

 		gTest.Printf(_L("TestGetClientGetResourceInfo: third HelperGetClientResourceInfo call (new client set level on shared resource):\n"));

 #endif

 		if((r=HelperGetClientResourceInfo())!=KErrNone)

 			return r;

 		}

 	// Fourth invocation - examine effect of orignal client requesting a level for 

 	// the Shared resource

 	if(gHaveSharedRes)

 		{

 		TRequestStatus status;

 		TBool cached = gUseCached;

 		TInt readValue;

 		TInt levelOwnerId;

 		gChannel.GetResourceState(status,gSharedResource,cached,&readValue,&levelOwnerId);

 		User::WaitForRequest(status);

 		r=status.Int();

 		if(r != KErrNone)

 			{

 			gTest.Printf(_L("TestGetClientGetResourceInfo, gChannel get state on Shareable resource returned %d\n"),r);

 			return r;

 			}

 		gTest.Printf(_L("TestGetClientGetResourceInfo, GetResourceState levelOwnerId =  %d\n"),levelOwnerId);		// Request a level on the resource

 		gChannel.ChangeResourceState(status,gSharedResource,(readValue+gSharedResStateDelta));

 		User::WaitForRequest(status);

 		if(status.Int() != KErrNone)

 			{

 			gTest.Printf(_L("TestGetClientGetResourceInfo, gChannel change state on Shareable returned %d\n"),r);

 			return r;

 			}

 #ifdef _DEBUG

 	gTest.Printf(_L("TestGetClientGetResourceInfo: fourth HelperGetClientResourceInfo call (gChannel set level on Shareable resource):\n"));

 #endif

 		if((r=HelperGetClientResourceInfo())!=KErrNone)

 		return r;

 		}

 	// Return the resource to the state it was on function entry

 	if(gHaveSharedRes)

 		{

 		TRequestStatus status;

 		gTest.Printf(_L("TestGetClientGetResourceInfo: returning sharable resource to startingLevel=0x%x\n"), startingLevel);

 		gChannel.ChangeResourceState(status,gSharedResource,startingLevel);

 		User::WaitForRequest(status);

 		r=status.Int();

 		if(r != KErrNone)

 			{

 			gTest.Printf(_L("TestGetClientGetResourceInfo, attempt to reset shareable resource state returned %d\n"),r);

 			return r;

 			}

 		}

 	// Close the temporary channels

 	channelTwo.Close();

 	channelThree.Close();

 	channelFour.Close();

 	return r;

 	}

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0610

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests APIs for getting and setting the state of resources; 

 //!						it also tests APIs to cancel such requests.

 //! 

 //! @SYMTestActions     0) Call API to get the initial state of a selected resource.

 //! 

 //!						1) Call API to modify the state of the resource.

 //! 

 //!						2) Call API to get the new state of the resource and check it exhibits

 //!						the expected value.

 //! 

 //!						3) Call API to return the resource state to its original value.

 //! 

 //!						4) Call API to get the state of a long latency resource then call API

 //!						with operation-type qualifier cancel the request.

 //! 

 //!						5) Call API to modify the state of the long latency resource then call API

 //!						with operation-type qualifier to cancel the request.

 //! 

 //!						6) Call API to get the state of a long latency resource and wait for it 

 //!						to complete. Then call API with operation-type qualifier to cancel the request.

 //! 

 //!						7) Call API to modify the state of the long latency resource and wait for

 //!						it to complete. Then call API with operation-type qualifier to cancel the request.

 //! 

 //!						8) Call API to get the state of a long latency resource then call API

 //!						without operation-type qualifier to cancel the request.

 //! 

 //!						9) Call API to modify the state of the long latency resource then call API

 //!						without operation-type qualifier to cancel the request.

 //! 

 //!						10) Call API to get the state of a long latency resource and wait for it 

 //!						to complete. Then call API without operation-type qualifier to cancel the request.

 //! 

 //!						11) Call API to modify the state of the long latency resource and wait for

 //!						it to complete. Then call API without operation-type qualifier to cancel the request.

 //! 

 //!						12) Call API to get the state of a long latency resource 'n' times. Then call API with 

 //!						resource qualifier to cancel the requests.

 //! 

 //!						13) Call API to modify the state of a long latency resource 'm' times. Then call API with 

 //!						resource qualifier to cancel the requests.

 //! 

 //!						14) Call API to get the state of a long latency resource 'n' times and wait for them to complete.

 //!						Then call API with resource qualifier to cancel the requests.

 //! 

 //!						15) Call API to modify the state of a long latency resource 'm' times and wait for them to complete.

 //!						Then call API with resource qualifier to cancel the requests.

 //! 

 //!						16) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 //!						a long latency resource 'm' times. Call the API to cancel the get operations with resource qualifier.

 //!						Wait for the operations to complete. Check the state of the associated TRequestStatus objects.

 //! 

 //!						17) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 //!						a long latency resource 'm' times. Call the API to cancel the modify operations with resource qualifier.

 //!						Wait for the get operations to complete. Check the state of the associated TRequestStatus objects.

 //! 

 //!						18) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 //!						a long latency resource 'm' times. Wait for the get operations to complete. Call the API to cancel the get

 //!						operations with resource qualifier. Check the state of the associated TRequestStatus objects.

 //! 

 //!						19) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 //!						a long latency resource 'm' times. Wait for the modify operations to complete. Call the API to cancel the modify

 //!						operations with resource qualifier. Check the state of the associated TRequestStatus objects.

 //! 

 //!						20) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 //!						a long latency resource 'm' times.

 //!						Then call API with operation-type qualifier to cancel the even-numbered get request(s).

 //!						Then call API without operation-type qualifier to cancel the even-numbered modify request(s).

 //!						Check the state of the associated TRequestStatus objects.

 //! 

 //! @SYMTestExpectedResults 0) The associated TRequestStatus object should indicate KErrNone, exits otherwise.

 //! 

 //!						1) The associated TRequestStatus object should indicate KErrNone, exits otherwise.

 //! 

 //!						2) The associated TRequestStatus object should indicate KErrNone, exits otherwise.

 //!						Exit if the value read back is not as expected.

 //! 

 //!						3) The associated TRequestStatus object should indicate KErrNone, exits otherwise.

 //! 

 //!						4) The associated TRequestStatus object should indicate KErrCancel if the cancel 

 //!						request was accepted, exits otherwise.

 //!						The associated TRequestStatus object should indicate KErrNone if the cancel request

 //!						was not accepted, exits otherwise.

 //! 

 //!						5) The associated TRequestStatus object should indicate KErrCancel if the cancel 

 //!						request was accepted, exits otherwise.

 //!						The associated TRequestStatus object should indicate KErrNone if the cancel request

 //!						was not accepted, exits otherwise.

 //! 

 //!						6) The TRequestStatus object associated with the get operation should indicate 

 //!						KErrNone - exits otherwise. The TRequestStatus object associated with the cancel

 //!						operation should indicate KErrNone - exits otherwise.

 //! 

 //!						7) The TRequestStatus object associated with the get operation should indicate

 //!						KErrNone - exits otherwise. The TRequestStatus object associated with the cancel

 //!						operation should indicate KErrNone - exits otherwise.

 //! 

 //!						8) The associated TRequestStatus object should indicate KErrCancel, exits otherwise.

 //! 

 //!						9) The associated TRequestStatus object should indicate KErrCancel, exits otherwise.

 //! 

 //!						10) The TRequestStatus object associated with the get operation should indicate 

 //!						KErrNone - exits otherwise. The TRequestStatus object associated with the cancel

 //!						operation should indicate KErrNone - exits otherwise.

 //! 

 //!						11) The TRequestStatus object associated with the get operation should indicate

 //!						KErrNone - exits otherwise. The TRequestStatus object associated with the cancel

 //!						operation should indicate KErrNone - exits otherwise.

 //!

 //!						12) The TRequestStatus objects should all exibit KErrCancel - exits otherwise.

 //! 

 //!						13) The TRequestStatus objects should all exibit KErrCancel - exits otherwise.

 //! 

 //!						14) The TRequestStatus objects associated with the get operations should all exibit KErrNone - exits otherwise.

 //!						The TRequestStatus objects associated with the cancel operations should all exibit KErrNone - exits otherwise

 //! 

 //!						15) The TRequestStatus objects associated with the modify operations should all exibit KErrNone - exits otherwise.

 //!						The TRequestStatus objects associated with the cancel operations should all exibit KErrNone - exits otherwise

 //! 

 //!						16) The TRequestStatus objects associated with the get operations should all exibit KErrCancel - exits otherwise.

 //!						The TRequestStatus objects associated with the modify operations should all exibit KErrNone - exits otherwise

 //! 

 //!						17) The TRequestStatus objects associated with the get operations should all exibit KErrNone - exits otherwise.

 //!						The TRequestStatus objects associated with the modify operations should all exibit KErrCancel - exits otherwise

 //! 

 //!						18) The TRequestStatus objects associated with the get and modify operations should all exibit KErrNone - exits otherwise.

 //! 

 //!						19) The TRequestStatus objects associated with the get and modify operations should all exibit KErrNone - exits otherwise.

 //!

 //!						20) The TRequestStatus objects associated with the even-numbered request should exhibit KErrCancel.

 //!						The TRequestStatus objects associated with the odd-numbered request should exhibit KErrNone.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt TestGetSetResourceStateOps()

 //

 // Test resource state access methods

 //

 	{

 	TInt r = KErrNone;

 	TRequestStatus status;

 	TBool cached = gUseCached;

 	TInt readValue = 0;

 	TInt levelOwnerId = 0;

 	TInt testNo = 0;

 #ifdef _DEBUG

 	// Ensure we have a resource we can use

 	if((r=SetAsyncResource())!=KErrNone)

 		return r;

 #endif

 	// 0) Call API to get the initial state of a selected resource.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, get state status = %d\n"),r);

 		return r;

 		}

 	TUint startingLevel = (TUint)readValue;

 	gTest.Printf(_L("TestGetSetResourceStateOps: initial level read =0x%x, levelOwnerId = %d\n"),readValue,levelOwnerId);

 	// 1) Call API to modify the state of the resource.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	TUint newLevel = (TUint)(readValue + gAsyncResStateDelta);

 	gTest.Printf(_L("TestGetSetResourceStateOps: writing 0x%x\n"), newLevel);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,newLevel);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, first change state returned %d\n"),r);

 		return r;

 		}

 	// 2) Call API to get the new state of the resource and check it exhibits the expected value.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, get state status = %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("TestGetSetResourceStateOps: level read back =0x%x, levelOwnerId=%d\n"),readValue,levelOwnerId);

 	gTest(newLevel==(TUint)readValue);

 	// 3) Call API to return the resource state to its original value.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gTest.Printf(_L("TestGetSetResourceStateOps: write original level 0x%x\n"), startingLevel);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,startingLevel);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, change state status = %d\n"),r);

 		return r;

 		}

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, get state status = %d\n"),r);

 		return r;

 		}

 	gTest.Printf(_L("TestGetSetResourceStateOps: check original level read back =0x%x, levelOwnerId=%d\n"),readValue,levelOwnerId);

 	// 4) Call API to get the state of a long latency resource then call API with operation-type qualifier cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	r=gChannel.CancelGetResourceState(status);

 	if(r!=KErrInUse)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, CancelGetResourceState returned %d\n"),r);

 		}

 	if(r!=KErrCompletion) // If request had not completed before cancellation request

 		{

 		User::WaitForRequest(status);

 		if(r==KErrNone)	// Cancel expected to proceed as requested

 			{

 			if(status.Int() != KErrCancel)

 				{

 				gTest.Printf(_L("TestGetSetResourceStateOps, expected KErrCancel but cancelled get state status = %d\n"),r);

 				return r;

 				}

 			}

 		else if(r==KErrInUse)	// Cancel failed since request was being processed - so expect successful completion

 			{

 			if(status.Int() != KErrNone)

 				{

 				gTest.Printf(_L("TestGetSetResourceStateOps, expected KErrNone but cancelled get state status = %d\n"),r);

 				return r;

 				}

 			}

 		else if(status.Int() != KErrCancel)	// Just report the error code and return

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status = %d\n"),r);

 			return r;

 			}

 		}

 	// 5) Call API to modify the state of the long latency resource then call API with operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	newLevel = (TUint)(readValue + gAsyncResStateDelta);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,newLevel);

 	r=gChannel.CancelChangeResourceState(status);

 	if(r!=KErrInUse)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, CancelChangeResourceState returned %d\n"),r);

 		}

 	if(r!=KErrCompletion) // If request had not completed before cancellation request

 		{

 		User::WaitForRequest(status);

 		if(r==KErrNone)	// Cancel expected to proceed as requested

 			{

 			if(status.Int() != KErrCancel)

 				{

 				gTest.Printf(_L("TestGetSetResourceStateOps, expected KErrCancel but cancelled get state status = %d\n"),r);

 				return r;

 				}

 			}

 		else if(r==KErrInUse)	// Cancel failed since request was being processed - so expect successful completion

 			{

 			if(status.Int() != KErrNone)

 				{

 				gTest.Printf(_L("TestGetSetResourceStateOps, expected KErrNone but cancelled get state status = %d\n"),r);

 				return r;

 				}

 			}

 		else if(status.Int() != KErrCancel)	// Just report the error code and return

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status = %d\n"),r);

 			return r;

 			}

 		}

 	// 6) Call API to get the state of a long latency resource and wait for it to complete.

 	//    Then call API with operation-type qualifier to cancel the request.	

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, get state status = %d\n"),r);

 		return r;

 		}

 	r=gChannel.CancelGetResourceState(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, CancelGetResourceState returned %d\n"),r);

 		}

 	if(status.Int() != KErrNone)	// TRequestStatus should be unchanged

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, completed-then-cancelled get state status = %d\n"),r);

 		return r;

 		}

 	// 7) Call API to modify the state of the long latency resource and wait for it to complete. 

 	//    Then call API with operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,(readValue + gAsyncResStateDelta));

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, change state status = %d\n"),r);

 		return r;

 		}

 	r=gChannel.CancelChangeResourceState(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, CancelChangeResourceState returned %d\n"),r);

 		}

 	if(status.Int() != KErrNone)	// TRequestStatus should be unchanged

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, completed-then-cancelled change state status = %d\n"),r);

 		return r;

 		}

 	// 8) Call API to get the state of a long latency resource then call API without operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	gChannel.CancelAsyncOperation(&status);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrCancel)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status = %d\n"),r);

 		return r;

 		}

 	// 9) Call API to modify the state of the long latency resource then call API without operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	newLevel = (TUint)(readValue + gAsyncResStateDelta);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,newLevel);

 	gChannel.CancelAsyncOperation(&status);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrCancel)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, cancelled change state status = %d\n"),r);

 		return r;

 		}

 	// 10) Call API to get the state of a long latency resource and wait for it to complete.

 	//     Then call API without operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.GetResourceState(status,gLongLatencyResource,cached,&readValue,&levelOwnerId);

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, get state status = %d\n"),r);

 		return r;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	if(status.Int() != KErrNone)	// TRequestStatus should be unchanged

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, completed-then-cancelled get state status = %d\n"),r);

 		return r;

 		}

 	// 11) Call API to modify the state of the long latency resource and wait for it to complete. 

 	//     Then call API without operation-type qualifier to cancel the request.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	gChannel.ChangeResourceState(status,gLongLatencyResource,(readValue + gAsyncResStateDelta));

 	User::WaitForRequest(status);

 	if(status.Int() != KErrNone)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, change state status = %d\n"),r);

 		return r;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	if(status.Int() != KErrNone)	// TRequestStatus should be unchanged

 		{

 		gTest.Printf(_L("TestGetSetResourceStateOps, completed-then-cancelled change state status = %d\n"),r);

 		return r;

 		}

 	// 'n' and 'm' values and support for cancellation of multiple requests

 	const TInt KLoopVarN = 2;

 	const TInt KLoopVarM = 3;

 	TRequestStatus getReqStatus[KLoopVarN];

 	TRequestStatus setReqStatus[KLoopVarM];

 	TInt i=0;

 	// 12) Call API to get the state of a long latency resource 'n' times. 

 	//     Then call API with resource qualifier to cancel the requests.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	gChannel.CancelGetResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 13) Call API to modify the state of a long latency resource 'm' times. 

 	//     Then call API with resource qualifier to cancel the requests.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	gChannel.CancelChangeResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 14) Call API to get the state of a long latency resource 'n' times and wait for them to complete.

 	//     Then call API with resource qualifier to cancel the requests.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, before cancel get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	gChannel.CancelGetResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, after cancel get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 15) Call API to modify the state of a long latency resource 'm' times and wait for them to complete.

 	//     Then call API with resource qualifier to cancel the requests.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, before cancel change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	gChannel.CancelChangeResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarM;i++)

 		{

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, after cancel change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 16) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 	//     a long latency resource 'm' times. 

 	//     Call the API to cancel the get operations with resource qualifier.

 	//     Wait for the operations to complete. Check the state of the associated TRequestStatus objects.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	gChannel.CancelGetResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed  change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 17) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 	//     a long latency resource 'm' times. 

 	//     Call the API to cancel the modify operations with resource qualifier.

 	//     Wait for the get operations to complete. Check the state of the associated TRequestStatus objects.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	gChannel.CancelChangeResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 18) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 	//     a long latency resource 'm' times. Wait for the get operations to complete. 

 	//     Call the API to cancel the get operations with resource qualifier. Check the state of the associated TRequestStatus objects.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	TInt flipper = -1;

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + (flipper*gAsyncResStateDelta)));

 		flipper*=-1;

 		}

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	gChannel.CancelGetResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed change state status[%d]= %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarN;i++)

 		{

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed-then-cancelled get state status[%d]= %d\n"),i,r);

 			return r;

 			}

 		}

 	// 19) Call API to get the state of a long latency resource 'n' times, call API to modify the state of

 	//     a long latency resource 'm' times. Wait for the modify operations to complete. Call the API to cancel the modify

 	//     operations with resource qualifier. Check the state of the associated TRequestStatus objects.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	gChannel.CancelChangeResourceStateRequests(gLongLatencyResource);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	// 20) Call API to get the state of a long latency resource 'n' times, call API to modify the state of a long latency resource 'm' times.

 	//     Then call API without operation-type qualifier to cancel the even-numbered modify request(s).

 	//     Then call API with operation-type qualifier to cancel the even-numbered get request(s).

 	//     Check the state of the associated TRequestStatus objects.

 	gTest.Printf(_L("TestGetSetResourceStateOps, starting test %d\n"),testNo++);

 	for(i=0;i<KLoopVarN;i++)

 		{

 		gChannel.GetResourceState(getReqStatus[i],gLongLatencyResource,cached,&readValue,&levelOwnerId);

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		gChannel.ChangeResourceState(setReqStatus[i],gLongLatencyResource,(readValue + gAsyncResStateDelta));

 		}

 	for(i=0;i<KLoopVarM;i+=2)

 		{

 		gChannel.CancelAsyncOperation(&(setReqStatus[i]));

 		}

 	for(i=0;i<KLoopVarN;i+=2)

 		{

 		r=gChannel.CancelGetResourceState(getReqStatus[i]);

 		if(r!=KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, CancelGetResourceState for index %d returned %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarM;i++)

 		{

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		if(++i >= KLoopVarM)

 			break;

 		User::WaitForRequest(setReqStatus[i]);

 		if((r=setReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed change state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}

 	for(i=0;i<KLoopVarN;i++)

 		{

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrCancel)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, cancelled get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		if(++i >= KLoopVarN)

 			break;

 		User::WaitForRequest(getReqStatus[i]);

 		if((r=getReqStatus[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateOps, completed get state status[%d] = %d\n"),i,r);

 			return r;

 			}

 		}	

 	return KErrNone;

 	}

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0611

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests APIs for regulating getting and setting the state of resources 

 //! 

 //! @SYMTestActions     0) Issue the maximum number (requested in the call to the Initialise API)

 //!						of requests to get the current state of a resource. Then issue one further request.

 //!

 //!						1) Issue the maximum number (requested in the call to the Initialise API) of 

 //!						requests to set the current state of a resource. Then issue one further request.

 //!

 //! @SYMTestExpectedResults 0) Test that the TRequestStatus object associated with the last request

 //!							exhibits status code KErrUnderflow - exit otherwise. Test that the 

 //!							TRequestStatus objects associated with the preceding requests exhibit 

 //!							status code KErrNone - exit otherwise.

 //!

 //!							1) Test that the TRequestStatus object associated with the last request

 //!							exhibits status code KErrUnderflow - exit otherwise. Test that the 

 //!							TRequestStatus objects associated with the preceding requests exhibit 

 //!							status code KErrNone - exit otherwise.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt TestGetSetResourceStateQuota()

 //

 // Test resource state access quota management

 //

 	{

 	TUint resourceId;

 	// To perform the quota test we need a long latency resource

 	// If one has not been defined alert the user and return

 	if(!gHaveAsyncRes)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateQuota: don't have suitable asynchronous resource ... exiting\n"));

 		return KErrNone;

 		}

 	else

 		resourceId = gLongLatencyResource;

 	TInt r = KErrNone;

 	TBool lastErr = KErrNone;

 	TInt i = 0;

 	TRequestStatus status[MAX_NUM_REQUESTS];

 	TInt state[MAX_NUM_REQUESTS];

 	TBool cached = gUseCached;

 	TInt levelOwnerId = 0;

 	//

 	//	Test GetResourceState - check client can not exceed quota of requests

 	//

     gTest.Printf(_L("**Test GetResourceState (quota management)\n"));

 	// KNoOfGetStateRequests Get state requests (of the same resource, ID=1) to consume the client quota

 	for(i=0; i<KNoOfGetStateRequests; i++)

 		gChannel.GetResourceState(status[i],resourceId,cached,&(state[i]),&levelOwnerId);

 	// Addition Get state request to exceed the quota - the provided TRequestStatus

 	// object should indicate KErrUnderflow

 	gChannel.GetResourceState(status[KNoOfGetStateRequests],resourceId,cached,&(state[KNoOfGetStateRequests]),&levelOwnerId);

 	User::WaitForRequest(status[KNoOfGetStateRequests]);

 	if(status[KNoOfGetStateRequests].Int() != KErrUnderflow)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateQuota, extra get state returned %d\n"),r);

 		return r;

 		}

 	// Need to check the TRequestStatus objects

 	for(i=0; i<KNoOfGetStateRequests; i++)

 		{

 		User::WaitForRequest(status[i]);

 		if((r=status[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateQuota, get state %d returned %d\n"),i, r);

 			lastErr = r;

 			}

 		}

 	if(lastErr != KErrNone)

 		return lastErr;

 	//

 	//	Test ChangeResourceState - check client can not exceed quota of requests

 	//

     gTest.Printf(_L("**Test ChangeResourceState (quota management)\n"));

 	// KNoOfSetStateRequests Set state requests (of the same resource, ID=1) to consume the client quota

 	TInt newState = (state[1])+1;

 	for(i=0; i<KNoOfSetStateRequests; i++)

 		{

 		gChannel.ChangeResourceState(status[i],resourceId,newState);

 		}

 	// Addition Set state request to exceed the quota - the provided TRequestStatus

 	// object should indicate KErrUnderflow

 	gChannel.ChangeResourceState(status[KNoOfSetStateRequests],resourceId,newState);

 	User::WaitForRequest(status[KNoOfSetStateRequests]);

 	if(status[KNoOfSetStateRequests].Int() != KErrUnderflow)

 		{

 		gTest.Printf(_L("TestGetSetResourceStateQuota, extra set state returned %d\n"),r);

 		return r;

 		}

 	// Need to check the TRequestStatus objects

 	for(i=0; i<KNoOfSetStateRequests; i++)

 		{

 		User::WaitForRequest(status[i]);

 		if((r=status[i].Int()) != KErrNone)

 			{

 			gTest.Printf(_L("TestGetSetResourceStateQuota, set state %d returned %d\n"),i, r);

 			lastErr = r;

 			}

 		}

 	if(lastErr != KErrNone)

 		return lastErr;

 	return r;

 	}

 LOCAL_C TInt TriggerNotification(TRequestStatus& aStatus, TUint aResourceId, TBool aCached, TInt aDelta)

 //

 // Support the notification tests - cause a notification for the specified resource

 //

 	{

 	TInt r = KErrNone;

 	TInt readValue = 0;

 	TInt levelOwnerId = 0;

 	// Get initial state

 	gChannel.GetResourceState(aStatus,aResourceId,aCached,&readValue,&levelOwnerId);

 	User::WaitForRequest(aStatus);

 	if(aStatus.Int() != KErrNone)

 		{

 		r=aStatus.Int();

 		gTest.Printf(_L("TriggerNotification, get state returned %d\n"),r);

 		return r;

 		}

 	TUint startingLevel = (TUint)readValue;

 	// Write updated state

 	TUint newLevel = (TUint)(readValue + aDelta);

 	gTest.Printf(_L("TriggerNotification: startingLevel=0x%x, writing 0x%x\n"), startingLevel, newLevel);

 	gChannel.ChangeResourceState(aStatus,aResourceId,newLevel);

 	User::WaitForRequest(aStatus);

 	if(aStatus.Int() != KErrNone)

 		{

 		r=aStatus.Int();

 		gTest.Printf(_L("TriggerNotification, change state returned %d\n"),r);

 		return r;

 		}

 	return r;

 	}

 LOCAL_C TInt CalcNotifyDirAndThr(TRequestStatus& aStatus, TUint aResourceId, TBool aCached, TInt& aThreshold, TBool& aDirection)

 //

 // Support the notification tests - determine an appropriate threshold and direction to request

 //

 	{

 	__KHEAP_MARK;

 	// Need to know current state

 	TInt r = KErrNone;

 	TInt readValue = 0;

 	TInt levelOwnerId = 0;

 		{

 		gChannel.GetResourceState(aStatus,aResourceId,aCached,&readValue,&levelOwnerId);

 		User::WaitForRequest(aStatus);

 		if(aStatus.Int() != KErrNone)

 			{

 			r=aStatus.Int();

 			gTest.Printf(_L("TestNotificationOps, pre-qualified notify get state returned %d\n"),r);

 			return r;

 			}

 		}

 	aThreshold = readValue + gAsyncResStateDelta;

 	aDirection=(gAsyncResStateDelta>0)?ETrue:EFalse;

 	__KHEAP_MARKEND;

 	return r;

 	}

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0612

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests APIs for requesting both qualified and unqualified

 //!						notifications; it also tests APIs to cancel such requests. 

 //! 

 //! @SYMTestActions     0) Call API to request notification of an unqualified change in resource

 //!						state for a selected resource. Trigger a state change.

 //!

 //!						1) Call API to request notification of a qualified change in resource

 //!						state for a selected resource. Trigger a state change.

 //!	

 //!						2) Call API to request notification of an unqualified change in resource

 //!						state for a selected resource. Then call API to cancel all notifications for the resource.

 //!

 //!						3) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Then call API to cancel all notifications for the resource.

 //!

 //!						4) Call API to request notification of an unqualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel all

 //!						notifications for the resource.

 //!

 //!						5) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel all

 //!						notifications for the resource.

 //!

 //!						6) Call API to request notification of an unqualified change in resource

 //!						state for a selected resource. Then call API to cancel the notification request

 //!

 //!						7) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Then call API to cancel the notification request

 //!

 //!						8) Call API to request notification of an unqualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel the

 //!						notification request

 //!

 //!						9) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel the

 //!						notification request

 //!

 //!						10) Call API to request notification of an unqualified change in resource

 //!						state for a selected resource. Then call API to cancel generic async request

 //!

 //!						11) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Then call API to cancel generic async request

 //!

 //!						12) Call API to request notification of an unqualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel

 //!						generic async request

 //!

 //!						13) Call API to request notification of a qualified change in resource 

 //!						state for a selected resource. Trigger a state change. Then call API to cancel

 //!						generic async request

 //!

 //! @SYMTestExpectedResults 0) The associated TRequestStatus object should indicate KErrNone 

 //!						- exits otherwise.

 //!

 //!						1) The associated TRequestStatus object should indicate KErrNone 

 //!						- exits otherwise.

 //!

 //!						2) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						3) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						4) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //!						5) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //!						6) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						7) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						8) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //!						9) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //!						10) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						11) The associated TRequestStatus object should indicate KErrCancel 

 //!						- exits otherwise. 

 //!

 //!						12) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //!						13) The TRequestStatus object should indicate state KRequestPending until

 //!						the state change is triggered, upon which it should exhibit state 

 //!						KErrNone. After the cancellation it should still exhibit state KErrNone.

 //!						Exit for any deviation from this behaviour.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt TestNotificationOps()

 //

 // Test notification methods

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	TRequestStatus status;

 	TUint resourceId;

 	TInt stateDelta;

 	if(!gHaveAsyncRes)

 		{

 		resourceId = 2; // Arbitrary

 		stateDelta = 1; // Arbitrary

 		}

 	else

 		{

 		resourceId = gLongLatencyResource;

 		stateDelta = gAsyncResStateDelta;

 		}

 	TInt testIndex = 0;

 	// 0) Call API to request notification of an unqualified change in resource

 	//    state for a selected resource. Trigger a state change.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	TBool cached = gUseCached;

 	TRequestStatus triggerStatus;

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, stateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after TriggerNotification status = %d\n"),status.Int());

 		return r;

 		}

 	// 1) Call API to request notification of a qualified change in resource

 	//    state for a selected resource. Trigger a state change.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	TInt dumThreshold=0;

 	TBool dumDirection=EFalse;

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after TriggerNotification status = %d\n"),status.Int());

 		return r;

 		}

 	// 2) Call API to request notification of an unqualified change in resource

 	//    state for a selected resource. Then call API to cancel all notifications for the resource.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	r=gChannel.CancelNotificationRequests(resourceId);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests returned %d\n"),r);

 		return r;

 		}

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 3) Call API to request notification of a qualified change in resource 

 	//    state for a selected resource. Then call API to cancel all notifications for the resource.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	dumThreshold = 0;			// Arbitrary

 	dumDirection = ETrue;		// Arbitrary

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	r=gChannel.CancelNotificationRequests(resourceId);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests (qualified) returned %d\n"),r);

 		return r;

 		}

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after qualified request cancel status = %d\n"),status.Int());

 		return r;

 		}

 	// 4) Call API to request notification of an unqualified change in resource 

 	//    state for a selected resource. Trigger a state change. Then call API to cancel all

 	//    notifications for the resource.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger basic request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	r=gChannel.CancelNotificationRequests(resourceId);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests returned %d\n"),r);

 		return r;

 		}

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 5) Call API to request notification of a qualified change in resource 

 	//    state for a selected resource. Trigger a state change. Then call API to cancel all

 	//    notifications for the resource.

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger qualified request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	r=gChannel.CancelNotificationRequests(resourceId);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests (qualified) returned %d\n"),r);

 		return r;

 		}

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) qualified request status = %d\n"),status.Int());

 		return r;

 		}

 	// 6) Call API to request notification of an unqualified change in resource

 	//    state for a selected resource. Then call API to cancel the notification request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	r=gChannel.CancelRequestNotification(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests returned %d\n"),r);

 		return r;

 		}

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 7) Call API to request notification of a qualified change in resource 

 	//    state for a selected resource. Then call API to cancel the notification request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	dumThreshold = 0;			// Arbitrary

 	dumDirection = ETrue;		// Arbitrary

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	r=gChannel.CancelRequestNotification(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests (qualified) returned %d\n"),r);

 		return r;

 		}

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after qualified request cancel status = %d\n"),status.Int());

 		return r;

 		}

 	// 8) Call API to request notification of an unqualified change in resource 

 	//    state for a selected resource. Trigger a state change. Then call API to cancel the

 	//    notification request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger basic request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	r=gChannel.CancelRequestNotification(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests returned %d\n"),r);

 		return r;

 		}

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 9) Call API to request notification of a qualified change in resource 

 	//    state for a selected resource. Trigger a state change. Then call API to cancel the

 	//    notification request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger qualified request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	r=gChannel.CancelRequestNotification(status);

 	if(r!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps, CancelNotificationRequests (qualified) returned %d\n"),r);

 		return r;

 		}

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) qualified request status = %d\n"),status.Int());

 		return r;

 		}

 	// 10) Call API to request notification of an unqualified change in resource

 	//     state for a selected resource. Then call API to cancel generic async request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 11) Call API to request notification of a qualified change in resource 

 	//     state for a selected resource. Then call API to cancel generic async request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	dumThreshold = 0;			// Arbitrary

 	dumDirection = ETrue;		// Arbitrary

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrCancel)

 		{

 		gTest.Printf(_L("TestNotificationOps: after qualified request cancel status = %d\n"),status.Int());

 		return r;

 		}

 	// 12) Call API to request notification of an unqualified change in resource 

 	//     state for a selected resource. Trigger a state change. Then call API to cancel

 	//     generic async request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	gChannel.RequestNotification(status, resourceId);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger basic request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) basic request status = %d\n"),status.Int());

 		return r;

 		}

 	// 13) Call API to request notification of a qualified change in resource 

 	//     state for a selected resource. Trigger a state change. Then call API to cancel

 	//     generic async request

 	gTest.Printf(_L("TestNotificationOps: starting test %d\n"),testIndex++);

 	if((r=CalcNotifyDirAndThr(status, resourceId, cached, dumThreshold, dumDirection))!=KErrNone)

 		return r;

 	gChannel.RequestNotification(status, resourceId, dumThreshold, dumDirection);

 	if(status.Int() != KRequestPending)

 		{

 		gTest.Printf(_L("TestNotificationOps: status=%d\n"),status.Int());

 		return KErrGeneral;

 		}

 	// Pass gAsyncResStateDelta as this represents the delta value

 	if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 		return r;

 	User::WaitForRequest(status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: trigger qualified request before cancel, status = %d\n"),status.Int());

 		return r;

 		}

 	gChannel.CancelAsyncOperation(&status);

 	if(status.Int()!=KErrNone)

 		{

 		gTest.Printf(_L("TestNotificationOps: after cancel (completed) qualified request status = %d\n"),status.Int());

 		return r;

 		}

 	__KHEAP_MARKEND;

 	return r;

 	}

 //----------------------------------------------------------------------------------------------

 //! @SYMTestCaseID      KBASE-T_RESMANUS-0613

 //! @SYMTestType        UT

 //! @SYMPREQ            PREQ1398

 //! @SYMTestCaseDesc    This test case tests quota management for notification operations.

 //! 

 //! @SYMTestActions     0) Issue the maximum number (requested in the call to the Initialise API)

 //!						of requests for notification of unqualified changes to the state of a 

 //!						resource. Then issue one further request.

 //!

 //!						1) Issue the maximum number (requested in the call to the Initialise API)

 //!						of requests for notification of qualified changes to the state of a 

 //!						resource. Then issue one further request.

 //!

 //!						2) Issue the maximum number (requested in the call to the Initialise API)

 //!						of requests for notification changes to the state of a resource, where 

 //!						every odd request is for an unqualified change and every even request is

 //!						for a qualified change. Then issue one further request.

 //!

 //! @SYMTestExpectedResults 0) Test that the TRequestStatus object associated with the last 

 //!							request exhibits status code KErrUnderflow - exit otherwise. Test

 //!							that the TRequestStatus objects associated with the preceding requests

 //!							exhibit status code KErrNone - exit otherwise.

 //!

 //!							1) Test that the TRequestStatus object associated with the last request

 //!							exhibits status code KErrUnderflow - exit otherwise. Test that the 

 //!							TRequestStatus objects associated with the preceding requests exhibit

 //!							status code KErrNone - exit otherwise.

 //!

 //!							2) Test that the TRequestStatus object associated with the last request

 //!							exhibits status code KErrUnderflow - exit otherwise. Test that the 

 //!							TRequestStatus objects associated with the preceding requests exhibit

 //!							status code KErrNone - exit otherwise.

 //!

 //! @SYMTestPriority        High

 //! @SYMTestStatus          Implemented

 //----------------------------------------------------------------------------------------------

 LOCAL_C TInt TestNotificationQuota()

 //

 // Test notification request quota management

 //

 	{

 	__KHEAP_MARK;

 	TInt r = KErrNone;

 	TRequestStatus status[MAX_NUM_REQUESTS];

 	TInt loopVar=0;

 	TBool cached = gUseCached;

 	TRequestStatus triggerStatus;

 	TUint resourceId = gLongLatencyResource;

 	// Test quota for basic operation

 	//

 	// Loop to perform maximum number of requests, check TRequestStatus objects are pending

 	for(loopVar=0; loopVar<KNoOfNotifyRequests; loopVar++)

 		{

 		gChannel.RequestNotification(status[loopVar], resourceId);

 		if(status[loopVar].Int() != KRequestPending)

 			{

 			gTest.Printf(_L("TestNotificationQuota: status not KRequestPending, =%d\n"),

 													status[loopVar].Int());

 			return KErrGeneral;

 			}

 		}

 	// Issue one more request, check that TRequestStatus object exhibits state KErrUnderflow

 	gChannel.RequestNotification(status[KNoOfNotifyRequests], resourceId);

 	if(status[KNoOfNotifyRequests].Int() != KErrUnderflow)

 		{

 		gTest.Printf(_L("TestNotificationQuota: status[%d] not KErrUnderflow, =%d\n"),

 													KNoOfNotifyRequests,status[loopVar].Int());

 		return KErrGeneral;

 		}

 	// Loop to trigger previously-issued notifications, check TRequestStatus objects

 	for(loopVar=0; loopVar<KNoOfNotifyRequests; loopVar++)

 		{

 		// Pass gAsyncResStateDelta as this represents the delta value

 		if((r=TriggerNotification(triggerStatus, resourceId, cached, gAsyncResStateDelta))!=KErrNone)

 			return r;