// Copyright (c) 2005-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// which accompanies this distribution, and is available

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test/buffer/t_hashtab.cpp

// 

//

#include <e32test.h>

#include <e32hashtab.h>

#include <hal.h>

#if defined(__VC32__) || defined(__CW32__)

typedef unsigned short wch;

#else

typedef wchar_t wch;

#endif

RTest test(_L("T_HASHTAB"));

TInt NanoTickPeriod;

typedef TBuf8<80> TTestName;

typedef RHashSet<TInt> TIntSet;

typedef RHashSet<TTestName> TNameSet;

typedef RPtrHashSet<TDesC8> TStringSet8;

typedef RPtrHashSet<TDesC16> TStringSet16;

typedef RPtrHashMap<TDesC8,TDesC8> TStringMap8;

typedef RPtrHashMap<TDesC16,TDesC16> TStringMap16;

#define INTSET(x)	TIntSet x

#define NAMESET(x)	TNameSet x(&HashTestName, &TestNameIdentity)

#define STRSET8(x)	TStringSet8 x

#define STRSET16(x)	TStringSet16 x

#define STRMAP8(x)	TStringMap8 x

#define STRMAP16(x)	TStringMap16 x

RPointerArray<TDesC8> DesC8Array;

RPointerArray<TDesC16> DesC16Array;

class HashTest : public RHashTableBase

	{

public:

	HashTest() : RHashTableBase(0,0,0,0) {}

	using RHashTableBase::ConsistencyCheck;

	using RHashTableBase::Count;

	};

void CCheck(RHashTableBase& aHT)

	{

	TUint32 ci[1024];

	TUint32 dc;

	TUint32 cmp;

	HashTest* h = (HashTest*)&aHT;

	h->ConsistencyCheck(&dc, &cmp, 1024, ci);

	test.Printf(_L("Count = %d, Deleted = %d, Cmp = %d\n"), h->Count(), dc, cmp);

	TInt i;

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

		{

		if (ci[i])

			test.Printf(_L("%d chains of length %d\n"), ci[i], i);

		}

	}

const char* Numbers[] =

	{

	"zero",

	"one",

	"two",

	"three",

	"four",

	"five",

	"six",

	"seven",

	"eight",

	"nine",

	"ten",

	"eleven",

	"twelve",

	"thirteen",

	"fourteen",

	"fifteen",

	"sixteen",

	"seventeen",

	"eighteen",

	"nineteen",

	"twenty",

	"thirty",

	"forty",

	"fifty",

	"sixty",

	"seventy",

	"eighty",

	"ninety",

	"hundred",

	"thousand"

	};

TTestName NumberInWords(const TInt& aNum)

	{

	TInt a = aNum;

	TTestName n;

	if (a<20)

		{

		n.Copy((const TUint8*)Numbers[a]);

		return n;

		}

	if (a<100)

		{

		TInt tens = a/10;

		TInt units = a%10;

		n.Copy((const TUint8*)Numbers[tens-2+20]);

		if (units)

			{

			n.Append(' ');

			n.Append(TPtrC8((const TUint8*)Numbers[units]));

			}

		return n;

		}

	if (a<1000)

		{

		TInt h = a/100;

		n.Copy((const TUint8*)Numbers[h]);

		n.Append(' ');

		n.Append(TPtrC8((const TUint8*)Numbers[28]));

		a%=100;

		if (a)

			{

			TTestName n2(NumberInWords(a));

			n.Append(_L8(" and "));

			n+=n2;

			}

		return n;

		}

	TInt t = a/1000;

	n = NumberInWords(t);

	n.Append(' ');

	n.Append(TPtrC8((const TUint8*)Numbers[29]));

	a%=1000;

	if (a)

		{

		TTestName n2(NumberInWords(a));

		if (a<100)

			n.Append(_L8(" and "));

		else

			n.Append(' ');

		n+=n2;

		}

	return n;

	}

void PrintNumberInWords(TInt a)

	{

	TBuf<256> buf;

	TTestName n(NumberInWords(a));

	buf.Copy(n);

	test.Printf(_L("%d: %S\n"), a, &buf);

	}

TUint32 HashTestName(const TTestName& aN)

	{

	return DefaultHash::Des8(aN);

	}

TBool TestNameIdentity(const TTestName& aA, const TTestName& aB)

	{

	return aA == aB;

	}

/******************************************************************************

 * Utility functions for RHashSet<T>

 ******************************************************************************/

template <class T>

