diff -r c55016431358 -r 0a7b44b10206 symport/e32test/math/t_i64_2.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/e32test/math/t_i64_2.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,484 @@
+// 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);
+    }
+