// 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_buf.cpp

// Overview:

// Test methods of the TBuf16, TBuf8, TBuf template class.

// API Information:

// TBuf16, TBuf8, TBuf.

// Details :

// - Create some 16 bit modifiable descriptors, 8 bit modifiable descriptors

// of fixed length, Build-independent modifiable descriptors, initialize 

// with different strings and check for

// - Comparison operators,

// - Property access methods,

// - Fill & swap methods,

// - Conversion methods,

// - Comparison methods,

// - Pattern Matching methods,

// - Pattern Locating methods,

// - Copying methods, 

// - Find, FindC, FindF methods,

// - Repeat, Trim, TrimLeft, TrimRight, Insert, Delete, Left,

// Right, Mid methods,

// - Formatting methods,

// - Replace methods are as expected.

// - Construct some descriptors with buffer length, string and buffer reference and

// verify that they are created successfully.

// - Test assignment operators and comparison operators for different descriptors.

// - Initialize some descriptors and check descriptors' maximum length, length and 

// size are as expected. 

// - Check Fill and Swap methods are as expected.

// - Test Fold, Collate, LowerCase, UpperCase methods are as expected.

// - Test Comparison methods are as expected.

// - Test pattern matching for simple string, wild cards with collated comparison. Verify that the 

// return value is KErrNotFound when pattern doesn't match.

// - Check Locating methods by searching character in forward and backward direction and 

// verify the return value is KErrNotFound when unavailable character is searched.

// - Check copying strings and converting those into lower and upper case strings are

// as expected.

// - Check Find methods by searching string and verify the return value is KErrNotFound when 

// unavailable string is searched.

// - Check Repeat, Trim, Insert and Delete methods are as expected.

// - Check the formatting operations are as expected.

// - Check integer to decimal character representation is as expected.

// - Check integer to character representation with different number system is as expected.

// - Check string formatting with variable parameter list is as expected

// - Check Replace method by replacing string at different places in a string is as expected.

// - Check the conversion of real numbers, extended precision real numbers into string

// format is as expected.

// - Check Format and FormatList methods are as expected.

// - Check Format of TReal is as expected.

// - Check the non-leaving and leaving descriptors overflow handlers are as expected. 

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32math.h>

#include <hal.h>

#include <hal_data.h>

#include <hal_data.h>

#include <e32svr.h>

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

LOCAL_D RTest test(_L("T_BUF"));

#pragma warning(disable: 4127) // disabling warning "conditional expression is constant"

#pragma warning(disable: 4310) // disabling warning "cast truncates constant value"

#undef _TL

#define _TL(a) DESTEMPLATE((S*)RTest::String(sizeof(S),(TText8*)a,(TText16*)L ## a)) 

#undef _TS

#define _TS(a) ((const S*)RTest::String(sizeof(S),(TText8*)a,(TText16*)L ## a)) 

template<class T,class S,class DESTEMPLATE>	

class TestTBuf

	{

public:

	TestTBuf(TInt aLength); // Test class constructor.

	void Test1();   // Tests all functions of the class.

	void Test2();   // Tests all constructors.

	void Test3();	// Tests all assignment operators

	void Test4();	// Tests all comparison operators

	void Test5();	// Tests all property access

	void Test6();	// Tests all fill and swap

	void Test7();	// Tests all conversion 

	void Test8();	// Tests all comparison

	void Test9();	// Tests all matching

	void Test10();	// Tests all locating

	void Test11();	// Tests all Copying

	void Test12();	// Tests all finding

	void Test13();	// Tests all basic like ops

	void Test14();  // Tests all formating

	void Test15();  // Tests all replacing

	void test_TBuf(); // Test all classes

protected:

	void Test1List(T* a,T* b,...);

	void Test14_ReorderedParameterFormatting(TInt aDummyParameter, ...);

private:

	TInt iMaxBufLength;

	};

void TestEq(const TDesC8& a, const TDesC8& b, TInt aLine)

	{

	if (a!=b)

		{

		TBuf<256> buf;

		test.Printf(_L("LINE %d:\n"),aLine);

		buf.Copy(a);

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

		buf.Copy(b);

		test.Printf(_L("b=%S\n"),&buf);

		test(0);

		}

	}

void TestEq(const TDesC16& a, const TDesC16& b, TInt aLine)

	{

	if (a!=b)

		{

		test.Printf(_L("LINE %d:\n"),aLine);

		test.Printf(_L("a=%S\n"),&a);

		test.Printf(_L("b=%S\n"),&b);

		test(0);

		}

	}

#define TESTEQ(a,b)	TestEq((a),(b),__LINE__)

template <class T,class S,class DESTEMPLATE>

GLDEF_C TestTBuf<T,S,DESTEMPLATE>::TestTBuf(TInt aLength)

// Constructor.

	: iMaxBufLength(aLength)

	{}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test1List(T* a,T* b,...)

