1 /*

     2 * Copyright (c) 2002-2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <e32math.h>

    22 #include <stdlib.h>

    23 #include <math.h>

    24 #include "tdouble_blr.h"

    25 

    26 CTestDouble_blr::~CTestDouble_blr() 

    27 	{ 

    28 	}  

    29 

    30 CTestDouble_blr::CTestDouble_blr(const TDesC& aStepName)

    31 	{

    32 	// MANDATORY Call to base class method to set up the human readable name for logging.

    33     iParamCnt=0;

    34 	SetTestStepName(aStepName);		

    35 	}

    36 

    37 TVerdict CTestDouble_blr::doTestStepPreambleL()

    38 	{

    39 	__UHEAP_MARK;	

    40 	SetTestStepResult(EPass);

    41 	return TestStepResult();

    42 	}

    43 

    44 

    45 TVerdict CTestDouble_blr::doTestStepPostambleL()

    46 	{

    47 	__UHEAP_MARKEND;	

    48 	return TestStepResult();

    49 	}

    50 

    51 TVerdict CTestDouble_blr::doTestStepL()

    52 	{

    53 	int err;

    54 	if(TestStepName() == Kcbrt_test)

    55 		{

    56    		INFO_PRINTF1(_L("cbrt_test():"));

    57    		err = cbrt_test();

    58    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    59    		}

    60 	else if(TestStepName() == Kceil_test)

    61 		{

    62    		INFO_PRINTF1(_L("ceil_test():"));

    63    		err = ceil_test();

    64    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    65    		}

    66    	else if(TestStepName() == Kerf_test)

    67 		{

    68    		INFO_PRINTF1(_L("erf_test():"));

    69    		err = erf_test();

    70    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    71    		}

    72    	else if(TestStepName() == Kerfc_test)

    73 		{

    74    		INFO_PRINTF1(_L("erfc_test():"));

    75    		err = erfc_test();

    76    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    77    		}

    78    	else if(TestStepName() == Kexp_test)

    79 		{

    80    		INFO_PRINTF1(_L("exp_test():"));

    81    		err = exp_test();

    82    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    83    		}

    84    	else if(TestStepName() == Kexp2_test)

    85 		{

    86    		INFO_PRINTF1(_L("exp2_test():"));

    87    		err = exp2_test();

    88    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    89    		}

    90    	else if(TestStepName() == Kexpm1_test)

    91 		{

    92    		INFO_PRINTF1(_L("expm1_test():"));

    93    		err = expm1_test();

    94    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

    95    		}

    96     else if(TestStepName() == Kfabs_test)

    97 		{

    98    		INFO_PRINTF1(_L("fabs_test():"));

    99    		err = fabs_test();

   100    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   101    		}

   102     else if(TestStepName() == Kilogb_test)

   103 		{

   104    		INFO_PRINTF1(_L("ilogb_test():"));

   105    		err = ilogb_test();

   106    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   107    		}

   108   	else if(TestStepName() == Kj0_test)

   109 		{

   110    		INFO_PRINTF1(_L("j0_test():"));

   111    		err = j0_test();

   112    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   113    		}

   114     else if(TestStepName() == Kj1_test)

   115 		{

   116    		INFO_PRINTF1(_L("j1_test():"));

   117    		err = j1_test();

   118    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   119    		}

   120    else if(TestStepName() == Klrint_test)

   121 		{

   122    		INFO_PRINTF1(_L("lrint_test():"));

   123    		err = lrint_test();

   124    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   125    		} 

   126    	else if(TestStepName() == Kllrint_test)

   127 		{

   128    		INFO_PRINTF1(_L("llrint_test():"));

   129    		err = llrint_test();

   130    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   131    		}  

   132    	else if(TestStepName() == Klog_test)

   133 		{

   134    		INFO_PRINTF1(_L("log_test():"));

   135    		err = log_test();

   136    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   137    		}

   138     else if(TestStepName() == Klog10_test)

   139 		{

   140    		INFO_PRINTF1(_L("log10_test():"));

   141    		err = log10_test();

   142    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   143    		}

   144     else if(TestStepName() == Klog1p_test)

   145 		{

   146    		INFO_PRINTF1(_L("log1p_test():"));

   147    		err = log1p_test();

   148    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   149    		} 

   150    	else if(TestStepName() == Klogb_test)

   151 		{

   152    		INFO_PRINTF1(_L("logb_test():"));

   153    		err = logb_test();

   154    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   155    		}  

   156    	else if(TestStepName() == Klround_test)

   157 		{

   158    		INFO_PRINTF1(_L("lround_test():"));

   159    		err = lround_test();

   160    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   161    		} 

   162    	else if(TestStepName() == Kllround_test)

   163 		{

   164    		INFO_PRINTF1(_L("llround_test():"));

   165    		err = llround_test();

   166    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   167    		}

   168     else if(TestStepName() == Krint_test)

   169 		{

   170    		INFO_PRINTF1(_L("rint_test():"));

   171    		err = rint_test();

   172    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   173    		}

   174     else if(TestStepName() == Ksqrt_test)

   175 		{

   176    		INFO_PRINTF1(_L("sqrt_test():"));

   177    		err = sqrt_test();

   178    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   179    		} 

   180    	else if(TestStepName() == Ktrunc_test)

   181 		{

   182    		INFO_PRINTF1(_L("trunc_test():"));

   183    		err = trunc_test();

   184    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   185    		}  

   186    	else if(TestStepName() == Ky0_test)

   187 		{

   188    		INFO_PRINTF1(_L("y0_test():"));

   189    		err = y0_test();

   190    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   191    		} 

   192    	

   193    	else if(TestStepName() == Ky1_test)

   194 		{

   195    		INFO_PRINTF1(_L("y1_test():"));

   196    		err = y1_test();

   197    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   198    		} 

   199    	else if(TestStepName() == Kfloor_test)

   200 		{

   201    		INFO_PRINTF1(_L("floor_test():"));

   202    		err = floor_test();

   203    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   204    		}

   205     else if(TestStepName() == Ksignificand_test)

   206 		{

   207    		INFO_PRINTF1(_L("significand_test():"));

   208    		err = significand_test();

   209    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   210    		}

   211     else if(TestStepName() == Knearbyint_test)

   212 		{

   213    		INFO_PRINTF1(_L("nearbyint_test():"));

   214    		err = nearbyint_test();

   215    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   216    		} 

   217    	else if(TestStepName() == Kisinf_test)

   218 		{

   219    		INFO_PRINTF1(_L("isinf_test():"));

   220    		err = isinf_test();

   221    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   222    		}  

   223    	else if(TestStepName() == Kisnan_test)

   224 		{

   225    		INFO_PRINTF1(_L("isnan_test():"));

   226    		err = isnan_test();

   227    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   228    		} 

   229    	else if(TestStepName() == Kfdim_test)

   230 		{

   231    		INFO_PRINTF1(_L("fdim_test():"));

   232    		err = fdim_test();

   233    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   234    		}

   235     else if(TestStepName() == Kfmax_test)

   236 		{

   237    		INFO_PRINTF1(_L("fmax_test():"));

   238    		err = fmax_test();

   239    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   240    		}

   241     else if(TestStepName() == Kfmin_test)

   242 		{

   243    		INFO_PRINTF1(_L("fmin_test():"));

   244    		err = fmin_test();

   245    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   246    		} 

   247    	else if(TestStepName() == Kfma_test)

   248 		{

   249    		INFO_PRINTF1(_L("fma_test():"));

   250    		err = fma_test();

   251    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   252    		} 

   253    	else if(TestStepName() == Kfmod_test)

   254 		{

   255    		INFO_PRINTF1(_L("fmod_test():"));

   256    		err = fmod_test();

   257    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   258    		}  

   259    	else if(TestStepName() == Khypot_test)

   260 		{

   261    		INFO_PRINTF1(_L("hypot_test():"));

   262    		err = hypot_test();

   263    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   264    		} 

   265    	else if(TestStepName() == Kremainder_test)

   266 		{

   267    		INFO_PRINTF1(_L("remainder_test():"));

   268    		err = remainder_test();

   269    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   270    		} 

   271    	else if(TestStepName() == Knexttoward_test)

   272 		{

   273    		INFO_PRINTF1(_L("nexttoward_test():"));

   274    		err = nexttoward_test();

   275    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   276    		}

   277     else if(TestStepName() == Knextafter_test)

   278 		{

   279    		INFO_PRINTF1(_L("nextafter_test():"));

   280    		err = nextafter_test();

   281    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   282    		}

   283     else if(TestStepName() == Kcopysign_test)

   284 		{

   285    		INFO_PRINTF1(_L("copysign_test():"));

   286    		err = copysign_test();

   287    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   288    		} 

   289    	else if(TestStepName() == Kfjn_test)

   290 		{

   291    		INFO_PRINTF1(_L("jn_test():"));

   292    		err = jn_test();

   293    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   294    		}  

   295    	else if(TestStepName() == Kfyn_test)

   296 		{

   297    		INFO_PRINTF1(_L("yn_test():"));

   298    		err = yn_test();

   299    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   300    		} 

   301    	else if(TestStepName() == Kscalb_test)

   302 		{

   303    		INFO_PRINTF1(_L("scalb_test():"));

   304    		err = scalb_test();

   305    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   306    		} 

   307    	else if(TestStepName() == Kscalbn_test)

   308 		{

   309    		INFO_PRINTF1(_L("scalbn_test():"));

   310    		err = scalbn_test();

   311    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   312    		} 

   313    	else if(TestStepName() == Kpow_test)

   314 		{

   315    		INFO_PRINTF1(_L("pow_test():"));

   316    		err = pow_test();

   317    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   318    		} 

   319    	else if(TestStepName() == Kacos_test)

   320 		{

   321    		INFO_PRINTF1(_L("acos_test():"));

   322    		err = acos_test();

   323    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   324    		}

   325     else if(TestStepName() == Kacosh_test)

   326 		{

   327    		INFO_PRINTF1(_L("acosh_test():"));

   328    		err = acosh_test();

   329    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   330    		}

   331     else if(TestStepName() == Kasin_test)

   332 		{

   333    		INFO_PRINTF1(_L("asin_test():"));

   334    		err = asin_test();

   335    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   336    		} 

   337    	else if(TestStepName() == Kasinh_test)

   338 		{

   339    		INFO_PRINTF1(_L("asinh_test():"));

   340    		err = asinh_test();

   341    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   342    		}  

   343    	else if(TestStepName() == Katan_test)

   344 		{

   345    		INFO_PRINTF1(_L("atan_test():"));

   346    		err = atan_test();

   347    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   348    		} 

   349    	else if(TestStepName() == Katanh_test)

   350 		{

   351    		INFO_PRINTF1(_L("atanh_test():"));

   352    		err = atanh_test();

   353    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   354    		} 

   355    	else if(TestStepName() == KCos_test)

   356 		{

   357    		INFO_PRINTF1(_L("Cos_test():"));

   358    		err = Cos_test();

   359    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   360    		} 

   361    	else if(TestStepName() == Kcosh_test)

   362 		{

   363    		INFO_PRINTF1(_L("cosh_test():"));

   364    		err = cosh_test();

   365    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   366    		} 

   367    	else if(TestStepName() == Ksin_test)

   368 		{

   369    		INFO_PRINTF1(_L("sin_test():"));

   370    		err = sin_test();

   371    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   372    		}  

   373    	else if(TestStepName() == Ksinh_test)

   374 		{

   375    		INFO_PRINTF1(_L("sinh_test():"));

   376    		err = sinh_test();

   377    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   378    		} 

   379    	else if(TestStepName() == Ktan_test)

   380 		{

   381    		INFO_PRINTF1(_L("tan_test():"));

   382    		err = tan_test();

   383    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   384    		} 

   385    	else if(TestStepName() == Ktanh_test)

   386 		{

   387    		INFO_PRINTF1(_L("tanh_test():"));

   388    		err = tanh_test();

   389    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   390    		} 

   391    	else if(TestStepName() == Katan2_test)

   392 		{

   393    		INFO_PRINTF1(_L("atan2_test():"));

   394    		err = atan2_test();

   395    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   396    		} 

   397    	else if(TestStepName() == Kisnormal_test)

   398 		{

   399    		INFO_PRINTF1(_L("isnormal_test():"));

   400    		err = isnormal_test();

   401    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   402    		}  

   403    	else if(TestStepName() == Ksignbit_test)

   404 		{

   405    		INFO_PRINTF1(_L("signbit_test():"));

   406    		err = signbit_test();

   407    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   408    		} 

   409    	else if(TestStepName() == Kscalbln_test)

   410 		{

   411    		INFO_PRINTF1(_L("scalbln_test():"));

   412    		err = scalbln_test();

   413    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   414    		} 

   415    	else if(TestStepName() == Kfinite_test)

   416 		{

   417    		INFO_PRINTF1(_L("finite_test():"));

   418    		err = finite_test();

   419    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   420    		} 

   421    	else if(TestStepName() == Kmodf_test)

   422 		{

   423    		INFO_PRINTF1(_L("modf_test():"));

   424    		err = modf_test();

   425    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   426    		} 

   427    	else if(TestStepName() == Kldexp_test)

   428 		{

   429    		INFO_PRINTF1(_L("ldexp_test():"));

   430    		err = ldexp_test();

   431    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   432    		} 

   433    	else if(TestStepName() == Kdrem_test)

   434 		{

   435    		INFO_PRINTF1(_L("drem_test():"));

   436    		err = drem_test();

   437    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   438    		} 

   439    	else if(TestStepName() == Kfrexp_test)

   440 		{

   441    		INFO_PRINTF1(_L("frexp_test():"));

   442    		err = frexp_test();

   443    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   444    		}  

   445    	else if(TestStepName() == Kremquo_test)

   446 		{

   447    		INFO_PRINTF1(_L("remquo_test():"));

   448    		err = remquo_test();

   449    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   450    		} 

   451    	else if(TestStepName() == Kremquo_remcheck_test)

   452 		{

   453    		INFO_PRINTF1(_L("remquo_remcheck_test():"));

   454    		err = remquo_remcheck_test();

   455    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   456    		} 

   457    	else if(TestStepName() == Kgamma_test)

   458 		{

   459    		INFO_PRINTF1(_L("gamma_test():"));

   460    		err = gamma_test();

   461    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   462    		} 

   463    	else if(TestStepName() == Klgamma_test)

   464 		{

   465    		INFO_PRINTF1(_L("lgamma_test():"));

   466    		err = lgamma_test();

   467    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   468    		} 

   469    	else if(TestStepName() == Kfpclassify_test)

   470 		{

   471    		INFO_PRINTF1(_L("fpclassify_test():"));

   472    		err = fpclassify_test();

   473    		SetTestStepResult(err ? static_cast<TVerdict>(err) : EPass);

   474    		}

   475 	return TestStepResult(); 

   476 	}

   477 

   478 

   479 // -----------------------------------------------------------------------------

   480 // Utility functions for testing.

   481 // -----------------------------------------------------------------------------

   482 

   483 void CTestDouble_blr::ReadIntParam(TInt &aInt)

   484 	{

   485 	_LIT( Kparam, "Param%d" );

   486     TBuf<8> pNameBuf;

   487     TPtrC string;

   488     pNameBuf.Format(Kparam,++iParamCnt);

   489 	TBool res = GetIntFromConfig(ConfigSection(), pNameBuf, aInt);

   490 	}

   491 

   492 void CTestDouble_blr::ReadFloatParam(FLOAT &aDbl)

   493 	{

   494 	char Str[MAX_SIZE];

   495 	double d;

   496 	ReadStringParam(Str);

   497 	#ifdef TESTING_FLOAT

   498 		d = strtod(Str,NULL);

   499 	#else

   500 	  	d = strtod(Str,NULL);

   501 	#endif

   502 	aDbl = d; 

   503 	}

   504 	

   505 	

   506 void CTestDouble_blr::ReadStringParam(char* aString)

   507 	{

   508 	_LIT( Kparam, "Param%d" );

   509     TBuf<100> pNameBuf;

   510   	TPtrC descriptor;

   511   	TInt i;

   512 	

   513 	pNameBuf.Format(Kparam,++iParamCnt);

   514 	TBool ret = GetStringFromConfig(ConfigSection(), pNameBuf, descriptor);

   515 	

   516 	if ( descriptor == _L("\"\"") )

   517 		{

   518 	  	i = 0;

   519 	  	}

   520 	else

   521 		{

   522 		// If the string is quoted, take only the insides

   523 		if ((descriptor[0] == '\"') && (descriptor[descriptor.Length()-1] == '\"'))

   524 	    	{

   525 	    	for ( i=0; i<descriptor.Length()-2; i++ )

   526     	  		{

   527         		aString[i]=descriptor[i+1];

   528         		}

   529       		}

   530     		// Otherwise, take the whole string

   531     	else

   532       		{

   533 	    	for ( i=0; i<descriptor.Length(); i++ )

   534     	  		{

   535         		aString[i]=descriptor[i];

   536         		}

   537       		}

   538       		aString[i]='\0';

   539     	}

   540     

   541     

   542 	}

   543 

   544 void CTestDouble_blr::ReadLIntParam(TInt32 &aLInt)

   545 	{

   546 	char Str[MAX_SIZE];

   547 	TInt32 d;

   548 	ReadStringParam( Str);

   549 	 /* Strtol converts the initial part of the

   550 	 string into long integer value according to the 

   551 	 give base [Third arg]*/

   552 	 

   553 	d = strtol(Str,NULL, 10);

   554 	aLInt = d; 

   555 	}

   556 	

   557 void CTestDouble_blr::ReadLLIntParam(TInt64 &aLInt)

   558 	{

   559 	char Str[MAX_SIZE];

   560 	TInt64 d; 							/*long long int*/

   561 	ReadStringParam( Str);

   562 	/* Strtoll converts the initial part of the

   563 	string into long long integer value according to the 

   564 	give base [Third arg]*/

   565 	

   566 	d = strtoll(Str,NULL, 10);

   567 	aLInt = d; 

   568 	}	

   569 // -----------------------------------------------------------------------------

   570 // Test methods

   571 // -----------------------------------------------------------------------------

   572 //                  

   573 int CTestDouble_blr::check_bool (int computed, int expected)

   574 	{

   575 	int ok = 0;

   576 	

   577 	if ((computed == 0) == (expected == 0))

   578 		{

   579 		ok = 1;

   580 		}

   581 	return ok;

   582 	}

   583 

   584 int CTestDouble_blr::check_int (int computed, int expected,  int max_ulp)

   585 	{

   586   	int diff = computed - expected;

   587   	int ok = 0;

   588 

   589   	if (abs (diff) <= max_ulp)

   590 		{

   591   		ok = 1;

   592 		}

   593   	return ok;

   594 	}

   595 

   596 int  CTestDouble_blr::check_float (FLOAT computed, FLOAT expected,FLOAT max_ulp, FLOAT &gen_ulp)

   597 	{

   598 	int ok = 0;

   599 	FLOAT diff = 0;

   600 	FLOAT ulp = 0;

   601 

   602 	if (isnan (computed) && isnan (expected))

   603   		{

   604   		ok = 1;

   605   		}

   606 	else if (isinf (computed) && isinf (expected))

   607 		{

   608 		// Test for sign of infinities.  

   609 		if ((IGNORE_ZERO_INF_SIGN) == 0

   610 			&& signbit (computed) != signbit (expected))

   611 			{

   612 			ok = 0;

   613 			}

   614 		else

   615 			{

   616 			ok = 1;

   617 			}

   618 		}

   619   // Don't calc ulp for NaNs or infinities.  

   620 	else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))

   621   		{

   622   		ok = 0;

   623   		}

   624 	else

   625 		{

   626 		diff = FUNC(fabs) (computed - expected);

   627 		// ilogb (0) isn't allowed.  

   628 		if (expected == 0.0)

   629       		{

   630       		ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);

   631       		}

   632 		else

   633 			{

   634 	  		ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);

   635 	  		}

   636       

   637 		if ((IGNORE_ZERO_INF_SIGN) == 0

   638 			 && computed == 0.0 && expected == 0.0

   639 			 && signbit(computed) != signbit (expected))

   640 			{

   641 			ok = 0;

   642 			}

   643 		else if (ulp == 0.0 || (ulp <= max_ulp ))

   644       		{

   645       		ok = 1;

   646       		}

   647 		else

   648 			{

   649 			ok = 0;

   650 			}

   651 

   652 		}

   653 	gen_ulp = ulp ; 

   654   

   655 	return ok;

   656 	}

   657 

   658 int CTestDouble_blr::check_longlong (TInt64 computed, TInt64 expected,  FLOAT max_ulp, FLOAT &gen_ulp)

   659 	{

   660   	long long int diff = computed - expected;

   661   	int ok = 0;

   662   

   663   

   664   	if ( (gen_ulp = llabs (diff)) <= max_ulp)

   665 		{

   666 		ok = 1;

   667 		}

   668   	return ok;

   669 	}

   670 

   671 int CTestDouble_blr::check_long (TInt32 computed, TInt32 expected,  FLOAT max_ulp, FLOAT &gen_ulp)

   672 	{

   673 	long int diff = computed - expected;

   674   	int ok = 0;

   675 

   676   	if ((gen_ulp =labs (diff)) <= max_ulp)

   677   		{

   678 		ok = 1;

   679 		}

   680 	

   681 	return ok;

   682 	}

   683 	

   684 TInt CTestDouble_blr::cbrt_test()

   685 	{

   686  	// Create temporary variables in stack

   687   	char chParam[MAX_SIZE];

   688   	FLOAT input;

   689   	FLOAT expected;

   690   	FLOAT max_ulp;

   691   	FLOAT gen_ulp;

   692   	  	

   693   	// Read parameters

   694   	

   695   	ReadStringParam (chParam);

   696     ReadFloatParam (input);

   697     ReadFloatParam (expected);

   698     ReadFloatParam (max_ulp);

   699     

   700     //

   701     TBuf<MAX_SIZE> buf;

   702     TInt len = strlen(chParam);

   703     

   704     for (TInt j =0; j<len;j++)

   705 		{

   706     	buf.Append(chParam[j]);

   707 		}

   708     

   709     // Do some testing

   710     FLOAT res = FUNC(cbrt) (input);

   711         

   712     if(check_float(res, expected, max_ulp, gen_ulp))

   713     	{

   714     	INFO_PRINTF1(_L("Test passed."));

   715     	}

   716     else    

   717     	{

   718     	ERR_PRINTF1(_L("Test Failed."));

   719    		return KErrGeneral;

   720       	} 

   721     

   722     INFO_PRINTF1(_L("_________________________________________\n"));

   723     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf );

   724     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   725     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   726 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   727 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   728 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   729 	INFO_PRINTF1(_L("_________________________________________\n"));

   730 	

   731     return KErrNone;

   732 	}

   733 

   734 

   735 

   736 TInt CTestDouble_blr::ceil_test()

   737 	{

   738  	// Create temporary variables in stack

   739   	char chParam[MAX_SIZE];

   740   	FLOAT input;

   741   	FLOAT expected;

   742   	FLOAT max_ulp;

   743   	FLOAT gen_ulp;

   744   

   745   	// Read parameters

   746   	

   747   	ReadStringParam (chParam);

   748     ReadFloatParam (input);

   749     ReadFloatParam (expected);

   750     ReadFloatParam (max_ulp);

   751     //

   752     TBuf<MAX_SIZE> buf;

   753     TInt len = strlen(chParam);

   754     

   755     for (TInt j =0; j<len;j++)

   756 		{

   757     	buf.Append(chParam[j]);

   758 		}

   759     

   760     // Do some testing

   761     FLOAT res = FUNC(ceil) (input);

   762         

   763     if(check_float(res, expected, max_ulp, gen_ulp))

   764     	{

   765     	INFO_PRINTF1(_L("Test passed."));

   766     	}

   767     else    

   768     	{

   769     	ERR_PRINTF1(_L("Test Failed."));

   770    		return KErrGeneral;

   771     	} 

   772     

   773     INFO_PRINTF1(_L("_________________________________________\n"));

   774     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

   775     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   776     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   777 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   778 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   779 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   780 	INFO_PRINTF1(_L("_________________________________________\n"));

   781     

   782     return KErrNone;

   783 	}

   784 

   785 

   786 TInt CTestDouble_blr::erf_test()

   787 	{

   788  	// Create temporary variables in stack

   789   	char chParam[MAX_SIZE];

   790   	FLOAT input;

   791   	FLOAT expected;

   792   	FLOAT max_ulp;

   793   	FLOAT gen_ulp;

   794   

   795   	// Read parameters

   796   	

   797   	ReadStringParam (chParam);

   798     ReadFloatParam (input);

   799     ReadFloatParam (expected);

   800     ReadFloatParam (max_ulp);

   801     //

   802     TBuf<MAX_SIZE> buf;

   803     TInt len = strlen(chParam);

   804     

   805     for (TInt j =0; j<len;j++)

   806     	buf.Append(chParam[j]);

   807     // Do some testing

   808     FLOAT res = FUNC(erf) (input);

   809         

   810     if(check_float(res, expected, max_ulp, gen_ulp))

   811     	{

   812     	INFO_PRINTF1(_L("Test passed."));

   813     	}

   814     else    

   815     	{

   816     	ERR_PRINTF1(_L("Test Failed."));

   817    		return KErrGeneral;

   818     	} 

   819     

   820     

   821     INFO_PRINTF1(_L("_________________________________________\n"));

   822     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

   823     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   824     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   825 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   826 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   827 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   828 	INFO_PRINTF1(_L("_________________________________________\n"));

   829     

   830     return KErrNone;

   831 	}

   832 

   833 TInt CTestDouble_blr::erfc_test()

   834 	{

   835  	// Create temporary variables in stack

   836   	char chParam[MAX_SIZE];

   837   	FLOAT input;

   838   	FLOAT expected;

   839   	FLOAT max_ulp;

   840   	FLOAT gen_ulp;

   841   	

   842   	// Read parameters

   843   	ReadStringParam (chParam);

   844     ReadFloatParam (input);

   845     ReadFloatParam (expected);

   846     ReadFloatParam (max_ulp);

   847     //

   848     TBuf<MAX_SIZE> buf;

   849     TInt len = strlen(chParam);

   850     

   851     for (TInt j =0; j<len;j++)

   852 		{

   853     	buf.Append(chParam[j]);

   854 		}

   855 		

   856     // Do some testing

   857     FLOAT res = FUNC(erfc) (input);

   858         

   859     if(check_float(res, expected, max_ulp, gen_ulp))

   860     	{

   861     	INFO_PRINTF1(_L("Test passed."));

   862     	}

   863     else    

   864     	{

   865     	ERR_PRINTF1(_L("Test Failed."));

   866    		return KErrGeneral;

   867     	} 

   868     

   869     INFO_PRINTF1(_L("_________________________________________\n"));

   870     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

   871     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   872     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   873 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   874 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   875 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   876 	INFO_PRINTF1(_L("_________________________________________\n"));

   877     

   878     return KErrNone;

   879 	}

   880 

   881 TInt CTestDouble_blr::exp_test()

   882 	{

   883  	// Create temporary variables in stack

   884   	char chParam[MAX_SIZE];

   885   	FLOAT input;

   886   	FLOAT expected;

   887   	FLOAT max_ulp;

   888   	FLOAT gen_ulp;

   889   	

   890   	// Read parameters

   891   	

   892   	ReadStringParam (chParam);

   893     ReadFloatParam (input);

   894     ReadFloatParam (expected);

   895     ReadFloatParam (max_ulp);

   896     //

   897     TBuf<MAX_SIZE> buf;

   898     TInt len = strlen(chParam);

   899     

   900     for (TInt j =0; j<len;j++)

   901 		{

   902     	buf.Append(chParam[j]);

   903 		}

   904     

   905     // Do some testing

   906     FLOAT res = FUNC(exp) (input);

   907         

   908     if(check_float(res, expected, max_ulp, gen_ulp))

   909     	{

   910     	INFO_PRINTF1(_L("Test passed."));

   911     	}

   912     else    

   913     	{

   914     	ERR_PRINTF1(_L("Test Failed."));

   915    		return KErrGeneral;

   916     	} 

   917     

   918     INFO_PRINTF1(_L("_________________________________________\n"));

   919     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

   920     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   921     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   922 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   923 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   924 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   925 	INFO_PRINTF1(_L("_________________________________________\n"));

   926      

   927     return KErrNone;

   928 	}

   929 

   930 

   931 TInt CTestDouble_blr::exp2_test()

   932 	{

   933  	// Create temporary variables in stack

   934   	char chParam[MAX_SIZE];

   935   	FLOAT input;

   936   	FLOAT expected;

   937   	FLOAT max_ulp;

   938   	FLOAT gen_ulp;

   939   	

   940   	// Read parameters

   941   	

   942   	ReadStringParam (chParam);

   943     ReadFloatParam (input);

   944     ReadFloatParam (expected);

   945     ReadFloatParam (max_ulp);

   946     //

   947     TBuf<MAX_SIZE> buf;

   948     TInt len = strlen(chParam);

   949     

   950     for (TInt j =0; j<len;j++)

   951 		{

   952     	buf.Append(chParam[j]);

   953 		}

   954     // Do some testing

   955     FLOAT res = FUNC(exp2) (input);

   956         

   957     if(check_float(res, expected, max_ulp, gen_ulp))

   958     	{

   959     	INFO_PRINTF1(_L("Test passed."));

   960     	}

   961     else    

   962     	{

   963     	ERR_PRINTF1(_L("Test Failed."));

   964    		return KErrGeneral;

   965     	} 

   966     

   967     INFO_PRINTF1(_L("_________________________________________\n"));

   968     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

   969     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

   970     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

   971 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

   972 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

   973 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

   974 	INFO_PRINTF1(_L("_________________________________________\n"));

   975      

   976     return KErrNone;

   977 	}

   978 

   979 TInt CTestDouble_blr::expm1_test()

   980 	{

   981  	// Create temporary variables in stack

   982   	char chParam[MAX_SIZE];

   983   	FLOAT input;

   984   	FLOAT expected;

   985   	FLOAT max_ulp;

   986   	FLOAT gen_ulp;

   987   	

   988   	// Read parameters

   989   	

   990   	ReadStringParam (chParam);

   991     ReadFloatParam (input);

   992     ReadFloatParam (expected);

   993     ReadFloatParam (max_ulp);

   994     //

   995     TBuf<MAX_SIZE> buf;

   996     TInt len = strlen(chParam);

   997     

   998     for (TInt j =0; j<len;j++)

   999 		{

  1000     	buf.Append(chParam[j]);

  1001 		}

  1002     // Do some testing

  1003     FLOAT res = FUNC(expm1) (input);

  1004         

  1005     if(check_float(res, expected, max_ulp, gen_ulp))

  1006     	{

  1007     	INFO_PRINTF1(_L("Test passed."));

  1008     	}

  1009     else    

  1010     	{

  1011     	ERR_PRINTF1(_L("Test Failed."));

  1012    		return KErrGeneral;

  1013     	} 

  1014     

  1015     INFO_PRINTF1(_L("_________________________________________\n"));

  1016     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

  1017     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

  1018     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

  1019 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

  1020 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

  1021 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

  1022 	INFO_PRINTF1(_L("_________________________________________\n"));

  1023     

  1024     return KErrNone;

  1025 	}

  1026 

  1027 TInt CTestDouble_blr::fabs_test()

  1028 	{

  1029  	// Create temporary variables in stack

  1030   	char chParam[MAX_SIZE];

  1031   	FLOAT input;

  1032   	FLOAT expected;

  1033   	FLOAT max_ulp;

  1034   	FLOAT gen_ulp;

  1035   	

  1036   	

  1037   	// Read parameters

  1038   	

  1039   	ReadStringParam (chParam);

  1040     ReadFloatParam (input);

  1041     ReadFloatParam (expected);

  1042     ReadFloatParam (max_ulp);

  1043     //

  1044     TBuf<MAX_SIZE> buf;

  1045     TInt len = strlen(chParam);

  1046     

  1047     for (TInt j =0; j<len;j++)

  1048 		{

  1049     	buf.Append(chParam[j]);

  1050 		}

  1051     // Do some testing

  1052     FLOAT res = FUNC(fabs) (input);

  1053         

  1054     if(check_float(res, expected, max_ulp, gen_ulp))

  1055     	{

  1056     	INFO_PRINTF1(_L("Test passed."));

  1057     	}

  1058     else    

  1059     	{

  1060     	ERR_PRINTF1(_L("Test Failed."));

  1061    		return KErrGeneral;

  1062     	} 

  1063     

  1064     INFO_PRINTF1(_L("_________________________________________\n"));

  1065     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf);

  1066     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

  1067     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

  1068 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

  1069 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

  1070 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

  1071 	INFO_PRINTF1(_L("_________________________________________\n"));

  1072      

  1073     return KErrNone;

  1074 	}

  1075 

  1076 

  1077 TInt CTestDouble_blr::ilogb_test()

  1078 	{

  1079  	// Create temporary variables in stack

  1080   	char chParam[MAX_SIZE];

  1081   	FLOAT input;

  1082   	FLOAT expected;

  1083   	FLOAT max_ulp;

  1084   	FLOAT gen_ulp;

  1085    	// Read parameters

  1086   	ReadStringParam (chParam);

  1087     ReadFloatParam (input);

  1088     ReadFloatParam (expected);

  1089     ReadFloatParam (max_ulp);

  1090     //

  1091     TBuf<MAX_SIZE> buf;

  1092     TInt len = strlen(chParam);

  1093     

  1094     for (TInt j =0; j<len;j++)

  1095 		{

  1096     	buf.Append(chParam[j]);

  1097 		}

  1098     // Do some testing

  1099     FLOAT res = FUNC(ilogb) (input);

  1100         

  1101     if(check_float(res, expected, max_ulp, gen_ulp))

  1102     	{

  1103     	INFO_PRINTF1(_L("Test passed."));

  1104     	}

  1105     else    

  1106     	{

  1107     	ERR_PRINTF1(_L("Test Failed."));

  1108    		return KErrGeneral;

  1109     	} 

  1110     

  1111     INFO_PRINTF1(_L("_________________________________________\n"));

  1112     INFO_PRINTF2(_L("TestCase		  : %S\n"), &buf );

  1113     INFO_PRINTF2(_L("Input Value    : %f\n"), input );

  1114     INFO_PRINTF2(_L("Expected Value : %f\n"), expected );

  1115 	INFO_PRINTF2(_L("Max ULP value  : %f\n"), max_ulp );

  1116 	INFO_PRINTF2(_L("Result  		  : %f\n"), res );

  1117 	INFO_PRINTF2(_L("Generated Ulp  : %f\n"), gen_ulp );

  1118 	INFO_PRINTF1(_L("_________________________________________\n"));

  1119     return KErrNone;

  1120 	}

  1121 

  1122 

  1123 TInt CTestDouble_blr::j0_test()

  1124 	{

  1125  	// Create temporary variables in stack

  1126   	char chParam[MAX_SIZE];

  1127   	FLOAT input;

  1128   	FLOAT expected;

  1129   	FLOAT max_ulp;

  1130   	FLOAT gen_ulp;

  1131   	

  1132   	// Read parameters

  1133   	

  1134   	ReadStringParam (chParam);

  1135     ReadFloatParam (input);