// Copyright (c) 1995-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_cobj.cpp

// Overview:

// Test CObject, CObjectIx, CObjectCon, CObjectConIx classes

// API Information:

// CObject, CObjectIx, CObjectCon, CObjectConIx

// Details:

// - Test the CObjectIx class by adding and removing CObject objects

// in the same order, in reverse order and in random order.

// - Test adding many CObject objects to a CObjectConIx and test that

// the returned handle is as expected.

// - Perform a speed test on CObjectCon for both named and unnamed

// objects.

// - Check that the CObject, CObjectCon, CObjectIx and CObjectConIx methods 

// are in the DLL by calling each one.

// - Test the CObject, CObjectCon, CObjectIx and CObjectConIx methods and

// verify the results are as expected.

// - Test all the objects together: create two containers, find objects by 

// name in a variety of ways, delete objects and verify the results are 

// as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32base.h>

#include <e32base_private.h>

#include <e32test.h>

#include <e32svr.h>

#include <e32ver.h>

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

struct TCObjectDump

	{

	TInt 		iAccessCount;

	CObject*	iOwner;

	CObjectCon*	iContainer;

	HBufC*		iName;

	};

void CObject::__DbgTest(void* pCObjectDump) const

	{

	((TCObjectDump*)pCObjectDump)->iAccessCount=iAccessCount;

	((TCObjectDump*)pCObjectDump)->iOwner=iOwner;

	((TCObjectDump*)pCObjectDump)->iContainer=iContainer;

	((TCObjectDump*)pCObjectDump)->iName=iName;

	}

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

LOCAL_D	TName gName;

LOCAL_D	TName gName1;

LOCAL_D	TName gName2;

LOCAL_D	TFullName gFullName;

LOCAL_D	TFullName gFullName1;

LOCAL_D	TFullName gFullName2;

class RTestHeap : public RAllocator

	{

public:

	enum TOp {EOpNone=0, EOpAlloc=1, EOpFree=2, EOpReAlloc=3};

	struct TOpInfo

		{

		TInt	iOp;

		TAny*	iPtrArg;

		TInt	iIntArg;

		TAny*	iResult;

		};

public:

	static RTestHeap* Install();

	void Uninstall();

	TInt GetLastOp(TOpInfo& aInfo);

	virtual TAny* Alloc(TInt aSize);

	virtual void Free(TAny* aPtr);

	virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode);

	virtual TInt AllocLen(const TAny* aCell) const;

	virtual TInt Compress();

	virtual void Reset();

	virtual TInt AllocSize(TInt& aTotalAllocSize) const;

	virtual TInt Available(TInt& aBiggestBlock) const;

	virtual TInt DebugFunction(TInt aFunc, TAny* a1, TAny* a2);

public:

	RAllocator* iA;

	TOpInfo iLastOp;

	};

RTestHeap* RTestHeap::Install()

	{

	RTestHeap* p = new RTestHeap;

	test(p!=0);

	p->iA = &User::Heap();

	p->iLastOp.iOp = EOpNone;

	User::SwitchHeap(p);

	return p;

	}

void RTestHeap::Uninstall()

	{

	User::SwitchHeap(iA);

	delete this;

	}

TInt RTestHeap::GetLastOp(RTestHeap::TOpInfo& aInfo)

	{

	memcpy(&aInfo, &iLastOp, sizeof(TOpInfo));

	iLastOp.iOp = EOpNone;

	return (aInfo.iOp == EOpNone) ? KErrNotFound : KErrNone;

	}

TAny* RTestHeap::Alloc(TInt aSize)

	{

	TAny* p = iA->Alloc(aSize);

	iLastOp.iOp = EOpAlloc;

	iLastOp.iPtrArg = 0;

	iLastOp.iIntArg = aSize;

	iLastOp.iResult = p;

	return p;

	}

void RTestHeap::Free(TAny* aPtr)

	{

	iLastOp.iOp = EOpFree;

	iLastOp.iPtrArg = aPtr;

	iLastOp.iIntArg = 0;

	iLastOp.iResult = 0;

	iA->Free(aPtr);

	}

TAny* RTestHeap::ReAlloc(TAny* aPtr, TInt aSize, TInt aMode=0)

	{

	TAny* p = iA->ReAlloc(aPtr,aSize,aMode);

	iLastOp.iOp = EOpReAlloc;

	iLastOp.iPtrArg = aPtr;

	iLastOp.iIntArg = aSize;

	iLastOp.iResult = p;

	return p;

	}

