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

   1 ///////////////////////////////////////////////////////////////
   2 //  Copyright 2020 John Maddock. Distributed under the Boost
   3 //  Software License, Version 1.0. (See accompanying file
   4 //  LICENSE_1_0.txt or copy at https://www.boost.org/LICENSE_1_0.txt
   5
   6 //
   7 // Compare arithmetic results using fixed_int to GMP results.
   8 //
   9
  10 #ifdef _MSC_VER
  11 #define _SCL_SECURE_NO_WARNINGS
  12 #endif
  13
  14 #include <boost/multiprecision/cpp_int.hpp>
  15 #include "test.hpp"
  16
  17 #ifdef __clang__
  18 #if __has_feature(address_sanitizer) || __has_feature(memory_sanitizer)
  19 // memory sanitizer is incompatible with this test:
  20 # define DISABLE_THIS_TEST
  21 #endif
  22 #endif
  23 #ifdef BOOST_CI_ASAN_BUILD
  24 #define DISABLE_THIS_TEST
  25 #endif
  26
  27 #ifndef DISABLE_THIS_TEST
  28
  29 unsigned alloc_count = 0;
  30 void* operator new(std::size_t count)
  31 {
  32    ++alloc_count;
  33    return std::malloc(count);
  34 }
  35 void* operator new[](std::size_t count)
  36 {
  37    ++alloc_count;
  38    return std::malloc(count);
  39 }
  40 void operator delete(void * p)noexcept
  41 {
  42    return std::free(p);
  43 }
  44 void operator delete[](void* p)noexcept
  45 {
  46    return std::free(p);
  47 }
  48
  49
  50 template <class From, class To>
  51 void test_one(From val)
  52 {
  53    From copy(val);
  54    To   target(val);
  55    alloc_count = 0;
  56    To   moved(std::move(copy));
  57    BOOST_CHECK_EQUAL(alloc_count, 0);
  58    BOOST_CHECK_EQUAL(moved, target);
  59    copy = val;
  60    moved = 0;
  61    BOOST_CHECK_EQUAL(copy, val);
  62    BOOST_CHECK_EQUAL(moved, 0);
  63    alloc_count = 0;
  64    moved = std::move(copy);
  65    BOOST_CHECK_EQUAL(alloc_count, 0);
  66    BOOST_CHECK_EQUAL(moved, target);
  67 }
  68
  69 template <class From, class To>
  70 void test()
  71 {
  72    From val(10);
  73    From limit = pow(From(2), 1000);
  74
  75    while (val < limit)
  76    {
  77       test_one<From, To>(val);
  78       test_one<From, To>(-val);
  79       val *= 100;
  80       val /= 3;
  81    }
  82 }
  83
  84 template <class From, class To>
  85 void test_operations()
  86 {
  87    From a = From(1) << 150;
  88    From b = From(1) << 149;
  89    {
  90       alloc_count = 0;
  91       To c        = a * b;
  92       BOOST_CHECK_EQUAL(alloc_count, 0);
  93       BOOST_CHECK_EQUAL(c, a * b);
  94    }
  95    {
  96       alloc_count = 0;
  97       To c;
  98       multiply(c, a, b);
  99       BOOST_CHECK_EQUAL(alloc_count, 0);
 100       BOOST_CHECK_EQUAL(c, a * b);
 101    }
 102    {
 103       alloc_count = 0;
 104       To c        = a + b;
 105       BOOST_CHECK_EQUAL(alloc_count, 0);
 106       BOOST_CHECK_EQUAL(c, a + b);
 107    }
 108    {
 109       alloc_count = 0;
 110       To c;
 111       add(c, a, b);
 112       BOOST_CHECK_EQUAL(alloc_count, 0);
 113       BOOST_CHECK_EQUAL(c, a + b);
 114    }
 115    {
 116       alloc_count = 0;
 117       To c        = -a;
 118       BOOST_CHECK_EQUAL(alloc_count, 0);
 119       BOOST_CHECK_EQUAL(c, -a);
 120    }
 121    {
 122       alloc_count = 0;
 123       To c        = a - b;
 124       BOOST_CHECK_EQUAL(alloc_count, 0);
 125       BOOST_CHECK_EQUAL(c, a - b);
 126    }
 127    {
 128       alloc_count = 0;
 129       To c;
 130       subtract(c, a, b);
 131       BOOST_CHECK_EQUAL(alloc_count, 0);
 132       BOOST_CHECK_EQUAL(c, a - b);
 133    }
 134    {
 135       alloc_count = 0;
 136       To c        = a / b;
 137       BOOST_CHECK_EQUAL(alloc_count, 0);
 138       BOOST_CHECK_EQUAL(c, a / b);
 139    }
 140    {
 141       alloc_count = 0;
 142       To c        = a % b;
 143       BOOST_CHECK_EQUAL(alloc_count, 0);
 144       BOOST_CHECK_EQUAL(c, a % b);
 145    }
 146    {
 147       alloc_count = 0;
 148       To c        = a << 1;
 149       BOOST_CHECK_EQUAL(alloc_count, 0);
 150       BOOST_CHECK_EQUAL(c, a << 1);
 151    }
 152    {
 153       alloc_count = 0;
 154       To c        = a >> 1;
 155       BOOST_CHECK_EQUAL(alloc_count, 0);
 156       BOOST_CHECK_EQUAL(c, a >> 1);
 157    }
 158    {
 159       alloc_count = 0;
 160       To c        = a | b;
 161       BOOST_CHECK_EQUAL(alloc_count, 0);
 162       BOOST_CHECK_EQUAL(c, a | b);
 163    }
 164    {
 165       alloc_count = 0;
 166       To c        = a & b;
 167       BOOST_CHECK_EQUAL(alloc_count, 0);
 168       BOOST_CHECK_EQUAL(c, a & b);
 169    }
 170    {
 171       alloc_count = 0;
 172       To c        = a ^ b;
 173       BOOST_CHECK_EQUAL(alloc_count, 0);
 174       BOOST_CHECK_EQUAL(c, a ^ b);
 175    }
 176    {
 177       alloc_count = 0;
 178       To c        = gcd(a, b);
 179       BOOST_CHECK_EQUAL(c, gcd(a, b));
 180    }
 181    {
 182       alloc_count = 0;
 183       To c        = lcm(a, b);
 184       BOOST_CHECK_EQUAL(c, lcm(a, b));
 185    }
 186    {
 187       alloc_count = 0;
 188       To c        = pow(a, 2);
 189       BOOST_CHECK_EQUAL(c, pow(a, 2));
 190    }
 191    {
 192       alloc_count = 0;
 193       To c        = powm(a, b, 2);
 194       BOOST_CHECK_EQUAL(c, powm(a, b, 2));
 195    }
 196    {
 197       alloc_count = 0;
 198       To c        = sqrt(a);
 199       BOOST_CHECK_EQUAL(c, sqrt(a));
 200    }
 201 }
 202
 203 int main()
 204 {
 205    using namespace boost::multiprecision;
 206    //
 207    // Our "From" type has the MinBits argument as small as possible,
 208    // should it be larger than the default used in cpp_int then we
 209    // may get allocations causing the tests above to fail since the
 210    // internal cache in type From is larger than that of cpp_int and so
 211    // allocation may be needed even on a move.
 212    //
 213    test<number<cpp_int_backend<sizeof(limb_type) * CHAR_BIT * 2> >, cpp_int>();
 214
 215    typedef boost::multiprecision::number<boost::multiprecision::cpp_int_backend<512> > To;
 216    test_operations<cpp_int, To>();
 217
 218    return boost::report_errors();
 219 }
 220
 221 #else
 222 int main(){ return 0; }
 223 #endif