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

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

// Overview:

// Test methods of the LString16, LString8, LString template class.

// API Information:

// LString16, LString8, LString 

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

#include <estring.h>

#ifdef __VC32__

    // Solve compilation problem caused by non-English locale

    #pragma setlocale("english")

#endif

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

#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 TestLString

	{

public:

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

	void Test1L();   // Tests all functions of the class with auto extension

	void Test2();   // Tests all constructors.

	void Test3();	// Tests all assignment operators

	void Test4();	// Tests all comparison operators

	void Test7();	// Tests all conversion 

	void Test8();	// Tests all comparison

	void Test9();	// Tests all matching

	void Test10();	// Tests all locating

	void Test11L();	// Tests all Copying

	void Test12();	// Tests all finding

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

	void Test14L();  // Tests all formating with auto extension 

	void Test15L();  // Tests all replacing with auto extension 

	void test_TBufL(); // Test all classes

protected:

	void Test14_ReorderedParameterFormatting(TInt aDummyParameter, ...);

	void Test14_ReorderedParameterFormattingL(TInt aDummyParameter, ...);

private:

	TInt iMaxBufLength;

	};

template<class T>

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

	{

	if (a!=b)

		{

		LString16 buf(256);

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

		buf.CopyL(a);

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

		buf.CopyL(b);

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

		test(0);

		}

	}

#define TESTEQ(a,b)	TestEq<T>((a),(b),__LINE__)

template <class T,class S,class DESTEMPLATE>

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

// Constructor.

	: iMaxBufLength(aLength)

	{}

/**

@SYMTestCaseID SYSLIB-EUSERHL-UT-4011

@SYMTestCaseDesc Tests LString Auto-extending functions 

@SYMTestPriority High

@SYMTestActions Creates LString objects and uses the auto-extending LString 

				functions to manipulate the strings.

				Verifies that the LStrings are auto-extended as expected.

@SYMTestExpectedResults The LString objects should be auto-extended as required to

				contain any new data.

@SYMREQ	10372-3

*/

template <class T,class S,class DESTEMPLATE>

