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

// Overview:

// Test TLex and TLexMark classes.

// API Information:

// TLex, TLexMark.

// Details:

// - For Unicode, non Unicode and build independent variant of TLex class

// - Test that string-parsing methods are present.

// - Test the constructors with no parameter, by a string, with an empty TLex class, 

// non-empty TLex class is as expected.

// - Test assignment operator of TLex, by initializing with TLex reference, string, 

// TBuf reference and check it is as expected.

// - Check that Eos, Inc, Mark, Get, Peek, UnGet, SkipSpace, SkipSpaceAndMark, 

// - Initialize Lex string, assign different values, Parse to extract signed, 

// unsigned integer of different lengths, using specified radix and verify 

// that the return value is KErrNone when a valid string is parsed, KErrGeneral 

// when invalid string is parsed, KErrOverflow when converted value is greater 

// than the limit. 

// - Refresh the contents with the system's locale settings, separate whole number from 

// it's fractional part, change locale settings then parse a 64-bit floating point 

// number and check that results are as expected.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

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

struct TLexMark8Dump

	{

	const TUint8* iPtr;

	};

struct TLexMark16Dump

	{

	const TUint16* iPtr;

	};

void TLexMark8::__DbgTest(void *pTLexMark8Dump) const 

	{

	((TLexMark8Dump*)pTLexMark8Dump)->iPtr=iPtr;

	}

void TLexMark16::__DbgTest(void *pTLexMark16Dump) const 

	{

	((TLexMark16Dump*)pTLexMark16Dump)->iPtr=iPtr;

	}

struct TLex8Dump

	{

	const TUint8* iNext;

	const TUint8* iBuf;

	const TUint8* iEnd;

	TLexMark8Dump iMark;

	};

struct TLex16Dump

	{

	const TUint16* iNext;

	const TUint16* iBuf;

	const TUint16* iEnd;

	TLexMark16Dump iMark;

	};

void TLex8::__DbgTest(void* pTLex8Dump) const

	{

	((TLex8Dump*)pTLex8Dump)->iNext=iNext;

	((TLex8Dump*)pTLex8Dump)->iBuf=iBuf;

	((TLex8Dump*)pTLex8Dump)->iEnd=iEnd;

	iMark.__DbgTest(&((TLex8Dump*)pTLex8Dump)->iMark);

	}

void TLex16::__DbgTest(void* pTLex16Dump) const

	{

	((TLex16Dump*)pTLex16Dump)->iNext=iNext;

	((TLex16Dump*)pTLex16Dump)->iBuf=iBuf;

	((TLex16Dump*)pTLex16Dump)->iEnd=iEnd;

	iMark.__DbgTest(&((TLex16Dump*)pTLex16Dump)->iMark);

	}

LOCAL_C	void TestDes(const TUint16* start1, const TUint16* start2, const TUint16* end1, const TUint16* end2)

	{

	TPtrC16 des1(start1, end1-start1);

	TPtrC16 des2(start2, end2-start2);

	test(des1==des2);

	}

LOCAL_C	void TestDes(const TUint8* start1, const TUint8* start2, const TUint8* end1, const TUint8* end2)

	{

	TPtrC8 des1(start1, end1-start1);

	TPtrC8 des2(start2, end2-start2);

	test(des1==des2);

	}

LOCAL_C void TestDes(const TUint16* start, const TUint16* end, const TUint16* string)

	{

	TPtrC16 des1(start, end-start);

	TPtrC16 des2(string);

	test(des1==des2);

	}

LOCAL_C void TestDes(const TUint8* start, const TUint8* end, const TUint8* string)

	{

	TPtrC8 des1(start, end-start);

	TPtrC8 des2(string);

	test(des1==des2);

	}

void _LL(TText8 array[], TText8 string[])

	{

	TInt index=0;

	for(;string[index]; index++)

		array[index]=string[index];

	array[index]='\0';

	}		

void _LL(TText16 array[], TText8 string[])

	{

	TInt index=0;

	for(;string[index]; index++)

		array[index]=string[index];

	array[index]='\0';

	}

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

class TestTLex

	{

public:

	void Test1();

	void Test2();

	void Test3();

	void Test4();

	void Test5();

protected:

	void TestList(TLexType* object, TUint param, ...);

	};

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

// Test that methods are in the DLL

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

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

