// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of "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:

//

#define _STLP_DO_IMPORT_CSTD_FUNCTIONS

#include <limits>

#include <cmath>

#include <complex>

//We also test math functions imported from stdlib.h or

//defined in cstdlib

#include <cstdlib>

#include "math_aux.h"

#include "cppunit/cppunit_proxy.h"

//This test purpose is to check the right import of math.h C symbols

//into the std namespace so we do not use the using namespace std

//specification

//

// TestCase class

//

{

  CPPUNIT_TEST_SUITE(CMathTest);

  CPPUNIT_TEST(test);

  CPPUNIT_TEST(complex_double_cov1);

  CPPUNIT_TEST(complex_double_cov2);

  CPPUNIT_TEST(complex_double_cov3);

  CPPUNIT_TEST(complex_double_cov4);

  CPPUNIT_TEST(complex_float_cov1);

  CPPUNIT_TEST(complex_float_cov2);

  CPPUNIT_TEST(complex_float_cov3);

  CPPUNIT_TEST(complex_float_cov4);

  CPPUNIT_TEST(complex_longdouble_cov1);

  CPPUNIT_TEST(complex_longdouble_cov2);

  CPPUNIT_TEST(complex_longdouble_cov3);

  CPPUNIT_TEST(complex_longdouble_cov4);

  CPPUNIT_TEST(complex_trigonometric_cov);

  CPPUNIT_TEST(complex_cmath_cov);

  CPPUNIT_TEST(complex_templates_cov1);

  CPPUNIT_TEST(complex_templates_cov2);

  CPPUNIT_TEST(complex_constructors_cov1);

  CPPUNIT_TEST(complex_constructors_cov2);

  CPPUNIT_TEST_SUITE_END();

  protected:

    void test();

    void complex_double_cov1();

    void complex_double_cov2();

    void complex_double_cov3();

    void complex_double_cov4();

    void complex_float_cov1();

    void complex_float_cov2();

    void complex_float_cov3();

    void complex_float_cov4();

    void complex_longdouble_cov1();

    void complex_longdouble_cov2();

    void complex_longdouble_cov3();

    void complex_longdouble_cov4();

    void complex_trigonometric_cov();

    void complex_cmath_cov();

    void complex_templates_cov1();

    void complex_templates_cov2();

    void complex_constructors_cov1();

    void complex_constructors_cov2();

};

CPPUNIT_TEST_SUITE_REGISTRATION(CMathTest);

//

// tests implementation

//

void CMathTest::test()

{

  int int_val = -1;

  long long_val = -1l;

  float float_val = -1.0f;

  double double_val = -1.0;

#if !defined (_STLP_NO_LONG_DOUBLE)

  long double long_double_val = -1.0l;

#endif

  CPPUNIT_CHECK( are_equals(std::abs(int_val), -int_val) );

  CPPUNIT_CHECK( are_equals(std::abs(long_val), -long_val) );

  CPPUNIT_CHECK( are_equals(std::labs(long_val), -long_val) );

  CPPUNIT_CHECK( are_equals(std::abs(float_val), -float_val) );

  CPPUNIT_CHECK( are_equals(std::abs(double_val), -double_val) );

#if !defined (_STLP_NO_LONG_DOUBLE)

  CPPUNIT_CHECK( are_equals(std::abs(long_double_val), -long_double_val) );

#endif

  CPPUNIT_CHECK( are_equals(std::fabs(float_val), -float_val) );

  CPPUNIT_CHECK( are_equals(std::fabs(double_val), -double_val) );

#if !defined (_STLP_NO_LONG_DOUBLE)

  CPPUNIT_CHECK( are_equals(std::fabs(long_double_val), -long_double_val) );

#endif

  std::div_t div_res = std::div(3, 2);

  CPPUNIT_CHECK( div_res.quot == 1 );

  CPPUNIT_CHECK( div_res.rem == 1 );

  std::ldiv_t ldiv_res = std::ldiv(3l, 2l);

  CPPUNIT_CHECK( ldiv_res.quot == 1l );

  CPPUNIT_CHECK( ldiv_res.rem == 1l );

  ldiv_res = std::div(3l, 2l);

  CPPUNIT_CHECK( ldiv_res.quot == 1l );

  CPPUNIT_CHECK( ldiv_res.rem == 1l );

  std::srand(2);

  int rand_val = std::rand();

  CPPUNIT_CHECK( rand_val >= 0 && rand_val <= RAND_MAX );

  CPPUNIT_CHECK( are_equals(std::floor(1.5), 1.0) );

  CPPUNIT_CHECK( are_equals(std::ceil(1.5), 2.0) );

  CPPUNIT_CHECK( are_equals(std::fmod(1.5, 1.0), 0.5) );

  CPPUNIT_CHECK( are_equals(std::sqrt(4.0), 2.0) );

  CPPUNIT_CHECK( are_equals(std::pow(2.0, 2), 4.0) );

  /*

   * Uncomment the following to check that it generates an ambiguous call

   * as there is no Standard pow(int, int) function only pow(double, int),

   * pow(float, int) and some others...

   * If it do not generate a compile time error it should at least give

   * the good result.

   */

  //CPPUNIT_CHECK( are_equals(std::pow(10, -2), 0.01) );

  CPPUNIT_CHECK( are_equals(std::pow(10.0, -2), 0.01) );

  CPPUNIT_CHECK( are_equals(std::exp(0.0), 1.0) );

  CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0)), 1.0) );

  CPPUNIT_CHECK( are_equals(std::log10(100.0), 2.0) );