// Test the format with list functions.

	{

	VA_LIST list;

	VA_START(list,b);

	a->Format(*b,list);

	VA_START(list,b);

	a->AppendFormat(*b,list);

	VA_START(list,b);

	a->Format(_TL("%d"),list);

	VA_START(list,b);

	a->AppendFormat(_TL("%d"),list);

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test1()

// Tests all functions of the class.

	{

	test.Start(_L("Constructors"));

	T a;

	T b;

	T c(_TL("AB"));

	T d(c);

// To avoid unused warning

    a.Length();

    b.Length();

    c.Length();

    d.Length();

	test.Next(_L("Copy operators"));

	a=_TL("DE");

	b=c;

	a+=_TL("DE");

	b+=c;

	test.Next(_L("Comparison operators"));

	TInt t=(a<b);

	t=(a<_TL("AB"));

	t=(_TL("AB")<a);

	t=(a<=b);

	t=(a<=_TL("AB"));

	t=(_TL("AB")<=a);

	t=(a>b);

	t=(a>_TL("AB"));

	t=(_TL("AB")>a);

	t=(a>=b);

	t=(a>=_TL("AB"));

	t=(_TL("AB")>=a);

	t=(a==b);

	t=(a==_TL("AB"));

	t=(_TL("AB")==a);

	t=(a!=_TL("AB"));

	t=(_TL("AB")!=a);

	test.Next(_L("Property access"));

	a[0]='A';

	a.Ptr();

	TInt i=a.MaxLength()-a.Length();

	i=a.Size();

	a.Zero();

	a.SetLength(2); 

	test.Next(_L("Fill & swap"));

	a.Fill(' ');

	a.Fill(' ',iMaxBufLength);

	a.FillZ();

	a.FillZ(iMaxBufLength);

	a.Swap(b);

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

	a.Fold();

	a.Collate();

	a.LowerCase();

	a.UpperCase();

	a.Capitalize();

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

	a.Compare(b);

	a.Compare(_TL("AB"));

	a.CompareF(b);

	a.CompareF(_TL("AB"));

	a.CompareC(b);

	a.CompareC(_TL("AB"));

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

	a.Match(b);

	a.Match(_TL("AB"));

	a.MatchF(b);

	a.MatchF(_TL("AB"));

	T buf(_TL("abcdef"));

	TInt res = buf.MatchF(_TL("abc*def"));

	test(res == 0);

	a.MatchC(b);

	a.MatchC(_TL("AB"));

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

	a.Locate('A');

	a.LocateF('A');

	a.LocateReverse('A');

	a.LocateReverseF('A');

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

	a.Copy(b);

	a.Copy(_TL("AB"));

//	a.Copy(_TL("AB"),1);

	a.CopyF(b);

	a.CopyF(_TL("AB"));

	a.CopyC(b);

	a.CopyC(_TL("AB"));

	a.CopyLC(b);

	a.CopyLC(_TL("AB"));

	a.CopyUC(b);

	a.CopyUC(_TL("AB"));

	a.CopyCP(b);

	a.CopyCP(_TL("AB"));

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

	a.Find(b);

	a.Find(_TL("AB"));

	a.FindF(b);

	a.FindF(_TL("AB"));

	a.FindC(b);

	a.FindC(_TL("AB"));

	test.Next(_L("Basic like ops"));

	a.Repeat(b);

	a.Repeat(_TL("AB"));

	a.TrimLeft();

	a.TrimRight();

	a.Trim();

	b=_TL("AA");

	a.Insert(0,b);

	a.Delete(0,2);

	b = a.Left(1);

	b = a.Right(1);

	b = a.Mid(0,1);

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

	a.Justify(_TL("AB"),10,ELeft,' ');

	a.Justify(b,10,ELeft,' ');

	b.Fill('A',2);

	a.Zero();

	a.AppendJustify(_TL("AB"),10,ELeft,' ');

	a.AppendJustify(b,10,ELeft,' ');

	TInt v1=10;

	a.Num(v1);

	a.AppendNum(v1);

	TInt v2=10;

	a.Num((TUint)v2,EHex);

	a.AppendNum((TUint)v2,EHex);

	a.NumUC((TUint)v2,EHex);

	a.AppendNumUC((TUint)v2,EHex);

	TReal v3=10.0;

	TRealFormat ff;

	ff.iType=KRealFormatFixed;

	ff.iWidth=10;

	ff.iPlaces=2;

	ff.iPoint='.';

	ff.iTriad=',';

	ff.iTriLen=3;

	a.Num(v3,ff);

	a.AppendNum(v3,ff);

	a.Format(_TL("%d"),12);

	a.AppendFormat(_TL("%d"),12);

	b=_TL("%d");

	a.Format(b,12);

	a.AppendFormat(b,12);

	Test1List(&a,&b,12);

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

	a=_TL("AAC");

	b=_TL("B");

	a.Replace(1,1,b);

	test.End();

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test2()

// Tests all constructors.

	{

	test.Start(_L("Default"));

	T a;

	test(a.MaxLength()==iMaxBufLength);

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

	test.Next(_L("By length"));

	T b(iMaxBufLength>>1);

	test(b.MaxLength()==iMaxBufLength);

	test(b.Length()==(iMaxBufLength>>1));

	test.Next(_L("By string"));

	T c(_TL("AB"));

	test(c.MaxLength()==iMaxBufLength);

	test(c.Length()==2);

	test(c[0]=='A');

	test(c[1]=='B');

	test.Next(_L("By buffer reference"));

	T d(c);

	test(d.MaxLength()==iMaxBufLength);

	test(d.Length()==2);

	test(d[0]=='A');

	test(d[1]=='B');

	test.End();

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test3()

// Tests all assignment operators

	{

	test.Start(_L("By String"));

	T a;

	a=_TL("AB");

	a+=_TL("CD");

	test(a.Length()==4);

	test(a==_TL("ABCD"));

	test.Next(_L("By buffer"));

	T b;

	b=a;

	b+=a;

	test(b.Length()==8);

	test(b==_TL("ABCDABCD"));

//	

	test.End();

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test4()

// Test all comparison operators

	{

	test.Start(_L("By NULL string"));

	T a;

	test(a==_TL(""));		// NULL strings

	test(!(a!=_TL("")));

	test(a<=_TL(""));

	test(a>=_TL(""));

	test(!(a<_TL("")));

	test(!(a>_TL("")));

	test(_TL("")==a);

	test(!(_TL("")!=a));

	test(_TL("")<=a);

	test(_TL("")>=a);

	test(!(_TL("")<a));

	test(!(_TL("")>a));

	test.Next(_L("By string or buffer"));

	a=_TL("abc");

	test(a==_TL("abc"));		// ==

	test(!(a==_TL("xyz")));

	test(!(a==_TL("aa")));

	test(_TL("abc")==a);

	test(!(_TL("xyz")==a));

	test(!(_TL("aa")==a));

	test(a!=_TL("xyz"));		// !=

	test(!(a!=_TL("abc")));

	test(a!=_TL("aa"));

	test(_TL("xyz")!=a);

	test(!(_TL("abc")!=a));

	test(_TL("aa")!=a);

	test(a<_TL("x"));			// <

	test(!(a<_TL("abc")));

	test(!(a<_TL("aa")));

	test(_TL("aa")<a);

	test(!(_TL("abc")<a));

	test(!(_TL("xyz")<a));

	test(a>_TL("aa"));			// >

	test(!(a>_TL("abc")));

	test(!(a>_TL("xyz")));

	test(_TL("xyz")>a);

	test(!(_TL("abc")>a));

	test(!(_TL("aa")>a));

	test(a>=_TL("abc"));		// >=

	test(!(a>=_TL("xyz")));

	test(a>=_TL("aa"));

	test(_TL("abc")>=a);

	test(!(_TL("aaa")>=a));

	test(_TL("xyz")>=a);

	test(a<=_TL("abc"));		// <=

	test(!(a<=_TL("aa")));

	test(a<=_TL("xyz"));

	test(_TL("abc")<=a);

	test(!(_TL("xyz")<=a));

	test(_TL("aa")<=a);

	test.Next(_L("By special characters"));

	a=_TL("!@#$%^&*()");

	test(a==_TL("!@#$%^&*()"));

	test.End();	

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test5()

// Test all property access

	{

	test.Start(_L("Length and Size"));

	T a;

	TInt maxLength=a.MaxLength();

    TInt i;

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

		{

		test(a.Length()==i);	// Length

		test(a.Size()==(TInt)(sizeof(S)*i)); // Size

		a.AppendNum(i%10);

		}

	const T b=a;

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

		{

		test(a[i]=='0'+(i%10));	// At

		test(b[i]=='0'+(i%10));	// AtConst

		}

	test(a[0]==*a.Ptr());	//Ptr

	a.SetLength(0);	// SetLength

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

	a.SetLength(maxLength-1);

	test(a.Length()==maxLength-1);

	a.Zero();	// Null

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

	test.End();

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test6()

// Fill and Swap

	{

	test.Start(_L("Fill and Swap"));

	T a,b;

	TChar chr;

	TInt j;

	TInt maxLength=a.MaxLength();

	for (TInt i=0;i<maxLength;i++)

		{

		chr=(i%10)+'0';

		a.SetLength(i);

		a.Fill(chr);	// Fill(TChar)

		b.Swap(a);

		test(b.Length()==i);	// Swap

		j=0;

		while (j<i)

			test(b[j++]=='0'+(i%10));

		b.FillZ();	// FillZ()

		a.Swap(b);

		j=0;

		while (j<i)

			test(a[j++]==0);

		a.Fill(chr,i);	// Fill(TChar,TUint)

		j=0;

		while (j<i)

			test(a[j++]=='0'+(i%10));

		a.FillZ(i);	// FillZ(TUint)

		j=0;

		while (j<i)

			test(a[j++]==0);

		}

	test.End();

	}

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestTBuf<T,S,DESTEMPLATE>::Test7()

// Conversion operators

	{

	test.Start(_L("Fold, collate ..."));

	T a;

	T b;

	a=_TL("abc AbC");

	b=_TL("ABC ABC");

	a.Fold();

	b.Fold();

	test(a==b);

	a=_TL("abc AbC");

	b=_TL("ABC ABC");