GLDEF_C void TestTLex<TDesType, TLexType, TLexMarkType, TBufType, DumpType, MarkDumpType, S>::Test1()

	{

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

	S String[100];

	_LL(&String[0], (TText8*)"hello");

	TBufType aTBufObject;

	TLexType a;								

	TLexType b(a);						   

	TLexType c(&String[0]);					

	TLexType d(aTBufObject);

    d.Offset(); // Avoids 'unused' warning

	TLexMarkType mark;

	test.Next(_L("Assignment operations"));

	a=b;							

	a=&String[0];					

	a=aTBufObject;					

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

	c.Eos();

	c.Mark(mark);

	c.Mark();

	c.Inc();

	c.Get();

	(S)c.Peek();

	c.UnGet();

	c.UnGetToMark(mark);

	c.UnGetToMark();

	c.SkipSpace();

	c.SkipSpaceAndMark(mark);

	c.SkipSpaceAndMark();

	c.SkipCharacters();

	c.TokenLength(mark);

	c.TokenLength();

	aTBufObject=c.MarkedToken(mark);

	aTBufObject=c.MarkedToken();

	aTBufObject=c.NextToken();

	aTBufObject=c.Remainder();

	aTBufObject=c.RemainderFromMark(mark);

	aTBufObject=c.RemainderFromMark();

	c.Offset();

	c.MarkedOffset(mark);

	c.MarkedOffset();

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

	TInt TI=1;

	c.Val(TI);

	TInt8 TI8='a';

	c.Val(TI8);

	TInt16 TI16=1;

	c.Val(TI16);

	TInt32 TI32=1;

	c.Val(TI32);

	TInt64 TI64=1;

	c.Val(TI64);

	TUint TU=1;

	c.Val(TU);

	TReal32 TR32=1.0F;

	c.Val(TR32);

	TReal64 TR64=1.0;

	c.Val(TR64);

	TUint8 TU8='a';

	TUint32 TU32=1;

	TRadix TR=(TRadix)EDecimal;

	TUint16 TU16=1;

	c.Val(TU8, TR);

	c.Val(TU16, TR);  	

	c.BoundedVal(TI32, TU);

	c.BoundedVal(TU32, TR, TU);

	c.BoundedVal(TI64, TR, TU);

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

	c.Assign(b);

	c.Assign(&String[0]);

	c.Assign(aTBufObject);	

	test.Next(_L("Test Dumps"));

	MarkDumpType mDump;

	mark.__DbgTest(&mDump);

	DumpType dump;

	c.__DbgTest(&dump);

	test.End();

	} 

///////////////////////////////////////

// Test calling Convert() with  a list

///////////////////////////////////////

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

GLDEF_C void TestTLex<TDesType, TLexType, TLexMarkType, TBufType, DumpType, MarkDumpType, S>::TestList(TLexType *object, TUint param, ...)

	{

	VA_LIST l;

	TBufType b;

	VA_START(l, param);

	object->Convert(b, l);

	}

/////////////////////////

// Test the constructors

////////////////////////

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

GLDEF_C void TestTLex<TDesType, TLexType, TLexMarkType, TBufType, DumpType, MarkDumpType, S>::Test2()

	{

	// Test constructors  NOTE: there's no getters for iMark or iBuf

	DumpType dump, dump2;

	S String[40];

	test.Start(_L("Constructors:"));	// TLexx::TLexx()

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

	TLexType a; 

	a.__DbgTest(&dump);

	test(dump.iBuf==NULL);

	test.Next(_L("By string"));		 	// TLexx::TLexx(const TUintx*)

	_LL(&String[0], (TText8*)"AB");

	TLexType b(&String[0]);

	b.__DbgTest(&dump);

	TestDes(dump.iNext, dump.iEnd, &String[0]);

	TestDes(dump.iBuf, dump.iEnd, &String[0]);

	TestDes(dump.iMark.iPtr, dump.iEnd, &String[0]);

	test.Next(_L("By TLex reference"));	// TLexx::TLexx(const TLexx&)

	// Test with an empty class

	TLexType c, d(c);

	c.__DbgTest(&dump);

	d.__DbgTest(&dump2);

	TestDes(dump.iNext, dump2.iNext, dump.iEnd, dump2.iEnd);

	test(dump.iBuf==NULL);

	test(dump.iBuf==dump2.iBuf); 

	TestDes(dump.iMark.iPtr, dump2.iMark.iPtr, dump.iEnd, dump2.iEnd);

	//Test with a non empty class

	_LL(&String[0], (TText8*)"XYZ");

	TLexType e(&String[0]), f(e);

	e.__DbgTest(&dump);

	f.__DbgTest(&dump2);

	TestDes(dump.iNext, dump.iEnd, &String[0]);

	TestDes(dump.iNext, dump2.iNext, dump.iEnd, dump2.iEnd);

	TestDes(dump.iBuf, dump2.iBuf, dump.iEnd, dump2.iEnd);

	TestDes(dump.iMark.iPtr, dump2.iMark.iPtr, dump.iEnd, dump2.iEnd);

	test.Next(_L("By TBuf reference"));	//TLexx::TLexx(const TBufBasex&)

	_LL(&String[0], (TText8*)"Hello");

	TBufType aBuf(&String[0]);

	TLexType g(aBuf);

	g.__DbgTest(&dump);

	TestDes(dump.iNext, dump.iEnd, &String[0]);

	TestDes(dump.iBuf, dump.iEnd, &String[0]);

	TestDes(dump.iMark.iPtr, dump.iEnd, &String[0]);

	test.End();

	}

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

