// 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\t_dobject.cpp

// Overview:

// Test RObjectIx strategy of memory reallocation and 

// free list maintenance.

// Test DObjectCon findhandle methods

// API Information:

// DObject, RObjectIx

// Details:

// - Add a number of DObjects to RObjectIx, then remove them 

// in the same order. Verify results are as expected. Time

// how long the process takes to complete.

// - Add a number of DObjects to RObjectIx, then remove them

// in the reverse order. Verify results are as expected. Time

// how long the process takes to complete.

// - Add and remove a random number of DObjects to/from RObjectIx.

// Time how long the process takes to complete.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#define __E32TEST_EXTENSION__

#include <e32test.h>

#include <e32math.h>

#include "d_dobject.h"

LOCAL_D RTest test(_L("T_DOBJECT"));

TInt TestRObjectIxAccess(TAny* aRObjectIxPtr)

	{

	const TInt  KConcurrentDObjectTestRepeats = 1;

	RTestDObject  ldd;

	TInt  ret;

	ret = ldd.Open();

	if (ret == KErrNone)

		{

		for (TInt  repeat = 0;  repeat < KConcurrentDObjectTestRepeats;  repeat++)

			{

			ret = ldd.RObjectIxThreadTestExerciseIx(aRObjectIxPtr);

			if (ret != KErrNone)

				{

				break;

				}

			}

		ldd.Close();

		}

	return ret;

	} // TestRObjectIxAccess

void TestConcurrentRObjectIxAccess(RTestDObject& aLdd)

	{

	const TInt  KConcurrentDObjectThreads = 4;

	_LIT(KConcurrentDObjectThreadName, "T_DObject_Thread");

	TInt ret;

	//

	// Create a RObjectIx in the driver (pointer not valid user side!)...

	//

	void*  objectIxPtr = NULL;

	ret = aLdd.RObjectIxThreadTestCreateIx(objectIxPtr);

	test_KErrNone(ret);

	//

	// Run KConcurrentDObjectThreads number of threads which random add/remove

	// DObjects to the same RObjectIx...

	//

	RThread  threadHandle[KConcurrentDObjectThreads];

	TRequestStatus  status[KConcurrentDObjectThreads];

	TBuf<32>  threadName;

	TInt  thread;

	for (thread = 0;  thread < KConcurrentDObjectThreads;  thread++)

		{

		threadName.Copy(KConcurrentDObjectThreadName);

		threadName.AppendNum(thread);

		ret = threadHandle[thread].Create(threadName, TestRObjectIxAccess, KDefaultStackSize, NULL, objectIxPtr);

		test_KErrNone(ret);

		threadHandle[thread].Logon(status[thread]);

		}

	//

	// The test thread must be higher priority to ensure all the threads start.

	// All the threads are then resumed and allowed to run to completion...

	//

	RThread().SetPriority(EPriorityMore);

	for (thread = 0;  thread < KConcurrentDObjectThreads;  thread++)

		{

		threadHandle[thread].Resume();

		}

	for (thread = 0;  thread < KConcurrentDObjectThreads;  thread++)

		{

		User::WaitForRequest(status[thread]);

		test_KErrNone(status[thread].Int());

		CLOSE_AND_WAIT(threadHandle[thread]);

		}

	RThread().SetPriority(EPriorityNormal);

	//

	// Free the RObjectIx in the driver...

	//

	ret = aLdd.RObjectIxThreadTestFreeIx(objectIxPtr);

	test_KErrNone(ret);

	} // TestConcurrentRObjectIxAccess

void ListAllMutexes()

	{

	test.Printf(_L("Mutexes:\n"));

	TFullName name;

	TFindMutex find;

	while (find.Next(name) == KErrNone)

		{

		test.Printf(_L("  %S (find handle == %08x)\n"), &name, find.Handle());

		}

	}

const TInt KObjectCount = 20;

_LIT(KDoubleMatch, "*double*");

_LIT(KTrippleMatch, "*tripple*");

RMutex Mutexes[KObjectCount];

TBuf<32> ObjectName;

