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

// 

//

#include <e32test.h>

#include <e32math.h>

#include <e32std.h>

#include <e32std_private.h>

#define NUM_TESTS 200

GLREF_D RTest test;

GLREF_C TInt Random();

struct SEntry

	{

	TInt iKey;

	TInt iValue;

	inline TBool operator!=(const SEntry& anEntry) const

		{return (iValue!=anEntry.iValue || iKey!=anEntry.iKey);}

	inline TBool operator==(const SEntry& anEntry) const

		{return (iValue==anEntry.iValue && iKey==anEntry.iKey);}

	};

struct SArray

	{

	TInt iCount;

	TAny* iEntries;

	TInt iEntrySize;

	TInt iKeyOffset;

	TInt iAllocated;

	TInt iGranularity;

	};

GLREF_C TInt OrderSEntry(const SEntry& aLeft, const SEntry& aRight);

GLREF_C TInt OrderSEntryU(const SEntry& aLeft, const SEntry& aRight);

GLREF_C TInt OrderSEntry2(const SEntry& aLeft, const SEntry& aRight);

GLREF_C TInt OrderSEntryU2(const SEntry& aLeft, const SEntry& aRight);

GLREF_C TBool CompareSEntryByKeyKey(const TInt* aKey, const SEntry& aRight);

GLREF_C TBool CompareSEntryByKeyValue(const TInt* aValue, const SEntry& aRight);

GLREF_D TLinearOrder<TInt64> Int64Order;

GLREF_D TIdentityRelation<TInt64> Int64Identity;

GLREF_D TLinearOrder<SEntry> SEntryOrder;

GLREF_D TIdentityRelation<SEntry> SEntryKeyIdentity;

GLREF_D TIdentityRelation<SEntry> SEntryIdentity;

LOCAL_C TInt64 Random64(TInt64& aMask)

	{

	TInt64 x = MAKE_TINT64(Random()&I64HIGH(aMask), Random()&I64LOW(aMask));

	return x;

	}

LOCAL_C TInt IntAppendAndAccessTest(TInt aCount, TInt aNumTests, TInt64 aMask)

	{

	TInt n;

	for (n=0; n<aNumTests; n++)

		{

		RArray<TInt64> a(aCount);

		TInt64 *pA=new TInt64[aCount];

		if (!pA)

			{

			a.Close();

			return -65535;

			}

		TInt i;

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

			{

			TInt64 x=Random64(aMask);

			pA[i]=x;

			a.Append(x);

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			return -1;

			}

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

			{

			if (a[i]!=pA[i])

				{

				a.Close();

				return -2;

				}

			pA[i]=Random64(aMask);

			a[i]=pA[i];

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			return -3;

			}

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

			{

			if (a[i]!=pA[i])

				{

				a.Close();

				return -4;

				}

			}

		delete[] pA;

		a.Close();

		}

	return KErrNone;

	}

LOCAL_C TInt IntRemoveTest()

	{

	TInt m=32;

	TInt n=m*m+1;

	RArray<TInt64> a(n);

	TInt i;

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

		{

		TInt64 x = MAKE_TINT64(i*i,i);

		a.Append(x);

		}

	TInt p=2;

	for (i=2; i<=m; i++)

		{

		TInt j;

		for (j=0; j<(2*i-2); j++)

			{

			a.Remove(p);

			}

		p++;

		}

	if (a.Count()!=m+1)

		{

		a.Close();

		return -1;

		}

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

		{

		TInt64 x = MAKE_TINT64(i*i*i*i,i*i);

		if (a[i]!=x)

			{

			a.Close();

			return -2;

			}

		}

	a.Close();

	return KErrNone;

	}