void Union(RHashSet<T>& aD, const RHashSet<T>& aS)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RHashSet<T>::TIter iS(aS);

	FOREVER

		{

		const T* p = iS.Next();

		if (!p)

			break;

		--c2;

		TInt r = aD.Insert(*p);

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class T>

void Subtract(RHashSet<T>& aD, const RHashSet<T>& aS)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	TInt nfd = 0;

	typename RHashSet<T>::TIter iS(aS);

	FOREVER

		{

		const T* p = iS.Next();

		if (!p)

			break;

		--c2;

		TInt r = aD.Remove(*p);

		test(r==KErrNone || r==KErrNotFound);

		if (r==KErrNotFound)

			++nfd;

		else

			--d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	test( (d0-d1) + nfd == c);

	}

template <class T>

void Intersect(RHashSet<T>& aD, const RHashSet<T>& aS)

	{

	typename RHashSet<T>::TIter iD(aD);

	FOREVER

		{

		const T* p = iD.Next();

		if (!p)

			break;

		if (!aS.Find(*p))

			iD.RemoveCurrent();

		}

	}

template <class T>

void CheckIdentical(const RHashSet<T>& aA, const RHashSet<T>& aB)

	{

	test(aA.Count()==aB.Count());

	TInt c = aA.Count();

	typename RHashSet<T>::TIter iA(aA);

	FOREVER

		{

		const T* p = iA.Next();

		if (!p)

			break;

		--c;

		test(aB.Find(*p)!=0);

		}

	test(c==0);

	c = aA.Count();

	typename RHashSet<T>::TIter iB(aB);

	FOREVER

		{

		const T* p = iB.Next();

		if (!p)

			break;

		--c;

		test(aA.Find(*p)!=0);

		}

	test(c==0);

	}

/******************************************************************************

 * Utility functions for RPtrHashSet<T>

 ******************************************************************************/

template <class T>

void Union(RPtrHashSet<T>& aD, const RPtrHashSet<T>& aS)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RPtrHashSet<T>::TIter iS(aS);

	FOREVER

		{

		const T* p = iS.Next();

		if (!p)

			break;

		--c2;

		TInt r = aD.Insert(p);

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class T>

void Subtract(RPtrHashSet<T>& aD, const RPtrHashSet<T>& aS)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	TInt nfd = 0;

	typename RPtrHashSet<T>::TIter iS(aS);

	FOREVER

		{

		const T* p = iS.Next();

		if (!p)

			break;

		--c2;

		TInt r = aD.Remove(p);

		test(r==KErrNone || r==KErrNotFound);

		if (r==KErrNotFound)

			++nfd;

		else

			--d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	test( (d0-d1) + nfd == c);

	}

template <class T>

void Intersect(RPtrHashSet<T>& aD, const RPtrHashSet<T>& aS)

	{

	typename RPtrHashSet<T>::TIter iD(aD);

	FOREVER

		{

		const T* p = iD.Next();

		if (!p)

			break;

		if (!aS.Find(*p))

			iD.RemoveCurrent();

		}

	}

template <class T>

void CheckIdentical(const RPtrHashSet<T>& aA, const RPtrHashSet<T>& aB)

	{

	test(aA.Count()==aB.Count());

	TInt c = aA.Count();

	typename RPtrHashSet<T>::TIter iA(aA);

	FOREVER

		{

		const T* p = iA.Next();

		if (!p)

			break;

		--c;

		test(aB.Find(*p)!=0);

		}

	test(c==0);

	c = aA.Count();

	typename RPtrHashSet<T>::TIter iB(aB);

	FOREVER

		{

		const T* p = iB.Next();

		if (!p)

			break;

		--c;

		test(aA.Find(*p)!=0);

		}

	test(c==0);

	}

/******************************************************************************

 * Utility functions for RHashMap<K,V>

 ******************************************************************************/

template <class K, class V>

void UnionTransform(RHashMap<K,V>& aD, const RHashSet<K>& aS, V (*aTransform)(const K&) )

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RHashSet<K>::TIter iS(aS);

	FOREVER

		{

		const K* p = iS.Next();

		if (!p)

			break;

		--c2;

		TInt r = aD.Insert(*p, (*aTransform)(*p) );

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class K, class V>

void UnionMap(RHashSet<V>& aD, const RHashSet<K>& aS, const RHashMap<K,V>& aM)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RHashSet<K>::TIter iS(aS);

	FOREVER

		{

		const K* p = iS.Next();

		if (!p)

			break;

		--c2;

		const V* q = aM.Find(*p);

		if (!q)

			continue;

		TInt r = aD.Insert(*q);

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class K, class V>

void UnionKeys(RHashSet<K>& aD, const RHashMap<K,V>& aM)

	{

	typename RHashMap<K,V>::TIter iM(aM);

	FOREVER

		{

		const K* p = iM.NextKey();

		if (!p)

			break;

		aD.Insert(*p);

		}

	}

template <class K, class V>

void UnionValues(RHashSet<V>& aD, const RHashMap<K,V>& aM)

	{

	typename RHashMap<K,V>::TIter iM(aM);

	FOREVER

		{

		const K* p = iM.NextKey();

		if (!p)

			break;

		const V* q = iM.CurrentValue();

		aD.Insert(*q);

		}

	}

template <class K, class V>

void UnionTransform(RHashMap<K,V>& aD, const RHashMap<K,V>& aS, V (*aTransform)(const V&) )

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RHashMap<K,V>::TIter iS(aS);

	FOREVER

		{

		const K* p = iS.NextKey();

		if (!p)

			break;

		--c2;

		TInt r = aD.Insert(*p, (*aTransform)(*iS.CurrentValue()) );

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class K, class V>

void UnionInverse(RHashMap<V,K>& aD, const RHashMap<K,V>& aS)

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RHashMap<K,V>::TIter iS(aS);

	FOREVER

		{

		const K* p = iS.NextKey();

		if (!p)

			break;

		--c2;

		const V* q = iS.CurrentValue();

		TInt r = aD.Insert(*q, *p);

		test(r==KErrNone);

		++d1;

		}

	test(d1 == aD.Count());

	test(c2 == 0);

	}

template <class K, class V>

void SetMap(RHashMap<V,K>& aM, const V& aV)

	{

	typename RHashMap<K,V>::TIter iM(aM);

	FOREVER

		{

		const K* p = iM.NextKey();

		if (!p)

			break;

		V* q = iM.CurrentValue();

		*q = aV;

		test(*q == aV);

		}

	}

/******************************************************************************

 * Utility functions for RPtrHashMap<K,V>

 ******************************************************************************/

template <class K, class V>

void UnionTransform(RPtrHashMap<K,V>& aD, const RPtrHashMap<K,V>& aS, V* (*aTransform)(const V*) )

	{

	TInt c = aS.Count();

	TInt c2 = c;

	TInt d0 = aD.Count();

	TInt d1 = d0;

	typename RPtrHashMap<K,V>::TIter iS(aS);

	FOREVER

		{

		const K* p = iS.NextKey();

		if (!p)

			break;

		--c2;