// Copyright (c) 1997-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_realx.cpp

// T_REALX.CPP - Test routines for TRealX

// Overview:

// Test the functionality of a class that encapsulates 64 bit extended precision

// real values.

// API Information:

// TRealX 

// Details:

// - Test the constructor and assignment operator with signed, unsigned, 64 bit

// integer, float and double values.

// - Check the conversion of TRealX value to signed, unsigned, 64 bit integer,

// float and double values is as expected.

// - Set TRealX variable with some special values and check it is as expected.

// - Test addition, multiplication, division of TRealX values is as expected.

// - Test Unary operators, comparison of two TRealX values are as expected.

// Platforms/Drives/Compatibility:

// All 

// Assumptions/Requirement/Pre-requisites:

// Failures and causes:

// Base Port information:

// 

//

#include <e32std.h>

#include <e32std_private.h>

#include <e32test.h>

#include <e32math.h>

#include "t_realxd.h"

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

// Conversion functions TInt64 <-> TReal64

LOCAL_C void TReal64ToTInt64(TInt64 *aDest, const TReal64 *aSrc)

	{

	TInt *pD=(TInt*)aDest;

	const TInt *pS=(TInt*)aSrc;

#ifdef __DOUBLE_WORDS_SWAPPED__

	pD[1]=pS[0];		// word containing sign,exp

	pD[0]=pS[1];

#else

	pD[1]=pS[1];		// word containing sign,exp

	pD[0]=pS[0];

#endif

	}

LOCAL_C void TInt64ToTReal64(TReal64 *aDest, const TInt64 *aSrc)

	{

	TInt *pD=(TInt*)aDest;

	const TInt *pS=(TInt*)aSrc;

#ifdef __DOUBLE_WORDS_SWAPPED__

	pD[0]=pS[1];		// word containing sign,exp

	pD[1]=pS[0];

#else

	pD[1]=pS[1];		// word containing sign,exp

	pD[0]=pS[0];

#endif

	}

// Test functions

SRealX::SRealX(TUint a, TUint b, TUint c)

	{

	iExpFlagSign=a;

	iMantHigh=b;

	iMantLow=c;

	}

SRealX::SRealX(const TRealX& aRealX)

	{

	const TUint *pR = (const TUint *)&aRealX;

	iExpFlagSign=pR[2];

	iMantHigh=pR[1];

	iMantLow=pR[0];

	}

SRealX& SRealX::operator=(const TRealX& aRealX)

	{

	const TUint *pR = (const TUint *)&aRealX;

	iExpFlagSign=pR[2];

	iMantHigh=pR[1];

	iMantLow=pR[0];

	return *this;

	}

SRealX::operator TRealX() const

	{

	TRealX r;

	TUint *pR=(TUint *)&r;

	pR[2]=iExpFlagSign;

	pR[1]=iMantHigh;

	pR[0]=iMantLow;

	return r;

	}

TBool SRealX::operator==(const SRealX& aSRealX) const

	{

	TUint e1=iExpFlagSign >> 16;

	TUint e2=aSRealX.iExpFlagSign >> 16;

	TUint s1=iExpFlagSign & 0x00000001;

	TUint s2=aSRealX.iExpFlagSign & 0x00000001;

	TUint f1=iExpFlagSign & 0x00000300;

	TUint f2=aSRealX.iExpFlagSign & 0x00000300;

	return( e1==e2 && s1==s2 && (e1==0 || (f1==f2 && iMantHigh==aSRealX.iMantHigh && iMantLow==aSRealX.iMantLow)) );

	}

SConvertFrom32BitTest::SConvertFrom32BitTest(TInt op, const SRealX& res, TInt r)

	{

	iOperand=op;

	iResult=res;

	iReturnCode=r;

	}

void SConvertFrom32BitTest::Test(TConversionFrom32Bits aConversion) const

	{

	TInt r=iReturnCode;

	SRealX sr;

	switch(aConversion)

		{

		case EConstructInt:

			{

			TRealX x(iOperand);

			sr=(SRealX)x;

			break;

			}

		case EAssignInt:

			{

			TRealX x;

			x=iOperand;

			sr=(SRealX)x;

			break;

			}

		case ESetInt:

			{

			TRealX x;

			r=x.Set(iOperand);

			sr=(SRealX)x;

			break;

			}

		case EConstructUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x(uint);

			sr=(SRealX)x;

			break;

			}

		case EAssignUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x;

			x=uint;

			sr=(SRealX)x;

			break;

			}

		case ESetUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x;

			r=x.Set(uint);

			sr=(SRealX)x;

			break;

			}

		case EConstructFloat:

			{

			TReal32 f;

			TInt *pF=(TInt*)&f;

			*pF=iOperand;

			TRealX x(f);

			sr=(SRealX)x;

			break;

			}

		case EAssignFloat:

			{

			TReal32 f;

			TInt *pF=(TInt*)&f;

			*pF=iOperand;

			TRealX x;

			x=f;

			sr=(SRealX)x;

			break;

			}

		case ESetFloat:

			{

			TReal32 f;

			TInt *pF=(TInt*)&f;

			*pF=iOperand;

			TRealX x;

			r=x.Set(f);

			sr=(SRealX)x;

			break;

			}

		}

	if (sr==iResult && r==iReturnCode)

		return;

	test.Printf(_L("Conversion %d from 32 bit operand test failed\noperand = %08X\n"),

		(TInt)aConversion, iOperand );

	test.Printf(_L("Result %08X %08X %08X\nReturn code %d\n"),

		sr.iExpFlagSign, sr.iMantHigh, sr.iMantLow, r );

	test.Printf(_L("Correct result %08X %08X %08X\nCorrect return code %d\n"),

		iResult.iExpFlagSign, iResult.iMantHigh, iResult.iMantLow, iReturnCode );

	//test.Getch();

	test(0);

	}

