Ticket #8272: test_multiprecision.patch

boost/test/tools/floating_point_comparison.hpp

@@ -18 +18 @@
 // Boost.Test
 #include <boost/test/detail/global_typedef.hpp>
 #include <boost/test/tools/assertion_result.hpp>
-
+#include <boost/type_traits/is_convertible.hpp>
 // Boost
 #include <boost/limits.hpp>  // for std::numeric_limits
 #include <boost/numeric/conversion/conversion_traits.hpp> // for numeric::conversion_traits
 #include <boost/static_assert.hpp>
 #include <boost/assert.hpp>
+#include <boost/mpl/if.hpp>
 
 // STL
 #include <iosfwd>
@@ -173 +174 @@
     // if one type is floating and the second integral we use floating type and 
     // value of integral type is promoted to the floating. The same for float and double
     // But we don't want to compare two values of integral types using this tool.
-    typedef typename numeric::conversion_traits<FPT1,FPT2>::supertype type;
+    typedef typename mpl::if_c<
+       is_convertible<FPT1, FPT2>::value && !is_convertible<FPT2, FPT1>::value,
+       FPT2,
+       typename mpl::if_c<
+          !is_convertible<FPT1, FPT2>::value && is_convertible<FPT2, FPT1>::value,
+          FPT1,
+          typename numeric::conversion_traits<FPT1,FPT2>::supertype
+       >::type
+    >::type type;
     BOOST_STATIC_ASSERT( !is_integral<type>::value );
 };
 
@@ -204 +213 @@
     // Action method
     bool                operator()( FPT left, FPT right ) const
     {
-        FPT diff              = fpc_detail::fpt_abs( left - right );
+        FPT diff              = fpc_detail::fpt_abs( static_cast<FPT>(left - right) );
         FPT fraction_of_right = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( right ) );
         FPT fraction_of_left  = fpc_detail::safe_fpt_division( diff, fpc_detail::fpt_abs( left ) );
         

boost/test/tools/old/impl.hpp

@@ -323 +323 @@
     {
         return fpc::is_small( fpv, tolerance );
     }
+    template<typename FPT1, class FPT2>
+    bool
+    operator()( FPT1 fpv, FPT2 tolerance ) const
+    {
+        typedef typename fpc::comp_supertype<FPT1, FPT2>::type common_type;
+        return fpc::is_small( static_cast<common_type>(fpv), static_cast<common_type>(tolerance));
+    }
 };
 
 //____________________________________________________________________________//

libs/test/test/Jamfile.v2

@@ -91 +91 @@
           [ test-btl-lib run : test_datasets_cxx11          : boost_unit_test_framework : : [ glob test_datasets_src/*.cpp ] : : <toolset>gcc:<cxxflags>-std=gnu++0x ]
           # [ test-btl-lib run : config_file_iterator_test    : boost_unit_test_framework/<link>static ]
           # [ test-btl-lib run : config_file_test             : boost_unit_test_framework/<link>static ]
+          [ test-btl-lib run : test_expression_template_fpt   : boost_unit_test_framework ]
         ;
 
 test-suite "multithreaded_test"
@@ -103 +104 @@
   
 # Only run tests when explicitly requested 
 # explicit test basics_test prg_exec_monitor_test unit_test_framework_test ;
+

libs/test/test/test_expression_template_fpt.cpp

@@ +1 @@
+///////////////////////////////////////////////////////////////////////////////
+//  Copyright 2013 John Maddock. 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)
+
+
+#include <boost/multiprecision/cpp_dec_float.hpp>
+#define BOOST_TEST_MODULE multiprecision
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE(multiprecision)
+{
+   using namespace boost::multiprecision;
+
+   cpp_dec_float_50 a(0), b(0), c(1);
+   cpp_dec_float_50 eps = std::numeric_limits<cpp_dec_float_50>::epsilon();
+
+   BOOST_CHECK_EQUAL(a, b);
+   BOOST_CHECK_NE(a, c);
+   BOOST_CHECK_LE(a, b);
+   BOOST_CHECK_GE(a, b);
+   BOOST_CHECK_GT(c, a);
+   BOOST_CHECK_LT(a, c);
+
+   BOOST_CHECK_SMALL(a, eps);
+   BOOST_CHECK_SMALL(eps/2, eps);
+
+   b = c + 10 * eps;
+
+   BOOST_CHECK_CLOSE_FRACTION(b, c, eps * 20);
+   BOOST_CHECK_CLOSE(b, c, eps * 20 * 100);
+
+   BOOST_CHECK_CLOSE_FRACTION(1 * b, c, eps * 20);
+   BOOST_CHECK_CLOSE(1 * b, c, eps * 20 * 100);
+}
+