// 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 "Symbian Foundation License v1.0"

// which accompanies this distribution, and is available

// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".

//

// Initial Contributors:

// Nokia Corporation - initial contribution.

//

// Contributors:

//

// Description:

// e32test\math\t_i64_2.cpp

// Overview:

// Test 64-bit integer functionality.

// API Information:

// TInt64, TUInt64.

// Details:

// - Construct TInt64 and TUInt64 and verify the results.

// - Test the unary and shift operators and check results are as expected.

// - Test the  + - * / and % operators, verify results are as expected.

// - Test the  + - * / and % operators with random numbers, verify results 

// are as expected.

// - Test the conversion of TInt64 to/from TReal. Verify that the results

// are as expected.

// - Test the conversion of TInt64 to/from text. Verify that the results

// are as expected.

// Platforms/Drives/Compatibility:

// All.

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32test.h>

#include <e32math.h>

#include "largeint.h"

#include "../misc/prbs.h"

typedef TLargeInt<2> I64;

typedef TLargeInt<4> I128;

RTest test(_L("T_I64_2"));

TUint Seed[2];

TUint64 Random64()

	{

	TUint h = Random(Seed);

	TUint l = Random(Seed);

	return MAKE_TUINT64(h,l);

	}

#define BOOL(x)	((x)?1:0)

#define FOREACH(p, table, esize)	\

	for(p=table; p<(const TUint32*)((const TUint8*)table+sizeof(table)); p+=esize/sizeof(TUint32))

const TUint32 Table1[] =

	{

	0x00000000, 0x00000000,

	0x00000001, 0x00000000,

	0x0000cc01, 0x00000000,

	0x00db2701, 0x00000000,

	0xcc9ffcd1, 0x00000000,

	0x00000000, 0xffffffff,

	0xeeeeeeee, 0xffffffff,

	0x04030201, 0x00000055,

	0x04030201, 0x00006655,

	0x04030201, 0x00776655,

	0x04030201, 0x33776655,

	0xf9de6484, 0xb504f333

	};

void Test1()

	{

	test.Next(_L("Unary operators and shifts"));

	const TUint32* p;

	FOREACH(p,Table1,8)

		{

		I64 a(p);

		TInt64 b = MAKE_TINT64(p[1], p[0]);

		I64 c(b);

		test(a==c);

		TUint64 d = MAKE_TUINT64(p[1], p[0]);

		I64 e(d);

		test(a==e);

		I64 c2(~b);

		I64 c3(-b);

		a.Not();

		test(c2==a);

		a.Not();

		test(c==a);

		a.Neg();

		test(c3==a);

		a.Neg();

		test(c==a);

		}

	FOREACH(p,Table1,8)

		{

		I64 a(p);

		TInt64 s = MAKE_TINT64(p[1], p[0]);

		TUint64 u = MAKE_TUINT64(p[1], p[0]);

		TInt n;

		for (n=0; n<64; ++n)

			{

			I64 b(a), c(a), d(a);

			b.Lsl(n), c.Lsr(n), d.Asr(n);

			TInt64 s2 = s<<n;

			TInt64 s3 = s>>n;

			TUint64 u2 = u<<n;

			TUint64 u3 = u>>n;

//			test.Printf(_L("s2=%lx\ns3=%lx\n,u2=%lx\n,u3=%lx\n"),s2,s3,u2,u3);

			test(b == I64(s2));

			test(b == I64(u2));

			test(c == I64(u3));

			test(d == I64(s3));

			}

		}

	}

