Home | History | Annotate | Download | only in unit
      1 /* boost limits_test.cpp   test your <limits> file for important
      2  *
      3  * Copyright Jens Maurer 2000
      4  * Permission to use, copy, modify, sell, and distribute this software
      5  * is hereby granted without fee provided that the above copyright notice
      6  * appears in all copies and that both that copyright notice and this
      7  * permission notice appear in supporting documentation,
      8  *
      9  * Jens Maurer makes no representations about the suitability of this
     10  * software for any purpose. It is provided "as is" without express or
     11  * implied warranty.
     12  *
     13  */
     14 
     15 #include <limits>
     16 //#include <sstream>
     17 
     18 #include "cppunit/cppunit_proxy.h"
     19 
     20 #if !defined (STLPORT) || defined(_STLP_USE_NAMESPACES)
     21 using namespace std;
     22 #endif
     23 
     24 //
     25 // TestCase class
     26 //
     27 class LimitTest : public CPPUNIT_NS::TestCase
     28 {
     29   CPPUNIT_TEST_SUITE(LimitTest);
     30 #  if defined (__BORLANDC__)
     31   /* Ignore FPU exceptions, set FPU precision to 64 bits */
     32   unsigned int _float_control_word = _control87(0, 0);
     33   _control87(PC_64|MCW_EM|IC_AFFINE, MCW_PC|MCW_EM|MCW_IC);
     34 #  endif
     35   CPPUNIT_TEST(test);
     36   CPPUNIT_TEST(qnan_test);
     37 #  if defined (__BORLANDC__)
     38   /* Reset floating point control word */
     39   _clear87();
     40   _control87(_float_control_word, MCW_PC|MCW_EM|MCW_IC);
     41 #  endif
     42   CPPUNIT_TEST_SUITE_END();
     43 
     44 protected:
     45   void test();
     46   void qnan_test();
     47 };
     48 
     49 CPPUNIT_TEST_SUITE_REGISTRATION(LimitTest);
     50 
     51 #if defined (STLPORT) && defined (_STLP_STATIC_CONST_INIT_BUG)
     52 #  define CHECK_COND(X) if (!(X))  { CPPUNIT_MESSAGE(#X); return false; }
     53 #else
     54 //This version force to have external linkage on static constant which might
     55 //reveal that _STLP_NO_STATIC_CONST_DEFINITION should be commented.
     56 bool check_cond(const bool& cond) { return cond; }
     57 #  define CHECK_COND(X) if (!check_cond(X)) { CPPUNIT_MESSAGE(#X); return false; }
     58 #endif
     59 
     60 bool valid_sign_info(bool, bool)
     61 { return true; }
     62 
     63 template <class _Tp>
     64 bool valid_sign_info(bool limit_is_signed, const _Tp &) {
     65   return (limit_is_signed && _Tp(-1) < 0) ||
     66          (!limit_is_signed && _Tp(-1) > 0);
     67 }
     68 
     69 template <class _Tp>
     70 bool test_integral_limits_base(const _Tp &, bool unknown_sign = true, bool is_signed = true) {
     71   typedef numeric_limits<_Tp> lim;
     72 
     73   CHECK_COND(lim::is_specialized);
     74   CHECK_COND(lim::is_exact);
     75   CHECK_COND(lim::is_integer);
     76   CHECK_COND(!lim::is_iec559);
     77   CHECK_COND(lim::min() < lim::max());
     78   CHECK_COND((unknown_sign && ((lim::is_signed && (lim::min() != 0)) || (!lim::is_signed && (lim::min() == 0)))) ||
     79              (!unknown_sign && ((lim::is_signed && is_signed) || (!lim::is_signed && !is_signed))));
     80 
     81   if (unknown_sign) {
     82     CHECK_COND(valid_sign_info(lim::is_signed, _Tp()));
     83   }
     84   return true;
     85 }
     86 
     87 template <class _Tp>
     88 bool test_integral_limits(const _Tp &val, bool unknown_sign = true, bool is_signed = true) {
     89   if (!test_integral_limits_base(val, unknown_sign, is_signed))
     90     return false;
     91 
     92   typedef numeric_limits<_Tp> lim;
     93 
     94   CHECK_COND(lim::is_modulo);
     95 
     96   if (lim::is_bounded ||
     97      (!lim::is_bounded && !lim::is_signed)) {
     98     _Tp tmp = lim::min();
     99     CHECK_COND( --tmp > lim::min() );
    100   }
    101 
    102   if (lim::is_bounded) {
    103     _Tp tmp = lim::max();
    104     CHECK_COND( ++tmp < lim::max() );
    105   }
    106 
    107   return true;
    108 }
    109 
    110 template <class _Tp>
    111 bool test_signed_integral_limits(const _Tp &__val) {
    112   return test_integral_limits(__val, false, true);
    113 }
    114 template <class _Tp>
    115 bool test_unsigned_integral_limits(const _Tp &__val) {
    116   return test_integral_limits(__val, false, false);
    117 }
    118 
    119 template <class _Tp>
    120 bool test_float_values(_Tp lhs, _Tp rhs)
    121 { return lhs == rhs; }
    122 
    123 template <class _Tp>
    124 bool test_float_limits(const _Tp &) {
    125   typedef numeric_limits<_Tp> lim;
    126   CHECK_COND(lim::is_specialized);
    127   CHECK_COND(!lim::is_modulo);
    128   CHECK_COND(!lim::is_integer);
    129   CHECK_COND(lim::is_signed);
    130 
    131   CHECK_COND(lim::max() > 1000);
    132   CHECK_COND(lim::min() > 0);
    133   CHECK_COND(lim::min() < 0.001);
    134   CHECK_COND(lim::epsilon() > 0);
    135 
    136   if (lim::is_iec559) {
    137     CHECK_COND(lim::has_infinity);
    138     CHECK_COND(lim::has_quiet_NaN);
    139     CHECK_COND(lim::has_signaling_NaN);
    140     CHECK_COND(lim::has_denorm == denorm_present);
    141   }
    142 
    143   if (lim::has_denorm == denorm_absent) {
    144     CHECK_COND(lim::denorm_min() == lim::min());
    145     _Tp tmp = lim::min();
    146     tmp /= 2;
    147     if (tmp > 0 && tmp < lim::min()) {
    148       // has_denorm could be denorm_present
    149       CPPUNIT_MESSAGE("It looks like your compiler/platform supports denormalized floating point representation.");
    150     }
    151   }
    152   else if (lim::has_denorm == denorm_present) {
    153     CHECK_COND(lim::denorm_min() > 0);
    154     CHECK_COND(lim::denorm_min() < lim::min());
    155 
    156     _Tp tmp = lim::min();
    157     while (tmp != 0) {
    158       _Tp old_tmp = tmp;
    159       tmp /= 2;
    160       CHECK_COND(tmp < old_tmp);
    161       CHECK_COND(tmp >= lim::denorm_min() || tmp == (_Tp)0);
    162       //ostringstream str;
    163       //str << "denorm_min = " << lim::denorm_min() << ", tmp = " << tmp;
    164       //CPPUNIT_MESSAGE(str.str().c_str());
    165     }
    166   }
    167 
    168   if (lim::has_infinity) {
    169     const _Tp infinity = lim::infinity();
    170     /* Make sure those values are not 0 or similar nonsense.
    171      * Infinity must compare as if larger than the maximum representable value. */
    172 
    173     _Tp val = lim::max();
    174     val *= 2;
    175 
    176     /* We use test_float_values because without it some compilers (gcc) perform weird
    177      * optimization on the test giving unexpected result. */
    178     CHECK_COND(test_float_values(val, infinity));
    179 
    180     /*
    181     ostringstream str;
    182     str << "lim::max() = " << lim::max() << ", val = " << val << ", infinity = " << infinity;
    183     CPPUNIT_MESSAGE( str.str().c_str() );
    184     str.str(string());
    185     str << "sizeof(_Tp) = " << sizeof(_Tp);
    186     CPPUNIT_MESSAGE( str.str().c_str() );
    187     if (sizeof(_Tp) == 4) {
    188       str.str(string());
    189       str << "val in hexa: " << showbase << hex << *((const unsigned int*)&val);
    190       str << ", infinity in hexa: " << showbase << hex << *((const unsigned int*)&infinity);
    191     }
    192 #if defined (_STLP_LONG_LONG)
    193     else if (sizeof(_Tp) == sizeof(_STLP_LONG_LONG)) {
    194       str.str(string());
    195       str << "val in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&val);
    196       str << ", infinity in hexa: " << showbase << hex << *((const unsigned _STLP_LONG_LONG*)&infinity);
    197     }
    198 #endif
    199     else {
    200       str.str(string());
    201       str << "val: ";
    202       for (int i = 0; i != sizeof(_Tp) /  sizeof(unsigned short); ++i) {
    203         if (i != 0) str << ' ';
    204         str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&val + i);
    205       }
    206       str << ", infinity: ";
    207       for (int i = 0; i != sizeof(_Tp) /  sizeof(unsigned short); ++i) {
    208         if (i != 0) str << ' ';
    209         str << showbase << hex << setw(4) << setfill('0') << *((const unsigned short*)&infinity + i);
    210       }
    211     }
    212     CPPUNIT_MESSAGE( str.str().c_str() );
    213     str.str(string());
    214     str << dec;
    215     str << "lim::digits = " << lim::digits << ", lim::digits10 = " << lim::digits10 << endl;
    216     str << "lim::min_exponent = " << lim::min_exponent << ", lim::min_exponent10 = " << lim::min_exponent10 << endl;
    217     str << "lim::max_exponent = " << lim::max_exponent << ", lim::max_exponent10 = " << lim::max_exponent10 << endl;
    218     CPPUNIT_MESSAGE( str.str().c_str() );
    219     */
    220 
    221     CHECK_COND(infinity == infinity);
    222     CHECK_COND(infinity > lim::max());
    223     CHECK_COND(-infinity < -lim::max());
    224   }
    225 
    226   return true;
    227 }
    228 
    229 //float generate_nan(float f) {
    230 //  return 0.0f / f;
    231 //}
    232 template <class _Tp>
    233 bool test_qnan(const _Tp &) {
    234   typedef numeric_limits<_Tp> lim;
    235   if (lim::has_quiet_NaN) {
    236     const _Tp qnan = lim::quiet_NaN();
    237 
    238     //if (sizeof(_Tp) == 4) {
    239     //  ostringstream str;
    240     //  str << "qnan " << qnan << ", in hexa: " << showbase << hex << *((unsigned int*)&qnan);
    241     //  CPPUNIT_MESSAGE( str.str().c_str() );
    242     //  str.str("");
    243     //  float val = generate_nan(0.0f);
    244     //  str << "val " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
    245     //  CPPUNIT_MESSAGE( str.str().c_str() );
    246     //  str.str("");
    247     //  val = -qnan;
    248     //  str << "-qnan " << val << ", in hexa: " << showbase << hex << *((unsigned int*)&val);
    249     //  CPPUNIT_MESSAGE( str.str().c_str() );
    250     //}
    251     /* NaNs shall always compare "false" when compared for equality
    252     * If one of these fail, your compiler may be optimizing incorrectly,
    253     * or the STLport is incorrectly configured.
    254     */
    255     CHECK_COND(! (qnan == 42));
    256     CHECK_COND(! (qnan == qnan));
    257     CHECK_COND(qnan != 42);
    258     CHECK_COND(qnan != qnan);
    259 
    260     /* The following tests may cause arithmetic traps.
    261     * CHECK_COND(! (qnan < 42));
    262     * CHECK_COND(! (qnan > 42));
    263     * CHECK_COND(! (qnan <= 42));
    264     * CHECK_COND(! (qnan >= 42));
    265     */
    266   }
    267   return true;
    268 }
    269 
    270 
    271 class ArbitraryType
    272 {};
    273 
    274 void LimitTest::test() {
    275   CPPUNIT_CHECK(test_integral_limits_base(bool()));
    276   CPPUNIT_CHECK(test_integral_limits(char()));
    277   typedef signed char signed_char;
    278   CPPUNIT_CHECK(test_signed_integral_limits(signed_char()));
    279   typedef unsigned char unsigned_char;
    280   CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_char()));
    281 #  if (defined (_STLP_HAS_WCHAR_T) && !defined (_STLP_WCHAR_T_IS_USHORT)) && WCHAR_MIN != 0 && !defined(__arm__)
    282  /* wchar_t is unsigned in arm */
    283   CPPUNIT_CHECK(test_integral_limits(wchar_t()));
    284 #  endif
    285   CPPUNIT_CHECK(test_signed_integral_limits(short()));
    286   typedef unsigned short unsigned_short;
    287   CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_short()));
    288   CPPUNIT_CHECK(test_signed_integral_limits(int()));
    289   typedef unsigned int unsigned_int;
    290   CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_int()));
    291   CPPUNIT_CHECK(test_signed_integral_limits(long()));
    292   typedef unsigned long unsigned_long;
    293   CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_long()));
    294 #  if defined (_STLP_LONG_LONG)
    295   typedef _STLP_LONG_LONG long_long;
    296   CPPUNIT_CHECK(test_signed_integral_limits(long_long()));
    297   typedef unsigned _STLP_LONG_LONG unsigned_long_long;
    298   CPPUNIT_CHECK(test_unsigned_integral_limits(unsigned_long_long()));
    299 #endif
    300 
    301   CPPUNIT_CHECK(test_float_limits(float()));
    302   CPPUNIT_CHECK(test_float_limits(double()));
    303 #  if !defined ( _STLP_NO_LONG_DOUBLE )
    304   typedef long double long_double;
    305   CPPUNIT_CHECK(test_float_limits(long_double()));
    306 #  endif
    307 
    308   CPPUNIT_ASSERT( !numeric_limits<ArbitraryType>::is_specialized );
    309 }
    310 
    311 void LimitTest::qnan_test() {
    312   CPPUNIT_CHECK(test_qnan(float()));
    313   CPPUNIT_CHECK(test_qnan(double()));
    314 #  if !defined ( _STLP_NO_LONG_DOUBLE )
    315   typedef long double long_double;
    316   CPPUNIT_CHECK(test_qnan(long_double()));
    317 #  endif
    318 }
    319