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

 // Tests round-trip convertibility of double->string->double

 // 

 //

 #define __E32TEST_EXTENSION__

 #include <e32test.h>

 #include <e32math.h>

 //#define __ALWAYS_PRINT__

 RTest test(_L("T_ROUNDTRIP"));

 void PrintRealHex(const char* aTitle, const TReal& aIn)

 	{

 	volatile TUint32* in = (volatile TUint32*)&aIn;

 #ifdef __DOUBLE_WORDS_SWAPPED__

 	TUint32 high = in[0];

 	TUint32 low = in[1];

 #else

 	TUint32 high = in[1];

 	TUint32 low = in[0];

 #endif

 	TBuf<256> title;

 	if (aTitle)

 		title.Copy(TPtrC8((const TUint8*)aTitle));

 	test.Printf(_L("%S%08x %08x\n"), &title, high, low);

 	}

 TInt RoundTrip(TReal& aOut, const TReal& aIn)

 	{

 	TBuf8<64> text;

 	TRealFormat fmt;

 	fmt.iType = KRealFormatExponent | KRealInjectiveLimit | KUseSigFigs | KDoNotUseTriads | KAllowThreeDigitExp;

 	fmt.iWidth = 32;

 	fmt.iPlaces = KIEEEDoubleInjectivePrecision;

 	fmt.iPoint = '.';

 #ifdef __ALWAYS_PRINT__

 	PrintRealHex("Input : ", aIn);

 #endif

 	TInt r = text.Num(aIn, fmt);

 	if (r<0)

 		{

 		test.Printf(_L("Result %d (Num)\n"), r);

 		return r;

 		}

 #ifdef __ALWAYS_PRINT__

 	TBuf16<64> text16;

 	text16.Copy(text);

 	test.Printf(_L("Text  : %S\n"), &text16);

 #endif

 	TLex8 lex(text);

 	r = lex.Val(aOut);

 	if (r < 0)

 		{

 		test.Printf(_L("Result %d (Val)\n"), r);

 		return r;

 		}

 #ifdef __ALWAYS_PRINT__

 	PrintRealHex("Output: ", aOut);

 #endif

 	volatile TUint32* in = (volatile TUint32*)&aIn;

 	volatile TUint32* out = (volatile TUint32*)&aOut;

 	if (in[0]!=out[0] || in[1]!=out[1])

 		{

 		test.Printf(_L("Unsuccessful\n"));

 #ifndef __ALWAYS_PRINT__

 		PrintRealHex("Input : ", aIn);

 		TBuf16<64> text16;

 		text16.Copy(text);

 		test.Printf(_L("Text  : %S\n"), &text16);

 		PrintRealHex("Output: ", aOut);

 #endif

 		return KErrUnknown;

 		}

 	return KErrNone;

 	}

 const TUint64 KMantissaOverflow =	UI64LIT(0x20000000000000);	// 2^53

 const TUint64 KMantissaThreshold =	UI64LIT(0x10000000000000);	// 2^52

 class R

 	{

 public:

 	enum {EMinExp=0, EMinNormExp=1, EMaxNormExp=2046, EMaxExp=2047};

 public:

 	R();

 	R(const TReal& aIn);

 	TReal Value() const;

 	TInt Next();

 	TInt Prev();

 public:

 	TUint64	iMant;		//	if iExp>0 2^52<=iMant<2^53 else 0<=iMant<2^52

 	TInt	iExp;		//	0 < iExp < 2047

 	TInt	iSign;

 	};

 R::R()

 	{

 	iMant = 0;

 	iExp = 0;

 	iSign = 0;

 	}

 R::R(const TReal& aIn)

 	{

 	const volatile TUint32* in = (const volatile TUint32*)&aIn;

 #ifdef __DOUBLE_WORDS_SWAPPED__

 	TUint32 high = in[0];

 	TUint32 low = in[1];

 #else

 	TUint32 high = in[1];

 	TUint32 low = in[0];

 #endif

 	iSign = high >> 31;

 	iExp = (high >> 20) & EMaxExp;

 	iMant = MAKE_TUINT64(high, low);

 	iMant <<= 12;

 	iMant >>= 12;

 	if (iExp)

 		iMant += KMantissaThreshold;

 	}

 TReal R::Value() const

 	{

 	TUint32 high = iSign ? 1 : 0;

 	high <<= 31;

 	high |= (iExp<<20);

 	TUint32 mh = I64HIGH(iMant);

 	mh <<= 12;

 	high |= (mh>>12);

 	TUint32 low = I64LOW(iMant);

 	union {TReal iReal; TUint32 iX[2];} result;

 #ifdef __DOUBLE_WORDS_SWAPPED__

 	result.iX[0] = high;

 	result.iX[1] = low;

 #else

 	result.iX[0] = low;

 	result.iX[1] = high;

 #endif

 	return result.iReal;

 	}

 TInt R::Next()

 	{

 	if (iExp>0)

 		{

 		if (++iMant == KMantissaOverflow)

 			{

 			iMant >>= 1;

 			if (++iExp == EMaxExp)

 				return KErrOverflow;

 			}

 		return KErrNone;

 		}

 	if (++iMant == KMantissaThreshold)

 		iExp = 1;

 	return KErrNone;

 	}

 TInt R::Prev()

 	{

 	if (iExp == EMaxExp)

 		{

 		if (iMant == KMantissaThreshold)

 			{

 			--iExp;

 			return KErrNone;

 			}

 		return KErrGeneral;

 		}

 	if (iExp>0)

 		{

 		if (--iMant < KMantissaThreshold)

 			{

 			if (--iExp)

 				{

 				iMant <<= 1;

 				iMant++;

 				}

 			}

 		return KErrNone;

 		}

 	if (iMant==0)

 		return KErrUnderflow;

 	--iMant;

 	return KErrNone;

 	}

 void DoTest(R& aR, TInt& aErrorCount)

 	{

 	TReal out;

 	TInt r;

 	r = RoundTrip(out, aR.Value());

 	if (r==KErrUnknown)

 		++aErrorCount;

 	R R1(aR);

 	R R2(aR);

 	if (R1.Next()==KErrNone)

 		{

 		r = RoundTrip(out, R1.Value());

 		if (r==KErrUnknown)

 			++aErrorCount;

 		}

 	if (R2.Prev()==KErrNone)

 		{

 		r = RoundTrip(out, R2.Value());

 		if (r==KErrUnknown)

 			++aErrorCount;

 		}

 	}

 void DoTest(TInt aExp, TInt& aErrorCount)

 	{

 	R x;

 	x.iExp = aExp;

 	x.iMant = KMantissaThreshold;

 	if (aExp==0)

 		{

 		do	{

 			x.iMant >>= 1;

 			DoTest(x, aErrorCount);

 			} while (x.iMant);

 		}

 	else

 		{

 		DoTest(x, aErrorCount);

 		}

 	}

 void DoTestPow10(TInt aPow, TInt& aErrorCount)

 	{

 	TReal64 r64;

 	TInt r = Math::Pow10(r64, aPow);

 	if (r<0)

 		return;

 	R x(r64);

 	DoTest(x, aErrorCount);

 	}

 void DoTestRandom(TInt& aErrorCount)

 	{

 	static TInt64 randSeed = I64LIT(0x3333333333333333);

 	R x;

 	x.iExp = Math::Rand(randSeed) & R::EMaxExp;

 	x.iMant = ((TUint64)Math::Rand(randSeed) << 32) | (TUint64)Math::Rand(randSeed);

 	while (x.iMant > KMantissaThreshold)

 		x.iMant >>= 1;

 	x.iSign = Math::Rand(randSeed) & 0x1;

 	DoTest(x, aErrorCount);

 	}

 TInt E32Main()

 	{

 	test.Title();

 	test.Start(_L("Testing conversion from double->string->double"));

 	TInt exp;

 	TInt errors = 0;

 	test.Next(_L("Test the conversion of powers of 2"));

 	for (exp = 0; exp < 2047; ++exp)

 		{

 		DoTest(exp, errors);

 		}

 	test.Next(_L("Test the conversion of powers of 10"));

 	for (exp = -325; exp < 325; ++exp)

 		{

 		DoTestPow10(exp, errors);

 		}

 	test.Next(_L("Test the conversion of some random numbers"));

 	for (exp = 0; exp < 100; ++exp)

 		{

 		DoTestRandom(errors);

 		}

 	test_Equal(0, errors);

 	test.End();

 	return KErrNone;

 	}