Inside Bitcoin

251    CHECKASSIGNMENTOPERATOR(Zero,R1,|)
252    CHECKASSIGNMENTOPERATOR(Zero,R1,^)
253    CHECKASSIGNMENTOPERATOR(Zero,R1,&)
254    CHECKASSIGNMENTOPERATOR(Max,R1,|)
255    CHECKASSIGNMENTOPERATOR(Max,R1,^)
256    CHECKASSIGNMENTOPERATOR(Max,R1,&)
257
258    uint64_t Tmp64 = 0xe1db685c9a0b47a2ULL;
259    TmpL = R1L; TmpL |= Tmp64;  BOOST_CHECK(TmpL == (R1L | arith_uint256(Tmp64)));
260    TmpL = R1L; TmpL |= 0; BOOST_CHECK(TmpL == R1L);
261    TmpL ^= 0; BOOST_CHECK(TmpL == R1L);
262    TmpL ^= Tmp64;  BOOST_CHECK(TmpL == (R1L ^ arith_uint256(Tmp64)));
263}
264
265BOOST_AUTO_TEST_CASE( comparison ) // <= >= < >
266{
267    arith_uint256 TmpL;
268    for (unsigned int i = 0; i < 256; ++i) {
269        TmpL= OneL<< i;
270        BOOST_CHECK(TmpL >= ZeroL);
271        BOOST_CHECK(TmpL > ZeroL);
272        BOOST_CHECK(ZeroL < TmpL);
273        BOOST_CHECK(ZeroL <= TmpL);
274        BOOST_CHECK(TmpL >= 0);
275        BOOST_CHECK(TmpL > 0);
276        BOOST_CHECK(0 < TmpL);
277        BOOST_CHECK(0 <= TmpL);
278        TmpL |= R1L;
279        BOOST_CHECK( TmpL >= R1L ); BOOST_CHECK( (TmpL == R1L) != (TmpL > R1L)); BOOST_CHECK( (TmpL == R1L) || !( TmpL <= R1L));
280        BOOST_CHECK( R1L <= TmpL ); BOOST_CHECK( (R1L == TmpL) != (R1L < TmpL)); BOOST_CHECK( (TmpL == R1L) || !( R1L >= TmpL));
281        BOOST_CHECK(! (TmpL < R1L)); BOOST_CHECK(! (R1L > TmpL));
282    }
283
284    BOOST_CHECK_LT(ZeroL,
285                   OneL);
286}
287
288BOOST_AUTO_TEST_CASE( plusMinus )
289{
290    arith_uint256 TmpL = 0;
291    BOOST_CHECK_EQUAL(R1L + R2L, UintToArith256(uint256{"549fb09fea236a1ea3e31d4d58f1b1369288d204211ca751527cfc175767850c"}));
292    TmpL += R1L;
293    BOOST_CHECK(TmpL == R1L);
294    TmpL += R2L;
295    BOOST_CHECK(TmpL == R1L + R2L);
296    BOOST_CHECK(OneL+MaxL == ZeroL);
297    BOOST_CHECK(MaxL+OneL == ZeroL);
298    for (unsigned int i = 1; i < 256; ++i) {
299        BOOST_CHECK( (MaxL >> i) + OneL == (HalfL >> (i-1)) );
300        BOOST_CHECK( OneL + (MaxL >> i) == (HalfL >> (i-1)) );
301        TmpL = (MaxL>>i); TmpL += OneL;
302        BOOST_CHECK( TmpL == (HalfL >> (i-1)) );
303        TmpL = (MaxL>>i); TmpL += 1;
304        BOOST_CHECK( TmpL == (HalfL >> (i-1)) );
305        TmpL = (MaxL>>i);
306        BOOST_CHECK( TmpL++ == (MaxL>>i) );
307        BOOST_CHECK( TmpL == (HalfL >> (i-1)));
308    }
309    BOOST_CHECK(arith_uint256(0xbedc77e27940a7ULL) + 0xee8d836fce66fbULL == arith_uint256(0xbedc77e27940a7ULL + 0xee8d836fce66fbULL));
310    TmpL = arith_uint256(0xbedc77e27940a7ULL); TmpL += 0xee8d836fce66fbULL;
311    BOOST_CHECK(TmpL == arith_uint256(0xbedc77e27940a7ULL+0xee8d836fce66fbULL));
312    TmpL -= 0xee8d836fce66fbULL;  BOOST_CHECK(TmpL == 0xbedc77e27940a7ULL);
313    TmpL = R1L;
314    BOOST_CHECK(++TmpL == R1L+1);
315
316    BOOST_CHECK(R1L -(-R2L) == R1L+R2L);
317    BOOST_CHECK(R1L -(-OneL) == R1L+OneL);
318    BOOST_CHECK(R1L - OneL == R1L+(-OneL));
319    for (unsigned int i = 1; i < 256; ++i) {
320        BOOST_CHECK((MaxL>>i) - (-OneL)  == (HalfL >> (i-1)));
321        BOOST_CHECK((HalfL >> (i-1)) - OneL == (MaxL>>i));
322        TmpL = (HalfL >> (i-1));
323        BOOST_CHECK(TmpL-- == (HalfL >> (i-1)));
324        BOOST_CHECK(TmpL == (MaxL >> i));
325        TmpL = (HalfL >> (i-1));
326        BOOST_CHECK(--TmpL == (MaxL >> i));
327    }
328    TmpL = R1L;
329    BOOST_CHECK(--TmpL == R1L-1);
330}
331
332BOOST_AUTO_TEST_CASE( multiply )
333{
334    BOOST_CHECK((R1L * R1L).ToString() == "62a38c0486f01e45879d7910a7761bf30d5237e9873f9bff3642a732c4d84f10");
335    BOOST_CHECK((R1L * R2L).ToString() == "de37805e9986996cfba76ff6ba51c008df851987d9dd323f0e5de07760529c40");
336    BOOST_CHECK((R1L * ZeroL) == ZeroL);
337    BOOST_CHECK((R1L * OneL) == R1L);
338    BOOST_CHECK((R1L * MaxL) == -R1L);
339    BOOST_CHECK((R2L * R1L) == (R1L * R2L));
340    BOOST_CHECK((R2L * R2L).ToString() == "ac8c010096767d3cae5005dec28bb2b45a1d85ab7996ccd3e102a650f74ff100");
341    BOOST_CHECK((R2L * ZeroL) == ZeroL);
342    BOOST_CHECK((R2L * OneL) == R2L);
343    BOOST_CHECK((R2L * MaxL) == -R2L);
344
345    BOOST_CHECK(MaxL * MaxL == OneL);
346
347    BOOST_CHECK((R1L * 0) == 0);
348    BOOST_CHECK((R1L * 1) == R1L);
349    BOOST_CHECK((R1L * 3).ToString() == "7759b1c0ed14047f961ad09b20ff83687876a0181a367b813634046f91def7d4");
350    BOOST_CHECK((R2L * 0x87654321UL).ToString() == "23f7816e30c4ae2017257b7a0fa64d60402f5234d46e746b61c960d09a26d070");
351}
352
353BOOST_AUTO_TEST_CASE( divide )
354{
355    arith_uint256 D1L{UintToArith256(uint256{"00000000000000000000000000000000000000000000000ad7133ac1977fa2b7"})};
356    arith_uint256 D2L{UintToArith256(uint256{"0000000000000000000000000000000000000000000000000000000ecd751716"})};
357    BOOST_CHECK((R1L / D1L).ToString() == "00000000000000000b8ac01106981635d9ed112290f8895545a7654dde28fb3a");
358    BOOST_CHECK((R1L / D2L).ToString() == "000000000873ce8efec5b67150bad3aa8c5fcb70e947586153bf2cec7c37c57a");
359    BOOST_CHECK(R1L / OneL == R1L);
360    BOOST_CHECK(R1L / MaxL == ZeroL);
361    BOOST_CHECK(MaxL / R1L == 2);
362    BOOST_CHECK_THROW(R1L / ZeroL, uint_error);
363    BOOST_CHECK((R2L / D1L).ToString() == "000000000000000013e1665895a1cc981de6d93670105a6b3ec3b73141b3a3c5");
364    BOOST_CHECK((R2L / D2L).ToString() == "000000000e8f0abe753bb0afe2e9437ee85d280be60882cf0bd1aaf7fa3cc2c4");
365    BOOST_CHECK(R2L / OneL == R2L);
366    BOOST_CHECK(R2L / MaxL == ZeroL);
367    BOOST_CHECK(MaxL / R2L == 1);
368    BOOST_CHECK_THROW(R2L / ZeroL, uint_error);
369}
370
371
372static bool almostEqual(double d1, double d2)
373{
374    return fabs(d1-d2) <= 4*fabs(d1)*std::numeric_limits<double>::epsilon();
375}
376
377BOOST_AUTO_TEST_CASE(methods)
378{
379    BOOST_CHECK(R1L.GetHex() == R1L.ToString());
380    BOOST_CHECK(R2L.GetHex() == R2L.ToString());
381    BOOST_CHECK(OneL.GetHex() == OneL.ToString());
382    BOOST_CHECK(MaxL.GetHex() == MaxL.ToString());
383    arith_uint256 TmpL(R1L);
384    BOOST_CHECK(TmpL == R1L);
385    TmpL = R2L;
386    BOOST_CHECK(TmpL == R2L);
387    TmpL = ZeroL;
388    BOOST_CHECK(TmpL == 0);
389    TmpL = HalfL;
390    BOOST_CHECK(TmpL == HalfL);
391
392    TmpL = R1L;
393    BOOST_CHECK(R1L.size() == 32);
394    BOOST_CHECK(R2L.size() == 32);
395    BOOST_CHECK(ZeroL.size() == 32);
396    BOOST_CHECK(MaxL.size() == 32);
397    BOOST_CHECK(R1L.GetLow64()  == R1LLow64);
398    BOOST_CHECK(HalfL.GetLow64() ==0x0000000000000000ULL);
399    BOOST_CHECK(OneL.GetLow64() ==0x0000000000000001ULL);
400
401    for (unsigned int i = 0; i < 255; ++i)
402    {
403        BOOST_CHECK((OneL << i).getdouble() == ldexp(1.0,i));
404    }
405    BOOST_CHECK(ZeroL.getdouble() == 0.0);
406    for (int i = 256; i > 53; --i)
407        BOOST_CHECK(almostEqual((R1L>>(256-i)).getdouble(), ldexp(R1Ldouble,i)));
408    uint64_t R1L64part = (R1L>>192).GetLow64();
409    for (int i = 53; i > 0; --i) // doubles can store all integers in {0,...,2^54-1} exactly
410    {
411        BOOST_CHECK((R1L>>(256-i)).getdouble() == (double)(R1L64part >> (64-i)));
412    }
413}
414
415BOOST_AUTO_TEST_CASE(bignum_SetCompact)
416{
417    arith_uint256 num;
418    bool fNegative;
419    bool fOverflow;
420    num.SetCompact(0, &fNegative, &fOverflow);
421    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
422    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
423    BOOST_CHECK_EQUAL(fNegative, false);
424    BOOST_CHECK_EQUAL(fOverflow, false);
425
426    num.SetCompact(0x00123456, &fNegative, &fOverflow);
427    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
428    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
429    BOOST_CHECK_EQUAL(fNegative, false);
430    BOOST_CHECK_EQUAL(fOverflow, false);
431
432    num.SetCompact(0x01003456, &fNegative, &fOverflow);
433    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
434    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
435    BOOST_CHECK_EQUAL(fNegative, false);
436    BOOST_CHECK_EQUAL(fOverflow, false);
437
438    num.SetCompact(0x02000056, &fNegative, &fOverflow);
439    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
440    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
441    BOOST_CHECK_EQUAL(fNegative, false);
442    BOOST_CHECK_EQUAL(fOverflow, false);
443
444    num.SetCompact(0x03000000, &fNegative, &fOverflow);
445    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
446    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
447    BOOST_CHECK_EQUAL(fNegative, false);
448    BOOST_CHECK_EQUAL(fOverflow, false);
449
450    num.SetCompact(0x04000000, &fNegative, &fOverflow);
451    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
452    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
453    BOOST_CHECK_EQUAL(fNegative, false);
454    BOOST_CHECK_EQUAL(fOverflow, false);
455
456    num.SetCompact(0x00923456, &fNegative, &fOverflow);
457    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
458    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
459    BOOST_CHECK_EQUAL(fNegative, false);
460    BOOST_CHECK_EQUAL(fOverflow, false);
461
462    num.SetCompact(0x01803456, &fNegative, &fOverflow);
463    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
464    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
465    BOOST_CHECK_EQUAL(fNegative, false);
466    BOOST_CHECK_EQUAL(fOverflow, false);
467
468    num.SetCompact(0x02800056, &fNegative, &fOverflow);
469    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
470    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
471    BOOST_CHECK_EQUAL(fNegative, false);
472    BOOST_CHECK_EQUAL(fOverflow, false);
473
474    num.SetCompact(0x03800000, &fNegative, &fOverflow);
475    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
476    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
477    BOOST_CHECK_EQUAL(fNegative, false);
478    BOOST_CHECK_EQUAL(fOverflow, false);
479
480    num.SetCompact(0x04800000, &fNegative, &fOverflow);
481    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000000");
482    BOOST_CHECK_EQUAL(num.GetCompact(), 0U);
483    BOOST_CHECK_EQUAL(fNegative, false);
484    BOOST_CHECK_EQUAL(fOverflow, false);
485
486    num.SetCompact(0x01123456, &fNegative, &fOverflow);
487    BOOST_CHECK_EQUAL(num.GetHex(), "0000000000000000000000000000000000000000000000000000000000000012");
488    BOOST_CHECK_EQUAL(num.GetCompact(), 0x01120000U);
489    BOOST_CHECK_EQUAL(fNegative, false);
490    BOOST_CHECK_EQUAL(fOverflow, false);
491
492    // Make sure that we don't generate compacts with the 0x00800000 bit set
493    num = 0x80;
494    BOOST_CHECK_EQUAL(num.GetCompact(), 0x02008000U);
495
496    num.SetCompact(0x01fedcba, &fNegative, &fOverflow);
497    BOOST_CHECK_EQUAL(num.GetHex(), "000000000000000000000000000000000000000000000000000000000000007e");
498    BOOST_CHECK_EQUAL(num.GetCompact(true), 0x01fe0000U);
499    BOOST_CHECK_EQUAL(fNegative, true);
500    BOOST_CHECK_EQUAL(fOverflow, false);