Fix for bug 2283 (RVCT 4.0 support is missing from PDK 3.0.h)
Have multiple extension sections in the bld.inf, one for each version
of the compiler. The RVCT version building the tools will build the
runtime libraries for its version, but make sure we extract all the other
versions from zip archives. Also add the archive for RVCT4.
// 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;
if (r!=KErrNone && exittype==EExitPanic)
return;
}
else
{
if (exittype==EExitKill)
return;
}
}
test.Printf(_L("Unary operation %d test failed\nop = %08X %08X %08X\n"),
(TInt)anOperation,
iOperand.iExpFlagSign, iOperand.iMantHigh, iOperand.iMantLow );
test.Printf(_L("Result %08X %08X %08X\nReturn code %d Exit type %d\n"),
sr.iExpFlagSign, sr.iMantHigh, sr.iMantLow, r, (TInt)exittype );
test.Printf(_L("Correct result %08X %08X %08X\nCorrect return code %d\n"),
iResult.iExpFlagSign, iResult.iMantHigh, iResult.iMantLow, iReturnCode );
//test.Getch();
test(0);
}
STwoOpTest::STwoOpTest(const SRealX& o1, const SRealX& o2, const SRealX& res, TInt r)
{
iOperand1=o1;
iOperand2=o2;
iResult=res;
iReturnCode=r;
}
TInt STwoOpTest::DoTest(TBinaryOperation anOperation, TRealX *aResult, TBool aSwap) const
{
TInt r=KErrNone;
TRealX op1, op2;
if (aSwap)
{
op2=(TRealX)iOperand1;
op1=(TRealX)iOperand2;
*aResult=(TRealX)iOperand2;
}
else
{
op1=(TRealX)iOperand1;
op2=(TRealX)iOperand2;
*aResult=(TRealX)iOperand1;
}
switch(anOperation)
{
case EAddEq:
r=aResult->AddEq(op2);
break;
case ESubEq:
r=aResult->SubEq(op2);
break;
case EMultEq:
r=aResult->MultEq(op2);
break;
case EDivEq:
r=aResult->DivEq(op2);
break;
case EAdd:
r=op1.Add(*aResult,op2);
break;
case ESub:
r=op1.Sub(*aResult,op2);
break;
case EMult:
r=op1.Mult(*aResult,op2);
break;
case EDiv:
r=op1.Div(*aResult,op2);
break;
case EPlusEq:
*aResult+=op2;
break;
case EMinusEq:
*aResult-=op2;
break;
case EStarEq:
*aResult*=op2;
break;
case ESlashEq:
*aResult/=op2;
break;
case EPlus:
*aResult=op1+op2;
break;
case EMinus:
*aResult=op1-op2;
break;
case EStar:
*aResult=op1*op2;
break;
case ESlash:
*aResult=op1/op2;
break;
}
return r;
}
TInt TwoOpTestThreadFunction(TAny *anInfo)
{
STwoOpTestThreadInfo *pI=(STwoOpTestThreadInfo *)anInfo;
TInt r=pI->iTest->DoTest(pI->iOperation,pI->iResult,pI->iSwap);
return r;
}
void STwoOpTest::Test(TBinaryOperation anOperation, TBool aSwap) const
{
STwoOpTestThreadInfo info;
TRealX result;
info.iTest=this;
info.iOperation=anOperation;
info.iResult=&result;
info.iSwap=aSwap;
RThread t;
TInt r=t.Create(_L("TestThread"),TwoOpTestThreadFunction,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 (anOperation>=EPlus && exittype==EExitPanic)
{
// if +,-,*,/ operation paniced, result will be lost
sr=iResult;
}
if (sr==iResult && r==iReturnCode)
{
if (anOperation>=EPlusEq)
{
if (r==KErrNone && exittype==EExitKill)
return;
if (r!=KErrNone && exittype==EExitPanic)
return;
}
else
{
if (exittype==EExitKill)
return;
}
}
test.Printf(_L("Binary operation %d test failed\nop1 = %08X %08X %08X\nop2 = %08X %08X %08X\n"),
(TInt)anOperation,
iOperand1.iExpFlagSign, iOperand1.iMantHigh, iOperand1.iMantLow,
iOperand2.iExpFlagSign, iOperand2.iMantHigh, iOperand2.iMantLow );
test.Printf(_L("Result %08X %08X %08X\nReturn code %d Exit type %d\n"),
sr.iExpFlagSign, sr.iMantHigh, sr.iMantLow, r, (TInt)exittype );
test.Printf(_L("Correct result %08X %08X %08X\nCorrect return code %d\n"),
iResult.iExpFlagSign, iResult.iMantHigh, iResult.iMantLow, iReturnCode );
//test.Getch();
test(0);
}
SSpecialValueTest::SSpecialValueTest(const SRealX& op, TInt aResults)
{
iOperand=op;
iIsZero=aResults & 8;
iIsNaN=aResults & 4;
iIsInfinite=aResults & 2;
iIsFinite=aResults & 1;
}
LOCAL_C TBool same(TBool a, TBool b)
{
return( (a && b) || (!a && !b) );
}
void SSpecialValueTest::Test() const
{
TRealX x=(TRealX)iOperand;
TBool isZero=x.IsZero();
TBool isNaN=x.IsNaN();
TBool isInfinite=x.IsInfinite();
TBool isFinite=x.IsFinite();
if ( same(isZero,iIsZero) && same(isNaN,iIsNaN) && same(isInfinite,iIsInfinite) && same(isFinite,iIsFinite) )
return;
test.Printf(_L("Special value test failed\nOperand %08X %08X %08X\n"),
iOperand.iExpFlagSign, iOperand.iMantHigh, iOperand.iMantLow );
test.Printf(_L("Results IsZero=%d, IsNaN=%d, IsInfinite=%d, IsFinite=%d "),
isZero, isNaN, isInfinite, isFinite );
test.Printf(_L("Correct results IsZero=%d, IsNaN=%d, IsInfinite=%d, IsFinite=%d "),
iIsZero, iIsNaN, iIsInfinite, iIsFinite );
//test.Getch();
test(0);
}
LOCAL_C void TestAssignConstruct()
{
TInt i;
// test default constructor
TRealX z;
SRealX sz(z);
test(sz.iExpFlagSign==0);
test(sz.iMantHigh==0);
test(sz.iMantLow==0);
for (i=0; i<NumConvertFromIntTests; i++)
{
const SConvertFrom32BitTest *pT=&(ConvertFromIntTests[i]);
pT->Test(EConstructInt);
pT->Test(EAssignInt);
pT->Test(ESetInt);
}
for (i=0; i<NumConvertFromUintTests; i++)
{
const SConvertFrom32BitTest *pT=&(ConvertFromUintTests[i]);
pT->Test(EConstructUint);
pT->Test(EAssignUint);
pT->Test(ESetUint);
}
for (i=0; i<NumConvertFromInt64Tests; i++)
{
const SConvertFrom64BitTest *pT=&(ConvertFromInt64Tests[i]);
pT->Test(EConstructInt64);
pT->Test(EAssignInt64);
pT->Test(ESetInt64);
}
for (i=0; i<NumConvertFromFloatTests; i++)
{
const SConvertFrom32BitTest *pT=&(ConvertFromFloatTests[i]);
pT->Test(EConstructFloat);
pT->Test(EAssignFloat);
pT->Test(ESetFloat);
}
for (i=0; i<NumConvertFromDoubleTests; i++)
{
const SConvertFrom64BitTest *pT=&(ConvertFromDoubleTests[i]);
pT->Test(EConstructDouble);
pT->Test(EAssignDouble);
pT->Test(ESetDouble);
}
}
LOCAL_C void TestConversions()
{
TInt i;
for (i=0; i<NumConvertToIntTests; i++)
{
const SConvertTo32BitTest *pT=&(ConvertToIntTests[i]);
pT->Test(EOperatorInt);
}
for (i=0; i<NumConvertToUintTests; i++)
{
const SConvertTo32BitTest *pT=&(ConvertToUintTests[i]);
pT->Test(EOperatorUint);
}
for (i=0; i<NumConvertToInt64Tests; i++)
{
const SConvertTo64BitTest *pT=&(ConvertToInt64Tests[i]);
pT->Test(EOperatorInt64);
}
for (i=0; i<NumConvertToFloatTests; i++)
{
const SConvertTo32BitTest *pT=&(ConvertToFloatTests[i]);
pT->Test(EOperatorTReal32);
pT->Test(EGetTReal32);
}
for (i=0; i<NumConvertToDoubleTests; i++)
{
const SConvertTo64BitTest *pT=&(ConvertToDoubleTests[i]);
pT->Test(EOperatorTReal64);
pT->Test(EGetTReal64);
}
}
LOCAL_C void TestSpecials()
{
TRealX x;
SRealX sx;
x.SetInfinite(EFalse);
sx=x;
test(sx.iExpFlagSign==0xFFFF0000);
test(sx.iMantHigh==0x80000000);
test(sx.iMantLow==0);
x.SetZero();
sx=x;
test(sx.iExpFlagSign==0x00000000);
x.SetInfinite(ETrue);
sx=x;
test(sx.iExpFlagSign==0xFFFF0001);
test(sx.iMantHigh==0x80000000);
test(sx.iMantLow==0);
x.SetNaN();
sx=x;
test(sx.iExpFlagSign==0xFFFF0001);
test(sx.iMantHigh==0xC0000000);
test(sx.iMantLow==0);
x.SetZero(ETrue);
sx=x;
test(sx.iExpFlagSign==0x00000001);
TInt i;
for(i=0; i<NumSpecialValueTests; i++)
{
const SSpecialValueTest *pT=&(SpecialValueTests[i]);
pT->Test();
}
}
LOCAL_C void TestUnaryOperators()
{
TInt i;
for (i=0; i<NumUnaryPlusTests; i++)
{
const SOneOpTest *pT=&(UnaryPlusTests[i]);
pT->Test(EUnaryPlus);
}
for (i=0; i<NumUnaryMinusTests; i++)
{
const SOneOpTest *pT=&(UnaryMinusTests[i]);
pT->Test(EUnaryMinus);
}
for (i=0; i<NumIncTests; i++)
{
const SOneOpTest *pT=&(IncTests[i]);
pT->Test(EPreInc);
pT->Test(EPostInc);
}
for (i=0; i<NumDecTests; i++)
{
const SOneOpTest *pT=&(DecTests[i]);
pT->Test(EPreDec);
pT->Test(EPostDec);
}
}
LOCAL_C void TestAddition()
{
TInt i;
for (i=0; i<NumAdditionTests; i++)
{
const STwoOpTest *pT=&(AdditionTests[i]);
pT->Test(EAddEq,EFalse);
pT->Test(EAddEq,ETrue);
pT->Test(EAdd,EFalse);
pT->Test(EAdd,ETrue);
pT->Test(EPlusEq,EFalse);
pT->Test(EPlusEq,ETrue);
pT->Test(EPlus,EFalse);
pT->Test(EPlus,ETrue);
}
for (i=0; i<NumBinaryOpNaNTests; i++)
{
const STwoOpTest *pT=&(BinaryOpNaNTests[i]);
pT->Test(EAddEq,EFalse);
pT->Test(EAddEq,ETrue);
pT->Test(EAdd,EFalse);
pT->Test(EAdd,ETrue);
pT->Test(EPlusEq,EFalse);
pT->Test(EPlusEq,ETrue);
pT->Test(EPlus,EFalse);
pT->Test(EPlus,ETrue);
}
}
LOCAL_C void TestMultiplication()
{
TInt i;
for (i=0; i<NumMultiplicationTests; i++)
{
const STwoOpTest *pT=&(MultiplicationTests[i]);
pT->Test(EMultEq,EFalse);
pT->Test(EMultEq,ETrue);
pT->Test(EMult,EFalse);
pT->Test(EMult,ETrue);
pT->Test(EStarEq,EFalse);
pT->Test(EStarEq,ETrue);
pT->Test(EStar,EFalse);
pT->Test(EStar,ETrue);
}
for (i=0; i<NumBinaryOpNaNTests; i++)
{
const STwoOpTest *pT=&(BinaryOpNaNTests[i]);
pT->Test(EMultEq,EFalse);
pT->Test(EMultEq,ETrue);
pT->Test(EMult,EFalse);
pT->Test(EMult,ETrue);
pT->Test(EStarEq,EFalse);
pT->Test(EStarEq,ETrue);
pT->Test(EStar,EFalse);
pT->Test(EStar,ETrue);
}
}
LOCAL_C void TestDivision()
{
TInt i;
for (i=0; i<NumDivisionTests; i++)
{
const STwoOpTest *pT=&(DivisionTests[i]);
pT->Test(EDivEq,EFalse);
pT->Test(EDiv,EFalse);
pT->Test(ESlashEq,EFalse);
pT->Test(ESlash,EFalse);
}
for (i=0; i<NumBinaryOpNaNTests; i++)
{
const STwoOpTest *pT=&(BinaryOpNaNTests[i]);
pT->Test(EDivEq,EFalse);
pT->Test(EDiv,EFalse);
pT->Test(ESlashEq,EFalse);
pT->Test(ESlash,EFalse);
}
}
LOCAL_C void TestComparison()
{
TInt i;
for (i=0; i<NumComparisonTests; i++)
{
const SCompareTest *pT=&(ComparisonTests[i]);
pT->Test();
}
}
GLDEF_C TInt E32Main()
//
// Test TRealX
//
{
User::SetJustInTime(EFalse);
test.Title();
test.Start(_L("Assignment Operator and Constructors"));
TestAssignConstruct();
test.Next(_L("Conversions"));
TestConversions();
test.Next(_L("Setting and Checking Specials"));
TestSpecials();
test.Next(_L("Addition"));
TestAddition();
test.Next(_L("Multiplication"));
TestMultiplication();
test.Next(_L("Division"));
TestDivision();
test.Next(_L("Unary Operators"));
TestUnaryOperators();
test.Next(_L("Comparisons"));
TestComparison();
test.End();
return(KErrNone);
}