--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/e32test/math/t_r32.cpp Mon Oct 19 15:55:17 2009 +0100
@@ -0,0 +1,711 @@
+// Copyright (c) 1995-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_r32.cpp
+// T_R32.CPP - Test routines for TReal32
+// 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.
+// Overview:
+// Test functionality of operations on 32bit real numbers.
+// API Information:
+// TReal32.
+// Details:
+// - Test the conversion from TReal to TReal32 is as expected.
+// - Check addition, subtraction and multiplication of 32-bit floating point
+// numbers are as expected.
+// - Check division of 32-bit floating-point numbers and verify that it is
+// panicked when divided by zero.
+// - Test arithmetic exceptions are raised for
+// - overflow error during addition, subtraction.
+// - overflow, underflow errors during multiplication.
+// - overflow, underflow, divided by zero errors during division.
+// - overflow, underflow, invalid operation errors during conversion
+// from double to float.
+// - Check unary operator, equalities and inequalities operators, pre/post
+// increment, decrement operators with TReal32 are as expected.
+// Platforms/Drives/Compatibility:
+// All
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+//
+//
+
+#include "t_math.h"
+#include "t_real32.h"
+
+#if defined(__VC32__)
+// Some symbols generated by the VC++ compiler for floating point stuff.
+extern "C" {
+GLDEF_D TInt _adj_fdiv_m32;
+}
+#endif
+
+// Data for tests from T_R32DTA.cpp
+GLREF_D TReal32 addInput[];
+GLREF_D TReal32 subInput[];
+GLREF_D TReal32 multInput[];
+GLREF_D TReal32 divInput[];
+GLREF_D TReal32 unaryInput[];
+GLREF_D TReal32 incDecInput[];
+GLREF_D TInt sizeAdd;
+GLREF_D TInt sizeSub;
+GLREF_D TInt sizeMult;
+GLREF_D TInt sizeDiv;
+GLREF_D TInt sizeUnary;
+GLREF_D TInt sizeIncDec;
+
+#if defined (__WINS__) || defined (__X86__)
+// Functions from EMGCC32.CPP
+GLREF_C TReal32 __addsf3(TReal32 a1,TReal32 a2);
+GLREF_C TReal32 __subsf3(TReal32 a1,TReal32 a2);
+GLREF_C TReal32 __mulsf3(TReal32 a1,TReal32 a2);
+GLREF_C TReal32 __divsf3(TReal32 a1,TReal32 a2);
+GLREF_C TReal32 __truncdfsf2(TReal64 a1);
+#endif
+
+GLDEF_D TReal32 NaNTReal32;
+GLDEF_D TReal32 posInfTReal32;
+GLDEF_D TReal32 negInfTReal32;
+GLDEF_D const TReal32 minDenormalTReal32=1.4E-45f;
+GLDEF_D TReal NaNTReal;
+GLDEF_D TReal posInfTReal;
+GLDEF_D TReal negInfTReal;
+
+enum TOrder
+ {
+ ELessThan,
+ EEqual,
+ EGreaterThan
+ };
+
+LOCAL_D RTest test(_L("T_R32"));
+
+LOCAL_C void initSpecialValues()
+//
+// Initialise special values
+//
+ {
+
+ SReal32 *p32=(SReal32*)&NaNTReal32;
+ p32->sign=0;
+ p32->exp=KTReal32SpecialExponent;
+ p32->man=0x7fffff;
+
+ p32=(SReal32*)&posInfTReal32;
+ p32->sign=0;
+ p32->exp=KTReal32SpecialExponent;
+ p32->man=0;
+
+ p32=(SReal32*)&negInfTReal32;
+ p32->sign=1;
+ p32->exp=KTReal32SpecialExponent;
+ p32->man=0;
+
+ SReal64 *p64=(SReal64*)&NaNTReal;
+ p64->sign=0;
+ p64->exp=KTReal64SpecialExponent;
+ p64->lsm=0xffffffffu;
+ p64->msm=0xfffff;
+
+ p64=(SReal64*)&posInfTReal;
+ p64->sign=0;
+ p64->exp=KTReal64SpecialExponent;
+ p64->lsm=0;
+ p64->msm=0;
+
+ p64=(SReal64*)&negInfTReal;
+ p64->sign=1;
+ p64->exp=KTReal64SpecialExponent;
+ p64->lsm=0;
+ p64->msm=0;
+ }
+
+LOCAL_C void testConvert()
+//
+// Conversion tests
+//
+ {
+
+ TRealX f;
+
+ TReal input[]=
+ {
+ KMaxTReal32inTReal,KMinTReal32inTReal,-KMaxTReal32inTReal,-KMinTReal32inTReal,
+ KMaxTReal32inTReal,KMinTReal32inTReal,-KMaxTReal32inTReal,-KMinTReal32inTReal,
+ 3.4027E+38,1.1755E-38,-3.4027E+38,-1.1755E-38,
+ 0.0,64.5,-64.5,1.54E+18,-1.54E+18,4.72E-22,-4.72E-22,
+ posInfTReal,negInfTReal,KNegZeroTReal,
+ 1.4E-45,-1.4E-45,2E-41,-2E-41,1E-38,-1E-38
+ };
+
+ TReal32 expect[]=
+ {
+ KMaxTReal32,KMinTReal32,-KMaxTReal32,-KMinTReal32,
+ KMaxTReal32,KMinTReal32,-KMaxTReal32,-KMinTReal32,
+ 3.4027E+38f,1.17550E-38f,-3.40270E+38f,-1.17550E-38f,
+ 0.0f,64.5f,-64.5f,1.54E+18f,-1.54E+18f,4.72E-22f,-4.72E-22f,
+ posInfTReal32,negInfTReal32,KNegZeroTReal32,
+ 1.4E-45f,-1.4E-45f,2E-41f,-2E-41f,1E-38f,-1E-38f
+ };
+
+ TInt size=sizeof(input)/sizeof(TReal);
+
+ for (TInt ii=0; ii<size; ii++)
+ {
+ f=TRealX(expect[ii]);
+ test(f==TRealX(TReal32(input[ii])));
+ }
+
+ // NaN
+// TReal a=NaNTReal;
+ TReal32 b=NaNTReal32;
+ f=TRealX(b);
+// test(f!=TRealX(TReal32(a)));
+ test(f.IsNaN());
+
+ // See EON Software Defects Bug Report no. HA-287
+ // There is a bug in MSDev compiler which means comparing TReal32's directly
+ // does not always work, hence...
+ /*
+ test(BitTest(TReal32(3.40270E+38),3.40270E+38f)); // this works
+ // (BitTest() checks for all 32 bits being identical
+
+ TReal32 a=TReal32(3.40270E+38);
+ TReal32 b=3.40270E+38f;
+ TReal64 c=3.40270E+38;
+ TReal32 d=TReal32(c);
+
+ test(a==b); // this works
+ test(d==b); // this works
+ test(TRealX(TReal32(c))==TRealX(b)); // this works
+ test(TReal64(TReal32(c))==TReal64(b)); // this panics
+ test(TReal32(c)==b); // this panics
+ test(TReal32(3.40270E+38)==3.40270E+38f); // this panics
+
+ // As expected, all these work fine under ARM.
+ */
+ }
+
+LOCAL_C void testAdd()
+//
+// Addition tests
+//
+ {
+ TReal32 f,g,h;
+ 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
+ test(TRealX(f+g)==TRealX(TReal32(ff+gg)));
+ test(TRealX(g+f)==TRealX(TReal32(ff+gg)));
+ // Test hex-encoded constants for TReal32s generated on PC using fp-hardware same as
+ // TRealX addition
+ test(TRealX(*(TReal32*)&addArray[ii])==TRealX(f+g));
+ test(TRealX(*(TReal32*)&addArray[ii])==TRealX(g+f));
+ // similarly to tests above ...
+ h=g;
+ hh=gg;
+ hh+=ff;
+ test(TRealX(h+=f)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&addArray[ii])==TRealX(h));
+ //
+ h=f;
+ hh=ff;
+ hh+=gg;
+ test(TRealX(h+=g)==TRealX(TReal32(hh)));
+ test(h==TReal32(hh));
+ test(TRealX(*(TReal32*)&addArray[ii])==TRealX(h));
+ }
+ }
+
+LOCAL_C void testSubt()
+//
+// Subtraction tests
+//
+ {
+ TReal32 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);
+ //
+
+// This test fails on GCC (with -O1 switch). The reason is that
+// comparing two intermediate floats is unpredictable.
+// See http://www.parashift.com/c++-faq-lite/newbie.html#faq-29.18
+#ifndef __GCC32__
+ test(f-g == -(g-f));
+#endif
+ //
+ test(TRealX(f-g)==TRealX(TReal32(ff-gg)));
+ test(TRealX(g-f)==TRealX(TReal32(gg-ff)));
+ test(TRealX(*(TReal32*)&subArray[ii])==TRealX(f-g));
+ test(TRealX(*(TReal32*)&subArray[ii])==TRealX(-(g-f)));
+ //
+ h=g;
+ hh=gg;
+ hh-=ff;
+ test(TRealX(h-=f)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&subArray[ii])==TRealX(-h));
+ //
+ h=f;
+ hh=ff;
+ hh-=gg;
+ test(TRealX(h-=g)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&subArray[ii])==TRealX(h));
+ }
+ }
+
+LOCAL_C void testMult()
+//
+// Multiplication test
+//
+ {
+ TReal32 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)==TRealX(TReal32(ff*gg)));
+ test(TRealX(g*f)==TRealX(TReal32(gg*ff)));
+ test(TRealX(*(TReal32*)&multArray[ii])==TRealX(f*g));
+ test(TRealX(*(TReal32*)&multArray[ii])==TRealX(g*f));
+ //
+ h=f;
+ hh=ff;
+ hh*=gg;
+ test(TRealX(h*=g)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&multArray[ii])==TRealX(h));
+ //
+ h=g;
+ hh=gg;
+ hh*=ff;
+ test(TRealX(h*=f)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&multArray[ii])==TRealX(h));
+ }
+ }
+
+LOCAL_C void testDiv()
+//
+// Division test
+//
+ {
+ TReal32 f,g,h;
+ TRealX ff,gg,hh;
+ TInt count=0;
+
+ // Panic: Divide by Zero
+ // 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)==TRealX(TReal32(ff/gg)));
+ test(TRealX(*(TReal32*)&divArray[count])==TRealX(f/g));
+ //
+ h=f;
+ hh=ff;
+ hh/=gg;
+ test(TRealX(h/=g)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ test(TRealX(*(TReal32*)&divArray[count])==TRealX(h));
+ ++count;
+ }
+ if (f!=0.0)
+ {
+ test(TRealX(g/f)==TRealX(TReal32(gg/ff)));
+ h=g;
+ hh=gg;
+ hh/=ff;
+ test(TRealX(h/=f)==TRealX(TReal32(hh)));
+ test(h==TReal32(hh));
+ }
+ };
+
+ //Additional test
+ f=3.9999f;
+ g=KMinTReal32;
+ ff=TRealX(f);
+ gg=TRealX(g);
+ test(TRealX(f/g)==TRealX(TReal32(ff/gg)));
+ h=f;
+ hh=ff;
+ hh/=gg;
+ test(TRealX(h/=g)==TRealX(TReal32(hh)));
+ test(TRealX(h)==TRealX(TReal32(hh)));
+ }
+
+#if defined (__WINS__) || defined (__X86__)
+
+LOCAL_C void testArithmeticExceptionRaising()
+//
+// Test that UP_GCC.CPP raise exceptions correctly by calling functions from EMGCC32.CPP which
+// are copies of those in UP_GCC.CPP. To be used in debugger only.
+// Added by AnnW, December 1996
+//
+ {
+ TReal32 f,g,h;
+
+ // Addition - possible errors are overflow, argument or none
+ // NB no underflow
+
+ f=NaNTReal32;
+ h=__addsf3(f,f); // argument
+
+ f=KMaxTReal32;
+ h=__addsf3(f,f); // overflow
+
+ f=1.0f;
+ g=2.0f;
+ h=__addsf3(f,g); // none
+ test(h==3.0f);
+
+ // Subtraction - possible errors are overflow, argument or none
+ // NB no underflow
+
+ f=NaNTReal32;
+ h=__subsf3(f,f); // argument
+
+ f=KMaxTReal32;
+ g=-KMaxTReal32;
+ h=__subsf3(f,g); // overflow
+
+ f=1.0f;
+ g=2.0f;
+ h=__subsf3(f,g); // none
+ test(h==-1.0f);
+
+ // Multiplication - possible errors are argument, overflow, underflow or none
+
+ f=NaNTReal32;
+ h=__mulsf3(f,f); // argument
+
+ f=KMaxTReal32;
+ g=2.0f;
+ h=__mulsf3(f,g); // overflow
+
+ f=minDenormalTReal32;
+ g=0.1f;
+ h=__mulsf3(f,g); // underflow
+
+ f=1.0f;
+ g=2.0f;
+ h=__mulsf3(f,g); // none
+ test(h==2.0f);
+
+ // Division - possible errors are overflow, underflow, divide by zero, argument or none
+
+ f=KMaxTReal32;
+ g=0.5f;
+ h=__divsf3(f,g); // overflow
+
+ f=minDenormalTReal32;
+ g=10.0f;
+ h=__divsf3(f,g); // underflow
+
+ f=4.0f;
+ g=0.0f;
+ h=__divsf3(f,g); // divide by zero
+
+ f=0.0f;
+ g=0.0f;
+ h=__divsf3(f,g); // argument
+
+ f=1.0f;
+ g=2.0f;
+ h=__divsf3(f,g); // none
+ test(h==0.5f);
+
+ // Converting double to float - possible errors are overflow, underflow, invalid operation or none
+ TReal64 d;
+
+ d=1.0E+50;
+ f=__truncdfsf2(d); // overflow
+
+ d=1.0E-50;
+ f=__truncdfsf2(d); // underflow
+
+ d=KNaNTReal64;
+ f=__truncdfsf2(d); // invalid operation
+
+ d=4.0;
+ f=__truncdfsf2(d); // none
+ }
+
+#endif
+
+LOCAL_C void testUnary()
+//
+// Unary operator tests
+//
+ {
+ TReal32 f;
+ TRealX g;
+
+ for (TInt ii=0; ii<sizeUnary-1; ii++)
+ {
+ f=unaryInput[ii];
+ g=TRealX(f);
+ test(TRealX(-f)==TRealX(TReal32(-g)));
+ test(TRealX(-f)==TRealX(0.0f-f));
+ test(TRealX(+f)==TRealX(TReal32(g)));
+ test(TRealX(+f)==TRealX(0.0f+f));
+ test(TRealX(*(TReal32*)&unaryArray[ii])==TRealX(-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;
+ TReal32 lessThanMax = KMaxTReal32-TReal32(1.0E+32);
+ TReal32 greaterThanMin = 1.17550E-38f;
+ TReal32 zero(0.0f);
+
+ TReal32 positive[] =
+ {KMinTReal32,5.3824705E-26f,1.0f,2387501.0f,5.3824705E+28f,KMaxTReal32};
+
+ TReal32 large[] =
+ {2.0f,KMaxTReal32,-lessThanMax,greaterThanMin,-KMinTReal32,10.4058482f,-10.4058482f,
+ 1.2443345E+14f,1.2443345E+14f,-1.3420344E-16f,132435.97f,5.0E-6f,9.6f,-8.0f};
+
+ TReal32 small[] =
+ {1.0f,lessThanMax,-KMaxTReal32,KMinTReal32,-greaterThanMin,10.4058474f,-10.4058496f,
+ 5.0E-10f,1.2443345E+10f,-5.0382470E+25f,-132435.97f,-5.1E-6f,8.0f,-9.6f};
+
+ TReal32 equal[] = // Same as large[]
+ {2.0f,KMaxTReal32,-lessThanMax,greaterThanMin,-KMinTReal32,10.4058482f,-10.4058482f,
+ 1.2443345E+14f,1.2443345E+14f,-1.3420344E-16f,132435.97f,5.0E-6f,9.6f,-8.0f};
+
+
+ // Tests with zero
+
+ size = sizeof(positive)/sizeof(TReal32);
+
+ 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(TReal32);
+
+ 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;
+ TReal32 f;
+ TRealX g;
+
+ test.Start(_L("Pre-increment"));
+
+ for (ii=0; ii<sizeIncDec; ii++)
+ {
+ f=incDecInput[ii];
+ g=TRealX(f);
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(++f)==TRealX(TReal32(++g)));
+ test(TRealX(*(TReal32*)&preIncArray1[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(++f)==TRealX(TReal32(++g)));
+ test(TRealX(*(TReal32*)&preIncArray2[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ }
+
+ test.Next(_L("Post-increment"));
+
+ for (ii=0; ii<sizeIncDec; ii++)
+ {
+ f=incDecInput[ii];
+ g=TRealX(f);
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(f++)==TRealX(TReal32(g++)));
+ test(TRealX(*(TReal32*)&postIncArray1[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(f++)==TRealX(TReal32(g++)));
+ test(TRealX(*(TReal32*)&postIncArray2[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ }
+
+ test.Next(_L("Pre-decrement"));
+
+ for (ii=0; ii<sizeIncDec; ii++)
+ {
+ f=incDecInput[ii];
+ g=TRealX(f);
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(--f)==TRealX(TReal32(--g)));
+ test(TRealX(*(TReal32*)&preDecArray1[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(--f)==TRealX(TReal32(--g)));
+ test(TRealX(*(TReal32*)&preDecArray2[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ }
+
+ test.Next(_L("Post-decrement"));
+
+ for (ii=0; ii<sizeIncDec; ii++)
+ {
+ f=incDecInput[ii];
+ g=TRealX(f);
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(f--)==TRealX(TReal32(g--)));
+ test(TRealX(*(TReal32*)&postDecArray1[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ test(TRealX(f--)==TRealX(TReal32(g--)));
+ test(TRealX(*(TReal32*)&postDecArray2[ii])==TRealX(f));
+ test(TRealX(f)==TRealX(TReal32(g)));
+ }
+ test.End();
+ }
+
+LOCAL_C void _matherr(TExcType aType)
+ {
+ test.Printf(_L("_matherr: Exception type %u handled\n"),TUint(aType));
+ }
+
+GLDEF_C TInt E32Main()
+//
+// Test TReal32
+//
+ {
+
+ test.Title();
+
+ User::SetExceptionHandler(_matherr,KExceptionFpe);
+
+ initSpecialValues();
+
+ test.Start(_L("Conversion from TReal to TReal32"));
+ testConvert();
+ test.Next(_L("Addition"));
+ testAdd();
+ test.Next(_L("Subtraction"));
+ testSubt();
+ 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 Operators"));
+ testUnary();
+ test.Next(_L("Equalities and Inequalities"));
+ testEqualities();
+ test.Next(_L("Increment and Decrement"));
+ testIncDec();
+
+ test.End();
+ return(KErrNone);
+ }
+
+