//
// boost limits_test.cpp   test your <limits> file for important
// Copyright Jens Maurer 2000
// Permission to use, copy, modify, sell, and distribute this software
// is hereby granted without fee provided that the above copyright notice
// appears in all copies and that both that copyright notice and this
// permission notice appear in supporting documentation,
// Jens Maurer makes no representations about the suitability of this
// software for any purpose. It is provided "as is" without express or
// implied warranty.
// 
//

#include <limits>

#include "cppunit/cppunit_proxy.h"

#if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
using namespace std;
#endif

//
// TestCase class
//
class LimitTest : public CPPUNIT_NS::TestCase
{
  CPPUNIT_TEST_SUITE(LimitTest);
  CPPUNIT_TEST(test);
#  if defined (__BORLANDC__)
  CPPUNIT_IGNORE;
#  endif
  CPPUNIT_TEST(qnan_test);
  CPPUNIT_TEST(limits_cov);
  CPPUNIT_TEST_SUITE_END();

protected:
  void test();
  void qnan_test();
  void limits_cov();
};

CPPUNIT_TEST_SUITE_REGISTRATION(LimitTest);

#  define CHECK_COND(X) if (!(X)) return false;

bool valid_sign_info(bool, bool)
{ return true; }

template <class _Tp>
bool valid_sign_info(bool limit_is_signed, const _Tp &) {
  return limit_is_signed && _Tp(-1) < 0 ||
         !limit_is_signed && _Tp(-1) > 0;
}

template <class _Tp>
bool test_integral_limits(const _Tp &, bool unknown_sign = true, bool is_signed = true) {
  typedef numeric_limits<_Tp> lim;

  CHECK_COND(lim::is_specialized);
  CHECK_COND(lim::is_integer);
  /*CHECK_COND(lim::is_modulo);*/
  CHECK_COND(lim::min() < lim::max());
  CHECK_COND((unknown_sign && ((lim::is_signed && (lim::min() != 0)) || (!lim::is_signed && (lim::min() == 0)))) ||
             (!unknown_sign && ((lim::is_signed && is_signed) || (!lim::is_signed && !is_signed))));

  if (unknown_sign) {
    CHECK_COND(valid_sign_info(lim::is_signed, _Tp()));
  }
  return true;
}

template <class _Tp>
bool test_signed_integral_limits(const _Tp &__val) {
  return test_integral_limits(__val, false, true);
}
template <class _Tp>
bool test_unsigned_integral_limits(const _Tp &__val) {
  return test_integral_limits(__val, false, false);
}

template <class _Tp>
bool test_float_limits(const _Tp &) {
  typedef numeric_limits<_Tp> lim;
  CHECK_COND(lim::is_specialized);
  CHECK_COND(!lim::is_modulo);
  CHECK_COND(!lim::is_integer);
  CHECK_COND(lim::is_signed);

  CHECK_COND(lim::max() > 1000);
  CHECK_COND(lim::min() > 0);
  CHECK_COND(lim::min() < 0.001);
  CHECK_COND(lim::epsilon() > 0);

  if (lim::is_iec559) {
    CHECK_COND(lim::has_infinity);
    CHECK_COND(lim::has_quiet_NaN);
    CHECK_COND(lim::has_signaling_NaN);
    CHECK_COND(lim::signaling_NaN);
  }

  if (lim::has_infinity) {
    const _Tp infinity = lim::infinity();
    /* Make sure those values are not 0 or similar nonsense.
    * Infinity must compare as if larger than the maximum representable value.
    */
    CHECK_COND(infinity > lim::max());
    CHECK_COND(-infinity < -lim::max());
  }
  return true;
}

