// Copyright (c) 1995-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\math\t_float.cpp

 // Data split into files: t_float1.cpp, t_float2.cpp and t_float3.cpp

 // Overview:

 // Test conversion of real to descriptors, descriptors to real and the 

 // Math::Round method.

 // API Information:

 // TDes8, TDes16, TLex8, TLex16, Math.  

 // Details:

 // - Test conversion of specified TReal32, TReal64 into TBuf8, TBuf16 

 // is as expected.

 // - Round some numbers to a specified number of decimal places and check it 

 // is as expected.

 // - Test conversion of specified TReal32, TReal64 into TBuf8, TBuf16 in

 // calculator mode is as expected.

 // - Check that errors returned during conversion from TReal32, TReal64 into 

 // TBuf8, TBuf16 are as expected.

 // - Verify the result when a string is parsed to extract a real number.

 // - Test string to real conversion in cases, which are not exact and check

 // that results are as expected.

 // - Test errors in string to real conversion are as expected.

 // - Test that the conversion from string to real and then real to string, verify

 // the results are as expected.

 // - For specified strings values check parsing of string to extract real value, 

 // absolute value, token length is as expected.

 // - Check the character representation of specified real numbers are as expected.

 // Platforms/Drives/Compatibility:

 // All 

 // Assumptions/Requirement/Pre-requisites:

 // Failures and causes:

 // Base Port information:

 // 

 //

 #include "t_math.h"

 #include "t_float.h"

 GLREF_D RtoB_TEST testd[];

 GLREF_D TUint size_testd;

 GLREF_D RtoB_TEST testcalc[];

 GLREF_D TUint size_testcalc;

 GLREF_D ERR_TEST testerr[];

 GLREF_D TUint size_testerr;

 GLREF_D DtoR_ERR_TEST testerr2[];

 GLREF_D TUint size_testerr2;

 GLREF_D DtoR_ERR_TEST testerr3[];

 GLREF_D TUint size_testerr3;

 GLREF_D CALC_TEST calctest[];

 GLREF_D TUint size_calctest;

 GLREF_D ROUND_TEST testround[];

 GLREF_D TUint size_testround;

 GLREF_D DtoR_TEST64 testd2[];

 GLREF_D TUint size_testd2;

 GLREF_D DtoR_TEST64 testApprox[];

 GLREF_D TUint size_testApprox;

 GLREF_D DtoR_TEST32 testd32[];

 GLREF_D TUint size_testd32;

 GLDEF_D RTest test(_L("T_FLOAT"));

 LOCAL_C TInt rtob(RtoB_TEST& tst)

     {

     TBuf<0x100> buf;

  	TInt ret=buf.Num(tst.num,tst.format);

 	if (ret!=KErrGeneral)

 		{

 		buf.ZeroTerminate();

 		TPtrC result(tst.res);

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

 		test(buf.Compare(result)==0);

 		}

     return(ret);

     }

 LOCAL_C void test1()

 // 

 // Test RtoB using selected numbers

 //

     {

   	for (TInt jj=0;jj<TInt(size_testd/sizeof(RtoB_TEST));jj++)

         test(rtob(testd[jj])>=0);

 	}

 LOCAL_C void test2()

 //

 // Test Math::Round(_,_,_) for specific numbers

 //

     {

     TReal res;

     TRealFormat pf;

 	pf.iType=KRealFormatExponent;

 	pf.iWidth=22;

 	pf.iPlaces=15;

 	pf.iPoint='.';

 	pf.iTriad=',';

 	pf.iTriLen=1;

     for (TInt jj=0;jj<TInt(size_testround/sizeof(ROUND_TEST));jj++) 

         {

         test(Math::Round(res,testround[jj].num,testround[jj].plcs)==KErrNone);

         TReal err=(res-testround[jj].res);

         if (res)

             err/=res;

         test(Abs(err)<=1E-15);

         }

     }

 LOCAL_C void test3()

 // 

 // Test RtoB in calculator mode using selected numbers

 // Added by AnnW, November 1996

 //

     {

   	for (TInt jj=0;jj<TInt(size_testcalc/sizeof(RtoB_TEST));jj++)

         test(rtob(testcalc[jj])>=0);

     }

 LOCAL_C void test4()

 //

 // Tests errors

 //

     {

     for (TInt jj=0;jj<TInt(size_testerr/sizeof(ERR_TEST));jj++)

         {

         RtoB_TEST tst=testerr[jj].rtob;

 		TInt ret=rtob(tst);

 		test(testerr[jj].err==ret);

         }

     }

 // End of translated test code from plib.  Now some tests from string o real conversions:

 LOCAL_C void test5()

 //

 // Test string to real conversion with selected numbers

 // added by AnnW, December 1996

 //

 	{

 	TLex l;

 	TReal64 r64;

 	TInt jj;

 	for (jj=0; jj<TInt(size_testd2/sizeof(DtoR_TEST64)); jj++)

 		{

 		const DtoR_TEST64* tst64=&testd2[jj];

 		l=tst64->iLex;

 		test(l.Val(r64)==KErrNone);

 		test(tst64->iRes==r64);

 		}

 	TReal32 r32;

 	for (jj=0; jj<TInt(size_testd32/sizeof(DtoR_TEST32)); jj++)

 		{

 		const DtoR_TEST32* tst32=&testd32[jj];

 		l=tst32->iLex;

 		test(l.Val(r32)==KErrNone);

 		test(tst32->iRes==r32);

 		}

 	}	

 LOCAL_C void test6()

 //

 // Test string to real conversion in cases which are not exact

 // Added by AnnW, December 1996

 //

 	{

 	TReal r64;

 	for (TInt jj=0; jj<TInt(size_testApprox/sizeof(DtoR_TEST64)); jj++)

 		{

 		const DtoR_TEST64* tst64=&testApprox[jj];

 		TLex l=tst64->iLex;

 		test(l.Val(r64)==KErrNone);

 		test(tst64->iRes==r64);

 		}

 	}

 LOCAL_C void test7()

 //

 // Test errors in string to real conversion

 // added by AnnW, December 1996

 //

 	{

 	TReal r64;

 	TInt jj;

 	for (jj=0; jj<TInt(size_testerr2/sizeof(DtoR_ERR_TEST)); jj++)

 		{

 		const DtoR_ERR_TEST* errtst64=&testerr2[jj];

 		TLex l=errtst64->iLex;

 		TInt err=errtst64->iErr;

 		test(l.Val(r64)==err);

 		}

 	TReal32 r32;

 	for (jj=0; jj<TInt(size_testerr3/sizeof(DtoR_ERR_TEST)); jj++)

 		{

 		const DtoR_ERR_TEST* errtst32=&testerr3[jj];

 		TLex l=errtst32->iLex;

 		TInt err=errtst32->iErr;

 		test(l.Val(r32)==err);

 		}

 	}

 LOCAL_C void test8()

 //

 // Some tests for calc to check that a number entered is printed to same significance when

 // returned

 // do dtor and rtod test

 //

 	{

 	TLex l;

 	TBuf<0x100> buf;

 	TInt ret;

 	TReal64 num;

 	for (TInt jj=0;jj<TInt(size_calctest/sizeof(CALC_TEST));jj++)

 		{

 		// string to real

 		const CALC_TEST tst=calctest[jj];

 		l=tst.iLex;

 		test(l.Val(num)==KErrNone);

 		// real to string

  		ret=buf.Num(num,tst.iFormat);

 		if (ret!=KErrGeneral)

 			{

 			buf.ZeroTerminate();

 			test(buf.Compare(TPtrC(tst.iRes))==0);

 			}

 		test(ret>=0);    

 		}

 	}

 // Tag on a few extra tests relating to ascii and unicode

 template<class R,class S,class L,class B,class T> 		

 class AsciiUnicode

 	{

 public:

 	void Test1();

 	};

 template<class R, class S,class L,class B,class T>

 void AsciiUnicode<R,S,L,B,T>::Test1()

 // R == TReal32 or TReal64

 // S == TText, TText8 or TText16

 // L == TLex, TLex8 or TLex16

 // B == TBuf, TBuf8 or TBuf16

 // T == TPtr, TPtr8 or TPtr16

 	{

 	L lex1(_TL("123.456"));

 	R real; // TReal32 or TReal64 

 	test(lex1.Val(real)==KErrNone);							 

 	test(Abs(real-123.456)<1E-5);

 	test(lex1.TokenLength()==7);

 	test((lex1.Remainder()).Compare(T(_TL(""),0,0))==0);

 	test(lex1.Val(real)==KErrGeneral);

 	L lex2(_TL("123.456abc"));

 	test(lex2.Val(real)==KErrNone);

 	test(Abs(real-123.456)<1E-5);

 	test(lex2.TokenLength()==7);

 	test((lex2.Remainder()).Compare(T(_TL("abc"),3,3))==0);

 	test(lex2.Val(real)==KErrGeneral);

 	L lex3;

 	real=(R)0.5;

 	test(lex3.Val(real)==KErrGeneral);

 	test(real==((R)0.5));

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

 	L lex4(_TL("abc123.45"));

 	real=(R)0.5;

 	test(lex4.Val(real)==KErrGeneral);

 	test(real==((R)0.5));

 	L Lex5(_TL("1.2e37"));

 	real=(R)0.5;

 	test(Lex5.Val(real)==KErrNone);

 	L Lex6(_TL("1.2e"));

 	real=(R)0.5;

 	test(Lex6.Val(real)==KErrNone);

 	TRealFormat format(20,3); // first param width, 2nd decimals

 	real=(R)12345.6789;

 	B buf1;

 	test(buf1.Num(real,format)==10);

 	test(buf1.Compare(T(_TL("12,345.679"),10,10))==0);

 	B buf2(_TL("abc"));

 	test(buf2.AppendNum(real,format)==13);

 	test(buf2.Compare(T(_TL("abc12,345.679"),13,13))==0); 

 	B buf3;

 	test(buf3.AppendNum(real,format)==10);

 	test(buf3.Compare(T(_TL("12,345.679"),10,10))==0);

 	}

 #ifndef _DEBUG

 #pragma warning (disable :4710) //Function not expanded

 #pragma warning (disable :4702) //Unreachable code

 #endif

 GLDEF_C TInt E32Main()

     {

 	test.Title();

 	test.Start(_L("Test ftol"));

     TReal f=34.567;

     TInt i=TInt(f);

     test(i==34);

 	test.Next(_L("Test TBuf8/16::Num() using selected numbers"));

 	test1();

 	test.Next(_L("Test specific numbers for Math::Round(_,_,_)"));

 	test2();

 	test.Next(_L("Test TBuf8/16::Num() using selected numbers in calculator mode"));

 	test3();

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

 	test4();

 	test.Next(_L("Test TLex8/16::Val using selected values which give exact results"));

 	test5();

 	test.Next(_L("Test TLex8/16::Val using values which do NOT give exact results"));

 	test6();

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

 	test7();

 	test.Next(_L("Test for CALC"));

 	test8();

 	//

 	test.Next(_L("Ascii/Unicode: TText"));

 	AsciiUnicode<TReal64,TText,TLex,TBuf<0x20>,TPtr> T1;

 	T1.Test1();

 	test.Next(_L("Ascii/Unicode: TText8"));

 	AsciiUnicode<TReal32,TText8,TLex8,TBuf8<0x20>,TPtr8> T2;

 	T2.Test1();

 	test.Next(_L("Ascii/Unicode: TText16"));

 	AsciiUnicode<TReal32,TText16,TLex16,TBuf16<0x20>,TPtr16> T3;

 	T3.Test1();											

 	//

 	test.End();

 	return(KErrNone);

 	}

 #pragma warning (default :4710)

 #pragma warning (default :4702)