ceph/src/boost/libs/multiprecision/test/constexpr_test_cpp_int_3.cpp

   1 //  (C) Copyright John Maddock 2019.
   2 //  Use, modification and distribution are subject to the
   3 //  Boost Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
   5
   6 #include "constexpr_arithmetric_test.hpp"
   7 #include "boost/multiprecision/cpp_int.hpp"
   8 #include "test.hpp"
   9
  10 #if !defined(BOOST_MP_NO_CONSTEXPR_DETECTION) && !defined(DISABLE_TESTS)
  11
  12 template <class F, class V>
  13 decltype(std::declval<F>()(std::declval<V>())) non_constexpr_invoke(F f, V v)
  14 {
  15    return f(v);
  16 }
  17
  18 int main()
  19 {
  20    typedef boost::multiprecision::checked_int256_t  int_backend;
  21    typedef boost::multiprecision::checked_uint256_t unsigned_backend;
  22
  23    {
  24       constexpr int_backend a(22);
  25       constexpr unsigned_backend c(22);
  26       constexpr int_backend b      = test_constexpr_add_subtract(a);
  27       constexpr unsigned_backend d = test_constexpr_add_subtract(c);
  28
  29       constexpr long long llv = (long long)b;
  30
  31       static_assert(b == -108);
  32       static_assert(d == 554);
  33
  34       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_add_subtract<int_backend>, a));
  35       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_add_subtract<unsigned_backend>, c));
  36    }
  37    {
  38       constexpr int_backend a(22);
  39       constexpr unsigned_backend c(22);
  40       constexpr int_backend b      = test_constexpr_mul_divide(a);
  41       constexpr unsigned_backend d = test_constexpr_mul_divide(c);
  42       static_assert(b == 22);
  43       static_assert(d == 22);
  44
  45       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_mul_divide<int_backend>, a));
  46       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_mul_divide<unsigned_backend>, c));
  47    }
  48    {
  49       constexpr int_backend a(22);
  50       constexpr unsigned_backend c(22);
  51       constexpr int_backend b      = test_constexpr_bitwise(a);
  52       constexpr unsigned_backend d = test_constexpr_bitwise(c);
  53 #ifdef BOOST_HAS_INT128
  54       static_assert(b == 230);
  55       static_assert(d == 120);
  56 #else
  57       static_assert(b == 210);
  58       static_assert(d == 106);
  59 #endif
  60
  61       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_bitwise<int_backend>, a));
  62       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_bitwise<unsigned_backend>, c));
  63    }
  64    {
  65       constexpr int_backend a(22);
  66       constexpr unsigned_backend c(22);
  67       constexpr int_backend b = test_constexpr_logical(a);
  68       constexpr unsigned_backend d = test_constexpr_logical(c);
  69 #ifdef BOOST_HAS_INT128
  70       //static_assert(b == 95);
  71       //static_assert(d == 95);
  72 #else
  73       static_assert(b == 82);
  74       static_assert(d == 82);
  75 #endif
  76       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_logical<int_backend>, a));
  77       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_logical<unsigned_backend>, c));
  78    }
  79    {
  80       constexpr int_backend a(22);
  81       constexpr unsigned_backend c(22);
  82       constexpr int_backend b      = test_constexpr_compare(a);
  83       constexpr unsigned_backend d = test_constexpr_compare(c);
  84 #ifdef BOOST_HAS_INT128
  85       static_assert(b == 95);
  86       static_assert(d == 95);
  87 #else
  88       static_assert(b == 95);
  89       static_assert(d == 95);
  90 #endif
  91       BOOST_CHECK_EQUAL(b, non_constexpr_invoke(test_constexpr_compare<int_backend>, a));
  92       BOOST_CHECK_EQUAL(d, non_constexpr_invoke(test_constexpr_compare<unsigned_backend>, c));
  93    }
  94    return boost::report_errors();
  95 }
  96 #else
  97 int main(){}
  98 #endif
  99