1 // Copyright (c) 2012-2018 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 <serialize.h>
6 #include <streams.h>
7 #include <hash.h>
8 #include <test/test_bitcoin.h>
9
10 #include <stdint.h>
11
12 #include <boost/test/unit_test.hpp>
13
14 BOOST_FIXTURE_TEST_SUITE(serialize_tests, BasicTestingSetup)
15
16 class CSerializeMethodsTestSingle
17 {
18 protected:
19 int intval;
20 bool boolval;
21 std::string stringval;
22 char charstrval[16];
23 CTransactionRef txval;
24 public:
25 CSerializeMethodsTestSingle() = default;
CSerializeMethodsTestSingle(int intvalin,bool boolvalin,std::string stringvalin,const char * charstrvalin,const CTransactionRef & txvalin)26 CSerializeMethodsTestSingle(int intvalin, bool boolvalin, std::string stringvalin, const char* charstrvalin, const CTransactionRef& txvalin) : intval(intvalin), boolval(boolvalin), stringval(std::move(stringvalin)), txval(txvalin)
27 {
28 memcpy(charstrval, charstrvalin, sizeof(charstrval));
29 }
30
31 ADD_SERIALIZE_METHODS;
32
33 template <typename Stream, typename Operation>
SerializationOp(Stream & s,Operation ser_action)34 inline void SerializationOp(Stream& s, Operation ser_action) {
35 READWRITE(intval);
36 READWRITE(boolval);
37 READWRITE(stringval);
38 READWRITE(charstrval);
39 READWRITE(txval);
40 }
41
operator ==(const CSerializeMethodsTestSingle & rhs)42 bool operator==(const CSerializeMethodsTestSingle& rhs)
43 {
44 return intval == rhs.intval && \
45 boolval == rhs.boolval && \
46 stringval == rhs.stringval && \
47 strcmp(charstrval, rhs.charstrval) == 0 && \
48 *txval == *rhs.txval;
49 }
50 };
51
52 class CSerializeMethodsTestMany : public CSerializeMethodsTestSingle
53 {
54 public:
55 using CSerializeMethodsTestSingle::CSerializeMethodsTestSingle;
56 ADD_SERIALIZE_METHODS;
57
58 template <typename Stream, typename Operation>
SerializationOp(Stream & s,Operation ser_action)59 inline void SerializationOp(Stream& s, Operation ser_action) {
60 READWRITE(intval, boolval, stringval, charstrval, txval);
61 }
62 };
63
BOOST_AUTO_TEST_CASE(sizes)64 BOOST_AUTO_TEST_CASE(sizes)
65 {
66 BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(char(0), 0));
67 BOOST_CHECK_EQUAL(sizeof(int8_t), GetSerializeSize(int8_t(0), 0));
68 BOOST_CHECK_EQUAL(sizeof(uint8_t), GetSerializeSize(uint8_t(0), 0));
69 BOOST_CHECK_EQUAL(sizeof(int16_t), GetSerializeSize(int16_t(0), 0));
70 BOOST_CHECK_EQUAL(sizeof(uint16_t), GetSerializeSize(uint16_t(0), 0));
71 BOOST_CHECK_EQUAL(sizeof(int32_t), GetSerializeSize(int32_t(0), 0));
72 BOOST_CHECK_EQUAL(sizeof(uint32_t), GetSerializeSize(uint32_t(0), 0));
73 BOOST_CHECK_EQUAL(sizeof(int64_t), GetSerializeSize(int64_t(0), 0));
74 BOOST_CHECK_EQUAL(sizeof(uint64_t), GetSerializeSize(uint64_t(0), 0));
75 BOOST_CHECK_EQUAL(sizeof(float), GetSerializeSize(float(0), 0));
76 BOOST_CHECK_EQUAL(sizeof(double), GetSerializeSize(double(0), 0));
77 // Bool is serialized as char
78 BOOST_CHECK_EQUAL(sizeof(char), GetSerializeSize(bool(0), 0));
79
80 // Sanity-check GetSerializeSize and c++ type matching
81 BOOST_CHECK_EQUAL(GetSerializeSize(char(0), 0), 1U);
82 BOOST_CHECK_EQUAL(GetSerializeSize(int8_t(0), 0), 1U);
83 BOOST_CHECK_EQUAL(GetSerializeSize(uint8_t(0), 0), 1U);
84 BOOST_CHECK_EQUAL(GetSerializeSize(int16_t(0), 0), 2U);
85 BOOST_CHECK_EQUAL(GetSerializeSize(uint16_t(0), 0), 2U);
86 BOOST_CHECK_EQUAL(GetSerializeSize(int32_t(0), 0), 4U);
87 BOOST_CHECK_EQUAL(GetSerializeSize(uint32_t(0), 0), 4U);
88 BOOST_CHECK_EQUAL(GetSerializeSize(int64_t(0), 0), 8U);
89 BOOST_CHECK_EQUAL(GetSerializeSize(uint64_t(0), 0), 8U);
90 BOOST_CHECK_EQUAL(GetSerializeSize(float(0), 0), 4U);
91 BOOST_CHECK_EQUAL(GetSerializeSize(double(0), 0), 8U);
92 BOOST_CHECK_EQUAL(GetSerializeSize(bool(0), 0), 1U);
93 }
94
BOOST_AUTO_TEST_CASE(floats_conversion)95 BOOST_AUTO_TEST_CASE(floats_conversion)
96 {
97 // Choose values that map unambiguously to binary floating point to avoid
98 // rounding issues at the compiler side.
99 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x00000000), 0.0F);
100 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f000000), 0.5F);
101 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x3f800000), 1.0F);
102 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40000000), 2.0F);
103 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x40800000), 4.0F);
104 BOOST_CHECK_EQUAL(ser_uint32_to_float(0x44444444), 785.066650390625F);
105
106 BOOST_CHECK_EQUAL(ser_float_to_uint32(0.0F), 0x00000000U);
107 BOOST_CHECK_EQUAL(ser_float_to_uint32(0.5F), 0x3f000000U);
108 BOOST_CHECK_EQUAL(ser_float_to_uint32(1.0F), 0x3f800000U);
109 BOOST_CHECK_EQUAL(ser_float_to_uint32(2.0F), 0x40000000U);
110 BOOST_CHECK_EQUAL(ser_float_to_uint32(4.0F), 0x40800000U);
111 BOOST_CHECK_EQUAL(ser_float_to_uint32(785.066650390625F), 0x44444444U);
112 }
113
BOOST_AUTO_TEST_CASE(doubles_conversion)114 BOOST_AUTO_TEST_CASE(doubles_conversion)
115 {
116 // Choose values that map unambiguously to binary floating point to avoid
117 // rounding issues at the compiler side.
118 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x0000000000000000ULL), 0.0);
119 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3fe0000000000000ULL), 0.5);
120 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x3ff0000000000000ULL), 1.0);
121 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4000000000000000ULL), 2.0);
122 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4010000000000000ULL), 4.0);
123 BOOST_CHECK_EQUAL(ser_uint64_to_double(0x4088888880000000ULL), 785.066650390625);
124
125 BOOST_CHECK_EQUAL(ser_double_to_uint64(0.0), 0x0000000000000000ULL);
126 BOOST_CHECK_EQUAL(ser_double_to_uint64(0.5), 0x3fe0000000000000ULL);
127 BOOST_CHECK_EQUAL(ser_double_to_uint64(1.0), 0x3ff0000000000000ULL);
128 BOOST_CHECK_EQUAL(ser_double_to_uint64(2.0), 0x4000000000000000ULL);
129 BOOST_CHECK_EQUAL(ser_double_to_uint64(4.0), 0x4010000000000000ULL);
130 BOOST_CHECK_EQUAL(ser_double_to_uint64(785.066650390625), 0x4088888880000000ULL);
131 }
132 /*
133 Python code to generate the below hashes:
134
135 def reversed_hex(x):
136 return binascii.hexlify(''.join(reversed(x)))
137 def dsha256(x):
138 return hashlib.sha256(hashlib.sha256(x).digest()).digest()
139
140 reversed_hex(dsha256(''.join(struct.pack('<f', x) for x in range(0,1000)))) == '8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c'
141 reversed_hex(dsha256(''.join(struct.pack('<d', x) for x in range(0,1000)))) == '43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96'
142 */
BOOST_AUTO_TEST_CASE(floats)143 BOOST_AUTO_TEST_CASE(floats)
144 {
145 CDataStream ss(SER_DISK, 0);
146 // encode
147 for (int i = 0; i < 1000; i++) {
148 ss << float(i);
149 }
150 BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("8e8b4cf3e4df8b332057e3e23af42ebc663b61e0495d5e7e32d85099d7f3fe0c"));
151
152 // decode
153 for (int i = 0; i < 1000; i++) {
154 float j;
155 ss >> j;
156 BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
157 }
158 }
159
BOOST_AUTO_TEST_CASE(doubles)160 BOOST_AUTO_TEST_CASE(doubles)
161 {
162 CDataStream ss(SER_DISK, 0);
163 // encode
164 for (int i = 0; i < 1000; i++) {
165 ss << double(i);
166 }
167 BOOST_CHECK(Hash(ss.begin(), ss.end()) == uint256S("43d0c82591953c4eafe114590d392676a01585d25b25d433557f0d7878b23f96"));
168
169 // decode
170 for (int i = 0; i < 1000; i++) {
171 double j;
172 ss >> j;
173 BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
174 }
175 }
176
BOOST_AUTO_TEST_CASE(varints)177 BOOST_AUTO_TEST_CASE(varints)
178 {
179 // encode
180
181 CDataStream ss(SER_DISK, 0);
182 CDataStream::size_type size = 0;
183 for (int i = 0; i < 100000; i++) {
184 ss << VARINT(i, VarIntMode::NONNEGATIVE_SIGNED);
185 size += ::GetSerializeSize(VARINT(i, VarIntMode::NONNEGATIVE_SIGNED), 0);
186 BOOST_CHECK(size == ss.size());
187 }
188
189 for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
190 ss << VARINT(i);
191 size += ::GetSerializeSize(VARINT(i), 0);
192 BOOST_CHECK(size == ss.size());
193 }
194
195 // decode
196 for (int i = 0; i < 100000; i++) {
197 int j = -1;
198 ss >> VARINT(j, VarIntMode::NONNEGATIVE_SIGNED);
199 BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
200 }
201
202 for (uint64_t i = 0; i < 100000000000ULL; i += 999999937) {
203 uint64_t j = std::numeric_limits<uint64_t>::max();
204 ss >> VARINT(j);
205 BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
206 }
207 }
208
BOOST_AUTO_TEST_CASE(varints_bitpatterns)209 BOOST_AUTO_TEST_CASE(varints_bitpatterns)
210 {
211 CDataStream ss(SER_DISK, 0);
212 ss << VARINT(0, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "00"); ss.clear();
213 ss << VARINT(0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
214 ss << VARINT((int8_t)0x7f, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "7f"); ss.clear();
215 ss << VARINT(0x80, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "8000"); ss.clear();
216 ss << VARINT((uint8_t)0x80); BOOST_CHECK_EQUAL(HexStr(ss), "8000"); ss.clear();
217 ss << VARINT(0x1234, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "a334"); ss.clear();
218 ss << VARINT((int16_t)0x1234, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "a334"); ss.clear();
219 ss << VARINT(0xffff, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f"); ss.clear();
220 ss << VARINT((uint16_t)0xffff); BOOST_CHECK_EQUAL(HexStr(ss), "82fe7f"); ss.clear();
221 ss << VARINT(0x123456, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "c7e756"); ss.clear();
222 ss << VARINT((int32_t)0x123456, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "c7e756"); ss.clear();
223 ss << VARINT(0x80123456U); BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756"); ss.clear();
224 ss << VARINT((uint32_t)0x80123456U); BOOST_CHECK_EQUAL(HexStr(ss), "86ffc7e756"); ss.clear();
225 ss << VARINT(0xffffffff); BOOST_CHECK_EQUAL(HexStr(ss), "8efefefe7f"); ss.clear();
226 ss << VARINT(0x7fffffffffffffffLL, VarIntMode::NONNEGATIVE_SIGNED); BOOST_CHECK_EQUAL(HexStr(ss), "fefefefefefefefe7f"); ss.clear();
227 ss << VARINT(0xffffffffffffffffULL); BOOST_CHECK_EQUAL(HexStr(ss), "80fefefefefefefefe7f"); ss.clear();
228 }
229
BOOST_AUTO_TEST_CASE(compactsize)230 BOOST_AUTO_TEST_CASE(compactsize)
231 {
232 CDataStream ss(SER_DISK, 0);
233 std::vector<char>::size_type i, j;
234
235 for (i = 1; i <= MAX_SIZE; i *= 2)
236 {
237 WriteCompactSize(ss, i-1);
238 WriteCompactSize(ss, i);
239 }
240 for (i = 1; i <= MAX_SIZE; i *= 2)
241 {
242 j = ReadCompactSize(ss);
243 BOOST_CHECK_MESSAGE((i-1) == j, "decoded:" << j << " expected:" << (i-1));
244 j = ReadCompactSize(ss);
245 BOOST_CHECK_MESSAGE(i == j, "decoded:" << j << " expected:" << i);
246 }
247 }
248
isCanonicalException(const std::ios_base::failure & ex)249 static bool isCanonicalException(const std::ios_base::failure& ex)
250 {
251 std::ios_base::failure expectedException("non-canonical ReadCompactSize()");
252
253 // The string returned by what() can be different for different platforms.
254 // Instead of directly comparing the ex.what() with an expected string,
255 // create an instance of exception to see if ex.what() matches
256 // the expected explanatory string returned by the exception instance.
257 return strcmp(expectedException.what(), ex.what()) == 0;
258 }
259
260
BOOST_AUTO_TEST_CASE(noncanonical)261 BOOST_AUTO_TEST_CASE(noncanonical)
262 {
263 // Write some non-canonical CompactSize encodings, and
264 // make sure an exception is thrown when read back.
265 CDataStream ss(SER_DISK, 0);
266 std::vector<char>::size_type n;
267
268 // zero encoded with three bytes:
269 ss.write("\xfd\x00\x00", 3);
270 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
271
272 // 0xfc encoded with three bytes:
273 ss.write("\xfd\xfc\x00", 3);
274 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
275
276 // 0xfd encoded with three bytes is OK:
277 ss.write("\xfd\xfd\x00", 3);
278 n = ReadCompactSize(ss);
279 BOOST_CHECK(n == 0xfd);
280
281 // zero encoded with five bytes:
282 ss.write("\xfe\x00\x00\x00\x00", 5);
283 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
284
285 // 0xffff encoded with five bytes:
286 ss.write("\xfe\xff\xff\x00\x00", 5);
287 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
288
289 // zero encoded with nine bytes:
290 ss.write("\xff\x00\x00\x00\x00\x00\x00\x00\x00", 9);
291 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
292
293 // 0x01ffffff encoded with nine bytes:
294 ss.write("\xff\xff\xff\xff\x01\x00\x00\x00\x00", 9);
295 BOOST_CHECK_EXCEPTION(ReadCompactSize(ss), std::ios_base::failure, isCanonicalException);
296 }
297
BOOST_AUTO_TEST_CASE(insert_delete)298 BOOST_AUTO_TEST_CASE(insert_delete)
299 {
300 // Test inserting/deleting bytes.
301 CDataStream ss(SER_DISK, 0);
302 BOOST_CHECK_EQUAL(ss.size(), 0U);
303
304 ss.write("\x00\x01\x02\xff", 4);
305 BOOST_CHECK_EQUAL(ss.size(), 4U);
306
307 char c = (char)11;
308
309 // Inserting at beginning/end/middle:
310 ss.insert(ss.begin(), c);
311 BOOST_CHECK_EQUAL(ss.size(), 5U);
312 BOOST_CHECK_EQUAL(ss[0], c);
313 BOOST_CHECK_EQUAL(ss[1], 0);
314
315 ss.insert(ss.end(), c);
316 BOOST_CHECK_EQUAL(ss.size(), 6U);
317 BOOST_CHECK_EQUAL(ss[4], (char)0xff);
318 BOOST_CHECK_EQUAL(ss[5], c);
319
320 ss.insert(ss.begin()+2, c);
321 BOOST_CHECK_EQUAL(ss.size(), 7U);
322 BOOST_CHECK_EQUAL(ss[2], c);
323
324 // Delete at beginning/end/middle
325 ss.erase(ss.begin());
326 BOOST_CHECK_EQUAL(ss.size(), 6U);
327 BOOST_CHECK_EQUAL(ss[0], 0);
328
329 ss.erase(ss.begin()+ss.size()-1);
330 BOOST_CHECK_EQUAL(ss.size(), 5U);
331 BOOST_CHECK_EQUAL(ss[4], (char)0xff);
332
333 ss.erase(ss.begin()+1);
334 BOOST_CHECK_EQUAL(ss.size(), 4U);
335 BOOST_CHECK_EQUAL(ss[0], 0);
336 BOOST_CHECK_EQUAL(ss[1], 1);
337 BOOST_CHECK_EQUAL(ss[2], 2);
338 BOOST_CHECK_EQUAL(ss[3], (char)0xff);
339
340 // Make sure GetAndClear does the right thing:
341 CSerializeData d;
342 ss.GetAndClear(d);
343 BOOST_CHECK_EQUAL(ss.size(), 0U);
344 }
345
BOOST_AUTO_TEST_CASE(class_methods)346 BOOST_AUTO_TEST_CASE(class_methods)
347 {
348 int intval(100);
349 bool boolval(true);
350 std::string stringval("testing");
351 const char charstrval[16] = "testing charstr";
352 CMutableTransaction txval;
353 CTransactionRef tx_ref{MakeTransactionRef(txval)};
354 CSerializeMethodsTestSingle methodtest1(intval, boolval, stringval, charstrval, tx_ref);
355 CSerializeMethodsTestMany methodtest2(intval, boolval, stringval, charstrval, tx_ref);
356 CSerializeMethodsTestSingle methodtest3;
357 CSerializeMethodsTestMany methodtest4;
358 CDataStream ss(SER_DISK, PROTOCOL_VERSION);
359 BOOST_CHECK(methodtest1 == methodtest2);
360 ss << methodtest1;
361 ss >> methodtest4;
362 ss << methodtest2;
363 ss >> methodtest3;
364 BOOST_CHECK(methodtest1 == methodtest2);
365 BOOST_CHECK(methodtest2 == methodtest3);
366 BOOST_CHECK(methodtest3 == methodtest4);
367
368 CDataStream ss2(SER_DISK, PROTOCOL_VERSION, intval, boolval, stringval, charstrval, txval);
369 ss2 >> methodtest3;
370 BOOST_CHECK(methodtest3 == methodtest4);
371 }
372
373 BOOST_AUTO_TEST_SUITE_END()
374