const TDesC& MutexName(TInt i)

	{

	ObjectName.Zero();

	ObjectName.AppendFormat(_L("Mutex_%02d"), i);

	if (i % 2 == 0)

		ObjectName.Append(_L("_double"));

	if (i % 3 == 0)

		ObjectName.Append(_L("_tripple"));

	return ObjectName;

	}

void CreateMutexes()

	{

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		test(Mutexes[i].CreateGlobal(MutexName(i)) == KErrNone);

		}

	}

void DeleteMutexes()

	{

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		Mutexes[i].Close();

		}

	}

void TestMutexesCreated()

	{

	test.Next(_L("Test mutexes have been created"));

	TFullName name;

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		}

	}

void TestMutexesDeleted()

	{

	test.Next(_L("Test mutexes deleted"));

	TFullName name;

	}

void TestFindSpecificMutex()

	{

	test.Next(_L("Test finding specific mutexes"));

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		TFullName name;

		TFindMutex find(MutexName(i));

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		test(name == MutexName(i));

		RMutex mutex;

		test(mutex.Open(find) == KErrNone);

		test(mutex.Name() == MutexName(i));

		mutex.Close();

		test(find.Next(name) == KErrNotFound);

		}	

	}

void TestFindMutexGroups()

	{

	test.Next(_L("Test finding groups of mutexes using wildcard name matching"));

	TFullName name;

	TInt i;

	TFindMutex find2(KDoubleMatch);

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

		{

		test(find2.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find2.Handle());

		test(name == MutexName(i));

		}

	test(find2.Next(name) == KErrNotFound);

	TFindMutex find3(KTrippleMatch);

	for (i = 0 ; i < KObjectCount ; i += 3)

		{

		test(find3.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find3.Handle());

		test(name == MutexName(i));

		}

	test(find3.Next(name) == KErrNotFound);

	}

void TestMatchChange()

	{

	test.Next(_L("Test changing match half way through find"));

	TFullName name;

	TInt i;

	TFindMutex find(KDoubleMatch);

	for (i = 0 ; i < KObjectCount/2 ; i += 2)

		{

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		test(name == MutexName(i));

		}

	find.Find(KTrippleMatch);

	for (i = 0 ; i < KObjectCount ; i += 3)

		{

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		test(name == MutexName(i));

		}

	test(find.Next(name) == KErrNotFound);

	}

void TestFindAndDeleteMutex1()

	{

	test.Next(_L("Test finding mutexes when the last found object has been deleted"));

	// Find and delete even mutexes

	TFullName name;

	TInt i;

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

		{

		test(find2.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find2.Handle());

		Mutexes[i].Close();

		RMutex mutex;

		test(mutex.Open(find2) == KErrNotFound);

		}

	// Check odd mutexes remaining

	for (i = 1 ; i < KObjectCount ; i += 2)

		{

		test(find.Next(name) == KErrNone);

		}

	}

void TestFindAndDeleteMutex2()

	{

	test.Next(_L("Test finding mutexes when the last found object has moved in the container"));

	// Find even mutexes and delete odd

	TFullName name;

	TInt i;

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

		{

		test(find2.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find2.Handle());

		Mutexes[(i+KObjectCount-1)%KObjectCount].Close();	// -1%n = -1 or n-1, unspecified

		RMutex mutex;

		test(mutex.Open(find2) == KErrNone);

		test(mutex.Name() == MutexName(i));

		mutex.Close();

		}

	// Check even mutexes remaining

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

		{

		test(find.Next(name) == KErrNone);

		}

	}

void TestFindWithCreation()

	{

	test.Next(_L("Test finding mutexes interleaved with creation"));

	TFullName name;

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		test(Mutexes[i].CreateGlobal(MutexName(i)) == KErrNone);

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		RMutex mutex;

		test(mutex.Open(find) == KErrNone);

		test(mutex.Name() == MutexName(i));

		mutex.Close();

		}

	}

void TestFindWithCreation2()

	{

	test.Next(_L("Test finding mutexes interleaved with creation and deletion"));

	TFullName name;

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		RMutex mutex;

		test(mutex.CreateGlobal(MutexName(0)) == KErrNone);

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		mutex.Close();

		}

	}

