2014-04-21 21:11:39 -07:00
|
|
|
// Copyright (c) 2012-2014 The Bitcoin Core developers
|
2022-05-11 16:29:59 -07:00
|
|
|
// Copyright (c) 2019-2022 The Zcash developers
|
2014-12-12 20:09:33 -08:00
|
|
|
// Distributed under the MIT software license, see the accompanying
|
2019-07-18 07:16:09 -07:00
|
|
|
// file COPYING or https://www.opensource.org/licenses/mit-license.php .
|
2014-04-21 21:11:39 -07:00
|
|
|
|
2015-11-25 04:19:48 -08:00
|
|
|
#include "scriptnum10.h"
|
2014-08-20 08:37:40 -07:00
|
|
|
#include "script/script.h"
|
2015-03-12 01:34:42 -07:00
|
|
|
#include "test/test_bitcoin.h"
|
|
|
|
|
2014-04-21 21:11:39 -07:00
|
|
|
#include <boost/test/unit_test.hpp>
|
|
|
|
#include <limits.h>
|
|
|
|
#include <stdint.h>
|
2015-03-12 01:34:42 -07:00
|
|
|
|
|
|
|
BOOST_FIXTURE_TEST_SUITE(scriptnum_tests, BasicTestingSetup)
|
2014-04-21 21:11:39 -07:00
|
|
|
|
|
|
|
static const int64_t values[] = \
|
2020-09-30 07:55:44 -07:00
|
|
|
{ 0, 1, CHAR_MIN, CHAR_MAX, UCHAR_MAX, SHRT_MIN, USHRT_MAX, INT_MIN, INT_MAX, UINT_MAX, INT64_MIN, INT64_MAX };
|
2014-04-21 21:11:39 -07:00
|
|
|
static const int64_t offsets[] = { 1, 0x79, 0x80, 0x81, 0xFF, 0x7FFF, 0x8000, 0xFFFF, 0x10000};
|
|
|
|
|
2020-09-30 07:55:44 -07:00
|
|
|
|
|
|
|
static bool addition_in_range(int64_t a, int64_t b) {
|
|
|
|
// intentionally excludes cases where the result would be INT64_MIN
|
|
|
|
return b > 0 ? (a <= INT64_MAX - b) : (a > INT64_MIN - b);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool subtraction_in_range(int64_t a, int64_t b) {
|
|
|
|
// intentionally excludes cases where the result would be INT64_MIN
|
|
|
|
return b >= 0 ? (a > INT64_MIN + b) : (a <= INT64_MAX + b);
|
|
|
|
}
|
|
|
|
|
|
|
|
static bool value_in_range(int64_t a) {
|
|
|
|
return a != INT64_MIN;
|
|
|
|
}
|
|
|
|
|
2015-11-25 04:19:48 -08:00
|
|
|
static bool verify(const CScriptNum10& bignum, const CScriptNum& scriptnum)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
return bignum.getvch() == scriptnum.getvch() && bignum.getint() == scriptnum.getint();
|
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckCreateVch(int64_t num)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
CScriptNum10 bignum(num);
|
2014-04-21 21:11:39 -07:00
|
|
|
CScriptNum scriptnum(num);
|
|
|
|
BOOST_CHECK(verify(bignum, scriptnum));
|
|
|
|
|
2015-11-25 04:19:48 -08:00
|
|
|
CScriptNum10 bignum2(bignum.getvch(), false);
|
2020-09-30 07:55:44 -07:00
|
|
|
std::vector<unsigned char> scriptnum_vch = scriptnum.getvch();
|
|
|
|
// The 9-byte case is exercised by the 'intmin' test.
|
|
|
|
BOOST_CHECK(scriptnum_vch.size() <= 8);
|
|
|
|
CScriptNum scriptnum2(scriptnum_vch, false);
|
2014-04-21 21:11:39 -07:00
|
|
|
BOOST_CHECK(verify(bignum2, scriptnum2));
|
|
|
|
|
2015-11-25 04:19:48 -08:00
|
|
|
CScriptNum10 bignum3(scriptnum2.getvch(), false);
|
2014-10-08 18:48:59 -07:00
|
|
|
CScriptNum scriptnum3(bignum2.getvch(), false);
|
2014-04-21 21:11:39 -07:00
|
|
|
BOOST_CHECK(verify(bignum3, scriptnum3));
|
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckCreateInt(int64_t num)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
CScriptNum10 bignum(num);
|
2014-04-21 21:11:39 -07:00
|
|
|
CScriptNum scriptnum(num);
|
|
|
|
BOOST_CHECK(verify(bignum, scriptnum));
|
2015-11-25 04:19:48 -08:00
|
|
|
BOOST_CHECK(verify(CScriptNum10(bignum.getint()), CScriptNum(scriptnum.getint())));
|
|
|
|
BOOST_CHECK(verify(CScriptNum10(scriptnum.getint()), CScriptNum(bignum.getint())));
|
|
|
|
BOOST_CHECK(verify(CScriptNum10(CScriptNum10(scriptnum.getint()).getint()), CScriptNum(CScriptNum(bignum.getint()).getint())));
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckAdd(int64_t num1, int64_t num2)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
const CScriptNum10 bignum1(num1);
|
|
|
|
const CScriptNum10 bignum2(num2);
|
2014-04-21 21:11:39 -07:00
|
|
|
const CScriptNum scriptnum1(num1);
|
|
|
|
const CScriptNum scriptnum2(num2);
|
2015-11-25 04:19:48 -08:00
|
|
|
CScriptNum10 bignum3(num1);
|
|
|
|
CScriptNum10 bignum4(num1);
|
2014-04-21 21:11:39 -07:00
|
|
|
CScriptNum scriptnum3(num1);
|
|
|
|
CScriptNum scriptnum4(num1);
|
|
|
|
|
2020-09-30 07:55:44 -07:00
|
|
|
if (addition_in_range(num1, num2))
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + scriptnum2));
|
|
|
|
BOOST_CHECK(verify(bignum1 + bignum2, scriptnum1 + num2));
|
|
|
|
BOOST_CHECK(verify(bignum1 + bignum2, scriptnum2 + num1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckNegate(int64_t num)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
const CScriptNum10 bignum(num);
|
2014-04-21 21:11:39 -07:00
|
|
|
const CScriptNum scriptnum(num);
|
|
|
|
|
2020-09-30 07:55:44 -07:00
|
|
|
BOOST_CHECK(verify(-bignum, -scriptnum));
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckSubtract(int64_t num1, int64_t num2)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
const CScriptNum10 bignum1(num1);
|
|
|
|
const CScriptNum10 bignum2(num2);
|
2014-04-21 21:11:39 -07:00
|
|
|
const CScriptNum scriptnum1(num1);
|
|
|
|
const CScriptNum scriptnum2(num2);
|
|
|
|
bool invalid = false;
|
|
|
|
|
2020-09-30 07:55:44 -07:00
|
|
|
if (subtraction_in_range(num1, num2))
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - scriptnum2));
|
|
|
|
BOOST_CHECK(verify(bignum1 - bignum2, scriptnum1 - num2));
|
|
|
|
}
|
|
|
|
|
2020-09-30 07:55:44 -07:00
|
|
|
if (subtraction_in_range(num2, num1))
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - scriptnum1));
|
|
|
|
BOOST_CHECK(verify(bignum2 - bignum1, scriptnum2 - num1));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void CheckCompare(int64_t num1, int64_t num2)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2015-11-25 04:19:48 -08:00
|
|
|
const CScriptNum10 bignum1(num1);
|
|
|
|
const CScriptNum10 bignum2(num2);
|
2014-04-21 21:11:39 -07:00
|
|
|
const CScriptNum scriptnum1(num1);
|
|
|
|
const CScriptNum scriptnum2(num2);
|
|
|
|
|
|
|
|
BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == scriptnum1));
|
2020-09-30 16:31:22 -07:00
|
|
|
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != scriptnum1));
|
|
|
|
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < scriptnum1));
|
|
|
|
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > scriptnum1));
|
|
|
|
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= scriptnum1));
|
|
|
|
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= scriptnum1));
|
2014-04-21 21:11:39 -07:00
|
|
|
|
|
|
|
BOOST_CHECK((bignum1 == bignum1) == (scriptnum1 == num1));
|
2020-09-30 16:31:22 -07:00
|
|
|
BOOST_CHECK((bignum1 != bignum1) == (scriptnum1 != num1));
|
|
|
|
BOOST_CHECK((bignum1 < bignum1) == (scriptnum1 < num1));
|
|
|
|
BOOST_CHECK((bignum1 > bignum1) == (scriptnum1 > num1));
|
|
|
|
BOOST_CHECK((bignum1 >= bignum1) == (scriptnum1 >= num1));
|
|
|
|
BOOST_CHECK((bignum1 <= bignum1) == (scriptnum1 <= num1));
|
|
|
|
|
|
|
|
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == scriptnum2));
|
|
|
|
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != scriptnum2));
|
|
|
|
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < scriptnum2));
|
|
|
|
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > scriptnum2));
|
|
|
|
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= scriptnum2));
|
|
|
|
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= scriptnum2));
|
|
|
|
|
|
|
|
BOOST_CHECK((bignum1 == bignum2) == (scriptnum1 == num2));
|
|
|
|
BOOST_CHECK((bignum1 != bignum2) == (scriptnum1 != num2));
|
|
|
|
BOOST_CHECK((bignum1 < bignum2) == (scriptnum1 < num2));
|
|
|
|
BOOST_CHECK((bignum1 > bignum2) == (scriptnum1 > num2));
|
|
|
|
BOOST_CHECK((bignum1 >= bignum2) == (scriptnum1 >= num2));
|
|
|
|
BOOST_CHECK((bignum1 <= bignum2) == (scriptnum1 <= num2));
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void RunCreate(int64_t num)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
CheckCreateInt(num);
|
|
|
|
CScriptNum scriptnum(num);
|
2014-09-28 22:00:01 -07:00
|
|
|
if (scriptnum.getvch().size() <= CScriptNum::nDefaultMaxNumSize)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2020-09-30 16:31:22 -07:00
|
|
|
CheckCreateVch(num);
|
|
|
|
} else {
|
|
|
|
BOOST_CHECK_THROW(CheckCreateVch(num), scriptnum10_error);
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-09-30 16:23:59 -07:00
|
|
|
static void RunOperators(int64_t num1, int64_t num2)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
|
|
|
CheckAdd(num1, num2);
|
|
|
|
CheckSubtract(num1, num2);
|
|
|
|
CheckNegate(num1);
|
|
|
|
CheckCompare(num1, num2);
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(creation)
|
|
|
|
{
|
2020-09-30 16:31:22 -07:00
|
|
|
for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2020-09-30 16:31:22 -07:00
|
|
|
for (size_t j = 0; j < sizeof(offsets) / sizeof(offsets[0]); ++j)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2020-09-30 07:55:44 -07:00
|
|
|
if (value_in_range(values[i])) {
|
|
|
|
RunCreate(values[i]);
|
|
|
|
}
|
|
|
|
if (addition_in_range(values[i], offsets[j])) {
|
|
|
|
RunCreate(values[i] + offsets[j]);
|
|
|
|
}
|
|
|
|
if (subtraction_in_range(values[i], offsets[j])) {
|
|
|
|
RunCreate(values[i] - offsets[j]);
|
|
|
|
}
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
BOOST_AUTO_TEST_CASE(operators)
|
|
|
|
{
|
2020-09-30 16:31:22 -07:00
|
|
|
for (size_t i = 0; i < sizeof(values) / sizeof(values[0]); ++i)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2020-09-30 07:55:44 -07:00
|
|
|
for (size_t j = 0; j < sizeof(values) / sizeof(values[0]); ++j)
|
2014-04-21 21:11:39 -07:00
|
|
|
{
|
2020-09-30 07:55:44 -07:00
|
|
|
if (value_in_range(values[i]))
|
|
|
|
{
|
|
|
|
RunOperators(values[i], values[i]);
|
|
|
|
RunOperators(values[i], -values[i]);
|
|
|
|
}
|
|
|
|
if (value_in_range(values[i]) && value_in_range(values[j]))
|
|
|
|
{
|
|
|
|
RunOperators(values[i], values[j]);
|
|
|
|
RunOperators(values[i], -values[j]);
|
|
|
|
}
|
|
|
|
if (addition_in_range(values[i], values[j]) && value_in_range(values[j]))
|
|
|
|
{
|
|
|
|
RunOperators(values[i] + values[j], values[j]);
|
|
|
|
RunOperators(values[i] + values[j], -values[j]);
|
|
|
|
RunOperators(values[i] + values[j], values[i] + values[j]);
|
|
|
|
}
|
|
|
|
if (subtraction_in_range(values[i], values[j]) && value_in_range(values[j]))
|
|
|
|
{
|
|
|
|
RunOperators(values[i] - values[j], values[j]);
|
|
|
|
RunOperators(values[i] - values[j], -values[j]);
|
|
|
|
RunOperators(values[i] - values[j], values[i] - values[j]);
|
|
|
|
}
|
|
|
|
if (addition_in_range(values[i], values[j]) && subtraction_in_range(values[i], values[j]))
|
|
|
|
{
|
|
|
|
RunOperators(values[i] + values[j], values[i] - values[j]);
|
|
|
|
RunOperators(values[i] - values[j], values[i] + values[j]);
|
|
|
|
}
|
2014-04-21 21:11:39 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-04-14 16:07:19 -07:00
|
|
|
BOOST_AUTO_TEST_CASE(intmin)
|
|
|
|
{
|
|
|
|
// INT64_MIN encodes to the buggy encoding.
|
|
|
|
const CScriptNum sn(INT64_MIN);
|
|
|
|
std::vector<unsigned char> buggy_int64_min_encoding = {0, 0, 0, 0, 0, 0, 0, 128, 128};
|
|
|
|
BOOST_CHECK(sn.getvch() == buggy_int64_min_encoding);
|
|
|
|
|
|
|
|
// The buggy INT64_MIN encoding decodes correctly.
|
|
|
|
const CScriptNum sn2(buggy_int64_min_encoding, true, 9);
|
|
|
|
BOOST_CHECK(sn2 == INT64_MIN);
|
|
|
|
BOOST_CHECK(sn2.getvch() == buggy_int64_min_encoding);
|
|
|
|
// getint() saturates at the min/max value of the int type
|
|
|
|
BOOST_CHECK((sn2.getint()) == std::numeric_limits<int>::min());
|
|
|
|
|
|
|
|
// Should throw for any other 9+ byte encoding.
|
|
|
|
std::vector<unsigned char> invalid_nine_bytes = {0, 0, 0, 0, 0, 0, 0, 0, 0};
|
|
|
|
BOOST_CHECK_THROW (CScriptNum sn3(invalid_nine_bytes, false, 9), scriptnum_error);
|
|
|
|
}
|
|
|
|
|
2014-04-21 21:11:39 -07:00
|
|
|
BOOST_AUTO_TEST_SUITE_END()
|