diff --git a/src/test/amount_tests.cpp b/src/test/amount_tests.cpp index 4d30b8e1dd..86d2524abb 100644 --- a/src/test/amount_tests.cpp +++ b/src/test/amount_tests.cpp @@ -1,133 +1,135 @@ // Copyright (c) 2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include BOOST_FIXTURE_TEST_SUITE(amount_tests, BasicTestingSetup) static void CheckAmounts(int64_t aval, int64_t bval) { Amount a(aval * SATOSHI), b(bval * SATOSHI); // Equality BOOST_CHECK_EQUAL(a == b, aval == bval); BOOST_CHECK_EQUAL(b == a, aval == bval); BOOST_CHECK_EQUAL(a != b, aval != bval); BOOST_CHECK_EQUAL(b != a, aval != bval); // Comparison BOOST_CHECK_EQUAL(a < b, aval < bval); BOOST_CHECK_EQUAL(b < a, bval < aval); BOOST_CHECK_EQUAL(a > b, aval > bval); BOOST_CHECK_EQUAL(b > a, bval > aval); BOOST_CHECK_EQUAL(a <= b, aval <= bval); BOOST_CHECK_EQUAL(b <= a, bval <= aval); BOOST_CHECK_EQUAL(a >= b, aval >= bval); BOOST_CHECK_EQUAL(b >= a, bval >= aval); // Unary minus BOOST_CHECK_EQUAL(-a, -aval * SATOSHI); BOOST_CHECK_EQUAL(-b, -bval * SATOSHI); // Addition and subtraction. BOOST_CHECK_EQUAL(a + b, b + a); BOOST_CHECK_EQUAL(a + b, (aval + bval) * SATOSHI); BOOST_CHECK_EQUAL(a - b, -(b - a)); BOOST_CHECK_EQUAL(a - b, (aval - bval) * SATOSHI); // Multiplication BOOST_CHECK_EQUAL(aval * b, bval * a); BOOST_CHECK_EQUAL(aval * b, (aval * bval) * SATOSHI); // Division if (b != Amount::zero()) { BOOST_CHECK_EQUAL(a / b, aval / bval); BOOST_CHECK_EQUAL(a / bval, (a / b) * SATOSHI); } if (a != Amount::zero()) { BOOST_CHECK_EQUAL(b / a, bval / aval); BOOST_CHECK_EQUAL(b / aval, (b / a) * SATOSHI); } // Modulus if (b != Amount::zero()) { BOOST_CHECK_EQUAL(a % b, a % bval); BOOST_CHECK_EQUAL(a % b, (aval % bval) * SATOSHI); } if (a != Amount::zero()) { BOOST_CHECK_EQUAL(b % a, b % aval); BOOST_CHECK_EQUAL(b % a, (bval % aval) * SATOSHI); } // OpAssign Amount v; BOOST_CHECK_EQUAL(v, Amount::zero()); v += a; BOOST_CHECK_EQUAL(v, a); v += b; BOOST_CHECK_EQUAL(v, a + b); v += b; BOOST_CHECK_EQUAL(v, a + 2 * b); v -= 2 * a; BOOST_CHECK_EQUAL(v, 2 * b - a); } BOOST_AUTO_TEST_CASE(AmountTests) { std::array values = {{-23, -1, 0, 1, 2, 3, 42, 99999999}}; for (int64_t i : values) { for (int64_t j : values) { CheckAmounts(i, j); } } BOOST_CHECK_EQUAL(COIN + COIN, 2 * COIN); BOOST_CHECK_EQUAL(2 * COIN + COIN, 3 * COIN); BOOST_CHECK_EQUAL(-1 * COIN + COIN, Amount::zero()); BOOST_CHECK_EQUAL(COIN - COIN, Amount::zero()); BOOST_CHECK_EQUAL(COIN - 2 * COIN, -1 * COIN); } BOOST_AUTO_TEST_CASE(MoneyRangeTest) { - BOOST_CHECK_EQUAL(MoneyRange(Amount(-1 * SATOSHI)), false); - BOOST_CHECK_EQUAL(MoneyRange(MAX_MONEY + Amount(1 * SATOSHI)), false); - BOOST_CHECK_EQUAL(MoneyRange(Amount(1 * SATOSHI)), true); + BOOST_CHECK_EQUAL(MoneyRange(-SATOSHI), false); + BOOST_CHECK_EQUAL(MoneyRange(Amount::zero()), true); + BOOST_CHECK_EQUAL(MoneyRange(SATOSHI), true); + BOOST_CHECK_EQUAL(MoneyRange(MAX_MONEY), true); + BOOST_CHECK_EQUAL(MoneyRange(MAX_MONEY + SATOSHI), false); } BOOST_AUTO_TEST_CASE(BinaryOperatorTest) { CFeeRate a, b; a = CFeeRate(1 * SATOSHI); b = CFeeRate(2 * SATOSHI); BOOST_CHECK(a < b); BOOST_CHECK(b > a); BOOST_CHECK(a == a); BOOST_CHECK(a <= b); BOOST_CHECK(a <= a); BOOST_CHECK(b >= a); BOOST_CHECK(b >= b); // a should be 0.00000002 BTC/kB now a += a; BOOST_CHECK(a == b); } BOOST_AUTO_TEST_CASE(ToStringTest) { CFeeRate feeRate; feeRate = CFeeRate(1 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.ToString(), "0.00000001 BCH/kB"); } BOOST_AUTO_TEST_SUITE_END() diff --git a/src/test/feerate_tests.cpp b/src/test/feerate_tests.cpp index 6fe49b3ed9..cd41f5b20c 100644 --- a/src/test/feerate_tests.cpp +++ b/src/test/feerate_tests.cpp @@ -1,88 +1,91 @@ // Copyright (c) 2016 The Bitcoin Core developers // Distributed under the MIT software license, see the accompanying // file COPYING or http://www.opensource.org/licenses/mit-license.php. #include #include #include #include BOOST_FIXTURE_TEST_SUITE(feerate_tests, BasicTestingSetup) BOOST_AUTO_TEST_CASE(GetFeeTest) { CFeeRate feeRate, altFeeRate; feeRate = CFeeRate(Amount::zero()); // Must always return 0 BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero()); BOOST_CHECK_EQUAL(feeRate.GetFee(1e5), Amount::zero()); feeRate = CFeeRate(1000 * SATOSHI); // Must always just return the arg BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero()); BOOST_CHECK_EQUAL(feeRate.GetFee(1), SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(121), 121 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(999), 999 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(1000), 1000 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(9000), 9000 * SATOSHI); feeRate = CFeeRate(-1000 * SATOSHI); // Must always just return -1 * arg BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero()); BOOST_CHECK_EQUAL(feeRate.GetFee(1), -SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(121), -121 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(999), -999 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(1000), -1000 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(9000), -9000 * SATOSHI); feeRate = CFeeRate(123 * SATOSHI); // Truncates the result, if not integer BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero()); // Special case: returns 1 instead of 0 BOOST_CHECK_EQUAL(feeRate.GetFee(8), SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(9), SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(121), 14 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(122), 15 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(999), 122 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(1000), 123 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(9000), 1107 * SATOSHI); feeRate = CFeeRate(-123 * SATOSHI); // Truncates the result, if not integer BOOST_CHECK_EQUAL(feeRate.GetFee(0), Amount::zero()); // Special case: returns -1 instead of 0 BOOST_CHECK_EQUAL(feeRate.GetFee(8), -SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFee(9), -SATOSHI); // Check ceiling results feeRate = CFeeRate(18 * SATOSHI); // Truncates the result, if not integer BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(0), Amount::zero()); BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(100), 2 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(200), 4 * SATOSHI); BOOST_CHECK_EQUAL(feeRate.GetFeeCeiling(1000), 18 * SATOSHI); // Check alternate constructor feeRate = CFeeRate(1000 * SATOSHI); altFeeRate = CFeeRate(feeRate); BOOST_CHECK_EQUAL(feeRate.GetFee(100), altFeeRate.GetFee(100)); // Check full constructor + BOOST_CHECK(CFeeRate(-SATOSHI, 0) == CFeeRate(Amount::zero())); + BOOST_CHECK(CFeeRate(Amount::zero(), 0) == CFeeRate(Amount::zero())); + BOOST_CHECK(CFeeRate(SATOSHI, 0) == CFeeRate(Amount::zero())); // default value BOOST_CHECK(CFeeRate(-SATOSHI, 1000) == CFeeRate(-SATOSHI)); BOOST_CHECK(CFeeRate(Amount::zero(), 1000) == CFeeRate(Amount::zero())); BOOST_CHECK(CFeeRate(SATOSHI, 1000) == CFeeRate(SATOSHI)); // lost precision (can only resolve satoshis per kB) BOOST_CHECK(CFeeRate(SATOSHI, 1001) == CFeeRate(Amount::zero())); BOOST_CHECK(CFeeRate(2 * SATOSHI, 1001) == CFeeRate(SATOSHI)); // some more integer checks BOOST_CHECK(CFeeRate(26 * SATOSHI, 789) == CFeeRate(32 * SATOSHI)); BOOST_CHECK(CFeeRate(27 * SATOSHI, 789) == CFeeRate(34 * SATOSHI)); // Maximum size in bytes, should not crash CFeeRate(MAX_MONEY, std::numeric_limits::max() >> 1).GetFeePerK(); } BOOST_AUTO_TEST_SUITE_END()