upgrade test_bdecode to use the new bdecode API
This commit is contained in:
arvidn
Arvid Norberg
parent
68f05d6380
commit
7444c12c6c
|
|
@ -40,10 +40,9 @@ using namespace lt;
|
|||
TORRENT_TEST(integer)
|
||||
{
|
||||
char b[] = "i12453e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
span<const char> section = e.data_section();
|
||||
TEST_CHECK(std::memcmp(b, section.data(), section.size()) == 0);
|
||||
|
|
@ -81,10 +80,9 @@ TORRENT_TEST(construct_integer)
|
|||
TORRENT_TEST(string)
|
||||
{
|
||||
char b[] = "26:abcdefghijklmnopqrstuvwxyz";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
span<const char> section = e.data_section();
|
||||
TEST_CHECK(std::memcmp(b, section.data(), section.size()) == 0);
|
||||
|
|
@ -102,10 +100,9 @@ TORRENT_TEST(string_prefix1)
|
|||
test.resize(1000000 + 8);
|
||||
memcpy(&test[0], "1000000:", 8);
|
||||
// test is a valid bencoded string, that's quite long
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(test.c_str(), test.c_str() + test.size(), e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(test, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%d bytes string\n", e.string_length());
|
||||
span<const char> section = e.data_section();
|
||||
TEST_CHECK(std::memcmp(test.c_str(), section.data(), section.size()) == 0);
|
||||
|
|
@ -119,10 +116,9 @@ TORRENT_TEST(string_prefix1)
|
|||
TORRENT_TEST(list)
|
||||
{
|
||||
char b[] = "li12453e3:aaae";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
span<const char> section = e.data_section();
|
||||
TEST_CHECK(std::memcmp(b, section.data(), section.size()) == 0);
|
||||
|
|
@ -143,10 +139,9 @@ TORRENT_TEST(list)
|
|||
TORRENT_TEST(dict)
|
||||
{
|
||||
char b[] = "d1:ai12453e1:b3:aaa1:c3:bbb1:X10:0123456789e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
span<const char> section = e.data_section();
|
||||
TEST_CHECK(std::memcmp(b, section.data(), section.size()) == 0);
|
||||
|
|
@ -171,11 +166,9 @@ TORRENT_TEST(dict)
|
|||
TORRENT_TEST(dict_key_novalue)
|
||||
{
|
||||
char b[] = "d1:ai1e1:be";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 10);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_value));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -185,11 +178,9 @@ TORRENT_TEST(dict_key_novalue)
|
|||
TORRENT_TEST(dict_nonstring_key)
|
||||
{
|
||||
char b[] = "di5e1:ae";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 1);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -199,10 +190,8 @@ TORRENT_TEST(dict_nonstring_key)
|
|||
TORRENT_TEST(dict_null_key)
|
||||
{
|
||||
char b[] = "d3:a\0bi1ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(e.dict_size() == 1);
|
||||
bdecode_node d = e.dict_find(std::string("a\0b", 3));
|
||||
TEST_EQUAL(d.type(), bdecode_node::int_t);
|
||||
|
|
@ -215,46 +204,36 @@ TORRENT_TEST(dict_unordered_keys)
|
|||
char error_string[200];
|
||||
{
|
||||
char b[] = "d2:abi1e2:aai2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("unsorted dictionary key"));
|
||||
}
|
||||
{
|
||||
char b[] = "d2:bai1e2:aai2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("unsorted dictionary key"));
|
||||
}
|
||||
{
|
||||
char b[] = "d2:aai1e1:ai2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("unsorted dictionary key"));
|
||||
}
|
||||
{
|
||||
char b[] = "d1:ai1e2:aai2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("unsorted dictionary key"));
|
||||
}
|
||||
{
|
||||
char b[] = "d2:aai1e1:bi2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("unsorted dictionary key"));
|
||||
}
|
||||
|
|
@ -263,10 +242,8 @@ TORRENT_TEST(dict_unordered_keys)
|
|||
TORRENT_TEST(dict_duplicate_key)
|
||||
{
|
||||
char b[] = "d2:aai1e2:aai2ee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
char error_string[200];
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("duplicate dictionary key"));
|
||||
|
|
@ -276,10 +253,8 @@ TORRENT_TEST(dict_duplicate_key)
|
|||
TORRENT_TEST(premature_e)
|
||||
{
|
||||
char b[] = "e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
}
|
||||
|
|
@ -288,11 +263,9 @@ TORRENT_TEST(premature_e)
|
|||
TORRENT_TEST(negative_length_prefix)
|
||||
{
|
||||
char b[] = "-10:foobar";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 0);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_value));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -302,11 +275,9 @@ TORRENT_TEST(negative_length_prefix)
|
|||
TORRENT_TEST(overflow_length_prefix)
|
||||
{
|
||||
char b[] = "18446744073709551615:foobar";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 19);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::overflow));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -316,11 +287,9 @@ TORRENT_TEST(overflow_length_prefix)
|
|||
TORRENT_TEST(close_overflow_length_prefix)
|
||||
{
|
||||
char b[] = "99999999:foobar";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 8);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -330,12 +299,10 @@ TORRENT_TEST(close_overflow_length_prefix)
|
|||
TORRENT_TEST(overflow_length_prefix2)
|
||||
{
|
||||
char b[] = "199999999:foobar";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
// pretend that we have a large buffer like that
|
||||
int ret = bdecode(b, b + 999999999, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 999999999}, ec, &pos);
|
||||
TEST_EQUAL(pos, 0);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::limit_exceeded));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -345,11 +312,9 @@ TORRENT_TEST(leading_zero_length_prefix)
|
|||
{
|
||||
{
|
||||
char b[] = "06:foobar";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
char error_string[200];
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("leading zero in string length"));
|
||||
|
|
@ -357,11 +322,9 @@ TORRENT_TEST(leading_zero_length_prefix)
|
|||
}
|
||||
{
|
||||
char b[] = "0:";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
char error_string[200];
|
||||
TEST_CHECK(!e.has_soft_error(error_string));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -372,11 +335,9 @@ TORRENT_TEST(leading_zero_length_prefix)
|
|||
TORRENT_TEST(nodigit_int)
|
||||
{
|
||||
char b[] = "ie";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 1);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -386,11 +347,9 @@ TORRENT_TEST(nodigit_int)
|
|||
TORRENT_TEST(minus_int)
|
||||
{
|
||||
char b[] = "i-e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 2);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -400,11 +359,9 @@ TORRENT_TEST(minus_int)
|
|||
TORRENT_TEST(interior_minus_int)
|
||||
{
|
||||
char b[] = "i35412-5633e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 6);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -414,10 +371,8 @@ TORRENT_TEST(interior_minus_int)
|
|||
TORRENT_TEST(int_overflow)
|
||||
{
|
||||
char b[] = "i18446744073709551615e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
// the lazy aspect makes this overflow when asking for
|
||||
// the value. turning it to zero.
|
||||
|
|
@ -428,11 +383,9 @@ TORRENT_TEST(int_overflow)
|
|||
TORRENT_TEST(int_overflow2)
|
||||
{
|
||||
char b[] = "i184467440737095516154e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 22);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::overflow));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -442,11 +395,9 @@ TORRENT_TEST(int_overflow2)
|
|||
TORRENT_TEST(int_truncated)
|
||||
{
|
||||
char b[] = "i-";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 2}, ec, &pos);
|
||||
TEST_EQUAL(pos, 2);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -456,10 +407,8 @@ TORRENT_TEST(int_leading_zero)
|
|||
{
|
||||
{
|
||||
char b[] = "i01e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
char error_string[200];
|
||||
TEST_CHECK(e.has_soft_error(error_string));
|
||||
TEST_EQUAL(std::string(error_string), std::string("leading zero in integer"));
|
||||
|
|
@ -467,10 +416,8 @@ TORRENT_TEST(int_leading_zero)
|
|||
}
|
||||
{
|
||||
char b[] = "i0e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b) - 1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
char error_string[200];
|
||||
TEST_CHECK(!e.has_soft_error(error_string));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -491,10 +438,8 @@ TORRENT_TEST(bdecode_error)
|
|||
TORRENT_TEST(64bit_int)
|
||||
{
|
||||
char b[] = "i9223372036854775807e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
TEST_CHECK(e.int_value() == 9223372036854775807LL);
|
||||
}
|
||||
|
|
@ -503,10 +448,8 @@ TORRENT_TEST(64bit_int)
|
|||
TORRENT_TEST(64bit_int_negative)
|
||||
{
|
||||
char b[] = "i-9223372036854775807e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
TEST_CHECK(e.int_value() == -9223372036854775807LL);
|
||||
}
|
||||
|
|
@ -515,11 +458,9 @@ TORRENT_TEST(64bit_int_negative)
|
|||
TORRENT_TEST(int_invalid_digit)
|
||||
{
|
||||
char b[] = "i92337203t854775807e";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos = 0;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 9);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -544,10 +485,9 @@ TORRENT_TEST(invalid_encoding)
|
|||
, 0x79, 0x31, 0xae, 0x71, 0x65, 0};
|
||||
|
||||
std::printf("%s\n", buf);
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode((char*)buf, (char*)buf + sizeof(buf), e, ec);
|
||||
TEST_CHECK(ret == -1);
|
||||
bdecode_node e = bdecode({reinterpret_cast<char const*>(buf), sizeof(buf)}, ec);
|
||||
TEST_CHECK(ec);
|
||||
}
|
||||
|
||||
// test the depth limit
|
||||
|
|
@ -562,10 +502,8 @@ TORRENT_TEST(depth_limit)
|
|||
|
||||
// 1024 levels nested lists
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b), e, ec, nullptr, 100);
|
||||
TEST_CHECK(ret != 0);
|
||||
bdecode_node e = bdecode({b, sizeof(b)}, ec, nullptr, 100);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::depth_exceeded));
|
||||
}
|
||||
|
||||
|
|
@ -574,15 +512,13 @@ TORRENT_TEST(item_limit)
|
|||
{
|
||||
char b[10240];
|
||||
b[0] = 'l';
|
||||
int i = 1;
|
||||
std::size_t i = 1;
|
||||
for (i = 1; i < 10239; i += 2)
|
||||
memcpy(&b[i], "0:", 2);
|
||||
b[i] = 'e';
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + i + 1, e, ec, nullptr, 1000, 1000);
|
||||
TEST_CHECK(ret != 0);
|
||||
bdecode_node e = bdecode({b, i + 1}, ec, nullptr, 1000, 1000);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::limit_exceeded));
|
||||
}
|
||||
|
||||
|
|
@ -591,11 +527,9 @@ TORRENT_TEST(unepected_eof)
|
|||
{
|
||||
char b[] = "l2:.."; // expected terminating 'e'
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 5}, ec, &pos);
|
||||
TEST_EQUAL(pos, 5);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -606,11 +540,9 @@ TORRENT_TEST(unepected_eof2)
|
|||
{
|
||||
char b[] = "l2:..0"; // expected ':' delimiter instead of EOF
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 6}, ec, &pos);
|
||||
TEST_EQUAL(pos, 6);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -622,11 +554,9 @@ TORRENT_TEST(expected_string)
|
|||
char b[] = "di2ei0ee";
|
||||
// expected string (dict keys must be strings)
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 1);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -637,11 +567,9 @@ TORRENT_TEST(unexpected_eof_dict_key)
|
|||
{
|
||||
char b[] = "d1000:..e";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 5);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -652,11 +580,9 @@ TORRENT_TEST(unexpected_eof_dict_key2)
|
|||
{
|
||||
char b[] = "d1000:";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 5);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -667,11 +593,9 @@ TORRENT_TEST(expected_string_dict_key2)
|
|||
{
|
||||
char b[] = "df00:";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 1);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_digit));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -682,11 +606,9 @@ TORRENT_TEST(unexpected_eof_int)
|
|||
{
|
||||
char b[] = "i";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 1}, ec, &pos);
|
||||
TEST_EQUAL(pos, 1);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -697,11 +619,9 @@ TORRENT_TEST(unexpected_eof_int2)
|
|||
{
|
||||
char b[] = "i10";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 3}, ec, &pos);
|
||||
TEST_EQUAL(pos, 3);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -713,11 +633,9 @@ TORRENT_TEST(expected_colon_dict)
|
|||
{
|
||||
char b[] = "d1000";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 5}, ec, &pos);
|
||||
TEST_EQUAL(pos, 5);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::expected_colon));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -726,12 +644,8 @@ TORRENT_TEST(expected_colon_dict)
|
|||
// test empty string
|
||||
TORRENT_TEST(empty_string)
|
||||
{
|
||||
char b[] = "";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, nullptr);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({}, ec, nullptr);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
}
|
||||
|
|
@ -741,11 +655,9 @@ TORRENT_TEST(partial_string)
|
|||
{
|
||||
char b[] = "100:..";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 3);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
|
@ -763,10 +675,9 @@ TORRENT_TEST(list_ints)
|
|||
}
|
||||
buf += "e";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode((char*)&buf[0], (char*)&buf[0] + buf.size(), e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(buf, ec);
|
||||
TEST_CHECK(!ec);
|
||||
TEST_EQUAL(e.type(), bdecode_node::list_t);
|
||||
TEST_EQUAL(e.list_size(), 1000);
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
|
|
@ -788,10 +699,9 @@ TORRENT_TEST(dict_ints)
|
|||
buf += "e";
|
||||
|
||||
std::printf("%s\n", buf.c_str());
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode((char*)&buf[0], (char*)&buf[0] + buf.size(), e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(buf, ec);
|
||||
TEST_CHECK(!ec);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
TEST_EQUAL(e.dict_size(), 1000);
|
||||
for (int i = 0; i < 1000; ++i)
|
||||
|
|
@ -807,10 +717,9 @@ TORRENT_TEST(dict_at)
|
|||
{
|
||||
char b[] = "d3:fooi1e3:bari2ee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
TEST_EQUAL(e.dict_size(), 2);
|
||||
|
|
@ -827,10 +736,9 @@ TORRENT_TEST(string_ptr)
|
|||
{
|
||||
char b[] = "l3:fooe";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::list_t);
|
||||
TEST_EQUAL(e.list_size(), 1);
|
||||
|
|
@ -844,10 +752,8 @@ TORRENT_TEST(exceed_buf_limit)
|
|||
{
|
||||
char b[] = "l3:fooe";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + 0x3fffffff, e, ec);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, 0x3fffffff}, ec);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::limit_exceeded));
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
}
|
||||
|
|
@ -899,9 +805,7 @@ TORRENT_TEST(parse_length_overflow)
|
|||
for (int i = 0; i < int(sizeof(b)/sizeof(b[0])); ++i)
|
||||
{
|
||||
error_code ec;
|
||||
bdecode_node e;
|
||||
int ret = bdecode(b[i], b[i] + strlen(b[i]), e, ec);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b[i], strlen(b[i])}, ec);
|
||||
TEST_EQUAL(ec, error_code(bdecode_errors::unexpected_eof));
|
||||
}
|
||||
}
|
||||
|
|
@ -925,10 +829,9 @@ TORRENT_TEST(dict_find_funs)
|
|||
// c: list
|
||||
// d: dict
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
|
@ -994,10 +897,9 @@ TORRENT_TEST(list_at_funs)
|
|||
// list
|
||||
// dict
|
||||
char b[] = "li1e3:fooli1ei2eed1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::list_t);
|
||||
|
|
@ -1032,10 +934,9 @@ TORRENT_TEST(list_at_reverse)
|
|||
// list
|
||||
// dict
|
||||
char b[] = "li1e3:fooli1ei2eed1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::list_t);
|
||||
|
|
@ -1058,10 +959,9 @@ TORRENT_TEST(dict_find_funs2)
|
|||
// c: list
|
||||
// d: dict
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
|
@ -1076,10 +976,9 @@ TORRENT_TEST(dict_find_funs2)
|
|||
TORRENT_TEST(print_entry)
|
||||
{
|
||||
char b[] = "li1e3:fooli1ei2eed1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(print_entry(e), "[ 1, 'foo', [ 1, 2 ], { 'x': 1 } ]");
|
||||
|
|
@ -1088,10 +987,9 @@ TORRENT_TEST(print_entry)
|
|||
TORRENT_TEST(print_entry2)
|
||||
{
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e = bdecode(b, ec);
|
||||
TEST_CHECK(!ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
|
||||
TEST_EQUAL(print_entry(e), "{ 'a': 1, 'b': 'foo', 'c': [ 1, 2 ], 'd': { 'x': 1 } }");
|
||||
|
|
@ -1103,15 +1001,12 @@ TORRENT_TEST(swap)
|
|||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
char b2[] = "i1e";
|
||||
|
||||
bdecode_node e1;
|
||||
bdecode_node e2;
|
||||
|
||||
error_code ec;
|
||||
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
ret = bdecode(b2, b2 + sizeof(b2)-1, e2, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e1 = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
bdecode_node e2 = bdecode({b2, sizeof(b2)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
std::string str1 = print_entry(e1);
|
||||
std::string str2 = print_entry(e2);
|
||||
|
|
@ -1141,15 +1036,12 @@ TORRENT_TEST(swap_root)
|
|||
{
|
||||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e1;
|
||||
bdecode_node e2;
|
||||
|
||||
error_code ec;
|
||||
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e1 = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
e2 = e1.dict_find("c").list_at(0);
|
||||
bdecode_node e2 = e1.dict_find("c").list_at(0);
|
||||
|
||||
std::string str1 = print_entry(e1);
|
||||
std::string str2 = print_entry(e2);
|
||||
|
|
@ -1181,15 +1073,13 @@ TORRENT_TEST(swap_disjoint)
|
|||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
char b2[] = "li1e3:fooli1ei2eed1:xi1eee";
|
||||
|
||||
bdecode_node e1_root;
|
||||
bdecode_node e2_root;
|
||||
|
||||
error_code ec;
|
||||
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1_root, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
ret = bdecode(b2, b2 + sizeof(b2)-1, e2_root, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e1_root = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
bdecode_node e2_root = bdecode({b2, sizeof(b2)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
bdecode_node e1 = e1_root.dict_find("c").list_at(0);
|
||||
bdecode_node e2 = e2_root.list_at(1);
|
||||
|
|
@ -1221,15 +1111,13 @@ TORRENT_TEST(swap_root_disjoint)
|
|||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
char b2[] = "li1e3:fooli1ei2eed1:xi1eee";
|
||||
|
||||
bdecode_node e1_root;
|
||||
bdecode_node e2;
|
||||
|
||||
error_code ec;
|
||||
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1_root, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
ret = bdecode(b2, b2 + sizeof(b2)-1, e2, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e1_root = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
bdecode_node e2 = bdecode({b2, sizeof(b2)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
bdecode_node e1 = e1_root.dict_find("d");
|
||||
|
||||
|
|
@ -1260,18 +1148,17 @@ TORRENT_TEST(clear)
|
|||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
char b2[] = "li1ei2ee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e, ec);
|
||||
bdecode_node e = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
TEST_EQUAL(ret, 0);
|
||||
TEST_CHECK(!ec);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
TEST_EQUAL(e.dict_size(), 4);
|
||||
TEST_EQUAL(e.dict_at(1).first, "b");
|
||||
|
||||
ret = bdecode(b2, b2 + sizeof(b2)-1, e, ec);
|
||||
e = bdecode({b2, sizeof(b2)-1}, ec);
|
||||
std::printf("%s\n", print_entry(e).c_str());
|
||||
TEST_EQUAL(ret, 0);
|
||||
TEST_CHECK(!ec);
|
||||
TEST_EQUAL(e.type(), bdecode_node::list_t);
|
||||
TEST_EQUAL(e.list_size(), 2);
|
||||
TEST_EQUAL(e.list_int_value_at(1), 2);
|
||||
|
|
@ -1282,10 +1169,9 @@ TORRENT_TEST(copy_root)
|
|||
{
|
||||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e1;
|
||||
error_code ec;
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1, ec);
|
||||
TEST_EQUAL(ret, 0);
|
||||
bdecode_node e1 = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
TEST_EQUAL(e1.type(), bdecode_node::dict_t);
|
||||
std::printf("%s\n", print_entry(e1).c_str());
|
||||
|
||||
|
|
@ -1309,11 +1195,10 @@ TORRENT_TEST(non_owning_refs)
|
|||
{
|
||||
char b1[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e1;
|
||||
error_code ec;
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e1, ec);
|
||||
bdecode_node e1 = bdecode({b1, sizeof(b1)-1}, ec);
|
||||
TEST_CHECK(!ec);
|
||||
|
||||
TEST_EQUAL(ret, 0);
|
||||
TEST_EQUAL(e1.type(), bdecode_node::dict_t);
|
||||
std::printf("%s\n", print_entry(e1).c_str());
|
||||
|
||||
|
|
@ -1332,11 +1217,9 @@ TORRENT_TEST(partial_parse)
|
|||
{
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:dd1:xi1-eee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 35);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
||||
|
|
@ -1349,11 +1232,9 @@ TORRENT_TEST(partial_parse2)
|
|||
{
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee1:d-d1:xi1eee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 29);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
||||
|
|
@ -1366,11 +1247,9 @@ TORRENT_TEST(partial_parse3)
|
|||
{
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1ei2ee-1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 26);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
||||
|
|
@ -1383,11 +1262,9 @@ TORRENT_TEST(partial_parse4)
|
|||
{
|
||||
char b[] = "d1:ai1e1:b3:foo1:cli1e-i2ee1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode(b, ec, &pos);
|
||||
TEST_EQUAL(pos, 22);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
||||
|
|
@ -1403,11 +1280,10 @@ TORRENT_TEST(partial_parse_string)
|
|||
// end
|
||||
char b[] = { '5', '5'};
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b, b + sizeof(b), e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b, sizeof(b)}, ec, &pos);
|
||||
TEST_CHECK(ec);
|
||||
TEST_EQUAL(pos, 2);
|
||||
}
|
||||
|
||||
|
|
@ -1417,11 +1293,9 @@ TORRENT_TEST(switch_buffer)
|
|||
char b1[] = "d1:ai1e1:b3:foo1:cli1e-i2ee1:dd1:xi1eee";
|
||||
char b2[] = "d1:ai1e1:b3:foo1:cli1e-i2ee1:dd1:xi1eee";
|
||||
|
||||
bdecode_node e;
|
||||
error_code ec;
|
||||
int pos;
|
||||
int ret = bdecode(b1, b1 + sizeof(b1)-1, e, ec, &pos);
|
||||
TEST_EQUAL(ret, -1);
|
||||
bdecode_node e = bdecode({b1, sizeof(b1)-1}, ec, &pos);
|
||||
TEST_EQUAL(pos, 22);
|
||||
TEST_EQUAL(e.type(), bdecode_node::dict_t);
|
||||
|
||||
|
|
|
|||
Loading…
Reference in New Issue