TInt RTestHeap::AllocLen(const TAny* aCell) const

	{

	TInt l = iA->AllocLen(aCell);

	return l;

	}

TInt RTestHeap::Compress()

	{

	TInt l = iA->Compress();

	return l;

	}

void RTestHeap::Reset()

	{

	iA->Reset();

	}

TInt RTestHeap::AllocSize(TInt& aTotalAllocSize) const

	{

	TInt s;

	TInt r = iA->AllocSize(s);

	aTotalAllocSize = s;

	return r;

	}

TInt RTestHeap::Available(TInt& aBiggestBlock) const

	{

	TInt s;

	TInt r = iA->Available(s);

	aBiggestBlock = s;

	return r;

	}

TInt RTestHeap::DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL)

	{

	TInt r = iA->DebugFunction(aFunc, a1, a2);

	return r;

	}

class TestCObjects

	{

public:

	void Test1(void);

	void Test2(void);

	void Test3(void);

	void Test4(void);

	void Test5(void);

	void Test6(void);

	void Test7(void);

	void Test8(void);

private:

	static void GetObjName(TName& aDest,const CObject& aObj);

	static void GetObjFullName(TFullName& aDest,const CObject& aObj);

	};

GLDEF_C void TestCObjects::Test1(void)

	{

	// Check CObject methods are in the DLL

	CObject* pCObject=new CObject; 

	CObject* temp=new CObject;

	pCObject->Open();

	pCObject->Close();

	gName=pCObject->Name();

	TPtrC aDesR(_S("a name"));

	pCObject->SetName(&aDesR);

	pCObject->SetNameL(&aDesR);

	gFullName=pCObject->FullName();

	pCObject->Owner();

	pCObject->SetOwner(temp);

	pCObject->Close(); // deletes object when iAccessCount==0

	temp->Close();

	}

GLDEF_C void TestCObjects::Test2(void)

	{

	// Check CObjectCon methods are in the DLL

	CObjectCon* pCObjectCon=CObjectCon::NewL();

	CObject* pCObject=new CObject;

	TInt aFindHandle=0;

	pCObjectCon->AddL(pCObject);

	pCObjectCon->At(aFindHandle);

	User::ValidateName(_L("a name"));

	pCObjectCon->CheckUniqueFullName(pCObject, _L("a name"));

	pCObjectCon->FindByName(aFindHandle, _L("a name"), gName); 

	pCObjectCon->FindByFullName(aFindHandle, _L("a Name"), gFullName);

	pCObjectCon->UniqueID();

	pCObjectCon->Count();

	pCObjectCon->Remove(pCObject); 

	pCObject->Close();

	delete pCObjectCon;

	}

GLDEF_C void TestCObjects::Test3(void)

	{	

	// Check the CObjectIx methods are in the DLL		  

	CObjectIx* pCObjectIx=CObjectIx::NewL();

	pCObjectIx->Count();

	test(pCObjectIx->At(0)==NULL);

	delete pCObjectIx;

	pCObjectIx=CObjectIx::NewL();

	test(pCObjectIx->Count()==0);

	CObjectConIx* pCObjectConIx=CObjectConIx::NewL();

	delete pCObjectConIx;

	pCObjectConIx=CObjectConIx::NewL();

	CObjectCon* pCObjectCon=pCObjectConIx->CreateL();

	test(pCObjectCon->Count()==0);

	CObject* pCObject= new CObject;

	test(pCObject!=NULL);

	TInt find;

	TName name;

	TInt r=pCObjectCon->FindByName(find,_L("Name"),name);

	test(r==KErrNotFound);

	TFullName fullName;

	r=pCObjectCon->FindByFullName(find,_L("Full Name"),fullName);

	test(r==KErrNotFound);

	pCObjectCon->AddL(pCObject);

	test(pCObjectCon->Count()==1);

	test(pCObjectIx->Count(pCObject)==0);

	pCObjectIx->AddL(pCObject); 

	test(pCObjectIx->Count(pCObject)==1);

	pCObjectIx->Count();

	pCObjectIx->At(0, 0);

	pCObjectIx->At(0);

//	pCObjectIx->Remove(0);

	delete pCObjectIx;

	delete pCObjectConIx;

//	delete pCObjectCon;

//	pCObject->Close();

	}

