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

// Tests TInt64

// Overview:

// Test 64-bit integer functionality.

// API Information:

// TInt64.

// Details:

// - Construct TInt64 with specified range of integer, real, high

// and low values and check constructor, copy constructor are as expected.

// - Test all the operators for range of values and check it is as expected.

// - Check the logical shift of specified number of bits is as expected.

// - Check multiplication of 64 bit integer by the specified 64 bit integer 

// using MulTop, fast multiplication of 64 bit integer by 10.

// - Verify the 64 bit integer divide and mod results are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32math.h>

inline TInt __i64multop(TInt64& aX, TInt64& aValue)

			{	Uint64 __lowResult; \

				Uint64 __highResult; \

				Math::UMul64(aX, aValue, __highResult, __lowResult); \

				aX = static_cast<TInt64>(__highResult); \

				return (__lowResult == UI64LIT(0x0000000000000000)) ?	-2 : \

				(__lowResult < UI64LIT(0x8000000000000000)) ?	-1 : \

				(__lowResult == UI64LIT(0x8000000000000000)) ?	0  : \

				/*__lowResult > UI64LIT(0x8000000000000000)*/	1; \

			}

#define	I64MULTOP(x, value) __i64multop(x, (value))

TInt HexMulAdd(TUint8 a1,TUint8 a2,TUint8& answer,TUint8& carry)

	{

	TUint x1= a1>'9' ? a1-'a'+10 : a1-'0';

	TUint x2= a2>'9' ? a2-'a'+10 : a2-'0';

	TUint a= answer>'9' ? answer-'a'+10 : answer-'0';

	TUint c= carry>'9' ? carry-'a'+10 : carry-'0';

	if (x1>15) return (KErrArgument);

	if (x2>15) return (KErrArgument);

	if (a>15) return (KErrArgument);

	if (c>15) return (KErrArgument);

	a+=(x1*x2)+c;

	c=a/16;

	a=a%16;

	a= a>9 ? a-10+'a' : a+'0';

	c= c>9 ? c-10+'a' : c+'0';

	answer=(TUint8)a;

	carry=(TUint8)c;

	return(KErrNone);

	}

TInt HexMul(TDesC8& a1,TDesC8& a2,TDes8& a3)

//

// Infinite precision hex multiplier

//

	{

	TInt l1=a1.Length();

	TInt l2=a2.Length();

	TInt l3=l1+l2;

	if (a3.MaxLength()<l3)

		return(KErrArgument);

	a3.Zero();

	TInt x;

	TInt y;

	TInt z;

	for (x=0;x<l3;x++)

		a3.Append('0');

	for (y=0;y<l2;y++)

		{

		TUint8 carry='0';

		for (z=0;z<l1;z++)

			{

			if(HexMulAdd(a2[l2-y-1],a1[l1-z-1],a3[l3-y-z-1],carry)!=KErrNone)

				return(KErrArgument);

			}

		if(HexMulAdd('0','0',a3[l3-y-l1-1],carry)!=KErrNone)

			return(KErrArgument);

		}

	return(KErrNone);

	}

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

LOCAL_C void SlowDivMod(const TInt64& aA, const TInt64& aB, TInt64& aDiv, TInt64& aMod)

//

//	Calculate Division/Remainder using repeated subtraction

//

	{

		TInt negative=0;

		TInt64 t=0;

		if (aA<0)

			{

			negative=1;

			aMod=-aA;

			}

		else

			{

			aMod=aA;

			}

		if (aB<0)

			{

			if (negative)

				negative=0;

			else

				negative=1;

			t=-aB;

			}

		else

			{

			t=aB;

			}

		aDiv=0;

		if ((t & UI64LIT(0xffffffff00000000)) == 0)

			{

			while (aMod >= (t << 31))

				{

				aMod -= t << 31;

				}

			}

		if ((t & UI64LIT(0xffffff0000000000)) == 0)

			{

			while (aMod >= (t << 23))

				{

				aDiv += 1 << 23;

				aMod -= t << 23;

				}

			}

		if ((t & UI64LIT(0xffff000000000000)) == 0)

			{

			while (aMod >= (t << 15))

				{

				aDiv += 1 << 15;

				aMod -= t << 15;

				}

			}

		if ((t & UI64LIT(0xff00000000000000)) == 0)

			{

			while (aMod >= (t << 7))

				{

				aDiv += 1 << 7;

				aMod -= t << 7;

				}

			}

		if ((t & UI64LIT(0xf000000000000000)) == 0)

			{

			while (aMod >= (t << 3))

				{

				aDiv += 1 << 3;

				aMod -= t << 3;

				}

			}

		while (aMod >= t)

			{

			++aDiv;

			aMod -= t;

			}

		if (negative)

			{

			aDiv=-aDiv;

			}

		if (aA < 0)

			{

			aMod =- aMod;	

			}

	}

