limits_test.cpp File Reference

#include <limits>
#include "cppunit/cppunit_proxy.h"

Include dependency graph for limits_test.cpp:

Go to the source code of this file.

Classes
class	LimitTest
class	ArbitraryType

Macros
#define	CHECK_COND(X)   if (!check_cond(X)) { CPPUNIT_MESSAGE(#X); return false; }

Functions
	CPPUNIT_TEST_SUITE_REGISTRATION (LimitTest)
bool	check_cond (const bool &cond)
bool	valid_sign_info (bool, bool)
template<class _Tp >
bool	valid_sign_info (bool limit_is_signed, const _Tp &)
template<class _Tp >
bool	test_integral_limits_base (const _Tp &, bool unknown_sign=true, bool is_signed=true)
template<class _Tp >
bool	test_integral_limits (const _Tp &val, bool unknown_sign=true, bool is_signed=true)
template<class _Tp >
bool	test_signed_integral_limits (const _Tp &__val)
template<class _Tp >
bool	test_unsigned_integral_limits (const _Tp &__val)
template<class _Tp >
bool	test_float_values (_Tp lhs, _Tp rhs)
template<class _Tp >
bool	test_float_limits (const _Tp &)
template<class _Tp >
bool	test_qnan (const _Tp &)

Macro Definition Documentation

CHECK_COND

#define CHECK_COND

(

X

)

if (!check_cond(X)) { CPPUNIT_MESSAGE(#X); return false; }

Definition at line 57 of file limits_test.cpp.

Function Documentation

check_cond()

bool check_cond

(

const bool &

cond

)

Definition at line 56 of file limits_test.cpp.

{ return cond; }

CPPUNIT_TEST_SUITE_REGISTRATION()

CPPUNIT_TEST_SUITE_REGISTRATION

(

LimitTest

)

test_float_limits()

template<class _Tp >

bool test_float_limits

(

const _Tp &

)

Definition at line 124 of file limits_test.cpp.

                                    {
  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::has_denorm == denorm_present);
  }
 
  if (lim::has_denorm == denorm_absent) {
    CHECK_COND(lim::denorm_min() == lim::min());
    _Tp tmp = lim::min();
    tmp /= 2;
    if (tmp > 0 && tmp < lim::min()) {
      // has_denorm could be denorm_present
      CPPUNIT_MESSAGE("It looks like your compiler/platform supports denormalized floating point representation.");
    }
  }
  else if (lim::has_denorm == denorm_present) {
    CHECK_COND(lim::denorm_min() > 0);
    CHECK_COND(lim::denorm_min() < lim::min());
 
    _Tp tmp = lim::min();
    while (tmp != 0) {
      _Tp old_tmp = tmp;
      tmp /= 2;
      CHECK_COND(tmp < old_tmp);
      CHECK_COND(tmp >= lim::denorm_min() || tmp == (_Tp)0);
      //ostringstream str;
      //str << "denorm_min = " << lim::denorm_min() << ", tmp = " << tmp;
      //CPPUNIT_MESSAGE(str.str().c_str());
    }
  }
 
  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. */
 
    _Tp val = lim::max();
    val *= 2;
 
    /* We use test_float_values because without it some compilers (gcc) perform weird
     * optimization on the test giving unexpected result. */
    CHECK_COND(test_float_values(val, infinity));
 
    /*
    ostringstream str;
    str << "lim::max() = " << lim::max() << ", val = " << val << ", infinity = " << infinity;
    CPPUNIT_MESSAGE( str.str().c_str() );
    str.str(string());
    str << "sizeof(_Tp) = " << sizeof(_Tp);
    CPPUNIT_MESSAGE( str.str().c_str() );
    if (sizeof(_Tp) == 4) {
      str.str(string());
      str << "val in hexa: " << showbase << hex << *((const unsigned int*)&val);
      str << ", infinity in hexa: " << showbase << hex << *((const unsigned int*)&infinity);
    }
#if defined (_STLP_LONG_LONG)
    else if (sizeof(_Tp) == sizeof(_STLP_LONG_LONG)) {
      str.str(string());
      str << "val in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&val);
      str << ", infinity in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&infinity);
    }
#endif
    else {
      str.str(string());
      str << "val: ";
      for (int i = 0; i != sizeof(_Tp) /  sizeof(unsigned short); ++i) {
        if (i != 0) str << ' ';
        str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&val + i);
      }
      str << ", infinity: ";
      for (int i = 0; i != sizeof(_Tp) /  sizeof(unsigned short); ++i) {
        if (i != 0) str << ' ';
        str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&infinity + i);
      }
    }
    CPPUNIT_MESSAGE( str.str().c_str() );
    str.str(string());
    str << dec;
    str << "lim::digits = " << lim::digits << ", lim::digits10 = " << lim::digits10 << endl;
    str << "lim::min_exponent = " << lim::min_exponent << ", lim::min_exponent10 = " << lim::min_exponent10 << endl;
    str << "lim::max_exponent = " << lim::max_exponent << ", lim::max_exponent10 = " << lim::max_exponent10 << endl;
    CPPUNIT_MESSAGE( str.str().c_str() );
    */
 
    CHECK_COND(infinity == infinity);
    CHECK_COND(infinity > lim::max());
    CHECK_COND(-infinity < -lim::max());
  }
 
  return true;
}

