// 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