void TestFindHandleOutOfRange()

	{

	test.Next(_L("Test finding mutexes when find handle index is off the end of container's array"));

	TFullName name;

	for (TInt i = 0 ; i < KObjectCount ; ++i)

		{

		test(find.Next(name) == KErrNone);

		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());

		RMutex mutex;

		test(mutex.Open(find) == KErrNone);

		test(mutex.Name() == MutexName(i));

		mutex.Close();

		// towards the end, suddenly delete half the mutexes

		if (i == (3 * KObjectCount) / 4)

			{

			for (TInt j = 0 ; j < KObjectCount / 2 ; ++j)

				Mutexes[j].Close();

			}

		}

	}

void TestFindHandles()

	{

	test.Start(_L("Test FindHandle APIs using mutex classes"));

	CreateMutexes();

	ListAllMutexes();

	TestMutexesCreated();

	TestFindSpecificMutex();

	TestFindMutexGroups();

	TestMatchChange();

	DeleteMutexes();

	TestMutexesDeleted();

	CreateMutexes();

	TestFindAndDeleteMutex1();

	DeleteMutexes();

	CreateMutexes();

	TestFindHandleOutOfRange();

	DeleteMutexes();

	CreateMutexes();

	TestFindAndDeleteMutex2();

	DeleteMutexes();

	TestFindWithCreation();

	DeleteMutexes();

	TestFindWithCreation2();

	TestMutexesDeleted();

	test.End();

	}

GLDEF_C TInt E32Main()

    {

	SParam param;

	TInt duration, r;

	RTestDObject ldd;

	test.Title();

	test.Start(_L("Loading test driver..."));

	r=User::LoadLogicalDevice(KDObjectTestLddName);

	test(r==KErrNone || r==KErrAlreadyExists);

	r=ldd.Open();

	test(r==KErrNone);

	test.Next(_L("RObjectIxTest1 test ..."));

	r=ldd.RObjectIxTest1(duration);

	test(KErrNone==r);

	test.Printf(_L("... completed in %d kernel ticks\n") , duration);

	test.Next(_L("RObjectIxTest2 test ..."));

	r=ldd.RObjectIxTest2(duration);

	test(KErrNone==r);

	test.Printf(_L("... completed in %d kernel ticks\n") , duration);

	test.Next(_L("RObjectIxTest3 test (performance) ..."));

	param.iSeed[0] = 0;

	param.iSeed[1] = 1;

	param.iPerformanceTest = ETrue;

	r=ldd.RObjectIxTest3(param);

	test(KErrNone==r);

	test.Printf(_L("... completed in %d kernel ticks\n") , param.duration);

	test.Next(_L("RObjectIxTest3 test (random)..."));

	param.iSeed[0]=User::TickCount();

	param.iSeed[1]=User::TickCount();

	param.iPerformanceTest = EFalse;

	test.Printf(_L("... seeds=%xh and %xh ..."),param.iSeed[0],param.iSeed[1]);

	r=ldd.RObjectIxTest3(param);

	test(KErrNone==r);

	test.Printf(_L("... completed in %d kernel ticks\n") , param.duration);

	test.Next(_L("RObjectIxTest4 test (reserved slots)..."));

	test_KErrNone(ldd.RObjectIxTest4(duration));

	test.Printf(_L("... completed in %d kernel ticks\n") , duration);

	test.Next(_L("Test Concurrent access to RObjectIx"));

	TestConcurrentRObjectIxAccess(ldd);

	test.Next(_L("Test Invalid handle look up"));

 	test_KErrNone(ldd.InvalidHandleLookupTest());

 	test.Next(_L("Test Kern::ValidateName and Kern::ValidateFullName"));

 	test_KErrNone(ldd.DObjectNameTest());

	test.Next(_L("Closing test driver"));

	ldd.Close();

	test.Next(_L("FindHandles test"));

	TestFindHandles();

	test.End();

	return(0);

	}