template <class _Tp>
bool test_qnan(const _Tp &) {
  typedef numeric_limits<_Tp> lim;
  if (lim::has_quiet_NaN) {
    const _Tp qnan = lim::quiet_NaN();

    /* NaNs shall always compare "false" when compared for equality
    * If one of these fail, your compiler may be optimizing incorrectly,
    * or the STLport is incorrectly configured.
    */
    CHECK_COND(! (qnan == 42));
    CHECK_COND(! (qnan == qnan));
    CHECK_COND(qnan != 42);
    CHECK_COND(qnan != qnan);

    /* The following tests may cause arithmetic traps.
    * CHECK_COND(! (qnan < 42));
    * CHECK_COND(! (qnan > 42));
    * CHECK_COND(! (qnan <= 42));
    * CHECK_COND(! (qnan >= 42));
    */
  }
  return true;
}
void LimitTest::test() {
  CPPUNIT_ASSERT(test_integral_limits(bool()));
  /*
  It is implementation-defined whether a char object can hold 
  negative values. Characters can be explicitly declared unsigned or signed. Plain char, signed char, and unsigned 
  char are three distinct types. 
  */
  //CPPUNIT_ASSERT(test_integral_limits(char()));
  typedef signed char signed_char;
  CPPUNIT_ASSERT(test_signed_integral_limits(signed_char()));
  typedef unsigned char unsigned_char;
  CPPUNIT_ASSERT(test_unsigned_integral_limits(unsigned_char()));
#  if defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)
  CPPUNIT_ASSERT(test_integral_limits(wchar_t()));
#  endif
  CPPUNIT_ASSERT(test_signed_integral_limits(short()));
  typedef unsigned short unsigned_short;
  CPPUNIT_ASSERT(test_unsigned_integral_limits(unsigned_short()));
  CPPUNIT_ASSERT(test_signed_integral_limits(int()));
  typedef unsigned int unsigned_int;
  CPPUNIT_ASSERT(test_unsigned_integral_limits(unsigned_int()));
  CPPUNIT_ASSERT(test_signed_integral_limits(long()));
  typedef unsigned long unsigned_long;
  CPPUNIT_ASSERT(test_unsigned_integral_limits(unsigned_long()));
#  if defined (_STLP_LONG_LONG)
  typedef _STLP_LONG_LONG long_long;
  CPPUNIT_ASSERT(test_signed_integral_limits(long_long()));
  typedef unsigned _STLP_LONG_LONG unsigned_long_long;
  CPPUNIT_ASSERT(test_unsigned_integral_limits(unsigned_long_long()));
#endif

  CPPUNIT_ASSERT(test_float_limits(float()));
  CPPUNIT_ASSERT(test_float_limits(double()));
#  if !defined ( _STLP_NO_LONG_DOUBLE )
  typedef long double long_double;
  CPPUNIT_ASSERT(test_float_limits(long_double()));
#  endif
}

void LimitTest::qnan_test() {
  CPPUNIT_ASSERT(test_qnan(float()));
  CPPUNIT_ASSERT(test_qnan(double()));
#  if !defined ( _STLP_NO_LONG_DOUBLE )
  typedef long double long_double;
  CPPUNIT_ASSERT(test_qnan(long_double()));
#  endif
}
void LimitTest::limits_cov() 
	{
	if(numeric_limits<float>::has_denorm == false)
		{
		CPPUNIT_ASSERT(numeric_limits<float>::denorm_min( )); // denorm_min for float
		CPPUNIT_ASSERT(numeric_limits<double>::denorm_min( )); // denorm_min for double
		CPPUNIT_ASSERT(numeric_limits<long double>::denorm_min( )); // denorm_min for long double
		}
	numeric_limits<float>::round_error( ); // round_error for float
	numeric_limits<double>::round_error( ); // round_error for double
	numeric_limits<long double>::round_error( ); // round_error for long double
	if(numeric_limits<long double>::is_iec559)
		{
		CPPUNIT_ASSERT(numeric_limits<long double>::infinity( )); // infinity for long double
		CPPUNIT_ASSERT(numeric_limits<long double>::quiet_NaN( ));// quiet_NaN for long double
		}
	}