//

 // 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

 		}

 	}