GLDEF_C void TestCObjects::Test4(void)

	{

	// Check CObjectConIx methods are in the DLL

	CObjectConIx* pCObjectConIx=CObjectConIx::NewL();

	CObjectCon* pCObjectCon=pCObjectConIx->CreateL();

	pCObjectConIx->Lookup(0);

	pCObjectConIx->Remove(pCObjectCon);

	delete pCObjectConIx;

	}

GLDEF_C void TestCObjects::Test5(void)

	{

	// Test the methods of the CObject class

	TCObjectDump CObjectDump;

	CObject* a=new CObject;

	CObject* b=new CObject;

	a->__DbgTest(&CObjectDump);

	test(CObjectDump.iAccessCount==1 && CObjectDump.iOwner==NULL && CObjectDump.iContainer==NULL);

	a->Open();

	a->__DbgTest(&CObjectDump);

	test(CObjectDump.iAccessCount==2);

	a->Close();

	a->__DbgTest(&CObjectDump);

	test(CObjectDump.iAccessCount==1);

	TPtrC aDesR(_L("aName"));

	a->SetName(&aDesR);

    gName=a->Name();

	test(gName==_L("aName"));

    gFullName=a->FullName();

	test(gFullName==_L("aName"));

	TPtrC aDesR2(_L("Owner"));

	b->SetName(&aDesR2);

	a->SetOwner(b);

	test(a->Owner()==b);

    gFullName=a->FullName();

	test(gFullName==_L("Owner::aName"));

	a->Close();  // Calls the destructor via the call to delete

// To Do: set iContainer to something then call Close() 

	}

