--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/unit/limits_test.cpp Tue Feb 02 02:01:42 2010 +0200
@@ -0,0 +1,199 @@
+//
+// 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
+ }
+ }