LOCAL_C void DivModTest(const TInt64& aA, const TInt64& aB)

//

//	Test DivMod against SlowDivMod

//

	{

	if (aB!=0)

		{

		TInt64 n(aA),d(aB);

		TInt64 div=0,mod=0,res=0;

		SlowDivMod(n,d,div,mod);

		res = n % d;

		n /= d;

		test(n==div);

		test(res==mod);

		}

	}

LOCAL_C void Test1()

	{

	// Test the constructors

	// TInt64()

	test.Start(_L("Default constructor"));

	TInt64 t1;

	t1 = 0; // to prevent uninitialised warnings

	(void)(t1 > 0); // to prevent unused warnings

	// TInt64(TInt aVal)

	test.Next(_L("TInt64(TInt aVal)"));

	TInt64 t2(0);

	test(I64LOW(t2)==0 && I64HIGH(t2)==0);

	TInt64 t3(1);  	 

	test(I64LOW(t3)==1 && I64HIGH(t3)==0);

	TInt64 t4(KMaxTInt32);

	test(I64LOW(t4)==(TUint)KMaxTInt32 && I64HIGH(t4)==0);

	TInt64 t5(-1);

	test(I64INT(t5)==-1);

	test(I64LOW(t5)==KMaxTUint32 && I64HIGH(t5)==KMaxTUint32);

	TInt64 t6(KMinTInt32); 	

	test(I64INT(t6)==KMinTInt32);

	// TInt64(TUint aVal)

	test.Next(_L("TInt64(TUint aVal)"));

	TInt64 t7((TUint)0);

	test(I64LOW(t7)==0 && I64HIGH(t7)==0);

	TInt64 t8((TUint)1);  	 

	test(I64LOW(t8)==1 && I64HIGH(t8)==0);

	TInt64 t9(KMaxTUint32);

	test(I64LOW(t9)==KMaxTUint32 && I64HIGH(t9)==0);

	// TInt64(TUint aHigh,TUint aLow)

	test.Next(_L("TInt64(TUint aHigh,TUint aLow)"));

	TInt64 t10 = MAKE_TINT64(0,0);

	test(I64LOW(t10)==0 && I64HIGH(t10)==0);

	TInt64 t11 = MAKE_TINT64(KMaxTUint32,KMaxTUint32);   // highest value stored === (2**64)-1

	test(I64LOW(t11)==KMaxTUint32 && I64HIGH(t11)==KMaxTUint32);

	// TInt64(TReal aVal)

	test.Next(_L("TInt64(TReal aVal)"));

	TInt64 t12((TInt64)1.0);

	test(I64LOW(t12)==1 && I64HIGH(t12)==0);

	TInt64 t15((TInt64)4.99);

	test(I64LOW(t15)==4 && I64HIGH(t15)==0);

	TReal x;

	x = -9.223372036854776831e18; // -2^63 - 2^10 (to ensure rounding outside of TInt64 range)

	TInt64 t16((TInt64)x);

	test(t16==KMinTInt64);

	TInt64 t17((TInt64)0.5);

	test(I64LOW(t17)==0 && I64HIGH(t17)==0);

	TInt64 t18((TInt64)0.0);

	test(I64LOW(t18)==0 && I64HIGH(t18)==0);

	TInt64 t19((TInt64)-123325.23411412);

	test(I64LOW(t19)==(TUint)(-123325) && I64HIGH(t19)==0xffffffff);

	TInt64 t20((TInt64)1.0E-1);

	test(I64LOW(t20)==0 && I64HIGH(t20)==0);

	// Make variable volatile to protect ourselves from compiler optimisations. Given that the

	// following test is negative with unspecified results, we don't really care if we do not have

	// FPU/compiler parity.

	volatile TReal xout;

	xout = 9.223372036854776831e18; // 2^63 + 2^10 (to ensure rounding outside of TInt64 range)

	TInt64 t21((TInt64)xout);

	// IEEE 754 does not specify the value to be returned when a conversion

	// is performed on a value that is outside the range of the target, only

	// that an invalid operation exception be raised if the io fp exception

	// is not masked.

#if defined(__WINS__) || defined(__X86__)

	// The x86 FPU returns KMin... as the "indefinite number"

	test(t21 == KMinTInt64);

#else

	// The target compiler support libraries return KMax...

	test(t21 == KMaxTInt64);

#endif

	TReal limit=1048576.0*1048576.0*8192.0;		// integers <2^53 in modulus can be represented exactly

	TInt64 t22((TInt64)limit);

	test(I64LOW(t22)==0 && I64HIGH(t22)==0x00200000);

	TInt64 t23((TInt64)(limit-1.0));

	test(I64LOW(t23)==0xffffffff && I64HIGH(t23)==0x001fffff);

	TReal i64limit=limit*1024.0;				// 2^63

	// Make variable volatile to protect ourselves from compiler optimisations. Given that the

	// following test is negative with unspecified results, we don't really care if we do not have

	// FPU/compiler parity.

	volatile TReal i64limitout=i64limit;

	TInt64 t24((TInt64)i64limitout);

	// IEEE 754 does not specify the value to be returned when a conversion

	// is performed on a value that is outside the range of the target, only

	// that an invalid operation exception be raised if the io fp exception

	// is not masked.

#if defined(__WINS__) || defined(__X86__)

	// The x86 FPU returns KMin... as the "indefinite number"

	test(t24 == KMinTInt64);

#else

	// The target compiler support libraries return KMax...

	test(t24 == KMaxTInt64);

#endif

	TInt64 t25((TInt64)(i64limit-1024.0));

	test(I64LOW(t25)==0xfffffc00 && I64HIGH(t25)==0x7fffffff);

	TInt64 t26((TInt64)-i64limit);

	test(I64LOW(t26)==0x00000000 && I64HIGH(t26)==0x80000000);

	TInt64 t27((TInt64)(1024.0-i64limit));

	test(I64LOW(t27)==0x00000400 && I64HIGH(t27)==0x80000000);

	TInt i;

	TInt64 l;

	for (i=-99; i<100; i++)

		{

		x=1;

		l=1;

		TReal a(i);

		TInt64 b(i);

		while (Abs(x)<limit)

			{

//			test.Printf(_L("Testing %g\n"),x);

			TInt64 ll((TInt64)x);

			test(ll==l);

			ll=0;

			ll = (TInt64)x;

			test(ll==l);

			x*=a;

			l*=b;

			if (i==1 || i==0 || (i==-1 && l==TInt64(1)))

				break;

			}

		}

	// TInt64::GetTReal

	test.Next(_L("TInt64::GetTReal"));

	// GCC does optimise large portions of the test code out and there can be small

	// differences in the way GCC and the FPU round floating point values.

	// We isolate the following test by giving it its own variables. This should

	// prevent values returned by the FPU from being compared with wrong GCC calculations.

	TInt64 m = MAKE_TINT64(0x7fffffff,0xffffffff);

	TReal xy = I64REAL(m);

	TReal xx = 1048576.0*1048576.0*1048576.0*8.0 - 1.0; // 2^63 - 1

	test(xy == xx);

	//

	l = MAKE_TINT64(0x7fffffff,0xfffffc00);

	x = I64REAL(l);

	test(x == (i64limit - 1024.0));

	l = MAKE_TINT64(0x80000000,0x00000000);

	x = I64REAL(l);

	test(x == -i64limit);

	l = MAKE_TINT64(0x80000000,0x00000400);

	x = I64REAL(l);

	test(x == (1024.0 - i64limit));

	l = MAKE_TINT64(0x00000001,0x00000000);

	x = I64REAL(l);

	test(x == (65536.0 * 65536.0));

	l = MAKE_TINT64(0xffffffff,0x00000000);

	x = I64REAL(l);

	test(x == (-65536.0 * 65536.0));

	for (i=-99; i<100; i++)

		{

		x=1;

		l=1;

		TReal a(i);

		TInt64 b(i);

		while (Abs(x)<limit)

			{

//			test.Printf(_L("Testing %g\n"),x);

			TReal y = I64REAL(l);

			test(y==x);

			x*=a;

			l*=b;

			if (i==1 || i==0 || (i==-1 && l==TInt64(1)))

				break;

			}

		}

	// TInt64(const TInt64& aVal)

	test.Next(_L("Copy constructor"));

	TInt64 t13(t10);

	test(I64LOW(t13)==I64LOW(t10) && I64HIGH(t13)==I64HIGH(t10));

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

	t13 = MAKE_TINT64(0, 0);

	test(I64LOW(t13)==0 && I64HIGH(t13)==0);

	test.End();

	}