Referenced by LimitTest::test().

test_float_values()

template<class _Tp >

bool test_float_values	(	_Tp	lhs,
		_Tp	rhs
	)

Definition at line 120 of file limits_test.cpp.

{ return lhs == rhs; }

Referenced by test_float_limits().

test_integral_limits()

template<class _Tp >

bool test_integral_limits	(	const _Tp &	val,
		bool	unknown_sign = true,
		bool	is_signed = true
	)

Definition at line 88 of file limits_test.cpp.

                                                                                           {
  if (!test_integral_limits_base(val, unknown_sign, is_signed))
    return false;
 
  typedef numeric_limits<_Tp> lim;
 
  CHECK_COND(lim::is_modulo);
 
  if (lim::is_bounded ||
     (!lim::is_bounded && !lim::is_signed)) {
    _Tp tmp = lim::min();
    CHECK_COND( --tmp > lim::min() );
  }
 
  if (lim::is_bounded) {
    _Tp tmp = lim::max();
    CHECK_COND( ++tmp < lim::max() );
  }
 
  return true;
}

Referenced by LimitTest::test(), test_signed_integral_limits(), and test_unsigned_integral_limits().

test_integral_limits_base()

template<class _Tp >

bool test_integral_limits_base	(	const _Tp &	,
		bool	unknown_sign = true,
		bool	is_signed = true
	)

Definition at line 70 of file limits_test.cpp.

                                                                                             {
  typedef numeric_limits<_Tp> lim;
 
  CHECK_COND(lim::is_specialized);
  CHECK_COND(lim::is_exact);
  CHECK_COND(lim::is_integer);
  CHECK_COND(!lim::is_iec559);
  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;
}

Referenced by LimitTest::test(), and test_integral_limits().

test_qnan()

template<class _Tp >

bool test_qnan

(

const _Tp &

)

Definition at line 233 of file limits_test.cpp.

                            {
  typedef numeric_limits<_Tp> lim;
  if (lim::has_quiet_NaN) {
    const _Tp qnan = lim::quiet_NaN();
 
    //if (sizeof(_Tp) == 4) {
    //  ostringstream str;
    //  str << "qnan " << qnan << ", in hexa: " << showbase << hex << *((unsigned int*)&qnan);
    //  CPPUNIT_MESSAGE( str.str().c_str() );
    //  str.str("");
    //  float val = generate_nan(0.0f);
    //  str << "val " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
    //  CPPUNIT_MESSAGE( str.str().c_str() );
    //  str.str("");
    //  val = -qnan;
    //  str << "-qnan " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
    //  CPPUNIT_MESSAGE( str.str().c_str() );
    //}
    /* 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;
}

Referenced by LimitTest::qnan_test().

test_signed_integral_limits()

template<class _Tp >

bool test_signed_integral_limits

(

const _Tp &

__val

)

Definition at line 111 of file limits_test.cpp.

                                                   {
  return test_integral_limits(__val, false, true);
}

Referenced by LimitTest::test().

test_unsigned_integral_limits()

template<class _Tp >

bool test_unsigned_integral_limits

(

const _Tp &

__val

)

Definition at line 115 of file limits_test.cpp.

                                                     {
  return test_integral_limits(__val, false, false);
}

Referenced by LimitTest::test().

valid_sign_info() [1/2]

template<class _Tp >

bool valid_sign_info	(	bool	limit_is_signed,
		const _Tp &
	)

Definition at line 64 of file limits_test.cpp.

                                                        {
  return (limit_is_signed && _Tp(-1) < 0) ||
         (!limit_is_signed && _Tp(-1) > 0);
}

valid_sign_info() [2/2]

bool valid_sign_info	(	bool	,
		bool
	)

Definition at line 60 of file limits_test.cpp.

{ return true; }

Referenced by test_integral_limits_base().