void
test_composition ()
{
testcase ("composition");
STAmount const amount1 (noIssue(), 231);
STAmount const amount2 (noIssue(), 462);
STAmount const amount3 (noIssue(), 924);
Quality const q11 (Amounts (amount1, amount1));
Quality const q12 (Amounts (amount1, amount2));
Quality const q13 (Amounts (amount1, amount3));
Quality const q21 (Amounts (amount2, amount1));
Quality const q31 (Amounts (amount3, amount1));
BEAST_EXPECT(
composed_quality (q12, q21) == q11);
Quality const q13_31 (
composed_quality (q13, q31));
Quality const q31_13 (
composed_quality (q31, q13));
BEAST_EXPECT(q13_31 == q31_13);
BEAST_EXPECT(q13_31 == q11);
}
void testThreads(int const threadCount)
{
testcase("threadCount = " + std::to_string(threadCount));
TestCallback cb(threadCount);
Workers w(cb, "Test", 0);
BEAST_EXPECT(w.getNumberOfThreads() == 0);
w.setNumberOfThreads(threadCount);
BEAST_EXPECT(w.getNumberOfThreads() == threadCount);
for (int i = 0; i < threadCount; ++i)
w.addTask();
// 10 seconds should be enough to finish on any system
//
bool signaled = cb.finished.wait(10 * 1000);
BEAST_EXPECT(signaled);
w.pauseAllThreadsAndWait();
// We had better finished all our work!
BEAST_EXPECT(cb.count.load() == 0);
}
void test_compact ()
{
Json::Value j;
Json::Reader r;
char const* s ("{\"array\":[{\"12\":23},{},null,false,0.5]}");
auto countLines = [](std::string const & s)
{
return 1 + std::count_if(s.begin(), s.end(), [](char c){
return c == '\n';
});
};
BEAST_EXPECT(r.parse(s,j));
{
std::stringstream ss;
ss << j;
BEAST_EXPECT(countLines(ss.str()) > 1);
}
{
std::stringstream ss;
ss << Json::Compact(std::move(j));
BEAST_EXPECT(countLines(ss.str()) == 1);
}
}
void testConstruction ()
{
testcase ("construction");
{
std::uint8_t src[16];
for (std::uint8_t i = 0; i < 64; i++)
{
beast::rngfill (
src,
sizeof(src),
default_prng());
Seed const seed ( {
src, sizeof(src)
});
BEAST_EXPECT(memcmp (seed.data(), src, sizeof(src)) == 0);
}
}
for (int i = 0; i < 64; i++)
{
uint128 src;
beast::rngfill (
src.data(),
src.size(),
default_prng());
Seed const seed (src);
BEAST_EXPECT(memcmp (seed.data(), src.data(), src.size()) == 0);
}
}
void run ()
{
try
{
Throw<std::runtime_error>("Throw test");
}
catch (std::runtime_error const& e)
{
BEAST_EXPECT(std::string(e.what()) == "Throw test");
try
{
Rethrow();
}
catch (std::runtime_error const& e)
{
BEAST_EXPECT(std::string(e.what()) == "Throw test");
}
catch (...)
{
BEAST_EXPECT(false);
}
}
catch (...)
{
BEAST_EXPECT(false);
}
}
std::string testPassphrase(std::string passphrase)
{
auto const seed1 = generateSeed (passphrase);
auto const seed2 = parseBase58<Seed>(toBase58(seed1));
BEAST_EXPECT(static_cast<bool>(seed2));
BEAST_EXPECT(equal (seed1, *seed2));
return toBase58(seed1);
}
void testKeySize ()
{
testcase ("Key Sizes");
RsaSha256 f1;
BEAST_EXPECT (!f1.sign (longKey, makeSlice (knownMessage)));
RsaSha256 f2;
BEAST_EXPECT (!f2.sign (shortKey, makeSlice (knownMessage)));
}
void testPassphrase()
{
testcase ("generation from passphrase");
BEAST_EXPECT(testPassphrase ("masterpassphrase") ==
"snoPBrXtMeMyMHUVTgbuqAfg1SUTb");
BEAST_EXPECT(testPassphrase ("Non-Random Passphrase") ==
"snMKnVku798EnBwUfxeSD8953sLYA");
BEAST_EXPECT(testPassphrase ("cookies excitement hand public") ==
"sspUXGrmjQhq6mgc24jiRuevZiwKT");
}
void check(char const* name, error ev)
{
auto const ec = make_error_code(ev);
BEAST_EXPECT(std::string{ec.category().name()} == name);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(std::addressof(ec.category()) ==
std::addressof(nudb_category()));
BEAST_EXPECT(nudb_category().equivalent(static_cast<int>(ev),
ec.category().default_error_condition(static_cast<int>(ev))));
BEAST_EXPECT(nudb_category().equivalent(
ec, static_cast<int>(ev)));
}
void testRandom()
{
testcase ("random generation");
for (int i = 0; i < 32; i++)
{
auto const seed1 = randomSeed ();
auto const seed2 = parseBase58<Seed>(toBase58(seed1));
BEAST_EXPECT(static_cast<bool>(seed2));
BEAST_EXPECT(equal (seed1, *seed2));
}
}
void run() override
{
std::string const s =
"HTTP/1.1 200 OK\r\n"
"Server: test\r\n"
"Content-Length: 3\r\n"
"\r\n"
"xyz";
test::string_istream ss(ios_, s);
parser_v1<false, streambuf_body, fields> p;
streambuf sb;
parse(ss, sb, p);
BEAST_EXPECT(to_string(p.get().body.data()) == "xyz");
BEAST_EXPECT(boost::lexical_cast<std::string>(p.get()) == s);
}
void run()
{
{
boost::system::error_code ec =
boost::system::error_code (335544539,
boost::asio::error::get_ssl_category ());
std::string const s = beast::error_message_with_ssl(ec);
#ifdef SSL_R_SHORT_READ
BEAST_EXPECT(s == " (20,0,219) error:140000DB:SSL routines:SSL routines:short read");
#else
BEAST_EXPECT(s == " (20,0,219) error:140000DB:SSL routines:SSL routines:reason(219)");
#endif
}
}
void test(
RCLCensorshipDetector<int, int>& cdet, int round,
std::vector<int> proposed, std::vector<int> accepted,
std::vector<int> remain, std::vector<int> remove)
{
// Begin tracking what we're proposing this round
cdet.propose(round, std::move(proposed));
// Finalize the round, by processing what we accepted; then
// remove anything that needs to be removed and ensure that
// what remains is correct.
cdet.check(std::move(accepted),
[&remove, &remain](auto id, auto seq)
{
// If the item is supposed to be removed from the censorship
// detector internal tracker manually, do it now:
if (std::find(remove.begin(), remove.end(), id) != remove.end())
return true;
// If the item is supposed to still remain in the censorship
// detector internal tracker; remove it from the vector.
auto it = std::find(remain.begin(), remain.end(), id);
if (it != remain.end())
remain.erase(it);
return false;
});
// On entry, this set contained all the elements that should be tracked
// by the detector after we process this round. We removed all the items
// that actually were in the tracker, so this should now be empty:
BEAST_EXPECT(remain.empty());
}
void testNearTrivial ()
{
setup ("near trivial");
BEAST_EXPECT(output_.empty ());
writer_->output (0);
expectResult("0");
}
void
attempt (
bool sell,
std::string name,
Quality taker_quality,
cross_attempt_offer const offer,
std::string const funds,
Quality cross_quality,
cross_attempt_offer const cross,
std::string const cross_funds,
cross_attempt_offer const flow,
Issue const& issue_in,
Issue const& issue_out,
Rate rate_in = parityRate,
Rate rate_out = parityRate)
{
Amounts taker_offer (parse_amounts (
offer.in, issue_in,
offer.out, issue_out));
Amounts cross_offer (parse_amounts (
cross.in, issue_in,
cross.out, issue_out));
CrossType cross_type;
if (isXRP (issue_out))
cross_type = CrossType::IouToXrp;
else if (isXRP (issue_in))
cross_type = CrossType::XrpToIou;
else
cross_type = CrossType::IouToIou;
// FIXME: We are always invoking the IOU-to-IOU taker. We should select
// the correct type dynamically.
TestTaker taker (cross_type, taker_offer, taker_quality,
parse_amount (funds, issue_in), sell ? tfSell : 0,
rate_in, rate_out);
taker.set_funds (parse_amount (cross_funds, issue_out));
auto result = taker.cross (cross_offer, cross_quality);
Amounts const expected (parse_amounts (
flow.in, issue_in,
flow.out, issue_out));
BEAST_EXPECT(expected == result);
if (expected != result)
{
log <<
"Expected: " << format_amount (expected.in) <<
" : " << format_amount (expected.out) << '\n' <<
" Actual: " << format_amount (result.in) <<
" : " << format_amount (result.out) << std::endl;
}
}
void
testSpanBody()
{
{
using B = span_body<char const>;
request<B> req;
BEAST_EXPECT(req.body.size() == 0);
BEAST_EXPECT(B::size(req.body) == 0);
req.body = B::value_type("xyz", 3);
BEAST_EXPECT(req.body.size() == 3);
BEAST_EXPECT(B::size(req.body) == 3);
B::reader r{req};
error_code ec;
r.init(ec);
BEAST_EXPECTS(! ec, ec.message());
auto const buf = r.get(ec);
BEAST_EXPECTS(! ec, ec.message());
if(! BEAST_EXPECT(buf != boost::none))
return;
BEAST_EXPECT(boost::asio::buffer_size(buf->first) == 3);
BEAST_EXPECT(! buf->second);
}
{
char buf[5];
using B = span_body<char>;
request<B> req;
req.body = span<char>{buf, sizeof(buf)};
B::writer w{req};
error_code ec;
w.init(boost::none, ec);
BEAST_EXPECTS(! ec, ec.message());
w.put(boost::asio::const_buffers_1{
"123", 3}, ec);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(buf[0] == '1');
BEAST_EXPECT(buf[1] == '2');
BEAST_EXPECT(buf[2] == '3');
w.put(boost::asio::const_buffers_1{
"456", 3}, ec);
BEAST_EXPECTS(ec == error::buffer_overflow, ec.message());
}
}
void testMalformedCondition ()
{
testcase ("Malformed Condition");
// This is malformed and will not load because a
// feature suite of 0 is not supported.
auto c1 = loadCondition (
"cc:3:0:Mjmrcm06fOo-3WOEZu9YDSNfqmn0lj4iOsTVEurtCdI:518");
BEAST_EXPECT (!c1);
// The following will load but fail in different ways
auto c2 = loadCondition ( // only sha256
"cc:3:1:Mjmrcm06fOo-3WOEZu9YDSNfqmn0lj4iOsTVEurtCdI:518");
BEAST_EXPECT (c2 && !validate(*c2));
auto c3 = loadCondition ( // only preimage
"cc:3:2:Mjmrcm06fOo-3WOEZu9YDSNfqmn0lj4iOsTVEurtCdI:518");
BEAST_EXPECT (c3 && !validate(*c3));
auto c4 = loadCondition ( // sha256+preimage
"cc:4:3:RCmTBlAEqh5MSPTdAVgZTAI0m8xmTNluQA6iaZGKjVE:96");
BEAST_EXPECT (c4 && !validate(*c4));
auto c5 = loadCondition ( // Ed25519+sha256+preimage
"cc:1:23:Yja3qFj7NS_VwwE7aJjPJos-uFCzStJlJLD4VsNy2XM:1");
BEAST_EXPECT (c5 && !validate(*c5));
auto c6 = loadCondition ( // rsa+sha256+threshold
"cc:1:19:Yja3qFj7NS_VwwE7aJjPJos-uFCzStJlJLD4VsNy2XM:1");
BEAST_EXPECT (c6 && !validate(*c6));
auto c7 = loadCondition ( // rsa
"cc:1:10:Yja3qFj7NS_VwwE7aJjPJos-uFCzStJlJLD4VsNy2XM:1");
BEAST_EXPECT (c7 && !validate(*c7));
}
void test_nest_limits ()
{
Json::Reader r;
{
auto nest = [](std::uint32_t depth)->std::string {
std::string s = "{";
for (std::uint32_t i{1}; i <= depth; ++i)
s += "\"obj\":{";
for (std::uint32_t i{1}; i <= depth; ++i)
s += "}";
s += "}";
return s;
};
{
// Within object nest limit
auto json{nest(std::min(10u, Json::Reader::nest_limit))};
Json::Value j;
BEAST_EXPECT(r.parse(json, j));
}
{
// Exceed object nest limit
auto json{nest(Json::Reader::nest_limit + 1)};
Json::Value j;
BEAST_EXPECT(!r.parse(json, j));
}
}
auto nest = [](std::uint32_t depth)->std::string {
std::string s = "{";
for (std::uint32_t i{1}; i <= depth; ++i)
s += "\"array\":[{";
for (std::uint32_t i{1}; i <= depth; ++i)
s += "]}";
s += "}";
return s;
};
{
// Exceed array nest limit
auto json{nest(Json::Reader::nest_limit + 1)};
Json::Value j;
BEAST_EXPECT(!r.parse(json, j));
}
}
void testFreeFunctions()
{
{
request_v1<empty_body> m;
m.method = "GET";
m.url = "/";
m.version = 11;
m.headers.insert("Upgrade", "test");
BEAST_EXPECT(! is_upgrade(m));
prepare(m, connection::upgrade);
BEAST_EXPECT(is_upgrade(m));
BEAST_EXPECT(m.headers["Connection"] == "upgrade");
m.version = 10;
BEAST_EXPECT(! is_upgrade(m));
}
}
void check (
Fulfillment const& f,
Condition const& c,
Slice test,
Slice good)
{
BEAST_EXPECT (validate (f, c, test) ==
((test == good) && (f.condition() == c)));
}
void
ceil_out (Quality const& q,
In1 in, Out1 out, Int limit, In2 in_expected, Out2 out_expected)
{
auto const expect_result (amounts (in_expected, out_expected));
auto const actual_result (q.ceil_out (
amounts (in, out), amount (limit)));
BEAST_EXPECT(actual_result == expect_result);
}
void
testGetValues()
{
testcase ("Get Values");
try
{
auto& engine = crypto_prng();
auto rand_val = engine();
BEAST_EXPECT(rand_val >= engine.min());
BEAST_EXPECT(rand_val <= engine.max());
uint16_t twoByte {0};
engine(&twoByte, sizeof(uint16_t));
pass();
}
catch(std::exception&)
{
fail();
}
}
void testPrepare()
{
request_v1<empty_body> m;
m.version = 10;
BEAST_EXPECT(! is_upgrade(m));
m.headers.insert("Transfer-Encoding", "chunked");
try
{
prepare(m);
fail();
}
catch(std::exception const&)
{
}
m.headers.erase("Transfer-Encoding");
m.headers.insert("Content-Length", "0");
try
{
prepare(m);
fail();
}
catch(std::exception const&)
{
pass();
}
m.headers.erase("Content-Length");
m.headers.insert("Connection", "keep-alive");
try
{
prepare(m);
fail();
}
catch(std::exception const&)
{
pass();
}
m.version = 11;
m.headers.erase("Connection");
m.headers.insert("Connection", "close");
BEAST_EXPECT(! is_keep_alive(m));
}
void testSeedParsing ()
{
testcase ("Parsing");
// account IDs and node and account public and private
// keys should not be parseable as seeds.
auto const node1 = randomKeyPair(KeyType::secp256k1);
BEAST_EXPECT(!parseGenericSeed (
toBase58 (TokenType::TOKEN_NODE_PUBLIC, node1.first)));
BEAST_EXPECT(!parseGenericSeed (
toBase58 (TokenType::TOKEN_NODE_PRIVATE, node1.second)));
auto const node2 = randomKeyPair(KeyType::ed25519);
BEAST_EXPECT(!parseGenericSeed (
toBase58 (TokenType::TOKEN_NODE_PUBLIC, node2.first)));
BEAST_EXPECT(!parseGenericSeed (
toBase58 (TokenType::TOKEN_NODE_PRIVATE, node2.second)));
auto const account1 = generateKeyPair(
KeyType::secp256k1, randomSeed ());
BEAST_EXPECT(!parseGenericSeed (
toBase58(calcAccountID(account1.first))));
BEAST_EXPECT(!parseGenericSeed (
toBase58(TokenType::TOKEN_ACCOUNT_PUBLIC, account1.first)));
BEAST_EXPECT(!parseGenericSeed (
toBase58(TokenType::TOKEN_ACCOUNT_SECRET, account1.second)));
auto const account2 = generateKeyPair(
KeyType::ed25519, randomSeed ());
BEAST_EXPECT(!parseGenericSeed (
toBase58(calcAccountID(account2.first))));
BEAST_EXPECT(!parseGenericSeed (
toBase58(TokenType::TOKEN_ACCOUNT_PUBLIC, account2.first)));
BEAST_EXPECT(!parseGenericSeed (
toBase58(TokenType::TOKEN_ACCOUNT_SECRET, account2.second)));
}
void
test_move ()
{
Json::Value v1{2.5};
BEAST_EXPECT(v1.isDouble ());
BEAST_EXPECT(v1.asDouble () == 2.5);
Json::Value v2 = std::move(v1);
BEAST_EXPECT(!v1);
BEAST_EXPECT(v2.isDouble ());
BEAST_EXPECT(v2.asDouble () == 2.5);
BEAST_EXPECT(v1 != v2);
v1 = std::move(v2);
BEAST_EXPECT(v1.isDouble ());
BEAST_EXPECT(v1.asDouble () == 2.5);
BEAST_EXPECT(! v2);
BEAST_EXPECT(v1 != v2);
pass ();
}
void testStringVersion ()
{
testcase ("string version");
for (std::uint16_t major = 0; major < 8; major++)
{
for (std::uint16_t minor = 0; minor < 8; minor++)
{
BEAST_EXPECT(to_string (from_version (major, minor)) ==
std::to_string (major) + "." + std::to_string (minor));
}
}
}
void testValues ()
{
testcase ("comparison");
BEAST_EXPECT(from_version (1,2) == from_version (1,2));
BEAST_EXPECT(from_version (3,4) >= from_version (3,4));
BEAST_EXPECT(from_version (5,6) <= from_version (5,6));
BEAST_EXPECT(from_version (7,8) > from_version (6,7));
BEAST_EXPECT(from_version (7,8) < from_version (8,9));
BEAST_EXPECT(from_version (65535,0) < from_version (65535,65535));
BEAST_EXPECT(from_version (65535,65535) >= from_version (65535,65535));
}
void
test_operations ()
{
testcase ("operations");
Quality const q11 (Amounts (
STAmount (noIssue(), 731),
STAmount (noIssue(), 731)));
Quality qa (q11);
Quality qb (q11);
BEAST_EXPECT(qa == qb);
BEAST_EXPECT(++qa != q11);
BEAST_EXPECT(qa != qb);
BEAST_EXPECT(--qb != q11);
BEAST_EXPECT(qa != qb);
BEAST_EXPECT(qb < qa);
BEAST_EXPECT(qb++ < qa);
BEAST_EXPECT(qb++ < qa);
BEAST_EXPECT(qb++ == qa);
BEAST_EXPECT(qa < qb);
}
void testBase58()
{
testcase ("base58 operations");
// Success:
BEAST_EXPECT(parseBase58<Seed>("snoPBrXtMeMyMHUVTgbuqAfg1SUTb"));
BEAST_EXPECT(parseBase58<Seed>("snMKnVku798EnBwUfxeSD8953sLYA"));
BEAST_EXPECT(parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwKT"));
// Failure:
BEAST_EXPECT(!parseBase58<Seed>(""));
BEAST_EXPECT(!parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwK"));
BEAST_EXPECT(!parseBase58<Seed>("sspUXGrmjQhq6mgc24jiRuevZiwKTT"));
BEAST_EXPECT(!parseBase58<Seed>("sspOXGrmjQhq6mgc24jiRuevZiwKT"));
BEAST_EXPECT(!parseBase58<Seed>("ssp/XGrmjQhq6mgc24jiRuevZiwKT"));
}
void testSwap()
{
message_v1<false, string_body, headers> m1;
message_v1<false, string_body, headers> m2;
m1.status = 200;
m1.version = 10;
m1.body = "1";
m1.headers.insert("h", "v");
m2.status = 404;
m2.reason = "OK";
m2.body = "2";
m2.version = 11;
swap(m1, m2);
BEAST_EXPECT(m1.status == 404);
BEAST_EXPECT(m2.status == 200);
BEAST_EXPECT(m1.reason == "OK");
BEAST_EXPECT(m2.reason.empty());
BEAST_EXPECT(m1.version == 11);
BEAST_EXPECT(m2.version == 10);
BEAST_EXPECT(m1.body == "2");
BEAST_EXPECT(m2.body == "1");
BEAST_EXPECT(! m1.headers.exists("h"));
BEAST_EXPECT(m2.headers.exists("h"));
}
