Separate test for round-tripping of floating point types.

[SVN r35771]

lexical_cast_test.cpp

@@ -67,9 +67,6 @@ void test_conversion_from_ulong();
 void test_conversion_from_longlong();
 void test_conversion_from_ulonglong();
 #endif
-void test_round_conversion_float();
-void test_round_conversion_double();
-void test_round_conversion_long_double();
 
 unit_test::test_suite *init_unit_test_suite(int, char *[])
 {
@@ -100,9 +97,6 @@ unit_test::test_suite *init_unit_test_suite(int, char *[])
     suite->add(BOOST_TEST_CASE(&test_conversion_from_longlong));
     suite->add(BOOST_TEST_CASE(&test_conversion_from_ulonglong));
     #endif
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
-    suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
 
     return suite;
 }
@@ -612,51 +606,3 @@ void test_conversion_from_ulonglong()
 
 #endif
 
-template<class T>
-void test_round_conversion(bool use_min_max_values = true)
-{
-    T v1 = std::numeric_limits<T>::epsilon();
-    std::string s1 = boost::lexical_cast<std::string>(v1);
-    BOOST_CHECK(v1 == lexical_cast<T>(s1));
-
-    if(use_min_max_values)
-    {
-        T v2 = (std::numeric_limits<T>::max)();
-        std::string s2 = boost::lexical_cast<std::string>(v2);
-        BOOST_CHECK(v2 == lexical_cast<T>(s2));
-
-        T v3 = (std::numeric_limits<T>::min)();
-        std::string s3 = boost::lexical_cast<std::string>(v3);
-        BOOST_CHECK(v3 == lexical_cast<T>(s3));
-
-        T v4 = v2 / 137;
-        std::string s4 = boost::lexical_cast<std::string>(v4);
-        BOOST_CHECK(v4 == lexical_cast<T>(s4));
-    }
-
-    T v5 = v1 * 137;
-    std::string s5 = boost::lexical_cast<std::string>(v5);
-    BOOST_CHECK(v5 == lexical_cast<T>(s5));
-}
-
-void test_round_conversion_float()
-{
-    test_round_conversion<float>();
-}
-
-void test_round_conversion_double()
-{
-    test_round_conversion<double>();
-}
-
-void test_round_conversion_long_double()
-{
-#if defined(BOOST_NO_STDLIB_CONFIG)
-    test_round_conversion<long double>();
-#elif defined(__i386__) && defined(__OpenBSD__)
-    test_round_conversion<long double>(false);
-#elif !defined(__i386__) || !defined(__FreeBSD__)
-    test_round_conversion<long double>();
-#endif
-}
-

test/Jamfile

@@ -27,8 +27,9 @@ DEPENDS all : test ;
       : [ run implicit_cast.cpp ]
         [ compile-fail implicit_cast_fail.cpp ]
         [ run ../cast_test.cpp ]
-	[ run ../numeric_cast_test.cpp ]
+        [ run ../numeric_cast_test.cpp ]
         [ run ../lexical_cast_test.cpp <lib>../../test/build/boost_unit_test_framework ]
+        [ run lexical_cast_loopback_test.cpp <lib>../../test/build/boost_unit_test_framework ]
       ;
 }
       

test/Jamfile.v2

@@ -21,6 +21,7 @@ test-suite conversion
     [ run ../cast_test.cpp ]
     [ run ../numeric_cast_test.cpp ]    
     [ run ../lexical_cast_test.cpp ../../test/build//boost_unit_test_framework ]
+    [ run lexical_cast_loopback_test.cpp ../../test/build//boost_unit_test_framework ]
   ;
 
-      
+      

test/lexical_cast_loopback_test.cpp

@@ -0,0 +1,98 @@
+//  Unit test for boost::lexical_cast.
+//
+//  See http://www.boost.org for most recent version, including documentation.
+//
+//  Copyright Alexander Nasonov, 2006.
+//
+//  Distributed under the Boost
+//  Software License, Version 1.0. (See accompanying file
+//  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+//
+//  Test round-tripping conversion FPT -> string -> FPT,
+//  where FPT is Floating Point Type.
+
+#include <boost/config.hpp>
+
+#if defined(__INTEL_COMPILER)
+#pragma warning(disable: 193 383 488 981 1418 1419)
+#elif defined(BOOST_MSVC)
+#pragma warning(disable: 4097 4100 4121 4127 4146 4244 4245 4511 4512 4701 4800)
+#endif
+
+#include <boost/lexical_cast.hpp>
+#include <boost/test/unit_test.hpp>
+
+using namespace boost;
+
+void test_round_conversion_float();
+void test_round_conversion_double();
+void test_round_conversion_long_double();
+
+unit_test::test_suite *init_unit_test_suite(int, char *[])
+{
+    unit_test_framework::test_suite *suite =
+        BOOST_TEST_SUITE("lexical_cast unit test");
+    suite->add(BOOST_TEST_CASE(&test_round_conversion_float));
+    suite->add(BOOST_TEST_CASE(&test_round_conversion_double));
+    suite->add(BOOST_TEST_CASE(&test_round_conversion_long_double));
+
+    return suite;
+}
+
+template<class T>
+void test_round_conversion()
+{
+    T epsilon = std::numeric_limits<T>::epsilon();
+    std::string const epsilon_s = boost::lexical_cast<std::string>(epsilon);
+    BOOST_CHECK(epsilon == lexical_cast<T>(epsilon_s));
+
+    T max_ = (std::numeric_limits<T>::max)();
+    std::string const max_s = boost::lexical_cast<std::string>(max_);
+    BOOST_CHECK(max_ == lexical_cast<T>(max_s));
+
+    T min_ = (std::numeric_limits<T>::min)();
+    std::string const min_s = boost::lexical_cast<std::string>(min_);
+    BOOST_CHECK(min_ == lexical_cast<T>(min_s));
+
+    T max_div137 = max_ / 137;
+    std::string max_div137_s = boost::lexical_cast<std::string>(max_div137);
+    BOOST_CHECK(max_div137 == lexical_cast<T>(max_div137_s));
+
+    T epsilon_mult137 = epsilon * 137;
+    std::string epsilon_mult137_s(lexical_cast<std::string>(epsilon_mult137));
+    BOOST_CHECK(epsilon_mult137 == lexical_cast<T>(epsilon_mult137_s));
+
+}
+
+#if defined(BOOST_MSVC)
+// See bug http://tinyurl.com/vhpvo
+template<class T>
+void test_msvc_magic_values()
+{
+    T magic_msvc = 0.00010000433948393407;
+    std::string magic_msvc_s = boost::lexical_cast<std::string>(magic_msvc);
+    BOOST_CHECK(magic_msvc == lexical_cast<T>(magic_msvc_s));
+}
+#endif
+
+void test_round_conversion_float()
+{
+    test_round_conversion<float>();
+}
+
+void test_round_conversion_double()
+{
+    test_round_conversion<double>();
+#if defined(BOOST_MSVC)
+    test_msvc_magic_values<double>();
+#endif
+}
+
+void test_round_conversion_long_double()
+{
+    test_round_conversion<long double>();
+#if defined(BOOST_MSVC)
+    test_msvc_magic_values<long double>();
+#endif
+}
+