// Copyright (c) 1996-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_r64.cpp

// T_R64.CPP - Test routines for TReal64

// Also note that these tests do not generally include testing of special values.  This is done

// in T_R96 tests and conversions are tested thoroughly, so explicit tests are unnecessary here.

// 

//

#include "t_math.h"

#include "t_vals.h"

#include "t_real64.h"

// Data for tests from T_R64DTA.cpp 

GLREF_D TReal64 addInput[];

GLREF_D TReal64 subInput[];

GLREF_D TReal64 multInput[];

GLREF_D TReal64 divInput[];

GLREF_D TReal64 divDenormalInput[];

GLREF_D TReal64 unaryInput[];

GLREF_D TReal64 incDecInput[];

GLREF_D TInt sizeAdd;

GLREF_D TInt sizeSub;

GLREF_D TInt sizeMult;

GLREF_D TInt sizeDiv;

GLREF_D TInt sizeDivDenormal;

GLREF_D TInt sizeUnary;

GLREF_D TInt sizeIncDec;

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

// Functions from EMGCC64.CPP

GLREF_C TReal64 __adddf3(TReal64 a1,TReal64 a2);

GLREF_C TReal64 __subdf3(TReal64 a1,TReal64 a2);

GLREF_C TReal64 __muldf3(TReal64 a1,TReal64 a2);

GLREF_C TReal64 __divdf3(TReal64 a1,TReal64 a2);

#endif

// Special numbers for arithmetic tests

GLDEF_D TReal64 endsInFour;

GLDEF_D TReal64 arg1;

GLDEF_D TReal64 arg2;

GLDEF_D TReal64 arg3;

GLDEF_D const TReal64 KMinDenormalTReal64=5E-324;

GLDEF_D const TReal KNaNTReal=TReal(KNaNTReal64);

GLDEF_D const TReal KPosInfTReal=TReal(KPosInfTReal64);;

GLDEF_D const TReal KNegInfTReal=TReal(KNegInfTReal64);;

GLDEF_D const TReal KMinDenormalTReal=5E-324;

enum TOrder

	{

	ELessThan,

	EEqual,

	EGreaterThan

	};

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

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

LOCAL_C void testConstants()

//

// Checks that constants are defined as expected in WINS, in case low and high words are swapped

//

	{

	test(TRealX(TReal32(KMinTReal32in64))==TRealX(KMinTReal32));

	test(TRealX(TReal32(KMaxTReal32in64))==TRealX(KMaxTReal32));

	}

#endif

LOCAL_C void initSpecialValues()

//

// Initialise special values, etc

//

	{

	SReal64* p64=(SReal64*)&endsInFour;

	p64->sign=0;

	p64->exp=1020;

	p64->msm=0;

	p64->lsm=0x4;

	p64=(SReal64*)&arg1;

	p64->sign=0;

	p64->exp=1075;

	p64->msm=0x20000;

	p64->lsm=0;

	p64=(SReal64*)&arg2;

	p64->sign=0;

	p64->exp=1075;

	p64->msm=0;

	p64->lsm=0x2a;

	p64=(SReal64*)&arg3;

	p64->sign=0;

	p64->exp=970;

	p64->msm=0xc71c7;

	p64->lsm=0x1c71c71c;

	}

LOCAL_C void testConvert()

//

// Test conversion from TReal to TReal64

// N.B. Conversions between TRealX and TReal64 are tested by t_r96.cpp 

