Bitcoin Core  22.99.0
P2P Digital Currency
serfloat_tests.cpp
Go to the documentation of this file.
1 // Copyright (c) 2014-2020 The Bitcoin Core developers
2 // Distributed under the MIT software license, see the accompanying
3 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
4 
5 #include <hash.h>
7 #include <util/serfloat.h>
8 #include <serialize.h>
9 #include <streams.h>
10 
11 #include <boost/test/unit_test.hpp>
12 
13 #include <cmath>
14 #include <limits>
15 
17 
18 namespace {
19 
20 uint64_t TestDouble(double f) {
21  uint64_t i = EncodeDouble(f);
22  double f2 = DecodeDouble(i);
23  if (std::isnan(f)) {
24  // NaN is not guaranteed to round-trip exactly.
25  BOOST_CHECK(std::isnan(f2));
26  } else {
27  // Everything else is.
28  BOOST_CHECK(!std::isnan(f2));
29  uint64_t i2 = EncodeDouble(f2);
30  BOOST_CHECK_EQUAL(f, f2);
31  BOOST_CHECK_EQUAL(i, i2);
32  }
33  return i;
34 }
35 
36 } // namespace
37 
38 BOOST_AUTO_TEST_CASE(double_serfloat_tests) {
39  BOOST_CHECK_EQUAL(TestDouble(0.0), 0U);
40  BOOST_CHECK_EQUAL(TestDouble(-0.0), 0x8000000000000000);
41  BOOST_CHECK_EQUAL(TestDouble(std::numeric_limits<double>::infinity()), 0x7ff0000000000000U);
42  BOOST_CHECK_EQUAL(TestDouble(-std::numeric_limits<double>::infinity()), 0xfff0000000000000);
43  BOOST_CHECK_EQUAL(TestDouble(0.5), 0x3fe0000000000000ULL);
44  BOOST_CHECK_EQUAL(TestDouble(1.0), 0x3ff0000000000000ULL);
45  BOOST_CHECK_EQUAL(TestDouble(2.0), 0x4000000000000000ULL);
46  BOOST_CHECK_EQUAL(TestDouble(4.0), 0x4010000000000000ULL);
47  BOOST_CHECK_EQUAL(TestDouble(785.066650390625), 0x4088888880000000ULL);
48 
49  // Roundtrip test on IEC559-compatible systems
50  if (std::numeric_limits<double>::is_iec559) {
51  BOOST_CHECK_EQUAL(sizeof(double), 8U);
52  BOOST_CHECK_EQUAL(sizeof(uint64_t), 8U);
53  // Test extreme values
54  TestDouble(std::numeric_limits<double>::min());
55  TestDouble(-std::numeric_limits<double>::min());
56  TestDouble(std::numeric_limits<double>::max());
57  TestDouble(-std::numeric_limits<double>::max());
58  TestDouble(std::numeric_limits<double>::lowest());
59  TestDouble(-std::numeric_limits<double>::lowest());
60  TestDouble(std::numeric_limits<double>::quiet_NaN());
61  TestDouble(-std::numeric_limits<double>::quiet_NaN());
62  TestDouble(std::numeric_limits<double>::signaling_NaN());
63  TestDouble(-std::numeric_limits<double>::signaling_NaN());
64  TestDouble(std::numeric_limits<double>::denorm_min());
65  TestDouble(-std::numeric_limits<double>::denorm_min());
66  // Test exact encoding: on currently supported platforms, EncodeDouble
67  // should produce exactly the same as the in-memory representation for non-NaN.
68  for (int j = 0; j < 1000; ++j) {
69  // Iterate over 9 specific bits exhaustively; the others are chosen randomly.
70  // These specific bits are the sign bit, and the 2 top and bottom bits of
71  // exponent and mantissa in the IEEE754 binary64 format.
72  for (int x = 0; x < 512; ++x) {
73  uint64_t v = InsecureRandBits(64);
74  v &= ~(uint64_t{1} << 0);
75  if (x & 1) v |= (uint64_t{1} << 0);
76  v &= ~(uint64_t{1} << 1);
77  if (x & 2) v |= (uint64_t{1} << 1);
78  v &= ~(uint64_t{1} << 50);
79  if (x & 4) v |= (uint64_t{1} << 50);
80  v &= ~(uint64_t{1} << 51);
81  if (x & 8) v |= (uint64_t{1} << 51);
82  v &= ~(uint64_t{1} << 52);
83  if (x & 16) v |= (uint64_t{1} << 52);
84  v &= ~(uint64_t{1} << 53);
85  if (x & 32) v |= (uint64_t{1} << 53);
86  v &= ~(uint64_t{1} << 61);
87  if (x & 64) v |= (uint64_t{1} << 61);
88  v &= ~(uint64_t{1} << 62);
89  if (x & 128) v |= (uint64_t{1} << 62);
90  v &= ~(uint64_t{1} << 63);
91  if (x & 256) v |= (uint64_t{1} << 63);
92  double f;
93  memcpy(&f, &v, 8);
94  uint64_t v2 = TestDouble(f);
95  if (!std::isnan(f)) BOOST_CHECK_EQUAL(v, v2);
96  }
97  }
98  }
99 }
100 
101 /*
102 Python code to generate the below hashes:
103 
104  def reversed_hex(x):
105  return bytes(reversed(x)).hex()
106 
107  def dsha256(x):
108  return hashlib.sha256(hashlib.sha256(x).digest()).digest()
109 
110  reversed_hex(dsha256(b''.join(struct.pack('<d', x) for x in range(0,1000)))) == '43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96'
111 */
113 {
114  CDataStream ss(SER_DISK, 0);
115  // encode
116  for (int i = 0; i < 1000; i++) {
117  ss << EncodeDouble(i);
118  }
119  BOOST_CHECK(Hash(ss) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
120 
121  // decode
122  for (int i = 0; i < 1000; i++) {
123  uint64_t val;
124  ss >> val;
125  double j = DecodeDouble(val);
126  BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
127  }
128 }
129 
SER_DISK
@ SER_DISK
Definition: serialize.h:139
BOOST_AUTO_TEST_CASE
BOOST_AUTO_TEST_CASE(double_serfloat_tests)
Definition: serfloat_tests.cpp:38
streams.h
setup_common.h
serfloat.h
BOOST_FIXTURE_TEST_SUITE
#define BOOST_FIXTURE_TEST_SUITE(a, b)
Definition: object.cpp:14
BOOST_AUTO_TEST_SUITE_END
BOOST_AUTO_TEST_SUITE_END()
Hash
uint256 Hash(const T &in1)
Compute the 256-bit hash of an object.
Definition: hash.h:75
BasicTestingSetup
Basic testing setup.
Definition: setup_common.h:76
uint256S
uint256 uint256S(const char *str)
Definition: uint256.h:137
DecodeDouble
double DecodeDouble(uint64_t v) noexcept
Definition: serfloat.cpp:10
serialize.h
CDataStream
Double ended buffer combining vector and stream-like interfaces.
Definition: streams.h:204
InsecureRandBits
static uint64_t InsecureRandBits(int bits)
Definition: setup_common.h:67
BOOST_CHECK
#define BOOST_CHECK(expr)
Definition: object.cpp:17
BOOST_CHECK_EQUAL
#define BOOST_CHECK_EQUAL(v1, v2)
Definition: object.cpp:18
EncodeDouble
uint64_t EncodeDouble(double f) noexcept
Definition: serfloat.cpp:37