const TUint32 Table2[] =

	{

	0x00000000, 0x00000000, 0x00000000, 0x00000000,

	0x00000001, 0x00000000, 0x00000000, 0x00000000,

	0x05f5e100, 0x00000000, 0x000000cb, 0x00000000,

	0xffffff9c, 0xffffffff, 0x00129cbb, 0x00000000,

	0xffffcd03, 0xffffffff, 0xffff9123, 0xffffffff,

	0xf9de6484, 0xb504f333, 0xf9de6484, 0xb504f333,

	0xf9de6484, 0xb504f333, 0x2168c235, 0xc90fdaa2,

	0xf9de6484, 0xb504f333, 0x000000cb, 0x00000000,

	0xf9de6484, 0xb504f333, 0x800000cb, 0x00000000,

	0xf9de6484, 0xb504f333, 0x000000cb, 0x00000001,

	0xf9de6484, 0xb504f333, 0xfffffed9, 0xffffffff,

	0xf9de6484, 0xb504f333, 0x197383db, 0xffffffff,

	0xf9de6484, 0xb504f333, 0x197383db, 0xffffffec,

	0x38aa3b29, 0x5c17f0bc, 0x000019c7, 0x00000000,

	0x38aa3b29, 0x5c17f0bc, 0x800019c7, 0x00000000,

	0x38aa3b29, 0x5c17f0bc, 0x000019c7, 0x00000003,

	0x38aa3b29, 0x5c17f0bc, 0x197383db, 0xffffffff,

	0x38aa3b29, 0x5c17f0bc, 0x197383db, 0xffffffec,

	0x00123456, 0x00000000, 0x8cb9fc1b, 0x00000000,

	0x00000123, 0x00000000, 0x8cb9fc1b, 0x0000cc9f,

	0xfffffe33, 0xffffffff, 0x8cb9fc1b, 0x0000cc9f

	};

void Test2(const TUint32* p)

	{

	I64 a(p), b(p+2);

	TInt64 x = MAKE_TINT64(p[1], p[0]);

	TInt64 y = MAKE_TINT64(p[3], p[2]);

	TUint64 u = MAKE_TUINT64(p[1], p[0]);

	TUint64 v = MAKE_TUINT64(p[3], p[2]);

	{

	I64 c(a); c.Add(b); test(c==I64(x+y)); test(c==I64(u+v));

	test(c==I64(y+x)); test(c==I64(v+u));

	}

	{

	I64 c(a); c.Sub(b); test(c==I64(x-y)); test(c==I64(u-v));

	I64 d(b); d.Sub(a); test(d==I64(y-x)); test(d==I64(v-u));

	}

	{

	I64 c(a); c.Mul(b); test(c==I64(x*y)); test(c==I64(u*v));

	test(c==I64(y*x)); test(c==I64(v*u));

	}

	{

	I128 c = a.LongMultS(b);

	TUint32 t[4];

	Math::Mul64(x, y, *(TInt64*)(t+2), *(TUint64*)t);

	test(c==I128(t));

	Math::Mul64(y, x, *(TInt64*)(t+2), *(TUint64*)t);

	test(c==I128(t));

	}

	{

	I128 c = a.LongMultU(b);

	TUint32 t[4];

	Math::UMul64(u, v, *(TUint64*)(t+2), *(TUint64*)t);

	test(c==I128(t));

	Math::UMul64(v, u, *(TUint64*)(t+2), *(TUint64*)t);

	test(c==I128(t));

	}

	if (y!=0)

		{

		I64 r; I64 q(a); q.DivS(b,r);

		test(q==I64(x/y));

		test(r==I64(x%y));

		TInt64 r2;

		TInt64 q2 = Math::DivMod64(x, y, r2);

		test(q==I64(q2));

		test(r==I64(r2));

		}

	if (x!=0)

		{

		I64 r; I64 q(b); q.DivS(a,r);

		test(q==I64(y/x));

		test(r==I64(y%x));

		TInt64 r2;

		TInt64 q2 = Math::DivMod64(y, x, r2);

		test(q==I64(q2));

		test(r==I64(r2));

		}

	if (v!=0)

		{

		I64 r; I64 q(a); q.DivU(b,r);

		test(q==I64(u/v));

		test(r==I64(u%v));

		TUint64 r2;

		TUint64 q2 = Math::UDivMod64(u, v, r2);

		test(q==I64(q2));

		test(r==I64(r2));

		}

	if (u!=0)

		{

		I64 r; I64 q(b); q.DivU(a,r);

		test(q==I64(v/u));

		test(r==I64(v%u));

		TUint64 r2;

		TUint64 q2 = Math::UDivMod64(v, u, r2);

		test(q==I64(q2));

		test(r==I64(r2));

		}

	{

	TInt cmpu = a.CompareU(b);

	TInt cmps = a.CompareS(b);

	TInt equ = BOOL(u==v);

	TInt neu = BOOL(u!=v);

	TInt hi = BOOL(u>v);

	TInt hs = BOOL(u>=v);

	TInt lo = BOOL(u<v);

	TInt ls = BOOL(u<=v);

	TInt eqs = BOOL(x==y);

	TInt nes = BOOL(x!=y);

	TInt gt = BOOL(x>y);

	TInt ge = BOOL(x>=y);

	TInt lt = BOOL(x<y);

	TInt le = BOOL(x<=y);

	test(equ==eqs);

	test(neu==nes);

	test(equ!=neu);

	if (cmpu>0)

		test(!equ && hi && hs && !lo && !ls);

	else if (cmpu<0)

		test(!equ && !hi && !hs && lo && ls);

	else

		test(equ && !hi && hs && !lo && ls);

	if (cmps>0)

		test(!eqs && gt && ge && !lt && !le);

	else if (cmps<0)

		test(!eqs && !gt && !ge && lt && le);

	else

		test(eqs && !gt && ge && !lt && le);

	}

	}