//

	{

	const TReal input[]=

		{

		KMaxTReal,KMinTReal,-KMaxTReal,-KMinTReal,

		1.7976931348622E+308,-1.7976931348622E+308,2.2250738585073E-308,-2.2250738585073E-308,

		KMaxTReal32inTReal,KMinTReal32inTReal,-KMaxTReal32inTReal,-KMinTReal32inTReal,

		0.0,64.5,-64.5,1.54E+180,-1.54E+180,4.72E-225,-4.72E-225,

		KNegZeroTReal,KPosInfTReal,KNegInfTReal,KMinDenormalTReal,

		1.2345E-318,-2.4682E-321,1.0E-323,-2.0E-308

		};

	const TReal64 expect[]=

		{

		KMaxTReal64,KMinTReal64,-KMaxTReal64,-KMinTReal64,

		1.7976931348622E+308,-1.7976931348622E+308,2.2250738585073E-308,-2.2250738585073E-308,

		KMaxTReal32in64,KMinTReal32in64,-KMaxTReal32in64,-KMinTReal32in64,			

		0.0,64.5,-64.5,1.54E+180,-1.54E+180,4.72E-225,-4.72E-225,

		KNegZeroTReal64,KPosInfTReal64,KNegInfTReal64,KMinDenormalTReal64,

		1.2345E-318,-2.4682E-321,1.0E-323,-2.0E-308

		};		  

	TInt size = sizeof(input)/sizeof(TReal);

	TRealX f;

	for (TInt ii=0; ii<size; ii++)

		{

		f=TRealX(TReal64(TRealX(input[ii])));

		test(f==TRealX(expect[ii]));

		}

	// NaN

	TReal a=KNaNTReal;

//	TReal64 b=KNaNTReal64;

	f=TRealX(TReal64(TRealX(a)));

//	test(f!=TRealX(b));

	test(f.IsNaN());

	}

LOCAL_C void testAdd()

//

//	Addition tests

//

	{

	TReal64 f,g,h,y;

	TRealX ff,gg,hh;

	for (TInt ii=0; ii<sizeAdd-1; ii++)

		{

		f=addInput[ii];

		g=addInput[ii+1];

		ff=TRealX(f);

		gg=TRealX(g);

		// Test commute

		test(f+g == g+f);

		// Test PC real addition using fp-hardware same as TRealX addition

		h=f+g;

		hh=ff+gg;

		y=(TReal64)hh;	// need to do this since TRealX has too much precision

		test(y==h);

		h=g+f;

		hh=gg+ff;

		y=(TReal64)hh;	// need to do this since TRealX has too much precision

		test(y==h);

		// Test hex-encoded constants for TReal64s generated on PC using fp-hardware same as 

		// TRealX addition

		test(*(TReal64*)&addArray[ii]==f+g);

		test(*(TReal64*)&addArray[ii]==g+f);

		// similarly to tests above ...

		h=g;

		hh=gg;

		h+=f;

		hh+=ff;

		test(h==(TReal64)hh);

		test(*(TReal64*)&addArray[ii]==h);

		//

		h=f;

		hh=ff;

		h+=g;

		hh+=gg;

		test(h==(TReal64)hh);

		test(*(TReal64*)&addArray[ii]==h);

		}

	}

LOCAL_C void testSub()

//

// Subtraction tests - see notes in addition test above

//

	{

	TReal64 f,g,h;

	TRealX ff,gg,hh;

	for (TInt ii=0; ii<sizeSub-1; ii++)

		{

		f=subInput[ii];

		g=subInput[ii+1];

		ff=TRealX(f);

		gg=TRealX(g);

		//

		test(f-g == -(g-f));

		//

		test(TRealX(f-g)==ff-gg);

		test(TRealX(g-f)==gg-ff);

		test(*(TReal64*)&subArray[ii]==f-g);

		test(*(TReal64*)&subArray[ii]==-(g-f));

		//

		h=g;

		hh=gg;

		test(TRealX(h-=f)==(hh-=ff));

		test(TRealX(h)==hh);

		test(*(TReal64*)&subArray[ii]==-h);

		//

		h=f;

		hh=ff;

		test(TRealX(h-=g)==(hh-=gg));

		test(TRealX(h)==hh);

		test(*(TReal64*)&subArray[ii]==h);

		}

	}

LOCAL_C void testMult()

//

//	Multiplication test