#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)

  CPPUNIT_CHECK( are_equals(std::modf(100.5, &double_val), 0.5) );

  CPPUNIT_CHECK( are_equals(double_val, 100.0) );

#endif

  double_val = std::frexp(8.0, &int_val);

  CPPUNIT_CHECK( are_equals(double_val * std::pow(2.0, int_val), 8.0) );

  CPPUNIT_CHECK( are_equals(std::ldexp(1.0, 2), 4.0) );

  CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0)), 1.0) );

  CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0)), 1.0) );

  CPPUNIT_CHECK( are_equals(std::tan(std::atan(1.0)), 1.0) );

  CPPUNIT_CHECK( are_equals(std::tan(std::atan2(1.0, 1.0)), 1.0) );

  CPPUNIT_CHECK( are_equals(std::cosh(0.0), 1.0) );

  CPPUNIT_CHECK( are_equals(std::sinh(0.0), 0.0) );

#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)

  CPPUNIT_CHECK( are_equals(std::tanh(0.0), 0.0) );

#endif

  CPPUNIT_CHECK( are_equals(std::floor(1.5f), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::ceil(1.5f), 2.0f) );

  CPPUNIT_CHECK( are_equals(std::fmod(1.5f, 1.0f), 0.5f) );

  CPPUNIT_CHECK( are_equals(std::sqrt(4.0f), 2.0f) );

  CPPUNIT_CHECK( are_equals(std::pow(2.0f, 2), 4.0f) );

  CPPUNIT_CHECK( are_equals(std::exp(0.0f), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0f)), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::log10(100.0f), 2.0f) );

#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)

  CPPUNIT_CHECK( are_equals(std::modf(100.5f, &float_val), 0.5f) );

  CPPUNIT_CHECK( are_equals(float_val, 100.0f) );

#endif

  float_val = std::frexp(8.0f, &int_val);

  CPPUNIT_CHECK( are_equals(float_val * std::pow(2.0f, int_val), 8.0f) );

  CPPUNIT_CHECK( are_equals(std::ldexp(1.0f, 2), 4.0f) );

  CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0f)), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0f)), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::tan(std::atan(1.0f)), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::tan(std::atan2(1.0f, 1.0f)), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::cosh(0.0f), 1.0f) );

  CPPUNIT_CHECK( are_equals(std::sinh(0.0f), 0.0f) );

#if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)

  CPPUNIT_CHECK( are_equals(std::tanh(0.0f), 0.0f) );

#endif

#if !defined (_STLP_NO_LONG_DOUBLE)

  CPPUNIT_CHECK( are_equals(std::floor(1.5l), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::ceil(1.5l), 2.0l) );

  CPPUNIT_CHECK( are_equals(std::fmod(1.5l, 1.0l), 0.5l) );

  CPPUNIT_CHECK( are_equals(std::sqrt(4.0l), 2.0l) );

  CPPUNIT_CHECK( are_equals(std::pow(2.0l, 2), 4.0l) );

  CPPUNIT_CHECK( are_equals(std::exp(0.0l), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::log(std::exp(1.0l)), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::log10(100.0l), 2.0l) );