// Test the = methods

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

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

GLDEF_C void TestTLex<TDesType, TLexType, TLexMarkType, TBufType, DumpType, MarkDumpType, S>::Test3()

	{

	DumpType dump, dump2;

	S String[40];

	test.Start(_L("= operators"));

	test.Next(_L("by TLex reference"));	//TLexx::operator=(const TLexx&)

	_LL(&String[0], (TText8*)"MNO");

	TLexType a(&String[0]), b;

	b=a;	

	a.__DbgTest(&dump);

	b.__DbgTest(&dump2);  

	TestDes(dump.iNext, dump2.iNext, dump.iEnd, dump2.iEnd); 

	TestDes(dump.iMark.iPtr, dump2.iMark.iPtr, dump.iEnd, dump2.iEnd);

	TestDes(dump.iBuf, dump2.iBuf, dump.iEnd, dump2.iEnd);

	test.Next(_L("by string"));			//TLexx::operator=(const TUintx*)

	TLexType c;

	_LL(&String[0], (TText8*)" abc");

	c=&String[0];

	c.__DbgTest(&dump);

	TestDes(dump.iNext, dump.iEnd, &String[0]);	

	TestDes(dump.iBuf, dump.iEnd, &String[0]);

	TestDes(dump.iMark.iPtr, dump.iEnd, &String[0]);

	test.Next(_L("by TBuf reference"));	//TLexx::operator=(const TBufx&);

	_LL(&String[0], (TText8*)"PQ R ");

	TLexType d;

	TBufType e(&String[0]);

	d=e;

	d.__DbgTest(&dump);

	TestDes(dump.iNext, dump.iEnd, &String[0]);	

	TestDes(dump.iBuf, dump.iEnd, &String[0]);

	TestDes(dump.iMark.iPtr, dump.iEnd, &String[0]);	

	test.End();	 		 

	}

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

// Test supporting methods

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

template<class TDesType, class TLexType, class TLexMarkType, class TBufType, class DumpType, class MarkDumpType, class S>