SConvertFrom64BitTest::SConvertFrom64BitTest(TInt64 op, const SRealX& res, TInt r)

	{

	iOperand=op;

	iResult=res;

	iReturnCode=r;

	}

void SConvertFrom64BitTest::Test(TConversionFrom64Bits aConversion) const

	{

	TInt r=iReturnCode;

	SRealX sr;

	switch(aConversion)

		{

		case EConstructInt64:

			{

			TRealX x(iOperand);

			sr=(SRealX)x;

			break;

			}

		case EAssignInt64:

			{

			TRealX x;

			x=iOperand;

			sr=(SRealX)x;

			break;

			}

		case ESetInt64:

			{

			TRealX x;

			r=x.Set(iOperand);

			sr=(SRealX)x;

			break;

			}

/*		case EConstructUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x(uint);

			sr=(SRealX)x;

			break;

			}

		case EAssignUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x;

			x=uint;

			sr=(SRealX)x;

			break;

			}

		case ESetUint:

			{

			TUint uint=(TUint)iOperand;

			TRealX x;

			r=x.Set(uint);

			sr=(SRealX)x;

			break;

			}*/

		case EConstructDouble:

			{

			TReal64 d;

			TInt64ToTReal64(&d, &iOperand);

			TRealX x(d);

			sr=(SRealX)x;

			break;

			}

		case EAssignDouble:

			{

			TReal64 d;

			TInt64ToTReal64(&d, &iOperand);

			TRealX x;

			x=d;

			sr=(SRealX)x;

			break;

			}

		case ESetDouble:

			{

			TReal64 d;

			TInt64ToTReal64(&d, &iOperand);

			TRealX x;

			r=x.Set(d);

			sr=(SRealX)x;

			break;

			}

		}

	if (sr==iResult && r==iReturnCode)

		return;

	test.Printf(_L("Conversion %d from 64 bit operand test failed\noperand = %08X %08X\n"),

		(TInt)aConversion, I64HIGH(iOperand), I64LOW(iOperand) );

	test.Printf(_L("Result %08X %08X %08X\nReturn code %d\n"),

		sr.iExpFlagSign, sr.iMantHigh, sr.iMantLow, r );

	test.Printf(_L("Correct result %08X %08X %08X\nCorrect return code %d\n"),

		iResult.iExpFlagSign, iResult.iMantHigh, iResult.iMantLow, iReturnCode );

	//test.Getch();

	test(0);

	}

SConvertTo32BitTest::SConvertTo32BitTest(const SRealX& op, TInt res, TInt r)

	{

	iOperand=op;

	iResult=res;

	iReturnCode=r;

	}

void SConvertTo32BitTest::Test(TConversionTo32Bits aConversion) const

	{

	TInt r=iReturnCode;

	TRealX op=(TRealX)iOperand;

	TInt result=0;

	switch(aConversion)

		{

		case EOperatorInt:

			result=(TInt)op;

			break;

		case EOperatorUint:

			{

			TUint uint;

			uint=(TUint)op;

			result=(TInt)uint;

			break;

			}

		case EOperatorTReal32:

			{

			TReal32 x;

			x=(TReal32)op;

			result=*((TInt*)&x);

			break;

			}

		case EGetTReal32:

			{

			TReal32 x;

			r=op.GetTReal(x);

			result=*((TInt*)&x);

			break;

			}

		}

	if (result==iResult && r==iReturnCode)

		return;

	test.Printf(_L("Conversion %d to 32 bit operand test failed\noperand = %08X %08X %08X\n"),

		(TInt)aConversion, iOperand.iExpFlagSign, iOperand.iMantHigh, iOperand.iMantLow );

	test.Printf(_L("Result %08X\nReturn code %d\n"),

		result, r );

	test.Printf(_L("Correct result %08X\nCorrect return code %d\n"),

		iResult, iReturnCode );

	//test.Getch();

	test(0);

	}

SConvertTo64BitTest::SConvertTo64BitTest(const SRealX& op, TInt64 res, TInt r)

	{

	iOperand=op;

	iResult=res;

	iReturnCode=r;

	}

