--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/buffer/t_farray.cpp	Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,388 @@
+// 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_farray.cpp
+// Overview:
+// Test the functionality of CArrayFixFlat,  CArrayPtrFlat,  CArrayFixSeg classes.
+// API Information:
+// CArrayFixFlat, CArrayPtrFlat, CArrayFixSeg.
+// Details:
+// - Create an array of fixed length buffer descriptor objects contained within a flat
+// dynamic and segmented buffer and verify that
+// - number of elements held in the array is 0.
+// - length of an element is as specified.
+// - array is compressed and reset as expected.
+// - the elements of the array are sorted as expected.
+// - insertion of a text into the array at specified position and filling a blank space
+// at the beginning is as expected.
+// - return value is 0 when available element is searched within the array.
+// - removal of first element from the array is successful.
+// - number of elements held in the array is 1 after appending a single element onto 
+// the end of the array.
+// - the position of specified element is found successfully
+// - resetting the array is as expected
+// - End and Back methods are as expected.
+// - Create an array of fixed length text character objects contained within a flat dynamic 
+// and segmented buffer.
+// - append a text onto the end of the array, check the contents and number of elements 
+// held in the array are as expected.
+// - insert a text and verify that the change in the content of array and number of 
+// elements held in the array are as expected.
+// - remove a single character and multiple characters from the array and verify that
+// the Delete method is as expected. Compress the array.
+// - Create an array of fixed length text character objects contained within a flat dynamic
+// and segmented buffer.
+// - append strings of specified length onto the end of the array and verify that the 
+// number of elements held in the array is as expected.
+// - insert strings at specified location and check that the contents are as expected.
+// - reset the array, append a string, compress the array and verify that content is as 
+// expected.
+// - sort the array and verify that content is as expected.
+// - verify the correct position of the element and return value is zero when an element
+// is found using binary and sequential search technique and nonzero if not present in 
+// the array.
+// - Create an array of fixed length text character objects contained within a flat dynamic 
+// and segmented buffer.
+// - Insert some elements into the array at specified positions determined by key of 
+// type TInt and verify that KErrAlreadyExists is returned if an element with the 
+// same key already exists within the array.
+// - Create an array of pointers to objects implemented using a flat dynamic buffer, insert one 
+// element into the array at the specified position and destroy the object whose pointer form 
+// the element of the array, before resetting the array.
+// - Create and delete an array of CBase objects contained within a flat dynamic buffer.
+// - 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>
+
+class MyCBase : public CBase
+	{
+	};
+
+const TInt KTestGranularity=0x02;
+
+LOCAL_D RTest test(_L("T_FARRAY"));
+
+template <class T,TInt S>
+class TArr
+	{
+public:
+	TArr() {}
+	TInt Count() const {return S;}
+	T& operator[](TInt anIndex) {return iArr[anIndex];}
+	const T& operator[](TInt anIndex) const {return iArr[anIndex];}
+private:
+	T iArr[S];
+	};
+
+LOCAL_C void testFix(CArrayFix<TBuf<0x10> >& aFix)
+//
+// Test all methods
+//
+	{
+	test.Next(_L("Test all methods"));
+	test(aFix.Count()==0);
+	test(aFix.Length()==sizeof(TBuf<0x10>));
+	aFix.Compress();
+	test(TRUE);
+	aFix.Reset();
+	test(TRUE);
+	TKeyArrayFix kk(0,ECmpNormal,0x10);
+	test(TRUE);
+	aFix.Sort(kk);
+	test(TRUE);
+	TBuf<0x10> aa(_L("aaaaa"));
+	aFix.InsertL(0,aa);
+	test(TRUE);
+	aFix[0].Fill(' ');
+	test(TRUE);
+	TBuf<0x10> z(aFix[0]);
+    z.Length();
+	test(TRUE);
+	aFix[0].Fill('a');
+	test(TRUE);
+	TInt pp;
+	test(aFix.Find(aa,kk,pp)==0);
+	test(pp==0);
+	aFix.Delete(0);
+	TBuf<0x10> bb(_L("bbbbb"));
+	aFix.AppendL(bb);
+	test(aFix.Count()==1);
+	test(aFix.InsertIsqAllowDuplicatesL(aa,kk)==0);
+	test(aFix.InsertIsqAllowDuplicatesL(bb,kk)==2);
+	test(aFix.FindIsq(aa,kk,pp)==0);
+	test(pp==0);
+	aFix.Reset();
+	for(TInt index=0;index<KTestGranularity*7/2;index++)
+		aFix.AppendL(aa);
+	const TBuf<0x10> *end=NULL;
+	const TBuf<0x10> *ptr=NULL;
+	for(TInt index2=0;index2<KTestGranularity*7/2;index2++)
+		{
+		if (end==ptr)
+			{
+			end=aFix.End(index2);
+			ptr=&aFix[index2];
+			TInt seglen=end-ptr;
+			test(seglen==KTestGranularity || seglen==(aFix.Count()-index2));
+			}
+		test(&aFix[index2]==ptr++);
+		}
+	const TBuf<0x10> *bak=NULL;
+	ptr=NULL;
+	for(TInt index3=KTestGranularity*7/2;index3>0;index3--)
+		{
+		if (bak==ptr)
+			{
+			bak=aFix.Back(index3);
+			ptr=&aFix[index3-1]+1;
+			TInt seglen=ptr-bak;
+			test(seglen==KTestGranularity || seglen==index3 || seglen==index3%KTestGranularity);
+			}
+		test(&aFix[index3-1]==--ptr);
+		}
+	}
+
+LOCAL_C void test1(CArrayFix<TText>& aFix)
+//
+	{
+	test.Next(_L("AppendL and InsertL single chars"));
+	aFix.AppendL(_S("abcd"),4);
+	test(aFix[0]=='a');
+	test(aFix[1]=='b');
+	test(aFix[3]=='d');
+	test(aFix.Count()==4);
+	aFix.InsertL(2,_S("ef"),2);
+	test(aFix[1]=='b');
+	test(aFix[2]=='e');
+	test(aFix[4]=='c');
+	test(aFix.Count()==6);	
+	aFix.AppendL(TText('z'));
+	test(aFix[6]=='z');
+	aFix.InsertL(0,TText('y'));
+	test(aFix[0]=='y');
+	test(aFix[1]=='a');
+	test(aFix.Count()==8);
+	test.Next(_L("Delete single chars"));
+	aFix.Delete(3);
+	test(aFix[2]=='b');
+	test(aFix[3]=='f');
+	test(aFix[4]=='c');
+	aFix.Delete(1,2);
+	test(aFix[0]=='y');
+	test(aFix[1]=='f');
+	test(aFix[2]=='c');
+	test(aFix.Count()==5);
+	aFix.Compress();
+	}
+
+LOCAL_C void test2(CArrayFix<TArr<TText,4> >& aFix)
+//
+	{
+	test(aFix.Length()==sizeof(TArr<TText,4>));
+	test.Next(_L("AppendL and insert strings of length 4"));
+	TPtrC des1=_L("abcd");
+	TPtrC des2=_L("efgh");
+	aFix.AppendL(*(const TArr<TText,4>*)des1.Ptr());
+	aFix.AppendL(*(const TArr<TText,4>*)des2.Ptr());
+	test(aFix.Count()==2);
+	TPtrC des3(&aFix[0][0],4);
+	TPtrC des4(&aFix[1][0],4);
+	test(des3==_L("abcd"));
+	test(des4==_L("efgh"));
+	aFix.InsertL(1,*(const TArr<TText,4>*)_S("ijkl"));
+	test(aFix.Count()==3);	
+	TPtrC des5(&aFix[2][0],4);
+	test(des3==_L("abcd"));
+	test(des4==_L("ijkl"));
+	test(des5==_L("efgh"));
+
+	test.Next(_L("Reset and Compress"));
+	aFix.Reset();
+	TBuf<0x10> buf1=_L("abcdefgh");
+	aFix.AppendL((const TArr<TText,4>*)buf1.Ptr(),2);
+	aFix.Compress();
+	TPtrC des6(&aFix[0][0],4);
+	test(des6==_L("abcd"));
+	TPtrC des7(&aFix[1][0],4);
+	test(des7==_L("efgh"));
+	buf1=_L("ghighhxy");
+	aFix.InsertL(1,(const TArr<TText,4>*)buf1.Ptr(),2);
+	aFix.Compress();
+	TPtrC des8(&aFix[0][0],4);
+	test(des8==_L("abcd"));
+	TPtrC des9(&aFix[1][0],4);
+	test(des9==_L("ghig"));
+	TPtrC des10(&aFix[2][0],4);
+	test(des10==_L("hhxy"));
+	TPtrC des11(&aFix[3][0],4);
+	test(des11==_L("efgh"));
+
+	test.Next(_L("Sort strings"));
+	TKeyArrayFix kk(0,ECmpNormal,0x04);
+	aFix.Sort(kk);
+	TPtrC des12(&aFix[0][0],4);
+	test(des12==_L("abcd"));
+	TPtrC des13(&aFix[1][0],4);
+	test(des13==_L("efgh"));
+	TPtrC des14(&aFix[2][0],4);
+	test(des14==_L("ghig"));
+	TPtrC des15(&aFix[3][0],4);
+	test(des15==_L("hhxy"));
+	
+	test.Next(_L("Find and FindIsq"));
+	aFix.Compress();
+	test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk)==2);
+	aFix.Compress();
+	test(aFix.InsertIsqAllowDuplicatesL(*(const TArr<TText,4>*)_S("ffff"),kk)==3);
+	aFix.Compress();
+	TRAPD(r,aFix.InsertIsqL(*(const TArr<TText,4>*)_S("ffff"),kk))
+	test(r==KErrAlreadyExists);
+	TInt aPos=0;
+	test(aFix.Find(*(const TArr<TText,4>*)_S("xxxx"),kk,aPos)==1);
+	test(aPos==6);
+	test(aFix.Find(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0);
+	test(aPos==0);
+	test(aFix.Find(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0);
+	test(aPos==4);
+	test(aFix.Find(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0);
+	test(aPos==2);
+	test(aFix.Find(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0);
+	test(aPos==5);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("bbbb"),kk,aPos)!=0);
+	test(aPos==1);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("abcd"),kk,aPos)==0);
+	test(aPos==0);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ghig"),kk,aPos)==0);
+	test(aPos==4);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("ffff"),kk,aPos)==0);
+	test(aPos==2);
+	test(aFix.InsertIsqL(*(const TArr<TText,4>*)_S("fghz"),kk)==4);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("fghz"),kk,aPos)==0);
+	test(aPos==4);
+	test(aFix.FindIsq(*(const TArr<TText,4>*)_S("hhxy"),kk,aPos)==0);
+	test(aPos==6);
+	}
+
+LOCAL_C void test3(CArrayFix<TInt>& aFix)
+	{
+
+	test.Next(_L("InsertIsqL"));
+	TKeyArrayFix kk(0,ECmpTInt);
+
+	TInt pos=0;
+	TInt mod=47;
+	TInt inc=23;
+	TInt i=0;
+
+	FOREVER
+		{
+		TInt ret;
+		if (i&1)
+			TRAP(ret,aFix.InsertIsqL(i,kk))
+		else
+			{
+			TRAP(ret,pos=aFix.InsertIsqL(i,kk))
+			if (ret==KErrNone)
+				test(aFix[pos]==i);
+			}
+		if (ret==KErrAlreadyExists)
+			break;
+		i=(i+inc)%mod;
+		}
+
+	for(i=0;i<mod;i++)
+		{
+		test(aFix.FindIsq(i,kk,pos)==0);
+		test(pos==i);
+		TRAPD(r,aFix.InsertIsqL(i,kk))
+		test(r==KErrAlreadyExists);
+		}
+	}
+	
+GLDEF_C TInt E32Main()
+//
+// Test the Array classes.
+//
+    {
+
+	test.Title();
+	__UHEAP_MARK;
+	test.Start(_L("class CArrayFixFlat"));
+	CArrayFixFlat<TBuf<0x10> >* pFixFlat=new CArrayFixFlat<TBuf<0x10> >(KTestGranularity);
+	if (pFixFlat==NULL)
+		test.Panic(_L("Allocating array"));
+	testFix(*pFixFlat);
+	delete pFixFlat;
+
+	CArrayFixFlat<TText>* pFixFlatChar=new CArrayFixFlat<TText>(KTestGranularity);
+	test1(*pFixFlatChar);
+	delete pFixFlatChar; 
+		
+	CArrayFixFlat<TArr<TText,4> >* pFixFlatArr=new CArrayFixFlat<TArr<TText,4> >(KTestGranularity);
+	test2(*pFixFlatArr);
+	delete pFixFlatArr;
+
+	CArrayFixFlat<TInt>* pFixFlatInt=new CArrayFixFlat<TInt>(KTestGranularity);
+	test3(*pFixFlatInt);
+	delete pFixFlatInt;
+
+	test.Next(_L("class CArrayPtrFlat of CBase"));
+	
+	CArrayPtrFlat<MyCBase>* pPtrFlatCBase=new CArrayPtrFlat<MyCBase>(KTestGranularity); 
+	if (pPtrFlatCBase==NULL)
+		test.Panic(_L("Allocating array of CBase*"));
+	MyCBase* c1 = new MyCBase();
+	pPtrFlatCBase->InsertL(0,&c1,1);
+	pPtrFlatCBase->ResetAndDestroy();
+//	test(pFixFlatCBase->iBase==0);
+	pPtrFlatCBase->ResetAndDestroy();
+	delete pPtrFlatCBase;
+
+	test.Next(_L("class CArrayFixFlat of CBase"));
+	
+	CArrayFixFlat<MyCBase>* pFixFlatCBase=new CArrayFixFlat<MyCBase>(KTestGranularity); 
+	if (pFixFlatCBase==NULL)
+		test.Panic(_L("Allocating array of CBase"));
+	delete pFixFlatCBase;
+
+	test.Next(_L("class CArrayFixSeg"));
+	CArrayFixSeg<TBuf<0x10> >* pFixSeg=new CArrayFixSeg<TBuf<0x10> >(KTestGranularity);
+	if (pFixSeg==NULL)
+		test.Panic(_L("Allocating array"));
+	testFix(*pFixSeg);
+	delete pFixSeg;
+
+	CArrayFixSeg<TText>* pFixSegChar=new CArrayFixSeg<TText>(KTestGranularity);
+	test1(*pFixSegChar);
+	delete pFixSegChar; 
+		
+	CArrayFixSeg<TArr<TText,4> >* pFixSegArr=new CArrayFixSeg<TArr<TText,4> >(KTestGranularity);
+	test2(*pFixSegArr);
+	delete pFixSegArr;
+
+	CArrayFixSeg<TInt>* pFixSegInt=new CArrayFixSeg<TInt>(KTestGranularity);
+	test3(*pFixSegInt);
+	delete pFixSegInt;
+
+	test.End();
+	__UHEAP_MARKEND;
+	return(0);
+    }
+