#  if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_WIN64)

  CPPUNIT_CHECK( are_equals(std::modf(100.5l, &long_double_val), 0.5l) );

  CPPUNIT_CHECK( are_equals(long_double_val, 100.0l) );

#  endif

  long_double_val = std::frexp(8.0l, &int_val);

  CPPUNIT_CHECK( are_equals(long_double_val * std::pow(2.0l, int_val), 8.0l) );

  CPPUNIT_CHECK( are_equals(std::ldexp(1.0l, 2), 4.0l) );

  CPPUNIT_CHECK( are_equals(std::cos(std::acos(1.0l)), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::sin(std::asin(1.0l)), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::tan(0.0l), 0.0l) );

  CPPUNIT_CHECK( are_equals(std::atan(0.0l), 0.0l) );

  CPPUNIT_CHECK( are_equals(std::atan2(0.0l, 1.0l), 0.0l) );

  CPPUNIT_CHECK( are_equals(std::cosh(0.0l), 1.0l) );

  CPPUNIT_CHECK( are_equals(std::sinh(0.0l), 0.0l) );

#  if !defined (STLPORT) || !defined (_STLP_USING_PLATFORM_SDK_COMPILER) || !defined (_M_AMD64)

  CPPUNIT_CHECK( are_equals(std::tanh(0.0l), 0.0l) );

#  endif

#endif

  CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0))), 2.0) );

  CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0f))), 2.0f) );

#if !defined (_STLP_NO_LONG_DOUBLE)

  CPPUNIT_CHECK( are_equals(std::sqrt(std::sqrt(std::sqrt(256.0l))), 2.0l) );

#endif

}

void CMathTest::complex_double_cov1()

	{

	using namespace std;

	double pi = 3.14159265359;

	// Test Case for abs,arg abd SQRT

	{

	complex <double> c1( polar ( 5.0 ) ); 

	complex <double> c2 ( polar ( 5.0 , pi / 6 ) );

	double absc1 = abs ( c1 );

	double argc1 = arg ( c1 );

	CPPUNIT_CHECK( absc1 == 5 );

	CPPUNIT_CHECK( argc1 == 0 );

	double normc2 = norm ( c2 );

	double sqrtnormc2 = sqrt ( normc2 );

	CPPUNIT_CHECK(sqrtnormc2 == 5);

	}

	// Test case for the real,imag and conj

	{

	complex <double> c1 ( 4.0 , 3.0 );

	double dr1 = real ( c1 );

	CPPUNIT_CHECK(dr1 == 4);

	double di1 = imag ( c1 );

	CPPUNIT_CHECK(di1 == 3);

	complex <double> c2 = conj ( c1 );

	double dr2 = real ( c2 );

	CPPUNIT_CHECK(dr2 == 4);

	double di2 = imag ( c2 );

	CPPUNIT_CHECK(di2 == -3);

	}

	// test case for the operator "=" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1a ( polar (2.0 , pi /3 ) );

	complex <double> cr1b ( polar (2.0 , pi / 3 ) );

	CPPUNIT_CHECK(cl1 != cr1a);

	CPPUNIT_CHECK(cr1b == cr1a);

	double cl3a =3;

	double cl3b =5;

	complex <double> cr3a ( 3 , 4 );

	complex <double> cr3b ( 5 ,0 );

	CPPUNIT_CHECK(cl3a != cr3a);

	CPPUNIT_CHECK(cl3b == cr3b);

	complex <int> cl2a ( 3 , 4 );

	complex <int> cl2b ( 5 ,0 );

	int cr2a =3;

	CPPUNIT_CHECK(cl2a != cr2a);

	}

}