//

	{

	TReal64 f,g,h;

	TRealX ff,gg,hh;

	for (TInt ii=0; ii<sizeMult-1; ii++)

		{

		f=multInput[ii];

		g=multInput[ii+1];

		ff=TRealX(f);

		gg=TRealX(g);

		//

		test(f*g == g*f);

		//

		test(TRealX(f*g)==ff*gg);

		test(TRealX(g*f)==gg*ff);

		test(*(TReal64*)&multArray[ii]==f*g);

		test(*(TReal64*)&multArray[ii]==g*f);

		//

		h=f;		

		hh=ff;

		test(TRealX(h*=g)==(hh*=gg));

		test(TRealX(h)==hh);

		test(*(TReal64*)&multArray[ii]==h);

		//

		h=g;

		hh=gg;

		test(TRealX(h*=f)==(hh*=ff));

		test(TRealX(h)==hh);

		test(*(TReal64*)&multArray[ii]==h);

		}

	}

LOCAL_C void testDiv()

//

//	Division tests

//

	{

	TReal64 f,g,h;

	TRealX ff,gg,hh;

	TInt count=0;

	// Panic (under ARM) - Divide by Zero - run in DEBUG build as a check only

	//f=1.0;

	//g=0.0;

	//f/=g;

	for (TInt ii=0; ii<sizeDiv-1; ii++)

		{

		f=divInput[ii];

		g=divInput[ii+1];

		ff=TRealX(f);

		gg=TRealX(g);

		if (g!=0.0)

			{

			test(TRealX(f/g)==ff/gg);

			test(*(TReal64*)&divArray[count]==f/g);

			//

			h=f;

			hh=ff;

			test(TRealX(h/=g)==(hh/=gg));

			test(TRealX(h)==hh);

			test(*(TReal64*)&divArray[count]==h);

			++count;

			}							   

		if (f!=0.0)

			{

			test(TRealX(g/f)==gg/ff);

			//

			h=g;

			hh=gg;

			test(TRealX(h/=f)==(hh/=ff));

			test(TRealX(h)==hh);

			}

		}

	gg=TRealX(arg2)/TRealX(arg3);

	//Additional test

	f=3.999999999999999;

	g=KMinTReal64;

	ff=TRealX(f);

	gg=TRealX(g);

	test(TRealX(f/g)==ff/gg);

	h=f;

	test(TRealX(h/=g)==ff/gg);

	test(TRealX(h)==ff/gg);

	}

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

LOCAL_C	 void testArithmeticExceptionRaising()

//

// Test that UP_GCC.CPP raise exceptions correctly by calling functions from EMGCC64.CPP which

// are copies of those in UP_GCC.CPP.  To be used in debugger only.

// Added by AnnW, December 1996

//

	{

	TReal64 f,g,h;

	// Addition - possible errors are argument, overflow, or none

	// NB cannot achieve underflow now denormals in use

	f=KNaNTReal64;

	h=__adddf3(f,f);	// argument

	f=KMaxTReal64;

	h=__adddf3(f,f);	// overflow

	f=1.0;

	g=2.0;

	h=__adddf3(f,g);	// none

	test(h==3.0);

	// Subtraction - possible errors are argumnet, overflow or none

	// NB cannot achieve underflow now denormals in use

	f=KNaNTReal64;

	h=__subdf3(f,f);	// argument

	f=KMaxTReal64;

	g=-KMaxTReal64;

	h=__subdf3(f,g);	// overflow

	f=1.0;

	g=2.0;

	h=__subdf3(f,g);	// none

	test(h==-1.0);

	// Multiplication - possible errors are argument, overflow, underflow or none

	f=KNaNTReal64;

	h=__muldf3(f,f);	// argument

	f=KMaxTReal64;

	g=2.0;

	h=__muldf3(f,g);	// overflow

	f=KMinDenormalTReal64;

	g=0.1;

	h=__muldf3(f,g);	// underflow

	f=1.0;

	g=2.0;

	h=__muldf3(f,g);	// none

	test(h==2.0);

	// Division - possible errors are overflow, underflow, divide by zero, argument or none

	f=KMaxTReal64;

	g=0.5;

	h=__divdf3(f,g);	// overflow

	f=KMinDenormalTReal64;

	g=10.0;

	h=__divdf3(f,g);	// underflow

	f=4.0;

	g=0.0;

	h=__divdf3(f,g);	// divide by zero

	f=0.0;

	g=0.0;

	h=__divdf3(f,g);	// argument

	f=1.0;

	g=2.0;

	h=__divdf3(f,g);	// none

	test(h==0.5);

	}

