diff -r 000000000000 -r a41df078684a kerneltest/e32test/system/d_dobject.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/system/d_dobject.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,965 @@
+// 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;
+	}