void CMathTest::complex_double_cov2()

	{

	using namespace std;

	double pi = 3.14159265359;

	// test case for the operator "*" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1 * cr1;	

	complex <double> cl2 ( polar ( 3.0 , pi / 6 ) );

	double cr2 =5;

	complex <double> cs2 = cl2 * cr2;

	double cl3 = 5;

	complex <double> cr3 ( polar (3.0 , pi / 6 ) );

	complex <double> cs3 = cl3 * cr3;

	CPPUNIT_CHECK(cs1 == cs2);

	CPPUNIT_CHECK(cs3 == cs2);

	}

	// test case for the operator "+" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1 + cr1;	

	complex <double> cl2 ( polar ( 3.0 , pi / 6 ) );

	double cr2 =5;

	complex <double> cs2 = cl2 + cr2;

	double cl3 = 5;

	complex <double> cr3 ( polar (3.0 , pi / 6 ) );

	complex <double> cs3 = cl3 + cr3;

	complex <double> cr4 ( 3.0 , 4.0 );

	complex <double> cs4 = + cr4;

	CPPUNIT_CHECK(cs4 == cr4);

	CPPUNIT_CHECK(cs1 == cs2);

	CPPUNIT_CHECK(cs3 == cs2);

	}

	// test case for the operator "-" , the 3 templates 

	{

	complex <double> cl1 (3 , 4);

	complex <double> cr1 ( 2,3 );

	complex <double> cs1 = cl1 - cr1;

	complex <double> cs11 ( 1,1 );

	CPPUNIT_CHECK(cs1 == cs11);

	complex <double> cl2 (3 , 4);

	double cr2 =5;

	complex <double> cs2 = cl2 - cr2;

	complex <double> cs22 (-2 , 4);

	CPPUNIT_CHECK(cs2 == cs22);

	double cl3 = 5;

	complex <double> cr3 (3 , 4);

	complex <double> cs3 = cl3 - cr3;

	complex <double> cs33 (2 , -4);

	CPPUNIT_CHECK(cs3 == cs33);

	complex <double> cr4 ( 3 , 4 );

	complex <double> cs4 = -cr4;

	complex <double> cs44 (-3 , -4);

	CPPUNIT_CHECK(cs4 == cs44);

	}

	// test case for the operator "/" , the 3 templates 

	{

	complex <double> cl1 (4 , 4);

	complex <double> cr1 ( 2,2 );

	complex <double> cs1 = cl1/cr1;

	complex <double> cs11 ( 2,0 );

	CPPUNIT_CHECK(cs1 == cs11);

	complex <double> cl2 (4 , 4);

	double cr2 =2;

	complex <double> cs2 = cl2/cr2;

	complex <double> cs22 (2 , 2);

	CPPUNIT_CHECK(cs2 == cs22);

	double cl3 = 4;

	complex <double> cr3 (2 , 2);

	complex <double> cs3 = cl3/cr3;

	complex <double> cs33 (1 , -1);

	CPPUNIT_CHECK(cs3 == cs33);

	}

}

void CMathTest::complex_double_cov3()

	{

	using namespace std;

	double pi = 3.14159265359;

	// test case for the operator "*=" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1 * cr1;	

	complex <double> cs11 (10,0);	

	complex <int> cint1 ( 2,0 );

	complex <double> csresult (20,0);	

	cl1 *= cr1;

	CPPUNIT_CHECK(cs1 == cl1);

	double val = 2;

	cr1 *= val;

	CPPUNIT_CHECK(cr1 == cs11);	

	cs11 *= cint1;

	CPPUNIT_CHECK(csresult == cs11);	

	}

	// test case for the operator "+=" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1 + cr1;	

	complex <double> cs11 (7,0);	

	complex <int> cint1 ( 2,0 );

	complex <double> csresult (9,0);

	cl1 += cr1;

	CPPUNIT_CHECK(cs1 == cl1);

	double val = 2;

	cr1 += val;

	CPPUNIT_CHECK(cr1 == cs11);	

	cs11 += cint1;

	CPPUNIT_CHECK(csresult == cs11);	

	}

}