void Test2()

	{

	test.Next(_L("Test + - * / % (1)"));

	const TUint32* p;

	FOREACH(p,Table2,16)

		{

		Test2(p);

		}

	}

void Test3()

	{

	test.Next(_L("Test + - * / % (2)"));

	TInt i;

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

		{

		TUint32 p[4];

		p[0] = Random(Seed);

		p[1] = Random(Seed);

		p[2] = Random(Seed);

		p[3] = Random(Seed);

		Test2(p);

		}

	}

void Test4()

	{

	test.Next(_L("Test conversion to/from TReal"));

	TReal x;

	TReal limit=1048576.0*1048576.0*8192.0;

	TInt64 t22 = (TInt64)limit;

	test(t22 == TInt64(1)<<53);

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

	test(t23 == (TInt64(1)<<53)-1);

	TInt i;

	TInt64 l;

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

		{

		x=1;

		l=1;

		TReal a(i);

		TInt64 b(i);

		while (Abs(x)<limit)

			{

			TInt64 ll = (TInt64)x;

//			test.Printf(_L("r64 %g -> i64 %lx (%lx)\n"), x, ll, l);

			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;

			}

		}

	TReal i64limit = 1024.0*limit;

	l=MAKE_TINT64(0x7fffffff,0xfffffc00);

	x=(TReal)l;

	test(x==i64limit-1024.0);

	l=MAKE_TINT64(0x80000000,0x00000000);

	x=(TReal)l;

	test(x==-i64limit);

	l=MAKE_TINT64(0x80000000,0x00000400);

	x=(TReal)l;

	test(x==1024.0-i64limit);

	l=MAKE_TINT64(0x00000001,0x00000000);

	x=(TReal)l;

	test(x==65536.0*65536.0);

	l=MAKE_TINT64(0xffffffff,0x00000000);

	x=(TReal)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)

			{

			TReal y = (TReal)l;

			test(y==x);

			x*=a;

			l*=b;

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

				break;

			}

		}

	}

_LIT8(KTestHex8,"0 1 8 a 1b 2c7 10000000 100000000 1901cbfdc b504f333f9de6484 ffffffffffffffff");

_LIT16(KTestHex16,"0 1 8 a 1b 2c7 10000000 100000000 1901cbfdc b504f333f9de6484 ffffffffffffffff");

const TUint32 TestHexTable[] =

	{

	0x00000000, 0x00000000,

	0x00000001, 0x00000000,

	0x00000008, 0x00000000,

	0x0000000a, 0x00000000,

	0x0000001b, 0x00000000,

	0x000002c7, 0x00000000,

	0x10000000, 0x00000000,

	0x00000000, 0x00000001,

	0x901cbfdc, 0x00000001,

	0xf9de6484, 0xb504f333,

	0xffffffff, 0xffffffff

	};

