// Copyright (c) 1994-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\buffer\t_array.cpp

 // Overview:

 // Simple array tests.

 // API Information:

 // RArray, RPointerArray.

 // Details:

 // - Create fixed length array of 32 and 64 bit integer objects, an array 

 // of pointers to objects and verify that they are created successfully. 

 // - Simulate heap allocation failure test for the current thread's heap, 

 // append some 32 & 64 bit integers to the created arrays and verify the 

 // returned errors are as expected.

 // - Append some 32, 64 bit integers to fixed length arrays of 32 and 64 

 // bit integer objects respectively, check that KErrNoMemory is returned 

 // as expected.

 // - Verify heap allocation granularity.

 // - Simulate heap allocation failure, attempt to insert an object into 

 // the arrays, verify failure as expected and verify that the array 

 // contents were not modified.

 // - Remove elements from the arrays and verify that the number of 

 // elements held in the arrays are as expected.

 // - Append and remove an element to each array (uncompressed) and check

 // that the number of elements held in the arrays are as expected.

 // - Simulate heap allocation failure, compress the arrays and verify 

 // that KErrNoMemory is returned on appending elements to the arrays.

 // - Reset the arrays and check the number of elements held in the arrays are 0.

 // - Append some 64 bit integer objects to the array of pointers to objects and 

 // verify that the number of elements held in the array is as expected.

 // - Empty the array of pointers, and verify that the heap has not been corrupted by 

 // any of the tests.

 // - Using a variety of random sized arrays, test RArray::FindInOrder and 

 // RPointerArray::FindInOrder, verify that the results are as expected.

 // - Using a variety of random sized arrays, test RArray::FindInSignedKeyOrder 

 // and RArray::FindInUnsignedKeyOrder, verify that the results are as expected.

 // - Using a variety of random sized arrays of a struct, test RArray::FindInUnsignedKeyOrder

 // an dRArray::FindInUnsignedKeyOrder, verify that the results are as expected.

 // - Using a variety of random sized arrays, test RPointerArray::FindInAddressOrder, 

 // verify that the results are as expected.

 // - Verify that the heap has not been corrupted by any of the tests.

 // - Tests for RArray and standard array objects:

 // - Append random numbers to the arrays and verify that the arrays are as expected. 

 // - Append and remove integers to an RArray, check the values are added and removed 

 // as expected.

 // - Append some random numbers, check that the numbers are found in the array using 

 // sequential and binary search techniques.

 // - Append some random numbers, insert them into the arrays allowing duplicates 

 // entries and without duplicate entries and check the numbers are found as expected.

 // - Insert some random numbers into the arrays allowing duplicates, and check the 

 // numbers are added as  expected.

 // - Insert a sequence of integers into an array, use the SpecificFindInOrder method 

 // and verify that results are as expected.

 // - Tests for 4 byte RArrays:

 // - Append random numbers to the arrays and verify that the arrays are as expected. 

 // - Append and remove integers to an RArray, check the values are added and removed 

 // as expected.

 // - Append some random numbers, check that the numbers are found in the array using 

 // sequential and binary search techniques.

 // - Append some random numbers, insert them into the arrays allowing duplicates 

 // entries and without duplicate entries and check the numbers are found as expected.

 // - Insert some random numbers into the arrays allowing duplicates, and check the 

 // numbers are added as  expected.

 // - Insert a sequence of integers into an array, use the SpecificFindInOrder method 

 // and verify that results are as expected.

 // - Verify that the heap has not been corrupted by any of the tests.

 // - Repeat the above test for arrays of unsigned integers, pointers, 64 bit integer 

 // array objects and array of pointers objects.

 // - Test and trap a variety of error conditions that cause the array functions to leave. 

 // Test on arrays of integers, pointers, unsigned integers and TInts.

 // - Verify that the heap has not been corrupted by any of the tests.

 // - Perform simple array tests by appending, finding, find in order, insert in order, 

 // sorting, growing and compressing arrays. Verify results are as expected.

 // - Perform a variety of speed tests on array objects.

 // - Test whether the heap has been corrupted by all the tests.

 // Platforms/Drives/Compatibility:

 // All 

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include <e32test.h>

 #include <e32math.h>

 GLREF_C void DoSpeedTests();

 GLREF_C void DoIntArrayTests();

 GLREF_C void DoUintArrayTests();

 GLREF_C void DoPointerArrayTests();

 GLREF_C void DoPointerArrayLeavingInterfaceTest();

 GLREF_C void DoPointerArrayAnyTests();

 GLREF_C void DoPointerArrayAnyLeavingInterfaceTest();

 GLREF_C void DoArrayLeavingInterfaceTest();

 GLDEF_C void DoTIntArrayLeavingInterfaceTest();

 GLDEF_C void DoTUintArrayLeavingInterfaceTest();

 GLREF_C void DoSimpleArrayTests();

 GLREF_C void DoRArrayTests();

 GLDEF_C RTest test(_L("T_ARRAY"));

 static TInt64 seed = MAKE_TINT64(0xb504f333,0xf9de6484);

 GLDEF_C TInt Random()

 	{

 	// Using this formula ensures repeated numbers wont come up in the tests.

 	seed = ((TUint) (69069*seed + 41));

 	return (TInt) seed;

 	}

 #ifdef _DEBUG

 RArray<TInt> *TheIntArray;

 RPointerArray<TInt64> *ThePtrArray;

 RArray<TInt64> *TheSimpleArray;

 void DoAllocTests()

 	{

 	test.Next(_L("Testing alloc failure"));

 	TheIntArray = new RArray<TInt>(16);

 	test(TheIntArray!=NULL);

 	ThePtrArray = new RPointerArray<TInt64>;

 	test(ThePtrArray!=NULL);

 	TheSimpleArray = new RArray<TInt64>;

 	test(TheSimpleArray!=NULL);

 	__UHEAP_MARK;

 	__UHEAP_SETFAIL(RHeap::EDeterministic,1);

 	TInt64 x = MAKE_TINT64(0xb504f333,0xf9de6484);

 	TInt64 y = MAKE_TINT64(0xc90fdaa2,0xc2352168);

 	TInt i;

 	TInt r=TheIntArray->Append(0);

 	test(r==KErrNoMemory);

 	r=ThePtrArray->Append(&x);

 	test(r==KErrNoMemory);

 	r=TheSimpleArray->Append(x);

 	test(r==KErrNoMemory);

 	__UHEAP_RESET;

 	r=TheIntArray->Append(0);

 	test(r==KErrNone);

 	r=ThePtrArray->Append(&x);

 	test(r==KErrNone);

 	r=TheSimpleArray->Append(x);

 	test(r==KErrNone);

 	TUint8* p1=new TUint8[1024];	// alloc a big cell to block simple expansion

 	__UHEAP_SETFAIL(RHeap::EDeterministic,1);

 	test.Next(_L("Testing granularity"));

 	TInt n=0;

 	while(r==KErrNone)

 		{

 		n++;

 		r=TheIntArray->Append(0);

 		}

 	test(r==KErrNoMemory);

 	test(n==16);

 	test(TheIntArray->Count()==16);

 	r=KErrNone;

 	n=0;

 	while(r==KErrNone)

 		{

 		n++;

 		r=ThePtrArray->Append(&x);

 		}

 	test(r==KErrNoMemory);

 	test(n==8);

 	test(ThePtrArray->Count()==8);		// default

 	r=KErrNone;

 	n=0;

 	while(r==KErrNone)

 		{

 		n++;

 		r=TheSimpleArray->Append(x);

 		}

 	test(r==KErrNoMemory);

 	test(n==8);

 	test(TheSimpleArray->Count()==8);	// default

 	r=TheIntArray->Insert(1,1);

 	test(r==KErrNoMemory);

 	test(TheIntArray->Count()==16);

 	for (i=0; i<TheIntArray->Count(); i++)

 		{

 		test((*TheIntArray)[i]==0);

 		}

 	r=ThePtrArray->Insert(&y,1);

 	test(r==KErrNoMemory);

 	test(ThePtrArray->Count()==8);

 	for (i=0; i<ThePtrArray->Count(); i++)

 		{

 		test((*ThePtrArray)[i]==&x);

 		}

 	r=TheSimpleArray->Insert(y,1);

 	test(r==KErrNoMemory);

 	test(TheSimpleArray->Count()==8);

 	for (i=0; i<TheSimpleArray->Count(); i++)

 		{

 		test((*TheSimpleArray)[i]==x);

 		}

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

 		{

 		TheIntArray->Remove(1);

 		}

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

 		{

 		ThePtrArray->Remove(1);

 		}

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

 		{

 		TheSimpleArray->Remove(1);

 		}

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

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

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

 	__UHEAP_RESET;

 	TAny* p2=User::Alloc(48);

 	TAny* p3=User::Alloc(24);

 	TAny* p4=User::Alloc(24);

 	__UHEAP_SETFAIL(RHeap::EDeterministic,1);

 	r=TheIntArray->Append(0);

 	test(r==KErrNone);

 	r=ThePtrArray->Append(&x);

 	test(r==KErrNone);

 	r=TheSimpleArray->Append(x);

 	test(r==KErrNone);

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

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

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

 	TheIntArray->Remove(1);

 	ThePtrArray->Remove(1);

 	TheSimpleArray->Remove(1);

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

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

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

 	TheIntArray->Compress();

 	ThePtrArray->Compress();

 	TheSimpleArray->Compress();

 	User::Free(p2);

 	User::Free(p3);

 	User::Free(p4);

 	__UHEAP_RESET;

 	p2=User::Alloc(48);

 	p3=User::Alloc(24);

 	p4=User::Alloc(24);

 	__UHEAP_SETFAIL(RHeap::EDeterministic,1);

 	r=TheIntArray->Append(0);

 	test(r==KErrNoMemory);

 	r=ThePtrArray->Append(&x);

 	test(r==KErrNoMemory);

 	r=TheSimpleArray->Append(x);

 	test(r==KErrNoMemory);

 	TheIntArray->Reset();

 	ThePtrArray->Reset();

 	TheSimpleArray->Reset();

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

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

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

 	delete p1;

 	User::Free(p2);

 	User::Free(p3);

 	User::Free(p4);

 	__UHEAP_RESET;

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

 	TInt64 *i1=new TInt64;

 	TInt64 *i2=new TInt64;

 	TInt64 *i3=new TInt64;

 	TInt64 *i4=new TInt64;

 	ThePtrArray->Append(i1);

 	ThePtrArray->Append(i2);

 	ThePtrArray->Append(i3);

 	ThePtrArray->Append(i4);

 	test(ThePtrArray->Count()==4);

 	ThePtrArray->ResetAndDestroy();

 	__UHEAP_MARKEND;

 	TheIntArray->Close();

 	delete TheIntArray;

 	ThePtrArray->Close();

 	delete ThePtrArray;

 	TheSimpleArray->Close();

 	delete TheSimpleArray;

 	}

 #endif

 class RHeapMonitor : public RAllocator

 	{

 public:

 	static RHeapMonitor& Install();

 	void Uninstall();

 	RHeapMonitor();

 public:

 	virtual TAny* Alloc(TInt);

 	virtual void Free(TAny*);

 	virtual TAny* ReAlloc(TAny*, TInt, TInt);

 	virtual TInt AllocLen(const TAny*) const;

 	virtual TInt Compress();

 	virtual void Reset();

 	virtual TInt AllocSize(TInt&) const;

 	virtual TInt Available(TInt&) const;

 	virtual TInt DebugFunction(TInt, TAny*, TAny*);

 	virtual TInt Extension_(TUint, TAny*&, TAny*);

 public:

 	RAllocator* iOrig;

 	TInt iAllocs;

 	TInt iFailedAllocs;

 	TInt iFrees;

 	TInt iReallocs;

 	TInt iFailedReallocs;

 	};

 RHeapMonitor::RHeapMonitor()

 	{

 	iOrig = &User::Allocator();

 	iAllocs = 0;

 	iFailedAllocs = 0;

 	iFrees = 0;

 	iReallocs = 0;

 	iFailedReallocs = 0;

 	}

 RHeapMonitor& RHeapMonitor::Install()

 	{

 	RHeapMonitor* m = new RHeapMonitor;

 	test(m!=0);

 	RAllocator* orig = User::SwitchAllocator(m);

 	test(orig == m->iOrig);

 	return *m;

 	}

 void RHeapMonitor::Uninstall()

 	{

 	RAllocator* m = User::SwitchAllocator(iOrig);

 	test(m == this);

 	delete this;

 	}

 TAny* RHeapMonitor::Alloc(TInt a)

 	{

 	++iAllocs;

 	TAny* p = iOrig->Alloc(a);

 	if (!p) ++iFailedAllocs;

 	return p;

 	}

 void RHeapMonitor::Free(TAny* a)

 	{

 	if (a) ++iFrees;

 	iOrig->Free(a);

 	}

 TAny* RHeapMonitor::ReAlloc(TAny* aCell, TInt aSize, TInt aMode)

 	{

 	if (aCell && aSize>0)

 		++iReallocs;

 	else if (aCell)

 		++iFrees;

 	else

 		++iAllocs;

 	TAny* p = iOrig->ReAlloc(aCell, aSize, aMode);

 	if (!p && aSize>0)

 		{

 		if (aCell)

 			++iFailedReallocs;

 		else

 			++iFailedAllocs;

 		}

 	return p;

 	}

 TInt RHeapMonitor::AllocLen(const TAny* a) const

 	{

 	return iOrig->AllocLen(a);

 	}

 TInt RHeapMonitor::Compress()

 	{

 	return iOrig->Compress();

 	}

 void RHeapMonitor::Reset()

 	{

 	iOrig->Reset();

 	}

 TInt RHeapMonitor::AllocSize(TInt& a) const

 	{

 	return iOrig->AllocSize(a);

 	}

 TInt RHeapMonitor::Available(TInt& a) const

 	{

 	return iOrig->Available(a);

 	}

 TInt RHeapMonitor::DebugFunction(TInt aFunc, TAny* a1, TAny* a2)

 	{

 	return iOrig->DebugFunction(aFunc, a1, a2);

 	}

 TInt RHeapMonitor::Extension_(TUint, TAny*&, TAny*)

 	{

 	return KErrExtensionNotSupported;

 	}

 template<class T>

 void TestReserveT()

 	{

 	RHeapMonitor& m = RHeapMonitor::Install();

 	TInt r;

 	RArray<T> a(1);

 	test(a.Count()==0);

 	test(m.iAllocs==0);

 	test(a.Append(1)==KErrNone);

 	test(m.iAllocs==1);

 	test(m.iReallocs==0);

 	test(a.Append(2)==KErrNone);

 	test(m.iReallocs==1);	// should have realloc'd

 	a.Close();

 	test(m.iFrees==1);

 	test(m.iAllocs==1);

 	test(m.iReallocs==1);

 	test(a.Count()==0);

 	test(a.Reserve(2)==KErrNone);

 	test(m.iAllocs==2);

 	TRAP(r,a.ReserveL(2));

 	test(r==KErrNone);

 	test(m.iFrees==1);

 	test(m.iAllocs==2);

 	test(m.iReallocs==1);

 	test(a.Append(1)==KErrNone);

 	test(m.iFrees==1);

 	test(m.iAllocs==2);

 	test(m.iReallocs==1);

 	test(a.Append(2)==KErrNone);

 	test(m.iFrees==1);

 	test(m.iAllocs==2);

 	test(m.iReallocs==1);	// shouldn't have realloc'd

 	test(a.Append(3)==KErrNone);

 	test(m.iFrees==1);

 	test(m.iAllocs==2);

 	test(m.iReallocs==2);	// should have realloc'd

 	a.Close();

 	test(m.iFrees==2);

 	test(m.iAllocs==2);

 	test(m.iReallocs==2);

 	test(a.Count()==0);

 	test(a.Reserve(2)==KErrNone);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==2);

 	test(a.Append(1)==KErrNone);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==2);

 	test(a.Append(2)==KErrNone);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==2);

 	test(a.Reserve(0x20000000)==KErrNoMemory);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==2);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==2);

 	test(a.Reserve(8)==KErrNone);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==3);

 	test(a.Append(3)==KErrNone);

 	test(a.Append(4)==KErrNone);

 	test(a.Append(5)==KErrNone);

 	test(a.Append(6)==KErrNone);

 	test(a.Append(7)==KErrNone);

 	test(a.Append(8)==KErrNone);

 	test(a.Count()==8);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==3);

 	TInt i;

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

 		{

 		test(a.Reserve(i)==KErrNone);

 		test(m.iFrees==2);

 		test(m.iAllocs==3);

 		test(m.iReallocs==3);

 		}

 	test(a.Append(9)==KErrNone);

 	test(m.iFrees==2);

 	test(m.iAllocs==3);

 	test(m.iReallocs==4);

 	a.Close();

 	test(m.iFrees==3);

 	test(m.iAllocs==3);

 	test(m.iReallocs==4);

 #ifdef _DEBUG

 	__UHEAP_FAILNEXT(1);

 	test(a.Count()==0);

 	test(a.Reserve(0)==KErrNone);

 	test(m.iFrees==3);

 	test(m.iAllocs==3);

 	test(m.iReallocs==4);

 	test(m.iFailedAllocs==0);

 	test(a.Reserve(1)==KErrNoMemory);

 	test(m.iFrees==3);

 	test(m.iAllocs==4);

 	test(m.iReallocs==4);

 	test(m.iFailedAllocs==1);

 	test(a.Reserve(1)==KErrNone);

 	test(m.iFrees==3);

 	test(m.iAllocs==5);

 	test(m.iReallocs==4);

 	test(m.iFailedAllocs==1);

 	a.Close();

 	test(m.iFrees==4);

 	test(m.iAllocs==5);

 	test(m.iReallocs==4);

 	test(m.iFailedAllocs==1);

 #endif

 	m.Uninstall();

 	TUint count = 0x80000000u / sizeof(T);

 	// don't do this in the heap monitored section because

 	// throwing a C++ exception allocates and frees memory

 	TRAP(r,a.ReserveL(count));

 	test(r==KErrNoMemory);

 	}

 void TestReserve()

 	{

 	test.Start(_L("Test Reserve()"));

 	__UHEAP_MARK;

 	TestReserveT<TInt>();

 	TestReserveT<TInt64>();

 	__UHEAP_MARKEND;

 	test.End();

 	}

 GLDEF_C TInt E32Main()

 	{

 	CTrapCleanup* trapHandler=CTrapCleanup::New();

 	test(trapHandler!=NULL);

 	test.Title();

 	test.Start(_L("Simple array tests"));

 #ifdef _DEBUG

 	DoAllocTests();

 #endif

 	TestReserve();

 	__UHEAP_MARK;

 	DoRArrayTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoIntArrayTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoUintArrayTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoPointerArrayTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	TRAPD(ret,DoArrayLeavingInterfaceTest());

 	test(ret==KErrNone);

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	TRAP(ret,DoPointerArrayLeavingInterfaceTest());

 	test(ret==KErrNone);

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	TRAP(ret,DoTIntArrayLeavingInterfaceTest());

 	test(ret==KErrNone);

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	TRAP(ret,DoTUintArrayLeavingInterfaceTest());

 	test(ret==KErrNone);

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoSimpleArrayTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoPointerArrayAnyTests();

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	TRAP(ret,DoPointerArrayAnyLeavingInterfaceTest());

 	test(ret==KErrNone);

 	__UHEAP_MARKEND;

 	__UHEAP_MARK;

 	DoSpeedTests();

 	__UHEAP_MARKEND;

 	test.End();

 	delete trapHandler;

 	return KErrNone;

 	}