diff -r 000000000000 -r 96e5fb8b040d kerneltest/f32test/math/t_gen.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/kerneltest/f32test/math/t_gen.cpp	Thu Dec 17 09:24:54 2009 +0200
@@ -0,0 +1,507 @@
+// Copyright (c) 1996-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:
+// f32test\math\t_gen.cpp
+// Generates files to be used in testing whether arithmetic in TReal32 and TReal64 gives
+// exactly the same results using the MSDEV complier as on the rack.
+// 
+//
+
+#include <e32test.h>
+#include <f32file.h>
+#include <e32svr.h>
+#include "../server/t_server.h"
+#include "t_math.h"
+
+GLDEF_D RTest test(_L("T_GEN"));
+
+LOCAL_D const TFileName pathName = _L("C:\\F32-TST\\E32-MATH\\");
+LOCAL_D	TBuf<0x100> buf;
+LOCAL_D	TBuf8<0x100> buf8;
+
+
+#define __GENERATE_SPECIAL_VALUES
+#ifdef __GENERATE_SPECIAL_VALUES
+
+LOCAL_D	RFile fspw;	// file for special values for WINS
+LOCAL_D	RFile fspa;	// file for special values for ARM
+
+LOCAL_D const TFileName fileNameWSp = _L("T_VALS.HWG");
+LOCAL_D const TFileName fileNameASp = _L("T_VALS.HAG");
+
+LOCAL_C void appendConstTI64(TPtrC aName,TReal64* aVal)
+	{
+	// for WINS 
+	buf=_L("");
+	buf.AppendFormat(_L("const TInt64 %S = TInt64(0x%x,0x%x);\n"),&aName,*(((TUint32*)aVal) + 1),*(TUint32*)aVal);
+	buf8.Copy(buf);	// Unicode
+	fspw.Write(buf8);
+	// for ARM
+	buf=_L("");
+	buf.AppendFormat(_L("const TInt64 %S = TInt64(0x%x,0x%x);\n"),&aName,*(TUint32*)aVal,*(((TUint32*)aVal) + 1));
+	buf8.Copy(buf);
+	fspa.Write(buf8);
+	}
+
+LOCAL_C void appendConstTI32x(TPtrC aName,TReal32* aVal)
+	{
+	// for WINS and ARM
+	buf=_L("");
+	buf.AppendFormat(_L("const TInt32x %S = TInt32x(0x%x);\n"),&aName,*(TUint32*)aVal);
+	buf8.Copy(buf);	// Unicode
+	fspw.Write(buf8);	
+	fspa.Write(buf8);	
+	}
+
+LOCAL_C void appendConstTR64(TPtrC aName,TPtrC aIntName)
+	{
+	// for WINS and ARM
+	buf=_L("");
+	buf.AppendFormat(_L("const TReal64 %S = *(TReal64*)&%S;\n"),&aName,&aIntName);
+	buf8.Copy(buf);	// Unicode
+	fspw.Write(buf8);
+	fspa.Write(buf8);
+	}
+
+LOCAL_C void appendConstTR32(TPtrC aName,TPtrC aIntName)
+	{
+	// for WINS and ARM
+	buf=_L("");
+	buf.AppendFormat(_L("const TReal32 %S = *(TReal32*)&%S;\n"),&aName,&aIntName);
+	buf8.Copy(buf);
+	fspw.Write(buf8);	
+	fspa.Write(buf8);	
+	}
+
+LOCAL_C void appendConstTR(TPtrC aName,TPtrC a64Name)
+	{ 
+	// for WINS and ARM
+	buf=_L("");
+	buf.AppendFormat(_L("const TReal %S = TReal(%S);\n"),&aName,&a64Name);
+	buf8.Copy(buf);	// Unicode
+	fspw.Write(buf8);	
+	fspa.Write(buf8);	
+	}
+
+LOCAL_C void appendStart()
+	{
+	// for WINS
+	fspw.Write(_L8("/* Generated by \\E32\\TMATH\\T_GEN.MAK for WINS (little-endian doubles) */\n\n"));
+	fspw.Write(_L8("#include <e32std.h>\n\n"));
+	fspw.Write(_L8("class TInt32x\n{\npublic:\n"));
+	fspw.Write(_L8("TInt32x(TInt32 aInt) {iInt=aInt;}\n"));
+	fspw.Write(_L8("public:\nTInt32 iInt;\n};\n\n"));
+
+	// for ARM
+	fspa.Write(_L8("/* Generated by \\E32\\TMATH\\T_GEN.MAK for ARM (big-endian doubles)*/\n\n"));
+	fspa.Write(_L8("#include <e32std.h>\n\n"));
+	fspa.Write(_L8("class TInt32x\n{\npublic:\n"));
+	fspa.Write(_L8("TInt32x(TInt32 aInt) {iInt=aInt;}\n"));
+	fspa.Write(_L8("public:\nTInt32 iInt;\n};\n\n"));
+	}
+
+LOCAL_C void generateSpecialValues()
+//
+// The following are to avoid the errors in the compiler in converting from string
+// to floating point
+//
+// Initialise max/min values and square roots and write to header files
+//
+	{
+
+	TReal64 minTReal32in64;
+	SReal64 *p64=(SReal64*)&minTReal32in64;
+	p64->sign=0;
+	p64->exp=0x381;
+	p64->msm=0;
+	p64->lsm=0;
+
+	TReal64 maxTReal32in64;
+	p64=(SReal64*)&maxTReal32in64;
+	p64->sign=0;
+	p64->exp=0x47E;
+	p64->msm=0xfffff;
+	p64->lsm=0xe0000000;
+
+	TReal64 sqrtMaxTReal64;		
+	const TReal64 arg1=KMaxTReal64-1.0E+299;		// Take off this to avoid overflow
+	TInt ret=Math::Sqrt(sqrtMaxTReal64,arg1);
+	TReal64 sqrtMinTReal64;
+	const TReal64 arg2=KMinTReal64;
+	ret=Math::Sqrt(sqrtMinTReal64,arg2);
+
+	TReal64 sqrtMaxTReal32in64,sqrtMinTReal32in64; 
+
+	TReal64 negZeroTReal64;
+	p64=(SReal64*)&negZeroTReal64;
+	p64->sign=1;
+	p64->exp=0;
+	p64->msm=0;
+	p64->lsm=0;
+
+	TReal64 posInfTReal64;
+	p64=(SReal64*)&posInfTReal64;
+	p64->sign=0;
+	p64->exp=KTReal64SpecialExponent;
+	p64->msm=0;
+	p64->lsm=0;
+
+	TReal64 negInfTReal64;
+	p64=(SReal64*)&negInfTReal64;
+	p64->sign=1;
+	p64->exp=KTReal64SpecialExponent;
+	p64->msm=0;
+	p64->lsm=0;
+
+	TReal64 NaNTReal64;
+	p64=(SReal64*)&NaNTReal64;
+	p64->sign=0;
+	p64->exp=KTReal64SpecialExponent;
+	p64->msm=0xfffffu;
+	p64->lsm=0xffffffffu;
+
+	TReal32 sqrtMaxTReal32;
+	const TReal arg3=maxTReal32in64-1.0E+32f;		// Take off this to avoid overflow
+	ret=Math::Sqrt(sqrtMaxTReal32in64,arg3);
+	sqrtMaxTReal32=TReal32(sqrtMaxTReal32in64);
+	
+	TReal32 sqrtMinTReal32;
+	const TReal arg4=minTReal32in64;
+	ret=Math::Sqrt(sqrtMinTReal32in64,arg4);
+	sqrtMinTReal32=TReal32(sqrtMinTReal32in64);
+
+	TReal32 negZeroTReal32;
+	SReal32 *p32=(SReal32*)&negZeroTReal32;
+	p32->sign=1;
+	p32->exp=0;
+	p32->man=0;	
+
+	appendStart();
+
+	appendConstTI64(_L("minTReal32in64"),&minTReal32in64);
+	appendConstTI64(_L("maxTReal32in64"),&maxTReal32in64);
+	appendConstTI64(_L("sqrtMaxTReal64"),&sqrtMaxTReal64);
+	appendConstTI64(_L("sqrtMinTReal64"),&sqrtMinTReal64);
+	appendConstTI64(_L("negZeroTReal64"),&negZeroTReal64);
+	appendConstTI64(_L("posInfTReal64"),&posInfTReal64);
+	appendConstTI64(_L("negInfTReal64"),&negInfTReal64);
+	appendConstTI64(_L("NaNTReal64"),&NaNTReal64);
+
+	appendConstTI32x(_L("sqrtMaxTReal32"),&sqrtMaxTReal32);
+	appendConstTI32x(_L("sqrtMinTReal32"),&sqrtMinTReal32);
+	appendConstTI32x(_L("negZeroTReal32"),&negZeroTReal32);
+
+	appendConstTR64(_L("KMinTReal32in64"),_L("minTReal32in64"));
+	appendConstTR64(_L("KMaxTReal32in64"),_L("maxTReal32in64"));
+	appendConstTR64(_L("KSqrtMaxTReal64"),_L("sqrtMaxTReal64"));
+	appendConstTR64(_L("KSqrtMinTReal64"),_L("sqrtMinTReal64"));
+	appendConstTR64(_L("KNegZeroTReal64"),_L("negZeroTReal64"));
+	appendConstTR64(_L("KPosInfTReal64"),_L("posInfTReal64"));
+	appendConstTR64(_L("KNegInfTReal64"),_L("negInfTReal64"));
+	appendConstTR64(_L("KNaNTReal64"),_L("NaNTReal64"));
+	
+	appendConstTR32(_L("KSqrtMaxTReal32"),_L("sqrtMaxTReal32"));
+	appendConstTR32(_L("KSqrtMinTReal32"),_L("sqrtMinTReal32"));
+	appendConstTR32(_L("KNegZeroTReal32"),_L("negZeroTReal32"));
+
+	appendConstTR(_L("KMinTReal32inTReal"),_L("KMinTReal32in64"));
+	appendConstTR(_L("KMaxTReal32inTReal"),_L("KMaxTReal32in64"));
+	appendConstTR(_L("KNegZeroTReal"),_L("KNegZeroTReal64"));
+	}
+
+#endif
+
+//#define __GENERATE_TR64 
+#ifdef __GENERATE_TR64
+
+// Data for tests from T_R64DTA.cpp 
+GLREF_D TReal64 addInput[];
+GLREF_D TReal64 subInput[];
+GLREF_D TReal64 multInput[];
+GLREF_D TReal64 divInput[];
+GLREF_D TReal64 unaryInput[];
+GLREF_D TReal64 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;
+
+LOCAL_D	RFile fw;	// file for WINS
+LOCAL_D RFile fa;	// file for ARM
+LOCAL_D const TFileName fileNameW64 = _L("T_REAL64.HWG");
+LOCAL_D const TFileName fileNameA64 = _L("T_REAL64.HAG");
+
+LOCAL_C void appendArrayName64(TDesC& aName)
+	{
+	buf=_L("");
+	buf.AppendFormat(_L("const TInt64 %S[] = \n{\n"),&aName);
+	fw.Write(buf);
+	fa.Write(buf);
+	}
+
+LOCAL_C void appendValue64(TReal64* aVal)
+	{
+	buf=_L("");
+	buf.AppendFormat(_L("	TInt64(0x%x,0x%x),\n"),*(((TUint32*)aVal) + 1),*(TUint32*)aVal);
+	fw.Write(buf);
+	buf=_L("");
+	buf.AppendFormat(_L("	TInt64(0x%x,0x%x),\n"),*(TUint32*)aVal,*(((TUint32*)aVal) + 1));
+	fa.Write(buf);
+	}
+
+LOCAL_C void appendArrayTerm()
+	{
+	buf=_L("};\n\n");
+	fw.Write(buf);
+	fa.Write(buf);
+	}
+
+LOCAL_C void createAddArray()
+//
+// Writes an array of results of additions to the header file
+//
+	{
+	TInt ii;
+	TReal64 ff;
+
+	appendArrayName64(_L("addArray"));
+	for (ii=0; ii<sizeAdd-1; ii++)
+		{
+		ff=addInput[ii]+addInput[ii+1];
+		appendValue64(&ff);
+		}
+	appendArrayTerm();
+	}
+
+LOCAL_C void createSubArray()
+//
+// Writes an array of results of subtractions to the header file
+//
+	{
+	TInt ii;
+	TReal64 ff;
+
+	appendArrayName64(_L("subArray"));
+	for (ii=0; ii<sizeSub-1; ii++)
+		{
+		ff=subInput[ii]-subInput[ii+1];
+		appendValue64(&ff);
+		}
+	appendArrayTerm();
+	} 
+
+LOCAL_C void createMultArray()
+//
+// Writes an array of results of multiplications to the header file
+//
+	{
+	TInt ii;
+	TReal64 ff;
+
+	appendArrayName64(_L("multArray"));
+	for (ii=0; ii<sizeMult-1; ii++)
+		{
+		ff=multInput[ii]*multInput[ii+1];
+		appendValue64(&ff);
+		}
+	appendArrayTerm();
+	} 
+
+LOCAL_C void createDivArray()
+//
+// Writes an array of results of divisions to the header file
+//
+	{
+	TInt ii;
+	TReal64 ff;
+
+	appendArrayName64(_L("divArray"));
+	for (ii=0; ii<sizeDiv-1; ii++)
+		{
+		if (divInput[ii+1]!=0)
+			{
+			ff=divInput[ii]/divInput[ii+1];
+			appendValue64(&ff);
+			}
+		}
+	appendArrayTerm();
+	} 
+
+LOCAL_C void createUnaryArray()
+//
+// Writes an array of results of unary operations to the header file
+//
+	{
+	TReal64 f;
+
+	appendArrayName64(_L("unaryArray"));
+	for (TInt ii=0; ii<sizeUnary; ii++)
+		{
+		f=-unaryInput[ii];
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+	} 
+
+LOCAL_C void createIncDecArrays()
+//
+// Writes an array of results of pre and post increment and decrement operations to the
+// header file
+//
+	{
+	TInt ii;
+	TReal64 f;
+
+	// Generate arrays for exact tests
+
+	appendArrayName64(_L("preIncArray1"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		++f;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("preIncArray2"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		++f;
+		++f;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("preDecArray1"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		--f;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("preDecArray2"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		--f;
+		--f;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("postIncArray1"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		f++;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("postIncArray2"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		f++;
+		f++;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+
+	appendArrayName64(_L("postDecArray1"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		f--;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+	
+	appendArrayName64(_L("postDecArray2"));
+	for (ii=0; ii<sizeIncDec; ii++)
+		{
+		f=incDecInput[ii];
+		f--;
+		f--;
+		appendValue64(&f);
+		}
+	appendArrayTerm();
+	} 
+
+LOCAL_C void createArrays()
+//
+// Create and append to header file all arrays required for T_R64.CPP tests
+//
+	{
+	createAddArray();
+	createSubArray();
+	createMultArray();
+	createDivArray();
+	createUnaryArray();
+	createIncDecArrays();
+	}
+#endif
+
+GLDEF_C void CallTestsL(void)
+//
+// Generate TReal64s (and special values if required) and write to header files
+//
+    {
+
+	test.Title();
+
+#ifdef __GENERATE_TR64
+	TFileName msg;
+	msg=_L("Generating Maths constants to header files:\n ");
+	msg+=pathName;
+	msg+=fileNameW64;
+	msg+=_L(" and ");
+	msg+=fileNameA64;
+	test.Start(msg);
+#endif
+
+	TInt r=TheFs.MkDirAll(pathName);
+	test(r==KErrNone || r==KErrAlreadyExists);
+	test(TheFs.SetSessionPath(pathName)==KErrNone);
+
+#ifdef __GENERATE_TR64
+	test(fw.Replace(TheFs,fileNameW64,EFileWrite)==KErrNone);
+	test(fa.Replace(TheFs,fileNameA64,EFileWrite)==KErrNone);
+	test.Next(_L("Generating TReal64s"));
+	fw.Write(_L("// Generated by \\E32\\TMATH\\T_GEN.MAK for WINS (little-endian doubles)\n\n"));
+	fa.Write(_L("// Generated by \\E32\\TMATH\\T_GEN.MAK for ARM (big-endian doubles)\n\n"));
+	createArrays();
+	fw.Close();
+	fa.Close();
+#endif
+
+#ifdef __GENERATE_SPECIAL_VALUES
+	test(fspw.Replace(TheFs,fileNameWSp,EFileWrite)==KErrNone);
+	test(fspa.Replace(TheFs,fileNameASp,EFileWrite)==KErrNone);
+	test.Start(_L("Generate header file of special values for use in maths testing"));
+	generateSpecialValues();
+	test.Next(_L("Done - now closing files"));
+	fspw.Close();
+	fspa.Close();
+#endif
+
+
+	test.End();
+
+	return;
+    }