// 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)
		{
		TFindMutex find(MutexName(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;

	for (TInt i = 0 ; i < KObjectCount ; ++i)
		{
		TFindMutex find(MutexName(i));
		test(find.Next(name) == KErrNotFound);
		}
	}


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)
		{
		TFindMutex find2(MutexName(i));
		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)
		{
		TFindMutex find(MutexName(i));
		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)
		{
		TFindMutex find2(MutexName(i));
		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)
		{
		TFindMutex find(MutexName(i));
		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);
		TFindMutex find(MutexName(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();
		}
	}

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);
		TFindMutex find(MutexName(0));
		test(find.Next(name) == KErrNone);
		test(name == MutexName(0));
		test.Printf(_L("  %02d: found handle %08x\n"), i, find.Handle());
		mutex.Close();

		TFindMutex find2(MutexName(0));
		test(find2.Next(name) == KErrNotFound);
		}
	}

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)
		{
		TFindMutex find(MutexName(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);
	}