GLDEF_C void TestTLex<TDesType, TLexType, TLexMarkType, TBufType, DumpType, MarkDumpType, S>::Test4()

	{

	S String[40];

	DumpType dump1,dump2;

	MarkDumpType mDump;

	test.Start(_L("Supporting methods"));

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

	_LL(&String[0], (TText8*)"GGG");

	TLexType a, b(&String[0]);

	test(a.Eos()==TRUE);

	test(b.Eos()==FALSE);

	test.Next(_L("Inc()"));	   // Inc() increments iNext

	_LL(&String[0], (TText8*)"mno");

	TLexType c(&String[0]);

	c.__DbgTest(&dump1);

	TestDes(dump1.iNext, dump1.iEnd, &String[0]);

	c.Inc();

	test((S)c.Peek()==String[1]);

	c.Inc();

	test((S)c.Peek()==String[2]);

	test.Next(_L("Mark()"));		//	Mark() sets iMark=iNext

	_LL(&String[0], (TText8*)"pqr");

	TLexType d(&String[0]);

	d.Inc();

	d.__DbgTest(&dump1);

	d.Mark();

	d.__DbgTest(&dump2);

	TestDes(dump2.iMark.iPtr, dump1.iNext, dump2.iEnd, dump1.iEnd);

	test.Next(_L("Mark(mark)")); //	Mark(aMark) sets aMark=iNext

	_LL(&String[0], (TText8*)"pqr");

	TLexType d1(&String[0]);

	TLexMarkType dm;

	d1.Inc();

	d1.__DbgTest(&dump1);

	d1.Mark(dm);

	dm.__DbgTest(&mDump);

	TestDes(mDump.iPtr, dump1.iNext, dump1.iEnd, dump1.iEnd);

	test.Next(_L("Get()")); 	// Get() is {TChar c(*iNext);Inc(); return(c);}

	_LL(&String[0], (TText8*)"s");

	TLexType e(&String[0]);

	TChar temp=e.Get();

	test(temp=='s');

	e.Inc();

	temp=e.Get();

	test(temp==0);

	test.Next(_L("Peek()"));	// Peek() returns *iNext

	TLexType f;

	test(f.Peek()==0);

	_LL(&String[0], (TText8*)"ab");

	TLexType g(&String[0]);

	test((S)g.Peek()==String[0]);

	test.Next(_L("UnGet()"));	//  UnGet() is effectively if(iNext!=iBuf) iNext--;

	_LL(&String[0], (TText8*)"abc");

	TLexType h(&String[0]);

	h.Inc();

	test((S)h.Peek()==String[1]);

	h.UnGet();

	test((S)h.Peek()==String[0]);

	test.Next(_L("SkipSpace()"));	// SkipSpace() 	is while(Peek.IsSpace()) iNext++;

	_LL(&String[0], (TText8*)"  j  kl");

	TLexType i(&String[0]);

	i.SkipSpace();

	test((S)i.Peek()==String[2]);

	i.Inc();

	i.SkipSpace();

	test((S)i.Peek()==String[5]);

	test.Next(_L("SkipSpaceAndMark()"));	// while(Peek.IsSpace()) iNext++;	iMark=iNext;

	_LL(&String[0], (TText8*)"    aaa");

	TLexType j(&String[0]);

	j.SkipSpaceAndMark();

	j.__DbgTest(&dump1);

	_LL(&String[0], (TText8*)"aaa");

	TestDes(dump1.iNext, dump1.iEnd, &String[0]);

	TestDes(dump1.iMark.iPtr, dump1.iEnd, &String[0]);

	test.Next(_L("SkipSpaceAndMark(aMark)"));	// while(Peek.IsSpace()) iNext++;	iMark=iNext;

	_LL(&String[0], (TText8*)"    aaa");

	TLexType j1(&String[0]);

	TLexMarkType jm;

	j1.SkipSpaceAndMark(jm);

	j1.__DbgTest(&dump1);

	jm.__DbgTest(&mDump);

	_LL(&String[0], (TText8*)"aaa");

	TestDes(dump1.iNext, dump1.iEnd, &String[0]);

	TestDes(mDump.iPtr, dump1.iEnd, &String[0]);

	test.Next(_L("SkipCharacters()"));	// Skips non whitespace characters

	_LL(&String[0], (TText8*)"abc   ");

	TLexType k(&String[0]);

	k.SkipCharacters();

	test((S)k.Peek()==String[3]);

	test.Next(_L("TokenLength()"));		// returns iNext-iMark

	_LL(&String[0], (TText8*)"GGG");

	TLexType l(&String[0]);

	test(l.TokenLength()==0);

	l.Inc();

	test(l.TokenLength()==1); 

	test.Next(_L("MarkedToken()"));		// Extract a marked token

	_LL(&String[0], (TText8*)"ABCD");

	TLexType m(&String[0]);

	TBufType Buf;

	TLexMarkType mm;

	m.Inc();

	m.Mark();

	m.Inc();

	m.Mark(mm);

	m.Inc();

	Buf=m.MarkedToken();

	S String2[4];

	_LL(&String2[0], (TText8*)"BC");

	test(TDesType(&String2[0])==Buf); 

	_LL(&String2[0], (TText8*)"C");

	Buf=m.MarkedToken(mm);

	test(TDesType(&String2[0])==Buf); 

	test.End();

	}

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