void SConvertTo64BitTest::Test(TConversionTo64Bits aConversion) const

	{

	TInt r=iReturnCode;

	TRealX op=(TRealX)iOperand;

	TInt64 result=0;

	switch(aConversion)

		{

		case EOperatorInt64:

			result=op.operator TInt64();  // odd conversion syntax required for VC5 compilation

			break;

		case EOperatorTReal64:

			{

			TReal64 d;

			d=(TReal64)op;

			TReal64ToTInt64(&result, &d);

			break;

			}

		case EGetTReal64:

			{

			TReal64 d;

			r=op.GetTReal(d);

			TReal64ToTInt64(&result, &d);

			break;

			}

		}

	if (result==iResult && r==iReturnCode)

		return;

	test.Printf(_L("Conversion %d to 64 bit operand test failed\noperand = %08X %08X %08X\n"),

		(TInt)aConversion, iOperand.iExpFlagSign, iOperand.iMantHigh, iOperand.iMantLow );

	test.Printf(_L("Result %08X %08X\nReturn code %d\n"),

		I64HIGH(result), I64LOW(result), r );

	test.Printf(_L("Correct result %08X %08X\nCorrect return code %d\n"),

		I64HIGH(iResult), I64LOW(iResult), iReturnCode );

	//test.Getch();

	test(0);

	}

SCompareTest::SCompareTest(const SRealX& o1, const SRealX& o2, TInt r)

	{

	iOperand1=o1;

	iOperand2=o2;

	iReturnCode=r;

	}

void SCompareTest::Test() const

	{

	TRealX op1=(TRealX)iOperand1;

	TRealX op2=(TRealX)iOperand2;

	TRealX::TRealXOrder r=op1.Compare(op2);

	TBool lt=op1<op2;

	TBool le=op1<=op2;

	TBool gt=op1>op2;

	TBool ge=op1>=op2;

	TBool eq=op1==op2;

	TBool ne=op1!=op2;

	if ((TInt)r==iReturnCode)

		{

		switch(r)

			{

			case TRealX::ELessThan:

				if (lt && le && !gt && !ge && !eq && ne)

					return;

				break;

			case TRealX::EEqual:

				if (!lt && le && !gt && ge && eq && !ne)

					return;

				break;

			case TRealX::EGreaterThan:

				if (!lt && !le && gt && ge && !eq && ne)

					return;

				break;

			case TRealX::EUnordered:

				if (!lt && !le && !gt && !ge && !eq && ne)

					return;

				break;

			}

		}

	test.Printf(_L("Compare test failed\nop1 = %08X %08X %08X\nop2 = %08X %08X %08X\n"),

		iOperand1.iExpFlagSign, iOperand1.iMantHigh, iOperand1.iMantLow,

		iOperand2.iExpFlagSign, iOperand2.iMantHigh, iOperand2.iMantLow );

	test.Printf(_L("Return code %d\nlt=%d, le=%d, gt=%d, ge=%d, eq=%d, ne=%d\n"),

		r, lt, le, gt, ge, eq, ne );

	//test.Getch();

	test(0);

	}

SOneOpTest::SOneOpTest(const SRealX& op, const SRealX& res, TInt r)

	{

	iOperand=op;

	iResult=res;

	iReturnCode=r;

	}

TInt SOneOpTest::DoTest(TUnaryOperation anOperation, TRealX *aResult) const

	{

	TInt r=KErrNone;

	TRealX op;

	*aResult=(TRealX)iOperand;

	switch(anOperation)

		{

		case EUnaryPlus:

			*aResult=+(*aResult);

			break;

		case EUnaryMinus:

			*aResult=-(*aResult);

			break;

		case EPreInc:

			++*aResult;

			break;

		case EPreDec:

			--*aResult;

			break;

		case EPostInc:

			op=(*aResult)++;

			if (!(SRealX(op)==iOperand))

				r=KErrGeneral;

			break;

		case EPostDec:

			op=(*aResult)--;

			if (!(SRealX(op)==iOperand))

				r=KErrGeneral;

			break;

		}

	return r;

	}

TInt OneOpTestThreadFunction(TAny *anInfo)

	{

	SOneOpTestThreadInfo *pI=(SOneOpTestThreadInfo *)anInfo;

	TInt r=pI->iTest->DoTest(pI->iOperation,pI->iResult);

	return r;

	}

void SOneOpTest::Test(TUnaryOperation anOperation) const

	{

	SOneOpTestThreadInfo info;

	TRealX result;

	info.iTest=this;

	info.iOperation=anOperation;

	info.iResult=&result;

	RThread t;

	TInt r=t.Create(_L("TestThread"),OneOpTestThreadFunction,0x1000,0x1000,0x100000,&info);

	test(r==KErrNone);

	t.SetPriority(EPriorityMore);	// so we will not run again until thread terminates

	TRequestStatus s;

	t.Logon(s);

	t.Resume();

	User::WaitForRequest(s);

	TExitType exittype=t.ExitType();

	r=s.Int();

	CLOSE_AND_WAIT(t);

	SRealX sr(result);

	if (sr==iResult && r==iReturnCode)

		{

		if (anOperation>EUnaryMinus)

			{

			if (r==KErrNone && exittype==EExitKill)

				return;