// Copyright (c) 2004-2009 Nokia Corporation and/or its subsidiary(-ies).

 // All rights reserved.

 // This component and the accompanying materials are made available

 // under the terms of the License "Eclipse Public License v1.0"

 // which accompanies this distribution, and is available

 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

 //

 // Initial Contributors:

 // Nokia Corporation - initial contribution.

 //

 // Contributors:

 //

 // Description:

 // e32test\system\d_dobject.cpp

 // LDD for testing RObjectIx class

 // 

 //

 #include <kernel/kern_priv.h>

 #include "d_dobject.h"

 #include "../misc/prbs.h"

 //

 // Handle Mutex referenced from ObjectIx.cpp (normally from sglobals.cpp).

 //

 DMutex* RObjectIx::HandleMutex;

 //

 // Constants for test sizes and stepings...

 //

 const TInt KDObjectTestMaxTestSize  = 2000;	// Bigest size to test

 const TInt KDObjectTestStepStart    = 19;	// Test all values below this

 const TInt KDObjectTestStep         = 31;	// Step value used when above KDObjectTestStepStart.

 const TInt KDObjectTestLoopCount    = 3;	// Loop count used in some tests to repeat random testing.

 //

 // LDD factory

 //

 class DObjectTestFactory : public DLogicalDevice

 	{

 public:

 	DObjectTestFactory();

 	~DObjectTestFactory();

 	virtual TInt Install();

 	virtual void GetCaps(TDes8& aDes) const;

 	virtual TInt Create(DLogicalChannelBase*& aChannel);

 public:

 	};

 //

 // Logical Channel

 //

 const TInt KObjectIndexMask=0x7fff;

 class DObjectTest : public DLogicalChannelBase

 	{

 public:

 	virtual ~DObjectTest();

 protected:

 	virtual TInt DoCreate(TInt aUnit, const TDesC8* anInfo, const TVersion& aVer);

 	virtual TInt Request(TInt aFunction, TAny* a1, TAny* a2);

 public:

 	DObjectTestFactory* iFactory;

 private:

 	TInt RObjectIxTest1(TInt aSize);

 	TInt RObjectIxTest2(TInt aSize);

 	TInt RObjectIxTest3(TInt aSize, TBool aPerformanceTest);

 	TInt RObjectIxTest4(TInt aSize);

 	TInt RObjectIxTestExerciseIx(RObjectIx& aObjectIx, TInt aSize);

 	TInt RObjectIxInvalidHandleLookupTest(TInt aSize);

 	TInt DObjectNameTest();

 	inline TInt Index(TInt aHandle)	{return(aHandle&KObjectIndexMask);}

 private:

 	struct DOBjAndHandle

 		{

 		DObject* iObject;

 		TInt	 iHandle;

 		};

 	TUint iSeed[2];

 	DOBjAndHandle* iObjAndHandle;	

 	};

 //

 // LDD factory

 //

 DObjectTestFactory::DObjectTestFactory()

 	{

 	Kern::MutexCreate(RObjectIx::HandleMutex, _L("HandleMutex"), KMutexOrdHandle);

 	}

 DObjectTestFactory::~DObjectTestFactory()

 	{

 	delete RObjectIx::HandleMutex;

 	RObjectIx::HandleMutex = NULL;

 	}

 TInt DObjectTestFactory::Create(DLogicalChannelBase*& aChannel)

 	{

 	aChannel=new DObjectTest;

 	return KErrNone;

 	}

 TInt DObjectTestFactory::Install()

 	{

 	return SetName(&KDObjectTestLddName);

 	}

 void DObjectTestFactory::GetCaps(TDes8& /* aDes */) const

 	{

 	//aDes.FillZ(aDes.MaxLength());

 	}

 DECLARE_STANDARD_LDD()

 	{

 	return new DObjectTestFactory;

 	}

 //

 // Logical Channel

 //

 TInt DObjectTest::DoCreate(TInt /*aUnit*/, const TDesC8* /*aInfo*/, const TVersion& /*aVer*/)

 	{

 	if (NULL == (iObjAndHandle = (DOBjAndHandle*)Kern::Alloc(KDObjectTestMaxTestSize * sizeof(DOBjAndHandle))))

 		return KErrNoMemory;

 	return KErrNone;

 	}

 DObjectTest::~DObjectTest()

 	{

 	delete[] iObjAndHandle;

 	}

 //Adds a number of DObjects to RObjectIx, then removes them in the same order.

 TInt DObjectTest::RObjectIxTest1(TInt aSize)

 {

 	TInt i,r;

 	DObject* object;

 	RObjectIx  myIx;

 	myIx.Check(0);

 	for (i=0; i<aSize; i++) //Add

 		{

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL) 

 			{

 			myIx.Close(NULL);

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = myIx.Add(iObjAndHandle[i].iObject, 0);

 		if (r<0)

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	myIx.Check(0);

 	for (i=0; i<aSize; i++)		//Remove

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=myIx.Remove(iObjAndHandle[i].iHandle, object, attr))) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		}

 	myIx.Check(0);

 	myIx.Close(NULL);

 	return KErrNone;

 }

 //Adds a number of DObjects to RObjectIx, then removes them in the reverse order.

 TInt DObjectTest::RObjectIxTest2(TInt aSize)

 {

 	TInt i,r;

 	DObject* object;

 	RObjectIx myIx;

 	myIx.Check(0);

 	for (i=0; i<aSize; i++) //Add

 		{

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL) 

 			{

 			myIx.Close(NULL);

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = myIx.Add(iObjAndHandle[i].iObject, 0);

 		if (r<0)

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	myIx.Check(0);

 	for (i=aSize-1; i>=0; i--)		//Remove in reverse

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=myIx.Remove(iObjAndHandle[i].iHandle, object, attr))) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		}

 	myIx.Check(0);

 	myIx.Close(NULL);

 	return KErrNone;

 }

 //Adds and removes random number of DObjects to/from RObjectIx.

 TInt DObjectTest::RObjectIxTest3(TInt aSize, TBool aPerformanceTest)

 {

 	TInt index, x, r;

 	DObject* object;

 	RObjectIx myIx;

 	//---Create & init the objects we need

 	for (x=0; x<aSize; x++) iObjAndHandle[x].iObject = NULL; //initialize the array

 	if (!aPerformanceTest)

 		myIx.Check(0);

 	for (x = 0;  x < KDObjectTestLoopCount;  x++)

 		{

 		//---Add the random number of objects (in random order)---

 		TInt toAdd=Random(iSeed)%(aSize-myIx.ActiveCount()+1);

 		while (toAdd--)

 			{

 			index=Random(iSeed)%aSize;

 			while (iObjAndHandle[index].iObject) index=(index+1)%aSize; //Find the next NULL pointer 

 			if( (iObjAndHandle[index].iObject = new DObject) == NULL) 

 				{

 				myIx.Close(NULL);

 				return KErrNoMemory;

 				}

 			r = myIx.Add(iObjAndHandle[index].iObject, 0);

 			if (r<0)

 				{

 				if (!aPerformanceTest)

 					myIx.Check(0);

 				myIx.Close(NULL);

 				return r;

 				}

 			iObjAndHandle[index].iHandle = r;

 			}

 		if (!aPerformanceTest)

 			myIx.Check(0);

 		//---Remove the random number of objects (in random order)---

 		TInt toRemove=Random(iSeed)%(myIx.ActiveCount()+1);

 		while (toRemove--)

 			{

 			index=Random(iSeed)%aSize;

 			while (!iObjAndHandle[index].iObject) index=(index+1)%aSize; //Find the next non-NULL pointer 

 			TUint32  attr = 0; // Receives the attributes of the removed handle...

 			if (KErrNone != (r=myIx.Remove(iObjAndHandle[index].iHandle, object, attr)))

 				{

 				if (!aPerformanceTest)

 					myIx.Check(0);

 				myIx.Close(NULL);

 				return r;

 				}

 			iObjAndHandle[index].iObject->Close(NULL);

 			iObjAndHandle[index].iObject=NULL;

 			}

 		if(aPerformanceTest) continue;

 		myIx.Check(0);

 		//---Test data consistency---

 		TInt objNum=0;

 		for (index=0;index<aSize;index++) 

 			{

 			if (iObjAndHandle[index].iObject)

 				{

 				objNum++;

 				//Test At(TInt aHandle) method

 				NKern::LockSystem();

 				if (iObjAndHandle[index].iObject != myIx.At(iObjAndHandle[index].iHandle))

 					{

 					NKern::UnlockSystem();

 					myIx.Check(0);

 					myIx.Close(NULL);

 					return KErrGeneral;

 					}

 				NKern::UnlockSystem();

 				//Test Count(CObject* aObject) method

 				RObjectIx::Wait();

 				if (1!=myIx.Count(iObjAndHandle[index].iObject))

 					{

 					RObjectIx::Signal();

 					myIx.Check(0);

 					myIx.Close(NULL);

 					return KErrGeneral;

 					}

 				//Test At(CObject* aObject) method

 				if (iObjAndHandle[index].iHandle != myIx.At(iObjAndHandle[index].iObject))

 					{

 					RObjectIx::Signal();

 					myIx.Check(0);

 					myIx.Close(NULL);

 					return KErrGeneral;

 					}

 				RObjectIx::Signal();

 				//Test operator[](TInt index) method

 				NKern::LockSystem();

 				if (iObjAndHandle[index].iObject != myIx[Index(iObjAndHandle[index].iHandle)])

 					{

 					NKern::UnlockSystem();

 					myIx.Check(0);

 					myIx.Close(NULL);

 					return KErrGeneral;

 					}

 				NKern::UnlockSystem();

 				}

 			}

 		if (objNum != myIx.ActiveCount())

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrGeneral;

 			}

 		}

 	myIx.Check(0);

 	myIx.Close(NULL);

 	return KErrNone;

 }

 //Adds a number of DObjects to RObjectIx using reserved slots, then removes

 // them in the same order. Repeat using the reverse order.

 TInt DObjectTest::RObjectIxTest4(TInt aSize)

 	{

 	TInt i,r;

 	DObject* object;

 	RObjectIx myIx;

 	myIx.Check(0);

 	myIx.Reserve(aSize);

 	myIx.Check(0);

 	myIx.Reserve(-aSize);

 	myIx.Check(0);

 	myIx.Reserve(aSize);

 	myIx.Check(0);

 	for (i=0; i<aSize; i++) //Add

 		{

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = myIx.Add(iObjAndHandle[i].iObject, (TUint32)RObjectIx::EReserved);

 		if (r<0)

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	myIx.Check(0);

 	TInt toRemove=Random(iSeed)%(myIx.ActiveCount()+1);

 	TInt toAdd=toRemove; // will put them all back again...

 	while (toRemove--)

 		{

 		i=Random(iSeed)%aSize;

 		while (!iObjAndHandle[i].iObject) i=(i+1)%aSize; //Find the next non-NULL pointer 

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=myIx.Remove(iObjAndHandle[i].iHandle, object, attr))) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		if ((attr & RObjectIx::EReserved) == 0) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrBadHandle;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		iObjAndHandle[i].iObject = NULL;

 		}

 	myIx.Check(0);

 	while (toAdd--)

 		{

 		i=Random(iSeed)%aSize;

 		while (iObjAndHandle[i].iObject) i=(i+1)%aSize; //Find the next NULL pointer 

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = myIx.Add(iObjAndHandle[i].iObject, (TUint32)RObjectIx::EReserved);

 		if (r<0)

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	myIx.Check(0);

 	for (i=aSize-1; i>=0; i--)		//Remove in reverse

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=myIx.Remove(iObjAndHandle[i].iHandle, object, attr))) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		if ((attr & RObjectIx::EReserved) == 0) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrBadHandle;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		iObjAndHandle[i].iObject = NULL;

 		}

 	myIx.Check(0);

 	myIx.Close(NULL);

 	return KErrNone;

 	} // DObjectTest::RObjectIxTest4

 // Adds a number of DObjects to RObjectIx using both normal and reserved slots, plus

 // unused reserved slots then removes

 // them in the same order. Repeat using the reverse order. Used in concurrent

 // testing with multiple threads.

 TInt DObjectTest::RObjectIxTestExerciseIx(RObjectIx& aObjectIx, TInt aSize)

 	{

 	TInt i,r;

 	DObject* object;

 	aObjectIx.Check(0);

 	for (i=0; i<aSize; i++) //Add and reserve (causing a Grow())...

 		{

 		// we reserve handles because it encourages grow and shrinking of the pool

 		aObjectIx.Reserve(1);

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL)

 			{

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = aObjectIx.Add(iObjAndHandle[i].iObject, i&0x1 ? (TUint32)RObjectIx::EReserved : 0);

 		if (r<0)

 			{

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	//---Test data consistency---

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

 		{

 		if (iObjAndHandle[i].iObject)

 			{

 			//Test At(TInt aHandle) method

 			NKern::LockSystem();

 			if (iObjAndHandle[i].iObject != aObjectIx.At(iObjAndHandle[i].iHandle))

 				{

 				NKern::UnlockSystem();

 				return KErrGeneral;

 				}

 			NKern::UnlockSystem();

 			}

 		}

 	aObjectIx.Check(0);

 	for (i=0; i<aSize; i++)		//Remove

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=aObjectIx.Remove(iObjAndHandle[i].iHandle, object, attr)))

 			{

 			return r;

 			}

 		if ((i&0x1) && ((attr & RObjectIx::EReserved) == 0))

 			{

 			return KErrBadHandle;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		iObjAndHandle[i].iObject = NULL;

 		}

 	aObjectIx.Check(0);

 	for (i=0; i<aSize; i++) //Add

 		{

 		if( (iObjAndHandle[i].iObject = new DObject) == NULL)

 			{

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = aObjectIx.Add(iObjAndHandle[i].iObject, i&0x1 ?  (TUint32)RObjectIx::EReserved : 0);

 		if (r<0)

 			{

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	//---Test data consistency---

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

 		{

 		if (iObjAndHandle[i].iObject)

 			{

 			NKern::LockSystem();

 			//Test At(TInt aHandle) method

 			if (iObjAndHandle[i].iObject != aObjectIx.At(iObjAndHandle[i].iHandle))

 				{

 				NKern::UnlockSystem();

 				return KErrGeneral;

 				}

 			NKern::UnlockSystem();

 			}

 		}

 	aObjectIx.Check(0);

 	for (i=aSize-1; i>=0; i--)		//Remove in reverse

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=aObjectIx.Remove(iObjAndHandle[i].iHandle, object, attr)))

 			{

 			return r;

 			}

 		if ((i&0x1) && ((attr & RObjectIx::EReserved) == 0))

 			{

 			return KErrBadHandle;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		aObjectIx.Reserve(-1); // Remove a reserved object causing a TidyAndCompact()...

 		}

 	aObjectIx.Check(0);

 	return KErrNone;

 	} // DObjectTest::RObjectIxTestExerciseIx

 /**

  *  Adds a number of DObjects to RObjectIx, tries random invalid handle to access them,

  *  then attempts removes them in the same order.

  * 

  *  @param aSize  Size of handle array to use.

  * 

  *  @return KErrNone or standard error code.

  */

 TInt DObjectTest::RObjectIxInvalidHandleLookupTest(TInt aSize)

 	{

 	TInt  i, r;

 	DObject*  object;

 	RObjectIx myIx;

 	myIx.Check(0);

 	//

 	// Add in some DObjects...

 	//

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

 		{

 		if ((iObjAndHandle[i].iObject = new DObject) == NULL) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return KErrNoMemory;

 			}

 		iObjAndHandle[i].iObject->iContainerID = 0;

 		r = myIx.Add(iObjAndHandle[i].iObject, 0);

 		if (r < 0)

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iHandle = r;

 		}

 	myIx.Check(0);

 	//

 	// Randomly attempt to access handles...

 	//

 	TInt  handlesToTest = aSize * KDObjectTestLoopCount;

 	TInt  count;

 	for (count = 0;  count < handlesToTest;  count++)

 		{

 		//

 		// A handle looks like this:

 		//	Bits 0-14	index

 		//	Bit 15		no-close flag (ignored)

 		//	Bits 16-29	instance value

 		//	Bit 30		thread local flag (ignored)

 		//	Bit 31		special handle flag (should be 0)

 		//

 		NKern::LockSystem();

 		TInt  randomHandle = Kern::Random() & 0x3fff7fff;

 		TInt  uniqueID = 0;		// any object type!

 		object = myIx.At(randomHandle, uniqueID);

 		NKern::UnlockSystem();

 		if (object != NULL)

 			{

 			//

 			// We've picked a valid handle, this is unlikely but check if

 			// it is really valid...

 			//

 			TBool  found = EFalse;

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

 				{

 				if (iObjAndHandle[i].iHandle == randomHandle  &&

 					iObjAndHandle[i].iObject == object)

 					{

 					found = ETrue;

 					break;

 					}

 				}

 			if (found == EFalse) 

 				{

 				myIx.Check(0);

 				myIx.Close(NULL);

 				return KErrBadHandle;

 				}

 			}

 		}

 	myIx.Check(0);

 	//

 	// Remove the DObjects...

 	//

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

 		{

 		TUint32  attr = 0; // Receives the attributes of the removed handle...

 		if (KErrNone != (r=myIx.Remove(iObjAndHandle[i].iHandle, object, attr))) 

 			{

 			myIx.Check(0);

 			myIx.Close(NULL);

 			return r;

 			}

 		iObjAndHandle[i].iObject->Close(NULL);

 		}

 	myIx.Check(0);

 	myIx.Close(NULL);

 	return KErrNone;

 	} // DObjectTest::RObjectIxInvalidHandleLookupTest

 TInt DObjectTest::DObjectNameTest()

 	{

 #define TEST_GOOD_NAME(name) if (Kern::ValidateName(name) != KErrNone) return KErrBadName;

 #define TEST_BAD_NAME(name) if (Kern::ValidateName(name) != KErrBadName) return KErrBadName;

 #define TEST_GOOD_FULLNAME(name) if (Kern::ValidateFullName(name) != KErrNone) return KErrBadName;

 #define TEST_BAD_FULLNAME(name) if (Kern::ValidateFullName(name) != KErrBadName) return KErrBadName;

 	_LIT(KGoodName1,"DObject1 ABCDEFGHIJKLMNOPRSTUVWXYZ0123456789");

 	_LIT(KGoodName2,"DObject2 abdefghijklmnoprstuvwxyz!\"#$%&'()+,-./;<=>@[\\]^_`{|}~");

 	_LIT(KGoodFullName1,"DObject :3");

 	_LIT(KBadName1,"DObject 5 *");

 	_LIT(KBadName2,"DObject 6 ?");

 	TUint8 badName3[] = {'D','O','b','j','e','c','t',0x00};

 	TUint8 badName4[] = {'D','O','b','j','e','c','t',0x1f};

 	TUint8 badName5[] = {'D','O','b','j','e','c','t',0x7f};

 	TUint8 badName6[] = {'D','O','b','j','e','c','t',0xff};

 	TPtr8 badNamePtr(badName3, sizeof(badName3), sizeof(badName3));

 	// Test Kern::ValidateName for good and bad names

 	TEST_GOOD_NAME(KGoodName1);

 	TEST_GOOD_NAME(KGoodName2);

 	TEST_BAD_NAME(KGoodFullName1);

 	TEST_BAD_NAME(KBadName1);

 	TEST_BAD_NAME(KBadName2);

 	TEST_BAD_NAME(badNamePtr); // already set to badName3 as no TPtr8 default constructor

 	badNamePtr.Set(badName4, sizeof(badName4), sizeof(badName4));

 	TEST_BAD_NAME(badNamePtr);

 	badNamePtr.Set(badName5, sizeof(badName5), sizeof(badName5));

 	TEST_BAD_NAME(badNamePtr);

 	badNamePtr.Set(badName6, sizeof(badName6), sizeof(badName6));

 	TEST_BAD_NAME(badNamePtr);

 	// Test Kern::ValidateFullName for good and bad full names

 	TEST_GOOD_FULLNAME(KGoodName1);

 	TEST_GOOD_FULLNAME(KGoodName2);

 	TEST_GOOD_FULLNAME(KGoodFullName1);

 	TEST_BAD_FULLNAME(KBadName1);

 	TEST_BAD_FULLNAME(KBadName2);

 	badNamePtr.Set(badName3, sizeof(badName3), sizeof(badName3));

 	TEST_BAD_FULLNAME(badNamePtr);

 	badNamePtr.Set(badName4, sizeof(badName4), sizeof(badName4));

 	TEST_BAD_FULLNAME(badNamePtr);

 	badNamePtr.Set(badName5, sizeof(badName5), sizeof(badName5));

 	TEST_BAD_FULLNAME(badNamePtr);

 	badNamePtr.Set(badName6, sizeof(badName6), sizeof(badName6));

 	TEST_BAD_FULLNAME(badNamePtr);

 	return KErrNone;

 	}

 TInt DObjectTest::Request(TInt aFunction, TAny* a1, TAny* a2)

 	{

 	TInt r=KErrNone;

 	TInt i;

 	TInt duration;

 	SParam param;

 	TAny* args[2];	

 	TRequestStatus* s=(TRequestStatus*)a1;

 	kumemget32(args,a2,sizeof(args));

 	switch (~aFunction)

 		{

 	case RTestDObject::ERObjectIxTest1:

 		duration = NKern::TickCount();

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			if (KErrNone != (r=RObjectIxTest1(i)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 		NKern::ThreadLeaveCS();

 		duration = NKern::TickCount() - duration;

 		kumemput32(args[0], &duration, sizeof(TInt));

 		Kern::RequestComplete(s,KErrNone);

 		return KErrNone;

 	case RTestDObject::ERObjectIxTest2:

 		duration = NKern::TickCount();

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			if (KErrNone != (r=RObjectIxTest2(i)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 		NKern::ThreadLeaveCS();

 		duration = NKern::TickCount() - duration;

 		kumemput32(args[0], &duration, sizeof(TInt));

 		Kern::RequestComplete(s,KErrNone);

 		return KErrNone;

 	case RTestDObject::ERObjectIxTest3:

 		kumemget32(&param, args[0], sizeof(param));

 		duration = NKern::TickCount();

 		iSeed[0] = param.iSeed[0];

 		iSeed[1] = param.iSeed[1];

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			if (KErrNone != (r=RObjectIxTest3(i, param.iPerformanceTest)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 		NKern::ThreadLeaveCS();

 		duration = NKern::TickCount() - duration;

 		kumemput32(&((SParam*)args[0])->duration, &duration, sizeof(TInt));

 		Kern::RequestComplete(s,KErrNone);

 		return KErrNone;

 	case RTestDObject::ERObjectIxTest4:

 		duration = NKern::TickCount();

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			if (KErrNone != (r=RObjectIxTest4(i)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 		NKern::ThreadLeaveCS();

 		duration = NKern::TickCount() - duration;

 		kumemput32(args[0], &duration, sizeof(TInt));

 		Kern::RequestComplete(s,KErrNone);

 		return KErrNone;

 	case RTestDObject::ERObjectIxThreadTestCreateIx:

 		//RTestDObject::RObjectIxThreadTestCreateIx(void*& aRObjectIxPtr);

 		{

 		RObjectIx*  threadTestObjectIx = NULL;

 		NKern::ThreadEnterCS();

 		threadTestObjectIx = new RObjectIx();

 		if (threadTestObjectIx == NULL)

 			{

 			NKern::ThreadLeaveCS();

 			r = KErrNoMemory;

 			}

 		else

 			{

 			NKern::ThreadLeaveCS();

 			kumemput32(args[0], &threadTestObjectIx, sizeof(RObjectIx*));

 			r = KErrNone;

 			}

 		Kern::RequestComplete(s, r);

 		r = KErrNone;

 		}

 		break;

 	case RTestDObject::ERObjectIxThreadTestExerciseIx:

 		//RTestDObject::RObjectIxThreadTestExerciseIx(void* aRObjectIxPtr);

 		{

 		RObjectIx*  threadTestObjectIx = (RObjectIx*) args[0];

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			{

 			if (KErrNone != (r=RObjectIxTestExerciseIx(*threadTestObjectIx, i)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 			}

 		NKern::ThreadLeaveCS();

 		Kern::RequestComplete(s, KErrNone);

 		r = KErrNone;

 		}

 		break;

 	case RTestDObject::ERObjectIxThreadTestFreeIx:

 		//RTestDObject::RObjectIxThreadTestFreeIx(void* aRObjectIxPtr)

 		{

 		RObjectIx*  threadTestObjectIx = (RObjectIx*) args[0];

 		NKern::ThreadEnterCS();

 		threadTestObjectIx->Check(0);

 		threadTestObjectIx->Close(NULL);

 		delete threadTestObjectIx;

 		threadTestObjectIx = NULL;

 		NKern::ThreadLeaveCS();

 		Kern::RequestComplete(s, KErrNone);

 		r = KErrNone;

 		}

 		break;

 	case RTestDObject::ERObjectIxInvalidHandleLookupTest:

 		//RTestDObject::InvalidHandleLookupTest()

 		{

 		NKern::ThreadEnterCS();

 		for (i = 1;  i < KDObjectTestMaxTestSize;  i = i<KDObjectTestStepStart?i+1:i+KDObjectTestStep) 

 			{

 			if (KErrNone != (r=RObjectIxInvalidHandleLookupTest(i)))

 				{

 				NKern::ThreadLeaveCS();

 				Kern::RequestComplete(s, r);

 				return KErrNone;

 				}

 			}

 		NKern::ThreadLeaveCS();

 		Kern::RequestComplete(s, r);

 		}

 		break;

 	case RTestDObject::EDObjectNameTest:

 		r = DObjectNameTest();

 		Kern::RequestComplete(s, r);

 		break;

 	default:

 		r = KErrNotSupported;

 		break;

 		}

 	return r;

 	}