LOCAL_C void Test1_2()

//

//	Test Unary operators -, and +

//

	{

	TInt64 r(0),q(0);

	r=1;

	test(-r==-1);

	test(+r==1);

	r=-100;

	test(-r==100);

	test(+r==-100);

	r = MAKE_TINT64(540423,21344);

	test(-r==(q-r));

	test(+r==r);

	test(+r==MAKE_TINT64(540423,21344));

	r=0;

	test(-r==0);

	test(+r==0);

	}

LOCAL_C void Test2()

	{

	// Test the operators

	// =

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

	TInt64 r=0,r2=0, a = MAKE_TINT64(12345,54321);

	r=KMaxTInt32;

	test(I64LOW(r)==(TUint)KMaxTInt32 && I64HIGH(r)==0);

	r2=r=KMinTInt32;

	test(I64INT(r)==KMinTInt32);

	test(I64INT(r2)==KMinTInt32);

	r2=r=KMaxTUint32;

	test(I64LOW(r)==KMaxTUint32 && I64HIGH(r)==0);

	test(I64LOW(r2)==KMaxTUint32 && I64HIGH(r2)==0);

	r2=r=a;

	test(I64LOW(r)==I64LOW(a) && I64HIGH(r)==I64HIGH(a));

	test(I64LOW(r2)==I64LOW(a) && I64HIGH(r2)==I64HIGH(a));

	r2=r=(TInt64)((TReal)1.2);

	test(r==1);

	test(r2==1);

	r2=r=(TInt64)((TReal)20.9);

	test(r==20);

	test(r2==20);

	r2=r=(TInt64)((TReal)-100.2);

	test(r==-100);

	test(r2==-100);

	// +=, -=, *=, /=, %=, >>=, <<=, >>, <<

	// += 

	test.Next(_L("+="));

	r=-1;

	r+=1;

	test(I64INT(r)==0);

	r+=1;

	test(I64INT(r)==1);

	r=KMaxTUint32;

	r+=1;

	test(I64INT(r)-1==(TInt)KMaxTUint32);

	r=KMinTInt32;

	r+=1;

	test(I64INT(r)==KMinTInt32+1);

	r=0;

	r+=MAKE_TINT64(0,0x80000000u);

	test(r==MAKE_TINT64(0,0x80000000u));

	// -=

	test.Next(_L("-="));						 

	r=-1;

	r-=1;

	test(I64INT(r)==-2);

	r=0;

	r-=1;

	test(I64INT(r)==-1);

	r=1;

	r-=1;

	test(I64INT(r)==0);

	r=KMaxTUint32;

	r+=1;

	r-=1;

	test(I64HIGH(r)==0 && I64LOW(r)==KMaxTUint32);

	test(I64INT(r)==(TInt)KMaxTUint32);

	r-=1;

	test(I64INT(r)==(TInt)(KMaxTUint32-1));

	// *= 

	test.Next(_L("*="));

	r=KMaxTUint32;			// ffffffff * 2 = 1 fffffffe

	r*=2;

	test(I64HIGH(r)==1 && I64LOW(r)==KMaxTUint32-1);

	r=KMaxTUint32-1;

	r*=2;

	r+=2;

	test(I64HIGH(r)==1 && I64LOW(r)==KMaxTUint32-1);

	r=KMaxTUint32;

	r+=1;