// 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;

	}