LOCAL_C TInt IntFindTest(TInt aCount, TInt aNumTests, TInt64 aMask)

	{

	TInt n;

	for (n=0; n<aNumTests; n++)

		{

		RArray<TInt64> a(aCount);

		TInt64 *pA=new TInt64[aCount];

		if (!pA)

			{

			a.Close();

			return -65535;

			}

		TInt i;

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

			{

			pA[i]=Random64(aMask);

			a.Append(pA[i]);

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			return -1;

			}

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

			{

			TInt r=a.Find(pA[i],Int64Identity);

			if (r<0 || pA[i]!=pA[r] || r>i)

				{

				a.Close();

				return -2;

				}

			}

		delete[] pA;

		a.Close();

		}

	return KErrNone;

	}

template <class XTestInput>

LOCAL_C TInt FindWithEqualityOp(XTestInput &aObject1, XTestInput &aObject2)

	{

	//Construct a suitable RArray

	RArray<XTestInput> testRArray;

	//Append the test objects to the RArray

	testRArray.AppendL(aObject1);

	testRArray.AppendL(aObject2);

	testRArray.AppendL(aObject1);

	testRArray.AppendL(aObject2);

	//Demonstrate that "regular" Find() method returns incorrect result

	TInt pos = KErrNotFound;

	pos = testRArray.Find(aObject1);

	if(pos!=0)

		return KErrNotFound;

	pos = testRArray.Find(aObject2);

	if(pos!=0)

		return KErrNotFound;

	//Test the Find() method using TIdentityRelation default CTOR

	pos = testRArray.Find(aObject1, TIdentityRelation<XTestInput>());

	if(pos!=0)

		return KErrNotFound;

	pos = testRArray.Find(aObject2, TIdentityRelation<XTestInput>());

	if(pos!=1)

		return KErrNotFound;

	//Test the FindReverse() method using TIdentityRelation default CTOR

	pos = testRArray.FindReverse(aObject1, TIdentityRelation<XTestInput>());

	if(pos!=2)

		return KErrNotFound;

	pos = testRArray.FindReverse(aObject2, TIdentityRelation<XTestInput>());

	if(pos!=3)

		return KErrNotFound;

	//Objects have been found correctly if this point reached

	testRArray.Close();

	return KErrNone;

	}

LOCAL_C TInt FindWithEqualityOpTest()

	{

	//Test "complex" objects which would work incorrectly with the regular Find() method

	TPoint p1(0,0);

    TPoint p2(0,1);

    TPoint p3(0,2);

	test(FindWithEqualityOp(p1, p2) == KErrNone);

    TRect rect1(p1,p2);

    TRect rect2(p1,p3);

	test(FindWithEqualityOp(rect1, rect2) == KErrNone);

    TBuf<5> buf1(_L("test1"));

	TBuf<5> buf2(_L("test2"));

	test(FindWithEqualityOp(buf1, buf2) == KErrNone);

	return KErrNone;

	}