_LIT8(KTestDec8,"0 1 8 100 6561 536870912 2147483648 4294967295 4294967296 549755813888 1000000000000000 9223372036854775807	\

					-9223372036854775808 -9223372036854775807 -9000000000000000000 -1099511627776 -4294967296 -1000 -1");

_LIT16(KTestDec16,"0 1 8 100 6561 536870912 2147483648 4294967295 4294967296 549755813888 1000000000000000 9223372036854775807	\

					-9223372036854775808 -9223372036854775807 -9000000000000000000 -1099511627776 -4294967296 -1000 -1");

const TUint32 TestDecTable[] =

	{

	0x00000000, 0x00000000,

	0x00000001, 0x00000000,

	0x00000008, 0x00000000,

	0x00000064, 0x00000000,

	0x000019a1, 0x00000000,

	0x20000000, 0x00000000,

	0x80000000, 0x00000000,

	0xffffffff, 0x00000000,

	0x00000000, 0x00000001,

	0x00000000, 0x00000080,

	0xa4c68000, 0x00038d7e,

	0xffffffff, 0x7fffffff,

	0x00000000, 0x80000000,

	0x00000001, 0x80000000,

	0x1d7c0000, 0x831993af,

	0x00000000, 0xffffff00,

	0x00000000, 0xffffffff,

	0xfffffc18, 0xffffffff,

	0xffffffff, 0xffffffff

	};

void Test5()

	{

	test.Next(_L("Test conversion to/from text"));

	TLex8 lex8;

	lex8.Assign(KTestHex8());

	TInt64 u;

	const TUint32* p = TestHexTable;

	for (; !lex8.Eos(); lex8.SkipSpace(), p+=2)

		{

		lex8.Mark();

		test(lex8.Val(u,EHex)==KErrNone);

		test(u == MAKE_TINT64(p[1], p[0]));

		TPtrC8 text = lex8.MarkedToken();

		TBuf8<64> b;

		b.Num(u,EHex);

		test(b==text);

		b.NumUC(u,EHex);

		TBuf8<64> uc = text;

		uc.UpperCase();

		test(b==uc);

		}

	lex8.Assign(KTestDec8());

	TInt64 s;

	p = TestDecTable;

	for (; !lex8.Eos(); lex8.SkipSpace(), p+=2)

		{

		lex8.Mark();

		test(lex8.Val(s)==KErrNone);

		test(s == MAKE_TINT64(p[1], p[0]));

		TPtrC8 text = lex8.MarkedToken();

		TBuf8<64> b;

		b.Num(s);

		test(b==text);

		}

	TLex16 lex16;

	lex16.Assign(KTestHex16());

	p = TestHexTable;

	for (; !lex16.Eos(); lex16.SkipSpace(), p+=2)

		{

		lex16.Mark();

		test(lex16.Val(u,EHex)==KErrNone);

		test(u == MAKE_TINT64(p[1], p[0]));

		TPtrC16 text = lex16.MarkedToken();

		TBuf16<64> b;

		b.Num(u,EHex);

		test(b==text);

		b.NumUC(u,EHex);

		TBuf16<64> uc = text;

		uc.UpperCase();

		test(b==uc);

		}

	lex16.Assign(KTestDec16());

	p = TestDecTable;

	for (; !lex16.Eos(); lex16.SkipSpace(), p+=2)

		{

		lex16.Mark();

		test(lex16.Val(s)==KErrNone);

		test(s == MAKE_TINT64(p[1], p[0]));

		TPtrC16 text = lex16.MarkedToken();

		TBuf16<64> b;

		b.Num(s);

		test(b==text);

		}

	}

GLDEF_C TInt E32Main()

    {

	Seed[0] = 0xb8aa3b29;

	Seed[1] = 0;

	test.Title();

	test.Start(_L("Testing 64 bit integers"));

	Test1();

	Test2();

	Test3();

	Test4();

	Test5();

	test.End();

	return(KErrNone);

    }