void CMathTest::complex_double_cov4()

	{

	using namespace std;

	double pi = 3.14159265359;

	// test case for the operator "-=" , the 3 templates 

	{

	complex <double> cl1 ( polar (3.0 , pi / 6 ) );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1 - cr1;	

	complex <double> cs11 (3,0);	

	complex <int> cint1 ( 2,0 );

	complex <double> csresult (1,0);

	cl1 -= cr1;

	CPPUNIT_CHECK(cs1 == cl1);

	double val = 2;

	cr1 -= val;

	CPPUNIT_CHECK(cr1 == cs11);	

	cs11 -= cint1;

	CPPUNIT_CHECK(csresult == cs11);

	}

	// test case for the operator "/=" , the 3 templates 

	{

	complex <double> cl1 ( 10,0 );

	complex <double> cr1 ( 5,0 );

	complex <double> cs1 = cl1/cr1;	

	complex <double> cs11 (1,0);

	complex <int> cint1 ( 1,0 );

	complex <double> csresult (1,0);	

	cl1 /= cr1;

	CPPUNIT_CHECK(cs1 == cl1);

	double val = 5;

	cr1 /= val;

	CPPUNIT_CHECK(cr1 == cs11);

	cs11 /= cint1;

	CPPUNIT_CHECK(csresult == cs11);

	}

	// test case for the operator "=" , the 3 templates 

	{

	complex <double> cl1 ( 3.0 , 4.0 );

	complex <double> cr1 ( 2.0 , -1.0 );

	cl1  = cr1;

	CPPUNIT_CHECK(cl1 == cr1);

	complex <double> cl2 ( -2 , 4 );

	double cr2 =5.0;

	cl2 = cr2;

	CPPUNIT_CHECK(cl2 == cr2);

	complex<double> cl3(3.0, 4.0);

	cl2 = cl3;

	CPPUNIT_CHECK(cl2 == cl3);

	}

}

void CMathTest::complex_float_cov1()

	{

		using namespace std;

		// test case for the abs,arg and sqrt 

		{

		complex <float> c1( polar ( 5.0 ) ); 

		complex <float> c2 ( 5,0 );

		float absc1 = abs ( c1 );

		float argc1 = arg ( c1 );

		CPPUNIT_CHECK( absc1 == 5 );

		CPPUNIT_CHECK( argc1 == 0 );

		float normc2 = norm ( c2 );

		float val = 25;

		float sqrtnormc2 = sqrt ( normc2 );

		CPPUNIT_CHECK(normc2 == val);

		CPPUNIT_CHECK(sqrtnormc2 == 5);

		}

		// test case for the real,imag and conj

		{

		complex <float> c1 ( 4.0 , 3.0 );

		float dr1 = real ( c1 );

	    CPPUNIT_CHECK(dr1 == 4);

	    float di1 = imag ( c1 );

	    CPPUNIT_CHECK(di1 == 3);

	    complex <float> c2 = conj ( c1 );

		float dr2 = real ( c2 );

		CPPUNIT_CHECK(dr2 == 4);

		float di2 = imag ( c2 );

		CPPUNIT_CHECK(di2 == -3);

		}

		// test case for the operator "=" , the 3 templates 

		{

	    complex <float> cl1 ( 7,7 );

	    complex <float> cr1a ( 5,7 );

	    complex <float> cr1b ( 5,7 );

		CPPUNIT_CHECK(cl1 != cr1a);

		CPPUNIT_CHECK(cr1b == cr1a);

		float cl3a =3;

		float cl3b =5;

	    complex <float> cr3a ( 3 , 4 );

	    complex <float> cr3b ( 5 ,0 );

	    CPPUNIT_CHECK(cl3a != cr3a);

	    CPPUNIT_CHECK(cl3b == cr3b);

	    complex <int> cl2a ( 3 , 4 );

	    complex <int> cl2b ( 5 ,0 );

	    int cr2a =3;

	    CPPUNIT_CHECK(cl2a != cr2a);

		}

	}

void CMathTest::complex_float_cov2()

	{

	using namespace std;

		// test case for the operator "*" , the 3 templates 

		{

	    complex <float> cl1 ( 7,5 );

		complex <float> cr1 ( 5,0 );

		complex <float> cs1 = cl1 * cr1;	

		complex <float> cl2 ( 7,5 );

		float cr2 =5;

		complex <float> cs2 = cl2 * cr2;

		float cl3 = 5;

		complex <float> cr3 ( 7,5 );

		complex <float> cs3 = cl3 * cr3;

		CPPUNIT_CHECK(cs1 == cs2);

		CPPUNIT_CHECK(cs3 == cs2);

		}

		// test case for the operator "+" , the 3 templates 

		{

	    complex <float> cl1 ( 7,0 );

		complex <float> cr1 ( 5,0 );

		complex <float> cs1 = cl1 + cr1;	

		complex <float> cl2 ( 7,0 );

		float cr2 =5;

		complex <float> cs2 = cl2 + cr2;

		float cl3 = 5;

		complex <float> cr3 ( 7,0 );

		complex <float> cs3 = cl3 + cr3;

		complex <float> cr4 ( 3.0 , 4.0 );