LOCAL_C TInt EntryFindTest(TInt aCount, TInt aNumTests)

	{

	TInt n;

	for (n=0; n<aNumTests; n++)

		{

		RArray<SEntry> a(aCount,0);	// keyed on iKey

		RArray<SEntry> b(aCount,4);	// keyed on iValue

		SEntry *pE=new SEntry[aCount];

		if (!pE)

			{

			a.Close();

			b.Close();

			return -65535;

			}

		TInt i;

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

			{

			pE[i].iValue=Random();

			pE[i].iKey=Random();

			a.Append(pE[i]);

			b.Append(pE[i]);

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			b.Close();

			return -1;

			}

		if (b.Count()!=aCount)

			{

			a.Close();

			b.Close();

			return -1;

			}

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

			{

			SEntry e1=pE[i];

			SEntry e2=pE[i];

			e2.iValue=~e2.iValue;

			SEntry e3=pE[i];

			e3.iKey=~e3.iKey;

			TInt r=a.Find(e1);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -2;

				}

			r=a.Find(e2);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -3;

				}

			r=a.Find(e3);

			if (r>=0 && pE[r].iKey!=e3.iKey)

				{

				a.Close();

				b.Close();

				return -4;

				}

			r=b.Find(e1);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -5;

				}

			r=b.Find(e3);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -6;

				}

			r=b.Find(e2);

			if (r>=0 && pE[r].iValue!=e3.iValue)

				{

				a.Close();

				b.Close();

				return -7;

				}

			r=a.Find(e1,SEntryIdentity);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -8;

				}

			r=a.Find(e2,SEntryIdentity);

			if (r>=0 && pE[r]!=e3)

				{

				a.Close();

				b.Close();

				return -9;

				}

			r=a.Find(e3,SEntryIdentity);

			if (r>=0 && pE[r]!=e3)

				{

				a.Close();

				b.Close();

				return -10;

				}

			r=b.Find(e1,SEntryIdentity);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -11;

				}

			r=b.Find(e3,SEntryIdentity);

			if (r>=0 && pE[r]!=e3)

				{

				a.Close();

				b.Close();

				return -12;

				}

			r=b.Find(e2,SEntryIdentity);

			if (r>=0 && pE[r]!=e3)

				{

				a.Close();

				b.Close();

				return -13;

				}

			r=a.Find(e1.iValue,CompareSEntryByKeyValue);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -14;

				}

			r=a.Find(e2.iValue,CompareSEntryByKeyValue);

			if (r>=0 && pE[r].iValue!=e2.iValue)

				{

				a.Close();

				b.Close();

				return -15;

				}			

			r=b.Find(e1.iKey,CompareSEntryByKeyKey);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -16;

				}

			r=b.Find(e3.iKey,CompareSEntryByKeyKey);

			if (r>=0 && pE[r].iKey!=e3.iKey)

				{

				a.Close();

				b.Close();

				return -17;

				}

			}

		delete[] pE;

		a.Close();

		b.Close();

		}

	return KErrNone;

	}

LOCAL_C TInt IntFindReverseTest(TInt aCount, TInt aNumTests, TInt64 aMask)

	{

	TInt n;

	for (n=0; n<aNumTests; n++)

		{

		RArray<TInt64> a(aCount);

		TInt64 *pA=new TInt64[aCount];

		if (!pA)

			{

			a.Close();

			return -65535;

			}

		TInt i;

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

			{

			pA[i]=Random64(aMask);

			a.Append(pA[i]);

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			return -1;

			}

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

			{

			TInt r=a.FindReverse(pA[i],Int64Identity);

			if (pA[i]!=pA[r] || r<i)

				{

				a.Close();

				return -2;

				}

			}

		delete[] pA;

		a.Close();

		}

	return KErrNone;

	}

LOCAL_C TInt EntryFindReverseTest(TInt aCount, TInt aNumTests)

	{

	TInt n;

	for (n=0; n<aNumTests; n++)

		{

		RArray<SEntry> a(aCount,0);	// keyed on iKey

		RArray<SEntry> b(aCount,4);	// keyed on iValue

		SEntry *pE=new SEntry[aCount];

		if (!pE)

			{

			a.Close();

			b.Close();

			return -65535;

			}

		TInt i;

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

			{

			pE[i].iValue=Random();

			pE[i].iKey=Random();

			a.Append(pE[i]);

			b.Append(pE[i]);

			}

		if (a.Count()!=aCount)

			{

			a.Close();

			b.Close();

			return -1;

			}

		if (b.Count()!=aCount)

			{

			a.Close();

			b.Close();

			return -1;

			}

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

			{

			SEntry e1=pE[i];

			SEntry e2=pE[i];

			e2.iValue=~e2.iValue;

			SEntry e3=pE[i];

			e3.iKey=~e3.iKey;

			TInt r=a.FindReverse(e1);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -2;

				}

			r=a.FindReverse(e2);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -3;

				}

			r=a.FindReverse(e3);

			if (r>=0 && pE[r].iKey!=e3.iKey)

				{

				a.Close();

				b.Close();

				return -4;

				}

			r=b.FindReverse(e1);

			if (r!=i)

				{

				a.Close();

				b.Close();

				return -5;

				}

			r=b.FindReverse(e3);