diff -r e20de85af2ee -r ce057bb09d0b genericopenlibs/cppstdlib/stl/test/unit/limits_test.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/genericopenlibs/cppstdlib/stl/test/unit/limits_test.cpp	Fri Jun 04 16:20:51 2010 +0100
@@ -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
+		}
+	}