GLDEF_C void TestLString<T,S,DESTEMPLATE>::Test1L()

	{

	test.Start(_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4011"));

	test.Next(_L("Extending Methods"));

	T a(1);

	T b(1);

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

	test(a.MaxLength() >=1);

	test.Next(_L("Setting a bigger length "));

	a.SetLengthL(10);

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

	test(a.MaxLength() >= 10);

	test.Next(_L("operator+ with memory extension "));

	test(b.MaxLength() >=1);

	b += a;

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

	test(b.MaxLength() >= 10);

	TChar c('A');

	test(b.MaxLength() >=1);

	b += c;

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

	test(b.MaxLength() >= 10);

	test.Next(_L("Filling past current size "));

	a.FillL(' ', 20);

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

	test(a.MaxLength() >= 20);

	test.Next(_L("Append filling past current size "));

	a.AppendFillL(' ', 10);

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

	test(a.MaxLength() >= 30);

	test.Next(_L("Zeroing past current size "));

	a.FillZL(40);

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

	test(a.MaxLength() >= 40);

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

	a.CopyL(b);

	test(a == b);

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

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

	a.CopyFL(b);

	T d(b);

	d.Fold();

	test(a == d);

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

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

	a.CopyCL(b);

	d = b;

	d.Collate();

	test(a == d);

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

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

	a.CopyLCL(b);

	d = b;

	d.LowerCase();

	test(a == d);

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

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

	a.CopyUCL(b);

	d = b;

	d.UpperCase();

	test(a == d);

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

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

	a.CopyCPL(b);

	d = b;

	d.Capitalize();

	test(a == d);	

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

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

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

	a.Zero();

	b=_TL("AA");

	a.InsertL(0,b);

	test(a == b);

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

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

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

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

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

	b.FillL('A',2);

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

	a.Zero();

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

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

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

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

	DESTEMPLATE des(b);

	a.Zero();

	a.AppendJustifyL(des,2,10,ELeft,' ');

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

	a.AppendJustifyL(des,2,KDefaultJustifyWidth ,ELeft,' ');

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

	a.Zero();

	a.AppendJustifyL(des,10,ELeft,' ');

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

	a.AppendJustifyL(des,KDefaultJustifyWidth ,ELeft,' ');

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

	a.Zero();

	a.AppendJustifyL(b.PtrZL(),10,ELeft,' ');

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

	a.AppendJustifyL(b.PtrZL(),KDefaultJustifyWidth,ELeft,' ');

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

	a.AppendJustifyL(b.PtrZL(),2,KDefaultJustifyWidth,ELeft,' ');

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

	a.Zero();

	a.AppendJustifyL(b.PtrZL(),2,10,ELeft,' ');

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

	a.AppendJustifyL(b.PtrZL(),2,5,ELeft,' ');

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

	TInt v1=10;

	a.NumL(v1);

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

	a.AppendNumL(v1);

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

	TInt v2=10;

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

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

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

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

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

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

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

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

	a.NumFixedWidthL((TUint)v2,EHex,1);

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

	a.AppendNumFixedWidthL((TUint)v2,EHex,1);

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

	a.NumFixedWidthUCL((TUint)v2,EHex,1);

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

	a.AppendNumFixedWidthUCL((TUint)v2,EHex,1);

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

	TReal v3=10.0;

	TRealFormat ff;

	ff.iType=KRealFormatFixed;

	ff.iWidth=10;

	ff.iPlaces=2;

	ff.iPoint='.';

	ff.iTriad=',';

	ff.iTriLen=3;

	a.NumL(v3,ff);

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

	a.AppendNumL(v3,ff);

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

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

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

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

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

	b=_TL("%d");

	a.FormatL(b,12);

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

	a.AppendFormatL(b,12);

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

	//*/

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

	a=_TL("AAC");

	b=_TL("B");

	a.ReplaceL(1,1,b);

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

	test.End();

	}

/**

@SYMTestCaseID SYSLIB-EUSERHL-UT-4012

@SYMTestCaseDesc Tests all LString Constructors

@SYMTestPriority High

@SYMTestActions Creates LString objects using the different constructors.

				Verifies that length and contents are as expected

@SYMTestExpectedResults LString objects should be created with the correct 

				Length and contents

@SYMREQ	10372

*/

template <class T,class S,class DESTEMPLATE>

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

// Tests all constructors.

	{

	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4012"));

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

	T a(iMaxBufLength);

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

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

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

	T c(iMaxBufLength);

	c = _TL("AB");

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

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

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

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

	T d(iMaxBufLength);

	d = c;

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

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

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

	test.End();

	}

/**

@SYMTestCaseID SYSLIB-EUSERHL-UT-4013

@SYMTestCaseDesc Tests all LString Assignment operators

@SYMTestPriority High

@SYMTestActions Creates LString objects and uses the different assignment 

				operators to change the string contents

				Verifies that length and contents are as expected

@SYMTestExpectedResults LString data should be assigned as expected

@SYMREQ	10372

*/

template <class T,class S,class DESTEMPLATE>

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

// Tests all assignment operators

	{

	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4013"));

	test.Next(_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();

	}

/**

@SYMTestCaseID SYSLIB-EUSERHL-UT-4014

@SYMTestCaseDesc Tests all LString comparison operators

@SYMTestPriority High

@SYMTestActions Creates LString objects and uses the different comparison 

				operators to compare string contents against other strings 

				Verifies that comparison operators work as expected

@SYMTestExpectedResults LString data comparison should work as expected

@SYMREQ	10372

*/

template <class T,class S,class DESTEMPLATE>

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

// Test all comparison operators

	{

	test.Start (_L ("@SYMTestCaseID:SYSLIB-EUSERHL-UT-4014"));

	test.Next(_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();	

	}

/**

@SYMTestCaseID SYSLIB-EUSERHL-UT-4015