diff -r c55016431358 -r 0a7b44b10206 symport/e32test/math/t_math.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/symport/e32test/math/t_math.cpp	Thu Jun 25 15:59:54 2009 +0100
@@ -0,0 +1,2926 @@
+// 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 "Symbian Foundation License v1.0"
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// e32test\math\t_math.cpp
+// T_MATH.CPP - Test routines for the maths functions
+// NB When considering the accuracy of the results (i.e. the tolerance used in testApprox()) it
+// should be remembered that the results expected are not always given to full precision and so
+// the results obtained are mostly as accurate as can be expected.
+// Overview:
+// Test functionality of the Math library.
+// API Information:
+// Math.
+// Details:
+// - Test math's trigonometric, powers, roots, logs, modulo, sqrt, exp,
+// Int, Frac, rounding for range of input values are as expected.
+// - Test the returned error values are as expected when illegal math's
+// operations are done.
+// - Check the return value is KErrTotalLossOfPrecision when incorrect values
+// is passed to modulo function.
+// - Test for success when the same variable for both operands in some 
+// Math functions are used.
+// Platforms/Drives/Compatibility:
+// All.
+// Assumptions/Requirement/Pre-requisites:
+// Failures and causes:
+// Base Port information:
+// 
+//
+
+#include "t_math.h"
+#include "t_vals.h"
+
+LOCAL_D RTest test(_L("T_MATH"));
+
+LOCAL_D TInt64 rseed = MAKE_TINT64(123456789,987654321);
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } SQRT_TEST;
+
+LOCAL_D SQRT_TEST testsqrt[]=
+    {
+    {0.0,0.0}, // zero
+	{KNegZeroTReal64,KNegZeroTReal64},
+    {1.0,1.0},
+    {.64,.8},
+    {.81,.9},
+    {9,3},
+    {25,5},
+    {10000,100},
+    {400,20},
+    {6.25,2.5},
+    {1E-98,1E-49},
+    {1E-98,1E-49},
+    {1E98,1E49},
+    {1.0000000001,1.00000000005}
+    };
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } TESTLN;
+
+LOCAL_D TESTLN testln[]=
+    {
+    {.001,-6.9077552789821317},
+    {.002,-6.2146080984221917},
+    {.023,-3.7722610630529874},
+    {.004,-5.5214609178622464},
+    {.050,-2.9957322735539910},
+    {.100,-2.3025850929940457},
+    {.150,-1.8971199848858813},
+    {.200,-1.6094379124341004},
+    {.250,-1.3862943611198906},
+    {.300,-1.2039728043259360},
+    {.350,-1.0498221244986777},
+    {.400,-0.9162907318741551},
+    {.450,-0.7985076962177716},
+    {.500,-0.6931471805599453},
+    {.550,-0.5978370007556204},
+    {.600,-0.5108256237659907},
+    {.650,-0.4307829160924543},
+    {.700,-0.3566749439387324},
+    {.750,-0.2876820724517809},
+    {.980,-0.0202027073175194},
+    {.985,-0.0151136378100482},
+    {.990,-0.0100503358535014},
+    {.995,-0.0050125418235443},
+    {.088,-2.4304184645039306},
+    {1,0}
+    };
+
+typedef struct
+    {
+    TReal val; // value for which the exponent is to be found
+    TReal result; // result
+    } EXP;
+
+LOCAL_D EXP testexp[]=
+    {
+    {4E-20,1.0}, 
+	{5.4E-20,1.0},
+	{0.0,1.0},
+	{5E-324,1.0},
+    };
+
+typedef struct
+    {
+    TReal number; // number to be raised to a power
+    TReal power; // power
+    TReal result; // result
+    } POWER;
+
+LOCAL_D POWER testpow[]=
+    {
+	{45,3,91125.0},
+	{-2,4,16},
+    {2,-3,0.125},
+    {-2,3,-8},
+    {16,20,1.208925819614628E+24},
+    };
+
+// Added by AnnW, October 1996
+LOCAL_D const POWER testpowexact[]=
+	{
+	{0.0,1.0,0.0},
+	{0,7,0},
+	{0.0,16.0,0.0},
+	{0.0,3.9271E-17,0.0},
+	{-2,0,1},
+    {1,0,1},
+	{1.545243,0,1},
+	{4.8,0.0,1.0},
+	{195.0,0.0,1.0},
+	{1.0E-7,0.0,1.0},
+	{1.0,2.0,1.0},
+	{1.0,1.0E-6,1.0},
+	{1.0,1.0E+10,1.0},
+	{-1.0,2.0,1.0},
+	{-1.0,1.0000000001E+10,-1.0},
+	{-1.0,1.0E+10,1.0},
+	{1.593704102953967e+3,1.0,1.593704102953967e+3},
+	{1.234567E+50,1.0,1.234567E+50},
+	{1.2345678901234567E+146,1.0,1.2345678901234567E+146},
+	{-7.6543210987654321E-53,1.0,-7.6543210987654321E-53},
+	{0.0,2.0,0.0},
+	{KNegZeroTReal64,4.0,0.0},
+	{KPosInfTReal64,-2.0,0.0},
+	{KNegInfTReal64,-2.0,0.0},
+	{2.0,KNegInfTReal64,0.0},
+	{-2.0,KNegInfTReal64,0.0},
+	{0.5,KPosInfTReal64,0.0},
+	{-0.5,KPosInfTReal64,0.0},
+	{KPosInfTReal64,-5.0,0.0},
+	{KPosInfTReal64,-6.0,0.0},
+	{KNegInfTReal64,KNegInfTReal64,0.0},
+	{KPosInfTReal64,KNegInfTReal64,0.0},
+	};
+
+// Check ISO requirements on Pow()
+//
+typedef struct
+	{
+	TReal number;	// number to be raised to a power
+	TReal power;	// power
+	TInt rc;		// return value from Pow()
+	TReal result;	// numerical result
+	} POWERISO;
+
+const TReal KPosZeroTReal64 = 0.0;
+
+LOCAL_D const POWERISO testpow_iso[] =
+	{
+	// pow(+/-0, y) returns +/-INF and raises the ''divide-by-zero''
+	// floating-point exception for y an odd integer < 0
+	{ KPosZeroTReal64, -3.0, KErrOverflow, KPosInfTReal64 },	// 0
+	{ KNegZeroTReal64, -3.0, KErrOverflow, KNegInfTReal64 },	// 1
+
+	// pow(+/-0, y) returns +INF and raises the ''divide-by-zero''
+	// floating-point exception for y < 0 and not an odd integer
+	{ KPosZeroTReal64, -2.0, KErrOverflow, KPosInfTReal64 },	// 2
+	{ KNegZeroTReal64, -2.0, KErrOverflow, KPosInfTReal64 },	// 3
+
+	// pow(+/-0, y) returns +/-0 for y an odd integer > 0
+	{ KPosZeroTReal64, 3.0, KErrNone, KPosZeroTReal64 },		// 4
+	{ KNegZeroTReal64, 3.0, KErrNone, KNegZeroTReal64 },		// 5
+
+	// pow(+/-0, y) returns +0 for y > 0 and not an odd integer
+	{ KPosZeroTReal64, 2.0, KErrNone, KPosZeroTReal64 },		// 6
+	{ KNegZeroTReal64, 2.0, KErrNone, KPosZeroTReal64 },		// 7
+
+	// pow(-1, +/-INF) returns 1
+	{ -1.0, KPosInfTReal64, KErrNone, 1.0 },					// 8
+	{ -1.0, KNegInfTReal64, KErrNone, 1.0 },					// 9
+
+	// pow(+1, y) returns 1 for any y, even a NaN
+	{ 1.0, 1.0, KErrNone, 1.0 },								// 10
+	{ 1.0, 10.0, KErrNone, 1.0 },								// 11
+	{ 1.0, -1.0, KErrNone, 1.0 },								// 12
+	{ 1.0, -10.0, KErrNone, 1.0 },								// 13
+	{ 1.0, 0.5, KErrNone, 1.0 },								// 14
+	{ 1.0, -0.5, KErrNone, 1.0 },								// 15
+	{ 1.0, KPosInfTReal64, KErrNone, 1.0 },						// 16
+	{ 1.0, KNegInfTReal64, KErrNone, 1.0 },						// 17
+	{ 1.0, KNaNTReal64, KErrNone, 1.0 },						// 18
+
+	// pow(x, +/-0) returns 1 for any x, even a NaN
+	{  1.0, KPosZeroTReal64, KErrNone, 1.0 },					// 19
+	{  1.0, KNegZeroTReal64, KErrNone, 1.0 },					// 20
+	{  2.0, KPosZeroTReal64, KErrNone, 1.0 },					// 21
+	{  2.0, KNegZeroTReal64, KErrNone, 1.0 },					// 22
+	{  0.5, KPosZeroTReal64, KErrNone, 1.0 },					// 23
+	{  0.5, KNegZeroTReal64, KErrNone, 1.0 },					// 24
+	{ -1.0, KPosZeroTReal64, KErrNone, 1.0 },					// 25
+	{ -1.0, KNegZeroTReal64, KErrNone, 1.0 },					// 26
+	{ -2.0, KPosZeroTReal64, KErrNone, 1.0 },					// 27
+	{ -2.0, KNegZeroTReal64, KErrNone, 1.0 },					// 28
+	{ -0.5, KPosZeroTReal64, KErrNone, 1.0 },					// 29
+	{ -0.5, KNegZeroTReal64, KErrNone, 1.0 },					// 30
+	{ KPosZeroTReal64, KPosZeroTReal64, KErrNone, 1.0 },		// 31
+	{ KPosZeroTReal64, KNegZeroTReal64, KErrNone, 1.0 },		// 32
+	{ KNegZeroTReal64, KPosZeroTReal64, KErrNone, 1.0 },		// 33
+	{ KNegZeroTReal64, KNegZeroTReal64, KErrNone, 1.0 },		// 34
+	{ KPosInfTReal64, KPosZeroTReal64, KErrNone, 1.0 },			// 35
+	{ KPosInfTReal64, KNegZeroTReal64, KErrNone, 1.0 },			// 36
+	{ KNegInfTReal64, KPosZeroTReal64, KErrNone, 1.0 },			// 37
+	{ KNegInfTReal64, KNegZeroTReal64, KErrNone, 1.0 },			// 38
+	{ KNaNTReal64, KPosZeroTReal64, KErrNone, 1.0 },			// 39
+	{ KNaNTReal64, KNegZeroTReal64, KErrNone, 1.0 },			// 40
+
+	// pow(x, y) returns a NaN and raises the ''invalid'' floating-point
+	// exception for finite x < 0 and finite non-integer y
+	{ -1.0, 1.5, KErrArgument, KNaNTReal64 },					// 41
+
+	// pow(x, -INF) returns +INF for |x| < 1
+	{ 0.5, KNegInfTReal64, KErrOverflow, KPosInfTReal64 },		// 42
+	{ -0.5, KNegInfTReal64, KErrOverflow, KPosInfTReal64 },		// 43
+
+	// pow(x, -INF) returns +0 for |x| > 1
+	{ 2, KNegInfTReal64, KErrNone, KPosZeroTReal64 },			// 44
+	{ -2, KNegInfTReal64, KErrNone, KPosZeroTReal64 },			// 45
+	{ 4.5, KNegInfTReal64, KErrNone, KPosZeroTReal64 },			// 46
+	{ -4.5, KNegInfTReal64, KErrNone, KPosZeroTReal64 },		// 47
+
+	// pow(x, +INF) returns +0 for |x| < 1
+	{ .5, KPosInfTReal64, KErrNone, KPosZeroTReal64 },			// 48
+	{ -.5, KPosInfTReal64, KErrNone, KPosZeroTReal64 },			// 49
+
+	// pow(x, +INF) returns +INF for |x| > 1
+	{ 2, KPosInfTReal64, KErrOverflow, KPosInfTReal64 },		// 50
+	{ -2, KPosInfTReal64, KErrOverflow, KPosInfTReal64 },		// 51
+	{ 4.5, KPosInfTReal64, KErrOverflow, KPosInfTReal64 },		// 52
+	{ -4.5, KPosInfTReal64, KErrOverflow, KPosInfTReal64 },		// 53
+
+	// pow(-INF, y) returns -0 for y an odd integer < 0
+	{ KNegInfTReal64, -1, KErrNone, KNegZeroTReal64 },			// 54
+	{ KNegInfTReal64, -5, KErrNone, KNegZeroTReal64 },			// 55
+
+	// pow(-INF, y) returns +0 for y < 0 and not an odd integer
+	{ KNegInfTReal64, -2, KErrNone, KPosZeroTReal64 },			// 56
+	{ KNegInfTReal64, -5.5, KErrNone, KPosZeroTReal64 },		// 57
+
+	// pow(-INF, y) returns -INF for y an odd integer > 0
+	{ KNegInfTReal64, 1, KErrOverflow, KNegInfTReal64 },		// 58
+	{ KNegInfTReal64, 5, KErrOverflow, KNegInfTReal64 },		// 59
+
+	// pow(-INF, y) returns +INF for y > 0 and not an odd integer
+	{ KNegInfTReal64, 2, KErrOverflow, KPosInfTReal64 },		// 60
+	{ KNegInfTReal64, 5.5, KErrOverflow, KPosInfTReal64 },		// 61
+
+	// pow(+INF, y) returns +0 for y < 0
+	{ KPosInfTReal64, -1, KErrNone, KPosZeroTReal64 },			// 62
+	{ KPosInfTReal64, -2, KErrNone, KPosZeroTReal64 },			// 63
+	{ KPosInfTReal64, -5, KErrNone, KPosZeroTReal64 },			// 64
+	{ KPosInfTReal64, -5.5, KErrNone, KPosZeroTReal64 },		// 65
+
+	// pow(+INF, y) returns +INF for y > 0
+	{ KPosInfTReal64, 1, KErrOverflow, KPosInfTReal64 },		// 66
+	{ KPosInfTReal64, 2, KErrOverflow, KPosInfTReal64 },		// 67
+	{ KPosInfTReal64, 5, KErrOverflow, KPosInfTReal64 },		// 68
+	{ KPosInfTReal64, 5.5, KErrOverflow, KPosInfTReal64 },		// 69
+	};
+
+struct POW10_TEST
+    {
+    TInt num; // input number
+    TReal res; // expected result
+    };
+
+LOCAL_D POW10_TEST pow10teste[]=
+	{
+	{300,1.0E300},		
+	{-162,1.0E-162},
+	{-300,1.0E-300},
+	{-99,1.0E-99},
+//	};
+
+//LOCAL_D POW10_TEST pow10testa[]=
+//	{
+	{99,1.0E99},
+	{283,1.0E283},
+	{-89,1.0E-89},
+	{-200,1.0E-200},
+	{-43,1.0E-43},
+	{24,1.0E24},
+ 	{-310,K1EMinus310Real64},
+ 	{-323,K1EMinus323Real64}
+	};
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } TESTSINE;
+
+#pragma warning ( disable : 4204 ) // non-constant aggregate initializer
+LOCAL_D TESTSINE testsin[]=
+    {
+	{0.5,0.4794255386042029},						// These were found using S3a
+	{1.2,0.9320390859672263},
+	{1.6,0.9995736030415051},
+	{28.6,-0.3199399618841981},
+	{-18.3,0.5223085896267315},
+	{KPi/4,0.7071067811865474},
+	{3*KPi/4,0.7071067811865474},
+	{5*KPi/4,-0.7071067811865474},
+	{-KPi/4,-0.7071067811865474},
+	{KPi/3,0.8660254037844387},
+	{-KPi/3,-0.8660254037844387},
+	{KPi/6,0.5},
+	{-KPi/6,-0.5},
+	{150*KDegToRad,0.5},
+	{210*KDegToRad,-0.5},
+//	{KPi+1.0E-15,-7.657143961860984E-16},	// loss of significance will limit accuracy here
+//	2*(KPi+1.0E-15),1.5314287923721969e-15}
+    };
+    
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } TESTCOSINE;
+
+LOCAL_D TESTCOSINE testcos[]=
+	{
+	{0.5,0.8775825618903727},			// These were found using S3a
+	{1.2,0.3623577544766734},
+	{1.6,-0.0291995223012888},
+	{28.6,-0.9474378189567576},
+	{-18.3,0.8527565521308730},
+	{KPi/4,0.7071067811865474},
+	{3*KPi/4,-0.7071067811865474},
+	{5*KPi/4,-0.7071067811865474},
+	{-KPi/4,0.7071067811865474},
+	{KPi/6,0.8660254037844387},
+	{5*KPi/6,-0.8660254037844387},
+	{KPi/3,0.5},
+	{4*KPi/3,-0.5},
+	{120*KDegToRad,-0.5},
+	{300*KDegToRad,0.5},
+	{KPi+1.0E-15,-1.0},
+	{2*(KPi+1.0E-15),1.0}
+	};
+
+typedef struct
+    {
+    TReal angle; // angle for which the tangent is to be found
+    TReal result; // result
+    } TAN;
+
+LOCAL_D TAN testtan[]=
+    {
+	{KPi/4,1.0},
+	{-KPi/4,-1.0},
+	{45*KDegToRad,1.0},
+	{KPi/3,1.732050807568877},					// Added by AnnW - Calculated on S3a
+	{2*KPi/3,-1.732050807568878},				//
+	{KPi/6,0.5773502691896257},					//
+	{-KPi/6,-0.5773502691896257},				//
+	{89*KDegToRad,57.28996163075913},			// these two should be the same!
+	{91*KDegToRad,-57.28996163075955},			//
+    {4E-123,4E-123},								
+    {-4E-123,-4E-123},	
+    };
+    
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } TESTASC;
+
+LOCAL_D TESTASC testas[]=
+    {
+    {.75,.848062078981},
+    {.82,.961411018764},
+    {.87,1.055202320549},
+    {.89,1.097345169523},
+    {.90,1.119769514999},
+    {.92,1.168080485214},
+    {.94,1.222630305522},
+    {.96,1.287002217587},
+    {.99,1.429256853470},
+    {1.0,1.570796326795},
+	{0.0,0},
+	{-1.0, -90.0*KDegToRad},
+	{0.5,30.0*KDegToRad}
+    };
+
+typedef struct
+    {
+    TReal num1; // Divisor
+    TReal num2; // Divand
+    TReal res; // expected result
+    } TESTATAN2;
+
+LOCAL_D TESTATAN2 testat2[]=
+    {
+    {5E-49,7E306,0.0}, // underflow, zero returned
+    {5E49,7E-306,KPiBy2}, // overflow, pi/2 returned
+    {0.45,0.5,0.732815101787},
+    {0.12,0.3,0.380506377112},
+    {0.3,0.0,KPiBy2}, // overflow, pi/2 returned
+    {-0.3,0.0,-KPiBy2}, // overflow, -pi/2 returned
+    {0.0,0.3,0.0},
+    };
+#pragma warning ( default : 4204 )
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } INT_TEST;
+
+LOCAL_D INT_TEST testint1[]=
+    {
+    {1.0,1.0},
+    {1.47934,1.0},
+    {-72.86345,-72.0},
+    {-734.9999,-734.0},
+    {4855.9974,4855.0},
+    {232478.35,232478.0},
+    {0.029345,0.0},
+    {0.9437,0.0},
+    {-0.2634,0.0},
+    {-0.98976,0.0},
+    {32769.36946,32769.0},
+    {-32774.997937,-32774.0},
+    {8738465.38749,8738465.0},
+    {-2348645.34965,-2348645.0},
+    {2147483655.7565,2147483655.0},
+    {-2147483657.89453,-2147483657.0},
+    {2374843546.34E2,2374843546.34E2},
+    {34780656.37643E12,34780656.37643E12},
+    {-2374843546.34E2,-2374843546.34E2},
+    {-34780656.37643E12,-34780656.37643E12},
+    {468650.3874E47,468650.3874E47},
+    {-4965.5987636E34,-4965.5987636E34},
+    };
+
+typedef struct
+    {
+    TReal num; // input number
+    TInt16 res; // expected result
+    } INTI_TEST;
+
+LOCAL_D INTI_TEST testint2[]=
+    {
+    {1.0,1},
+    {1.47934,1},
+    {-72.86345,-72},
+    {-734.9999,-734},
+    {4855.9974,4855},
+    {0.029345,0},
+    {0.9437,0},
+    {-0.2634,0},
+    {-0.98976,0},
+    {3234.56,3234},
+    {4698.435,4698},
+    {-32767.47658,-32767},
+    {32767.9830857,32767},
+    {-32768.47658,-32767-1}
+    };
+
+typedef struct
+    {
+    TReal num; // input number
+    TInt32 res; // expected result
+    } INTL_TEST;
+
+LOCAL_D INTL_TEST testint3[]=
+    {
+    {1.0,1l},
+    {1.47934,1l},
+    {-72.86345,-72l},
+    {-734.9999,-734l},
+    {4855.9974,4855l},
+    {0.029345,0l},
+    {0.9437,0l},
+    {-0.2634,0l},
+    {-0.98976,0l},
+    {3234.56,3234l},
+    {4698.435,4698l},
+    {-32767.47658,-32767l},
+    {32767.9830857,32767l},
+    {32769.36946,32769l},
+    {-32774.997937,-32774l},
+    {64835903.74605,64835903l},
+    {-46652024.393,-46652024l},
+    {2147483647.34576,2147483647l},
+    {-2147483647.9501,-2147483647l},
+    {-2147483648.00,0x80000000l}, 
+    {-2147483648.6843,0x80000000l}
+    };
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal res; // expected result
+    } FRAC_TEST;
+
+LOCAL_D FRAC_TEST testfrac[]=
+    {
+	{0.0,0.0},
+	{KNegZeroTReal64,0.0},
+    {1.0,0.0},
+    {1.47934,.47934},
+    {-72.86345,-.86345},
+    {-734.9999,-.9999},
+    {4855.9974,.9974},
+    {232478.35,.35},
+    {0.029345,.029345},
+    {0.9437,0.9437},
+    {-0.2634,-.2634},
+    {-0.98976,-.98976},
+    {32769.36946,.36946},
+    {-32774.997937,-0.997937},
+    {8738465.38749,0.38749},
+    {-2348645.34965,-0.34965},
+    {2147483655.7565,0.7565},
+    {-2147483657.89453,-.89453},
+    {2374843546.34E2,0.0},
+    {34780656.37643E12,0.0},
+    {-2374843546.34E2,0.0},
+    {-34780656.37643E12,0.0},
+    {468650.3874E47,0.0},
+    {-4965.5987636E34,0.0}
+    };
+
+typedef struct
+    {
+    TReal num; // input number
+    TReal mod; // modulo
+    TReal res; // expected result
+    } MOD_TEST;
+
+LOCAL_D MOD_TEST testmod[]=
+    {
+    {4.0,2.0,0.0},
+    {3.0,2.0,1.0},
+    {56.847,2.3,1.647},
+    {-65.6478,.65,-.6478},
+    {-6858.78432,-87.5323,-31.26492},
+    {7665.140215,-34.98,4.520215},
+    {.4645,1.0,0.4645},
+    {-.246,1.0,-.246},
+	{1.0,KPosInfTReal64,1.0},
+	{1.0,KNegInfTReal64,1.0},
+	{1.0E17,8.0,0.0},
+	//
+	{1.0,3.0,1.0},				//0
+	{2.0,3.0,2.0},
+	{4.0,3.0,1.0},
+	{8.0,3.0,2.0},
+	{16.0,3.0,1.0},
+	{32.0,3.0,2.0},
+	{64.0,3.0,1.0},
+	{128.0,3.0,2.0},
+	{256.0,3.0,1.0},
+	{512.0,3.0,2.0},
+	{1024.0,3.0,1.0},			//10
+	{2048.0,3.0,2.0},
+	{4096.0,3.0,1.0},
+	{8192.0,3.0,2.0},
+	{16384.0,3.0,1.0},
+	{32768.0,3.0,2.0},
+	{65536.0,3.0,1.0},
+	{131072.0,3.0,2.0},
+	{262144.0,3.0,1.0},
+	{524288.0,3.0,2.0},
+	{1048576.0,3.0,1.0},		//20
+	{2097152.0,3.0,2.0},
+	{4194304.0,3.0,1.0},
+	{8388608.0,3.0,2.0},
+	{16777216.0,3.0,1.0},
+	{33554432.0,3.0,2.0},
+	{67108864.0,3.0,1.0},
+	{134217728.0,3.0,2.0},
+	{268435456.0,3.0,1.0},
+	{536870912.0,3.0,2.0},
+	{1073741824.0,3.0,1.0},		//30
+	{2147483648.0,3.0,2.0},
+	{4294967296.0,3.0,1.0},
+	{8589934592.0,3.0,2.0},
+	{17179869184.0,3.0,1.0},
+	{34359738368.0,3.0,2.0},
+	{68719476736.0,3.0,1.0},
+	{137438953472.0,3.0,2.0},
+	{274877906944.0,3.0,1.0},
+	{549755813888.0,3.0,2.0},
+	{1099511627776.0,3.0,1.0},	//40
+	{2199023255552.0,3.0,2.0},
+	{4398046511104.0,3.0,1.0},
+	{8796093022208.0,3.0,2.0},
+	{17592186044416.0,3.0,1.0},
+	{35184372088832.0,3.0,2.0},
+	{70368744177664.0,3.0,1.0},
+	{140737488355328.0,3.0,2.0},
+	{281474976710656.0,3.0,1.0},
+	{562949953421312.0,3.0,2.0},
+	{1125899906842624.0,3.0,1.0},	//50
+	{2251799813685248.0,3.0,2.0},
+	{4503599627370496.0,3.0,1.0},
+	{9007199254740992.0,3.0,2.0},
+	{18014398509481984.0,3.0,1.0},
+	{6.626176E-34,299792458.0,6.626176E-34},
+	{-1.6022E-19,6.022045E23,-1.6022E-19},
+	{0.0,2.71828182845904524,0.0}
+    };
+
+// expected result is unused in following - will be zero in all cases
+LOCAL_D MOD_TEST testmod2[]=
+    {
+	{1.0E17,7.9,0.0},
+	{1.0E100,4.0,0.0},
+	{KMaxTReal64,5.0,0.0},
+	{-KMaxTReal64,5.0,0.0},
+	{0.125,1.0E-17,0.0},
+	{36028797019963968.0,2.0,0.0},   // 2**55,2**1
+	//
+	{36028797019963968.0,3.0,0.0},	//55
+	{72057594039927936.0,3.0,0.0},
+	{144115188079855872.0,3.0,0.0},
+	{288230376159711744.0,3.0,0.0},
+	};
+
+TInt testApprox(TReal aFound,TReal aExpect,TReal aTol)
+//
+// Tests relative error, i.e. whether (aFound-aExpect)/aFound <= aTol
+//
+	{
+
+	TRealX diff,check,l,r,t;
+	l.Set(aFound);
+	r.Set(aExpect);
+	t.Set(aTol);
+	if (l.Mult(check,t)==KErrUnderflow)
+		{
+		l*=TRealX(1.0E20);
+		r*=TRealX(1.0E20);
+		}
+	diff=l-r;
+	if (diff.IsZero())
+		return ETrue;
+	if (!l.IsZero())
+		diff.DivEq(l);
+	if (Abs(TReal(diff))<=aTol)
+		return ETrue;
+	return EFalse;
+	}
+
+LOCAL_C void randrng(TReal& pret,TReal& llim,TReal& ulim)
+/*
+Returns a random number in the range [llim,ulim]
+*/
+    {
+
+    pret=Math::FRand(rseed);
+    pret*=ulim-llim;
+    pret+=llim;
+    }
+
+LOCAL_C TReal taylor(TReal x,TInt k)
+/*
+Evaluate the Taylor series approximation to arc sine up to terms of order k
+*/
+    //TReal x; // argument
+    //TInt k; // Highest order term
+    {
+
+    TInt i,j;
+    TReal den,num,res,term,di;
+
+    den=1;
+    num=1;
+    term=0;
+    for (i=1;i<=k;i+=2)
+		{
+		for (j=2;j<i;j+=2)
+			{
+			num*=j;
+			if (j<(i-1))
+			den*=j+1;
+			}
+		di=(TReal)i;
+		Math::Pow(res,x,di);
+		term+=(res*den)/(i*num);
+		num=1;
+		den=1;
+		}
+    return(term);
+    }
+
+LOCAL_C TReal tayatan(TReal val)
+/* 
+Finds the taylor series approximation to the arc tangent function 
+*/
+    //TReal val;
+    {
+
+    TInt i;
+    TReal sgn,s,d,di,term,res;
+    
+    term=0.0;
+    s=(-1.0);
+    for (i=0;i<8;i++)
+		{
+		di=(TReal)i;
+		d=2.0*di;
+		Math::Pow(sgn,s,di);
+		Math::Pow(res,val,d);
+		term+=(sgn*res)/(2.0*di+1.0);
+		}
+    return(val*term);
+    }
+
+LOCAL_C void AssortedTests()
+//
+// Tests the methods with just a handful of values each 
+// All tests as accurate as possible - if exact answer given, tests for equality
+//
+	{
+
+	TReal trg,src;
+
+	// ASin
+	test.Start(_L("Math::ASin()"));
+	test(Math::ASin(trg,0.0)==KErrNone);
+	test(trg==0.0);
+
+	test(Math::ASin(trg,1.0)==KErrNone);
+	test(testApprox(trg,1.5707963267949,5.0E-15));
+
+	// ACos
+	test.Next(_L("Math::ACos()"));
+	test(Math::ACos(trg,0)==KErrNone);
+	test(testApprox(trg,1.5707963267949,5.0E-15));
+
+	test(Math::ACos(trg,1.0)==KErrNone);
+	test(trg==0.0);
+
+	// ATan
+	test.Next(_L("Math::ATan()"));
+	test(Math::ATan(trg,0.0)==KErrNone);
+	test(trg==0.0);
+
+	test(Math::ATan(trg,1.0)==KErrNone);
+	test(testApprox(trg,0.78539816339745,5.0E-15));	
+
+	test(Math::Tan(trg,KPi/4)==KErrNone);
+	test(testApprox(trg,1.0,1.0E-15));
+	test(Math::ATan(trg,trg)==KErrNone);
+	test(testApprox(trg,KPi/4,1e-15));
+
+	// Sqrt
+	test.Next(_L("Math::Sqrt()"));
+	test(Math::Sqrt(trg,0.0)==KErrNone);
+	test(trg==0.0);
+	
+	test(Math::Sqrt(trg,-1.0)==KErrArgument);
+
+	test(Math::Sqrt(trg,100.0)==KErrNone);
+	test(testApprox(trg,10.0,1.0E-15));	
+
+	test(Math::Sqrt(trg,56.25)==KErrNone);
+	test(trg==7.5);
+
+	// Pow10
+	test.Next(_L("Math::Pow10()"));
+	test(Math::Pow10(trg,-2)==KErrNone);
+	test(trg==0.01);	
+
+	test(Math::Pow10(trg,-1)==KErrNone);
+	test(trg==0.1);
+
+	test(Math::Pow10(trg,0)==KErrNone);
+	test(trg==1.0);
+
+	test(Math::Pow10(trg,1)==KErrNone);
+	test(trg==10.0);
+
+	test(Math::Pow10(trg,2)==KErrNone);
+	test(trg==100.0);
+
+	// Ln
+	test.Next(_L("Math::Ln()"));
+	test(Math::Ln(trg,0.0)==KErrOverflow);
+	
+	test(Math::Ln(trg,1.0)==KErrNone);
+	test(trg==0.0);
+
+	test(Math::Ln(trg,2)==KErrNone);
+	test(testApprox(trg,0.69314718055995,1.0E-14));	
+
+	// Log
+	test.Next(_L("Math::Log()"));
+	test(Math::Log(trg,0)==KErrOverflow);
+
+	test(Math::Log(trg,1)==KErrNone);
+	test(trg==0);
+
+	test(Math::Log(trg,10)==KErrNone);
+	test(trg==1);
+
+	test(Math::Log(trg,100000)==KErrNone);
+	test(trg==5);
+
+	// Sin
+	test.Next(_L("Math::Sin()"));
+	test(Math::Sin(trg,0)==KErrNone);
+	test(trg==0);   
+
+	test(Math::Sin(trg,1)==KErrNone);
+	test(testApprox(trg,0.84147098480790,5.0E-15));	
+
+	test(Math::Sin(trg,KPi)==KErrNone);
+//    test(trg==0.0);
+	test(Abs(trg)<1e-15);
+
+	test(Math::Sin(trg,KPiBy2)==KErrNone);
+	test(testApprox(trg,1.0,1.0E-15));
+
+	test(Math::Sin(trg,10.0*KPi)==KErrNone);
+//   test(trg==0.0);
+	test(Abs(trg)<2e-15);
+
+	test(Math::Sin(trg,3)==KErrNone);
+	test(trg==0.1411200080598672);
+
+	test(Math::Sin(trg,4)==KErrNone);
+	test(trg==-0.7568024953079282);
+
+	test(Math::Sin(trg,3.1415)==KErrNone);
+	test(testApprox(trg,9.26535896605E-5,2.0E-13));	
+
+	test(Math::Sin(trg,3.1416)==KErrNone);
+	test(testApprox(trg,-7.3464102066435914E-6,1.0E-11));	
+
+	test(Math::Sin(trg,(10.0*KPi)+0.001)==KErrNone);
+	test(testApprox(trg,0.000999999833333,4.0E-13));	
+
+	// Cos
+	test.Next(_L("Math::Cos()"));
+	test(Math::Cos(trg,0.0)==KErrNone);
+	test(testApprox(trg,1.0,1.0E-15));		
+
+	test(Math::Cos(trg,1)==KErrNone);
+	test(testApprox(trg,0.54030230586814,1.0E-15));		
+
+    test(Math::Cos(trg,KPiBy2)==KErrNone);
+//    test(trg==0.0);
+	test(Abs(trg)<1e-15);
+
+	test(Math::Cos(trg,KPi)==KErrNone);
+	test(trg==-1.0);
+
+    test(Math::Cos(trg,KPiBy2+KPi)==KErrNone);
+//    test(trg==0.0);
+	test(Abs(trg)<1e-15);
+	
+	test(Math::Cos(trg,89.99999*KDegToRad)==KErrNone);
+	test(testApprox(trg,1.745329252E-07,5.0E-10));		
+
+	test(Math::Cos(trg,90.00001*KDegToRad)==KErrNone);
+	test(testApprox(trg,-1.7453292516217e-007,5.0E-10));			
+
+	// Tan
+	test.Next(_L("Math::Tan()"));
+	test(Math::Tan(trg,0.0)==KErrNone);
+    test(trg==0.0);   
+
+	test(Math::Tan(trg,1)==KErrNone);
+	test(testApprox(trg,1.5574077246549,2.0E-15));			
+
+	// Pow
+	test.Next(_L("Math::Pow()"));
+	src=10;
+	test(Math::Pow(trg,src,-1.0)==KErrNone);
+	test(testApprox(trg,0.1,1.0E-15));			
+
+	test(Math::Pow(trg,src,0.0)==KErrNone);
+	test(trg==1.0);
+
+	test(Math::Pow(trg,src,2.0)==KErrNone);
+	test(testApprox(trg,100.0,1.0E-15));			
+
+	src=1.0;
+	test(Math::Pow(trg,src,10000000000000000.0)==KErrNone);
+	test(trg==1.0);
+
+	test.End();
+	}       
+
+LOCAL_C void sqrtest1(TReal low,TReal upp)
+/*
+Test the identity sqrt(x*x)=x  on the range low<=x<upp
+*/
+    {
+    
+	TReal x,y,res;
+
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		y=x*x;
+		test(Math::Sqrt(res,y)==KErrNone);
+		test(testApprox(res,x,1.0E-15));
+		}
+    }
+
+LOCAL_C void sqrtest2()
+/*
+Tests specific numbers
+*/
+    {
+    
+	TReal root;
+
+	// test errors
+	test(Math::Sqrt(root,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(root));
+	test(Math::Sqrt(root,-1)==KErrArgument);
+	test(Math::IsNaN(root));
+	test(Math::Sqrt(root,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(root));
+	test(Math::Sqrt(root,KPosInfTReal64)==KErrOverflow);
+	test(root==KPosInfTReal64);
+
+    TInt i=sizeof(testsqrt)/sizeof(SQRT_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Sqrt(root,testsqrt[j].num)==KErrNone);
+		test(testApprox(root,testsqrt[j].res,1.0E-15));
+		}
+
+	// a couple of denormal tests
+	test(Math::Sqrt(root,4E-322)==KErrNone);
+	test(testApprox(root,2E-161,1.0E-3));
+	test(Math::Sqrt(root,1.6E-309)==KErrNone);
+	test(testApprox(root,4E-155,1.0E-15));	
+    }
+
+LOCAL_C void logtest()
+/*
+Test numbers in the range sqrt(.1) to .9, using the identity 
+log(x)=log(11x/10)-log(1.1) 
+*/
+    {
+
+    TReal res,x;
+    TReal cnstlog,cnstlogx;
+
+    TReal low=.316227766017;
+    TReal upp=0.9;
+    TReal cnst=11.0/10.0;
+    test(Math::Log(cnstlog,cnst)==KErrNone);
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Log(res,x)==KErrNone); 
+		TReal num=cnst*x;
+		test(Math::Log(cnstlogx,num)==KErrNone);
+		test(testApprox(res,(cnstlogx-cnstlog),1.0E-15));
+		}
+    }
+
+LOCAL_C void lntest1()
+/* 
+Test selected numbers 
+*/
+    {
+ 
+    TReal res;
+
+	// test errors
+//	test(Math::Ln(res,KNegZeroTReal64)==KErrArgument);
+	test(Math::Ln(res,KNegZeroTReal64)==KErrOverflow);
+	test(Math::IsInfinite(res));
+	test(Math::Ln(res,-34)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Ln(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Ln(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Ln(res,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Ln(res,0.0)==KErrOverflow);
+	test(res==KNegInfTReal64);
+	test(Math::Ln(res,2.71828182845904524)==KErrNone);
+	test(testApprox(res,1.0,1e-15));
+	test(Math::Ln(res,7.389056098930650227)==KErrNone);
+	test(testApprox(res,2.0,1e-15));
+
+    TInt i=sizeof(testln)/sizeof(TESTLN);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Ln(res,testln[j].num)==KErrNone);
+		test(testApprox(res,testln[j].res,1.0E-14));
+		}
+
+	// test some denormals
+ 	test(Math::Log(res,K1EMinus322Real64)==KErrNone);
+	test(testApprox(res,-322.0,2.0E-5));
+ 	test(Math::Log(res,K1EMinus313Real64)==KErrNone);
+	test(testApprox(res,-313.0,1.0E-13));	
+    }
+
+LOCAL_C void lntest2()
+/* 
+Test numbers near to one against the Taylor series approximation 
+*/
+    {
+    
+	TReal x,res;
+    
+    TReal low=.999999989463;
+    TReal upp=1.00000001054;
+    for (TInt k=0;k<10;k++)
+		{
+		randrng(x,low,upp);
+		TRealX tot=0.0;
+		TRealX xx(x-1);
+		TInt sign=-1;
+		for (TInt i=4;i>0;i--)
+			{
+			tot+=TRealX(sign)/TRealX(i);
+			tot*=xx;
+			sign=-sign;
+			}
+		TReal tot2=(TReal)tot;
+		test(Math::Ln(res,x)==KErrNone);
+		test(testApprox(res,tot2,1.0E-15));
+		}
+    }
+
+LOCAL_C void lntest3()
+/* 
+Test numbers in the range sqrt(.5) to 15/16, using the identity 
+ln(x)=ln(17x/16)-ln(17/16) 
+*/
+    {
+
+    TReal x,cnstln,cnstlnx,res;
+
+	TReal low=KSqhf;
+    TReal upp=15.0/16.0;
+    TReal cnst=17.0/16.0;
+    test(Math::Ln(cnstln,cnst)==KErrNone);
+	for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Ln(res,x)==KErrNone);
+		TReal num=cnst*x;
+		test(Math::Ln(cnstlnx,num)==KErrNone);
+		test(testApprox(res,(cnstlnx-cnstln),1.0E-15));
+		}
+    }
+
+LOCAL_C void lntest4()
+/* 
+Test numbers in the range 16 to 240 using the identity ln(x*x)=2ln(x) 
+*/
+    {
+
+    TReal cnstlnx,res;
+
+    TReal low=16.0;
+    TReal upp=240.0;
+    TReal x=16.0;
+	test(Math::Ln(res,-1)==KErrArgument);
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		TReal num=x*x;
+		test(Math::Ln(res,num)==KErrNone);
+		test(Math::Ln(cnstlnx,x)==KErrNone);
+		test(testApprox(res,2*cnstlnx,1.0E-15));
+		}
+    }
+
+LOCAL_C void exptest1()
+/* 
+To test exponent for specific values 
+*/
+    {
+
+    TReal res;
+
+	// test errors
+	test(Math::Exp(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Exp(res,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Exp(res,709.8)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Exp(res,KNegInfTReal64)==KErrUnderflow);
+	test(Math::IsZero(res));
+	test(Math::Exp(res,-745.2)==KErrUnderflow);
+	test(Math::IsZero(res));
+
+    TInt i=sizeof(testexp)/sizeof(EXP);
+    for (TInt j=0;j<i;j++)
+		{
+		test(Math::Exp(res,testexp[j].val)==KErrNone);
+		test(testApprox(res,testexp[j].result,0));	// NB only tests values with results of 1
+		}
+
+	// test some denormals
+	test(Math::Exp(res,5E-324)==KErrNone);
+	test(testApprox(res,1.0,0));
+	test(Math::Exp(res,-6E-318)==KErrNone);
+	test(testApprox(res,1.0,0));	
+	}
+
+LOCAL_C void exptest2(TReal cnst,TReal ll,TReal ul)
+/*
+Test the identity exp(x-cnst)=exp(x)*exp(-cnst) for x in the range [ul,ll]
+*/
+    //TReal cnst; // constant used in the identity
+    //TReal ll; // Lower limit of the range
+    //TReal ul; // Upper limit of the range
+    {
+
+    TReal cnstexp,cnstexpx,x,res;
+
+    test(Math::Exp(cnstexp,cnst)==KErrNone);
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,ll,ul);
+		test(Math::Exp(res,x)==KErrNone);
+		TReal num=x+cnst;
+		test(Math::Exp(cnstexpx,num)==KErrNone);
+		test(testApprox(cnstexpx,(res*cnstexp),1.0E-15));
+		}
+    }
+
+LOCAL_C void exptest3()
+/* 
+Test for systematic error 
+*/
+    {
+    
+	TReal step,ul,v;
+
+    TReal x=1.0123;
+    TReal y=x/2;
+    test(Math::Exp(v,y)==KErrNone);
+    test(Math::Exp(step,x)==KErrNone);
+    test(Math::Sqrt(ul,step)==KErrNone);
+	test(testApprox(ul,v,1.0E-15));
+    }
+
+LOCAL_C void powtest1()
+/*
+Test selected numbers
+*/
+    {
+    
+	TReal res;
+	
+	// test errors
+	test(Math::Pow(res,10,-1E8)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow(res,10,-KMaxTReal64)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow(res,10,-5.5E307)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow(res,10,-5.4E307)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow(res,10,-1E300)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow(res,10,-1E10)==KErrUnderflow);
+	test(res==0.0);
+	
+	test(Math::Pow(res,10,5.5E307)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,10,5.4E307)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,10,1E308)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,10,1.7E308)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,10,KMaxTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	
+	test(Math::Pow(res,1.0,KNaNTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,KNaNTReal64,1.0)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Pow(res,0.0,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Pow(res,KNaNTReal64,0.0)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,KNaNTReal64,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Pow(res,KPosInfTReal64,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+//	test(Math::Pow(res,KNegInfTReal64,KPosInfTReal64)==KErrOverflow);
+//	test(res==KPosInfTReal64);
+	test(Math::Pow(res,KNegInfTReal64,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,2.0,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+//	test(Math::Pow(res,-2.0,KPosInfTReal64)==KErrOverflow);
+//	test(res==KPosInfTReal64);
+	test(Math::Pow(res,-2.0,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,0.5,KNegInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+//	test(Math::Pow(res,-0.5,KNegInfTReal64)==KErrOverflow);
+//	test(res==KPosInfTReal64);
+	test(Math::Pow(res,-0.5,KNegInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+//	test(Math::Pow(res,1.0,KPosInfTReal64)==KErrArgument);
+//	test(Math::IsNaN(res));
+	test(Math::Pow(res,1.0,KPosInfTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,-1.0,KPosInfTReal64)==KErrNone);
+	test(res==1.0);
+//	test(Math::Pow(res,1.0,KNegInfTReal64)==KErrArgument);
+//	test(Math::IsNaN(res));
+	test(Math::Pow(res,1.0,KNegInfTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,-1.0,KNegInfTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,0.0,0.0)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,KNegZeroTReal64,KNegZeroTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,0.0,KNegZeroTReal64)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,KNegZeroTReal64,0.0)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,KPosInfTReal64,2.0)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,0.0,-2.0)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,-2.0,-2.6)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Pow(res,-2.0,4.8)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Pow(res,KNegZeroTReal64,-5)==KErrOverflow);
+	test(res==KNegInfTReal64);
+	test(Math::Pow(res,KNegZeroTReal64,-6)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,30,999999)==KErrOverflow);	// checking bug fixed
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,200,200)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,200,2000)==KErrOverflow);	// checking bug fixed
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,1000,1000)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow(res,1000,100)==KErrNone);
+	test(testApprox(res,1E+300,3.0E-15));
+	test(Math::Pow(res,1000,-1000)==KErrUnderflow);
+	test(Math::IsZero(res));
+	test(Math::Pow(res,1000,-100)==KErrNone);
+	test(testApprox(res,1E-300,4.0E-15));
+	
+	TInt j;
+    TInt i=sizeof(testpow)/sizeof(POWER);
+    for (j=0;j<i;j++)
+		{
+		test(Math::Pow(res,testpow[j].number,testpow[j].power)==KErrNone);
+		test(testApprox(res,testpow[j].result,1.0E-15));
+		}
+
+	// Added by AnnW, October 1996
+	TInt size = sizeof(testpowexact)/sizeof(POWER);
+	for (j=0; j<size; j++)
+		{
+		test(Math::Pow(res,testpowexact[j].number,testpowexact[j].power)==KErrNone);
+		test(res==testpowexact[j].result);
+		}
+
+	// denormals (base only - do not know results for denormal power)
+ 	test(Math::Pow(res,K5EMinus324Real64,1.0)==KErrNone);
+ 	test(res==K5EMinus324Real64);
+ 	test(Math::Pow(res,K5EMinus324Real64,0.0)==KErrNone);
+	test(res==1.0);
+	test(Math::Pow(res,2E-160,2.0)==KErrNone);
+	test(testApprox(res,K4EMinus320Real64,1.0E-4));		
+
+	// This test is to check that reduce() is working properly
+	// This is only a very approximate test due to loss of significance for such nos
+	TReal base,power;
+	for (TReal powerOfTwo=16.0; powerOfTwo<=54.0; powerOfTwo++)
+		{
+		Math::Pow(power,2.0,powerOfTwo);
+		power+=0.7;
+ 		Math::Pow(base,2.0,1/power);
+		test(Math::Pow(res,base,power)==KErrNone);
+		test((2.0-res)<=1.0);
+		}
+    }
+
+LOCAL_C void powtest2(TReal low,TReal upp)
+/*
+Test the identity (x**2)**1.5=x**3  on the range low<=x<upp
+*/
+    //TReal low; // lower limit of range to test
+    //TReal upp; // upper limit of range to test 
+    {
+    
+	TReal res,rres,x;
+
+	for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		TReal y=2;
+		test(Math::Pow(res,x,y)==KErrNone);
+		TReal xr=res;
+		y=1.5;
+		test(Math::Pow(res,xr,y)==KErrNone);
+		TReal yr=3;
+		test(Math::Pow(rres,x,yr)==KErrNone);    
+		test(testApprox(rres,res,1.0E-14));
+		}
+    }
+
+LOCAL_C void powtest3()
+/* 
+Test the identity x**1=x 
+*/
+    {
+    
+	TReal x,res;
+ 
+    TReal low=.5;
+    TReal upp=1.0;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		TReal y=1.0;
+		test(Math::Pow(res,x,y)==KErrNone);
+		test(testApprox(res,x,1.0E-15));
+		}
+    }
+
+LOCAL_C void powtest4()
+/* 
+Test the identity (x**2)**(y/2)=x**y 
+*/
+    {
+    
+	TReal res,xr,rres,x,y;
+    
+    TReal low=.01;
+    TReal upp=10.0;
+    TReal lowy=-98; // range for y
+    TReal uppy=98;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		randrng(y,lowy,uppy);
+		test(Math::Pow(res,x,y)==KErrNone);
+		TReal yr=2;
+		test(Math::Pow(xr,x,yr)==KErrNone);
+		y/=2;
+		test(Math::Pow(rres,xr,y)==KErrNone);
+		test(testApprox(res,rres,5.0E-14));
+		}
+    }
+
+LOCAL_C void powtest5()
+/* 
+Test the identity x**y=1/(x**(-y)) 
+*/
+    {
+    
+	TReal x,y;
+    TReal res,rres;
+    
+	test(Math::Pow(res,-2,-3.765)==KErrArgument);
+    TReal low=0.5;
+    TReal upp=1.0;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		randrng(y,low,upp);
+		test(Math::Pow(res,x,y)==KErrNone);
+		y*=(-1);
+		test(Math::Pow(rres,x,y)==KErrNone);
+		rres=1/rres;
+		test(testApprox(res,rres,5.0E-15));
+		}
+    }
+
+LOCAL_C void powtest6()
+/* 
+Test specific ISO requirements on Pow()
+*/
+	{
+	TInt i;
+	TInt n = sizeof(testpow_iso) / sizeof(POWERISO);
+	for (i = 0; i < n; i++)
+		{
+		TReal ans;
+		TInt rc;
+
+		// If one of these tests fails, convert the "failed check xx" number
+		// to an index in testpow_iso[] by subtracting 1 and then dividing by 2.
+		// If the original number was odd, the first test (rc == xxx) failed.
+		// If the original number was even, the second test (.result) failed.
+		rc = Math::Pow(ans, testpow_iso[i].number, testpow_iso[i].power);
+		test(rc == testpow_iso[i].rc);
+		test((rc == KErrArgument) || (ans == testpow_iso[i].result));
+		}
+	}
+
+LOCAL_C void pow10test()
+//
+// Test Pow10() for various selected values - results should indicate which string to 
+// binary conversions would NOT be expected to be exact - see t_float
+//
+	{
+
+	TReal res;
+
+	// test errors
+	test(Math::Pow10(res,-324)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow10(res,-400)==KErrUnderflow);
+	test(res==0.0);
+	test(Math::Pow10(res,309)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Pow10(res,400)==KErrOverflow);
+	test(res==KPosInfTReal64);
+
+	TInt j;
+	TInt i=sizeof(pow10teste)/sizeof(POW10_TEST);
+
+	for (j=0; j<i; j++)
+		{
+		test(Math::Pow10(res,pow10teste[j].num)==KErrNone);
+		test(res==pow10teste[j].res);
+		}
+
+/*	i=sizeof(pow10testa)/sizeof(POW10_TEST);
+	
+	for (j=0; j<i; j++)
+		{
+		test(Math::Pow10(res,pow10testa[j].num)==KErrNone);
+		test(testApprox(res,pow10testa[j].res,1.0E-15));
+		}
+*/	}
+
+LOCAL_C void sintest1(TReal low,TReal upp)
+/*
+Test the identity sin(x)=sin(x/3)[3-4*(sin(x/3))**2] on the range low<=x<upp
+*/
+    //TReal low; // lower limit of range to test
+    //TReal upp; // upper limit of range to test 
+    {
+    
+	TReal x,res,rres;
+
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Sin(res,x)==KErrNone);
+		x/=3;
+		test(Math::Sin(rres,x)==KErrNone);
+		TReal err=rres*rres;
+		err*=4;
+		err=3-err;
+		err*=rres;
+		test(testApprox(res,err,1.0E-12));
+		}
+    }
+
+LOCAL_C void sintest2()
+/* 
+Test selected values (which may not give exact results) 
+*/
+    {
+    
+	TReal res;
+	
+	// test errors
+	test(Math::Sin(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Sin(res,KPosInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Sin(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Sin(res,2147483648.0*KPi)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Sin(res,-1E+10)==KErrArgument);
+	test(Math::IsNaN(res));
+
+	TInt i=sizeof(testsin)/sizeof(TESTSINE);
+    TInt j;
+    
+	for (j=0;j<i;j++)
+		{
+		TReal x=testsin[j].num;
+		TReal y=testsin[j].res;
+		test(Math::Sin(res,x)==KErrNone);
+   		test(testApprox(res,y,1.0E-15));
+		}
+
+	//Added by AnnW, October 1996
+	TInt mult=101;
+	for (j=-(mult-1); j<mult; j++)
+		{
+		test(Math::Sin(res, (4*j+1)*KPiBy2)==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));
+
+		test(Math::Sin(res, (4*j+3)*KPiBy2)==KErrNone);
+		test(testApprox(res,-1.0,1.0E-15));
+
+		test(Math::Sin(res, ((4*j+1)*90)*KDegToRad)==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));
+
+		test(Math::Sin(res, ((4*j+3)*90)*KDegToRad)==KErrNone);
+		test(testApprox(res,-1.0,1.0E-15));
+		}
+	//
+    }
+
+LOCAL_C void sintest3()
+/* 
+To test the identity sin(-x)=-sin(x) on the range [0,10*pi] 
+*/        
+    {
+    
+	TReal x,res,rres;
+
+    TReal low=0.0;
+    TReal upp=10*KPi;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Sin(res,x)==KErrNone);
+		x*=(-1);
+		test(Math::Sin(rres,x)==KErrNone);
+		test(testApprox(rres,-res,1.0E-15));
+		}
+    }
+
+LOCAL_C void sintest4()
+/* 
+To test the identity sin(x)=x for x<<1 
+*/        
+    {
+    
+	TReal res,x;
+    TReal low=1E-90;
+    TReal upp=1E-10;
+
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Sin(res,x)==KErrNone);
+		test(testApprox(res,x,1.0E-15));
+		}
+
+	// test some denormals
+	test(Math::Sin(res,5E-324)==KErrNone);
+	test(testApprox(res,5E-324,1.0E-15));
+	test(Math::Sin(res,7E-317)==KErrNone);
+	test(testApprox(res,7E-317,1.0E-15));		
+    }
+/*
+LOCAL_C void sintest5()
+//
+// To test that exact results are given for multiples of pi and
+// values sufficiently close to them 
+// Added by AnnW, October 1996
+//
+	{
+	
+	TReal res;
+	TInt j;
+	TInt mult=101; // can use up to 32768
+
+    test(Math::Sin(res,KNegZeroTReal64)==KErrNone);
+	test(res==0.0);
+
+    for (j=-(mult-1); j<mult; j++)
+		{
+		test(Math::Sin(res, j*KPi)==KErrNone);
+		test(res==0.0);
+		test(Math::Sin(res, j*(KPi+1.224E-16))==KErrNone);
+		test(res==0.0);
+		test(Math::Sin(res, (j*180)*KDegToRad)==KErrNone);
+		test(res==0.0);
+		if (j!=0)
+			{
+			test(Math::Sin(res, j*(KPi+1.0E-14))==KErrNone);
+			test(res!=0.0);
+			}		
+		}
+	}
+*/
+LOCAL_C void costest1()
+/* 
+To test the identity cos(x)=cos(x/3)[4*(cos(x/3)**2)-3] on the interval 
+[7*pi,7.5*pi] 
+Added by AnnW, October 1996
+*/
+    {
+
+    TReal x,res,rres;
+
+    TReal low=7*KPi;
+    TReal upp=7.5*KPi;
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Cos(res,x)==KErrNone);
+		x/=3;
+		test(Math::Cos(rres,x)==KErrNone);
+		test(testApprox(res,rres*(4*(rres*rres)-3),5.0E-13));
+		}
+    }
+
+LOCAL_C void costest2()
+/*
+Test selected values (which may not give exact results) 
+Added by AnnW, October 1996
+*/
+    {
+    
+	TReal res;
+
+	// test errors
+	test(Math::Cos(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Cos(res,KPosInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Cos(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Cos(res,(2147483648.0*KPi))==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Sin(res,-1E+10)==KErrArgument);
+	test(Math::IsNaN(res));
+
+	TInt j;
+	TInt mult=101;
+	TInt i=sizeof(testcos)/sizeof(TESTCOSINE);
+
+    for (j=0; j<i; j++)
+		{
+		test(Math::Cos(res,testcos[j].num)==KErrNone);
+		test(testApprox(res,testcos[j].res,1.0E-15));		
+		}
+
+	test(Math::Cos(res,KNegZeroTReal64)==KErrNone);
+	test(testApprox(res,1.0,1E-15));
+
+    for (j=-(mult-1); j<mult; j++)
+		{
+		test(Math::Cos(res, (2*j)*KPi)==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));		
+
+		test(Math::Cos(res, (2*j+1)*KPi)==KErrNone);
+		test(testApprox(res,-1.0,1.0E-15));		
+
+		test(Math::Cos(res, (2*j)*(KPi+1.224E-16))==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));		
+
+		test(Math::Cos(res, (2*j+1)*(KPi+1.224E-16))==KErrNone);
+		test(testApprox(res,-1.0,1.0E-15));		
+
+		test(Math::Cos(res, ((2*j)*180)*KDegToRad)==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));		
+
+		test(Math::Cos(res, ((2*j+1)*180)*KDegToRad)==KErrNone);
+		test(testApprox(res,-1.0,1.0E-15));		
+		}
+    }
+
+LOCAL_C void costest3()
+/* 
+To test the identity cos(-x)=cos(x) on the range [0,10*pi]
+Added by AnnW, October 1996 
+*/        
+    {
+
+    TReal x,res,rres;
+
+    TReal low=0.0;
+    TReal upp=10*KPi;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Cos(res,x)==KErrNone);
+		x*=(-1);
+		test(Math::Cos(rres,x)==KErrNone);
+		test(testApprox(rres,res,1.0E-15));		
+		}
+    }
+
+LOCAL_C void costest4()
+/* 
+To test the identity cos(x)=1 for x<<1 
+Added by Annw, October 1996
+*/        
+    {
+
+    TReal res,x;
+    TReal low=1E-90;
+    TReal upp=1E-10;
+
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Cos(res,x)==KErrNone);
+		test(testApprox(res,1.0,1.0E-15));
+		}
+
+	// test some denormals
+	test(Math::Cos(res,5E-324)==KErrNone);
+	test(testApprox(res,1.0,1.0E-15));
+	test(Math::Cos(res,1.34E-315)==KErrNone);
+	test(testApprox(res,1.0,1.0E-15));			
+    }
+/*
+LOCAL_C void costest5()
+//
+// To test that exact results are given for multiples of KPi and
+// values sufficiently close to them 
+// Added by AnnW, October 1996
+//
+	{
+
+	TReal res;
+	TInt mult=101;	// can use up to 32768
+	TInt j;
+    
+    for (j=-(mult-1); j<mult; j++)
+		{
+		test(Math::Cos(res, (2*j+1)*KPiBy2)==KErrNone);
+		test(res==0.0);
+		test(Math::Cos(res, (2*j+1)*KPiBy2+(j+1)*1.224E-16)==KErrNone);
+		test(res==0.0);
+		test(Math::Cos(res, (2*j+1)*90*KDegToRad)==KErrNone);
+		test(res==0.0);
+		if (j!=0)
+			{
+			test(Math::Sin(res, (2*j+1)*(KPiBy2+1.0E-14))==KErrNone);
+			test(res!=0.0);
+			}
+		}
+	}
+*/
+LOCAL_C void tantest1(TReal low,TReal upp)
+/*
+Test the identity tan(x)=(2*tan(x/2))/(1-tan(x/2)**2) on the range low<=x<upp
+*/
+    //TReal low; // lower limit of range to test
+    //TReal upp; // upper limit of range to test 
+    {
+
+    TReal x,res,rres;
+
+    for (TInt j=0;j<100;j++)
+		{
+		if (j==90)
+			{
+			test(1);
+			}
+		randrng(x,low,upp);
+		test(Math::Tan(res,x)==KErrNone);
+		x/=2;
+		test(Math::Tan(rres,x)==KErrNone);
+		TReal ex=(2*rres)/(1-rres*rres);
+		test(testApprox(res,ex,1.0E-15));		
+		}
+    }
+
+LOCAL_C void tantest2()
+/* 
+To test tangent for specific  arguments 
+*/
+    {
+
+    TReal res;
+
+	// test errors
+	test(Math::Tan(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Tan(res,KPosInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Tan(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Tan(res, 1073741824.0*KPi)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Tan(res, 4.0E+102)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Tan(res, -4.0E+102)==KErrArgument);
+	test(Math::IsNaN(res));
+    
+	TInt j;
+	TInt mult=101;	// can use up to 32768
+    TInt i=sizeof(testtan)/sizeof(TAN);
+    for (j=0;j<i;j++)
+		{
+		test(Math::Tan(res,testtan[j].angle)==KErrNone);
+		test(testApprox(res,testtan[j].result,1.0E-15));		
+		}
+
+	//Added by AnnW, October 1996
+	for (j=-(mult-1); j<mult; j++)
+		{
+//		test(Math::Tan(res, (2*j+1)*KPiBy2)==KErrOverflow);
+//		test(Math::IsInfinite(res));	// this test is no longer valid
+		test(Math::Tan(res, (2*j+1)*(KPiBy2+1.0E-15))!=KErrOverflow);
+		test(Math::IsFinite(res));
+		}
+	
+	// Check that signs are correct
+	test(Math::Tan(res,KPiBy2+5E-16)==KErrNone);
+	test(res<0);
+	test(Math::Tan(res,KPiBy2-5E-16)==KErrNone);
+	test(res>0);
+	}
+
+LOCAL_C void tantest3()
+/* 
+To test the identity tan(-x)=-tan(x) on the range [-1.5,1.5] 
+*/        
+    {
+
+    TReal x,res,rres;
+
+    TReal low=(-1.5);
+    TReal upp=1.5;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Tan(res,x)==KErrNone);
+		x*=(-1);
+		test(Math::Tan(rres,x)==KErrNone);
+		test(testApprox(rres,-res,1.0E-15));		
+		}
+    }
+
+LOCAL_C void tantest4()
+/* 
+To test the identity tan(x)=x for x<<1 
+*/        
+    {
+
+    TReal x,res;
+
+    TReal low=1E-90;
+    TReal upp=1E-10;
+    for (TInt j=0;j<10;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::Tan(res,x)==KErrNone);
+		test(testApprox(res,x,1.0E-15));		
+		}
+
+	// Check some denormals
+	test(Math::Tan(res,5E-324)==KErrNone);
+	test(res==5E-324);
+	test(Math::Tan(res,-1.234567891234E-315)==KErrNone);
+	test(res==-1.234567891234E-315);	
+    }
+/*
+LOCAL_C void tantest5()
+
+// To test that exact results are given for multiples of KPi
+// Added by AnnW, October 1996
+
+	{
+
+    TReal res;
+	TInt j;
+	TInt mult=101;	// can use up to 32768
+
+	test(Math::Tan(res,KNegZeroTReal64)==KErrNone);
+	test(res==KNegZeroTReal64);
+    
+    for (j=-(mult-1); j<mult; j++)
+		{
+		test(Math::Tan(res, j*KPi)==KErrNone);
+		test(res==0.0);
+		test(Math::Tan(res, j*(KPi+1.224E-16))==KErrNone);
+		test(res==0.0);
+		test(Math::Tan(res, (j*180)*KDegToRad)==KErrNone);
+		test(res==0.0);
+		if (j!=0)
+			{
+			test(Math::Sin(res, j*(KPi+1.0E-14))==KErrNone);
+			test(res!=0.0);
+			}
+		}
+	}
+*/
+LOCAL_C void astest1(TReal low,TReal upp,TInt k,TInt cosflg)
+/*
+Tests random numbers in the range [low,upp] using the Taylor approximation 
+*/
+    //TReal low; // lower limit of range to test
+    //TReal upp; // upper limit of range to test 
+    //TInt k; // Highest order term to be used in the taylor approximation
+    //TInt cosflg; // Flag for arc cos
+    {
+
+    TReal res,x;
+
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		if (cosflg)
+			test(Math::ACos(res,x)==KErrNone);
+		else
+			test(Math::ASin(res,x)==KErrNone);
+		TReal tres=taylor(x,k);
+		if (cosflg)
+			tres=KPiBy2-tres;
+		test(testApprox(tres,res,5.0E-15));		
+		}
+    }
+
+LOCAL_C void astest2()
+/* 
+To test the identity arc sin(x)=x for x<<1 
+*/        
+    {
+
+    TReal x,res;
+
+    TReal low=1E-90;
+    TReal upp=1E-10;
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::ASin(res,x)==KErrNone);
+		test(testApprox(res,x,1.0E-15));		
+		}
+
+	// Check some denormals
+	test(Math::ASin(res,5E-324)==KErrNone);
+	test(res==5E-324);		
+	test(Math::ASin(res,-8.912345678E-318)==KErrNone);
+	test(res==-8.912345678E-318);		
+    }
+
+LOCAL_C void astest3()
+/* 
+To test the identity arc sin(-x)=-arc sin(x) 
+*/        
+    {
+
+    TReal res,rres,x;
+
+    TReal low=0.0;
+    TReal upp=1.0;
+    for (TInt j=0;j<100;j++)
+		{
+		randrng(x,low,upp);
+		test(Math::ASin(res,x)==KErrNone);
+		TReal y=(-x);
+		test(Math::ASin(rres,y)==KErrNone);
+		test(testApprox(rres,-res,1.0E-15));		
+		}
+    }
+
+LOCAL_C void astest4(TInt k,TInt sgn)
+/* 
+Test selected numbers 
+*/
+    //TInt k; // arc cosine flag
+    //TInt sgn; // sign flag for range    
+    {
+
+    TReal res;
+
+	// test errors
+	test(Math::ASin(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ASin(res,KPosInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ASin(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ASin(res,1.0000000000001)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ASin(res,-1.0000000000001)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ACos(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ACos(res,KPosInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ACos(res,KNegInfTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ACos(res,1.0000000000001)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ACos(res,-1.0000000000001)==KErrArgument);
+	test(Math::IsNaN(res));
+
+	test(Math::ASin(res,0.0)==KErrNone);
+	test(res==0.0);
+	test(Math::ASin(res,KNegZeroTReal64)==KErrNone);
+	test(res==0.0);
+
+    TInt i=sizeof(testas)/sizeof(TESTASC);
+    for (TInt j=0;j<i;j++) 
+		{
+		// NB Results for comparison only given to 12 or 13 decimal places, so can't expect 
+		// better accuracy
+		if (k)
+			{
+			testas[j].num*=sgn;
+			testas[j].res*=sgn;
+			test(Math::ACos(res,testas[j].num)==KErrNone);
+			test(testApprox(res,(KPiBy2-testas[j].res),1.0E-11));	
+			}
+		else
+			{
+			test(Math::ASin(res,testas[j].num)==KErrNone);
+			test(testApprox(res,testas[j].res,1.0E-12));	
+			}
+		}
+
+	// Check some denormals for ACos()
+	test(Math::ACos(res,5E-324)==KErrNone);
+	test(res==KPiBy2);	
+	test(Math::ACos(res,-9.87654E-320)==KErrNone);
+	test(res==KPiBy2);						
+    }
+
+LOCAL_C void attest1()
+/* 
+Random argument tests for x in the primary range, comparing the result with a 
+Taylor series approximation
+*/
+    {
+
+    TReal res,x;
+
+    TReal low=(-0.0625);
+    TReal upp=0.0625;
+    for (TInt i=0;i<10;i++)
+		{
+		randrng(x,low,upp);
+		test(Math::ATan(res,x)==KErrNone);
+		TReal tres=tayatan(x);
+		test(testApprox(res,tres,1.0E-15));		
+		}
+    }
+
+LOCAL_C void attest2()
+/* 
+Random argument tests for x outside the primary range, using the identity
+arctan(u)=arctan(v)+arctan[(u-v)/(1+uv)]
+*/
+    {
+
+    TReal x,res,rres,atcnst;
+
+    TReal low=0.0625;
+    TReal upp=2.0-KSqt3;
+    TReal cnst=0.0625;
+    test(Math::ATan(atcnst,cnst)==KErrNone);
+    for (TInt i=0;i<10;i++)
+		{
+		randrng(x,low,upp);
+		test(Math::ATan(res,x)==KErrNone);
+		TReal y=(x-cnst)/(1+x*cnst);
+		test(Math::ATan(rres,y)==KErrNone);
+		test(testApprox(res,(atcnst+rres),1.0E-15));		
+		}
+    }                   
+
+LOCAL_C void attest3()
+/*
+Check that the identity arctan(-x)=-arctan(x) holds
+*/
+    {
+
+    TReal res,rres,x;
+    TReal low=0.0;
+    TReal upp=1.0;
+    for (TInt i=0;i<10;i++)
+		{
+		randrng(x,upp,low);
+		test(Math::ATan(res,x)==KErrNone);
+		x=(-x);
+		test(Math::ATan(rres,x)==KErrNone);
+		test(testApprox(res,-rres,1.0E-15));		
+		}
+    }           
+
+LOCAL_C void attest4()
+/* 
+Check that the identity arctan(x)=x for Abs(x)<1 holds
+*/
+    {
+
+    TReal x,res;
+
+    TReal low=1E-90;
+    TReal upp=1E-20;
+    for (TInt i=0;i<10;i++)
+		{
+		randrng(x,low,upp);
+		test(Math::ATan(res,x)==KErrNone);
+		test(testApprox(res,x,1.0E-15));		
+		}
+
+	// Check some denormals
+	test(Math::ATan(res,-5E-324)==KErrNone);
+	test(res==-5E-324);		
+	test(Math::ATan(res,7.123E-322)==KErrNone);
+	test(res==7.123E-322);			
+    }
+
+LOCAL_C void attest5()
+/*
+Tests selected values
+*/
+    {
+
+    TReal res;
+
+	// test errors, special cases
+	test(Math::ATan(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ATan(res,0.0)==KErrNone);
+	test(res==0.0);
+	test(Math::ATan(res,KNegZeroTReal64)==KErrNone);
+	test(res==0.0);
+	test(Math::ATan(res,KPosInfTReal64)==KErrNone);
+	test(res==KPiBy2);
+	test(Math::ATan(res,KNegInfTReal64)==KErrNone);
+	test(res==-KPiBy2);
+
+	test(Math::ATan(res,KNaNTReal64,1.0)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ATan(res,1.0,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ATan(res,KNaNTReal64,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ATan(res,0.0,KNegZeroTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::ATan(res,KNegZeroTReal64,KNegZeroTReal64)==KErrArgument);
+	test(Math::IsNaN(res));	
+	test(Math::ATan(res,0.0,0.0)==KErrArgument);
+	test(Math::IsNaN(res));	
+	test(Math::ATan(res,KNegZeroTReal64,KNegZeroTReal64)==KErrArgument);
+	test(Math::IsNaN(res));	
+	test(Math::ATan(res,KPosInfTReal64,KNegInfTReal64)==KErrNone);
+	test(res==3.0*(KPiBy2/2.0));
+	test(Math::ATan(res,KPosInfTReal64,KPosInfTReal64)==KErrNone);
+	test(res==KPiBy2/2.0);
+	test(Math::ATan(res,KNegInfTReal64,KPosInfTReal64)==KErrNone);
+	test(res==-(KPiBy2/2.0));
+	test(Math::ATan(res,KNegInfTReal64,KNegInfTReal64)==KErrNone);
+	test(res==-3.0*(KPiBy2/2.0));
+	test(Math::ATan(res,KNegZeroTReal64,1.0)==KErrNone);
+	test(res==0.0);
+	test(Math::ATan(res,0.0,1.0)==KErrNone);
+	test(res==0.0);	
+	test(Math::ATan(res,0.0,-1.0)==KErrNone);
+	test(res==KPi);	
+	test(Math::ATan(res,1.0,KPosInfTReal64)==KErrNone);
+	test(res==0.0);
+	test(Math::ATan(res,1.0,KNegInfTReal64)==KErrNone);
+	test(res==KPi);
+	test(Math::ATan(res,0.0,KPosInfTReal64)==KErrNone);	
+	test(res==0.0);
+	test(Math::ATan(res,KPosInfTReal64,1.0)==KErrNone);	
+	test(res==KPiBy2);
+	test(Math::ATan(res,KNegInfTReal64,1.0)==KErrNone);	
+	test(res==-KPiBy2);
+	test(Math::ATan(res,1.0,0.0)==KErrNone);	
+	test(res==KPiBy2);
+	test(Math::ATan(res,1.0,KNegZeroTReal64)==KErrNone);	
+	test(res==KPiBy2);
+	test(Math::ATan(res,KPosInfTReal64,-1.0)==KErrNone);	
+	test(res==KPiBy2);
+	test(Math::ATan(res,KNegInfTReal64,-1.0)==KErrNone);	
+	test(res==-KPiBy2);
+	test(Math::ATan(res,-1.0,0.0)==KErrNone);	
+	test(res==-KPiBy2);
+	test(Math::ATan(res,-1.0,KNegZeroTReal64)==KErrNone);	
+	test(res==-KPiBy2);
+	test(Math::ATan(res,5E-324,10)==KErrNone);	
+	test(res==0.0);
+	test(Math::ATan(res,1E+308,0.1)==KErrNone);	
+	test(res==KPiBy2);
+
+    TInt i=sizeof(testat2)/sizeof(TESTATAN2);
+    for (TInt j=0;j<i;j++) 
+		{
+		// NB Some results only given to 12 dp so cannot expect better accuracy
+		test(Math::ATan(res,testat2[j].num1,testat2[j].num2)==KErrNone);
+		test(testApprox(res,testat2[j].res,1.0E-12));		
+		}	
+    }
+
+LOCAL_C void inttest1()
+/*
+Tests specific numbers
+*/
+    {
+
+    TReal res;
+
+	// Specials
+	test(Math::Int(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Int(res,KPosInfTReal64)==KErrOverflow);
+	test(res==KPosInfTReal64);
+	test(Math::Int(res,KNegInfTReal64)==KErrOverflow);
+	test(res==KNegInfTReal64);
+
+    TInt i=sizeof(testint1)/sizeof(INT_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Int(res,testint1[j].num)==KErrNone);
+		test(res==testint1[j].res);
+		}
+
+	// Check some denormals
+	test(Math::Int(res,5E-324)==KErrNone);
+	test(res==0.0);
+	test(Math::Int(res,1.45E-309)==KErrNone);
+	test(res==0.0);
+    }
+
+LOCAL_C void inttest2()
+/*
+Tests specific numbers
+*/
+    {
+
+    TInt16 res;
+
+	// test errors
+	test(Math::Int(res,KNaNTReal64)==KErrArgument);
+	test(res==0);
+	test(Math::Int(res,KPosInfTReal64)==KErrOverflow);
+	test(res==TInt16(KMaxTInt16));	
+	test(Math::Int(res,32768.9830857)==KErrOverflow);
+	test(res==TInt16(KMaxTInt16));
+	test(Math::Int(res,32769.36946)==KErrOverflow);
+	test(res==TInt16(KMaxTInt16));
+	test(Math::Int(res,KNegInfTReal64)==KErrUnderflow);
+    test(res==TInt16(KMinTInt16));
+	test(Math::Int(res,-32774.997937)==KErrUnderflow);
+    test(res==TInt16(KMinTInt16));
+
+    TInt i=sizeof(testint2)/sizeof(INTI_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Int(res,testint2[j].num)==KErrNone);
+		test(res==testint2[j].res);		
+		}
+
+	// Check some denormals
+	test(Math::Int(res,5E-324)==KErrNone);
+	test(res==0.0);
+	test(Math::Int(res,1.45E-309)==KErrNone);
+	test(res==0.0);
+	}
+
+LOCAL_C void inttest3()
+/*
+Tests specific numbers
+*/
+    {
+
+    TInt32 res;
+
+    // test errors
+	test(Math::Int(res,KNaNTReal64)==KErrArgument);
+	test(res==0);
+	test(Math::Int(res,KPosInfTReal64)==KErrOverflow);
+	test(res==KMaxTInt32);
+	test(Math::Int(res,2147483648.34576)==KErrOverflow);
+	test(res==KMaxTInt32);
+    test(Math::Int(res,2147553576.8794365)==KErrOverflow);
+	test(res==KMaxTInt32);
+    test(Math::Int(res,KNegInfTReal64)==KErrUnderflow);
+	test(res==KMinTInt32);
+	test(Math::Int(res,-2147496757.583)==KErrUnderflow);
+	test(res==KMinTInt32);
+    
+	TInt i=sizeof(testint3)/sizeof(INTL_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Int(res,testint3[j].num)==KErrNone);
+		test(res==testint3[j].res);
+		}
+
+	// Check some denormals
+	test(Math::Int(res,5E-324)==KErrNone);
+	test(res==0.0);
+	test(Math::Int(res,1.45E-309)==KErrNone);
+	test(res==0.0);
+	}
+
+LOCAL_C void inttest4()
+	{
+	// tests Int()
+	TInt16 tint16;
+	TInt32 tint32;
+	TReal trg,src=100.0;
+
+	test.Start(_L("Math::Int()"));
+	src=0.0;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==0.0);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==0);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==0);
+
+    src=0.1233456789;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==0.0);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==0);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==0);
+
+	src=-0.5;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==0.0);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==0);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==0);
+
+	src=1.123456789;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==1.0);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==1);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==1);
+
+	src=-1.12345678;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==-1.0);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==-1);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==-1);
+
+	src=KMaxTInt16-0.1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTInt16-1);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==KMaxTInt16-1);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMaxTInt16-1);
+
+	src=KMaxTInt16+0.5; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTInt16);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==KMaxTInt16);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMaxTInt16);
+
+	src=KMaxTInt16+1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTInt16+1);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMaxTInt16+1);
+
+	src=KMinTInt16-0.1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMinTInt16);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==KMinTInt16);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMinTInt16);
+
+	src=KMinTInt16; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMinTInt16);
+	test(Math::Int(tint16,src)==KErrNone);
+	test(tint16==KMinTInt16);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMinTInt16);
+
+	src=KMinTInt16-1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMinTInt16-1);
+	test(Math::Int(tint16,src)==KErrUnderflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMinTInt16-1);
+
+	src=KMaxTInt32-0.1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTInt32-1);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMaxTInt32-1);
+
+	src=KMaxTInt32+0.5; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTInt32);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMaxTInt32);
+
+	src=KMaxTInt32; 
+	src+=1;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==(TUint32)KMaxTInt32+1);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrOverflow);
+
+	src=KMinTInt32+0.1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMinTInt32+1);
+	test(Math::Int(tint16,src)==KErrUnderflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMinTInt32+1);
+
+	src=KMinTInt32; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMinTInt32);
+	test(Math::Int(tint16,src)==KErrUnderflow);
+	test(Math::Int(tint32,src)==KErrNone);
+	test(tint32==KMinTInt32);
+
+	src=KMinTInt32;
+	src-=1; 
+	test(Math::Int(trg,src)==KErrNone);  
+	test((trg+1)==KMinTInt32);
+	test(Math::Int(tint16,src)==KErrUnderflow);
+	test(Math::Int(tint32,src)==KErrUnderflow);
+
+	src=KMaxTUint32-0.1;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTUint32-1);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrOverflow);
+
+	src=KMaxTUint32;
+	test(Math::Int(trg,src)==KErrNone);  
+	test(trg==KMaxTUint32);
+	test(Math::Int(tint16,src)==KErrOverflow);
+	test(Math::Int(tint32,src)==KErrOverflow);
+
+	test.End();
+	}
+
+LOCAL_C void fractest1()
+/*
+Tests specific numbers
+*/
+    {
+
+    TReal res;
+
+	// test errors
+	test(Math::Frac(res,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Frac(res,KPosInfTReal64)==KErrOverflow);
+	test(res==0.0);
+	test(Math::Frac(res,KNegInfTReal64)==KErrOverflow);
+	test(res==0.0);
+
+    TInt i=sizeof(testfrac)/sizeof(FRAC_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Frac(res,testfrac[j].num)==KErrNone);
+		TReal err=(res-testfrac[j].res);
+		if (res)
+			err/=testfrac[j].num;	// NB num not res
+		test(Abs(err)<1.0E-15);
+		}
+
+	// Check some denormals
+	test(Math::Frac(res,5E-324)==KErrNone);
+	test(res==5E-324);
+	test(Math::Frac(res,1.23456789E-314)==KErrNone);
+	test(res==1.23456789E-314);
+    }
+
+LOCAL_C void fractest2()
+	{
+	// tests Frac() 
+	test.Start(_L("Math::Frac()"));
+	TReal trg,src;
+
+	src=0.0;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.0);
+
+	src=0.1;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.1);
+
+	src=-0.1;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==-0.1);
+
+	src=7.5;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.5);
+
+	src=-7.5;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==-0.5);
+
+	src=5.998046875;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.998046875);
+
+	src=-5.998046875;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==-0.998046875);
+
+	src=-0.00000000001;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==-0.00000000001);
+
+	src=1000000000000.5;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.5);
+
+	src=1099511627776.0;
+	src+=0.000244140625;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.000244140625);
+
+	src=-KMaxTInt32;
+	src+=0.5;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==-0.5);
+
+	src=KMaxTUint32;
+	src+=0.5;
+	test(Math::Frac(trg,src)==KErrNone);
+	test(trg==0.5);
+
+	test.End();
+	}
+
+LOCAL_C void modtest1()
+/*
+Test modulo function using specified values
+*/
+    {
+
+    TReal res;
+
+	// test errors
+	test(Math::Mod(res,KNaNTReal64,1.0)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,1.0,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,KNaNTReal64,KNaNTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,KPosInfTReal64,2.0)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,KNegInfTReal64,2.0)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,2.0,KNegZeroTReal64)==KErrArgument);
+	test(Math::IsNaN(res));
+	test(Math::Mod(res,1.0,0.0)==KErrArgument);
+	test(Math::IsNaN(res));
+
+    TInt i=sizeof(testmod)/sizeof(MOD_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Mod(res,testmod[j].num,testmod[j].mod)==KErrNone);
+		test(testApprox(res,testmod[j].res,5.0E-13));		
+		}
+
+	// Check some denormals
+ 	test(Math::Mod(res,K1Point2EMinus320Real64,K5EMinus321Real64)==KErrNone);
+ 	test(res==K2EMinus321Real64);		
+ 	test(Math::Mod(res,K1Point234EMinus316Real64,K1Point234EMinus316Real64)==KErrNone);
+	test(res==0.0);		
+    }
+
+LOCAL_C void modtest2()
+/*
+Test modulo function for values which will be incorrect so return KErrTotalLossOfPrecision
+*/
+    {
+
+    TReal res;
+
+	TInt i=sizeof(testmod2)/sizeof(MOD_TEST);
+    for (TInt j=0;j<i;j++) 
+		{
+		test(Math::Mod(res,testmod2[j].num,testmod2[j].mod)==KErrTotalLossOfPrecision);
+		test(Math::IsZero(res));
+		}
+	}
+
+LOCAL_C void DuplicateTest()
+//
+// Tests that you can use the same variable for both operands in some Math functions
+// NB results only given to 12 or 13 significant figures so cannot expect better accuracy
+//
+	{
+
+	TReal inOut;
+	test.Start(_L("ACos"));
+	inOut=-0.5;
+	test(Math::ACos(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,2.094395102393,1.0E-13));			
+
+	test.Next(_L("ASin"));
+	inOut=-0.5;
+	test(Math::ASin(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,-0.523598775598,6.0E-13));			
+
+	test.Next(_L("ATan"));
+	inOut=0.5;
+	test(Math::ATan(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,0.463647609001,5.0E-13));			
+	inOut=-0.25;
+	TReal another=-0.5;
+	test(Math::ATan(inOut,inOut,another)==KErrNone);
+	test(testApprox(inOut,-2.677945044589,5.0E-15));			
+	inOut=-0.5;
+	another=0.25;
+	test(Math::ATan(inOut,another,inOut)==KErrNone);
+	test(testApprox(inOut,2.677945044589,5.0E-15));			
+
+	test.Next(_L("Cos"));
+	inOut=1;
+	test(Math::Cos(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,0.540302305868,3.0E-13));			
+
+	test.Next(_L("Exp"));
+	inOut=0.5;
+	test(Math::Exp(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,1.648721270700,1.0E-13));			
+
+	test.Next(_L("Frac"));
+	inOut=56.123456789;
+	test(Math::Frac(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,0.123456789,2.0E-14));
+
+	test.Next(_L("Int"));
+	inOut=56.123456789;
+	test(Math::Int(inOut,inOut)==KErrNone);
+	test(inOut==56);
+	
+	test.Next(_L("Log"));
+	inOut=0.5;
+	test(Math::Log(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,-0.301029995664,7.0E-14));				
+
+	test.Next(_L("Ln"));
+	inOut=0.5;
+	test(Math::Ln(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,-0.693147180560,8.0E-14));				
+
+	test.Next(_L("Mod"));
+	inOut=53;
+	another=17;
+	test(Math::Mod(inOut,inOut,another)==KErrNone);
+	test(inOut==2);
+	inOut=17;
+	another=53;
+	test(Math::Mod(inOut,another,inOut)==KErrNone);
+	test(inOut==2);
+
+	test.Next(_L("Pow"));
+	inOut=-5;
+	another=3;
+	test(Math::Pow(inOut,inOut,another)==KErrNone);
+	test(inOut==-125.0);
+	another=-5;
+	inOut=3;
+	test(Math::Pow(inOut,another,inOut)==KErrNone);
+	test(inOut==-125.0);
+
+	test.Next(_L("Sin"));
+	inOut=1;
+	test(Math::Sin(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,0.84147098480790,5.0E-15));				
+
+	test.Next(_L("Round"));
+	inOut=123.4567;
+	test(Math::Round(inOut,inOut,2)==KErrNone);
+	test(testApprox(inOut,123.46,1.0E-15));				
+
+	test.Next(_L("Sqrt"));
+	inOut=53;
+	test(Math::Sqrt(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,7.280109889281,7.0E-14));				
+
+	test.Next(_L("Tan"));
+	inOut=1;
+	test(Math::Tan(inOut,inOut)==KErrNone);
+	test(testApprox(inOut,1.557407724655,7.0E-14));				
+
+	test.End();
+	}
+
+LOCAL_C void specialtest()
+//
+// Tests functions which test for specials
+// 
+	{
+
+	test(Math::IsZero(0.0));
+	test(Math::IsZero(KNegZeroTReal64));
+	test(Math::IsZero(0.0));
+	test(!Math::IsZero(1.0));
+	test(!Math::IsZero(KPosInfTReal64));
+	test(!Math::IsZero(KNaNTReal64));
+ 	test(!Math::IsZero(K5EMinus324Real64));
+
+	test(Math::IsNaN(KNaNTReal64));
+	test(!Math::IsNaN(KPosInfTReal64));
+	test(!Math::IsNaN(KNegInfTReal64));
+	test(!Math::IsNaN(0.0));
+	test(!Math::IsNaN(1.0));
+
+	test(Math::IsInfinite(KPosInfTReal64));
+	test(Math::IsInfinite(KNegInfTReal64));
+	test(!Math::IsInfinite(KNaNTReal64));
+	test(!Math::IsInfinite(0.0));
+	test(!Math::IsInfinite(KMaxTReal64));
+
+	test(!Math::IsFinite(KPosInfTReal64));
+	test(!Math::IsFinite(KNegInfTReal64));
+	test(!Math::IsFinite(KNaNTReal64));
+	test(Math::IsFinite(0.0));
+	test(Math::IsFinite(KMaxTReal64));
+	test(Math::IsFinite(5E-324));	
+	test(Math::IsFinite(1.0));
+	}
+
+void _matherr(TExcType aType)
+//
+// Dummy function to handle exceptions
+//
+	{
+
+	test.Printf(_L("_matherr: Exception type %u handled\n"),TUint(aType));
+	}
+
+GLDEF_C TInt E32Main()
+    {
+	test.Title();
+
+	test.Start(_L("Assorted tests"));
+	AssortedTests();
+
+	test.Next(_L("sqrtest1(KSqhf,1.0)"));
+    sqrtest1(KSqhf,1.0);
+	test.Next(_L("sqrtest1(1.0,1.41421356238)"));
+    sqrtest1(1.0,1.41421356238);
+	test.Next(_L("sqrtest2"));
+    sqrtest2();                  
+
+	test.Next(_L("logtest"));
+    logtest();
+	test.Next(_L("lntest1"));
+    lntest1();
+	test.Next(_L("lntest2"));
+    lntest2();
+	test.Next(_L("lntest3"));
+    lntest3();
+	test.Next(_L("lntest4"));
+    lntest4();
+
+	test.Next(_L("exptest1"));
+    exptest1();
+	test.Next(_L("exptest2(-0.0625,-.9375,1.0625)"));
+    exptest2(-0.0625,-0.9375,1.0625);
+	test.Next(_L("exptest2(-29.0/16.0),1.0,88.0)"));
+    exptest2((-29.0/16.0),1.0,88.0);
+	test.Next(_L("exptest2(-29.0/16.0),-1.0,-88.0)"));
+    exptest2((-29.0/16.0),-1.0,-88.0);
+	test.Next(_L("exptest3"));
+    exptest3();
+
+	test.Next(_L("powtest1"));
+    powtest1();
+	test.Next(_L("powtest2(.5,1.0)"));
+    powtest2(.5,1.0);
+	test.Next(_L("powtest2(1.0,1.0E33)"));
+    powtest2(1.0,1.0E33);
+	test.Next(_L("powtest3"));
+    powtest3();
+	test.Next(_L("powtest4"));
+    powtest4();
+	test.Next(_L("powtest5"));
+    powtest5();
+	test.Next(_L("powtest6"));
+    powtest6();
+	
+	test.Next(_L("pow10test"));
+	pow10test();
+														
+	test.Next(_L("sintest1(3*KPi,3.5*KPi)"));
+    sintest1(3*KPi,3.5*KPi);
+	test.Next(_L("sintest1(3*KPi,3.5*KPi)"));
+    sintest1(6*KPi,6.5*KPi);
+	test.Next(_L("sintest2"));
+    sintest2();
+	test.Next(_L("sintest3"));    
+	sintest3();
+	test.Next(_L("sintest4"));
+    sintest4();
+//	test.Next(_L("sintest5"));		// this test is no longer valid
+//	sintest5();
+
+	test.Next(_L("costest1"));
+	costest1();
+	test.Next(_L("costest2"));
+	costest2();
+	test.Next(_L("costest3"));
+	costest3();
+	test.Next(_L("costest4"));
+	costest4();
+//	test.Next(_L("costest5"));		// this test is no longer valid
+//	costest5();
+
+	test.Next(_L("tantest1(-.25*KPi,.25*KPi)"));                                            
+    tantest1(-.25*KPi,.25*KPi);
+	test.Next(_L("tantest1(.875*KPi,1.125*KPi)"));
+    tantest1(.875*KPi,1.125*KPi);
+	test.Next(_L("tantest1(6*KPi,6.25*KPi)"));
+    tantest1(6*KPi,6.25*KPi);
+	test.Next(_L("tantest2"));
+    tantest2();   
+	test.Next(_L("tantest3"));
+    tantest3();
+	test.Next(_L("tantest4"));
+    tantest4();
+//	test.Next(_L("tantest5"));		// this test is no longer valid
+//	tantest5();
+
+	test.Next(_L("astest1(-.125,0.125,15,0)"));
+    astest1(-.125,0.125,15,0);
+	test.Next(_L("astest1(-.125,0.125,15,1)"));
+    astest1(-.125,0.125,15,1);
+	test.Next(_L("astest2"));
+    astest2();
+	test.Next(_L("astest3"));
+    astest3();
+	test.Next(_L("astest4(0,1)"));
+    astest4(0,1);
+	test.Next(_L("astest4(1,1)"));
+    astest4(1,1);
+	test.Next(_L("astest4(1,-1)"));
+    astest4(1,-1);
+		  
+	test.Next(_L("attest1"));
+    attest1();
+	test.Next(_L("attest2"));
+    attest2();
+	test.Next(_L("attest3"));
+    attest3();
+	test.Next(_L("attest4"));
+    attest4();
+	test.Next(_L("attest5"));
+    attest5();
+
+    test.Next(_L("inttest1"));
+    inttest1();	
+	test.Next(_L("intitest2"));
+    inttest2();	
+	test.Next(_L("inttest3"));
+    inttest3();	
+	test.Next(_L("inttest4"));
+	inttest4();	
+
+	test.Next(_L("fractest1"));
+    fractest1();	
+	test.Next(_L("fractest2"));
+	fractest2();
+
+	test.Next(_L("modtest1"));
+    modtest1();
+	test.Next(_L("modtest2"));
+    modtest2();
+
+	test.Next(_L("Test duplicate parameters"));
+	DuplicateTest();
+
+	test.Next(_L("Test Math::Is...() functions"));
+	specialtest();
+
+	test.End();
+	return(KErrNone);
+    }
+