// 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_realxd.h

 // T_REALXD.H - Structure definitions for TRealX test

 // 

 //

 #ifndef __REALXTST_H__

 #define __REALXTST_H__

 #include <e32std.h>

 #include <e32math.h>

 // Some constants

 const TUint KExpFlagSignMask = 0xFFFF0301;

 // Structure definitions

 struct SRealX

 	{

 	SRealX() {}

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

 	SRealX(const TRealX& aRealX);

 	SRealX& operator=(const TRealX& aRealX);

 	operator TRealX() const;

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

 	TUint iExpFlagSign;

 	TUint iMantHigh;

 	TUint iMantLow;

 	};

 enum TConversionFrom32Bits

 	{

 	EConstructInt=0, EAssignInt=1, ESetInt=2,

 	EConstructUint=3, EAssignUint=4, ESetUint=5,

 	EConstructFloat=6, EAssignFloat=7, ESetFloat=8

 	};

 struct SConvertFrom32BitTest

 	{

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

 	void Test(TConversionFrom32Bits aConversion) const;

 	TInt iOperand;

 	SRealX iResult;

 	TInt iReturnCode;

 	};

 enum TConversionFrom64Bits

 	{

 	EConstructInt64=0, EAssignInt64=1, ESetInt64=2,

 	EConstructDouble=3, EAssignDouble=4, ESetDouble=5

 	};

 struct SConvertFrom64BitTest

 	{

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

 	void Test(TConversionFrom64Bits aConversion) const;

 	TInt64 iOperand;

 	SRealX iResult;

 	TInt iReturnCode;

 	};

 enum TConversionTo32Bits

 	{

 	EOperatorInt=0, EOperatorUint=1,

 	EOperatorTReal32=2, EGetTReal32=3

 	};

 struct SConvertTo32BitTest

 	{

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

 	void Test(TConversionTo32Bits aConversion) const;

 	SRealX iOperand;

 	TInt iResult;

 	TInt iReturnCode;

 	};

 enum TConversionTo64Bits

 	{

 	EOperatorInt64=0,

 	EOperatorTReal64=1, EGetTReal64=2

 	};

 struct SConvertTo64BitTest

 	{

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

 	void Test(TConversionTo64Bits aConversion) const;

 	SRealX iOperand;

 	TInt64 iResult;

 	TInt iReturnCode;

 	};

 enum TUnaryOperation

 	{

 	EUnaryPlus=0, EUnaryMinus=1,

 	EPreInc=2, EPreDec=3, EPostInc=4, EPostDec=5

 	};

 struct SOneOpTest

 	{

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

 	void Test(TUnaryOperation anOperation) const;

 	TInt DoTest(TUnaryOperation anOperation, TRealX *aResult) const;

 	SRealX iOperand;

 	SRealX iResult;

 	TInt iReturnCode;

 	};

 struct SOneOpTestThreadInfo

 	{

 	const SOneOpTest *iTest;

 	TUnaryOperation iOperation;

 	TRealX *iResult;

 	};

 struct SCompareTest

 	{

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

 	void Test() const;

 	SRealX iOperand1;

 	SRealX iOperand2;

 	TInt iReturnCode;

 	};

 enum TBinaryOperation

 	{

 	EAddEq=0, ESubEq=1, EMultEq=2, EDivEq=3,			// TInt TRealX::AddEq() etc

 	EAdd=4, ESub=5, EMult=6, EDiv=7,					// TInt TRealX::Add() etc

 	EPlusEq=8, EMinusEq=9, EStarEq=10, ESlashEq=11,		// += -= *= /=

 	EPlus=12, EMinus=13, EStar=14, ESlash=15			// + - * /

 	};

 struct STwoOpTest

 	{

 	STwoOpTest(const SRealX& o1, const SRealX& o2, const SRealX& res, TInt r);

 	void Test(TBinaryOperation anOperation, TBool aSwap=EFalse) const;

 	TInt DoTest(TBinaryOperation anOperation, TRealX *aResult, TBool aSwap) const;

 	SRealX iOperand1;

 	SRealX iOperand2;

 	SRealX iResult;

 	TInt iReturnCode;

 	};

 struct STwoOpTestThreadInfo

 	{

 	const STwoOpTest *iTest;

 	TBinaryOperation iOperation;

 	TRealX *iResult;

 	TBool iSwap;

 	};

 struct SSpecialValueTest

 	{

 	SSpecialValueTest(const SRealX& op, TInt aResults);

 	void Test() const;

 	SRealX iOperand;

 	TBool iIsZero;

 	TBool iIsNaN;

 	TBool iIsInfinite;

 	TBool iIsFinite;

 	};

 GLREF_D const TInt NumBinaryOpNaNTests;

 GLREF_D const STwoOpTest BinaryOpNaNTests[];

 GLREF_D const TInt NumAdditionTests;

 GLREF_D const STwoOpTest AdditionTests[];

 GLREF_D const TInt NumMultiplicationTests;

 GLREF_D const STwoOpTest MultiplicationTests[];

 GLREF_D const TInt NumDivisionTests;

 GLREF_D const STwoOpTest DivisionTests[];

 GLREF_D const TInt NumComparisonTests;

 GLREF_D const SCompareTest ComparisonTests[];

 GLREF_D const TInt NumUnaryPlusTests;

 GLREF_D const SOneOpTest UnaryPlusTests[];

 GLREF_D const TInt NumUnaryMinusTests;

 GLREF_D const SOneOpTest UnaryMinusTests[];

 GLREF_D const TInt NumIncTests;

 GLREF_D const SOneOpTest IncTests[];

 GLREF_D const TInt NumDecTests;

 GLREF_D const SOneOpTest DecTests[];

 GLREF_D const TInt NumConvertFromIntTests;

 GLREF_D const SConvertFrom32BitTest ConvertFromIntTests[];

 GLREF_D const TInt NumConvertFromUintTests;

 GLREF_D const SConvertFrom32BitTest ConvertFromUintTests[];

 GLREF_D const TInt NumConvertFromFloatTests;

 GLREF_D const SConvertFrom32BitTest ConvertFromFloatTests[];

 GLREF_D const TInt NumConvertFromInt64Tests;

 GLREF_D const SConvertFrom64BitTest ConvertFromInt64Tests[];

 GLREF_D const TInt NumConvertFromDoubleTests;

 GLREF_D const SConvertFrom64BitTest ConvertFromDoubleTests[];

 GLREF_D const TInt NumConvertToIntTests;

 GLREF_D const SConvertTo32BitTest ConvertToIntTests[];

 GLREF_D const TInt NumConvertToUintTests;

 GLREF_D const SConvertTo32BitTest ConvertToUintTests[];

 GLREF_D const TInt NumConvertToInt64Tests;

 GLREF_D const SConvertTo64BitTest ConvertToInt64Tests[];

 GLREF_D const TInt NumConvertToFloatTests;

 GLREF_D const SConvertTo32BitTest ConvertToFloatTests[];

 GLREF_D const TInt NumConvertToDoubleTests;

 GLREF_D const SConvertTo64BitTest ConvertToDoubleTests[];

 GLREF_D const TInt NumSpecialValueTests;

 GLREF_D const SSpecialValueTest SpecialValueTests[];

 #endif