Page MenuHomePhabricator
Differential D1638 Diff 4547 src/test/opcode_tests.cpp

Changeset View

Standalone View

View Options

src/test/opcode_tests.cpp

Show All 24 Lines
static void CheckTestResultForAllFlags(const stacktype &original_stack, static void CheckTestResultForAllFlags(const stacktype &original_stack,
const CScript &script, const CScript &script,
const stacktype &expected) { const stacktype &expected) {
BaseSignatureChecker sigchecker; BaseSignatureChecker sigchecker;
for (uint32_t flags : flagset) { for (uint32_t flags : flagset) {
ScriptError err = SCRIPT_ERR_OK; ScriptError err = SCRIPT_ERR_OK;
stacktype stack{original_stack}; stacktype stack{original_stack};
bool r = EvalScript(stack, script, flags, sigchecker, &err); bool r =
EvalScript(stack, script, flags | SCRIPT_ENABLE_MAGNETIC_OPCODES,
sigchecker, &err);
BOOST_CHECK(r); BOOST_CHECK(r);
BOOST_CHECK(stack == expected); BOOST_CHECK(stack == expected);
} }
} }
static void CheckError(uint32_t flags, const stacktype &original_stack, static void CheckError(uint32_t flags, const stacktype &original_stack,
const CScript &script, ScriptError expected_error) { const CScript &script, ScriptError expected_error) {
BaseSignatureChecker sigchecker; BaseSignatureChecker sigchecker;
ScriptError err = SCRIPT_ERR_OK; ScriptError err = SCRIPT_ERR_OK;
stacktype stack{original_stack}; stacktype stack{original_stack};
bool r = EvalScript(stack, script, flags, sigchecker, &err); bool r = EvalScript(stack, script, flags | SCRIPT_ENABLE_MAGNETIC_OPCODES,
sigchecker, &err);
BOOST_CHECK(!r); BOOST_CHECK(!r);
BOOST_CHECK_EQUAL(err, expected_error); BOOST_CHECK_EQUAL(err, expected_error);
} }
static void CheckErrorForAllFlags(const stacktype &original_stack, static void CheckErrorForAllFlags(const stacktype &original_stack,
const CScript &script, const CScript &script,
ScriptError expected_error) { ScriptError expected_error) {
for (uint32_t flags : flagset) { for (uint32_t flags : flagset) {
Show All 22 Linesstatic valtype NegativeValtype(const valtype &v) {
valtype r(v); valtype r(v);
if (r.size() > 0) { if (r.size() > 0) {
r[r.size() - 1] ^= 0x80; r[r.size() - 1] ^= 0x80;
} }
CScriptNum::MinimallyEncode(r); CScriptNum::MinimallyEncode(r);
return r; return r;
} }
// Expects str to contain 8*n bits.
static valtype to_bitpattern(const char *str) {
size_t len = strlen(str);
valtype val((len - 1) / 8 + 1, 0);
const char *pin = &str[len - 1];
for (size_t i = 0; i < len; i++) {
int byte_idx = i / 8;
int bit_idx = i % 8;
int8_t mask = 1 << bit_idx;
if (*pin == '0') {
val[byte_idx] &= ~mask;
} else {
val[byte_idx] |= mask;
}
pin--;
}
return val;
}
BOOST_AUTO_TEST_CASE(negative_valtype_test) { BOOST_AUTO_TEST_CASE(negative_valtype_test) {
// Test zero values // Test zero values
BOOST_CHECK(NegativeValtype({}) == valtype{}); BOOST_CHECK(NegativeValtype({}) == valtype{});
BOOST_CHECK(NegativeValtype({0x00}) == valtype{}); BOOST_CHECK(NegativeValtype({0x00}) == valtype{});
BOOST_CHECK(NegativeValtype({0x80}) == valtype{}); BOOST_CHECK(NegativeValtype({0x80}) == valtype{});
BOOST_CHECK(NegativeValtype({0x00, 0x00}) == valtype{}); BOOST_CHECK(NegativeValtype({0x00, 0x00}) == valtype{});
BOOST_CHECK(NegativeValtype({0x00, 0x80}) == valtype{}); BOOST_CHECK(NegativeValtype({0x00, 0x80}) == valtype{});
▲ Show 20 Lines • Show All 296 Lines • ▼ Show 20 LinesBOOST_AUTO_TEST_CASE(bitwise_opcodes_test) {
CheckAllBitwiseOpErrors({{0x00}, {0xab, 0xcd, 0xef}}, CheckAllBitwiseOpErrors({{0x00}, {0xab, 0xcd, 0xef}},
SCRIPT_ERR_INVALID_OPERAND_SIZE); SCRIPT_ERR_INVALID_OPERAND_SIZE);
CheckAllBitwiseOpErrors({{0xab, 0xcd, 0xef}, {0x00}}, CheckAllBitwiseOpErrors({{0xab, 0xcd, 0xef}, {0x00}},
SCRIPT_ERR_INVALID_OPERAND_SIZE); SCRIPT_ERR_INVALID_OPERAND_SIZE);
CheckAllBitwiseOpErrors({{}, a}, SCRIPT_ERR_INVALID_OPERAND_SIZE); CheckAllBitwiseOpErrors({{}, a}, SCRIPT_ERR_INVALID_OPERAND_SIZE);
CheckAllBitwiseOpErrors({b, {}}, SCRIPT_ERR_INVALID_OPERAND_SIZE); CheckAllBitwiseOpErrors({b, {}}, SCRIPT_ERR_INVALID_OPERAND_SIZE);
} }
static void CheckShiftOp(const valtype &x, const valtype &n, opcodetype op,
const valtype &expected) {
CheckBinaryOp(x, n, op, expected);
}
BOOST_AUTO_TEST_CASE(lshift_test) {
CheckShiftOp({}, {}, OP_LSHIFT, {});
CheckShiftOp({}, {0x01}, OP_LSHIFT, {});
CheckShiftOp({}, {0x02}, OP_LSHIFT, {});
CheckShiftOp({}, {0x07}, OP_LSHIFT, {});
CheckShiftOp({}, {0x08}, OP_LSHIFT, {});
CheckShiftOp({}, {0x09}, OP_LSHIFT, {});
CheckShiftOp({}, {0x0F}, OP_LSHIFT, {});
CheckShiftOp({}, {0x10}, OP_LSHIFT, {});
CheckShiftOp({}, {0x11}, OP_LSHIFT, {});
CheckShiftOp({0xFF}, {}, OP_LSHIFT, to_bitpattern("11111111"));
CheckShiftOp({0xFF}, {0x01}, OP_LSHIFT, to_bitpattern("11111110"));
CheckShiftOp({0xFF}, {0x02}, OP_LSHIFT, to_bitpattern("11111100"));
CheckShiftOp({0xFF}, {0x03}, OP_LSHIFT, to_bitpattern("11111000"));
CheckShiftOp({0xFF}, {0x04}, OP_LSHIFT, to_bitpattern("11110000"));
CheckShiftOp({0xFF}, {0x05}, OP_LSHIFT, to_bitpattern("11100000"));
CheckShiftOp({0xFF}, {0x06}, OP_LSHIFT, to_bitpattern("11000000"));
CheckShiftOp({0xFF}, {0x07}, OP_LSHIFT, to_bitpattern("10000000"));
CheckShiftOp({0xFF}, {0x08}, OP_LSHIFT, to_bitpattern("00000000"));
CheckShiftOp({0xFF}, {0x01}, OP_LSHIFT, {0xFE});
CheckShiftOp({0xFF}, {0x02}, OP_LSHIFT, {0xFC});
CheckShiftOp({0xFF}, {0x03}, OP_LSHIFT, {0xF8});
CheckShiftOp({0xFF}, {0x04}, OP_LSHIFT, {0xF0});
CheckShiftOp({0xFF}, {0x05}, OP_LSHIFT, {0xE0});
CheckShiftOp({0xFF}, {0x06}, OP_LSHIFT, {0xC0});
CheckShiftOp({0xFF}, {0x07}, OP_LSHIFT, {0x80});
CheckShiftOp(
{0xFF}, {0x08}, OP_LSHIFT,
{0x00}); // bitpattern, not a number so not reduced to zero bytes
// valtype {0x9F, 0x11, 0xF5, 0x55} is a bit pattern
// "01010101111101010001000110011111"
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {}, OP_LSHIFT,
to_bitpattern("01010101111101010001000110011111"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x01}, OP_LSHIFT,
to_bitpattern("10101011111010100010001100111110"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x02}, OP_LSHIFT,
to_bitpattern("01010111110101000100011001111100"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x03}, OP_LSHIFT,
to_bitpattern("10101111101010001000110011111000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x04}, OP_LSHIFT,
to_bitpattern("01011111010100010001100111110000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x05}, OP_LSHIFT,
to_bitpattern("10111110101000100011001111100000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x06}, OP_LSHIFT,
to_bitpattern("01111101010001000110011111000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x07}, OP_LSHIFT,
to_bitpattern("11111010100010001100111110000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x08}, OP_LSHIFT,
to_bitpattern("11110101000100011001111100000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x09}, OP_LSHIFT,
to_bitpattern("11101010001000110011111000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0A}, OP_LSHIFT,
to_bitpattern("11010100010001100111110000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0B}, OP_LSHIFT,
to_bitpattern("10101000100011001111100000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0C}, OP_LSHIFT,
to_bitpattern("01010001000110011111000000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0D}, OP_LSHIFT,
to_bitpattern("10100010001100111110000000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0E}, OP_LSHIFT,
to_bitpattern("01000100011001111100000000000000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0F}, OP_LSHIFT,
to_bitpattern("10001000110011111000000000000000"));
CheckErrorForAllFlags({valtype{0x12, 0x34}},
CScript() << OP_1NEGATE << OP_LSHIFT,
SCRIPT_ERR_INVALID_NUMBER_RANGE);
}
BOOST_AUTO_TEST_CASE(rshift_test) {
CheckShiftOp({}, {}, OP_RSHIFT, {});
CheckShiftOp({}, {0x01}, OP_RSHIFT, {});
CheckShiftOp({}, {0x02}, OP_RSHIFT, {});
CheckShiftOp({}, {0x07}, OP_RSHIFT, {});
CheckShiftOp({}, {0x08}, OP_RSHIFT, {});
CheckShiftOp({}, {0x09}, OP_RSHIFT, {});
CheckShiftOp({}, {0x0F}, OP_RSHIFT, {});
CheckShiftOp({}, {0x10}, OP_RSHIFT, {});
CheckShiftOp({}, {0x11}, OP_RSHIFT, {});
CheckShiftOp({0xFF}, {}, OP_RSHIFT, to_bitpattern("11111111"));
CheckShiftOp({0xFF}, {0x01}, OP_RSHIFT, to_bitpattern("01111111"));
CheckShiftOp({0xFF}, {0x02}, OP_RSHIFT, to_bitpattern("00111111"));
CheckShiftOp({0xFF}, {0x03}, OP_RSHIFT, to_bitpattern("00011111"));
CheckShiftOp({0xFF}, {0x04}, OP_RSHIFT, to_bitpattern("00001111"));
CheckShiftOp({0xFF}, {0x05}, OP_RSHIFT, to_bitpattern("00000111"));
CheckShiftOp({0xFF}, {0x06}, OP_RSHIFT, to_bitpattern("00000011"));
CheckShiftOp({0xFF}, {0x07}, OP_RSHIFT, to_bitpattern("00000001"));
CheckShiftOp({0xFF}, {0x08}, OP_RSHIFT, to_bitpattern("00000000"));
CheckShiftOp({0xFF}, {0x01}, OP_RSHIFT, {0x7F});
CheckShiftOp({0xFF}, {0x02}, OP_RSHIFT, {0x3F});
CheckShiftOp({0xFF}, {0x03}, OP_RSHIFT, {0x1F});
CheckShiftOp({0xFF}, {0x04}, OP_RSHIFT, {0x0F});
CheckShiftOp({0xFF}, {0x05}, OP_RSHIFT, {0x07});
CheckShiftOp({0xFF}, {0x06}, OP_RSHIFT, {0x03});
CheckShiftOp({0xFF}, {0x07}, OP_RSHIFT, {0x01});
CheckShiftOp(
{0xFF}, {0x08}, OP_RSHIFT,
{0x00}); // bitpattern, not a number so not reduced to zero bytes
// valtype {0x9F, 0x11, 0xF5, 0x55} is a bit pattern
// "01010101111101010001000110011111"
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {}, OP_RSHIFT,
to_bitpattern("01010101111101010001000110011111"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x01}, OP_RSHIFT,
to_bitpattern("00101010111110101000100011001111"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x02}, OP_RSHIFT,
to_bitpattern("00010101011111010100010001100111"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x03}, OP_RSHIFT,
to_bitpattern("00001010101111101010001000110011"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x04}, OP_RSHIFT,
to_bitpattern("00000101010111110101000100011001"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x05}, OP_RSHIFT,
to_bitpattern("00000010101011111010100010001100"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x06}, OP_RSHIFT,
to_bitpattern("00000001010101111101010001000110"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x07}, OP_RSHIFT,
to_bitpattern("00000000101010111110101000100011"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x08}, OP_RSHIFT,
to_bitpattern("00000000010101011111010100010001"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x09}, OP_RSHIFT,
to_bitpattern("00000000001010101111101010001000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0A}, OP_RSHIFT,
to_bitpattern("00000000000101010111110101000100"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0B}, OP_RSHIFT,
to_bitpattern("00000000000010101011111010100010"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0C}, OP_RSHIFT,
to_bitpattern("00000000000001010101111101010001"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0D}, OP_RSHIFT,
to_bitpattern("00000000000000101010111110101000"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0E}, OP_RSHIFT,
to_bitpattern("00000000000000010101011111010100"));
CheckShiftOp({0x9F, 0x11, 0xF5, 0x55}, {0x0F}, OP_RSHIFT,
to_bitpattern("00000000000000001010101111101010"));
CheckErrorForAllFlags({valtype{0x12, 0x34}},
CScript() << OP_1NEGATE << OP_RSHIFT,
SCRIPT_ERR_INVALID_NUMBER_RANGE);
}
/** /**
* String opcodes. * String opcodes.
*/ */
static void CheckStringOp(const valtype &a, const valtype &b, static void CheckStringOp(const valtype &a, const valtype &b,
const valtype &n) { const valtype &n) {
CheckBinaryOp(a, b, OP_CAT, n); CheckBinaryOp(a, b, OP_CAT, n);
// Check concatenation with empty elements. // Check concatenation with empty elements.
▲ Show 20 Lines • Show All 370 Lines • Show Last 20 Lines