#endif

LOCAL_C void testUnary()

//

//	Unary operator tests

//

	{

	TReal64 f;

	TRealX g;

	for (TInt ii=0; ii<sizeUnary-1; ii++)

		{

		f=unaryInput[ii];

		g=TRealX(f);

		test(TRealX(-f)==-g);

		test(TRealX(-f)==TRealX(0-f));

		test(TRealX(+f)==g);

		test(TRealX(+f)==TRealX(0+f));

		test(*(TReal64*)&unaryArray[ii]==-f);

		}

	}

LOCAL_C void testEqualities(const TReal& aA, TOrder aOrder, const TReal& aB)

//

//	Test equality/inequality functions on aA and aB

//	aOrder specifies the operand's relative sizes

//

	{

	//	Tautologies

	test((aA>aA) ==FALSE);

	test((aA<aA) ==FALSE);

	test((aA>=aA)==TRUE);

	test((aA<=aA)==TRUE);

	test((aA==aA)==TRUE);

	test((aA!=aA)==FALSE);

	if (aOrder!=EEqual)

		{

		test((aA==aB)==FALSE);

  		test((aA!=aB)==TRUE);

		}

	if (aOrder==ELessThan)

		{

		test((aA<aB) ==TRUE);

		test((aA<=aB)==TRUE);

		test((aA>aB) ==FALSE);

		test((aA>=aB)==FALSE);

		}

	if (aOrder==EEqual)

		{

		test((aA==aB)==TRUE);

		test((aA!=aB)==FALSE);

		test((aA>=aB)==TRUE);

		test((aA<=aB)==TRUE);

		test((aA>aB)==FALSE);

		test((aA<aB)==FALSE);

		}

	if (aOrder==EGreaterThan)

		{

		test((aA>aB) ==TRUE);

		test((aA>=aB)==TRUE);

		test((aA<aB) ==FALSE);

		test((aA<=aB)==FALSE);

		}

	}

LOCAL_C void testEqualities()

//

//	Test >, <, >=, <=, ==, !=

//

	{

	TInt i, size;

	TReal64 lessThanMax = KMaxTReal64-TReal64(1.0E+294);

	TReal64 greaterThanMin = TReal64(2.225075E-308);

	TReal64 zero(0.0);

	TReal64 positive[] =

	{KMinTReal64,5.3824705392348592E-138,1.0,2387501,5.3824705392348592E+138,KMaxTReal64};

	TReal64 large[] =

	{2.0,KMaxTReal64,-lessThanMax,greaterThanMin,-KMinTReal64,10.40584821945060,-10.40584821945058,

	1.244334567201E+105,1.244334567201E+105,-1.3420344230402E-106,132435.97865,5.0E-16,9.6,-8.0}; 

	TReal64 small[] =

	{1.0,lessThanMax,-KMaxTReal64,KMinTReal64,-greaterThanMin,10.40584821945058,-10.40584821945060,

	50E-100,1.244334567201E+104,-5.03824705392348592E+58,-132435.97865,-5.1E-16,8.0,-9.6};

	TReal64 equal[] =							  // Same as large[]

	{2.0,KMaxTReal64,-lessThanMax,greaterThanMin,-KMinTReal64,10.40584821945060,-10.40584821945058,

	1.244334567201E+105,1.244334567201E+105,-1.3420344230402E-106,132435.97865,5.0E-16,9.6,-8.0}; 

	// Tests with zero

	size = sizeof(positive)/sizeof(TReal64);

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

	testEqualities(zero, EEqual, zero);

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

		{

		testEqualities(positive[i], EGreaterThan, zero);

		testEqualities(-positive[i], ELessThan, zero);

		testEqualities(zero, ELessThan, positive[i]);

		testEqualities(zero, EGreaterThan, -positive[i]);

		}

	// Test boundary and other numbers

	size = sizeof(large)/sizeof(TReal64);

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

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

		{

		testEqualities(large[i], EGreaterThan, small[i]);

		testEqualities(small[i], ELessThan, large[i]);

		testEqualities(large[i], EEqual, equal[i]);

		}

	test.End();

	}

