Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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_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,
// SkipCharacters, TokenLength, MarkedToken methods are as expected.
// - 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();
}
//*********************************
// Test Val()
//*********************************
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>::Test5()
{
S String[66];
TInt ret;
TLexType Lex;
test.Start(_L("Val()"));
//////////////////
// Test Val(TInt8)
/////////////////
test.Next(_L("Val(TInt8)"));
TInt8 T8;
_LL(&String[0], (TText8*)"");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrGeneral);
_LL(&String[0], (TText8*)"abc");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrGeneral);
_LL(&String[0], (TText8*)"-abc-");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrGeneral);
_LL(&String[0], (TText8*)"+abc+");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrGeneral);
_LL(&String[0], (TText8*)"0000000123abc");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==123);
_LL(&String[0], (TText8*)"000");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==0);
_LL(&String[0], (TText8*)"+0");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==0);
_LL(&String[0], (TText8*)"-0");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==0);
_LL(&String[0], (TText8*)"+1 ");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==1);
_LL(&String[0], (TText8*)"-1 ");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==-1);
_LL(&String[0], (TText8*)"127");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==127);
_LL(&String[0], (TText8*)"128");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrOverflow);
_LL(&String[0], (TText8*)"-128");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrNone);
test(T8==-128);
_LL(&String[0], (TText8*)"-129");
Lex=&String[0];
test((ret=Lex.Val(T8))==KErrOverflow);
///////////////////
// Test Val(TInt16)
///////////////////
test.Next(_L("Val(TInt16)"));
TInt16 T16;
_LL(&String[0], (TText8*)"");
Lex=&String[0];
test((ret=Lex.Val(T16))==KErrGeneral);
_LL(&String[0], (TText8*)"32767");
Lex=&String[0];
test((ret=Lex.Val(T16))==KErrNone);
test(T16==32767);
_LL(&String[0], (TText8*)"32768");
Lex=&String[0];
test((ret=Lex.Val(T16))==KErrOverflow);
_LL(&String[0], (TText8*)"-32768");
Lex=&String[0];
test((ret=Lex.Val(T16))==KErrNone);
test(T16==-32768);
_LL(&String[0], (TText8*)"-32769");
Lex=&String[0];
test((ret=Lex.Val(T16))==KErrOverflow);
///////////////////
// Test Val(TInt32)
///////////////////
test.Next(_L("Val(TInt32)"));
TInt32 T32;
_LL(&String[0], (TText8*)"");
Lex=&String[0];
test((ret=Lex.Val(T32))==KErrGeneral);
_LL(&String[0], (TText8*)"2147483647");
Lex=&String[0];
test((ret=Lex.Val(T32))==KErrNone);
test(T32==2147483647L);
_LL(&String[0], (TText8*)"2147483648");
Lex=&String[0];
test((ret=Lex.Val(T32))==KErrOverflow);
_LL(&String[0], (TText8*)"-2147483648");
Lex=&String[0];
test((ret=Lex.Val(T32))==KErrNone);
test(T32==-2147483647-1); // the -1 prevents a (bug?) warning
_LL(&String[0], (TText8*)"-2147483649");
Lex=&String[0];
test((ret=Lex.Val(T32))==KErrOverflow);
/////////////////
// Test Val(TInt)
/////////////////
test.Next(_L("Val(TInt)"));
TInt T;
_LL(&String[0], (TText8*)"");
Lex=&String[0];
test((ret=Lex.Val(T))==KErrGeneral);
_LL(&String[0], (TText8*)"2147483647");
Lex=&String[0];
test((ret=Lex.Val(T))==KErrNone);
test(T==2147483647L);
_LL(&String[0], (TText8*)"2147483648");
Lex=&String[0];
test((ret=Lex.Val(T))==KErrOverflow);
_LL(&String[0], (TText8*)"-2147483648");
Lex=&String[0];
test((ret=Lex.Val(T))==KErrNone);
test(T==-2147483647-1); // the -1 prevents a (bug?) warning
_LL(&String[0], (TText8*)"-2147483649");
Lex=&String[0];
test((ret=Lex.Val(T))==KErrOverflow);
/////////////////
// Test Val(TInt64)
/////////////////
test.Next(_L("Val(TInt64)"));
TInt64 T64;
_LL(&String[0], (TText8*)"");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrGeneral);
_LL(&String[0], (TText8*)"2147483647");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrNone);
test(T64==TInt(2147483647L));
_LL(&String[0], (TText8*)"2147483648");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrNone);
test(T64==MAKE_TINT64(0,0x80000000u));
_LL(&String[0], (TText8*)"-2147483648");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrNone);
test(T64==-2147483647-1); // the -1 prevents a (bug?) warning
_LL(&String[0], (TText8*)"-2147483649");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrNone);
test(T64==MAKE_TINT64(0xffffffffu,0x7fffffffu));
_LL(&String[0], (TText8*)"9223372036854775807");
Lex=&String[0];
ret=Lex.Val(T64);
test.Printf(_L("ret=%d\n"),ret);
test(ret==KErrNone);
test.Printf(_L("%lx\n"),T64);
test(T64==MAKE_TINT64(0x7fffffffu,0xffffffffu));
_LL(&String[0], (TText8*)"9223372036854775808");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrOverflow);
_LL(&String[0], (TText8*)"-9223372036854775808");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrNone);
test(T64==MAKE_TINT64(0x80000000u,0x0));
_LL(&String[0], (TText8*)"-9223372036854775809");
Lex=&String[0];
test((ret=Lex.Val(T64))==KErrOverflow);
////////////////////
// Test Val(TReal32)
/////////////////////
// test.Next(_L("Val(TReal32)"));
// TReal32 TR32;
// test((ret=Lex.Val(TR32))==KErrNotSupported);
////////////////////
// Test Val(TReal64)
///////////////////
// test.Next(_L("Val(TReal64)"));
// TReal64 TR64;
// test((ret=Lex.Val(TR64))==KErrNotSupported);
///////////////////////////
// Test Val(TUint8, TRadix)
///////////////////////////
test.Next(_L("Val(TUint8, TRadix)"));
TUint8 TU8;
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EBinary))==KErrNone);
test(TU8==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EBinary))==KErrNone);
test(TU8==1);
_LL(&String[0], (TText8*)"11111111");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EBinary))==KErrNone);
test(TU8==255);
_LL(&String[0], (TText8*)"100000000");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EBinary))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EOctal))==KErrNone);
test(TU8==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EOctal))==KErrNone);
test(TU8==1);
_LL(&String[0], (TText8*)"377");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EOctal))==KErrNone);
test(TU8==255);
_LL(&String[0], (TText8*)"400");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EOctal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EDecimal))==KErrNone);
test(TU8==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EDecimal))==KErrNone);
test(TU8==1);
_LL(&String[0], (TText8*)"255");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EDecimal))==KErrNone);
test(TU8==255);
_LL(&String[0], (TText8*)"256");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EDecimal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EHex))==KErrNone);
test(TU8==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EHex))==KErrNone);
test(TU8==1);
_LL(&String[0], (TText8*)"Ff");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EHex))==KErrNone);
test(TU8==255);
_LL(&String[0], (TText8*)"100");
Lex=&String[0];
test((ret=Lex.Val(TU8, (TRadix)EHex))==KErrOverflow);
////////////////////////////
// Test Val(TUint16, TRadix)
////////////////////////////
test.Next(_L("Val(TUint16, TRadix)"));
TUint16 TU16;
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EBinary))==KErrNone);
test(TU16==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EBinary))==KErrNone);
test(TU16==1);
_LL(&String[0], (TText8*)"1111111111111111");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EBinary))==KErrNone);
test(TU16==65535);
_LL(&String[0], (TText8*)"10000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EBinary))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EOctal))==KErrNone);
test(TU16==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EOctal))==KErrNone);
test(TU16==1);
_LL(&String[0], (TText8*)"177777");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EOctal))==KErrNone);
test(TU16==65535);
_LL(&String[0], (TText8*)"200000");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EOctal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EDecimal))==KErrNone);
test(TU16==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EDecimal))==KErrNone);
test(TU16==1);
_LL(&String[0], (TText8*)"65535");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EDecimal))==KErrNone);
test(TU16==65535);
_LL(&String[0], (TText8*)"65536");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EDecimal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EHex))==KErrNone);
test(TU16==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EHex))==KErrNone);
test(TU16==1);
_LL(&String[0], (TText8*)"ffFf");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EHex))==KErrNone);
test(TU16==65535);
_LL(&String[0], (TText8*)"10000");
Lex=&String[0];
test((ret=Lex.Val(TU16, (TRadix)EHex))==KErrOverflow);
////////////////////////////
// Test Val(TUint32, TRadix)
////////////////////////////
test.Next(_L("Val(TUint32, TRadix)"));
TUint32 TU32;
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EBinary))==KErrNone);
test(TU32==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EBinary))==KErrNone);
test(TU32==1);
_LL(&String[0], (TText8*)"11111111111111111111111111111111");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EBinary))==KErrNone);
test(TU32==4294967295u);
_LL(&String[0], (TText8*)"100000000000000000000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EBinary))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EOctal))==KErrNone);
test(TU32==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EOctal))==KErrNone);
test(TU32==1);
_LL(&String[0], (TText8*)"37777777777");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EOctal))==KErrNone);
test(TU32==4294967295u);
_LL(&String[0], (TText8*)"40000000000");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EOctal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EDecimal))==KErrNone);
test(TU32==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EDecimal))==KErrNone);
test(TU32==1);
_LL(&String[0], (TText8*)"4294967295");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EDecimal))==KErrNone);
test(TU32==4294967295u);
_LL(&String[0], (TText8*)"4294967296");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EDecimal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EHex))==KErrNone);
test(TU32==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EHex))==KErrNone);
test(TU32==1);
_LL(&String[0], (TText8*)"FFFFFFFF");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EHex))==KErrNone);
test(TU32==4294967295u);
_LL(&String[0], (TText8*)"100000000");
Lex=&String[0];
test((ret=Lex.Val(TU32, (TRadix)EHex))==KErrOverflow);
///////////////////////////////////
// Test Val(TInt64, TRadix)
///////////////////////////////////
test.Next(_L("Val(TInt64,TRadix)"));
TInt64 TI64;
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrNone);
test(TI64==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrNone);
test(TI64==1);
_LL(&String[0], (TText8*)"11111111111111111111111111111111");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrNone);
test(TI64==TInt64(0xffffffffu));
_LL(&String[0], (TText8*)"100000000000000000000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrNone);
test(TI64==MAKE_TINT64(0x1,0x0));
_LL(&String[0], (TText8*)"1111111111111111111111111111111111111111111111111111111111111111");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrNone);
test(TI64==MAKE_TINT64(0xffffffffu,0xffffffffu));
_LL(&String[0], (TText8*)"10000000000000000000000000000000000000000000000000000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EBinary))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrNone);
test(TI64==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrNone);
test(TI64==1);
_LL(&String[0], (TText8*)"37777777777");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrNone);
test(TI64==TInt64(0xffffffffu));
_LL(&String[0], (TText8*)"40000000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrNone);
test(TI64==MAKE_TINT64(0x1,0x0));
_LL(&String[0], (TText8*)"1777777777777777777777");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrNone);
test(TI64==MAKE_TINT64(0xffffffffu,0xffffffffu));
_LL(&String[0], (TText8*)"2000000000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EOctal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrNone);
test(TI64==0);
_LL(&String[0], (TText8*)"00");
Lex=&String[0]; //************** iNext is set to "" by Val
test((ret=Lex.Val(TI64))==KErrNone);
test(TI64==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrNone);
test(TI64==1);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TI64))==KErrNone);
test(TI64==1);
_LL(&String[0], (TText8*)"4294967295");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrNone);
test(TI64==TInt64(0xffffffffu));
_LL(&String[0], (TText8*)"4294967295");
Lex=&String[0];
test((ret=Lex.Val(TI64))==KErrNone);
test(TI64==TInt64(0xffffffffu));
_LL(&String[0], (TText8*)"4294967296");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrNone);
test(TI64==MAKE_TINT64(1,0));
_LL(&String[0], (TText8*)"4294967296");
Lex=&String[0];
test((ret=Lex.Val(TI64))==KErrNone);
test(TI64==MAKE_TINT64(1,0));
_LL(&String[0], (TText8*)"18446744073709551615");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrNone);
test(TI64==MAKE_TINT64(0xffffffffu,0xffffffffu));
_LL(&String[0], (TText8*)"18446744073709551616");
Lex=&String[0];
test((ret=Lex.Val(TI64))==KErrOverflow);
_LL(&String[0], (TText8*)"-1");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EDecimal))==KErrGeneral);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrNone);
test(TI64==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrNone);
test(TI64==1);
_LL(&String[0], (TText8*)"FFFFFFFF");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrNone);
test(TI64==TInt64(0xffffffffu));
_LL(&String[0], (TText8*)"100000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrNone);
test(TI64==MAKE_TINT64(1,0));
_LL(&String[0], (TText8*)"FFFFFFFFffffffff");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrNone);
test(TI64==MAKE_TINT64(0xffffffffu,0xffffffffu));
_LL(&String[0], (TText8*)"10000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TI64, (TRadix)EHex))==KErrOverflow);
///////////////////////////////////
// Test Val(TUint, TRadix=(TRadix)EDecimal)
///////////////////////////////////
test.Next(_L("Val(TUint, TRadix=(TRadix)EDecimal)"));
TUint TU;
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EBinary))==KErrNone);
test(TU==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EBinary))==KErrNone);
test(TU==1);
_LL(&String[0], (TText8*)"11111111111111111111111111111111");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EBinary))==KErrNone);
test(TU==4294967295u);
_LL(&String[0], (TText8*)"100000000000000000000000000000000");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EBinary))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EOctal))==KErrNone);
test(TU==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EOctal))==KErrNone);
test(TU==1);
_LL(&String[0], (TText8*)"37777777777");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EOctal))==KErrNone);
test(TU==4294967295u);
_LL(&String[0], (TText8*)"40000000000");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EOctal))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EDecimal))==KErrNone);
test(TU==0);
_LL(&String[0], (TText8*)"00");
Lex=&String[0]; //************** iNext is set to "" by Val
test((ret=Lex.Val(TU))==KErrNone);
test(TU==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EDecimal))==KErrNone);
test(TU==1);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU))==KErrNone);
test(TU==1);
_LL(&String[0], (TText8*)"4294967295");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EDecimal))==KErrNone);
test(TU==4294967295u);
_LL(&String[0], (TText8*)"4294967295");
Lex=&String[0];
test((ret=Lex.Val(TU))==KErrNone);
test(TU==4294967295u);
_LL(&String[0], (TText8*)"4294967296");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EDecimal))==KErrOverflow);
_LL(&String[0], (TText8*)"4294967296");
Lex=&String[0];
test((ret=Lex.Val(TU))==KErrOverflow);
_LL(&String[0], (TText8*)"00");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EHex))==KErrNone);
test(TU==0);
_LL(&String[0], (TText8*)"01");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EHex))==KErrNone);
test(TU==1);
_LL(&String[0], (TText8*)"FFFFFFFF");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EHex))==KErrNone);
test(TU==4294967295u);
_LL(&String[0], (TText8*)"100000000");
Lex=&String[0];
test((ret=Lex.Val(TU, (TRadix)EHex))==KErrOverflow);
/////////////////////////////////
// Test Val(TInt32, TUint aLimit)
/////////////////////////////////
// This is called by several of the other Val methods and so has been indirectly tested already
test.Next(_L("Val(TInt32, TUint aLimit"));
_LL(&String[0], (TText8*)"1000");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32,1000))==KErrNone);
test(T32==1000);
_LL(&String[0], (TText8*)"1001");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 1000))==KErrOverflow);
_LL(&String[0], (TText8*)"-1000");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 1000))==KErrNone);
test(T32==-1000);
_LL(&String[0], (TText8*)"-1001");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 1000))==KErrNone);
test(T32==-1001);
_LL(&String[0], (TText8*)"-1002");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 1000))==KErrOverflow);
_LL(&String[0], (TText8*)"0");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 0))==KErrNone);
test(T32==0);
_LL(&String[0], (TText8*)"1");
Lex=&String[0];
test((ret=Lex.BoundedVal(T32, 0))==KErrOverflow);
/////////////////////////////////////////////////
// Test Val(TUInt32, TRadix aRadix, TUint aLimit)
////////////////////////////////////////////////
// This is called by several of the other Val methods and so has been indirectly tested already
test.Next(_L("Val(TUInt32, TRadix, TUint)"));
// Test bug found during previous testing
_LL(&String[0], (TText8*)"10");
Lex=&String[0];
test((ret=Lex.BoundedVal(TU32, (TRadix)EDecimal, 10))==KErrNone);
test(TU32==10);
_LL(&String[0], (TText8*)"11");
Lex=&String[0];
test((ret=Lex.BoundedVal(TU32, (TRadix)EDecimal, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"19");
Lex=&String[0];
test((ret=Lex.BoundedVal(TU32, (TRadix)EDecimal, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"20");
Lex=&String[0];
test((ret=Lex.BoundedVal(TU32, (TRadix)EDecimal, 10))==KErrOverflow);
/////////////////////////////////////////////////
// Test Val(TInt64, TRadix aRadix, TInt64 aLimit)
////////////////////////////////////////////////
test.Next(_L("Val(TInt64, TRadix, TInt64)"));
_LL(&String[0], (TText8*)"10");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, 10))==KErrNone);
test(TI64==TInt64(10));
_LL(&String[0], (TText8*)"11");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"19");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"20");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"34532739886900");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrNone);
test(TI64==MAKE_TINT64(0x1f68u,0x47b1af34u));
_LL(&String[0], (TText8*)"34532739886901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"74532739886901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"6901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EDecimal, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrNone);
test(TI64==TInt64(6901));
_LL(&String[0], (TText8*)"1f6847b1af34");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EHex, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrNone);
test(TI64==MAKE_TINT64(0x1f68u,0x47b1af34u));
_LL(&String[0], (TText8*)"1f6847b1af35");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EHex, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"1f6847b1af340");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EHex, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"1e82791aed35");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, (TRadix)EHex, TInt64(0x56fba45u)))==KErrOverflow);
/////////////////////////////////////////////////
// Test Val(TInt64, TInt64 aLimit)
////////////////////////////////////////////////
test.Next(_L("Val(TInt64, TInt64)"));
_LL(&String[0], (TText8*)"10");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, 10))==KErrNone);
test(TI64==TInt64(10));
_LL(&String[0], (TText8*)"11");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"19");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"20");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, 10))==KErrOverflow);
_LL(&String[0], (TText8*)"34532739886900");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrNone);
test(TI64==MAKE_TINT64(0x1f68u,0x47b1af34u));
_LL(&String[0], (TText8*)"34532739886901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"74532739886901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrOverflow);
_LL(&String[0], (TText8*)"6901");
Lex=&String[0];
test((ret=Lex.BoundedVal(TI64, MAKE_TINT64(0x1f68u,0x47b1af34u)))==KErrNone);
test(TI64==TInt64(6901));
test.End();
}
void testLocale()
{
TLocale current;
current.Refresh();
TLocale loc;
loc.Refresh();
TReal64 v,v8;
TLex l;
TLex8 l8;
TInt r;
loc.SetDecimalSeparator('.');
loc.Set();
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v);
r=l8.Val(v8);
test(r==KErrNone);
test(v==-12.34);
test(v==v8);
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v,'.');
r=l8.Val(v8,'.');
test(r==KErrNone);
test(v==-12.34);
test(v==v8);
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v,',');
r=l8.Val(v8,',');
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v);
r=l8.Val(v8);
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v,'.');
r=l8.Val(v8,'.');
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v,',');
r=l8.Val(v8,',');
test(r==KErrNone);
test(v==-12.34);
test(v==v8);
loc.SetDecimalSeparator(',');
loc.Set();
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v);
r=l8.Val(v8);
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v,'.');
r=l8.Val(v8,'.');
test(r==KErrNone);
test(v==-12.34);
test(v==v8);
l=_L("-12.34");
l8=_L8("-12.34");
r=l.Val(v,',');
r=l8.Val(v8,',');
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v);
r=l8.Val(v8);
test(r==KErrNone);
test(v==-12.34);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v,'.');
r=l8.Val(v8,'.');
test(r==KErrNone);
test(v==-12);
test(v==v8);
l=_L("-12,34");
l8=_L8("-12,34");
r=l.Val(v,',');
r=l8.Val(v8,',');
test(r==KErrNone);
test(v==-12.34);
test(v==v8);
loc.Set();
current.Set();
}
#pragma warning( disable : 4705 ) // statement has no effect
GLDEF_C TInt E32Main()
{
test.Title();
test.Start(_L("********* TLEX **********"));
#if defined(_UNICODE)
TestTLex<TPtrC, TLex, TLexMark, TBuf<0x40>, TLex16Dump, TLexMark16Dump, TText> T;
#else
TestTLex<TPtrC, TLex, TLexMark, TBuf<0x40>, TLex8Dump, TLexMark8Dump, TText> T;
#endif
test.Next(_L("TText 1"));
T.Test1();
test.Next(_L("TText 2"));
T.Test2();
test.Next(_L("TText 3"));
T.Test3();
test.Next(_L("TText 4"));
T.Test4();
test.Next(_L("TText 5"));
T.Test5();
TestTLex<TPtrC8, TLex8, TLexMark8, TBuf8<0x40>, TLex8Dump, TLexMark8Dump, TText8> T8;
test.Next(_L("TText8 1"));
T8.Test1();
test.Next(_L("TText8 2"));
T8.Test2();
test.Next(_L("TText8 3"));
T8.Test3();
test.Next(_L("TText8 4"));
T8.Test4();
test.Next(_L("TText8 5"));
T8.Test5();
TestTLex<TPtrC16, TLex16, TLexMark16, TBuf16<0x40>, TLex16Dump, TLexMark16Dump, TText16> T16;
test.Next(_L("TText16 1"));
T16.Test1();
test.Next(_L("TText16 2"));
T16.Test2();
test.Next(_L("TText16 3"));
T16.Test3();
test.Next(_L("TText16 4"));
T16.Test4();
test.Next(_L("TText16 5"));
T16.Test5();
test.Next(_L("Test TLex in different locales"));
testLocale();
test.End();
return(KErrNone);
}
#pragma warning( default : 4705 )