Trying to figure out how to implement my WINC like compatibility layer. Going the emulation way is probably not so smart. We should not use the kernel but rather hook native functions in the Exec calls.
// 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;
User::WaitForRequest(status[loopVar]);
if(status[loopVar].Int()!=KErrNone)
{
gTest.Printf(_L("TestNotificationQuota: trigger basic request status[%d] = %d\n"),
loopVar,status[loopVar].Int());
return r;
}
}
// Test quota for qualified operation
//
TInt dumThreshold = -25; // Arbitrary
TBool dumDirection = ETrue; // Arbitrary
//
// Loop to perform maximum number of requests, check TRequestStatus objects are pending
for(loopVar=0; loopVar<KNoOfNotifyRequests; loopVar++)
{
if((r=CalcNotifyDirAndThr(status[loopVar], resourceId, cached, dumThreshold, dumDirection))!=KErrNone)
return r;
gChannel.RequestNotification(status[loopVar], resourceId, dumThreshold, dumDirection);
if(status[loopVar].Int() != KRequestPending)
{
gTest.Printf(_L("TestNotificationQuota: status[%d] not KRequestPending, =%d\n"),
loopVar,status[loopVar].Int());
return KErrGeneral;
}
}
// Issue one more request, check that TRequestStatus object exhibits state KErrUnderflow
if((r=CalcNotifyDirAndThr(status[KNoOfNotifyRequests], resourceId, cached, dumThreshold, dumDirection))!=KErrNone)
return r;
gChannel.RequestNotification(status[KNoOfNotifyRequests], resourceId, dumThreshold, dumDirection);
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;
User::WaitForRequest(status[loopVar]);
if(status[loopVar].Int()!=KErrNone)
{
gTest.Printf(_L("TestNotificationQuota: trigger qualified request status[%d] = %d\n"),
loopVar,status[loopVar].Int());
return r;
}
}
// Text quota with mixture of basic and qualified requests
//
TBool qualified = ETrue;
// Issue requests and check TRequestStatus objects are pending
for(loopVar=0; loopVar<KNoOfNotifyRequests; loopVar++)
{
if(qualified)
{
if((r=CalcNotifyDirAndThr(status[loopVar], resourceId, cached, dumThreshold, dumDirection))!=KErrNone)
return r;
gChannel.RequestNotification(status[loopVar], resourceId, dumThreshold, dumDirection);
}
else
{
gChannel.RequestNotification(status[loopVar], resourceId);
}
qualified=!qualified;
if(status[loopVar].Int() != KRequestPending)
{
gTest.Printf(_L("TestNotificationQuota: mixed loop status[%d] not KRequestPending, =%d\n"),
loopVar,status[loopVar].Int());
return KErrGeneral;
}
}
// Issue one more request, check that TRequestStatus object exhibits state KErrUnderflow
if(qualified)
{
if((r=CalcNotifyDirAndThr(status[KNoOfNotifyRequests], resourceId, cached, dumThreshold, dumDirection))!=KErrNone)
return r;
gChannel.RequestNotification(status[KNoOfNotifyRequests], resourceId, dumThreshold, dumDirection);
}
else
{
gChannel.RequestNotification(status[KNoOfNotifyRequests], resourceId);
}
if(status[KNoOfNotifyRequests].Int() != KErrUnderflow)
{
gTest.Printf(_L("TestNotificationQuota: mixed loop 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;
User::WaitForRequest(status[loopVar]);
if(status[loopVar].Int()!=KErrNone)
{
gTest.Printf(_L("TestNotificationQuota: trigger mixed request status[%d] = %d\n"),
loopVar,status[loopVar].Int());
return r;
}
}
__KHEAP_MARKEND;
return r;
}
#ifdef PIRATE_THREAD_TESTS
RThread PirateThread;
TRequestStatus PirateStatus;
const TInt KHeapSize=0x4000;
const TInt KStackSize=0x4000;
_LIT(KPirateThreadName,"Pirate");
TInt PirateThreadFn(TAny* /*aSrcThread*/)
{
#if 0
TInt r=KErrNone;
RBusDevResManUs pirateChannel = gChannel;
RThread& thread = *((RThread*)aSrcThread);
/* 1 - pirate with current thread - Panics kernel with KErrBadHandle */
if((r=pirateChannel.Duplicate(RThread(),EOwnerProcess))!=KErrAccessDenied)
{
gTest.Printf(_L("TestThreadExclusiveAccess: pirateChannel.Duplicate(RThread(),EOwnerProcess) returned %d\n"),r);
return KErrGeneral;
}
/* 2 - pirate with parent thread - Panics kernel with KErrBadHandle */
pirateChannel = gChannel;
if((r=pirateChannel.Duplicate(thread,EOwnerThread))!=KErrAccessDenied)
{
gTest.Printf(_L("TestThreadExclusiveAccess: pirateChannel.Duplicate(thread,EOwnerThread) returned %d\n"),r);
return KErrGeneral;
}
/* 3 - gChannel with current thread - Panics kernel with KErrBadHandle */
if((r=gChannel.Duplicate(RThread(),EOwnerThread))!=KErrAccessDenied)
{
gTest.Printf(_L("TestThreadExclusiveAccess: gChannel.Duplicate(RThread(),EOwnerThread) returned %d\n"),r);
return KErrGeneral;
}
/* 4 - gChannel with parent thread - Panics kernel with KErrBadHandle */
if((r=gChannel.Duplicate(thread,EOwnerThread))!=KErrAccessDenied)
{
gTest.Printf(_L("TestThreadExclusiveAccess: gChannel.Duplicate(thread,EOwnerThread)returned %d\n"),r);
return KErrGeneral;
}
#endif
// pirateChannel.Close();
return KErrNone;
}
TInt StartPirate(RThread& aSrcThread)
{
TAny* srcThread =(TAny*)(&aSrcThread);
TInt r=PirateThread.Create(KPirateThreadName,PirateThreadFn,KStackSize,KHeapSize,KHeapSize,srcThread,EOwnerThread);
if (r!=KErrNone)
return r;
PirateThread.Logon(PirateStatus);
PirateThread.Resume();
return KErrNone;
}
TInt WaitForPirateThread()
{
User::WaitForRequest(PirateStatus);
TInt exitType=PirateThread.ExitType();
TInt exitReason=PirateThread.ExitReason();
TBuf<16> exitCat=PirateThread.ExitCategory();
if((exitType!= EExitKill)||(exitReason!=KErrNone))
{
gTest.Printf(_L("Pirate thread error: %d\n"),PirateStatus.Int());
gTest.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
gTest(0);
}
PirateThread.Close();
return KErrNone;
}
#endif
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-T_RESMANUS-0608
//! @SYMTestType UT
//! @SYMPREQ PREQ1398
//! @SYMTestCaseDesc This test case tests that channels can not be shared between threads.
//! @SYMTestActions 0) Attempt to Duplicate the channel handle with EOwnerProcess as the owner type.
//!
//! 1) Attempt to Duplicate the channel handle with EOwnerThread
//!
//! @SYMTestExpectedResults 0) API should return with KErrAccessDenied, exits otherwise.
//! 1) API should return with KErrNone, exits otherwise.
//!
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
LOCAL_C TInt TestThreadExclusiveAccess()
//
// Test mechanism to prevent other threads accessing a channel
//
{
__KHEAP_MARK;
TInt r;
RBusDevResManUs pirateChannel = gChannel;
if((r=pirateChannel.Duplicate(RThread(),EOwnerProcess))!=KErrAccessDenied)
{
gTest.Printf(_L("TestThreadExclusiveAccess: Duplicate with EOwnerProcess returned %d\n"),r);
if(r==KErrNone)
r=KErrGeneral;
return r;
}
pirateChannel = gChannel;
if((r=pirateChannel.Duplicate(RThread(),EOwnerThread))!=KErrNone)
{
gTest.Printf(_L("TestThreadExclusiveAccess: Duplicate with EOwnerThread returned %d\n"),r);
return r;
}
#ifdef PIRATE_THREAD_TESTS
RThread& threadRef = RThread();
if((r=StartPirate(threadRef))!=KErrNone)
{
gTest.Printf(_L("TestThreadExclusiveAccess: StartPirate returned %d\n"),r);
return KErrGeneral;
}
if((r=WaitForPirateThread())!=KErrNone)
{
gTest.Printf(_L("TestThreadExclusiveAccess: WaitForPirateThread returned %d\n"),r);
return KErrGeneral;
}
#endif
pirateChannel.Close();
__KHEAP_MARKEND;
return KErrNone;
}
RThread Thrd2;
TRequestStatus Thrd2Status;
const TInt KHeapSize=0x4000;
const TInt KStackSize=0x4000;
_LIT(KThrd2Name,"Thread2");
TInt Thread2Fn(TAny* /* */)
//
// Test that more than one thread can be supported
//
{
TInt r;
// Open a channel
//
_LIT(secThrdStr,"Thrd2Channel");
TBufC<16> secThrdName(secThrdStr);
// API accepts 8-bit descriptors, only - so convert name accordingly
TBuf8<MAX_RESOURCE_NAME_LENGTH+1>EightBitName;
EightBitName.Copy(secThrdName);
RBusDevResManUs secThrdChannel;
if((r=secThrdChannel.Open(EightBitName))!=KErrNone)
return r;
// Read the resource information
//
TUint numResources=0;
if((r=secThrdChannel.GetNoOfResources(numResources))!=KErrNone)
return r;
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
TUint bufSize = numResources;
RSimplePointerArray<TResourceInfoBuf> resPtrs(bufSize);
for(TUint i=0;i<bufSize;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=resPtrs.Insert(info, i))!=KErrNone)
return r;
}
TUint updateNumResources=numResources;
if((r=secThrdChannel.GetAllResourcesInfo(&resPtrs,updateNumResources))!=KErrNone)
return r;
resPtrs.Close();
// Read current client information
//
TUint numClients=0;
TUint numAllClients=0;
//
// GetNoOfClients - with default aIncludeKern=EFalse
//
if((r=secThrdChannel.GetNoOfClients(numClients,EFalse)) != KErrNone)
return r;
//
// GetNoOfClients - with aIncludeKern=ETrue
//
r=secThrdChannel.GetNoOfClients(numAllClients, ETrue);
#ifdef RESMANUS_KERN
if(r!=KErrNone)
#else
if(r!=KErrPermissionDenied)
#endif
return KErrGeneral;
//
// Need a buffer big enough to contain numClients instances of TClientName
// To support the GetNamesAllClients testing, instantiate TClientName objects
// and reference via an RSimplePointerArray
TUint resBufSize = (numAllClients>numClients)?numAllClients:numClients;
RSimplePointerArray<TClientName> infoPtrs(resBufSize);
for(TUint j=0;j<resBufSize;j++)
{
TClientName *info = new TClientName();
if((r=infoPtrs.Insert(info, j))!=KErrNone)
return r;
}
//
// GetNamesAllClients - with aIncludeKern=EFalse
//
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numClients, EFalse)) != KErrNone)
return r;
//
// GetNamesAllClients - with aIncludeKern=ETrue
//
#ifdef RESMANUS_KERN
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numAllClients, ETrue)) != KErrNone)
return r;
#else
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numClients, ETrue)) != KErrPermissionDenied)
{
if(r==KErrNone)
r=KErrGeneral;
return r;
}
else
r=KErrNone; // Ensure misleading result is not propagated
#endif
infoPtrs.Close();
// If we don't have a shared resource identified, skip the remaining tests
if(gHaveSharedRes)
{
// Register with the Resource Controller
//
if ((r=secThrdChannel.Initialise(1,1,0))!=KErrNone) // Just need 1 get and 1 set state
return r;
// Set a level on the shared resource
//
// Get initial state
TRequestStatus status;
TBool cached = gUseCached;
TInt readValue;
TInt levelOwnerId;
secThrdChannel.GetResourceState(status,gSharedResource,cached,&readValue,&levelOwnerId);
User::WaitForRequest(status);
r=status.Int();
if(r != KErrNone)
return r;
// Write updated state
TUint newLevel = (TUint)(readValue + gSharedResStateDelta);
secThrdChannel.ChangeResourceState(status,gSharedResource,newLevel);
User::WaitForRequest(status);
r=status.Int();
if(r != KErrNone)
return r;
// Read current client information
//
numClients=0;
numAllClients=0;
//
// GetNoOfClients - with default aIncludeKern=EFalse
//
if((r=secThrdChannel.GetNoOfClients(numClients,EFalse)) != KErrNone)
return r;
//
// GetNoOfClients - with aIncludeKern=ETrue
//
#ifdef RESMANUS_KERN
if((r=secThrdChannel.GetNoOfClients(numAllClients, ETrue))!=KErrNone)
#else
if((r=secThrdChannel.GetNoOfClients(numAllClients, ETrue))!=KErrPermissionDenied)
#endif
return KErrGeneral;
//
// Need a buffer big enough to contain numClients instances of TClientName
// 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)
return r;
}
//
// GetNamesAllClients - with aIncludeKern=EFalse
//
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numClients, EFalse)) != KErrNone)
return r;
//
// GetNamesAllClients - with aIncludeKern=ETrue
//
#ifdef RESMANUS_KERN
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numAllClients, ETrue)) != KErrNone)
return r;
#else
if((r=secThrdChannel.GetNamesAllClients(&infoPtrs, numClients, ETrue)) != KErrPermissionDenied)
{
if(r==KErrNone)
r=KErrGeneral;
return r;
}
else
r=KErrNone; // Ensure misleading result is not propagated
#endif
infoPtrs.Close();
// Read the resource information
//
numResources=0;
if((r=secThrdChannel.GetNoOfResources(numResources))!=KErrNone)
return r;
//
// Need a buffer big enough to contain numResources instances of TResourceInfoBuf
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> resPtrs(numResources);
for(TUint j=0;j<numResources;j++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=resPtrs.Insert(info, j))!=KErrNone)
return r;
}
if((r=secThrdChannel.GetAllResourcesInfo(&resPtrs,numResources))!=KErrNone)
return r;
resPtrs.Close();
}
// Close the channel
secThrdChannel.Close();
return r;
}
TInt StartThread2()
{
TInt r=Thrd2.Create(KThrd2Name,Thread2Fn,KStackSize,KHeapSize,KHeapSize,NULL,EOwnerThread);
if (r!=KErrNone)
return r;
Thrd2.Logon(Thrd2Status);
Thrd2.Resume();
return KErrNone;
}
TInt WaitForThread2()
{
User::WaitForRequest(Thrd2Status);
TInt exitType=Thrd2.ExitType();
TInt exitReason=Thrd2.ExitReason();
TBuf<16> exitCat=Thrd2.ExitCategory();
if((exitType!= EExitKill)||(exitReason!=KErrNone))
{
gTest.Printf(_L("Thread2 error: %d\n"),Thrd2Status.Int());
gTest.Printf(_L("Thread exit reason: %d,%d,%S\n"),exitType,exitReason,&exitCat);
gTest(0);
}
Thrd2.Close();
return KErrNone;
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-T_RESMANUS-0614
//! @SYMTestType UT
//! @SYMPREQ PREQ1398
//! @SYMTestCaseDesc This test case tests that an additional thread can open a channel and
//! exercise selected APIs.
//!
//! @SYMTestActions 0) Call API to open a channel.
//!
//! 1) Call GetNoOfResources API.
//!
//! 2) Call GetAllResourcesInfo API.
//!
//! 3) Call GetNoOfClients API with default aIncludeKern=EFalse.
//!
//! 4) Call GetNoOfClients API with aIncludeKern=ETrue
//!
//! 5) Call GetNamesAllClientsAPI with default aIncludeKern=EFalse.
//!
//! 6) Call GetNamesAllClientsAPI with aIncludeKern=ETrue
//!
//! 7) Call Initialise API.
//!
//! 8) Call GetResourceState API for selected resource.
//!
//! 9) Call GetResourceState API for selected resource.
//!
//! 10) Call GetNoOfClients API with default aIncludeKern=EFalse.
//!
//! 11) Call GetNoOfClients API with aIncludeKern=ETrue
//!
//! 12) Call GetNamesAllClientsAPI with default aIncludeKern=EFalse.
//!
//! 13) Call GetNamesAllClientsAPI with aIncludeKern=ETrue
//!
//! 14) Call GetNoOfResources API.
//!
//! 15) Call GetAllResourcesInfo API.
//!
//! @SYMTestExpectedResults 0) Test that the channel was opened - exit otherwise.
//!
//! 1) Test that the API call returned KErrNone - exit otherwise.
//!
//! 2) Test that the API call returned KErrNone - exit otherwise.
//!
//! 3) Test that the API call returned KErrNone - exit otherwise.
//!
//! 4) If client exhibits PlatSec capability ReadDeviceData, Test that the API call returned KErrNone - exit otherwise
//! If client lacks PlatSec capability ReadDeviceData, Test that the API call returned KErrPermissionDenied - exit otherwise
//!
//! 5) Test that the API call returned KErrNone - exit otherwise.
//!
//! 6) If client exhibits PlatSec capability ReadDeviceData, Test that the API call returned KErrNone - exit otherwise
//! If client lacks PlatSec capability ReadDeviceData, Test that the API call returned KErrPermissionDenied - exit otherwise
//!
//! 7) Test that the API call returned KErrNone - exit otherwise
//!
//! 8) Test that the associated TRequestStatus object exhibited state KErrNone - exit otherwise
//!
//! 9) Test that the associated TRequestStatus object exhibited state KErrNone - exit otherwise
//!
//! 10) Test that the API call returned KErrNone - exit otherwise.
//!
//! 11) If client exhibits PlatSec capability ReadDeviceData, Test that the API call returned KErrNone - exit otherwise
//! If client lacks PlatSec capability ReadDeviceData, Test that the API call returned KErrPermissionDenied - exit otherwise
//!
//! 12) Test that the API call returned KErrNone - exit otherwise.
//!
//! 13) If client exhibits PlatSec capability ReadDeviceData, Test that the API call returned KErrNone - exit otherwise
//! If client lacks PlatSec capability ReadDeviceData, Test that the API call returned KErrPermissionDenied - exit otherwise
//!
//! 14) Test that the API call returned KErrNone - exit otherwise.
//!
//! 15) Test that the API call returned KErrNone - exit otherwise.
//!
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
LOCAL_C TInt TestAdditionalThread()
//
// Test that more than one thread can be supported
//
{
TInt r;
if((r=StartThread2())!=KErrNone)
{
gTest.Printf(_L("TestAdditionalThread: StartThread2 returned %d\n"),r);
return KErrGeneral;
}
if((r=WaitForThread2())!=KErrNone)
{
gTest.Printf(_L("TestAdditionalThread: WaitForThread2 returned %d\n"),r);
return KErrGeneral;
}
return r;
}
LOCAL_C TInt LocateResourceWithDependencies(TUint &aNumResources, TUint &aResId, TUint &aNumDependents)
//
// Support function for tests of dependencies
//
{
__KHEAP_MARK;
TInt r = KErrNone;
if((r=gChannel.GetNoOfResources(aNumResources))!=KErrNone)
{
gTest.Printf(_L("GetNoOfResources for test channel returned %d\n"),r);
return r;
}
TUint bufSize = aNumResources;
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=aNumResources;
if((r=gChannel.GetAllResourcesInfo(&infoPtrs,updateNumResources))!=KErrNone)
{
gTest.Printf(_L("GetAllResourcesInfo for channel returned %d\n"),r);
return r;
}
for(TUint resNo=0;resNo<aNumResources;resNo++)
{
TResourceInfoBuf *info = infoPtrs[resNo];
TUint resId = ((*info)()).iId;
TUint numDependents = 0;
r=gChannel.GetNumDependentsForResource(resId,&numDependents, EFalse); // EFalse - don't load the dependency info
if((r!=KErrNone)&&(r!=KErrNotFound)&&(r!=KErrNotSupported))
{
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource returned %d\n"),r);
return r;
}
if(numDependents>0)
{
aResId = resId;
aNumDependents = numDependents;
break;
}
}
infoPtrs.Close();
__KHEAP_MARKEND;
return r;
}
//----------------------------------------------------------------------------------------------
//! @SYMTestCaseID KBASE-T_RESMANUS-0615
//! @SYMTestType UT
//! @SYMPREQ PREQ1398
//! @SYMTestCaseDesc This test case tests the different options available for handling transient data.
//! @SYMTestActions 0) Locate a resource that has at least one dependency.
//!
//! 1) Read the number of dependencies without reading the dependency information.
//! Call to read the dependency information (without re-loading).
//!
//! 2) Read the number of dependencies (with default option of reading the dependency information).
//! Then read the dependency information (without re-loading).
//!
//! 3) Repeat the read the number of dependencies without reading the dependency information
//! Then read the dependency information (without re-loading).
//! Then read the dependency information (with re-loading).
//!
//! 4) Attempt to read the dependency information (without re-loading) with a buffer of insufficient size
//!
//! 5) Read the number of (all) resources without reading the resource information.
//! Call to read (all) the resource information (without re-loading).
//!
//! 6) Read the number of (all) resources (with default option of reading the resource information).
//! Then read (all) the resource information (without re-loading).
//!
//! 7) Repeat the read the number of (all) resources without reading the resources information
//! Then read (all) the resources information (without re-loading).
//! Then read (all) the resources information (with re-loading).
//!
//! 8) Attempt to read (all) the resource information (without re-loading) with a buffer of insufficient size
//!
//! 9) Read the number of user-side clients using a resource without reading the resource information.
//! Call to read the information for user-side clients using a resource (without re-loading).
//!
//! 10) Read the number of user-side clients (with loading of the client information)
//! Call to read the client information (without re-loading) should return be successful
//! Call to read the information for a resourceID with zero clients (without re-loading)
//! Call to read the information for the first resourceID
//!
//! 11) Repeat the read of the number of user-side clients (without re-loading)
//! Call to read the client information (without re-loading)
//! Call to read the client information (with re-loading)
//!
//! 12) Open a second channel on the User-Side API, and call initialise support for resource state access
//! Get the current state of a specific resource, then change the state
//! Call to read the number of user-side clients for the resource (with loading of the client information)
//! but with a buffer of insufficient size.
//!
//! 13) Read the number of resources in use by a specified client (without loading)
//! Call to read the information on the resources in use by the client (without loading)
//!
//! 14) Open a third channel on the User-Side API, do not call initialise.
//! Read the number of resources in use by a specified client (with loading)
//! Call to read the information for resources in use by the third channel (without re-loading)
//! Call to read the information for resources in use by the second channel (without re-loading)
//!
//! 15) Read the number of resources in use by a specified client (without loading)
//! Call to read the information on the resources in use by the client (without loading)
//! Call to read the information on the resources in use by the client (with loading)
//!
//! 16) Read the number of resources in use by a specified client (with loading)
//! Call to read the information on the resources in use by the client (without loading)
//! with a buffer of insufficient size.
//!
//! @SYMTestExpectedResults 0) If a suitable resource is found, the number of dependencies is reported - exit otherwise.
//!
//! 1) Test that the read of the number of dependencies returns KErrNone - exit otherwise.
//! Test that the read of the dependency information returned KErrNotReady - exit otherwise.
//!
//! 2) Test that the read of the number of dependencies returns KErrNone - exit otherwise.
//! Test that the read of the dependency information returned KErrNone - exit otherwise.
//!
//! 3) Test that the read of the number of dependencies returns KErrNone - exit otherwise.
//! Test that the read of the dependency information (without re-loading) returned KErrNotReady - exit otherwise.
//! Test that the read of the dependency information (with re-loading) returned KErrNone - exit otherwise.
//!
//! 4) Test that the read of the dependency information returns KErrArgument - exit otherwise
//!
//! 5) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information returned KErrNotReady - exit otherwise.
//!
//! 6) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information returned KErrNone - exit otherwise.
//!
//! 7) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information (without re-loading) returned KErrNotReady - exit otherwise.
//! Test that the read of the resources information (with re-loading) returned KErrNone - exit otherwise.
//!
//! 8) Test that the read of the resource information returns KErrArgument - exit otherwise
//!
//! 9) Test that the read of the number of clients returns KErrNone - exit otherwise.
//! Test that the read of the client information returned KErrNotReady - exit otherwise.
//!
//! 10) Test that the read of the number of clients returns KErrNone - exit otherwise.
//! Test that the read of the client information returned KErrNone - exit otherwise.
//! Test that the read of the client information returned KErrNone and numClients==0 - exit otherwise.
//! Test that the read of the client information returned KErrNotReady - exit otherwise.
//!
//! 11) Test that the read of the number of clients returns KErrNone - exit otherwise.
//! Test that the read of the client information returned KErrNotReady - exit otherwise.
//! Test that the read of the client information returned KErrNone - exit otherwise.
//!
//! 12) Test that the opening and initialisation of the channel was successful - exit otherwise.
//! Test that the get and change of the resource state completed successfully - exit otherwise
//! Test that the read of the client information returned KErrArgument - exit otherwise.
//!
//! 13) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information returned KErrNotReady - exit otherwise.
//!
//! 14) Test that the opening of the channel was successful - exit otherwise.
//! Test that the read of the resource information returned KErrNone - exit otherwise.
//! Test that the read of the client information returned KErrNone, and numResources = 0 - exit otherwise.
//! Test that the read of the client information returned KErrNotReady - exit otherwise.
//!
//! 15) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information returned KErrNotReady - exit otherwise.
//! Test that the read of the resource information returned KErrNone - exit otherwise.
//!
//! 16) Test that the read of the number of resources returns KErrNone - exit otherwise.
//! Test that the read of the resource information returned KErrArgument - exit otherwise..
//!
//! @SYMTestPriority High
//! @SYMTestStatus Implemented
//----------------------------------------------------------------------------------------------
LOCAL_C TInt TestTransientHandling()
//
// Test APIs with options for handling transient data (dependencies, resources and clients)
//
{
TInt r = KErrNone;
TUint testNo = 1;
TUint numDependents = 0;
TUint resNo = 0;
//
// Dependency data tests
//
gTest.Printf(_L("TestTransientHandling: dependency data tests ...\n"));
// 0) Find a resource that has dependents - if none is located skip the remaining dependancy tests
// (this reads the number of dependencies, without loading the dependency data)
//
TUint numResources=0;
if((r=LocateResourceWithDependencies(numResources, resNo, numDependents))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: no resource with dependencies found ... skipping tests\n"));
return KErrNone;
}
if(numDependents==0)
{
gTest.Printf(_L("TestTransientHandling: no resource with dependencies found ... skipping tests\n"));
}
else
{
// 1) Read the number of dependencies without reading the dependency information
// Subsequent call to read the dependency information (without re-loading) should return error KErrNotReady
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
if((r=gChannel.GetNumDependentsForResource(resNo,&numDependents, EFalse))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource returned %d\n"),r);
return r;
}
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource reported %d dependents for resource %d\n"),numDependents,resNo);
if(numDependents > 0)
{
RBuf8 buffer;
if((buffer.Create(numDependents*sizeof(SResourceDependencyInfo)))!=KErrNone)
return KErrGeneral;
buffer.SetLength(0);
if((r=gChannel.GetDependentsIdForResource(resNo, buffer, &numDependents))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetDependentsIdForResource returned %d\n"),r);
return KErrGeneral;
}
buffer.Close();
}
// 2) Read the number of dependencies (and, by default, read the dependency information)
// Subsequent call to read the dependency information (without re-loading) should return be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
if((r=gChannel.GetNumDependentsForResource(resNo,&numDependents))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource returned %d\n"),r);
return r;
}
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource reported %d dependents for resource %d\n"),numDependents,resNo);
if(numDependents > 0)
{
RBuf8 buffer;
if((buffer.Create(numDependents*sizeof(SResourceDependencyInfo)))!=KErrNone)
return KErrGeneral;
buffer.SetLength(0);
if((r=gChannel.GetDependentsIdForResource(resNo, buffer, &numDependents))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetDependentsIdForResource returned %d\n"),r);
return r;
}
SResourceDependencyInfo* tempPtr = (SResourceDependencyInfo*)(buffer.Ptr());
gTest.Printf(_L("TestTransientHandling: numDependents = %d\n"),numDependents);
for(TUint i=0; i<numDependents; i++,tempPtr++)
{
gTest.Printf(_L("TestTransientHandling: info.iResourceId = %d\n"),tempPtr->iResourceId);
gTest.Printf(_L("TestTransientHandling: info.iDependencyPriority= %d\n"),tempPtr->iDependencyPriority);
}
buffer.Close();
}
// 3) Repeat the read the number of dependencies without reading the dependency information
// Subsequent call to read the dependency information (without re-loading) should return error KErrNotReady
// Then call to read the dependency information (with re-loading) should be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
if((r=gChannel.GetNumDependentsForResource(resNo,&numDependents, EFalse))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource returned %d\n"),r);
return r;
}
gTest.Printf(_L("TestTransientHandling: GetNumDependentsForResource reported %d dependents for resource %d\n"),numDependents,resNo);
if(numDependents > 0)
{
RBuf8 buffer;
if((buffer.Create(numDependents*sizeof(SResourceDependencyInfo)))!=KErrNone)
return KErrGeneral;
buffer.SetLength(0);
if((r=gChannel.GetDependentsIdForResource(resNo, buffer, &numDependents))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetDependentsIdForResource returned %d\n"),r);
return KErrGeneral;
}
if((r=gChannel.GetDependentsIdForResource(resNo, buffer, &numDependents, ETrue))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetDependentsIdForResource returned %d\n"),r);
return KErrGeneral;
}
SResourceDependencyInfo* tempPtr = (SResourceDependencyInfo*)(buffer.Ptr());
for(TUint i=0; i<numDependents; i++,tempPtr++)
{
gTest.Printf(_L("TestTransientHandling: info.iResourceId = %d"),tempPtr->iResourceId);
gTest.Printf(_L("TestTransientHandling: info.iDependencyPriority= %d"),tempPtr->iDependencyPriority);
}
buffer.Close();
}
// 4) Attempt to read the dependency information (without re-loading) with a buffer of insufficient size should
// return error KErrArgument
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
if(numDependents > 0)
{
RBuf8 buffer;
if((buffer.Create((numDependents-1)*sizeof(SResourceDependencyInfo)))!=KErrNone)
return KErrGeneral;
buffer.SetLength(0);
if((r=gChannel.GetDependentsIdForResource(resNo, buffer, &numDependents))!=KErrArgument)
{
gTest.Printf(_L("TestTransientHandling: GetDependentsIdForResource returned %d\n"),r);
return KErrGeneral;
}
// Ensure misleading result is not returned
r=KErrNone;
buffer.Close();
}
}
//
// All resource data tests
//
gTest.Printf(_L("TestTransientHandling: All resource data tests ...\n"));
testNo=1;
// 5) Attempt to read the resource information without having previously loaded it.
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
r = gChannel.GetNoOfResources(numResources, EFalse); // EFalse - don't load the resource info
if(r!=KErrNone)
{
gTest.Printf(_L("GetNoOfResources returned %d\n"),r);
return r;
}
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetAllResourcesInfo(&infoPtrs, numResources))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetAllResourcesInfo returned %d\n"),r);
return KErrGeneral;
}
else
r=KErrNone; // Ensure misleading result is not propagated
infoPtrs.Close();
}
// 6) Read the number of resources (and, by default, read the resource information)
// Subsequent call to read the resource information (without re-loading) should return be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNoOfResources(numResources))!=KErrNone)
{
gTest.Printf(_L("GetNoOfResources returned %d\n"),r);
return r;
}
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetAllResourcesInfo(&infoPtrs, numResources))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetAllResourcesInfo returned %d\n"),r);
return r;
}
infoPtrs.Close();
}
// 7) Repeat the read the number of resources without reading the resource information
// Subsequent call to read the resource information (without re-loading) should return error KErrNotReady
// Then call to read the resource information (with re-loading) should be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNoOfResources(numResources, EFalse))!=KErrNone) // EFalse - don't load the resource info
{
gTest.Printf(_L("GetNoOfResources returned %d\n"),r);
return r;
}
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetAllResourcesInfo(&infoPtrs, numResources))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetAllResourcesInfo returned %d\n"),r);
return KErrGeneral;
}
if((r=gChannel.GetAllResourcesInfo(&infoPtrs, numResources,ETrue))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetAllResourcesInfo returned %d\n"),r);
return r;
}
else
infoPtrs.Close();
}
// 8) Attempt to read the resource information (without re-loading) with a buffer of insufficient size should
// return error KErrArgument
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNoOfResources(numResources, EFalse))!=KErrNone) // EFalse - don't load the resource info
{
gTest.Printf(_L("GetNoOfResources returned %d\n"),r);
return r;
}
// To support the GetAllResourcesInfo testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources - 1);
for(TUint i=0;i<(numResources-1);i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetAllResourcesInfo(&infoPtrs, numResources))!=KErrArgument)
{
gTest.Printf(_L("TestTransientHandling: GetAllResourcesInfo returned %d\n"),r);
return KErrGeneral;
}
// Ensure misleading result is not returned
r=KErrNone;
infoPtrs.Close();
}
//
// Specific resource data tests
//
gTest.Printf(_L("TestTransientHandling: Resource-specific data tests ...\n"));
testNo=1;
// 9) Attempt to read the resource information without having previously loaded it.
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numClients = 0;
if((r=gChannel.GetNumClientsUsingResource(gLongLatencyResource, numClients, EFalse, EFalse))!=KErrNone) // user-side clients, don't load the info
{
gTest.Printf(_L("GetNumClientsUsingResource returned %d\n"),r);
return r;
}
// To support the GetInfoOnClientsUsingResource testing, instantiate TClientInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TClientInfoBuf> infoPtrs(numClients);
for(TUint i=0;i<numClients;i++)
{
TClientInfoBuf *info = new TClientInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetInfoOnClientsUsingResource infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnClientsUsingResource(gLongLatencyResource, numClients, &infoPtrs, EFalse))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource returned %d\n"),r);
return KErrGeneral;
}
else
r=KErrNone; // Ensure misleading result is not propagated
infoPtrs.Close();
}
// 10) Read the number of clients (and, by default, read the client information)
// Subsequent call to read the client information (without re-loading) should return be successful
// Call to read the information for a resourceID with zero clients (without re-loading) should return KErrNone, numClients==0
// Call to read the information for a resourceID with one or more clients (without re-loading) should return KErrNotReady
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numClients = 0;
if((r=gChannel.GetNumClientsUsingResource(gLongLatencyResource, numClients, EFalse))!=KErrNone) // user-side clients, load the info
{
gTest.Printf(_L("GetNumClientsUsingResource returned %d\n"),r);
return r;
}
// To support the GetInfoOnClientsUsingResource testing, instantiate TClientInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TClientInfoBuf> infoPtrs(numClients);
for(TUint i=0;i<numClients;i++)
{
TClientInfoBuf *info = new TClientInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetInfoOnClientsUsingResource infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnClientsUsingResource(gLongLatencyResource, numClients, &infoPtrs, EFalse))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for gLongLatencyResource returned %d\n"),r);
return r;
}
if(((r=gChannel.GetInfoOnClientsUsingResource((gLongLatencyResource+1), numClients, &infoPtrs, EFalse))!=KErrNone) || (numClients!=0))
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for (gLongLatencyResource+1) returned %d\n"),r);
if(numClients!=0)
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for (gLongLatencyResource+1), %d clients\n"),numClients);
return KErrGeneral;
}
if((r=gChannel.GetInfoOnClientsUsingResource(gSharedResource, numClients, &infoPtrs, EFalse))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource (for gSharedResource) returned %d\n"),r);
return r;
}
infoPtrs.Close();
}
// 11) Repeat the read the number of clients without reading the client information
// Subsequent call to read the client information (without re-loading) should return error KErrNotReady
// Then call to read the client information (with re-loading) should be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numClients = 0;
if((r=gChannel.GetNumClientsUsingResource(gLongLatencyResource, numClients, EFalse, EFalse))!=KErrNone) // user-side clients, don't load the info
{
gTest.Printf(_L("GetNumClientsUsingResource returned %d\n"),r);
return r;
}
// To support the GetInfoOnClientsUsingResource testing, instantiate TClientInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TClientInfoBuf> infoPtrs(numClients);
for(TUint i=0;i<numClients;i++)
{
TClientInfoBuf *info = new TClientInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetInfoOnClientsUsingResource infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnClientsUsingResource(gLongLatencyResource, numClients, &infoPtrs, EFalse))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for gLongLatencyResource returned %d\n"),r);
return KErrGeneral;
}
if((r=gChannel.GetInfoOnClientsUsingResource(gLongLatencyResource, numClients, &infoPtrs, EFalse, ETrue))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for gLongLatencyResource returned %d\n"),r);
return r;
}
infoPtrs.Close();
}
// 12) To support the following test (and specific resource data tests, below) need a second channel to be using the resource
_LIT(tempStr1,"ExtraChan1");
TBufC<16> tempName1(tempStr1);
RBusDevResManUs channelTwo;
if((r=OpenChannel(tempName1, channelTwo))!=KErrNone)
{
gTest.Printf(_L("Failed to open channelTwo, %d\n"),r);
channelTwo.Close();
return r;
}
if ((r=channelTwo.Initialise(1,1,1))!=KErrNone)
{
gTest.Printf(_L("Failed to Initialise channelTwo, %d\n"),r);
channelTwo.Close();
return r;
}
// Attempt to change the resource level
// Get initial state
TRequestStatus status;
TBool cached = gUseCached;
TInt readValue;
TInt levelOwnerId = 0;
channelTwo.GetResourceState(status,gSharedResource,cached,&readValue,&levelOwnerId);
User::WaitForRequest(status);
r=status.Int();
if(r != KErrNone)
{
gTest.Printf(_L("GetResourceState for gSharedResource completed with = 0x%x\n"),r);
return r;
}
// Write updated state
TUint newLevel = (TUint)(readValue + gSharedResStateDelta);
channelTwo.ChangeResourceState(status,gSharedResource,newLevel);
User::WaitForRequest(status);
r=status.Int();
if(r != KErrNone)
{
gTest.Printf(_L("ChangeResourceState forgSharedResource completed with %d\n"),r);
return r;
}
// Attempt to read the client information (without re-loading) with a buffer of insufficient size should
// return error KErrArgument
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numClients = 0;
if((r=gChannel.GetNumClientsUsingResource(gSharedResource, numClients, EFalse))!=KErrNone) // user-side clients, load the info
{
gTest.Printf(_L("GetNumClientsUsingResource returned %d\n"),r);
channelTwo.Close();
return r;
}
// To support the GetInfoOnClientsUsingResource testing, instantiate TClientInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TClientInfoBuf> infoPtrs(numClients-1);
for(TUint i=0;i<(numClients-1);i++)
{
TClientInfoBuf *info = new TClientInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetInfoOnClientsUsingResource infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
channelTwo.Close();
}
}
if((r=gChannel.GetInfoOnClientsUsingResource(gSharedResource, numClients, &infoPtrs, EFalse))!=KErrArgument)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource for gLongLatencyResource returned %d\n"),r);
channelTwo.Close();
return KErrGeneral;
}
// Ensure misleading result is not returned
r=KErrNone;
infoPtrs.Close();
}
//
// Specific resource data tests
//
gTest.Printf(_L("TestTransientHandling: Client-specific data tests ...\n"));
testNo=1;
// These tests require a client name
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 TestTransientHandling client-specific data tests with %S \n"),&clientName16Bit);
#endif
// 13) Attempt to read the resource information without having previously loaded it.
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNumResourcesInUseByClient(*clientName, numResources, EFalse))!=KErrNone) // EFalse - don't load data
{
gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);
return r;
}
// To support the GetInfoOnResourcesInUseByClient testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, numResources, &infoPtrs))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnClientsUsingResource returned %d\n"),r);
return KErrGeneral;
}
else
r=KErrNone; // Ensure misleading result is not propagated
infoPtrs.Close();
}
// 14) To support the following test need a third channel
_LIT(tempStr2,"ExtraChan2");
TBufC<16> tempName2(tempStr2);
RBusDevResManUs channelThree;
if((r=OpenChannel(tempName2, channelThree))!=KErrNone)
{
gTest.Printf(_L("Failed to open channelThree, %d\n"),r);
channelTwo.Close();
return r;
}
// Read the number of resources (and, by default, read the resource information)
// Subsequent call to read the resource information (without re-loading) should return be successful
// Call to read the information for a client name with zero resource requirements (without re-loading) should return KErrNone, numResources==0
// Call to read the information for a client name with one or more resource requirements (without re-loading) should return KErrNotReady
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNumResourcesInUseByClient(*clientName, numResources))!=KErrNone) // load data
{
gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);
return r;
}
// To support the GetInfoOnResourcesInUseByClient testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, numResources, &infoPtrs))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: gChannel GetInfoOnClientsUsingResource returned %d\n"),r);
return KErrGeneral;
}
TUint dumResources=0;
TBuf8<MAX_RESOURCE_NAME_LENGTH+1>name8Bit2;
name8Bit2.Copy(tempName2);
TClientName* clientName2 = (TClientName*)&name8Bit2;
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName2, dumResources, &infoPtrs))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: tempName2 GetInfoOnClientsUsingResource returned %d\n"),r);
return KErrGeneral;
}
if(dumResources!=0)
{
gTest.Printf(_L("TestTransientHandling: tempName2 GetInfoOnClientsUsingResource dumResources=%d\n"),dumResources);
return KErrGeneral;
}
TBuf8<MAX_RESOURCE_NAME_LENGTH+1>name8Bit1;
name8Bit1.Copy(tempName1);
TClientName* clientName1 = (TClientName*)&name8Bit1;
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName1, numResources, &infoPtrs))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: tempName1 GetInfoOnClientsUsingResource returned %d\n"),r);
return KErrGeneral;
}
infoPtrs.Close();
}
// 15) Repeat the read the number of resources without reading the resource information
// Subsequent call to read the resources information (without re-loading) should return error KErrNotReady
// Then call to read the resources information (with re-loading) should be successful
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNumResourcesInUseByClient(*clientName, numResources, EFalse))!=KErrNone) // don't load data
{
gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);
return r;
}
// To support the GetInfoOnResourcesInUseByClient testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources);
for(TUint i=0;i<numResources;i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, numResources, &infoPtrs))!=KErrNotReady)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnResourcesInUseByClient returned %d\n"),r);
return KErrGeneral;
}
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, numResources, &infoPtrs, ETrue))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnResourcesInUseByClient returned %d\n"),r);
return r;
}
infoPtrs.Close();
}
// 16) Attempt to read the resource information (without re-loading) with a buffer of insufficient size should
// return error KErrArgument
gTest.Printf(_L("TestTransientHandling: test %d\n"),testNo++);
{
TUint numResources = 0;
if((r=gChannel.GetNumResourcesInUseByClient(*clientName, numResources))!=KErrNone) // load data
{
gTest.Printf(_L("GetNumResourcesInUseByClient returned %d\n"),r);
return r;
}
// To support the GetInfoOnResourcesInUseByClient testing, instantiate TResourceInfoBuf objects
// and reference via an RSimplePointerArray
RSimplePointerArray<TResourceInfoBuf> infoPtrs(numResources-1);
for(TUint i=0;i<(numResources-1);i++)
{
TResourceInfoBuf *info = new TResourceInfoBuf();
if((r=infoPtrs.Insert(info, i))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling test, GetAllResourcesInfo infoPtrs.Insert at index %d returned %d\n"),testNo,i,r);
}
}
if((r=gChannel.GetInfoOnResourcesInUseByClient(*clientName, numResources, &infoPtrs))!=KErrArgument)
{
gTest.Printf(_L("TestTransientHandling: GetInfoOnResourcesInUseByClient returned %d\n"),r);
return KErrGeneral;
}
// Ensure misleading result is not returned
r=KErrNone;
infoPtrs.Close();
}
channelTwo.Close();
channelThree.Close();
return r;
}
EXPORT_C TInt E32Main()
//
// Main
//
{
gTest.Start(_L("Test Power Resource Manager user side API\n"));
TInt r = KErrNone;
// Test attempted load of PDD
gTest.Next(_L("**Load PDD\n"));
r=User::LoadPhysicalDevice(PDD_NAME);
if((r!=KErrNone)&&(r!=KErrAlreadyExists))
{
gTest.Printf(_L("User::LoadPhysicalDevice error %d\n"),r);
}
else
{
// Test attempted load of LDD
gTest.Next(_L("**Load LDD\n"));
r=User::LoadLogicalDevice(LDD_NAME);
if((r!=KErrNone)&&(r!=KErrAlreadyExists))
gTest.Printf(_L("User::LoadLogicalDevice error - expected %d, got %d\n"),KErrAlreadyExists,r);
}
if((r==KErrNone)||(r==KErrAlreadyExists))
{
r = KErrNone; // Re-initialise in case set to KErrAlreadyExists
//
// Need a channel open for the following tests
gTest.Next(_L("**OpenAndRegisterChannel\n"));
r=OpenAndRegisterChannel();
if (r==KErrNone)
{
// Get the version of the ResourceController
TUint version;
if((r=gChannel.GetResourceControllerVersion(version))!=KErrNone)
{
gTest.Printf(_L("TestTransientHandling: GetResourceControllerVersion returned %d\n"),r);
return r;
}
gTest.Printf(_L("TestTransientHandling: ResourceController version =0x%x\n"),version);
}
if (r==KErrNone)
{
gTest.Next(_L("**TestThreadExclusiveAccess\n"));
r=TestThreadExclusiveAccess();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestGetClientGetResourceInfo - initial state\n"));
r=TestGetClientGetResourceInfo();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestGetSetResourceStateOps\n"));
r=TestGetSetResourceStateOps();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestGetClientGetResourceInfo - after changing stateof Async resource\n"));
r=TestGetClientGetResourceInfo();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestGetSetResourceStateQuota\n"));
r=TestGetSetResourceStateQuota();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestNotificationOps\n"));
r=TestNotificationOps();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestNotificationQuota\n"));
r=TestNotificationQuota();
}
if (r==KErrNone)
{
// Should be no change since last invocation (assuming that
// no clients other than those in this test)
gTest.Next(_L("**TestGetClientGetResourceInfo - last invocation\n"));
r=TestGetClientGetResourceInfo();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestAdditionalThread\n"));
r=TestAdditionalThread();
}
if (r==KErrNone)
{
gTest.Next(_L("**TestTransientHandling\n"));
r=TestTransientHandling();
}
}
gChannel.Close();
User::FreeLogicalDevice(KLddRootName);
User::FreePhysicalDevice(PDD_NAME);
User::After(100000); // Allow idle thread to run for driver unloading
gTest.End();
return r;
}