LOCAL_C void testIncDec()

//

//	Test Pre/Post-increment/decrement

//

	{

	TInt ii;

	TReal64 f;

	TRealX g;

	test.Start(_L("Pre-increment"));

	for (ii=0; ii<sizeIncDec; ii++)

		{

		f=incDecInput[ii];

		g=TRealX(f);

		test(TRealX(f)==g);

		test(TRealX(++f)==(++g));

		test(*(TReal64*)&preIncArray1[ii]==f);

		test(TRealX(f)==g);

		test(TRealX(++f)==(++g));

		test(*(TReal64*)&preIncArray2[ii]==f);

		test(TRealX(f)==g);

		}

	test.Next(_L("Post-increment"));

	for (ii=0; ii<sizeIncDec; ii++)

		{

		f=incDecInput[ii];

		g=TRealX(f);

		test(TRealX(f)==g);

		test(TRealX(f++)==(g++));

		test(*(TReal64*)&postIncArray1[ii]==f);

		test(TRealX(f)==g);

		test(TRealX(f++)==(g++));

		test(*(TReal64*)&postIncArray2[ii]==f);

		test(TRealX(f)==g);

		}

	test.Next(_L("Pre-decrement"));

	for (ii=0; ii<sizeIncDec; ii++)

		{

		f=incDecInput[ii];

		g=TRealX(f);

		test(TRealX(f)==g);

		test(TRealX(--f)==(--g));

		test(*(TReal64*)&preDecArray1[ii]==f);

		test(TRealX(f)==g);

		test(TRealX(--f)==(--g));

		test(*(TReal64*)&preDecArray2[ii]==f);

		test(TRealX(f)==g);

		}

	test.Next(_L("Post-decrement"));

	for	(ii=0; ii<sizeIncDec; ii++)

		{

		f=incDecInput[ii];

		g=TRealX(f);

		test(TRealX(f)==g);

		test(TRealX(f--)==(g--));

		test(*(TReal64*)&postDecArray1[ii]==f);

		test(TRealX(f)==g);

		test(TRealX(f--)==(g--));

		test(*(TReal64*)&postDecArray2[ii]==f);

		test(TRealX(f)==g);

		}

	test.End();

	}

LOCAL_C void _matherr(TExcType aType)

//

// Dummy function to handle exceptions

//

	{

	test.Printf(_L("_matherr: Exception type %u handled\n"),TUint(aType));

	}

GLDEF_C TInt E32Main()

//

//	Test TReal64

//

    {	  

	test.Title();

#if defined (__X86__)

	TInt16 cw=0;

	_asm fstcw cw;

	test.Printf(_L("control word = 0x%x\n"),cw);

	cw=0x27f;	// WINS value

	_asm fldcw cw;

#endif

	// Set exceptions to be handled

	RThread myThread;

	myThread.SetExceptionHandler(_matherr,KExceptionFpe);

	initSpecialValues();

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

	test.Start(_L("Checking double words not swapped..."));

	testConstants();

	test.Next(_L("Conversion from TReal to TReal64"));

	testConvert();

#else

	test.Start(_L("Conversion from TReal to TReal64"));

	testConvert();

#endif

	test.Next(_L("Conversion from TReal to TReal64"));

	testConvert();

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

	testAdd();

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

	testSub();

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

	testMult();

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

	testDiv();

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

	test.Next(_L("Arithmetic which emulates UP_GCC and raises an exception"));

	testArithmeticExceptionRaising();

#endif

	test.Next(_L("Unary Operations"));

	testUnary();

	test.Next(_L("Equalities and Inequalities"));

	testEqualities();

	test.Next(_L("Increment and Decrement"));

	testIncDec();

	test.End();

	return(KErrNone);

    }