GLDEF_C void TestCObjects::Test6(void)

	{

	// Test the methods of CObjectCon

	TCObjectDump dump1, dump2;

	TInt aFindHandle=0;

	CObject	*pObj1=new CObject,

			*pObj2=new CObject,

			*pObj3=new CObject,

			*temp;

	CObjectCon* pCon=CObjectCon::NewL();

	test(User::ValidateName(_L("xxx*xxx"))==KErrBadName);

	test(User::ValidateName(_L("xxx?xxx"))==KErrBadName);

	test(User::ValidateName(_L("xxx:xxx"))==KErrBadName);

	test(User::ValidateName(_L("xxxxxxx"))==KErrNone);

	TPtrC name1(_S("Obj1")), name2(_S("Obj2")), name3(_S("Owner"));

	pObj1->SetName(&name1);

	pObj2->SetName(&name2);

	pObj3->SetName(&name3);

	test(pCon->Count()==0);

	pCon->AddL(pObj1);

	test(pCon->Count()==1);

	pCon->AddL(pObj2);

	test(pCon->Count()==2);

	aFindHandle=0;

	test(pCon->FindByName(aFindHandle, _L("xxx"), gName)==KErrNotFound);

	aFindHandle=0;

	GetObjName(gName1,*pObj1);

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNone);

	test(aFindHandle==0);

	aFindHandle=2;

	GetObjName(gName1,*pObj1);

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNotFound);

	aFindHandle=0;

	GetObjName(gName1,*pObj2);

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNone);

	test(aFindHandle==1);

	aFindHandle=0;

	test(pCon->FindByFullName(aFindHandle, _L("xxx"), gFullName)==KErrNotFound);

	aFindHandle=0;

	GetObjName(gName1,*pObj1);

	test(pCon->FindByFullName(aFindHandle, gName1, gFullName)==KErrNone);

	test(aFindHandle==0);

	GetObjName(gName1,*pObj2);

	test(pCon->FindByFullName(aFindHandle, gName1, gFullName)==KErrNone);

	test(aFindHandle==1);

	pObj1->SetOwner(pObj3);

	pObj2->SetOwner(pObj3);

	aFindHandle=0;

	test(pCon->FindByFullName(aFindHandle, _L("xxx"), gFullName)==KErrNotFound);

	aFindHandle=0;

	GetObjFullName(gFullName1,*pObj1);

	test(pCon->FindByFullName(aFindHandle, gFullName1, gFullName)==KErrNone);

	test(aFindHandle==0);

	GetObjFullName(gFullName1,*pObj2);

	test(pCon->FindByFullName(aFindHandle, gFullName1, gFullName)==KErrNone);

	test(aFindHandle==1);

	test(pCon->CheckUniqueFullName(pObj3, _L("aname"))==KErrNone);

	GetObjName(gName1,*pObj1);

	test(pCon->CheckUniqueFullName(pObj3, gName1)==KErrAlreadyExists);

	pCon->Remove(pObj1);

	test(pCon->CheckUniqueFullName(pObj3, gName1)==KErrNone);

	test(pCon->Count()==1);

	pCon->AddL(pObj3);

	test(pCon->Count()==2);

	aFindHandle=0;

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNotFound);

	aFindHandle=0;

	GetObjFullName(gFullName1,*pObj1);

	test(pCon->FindByFullName(aFindHandle, gFullName1, gFullName)==KErrNotFound);

	aFindHandle=0;

	GetObjName(gName1,*pObj2);

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNone);

	test(aFindHandle==0);

	GetObjFullName(gFullName1,*pObj2);

	test(pCon->FindByFullName(aFindHandle, gFullName1, gFullName)==KErrNone);

	test(aFindHandle==0);

	GetObjName(gName1,*pObj3);

	test(pCon->FindByName(aFindHandle, gName1, gName)==KErrNone);

	test(aFindHandle==1);

	aFindHandle=0;

	test(pCon->FindByFullName(aFindHandle, _L("Owner"), gFullName)==KErrNone);

	test(aFindHandle==1);

	pObj2->__DbgTest(&dump1);

	temp=pCon->At(0);

	temp->__DbgTest(&dump2);

	test(dump1.iAccessCount==dump2.iAccessCount  && dump1.iOwner==dump2.iOwner && 

			dump1.iName==dump2.iName &&dump1.iContainer==dump2.iContainer); 

	pObj3->__DbgTest(&dump1);

	temp=pCon->At(1);

	temp->__DbgTest(&dump2);

	test(dump1.iAccessCount==dump2.iAccessCount  && dump1.iOwner==dump2.iOwner && 

			dump1.iName==dump2.iName &&dump1.iContainer==dump2.iContainer); 

	pCon->Remove(pObj2);

	pCon->Remove(pObj3);

	test(pCon->Count()==0);

	delete pCon;

	// Test expansion and shrinking

	__UHEAP_MARK;

	pCon=CObjectCon::NewL();

	CObject** obj = new CObject*[2048];

	test(obj!=0);

	TInt i;

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

		{

		obj[i] = new CObject;

		test(obj[i] != 0);

		}

	RTestHeap* h = RTestHeap::Install();

	const TInt xov_values[] = {0,8,12,16,24,32,48,64,96,128,192,256,384,512,768,1024,1536,2048};

	const TInt xov2_values[] = {1472, 960, 704, 448, 320, 192, 128, 96, 64, 48, 32, 24, 16, 12, 8, 6, 0};

	const TInt* xov_ptr = xov_values;

	const TInt* xov2_ptr = xov2_values;

	TInt sz = 0;

	TInt xov = 0;

	TAny* ptr = 0;

	for (i=1; i<=2048; ++i)

		{

		pCon->AddL(obj[i-1]);

		test(pCon->Count()==i);

		RTestHeap::TOpInfo opi;

		TInt r = h->GetLastOp(opi);

		if (i*4 <= sz)

			{

			test(r==KErrNotFound);

			continue;

			}

		test(r==KErrNone);

		test.Printf(_L("Realloc at %d -> %d\n"), i, opi.iIntArg);

		test(i-1 == xov);

		test(opi.iOp == RTestHeap::EOpReAlloc);

		test(opi.iPtrArg == ptr);

		// recalc xov

		xov = *++xov_ptr;

		test(opi.iIntArg == xov*4);

		sz = xov*4;

		test(opi.iResult != 0);

		ptr = opi.iResult;

		}

	xov = *xov2_ptr;

	for (i=2047; i>=0; --i)

		{

		pCon->Remove(obj[i]);

		test(pCon->Count()==i);

		RTestHeap::TOpInfo opi;

		TInt r = h->GetLastOp(opi);

		if (i>xov)

			{

			test(r==KErrNotFound);

			continue;

			}

		test(r==KErrNone);

		test.Printf(_L("Realloc at %d -> %d\n"), i, opi.iIntArg);

		test(i == xov);

		if (i==0)

			{

			test(opi.iOp == RTestHeap::EOpReAlloc || opi.iOp == RTestHeap::EOpFree);

			}

		else

			{

			test(opi.iOp = RTestHeap::EOpReAlloc);

			test(opi.iResult == ptr);

			}

		test(opi.iPtrArg == ptr);

		// recalc xov

		xov = *++xov2_ptr;

		sz = *--xov_ptr;

		test(opi.iIntArg == sz*4);

		}

	delete pCon;

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