ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-11-04 18:55:49 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
eeb9d92fb0990e56defe4430fa8b45b67d7990cd
xahaud/src/test/rpc/RPCCall_test.cpp
Scott Schurr eeb9d92fb0 Add RPCCall unit tests (RIPD-1634)
2018-10-01 07:40:56 -07:00

7048 lines
147 KiB
C++
Raw Blame History

//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2018 Ripple Labs Inc.
Permission to use, copy, modify, and/or distribute this software for any
purpose with or without fee is hereby granted, provided that the above
copyright notice and this permission notice appear in all copies.
THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
ANY SPECIAL , DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
*/
//==============================================================================
#include <ripple/net/RPCCall.h>
#include <ripple/beast/unit_test.h>
#include <ripple/json/json_reader.h>
#include <ripple/protocol/ErrorCodes.h>
#include <test/jtx.h>
#include <initializer_list>
#include <vector>
namespace ripple {
namespace test {
struct RPCCallTestData
{
char const* const description;
int const line;
// List of passed arguments.
std::vector<char const*> const args;
// If it throws, what does it throw?
enum Exception
{
no_exception = 0,
bad_cast
};
Exception const throwsWhat;
// Expected JSON response.
char const* const exp;
RPCCallTestData (char const* description_, int line_,
std::initializer_list<char const*> const& args_,
Exception throwsWhat_, char const* exp_)
: description (description_)
, line (line_)
, args (args_)
, throwsWhat (throwsWhat_)
, exp (exp_)
{ }
RPCCallTestData () = delete;
RPCCallTestData (RPCCallTestData const&) = delete;
RPCCallTestData (RPCCallTestData&&) = delete;
RPCCallTestData& operator= (RPCCallTestData const&) = delete;
RPCCallTestData& operator= (RPCCallTestData&&) = delete;
};
static RPCCallTestData const rpcCallTestArray [] =
{
// account_channels ------------------------------------------------------------
{
"account_channels: minimal.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"account_channels: account and ledger hash.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"destination_account" : "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"
}
]
})"
},
{
"account_channels: account and ledger index.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"destination_account" : "closed"
}
]
})"
},
{
"account_channels: two accounts.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_channels: two accounts and ledger hash.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
}
]
})"
},
{
"account_channels: two accounts and ledger index.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"90210"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"destination_account" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_index" : 90210
}
]
})"
},
{
"account_channels: too few arguments.", __LINE__,
{
"account_channels",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_channels: too many arguments.", __LINE__,
{
"account_channels",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"current",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_channels: invalid accountID.", __LINE__,
{
"account_channels",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_channels",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})"
},
// account_currencies ----------------------------------------------------------
{
"account_currencies: minimal.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"account_currencies: strict.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
"account_currencies: ledger index.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"42"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 42
}
]
})"
},
{
"account_currencies: validated ledger.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "validated"
}
]
})"
},
{
"account_currencies: too few arguments.", __LINE__,
{
"account_currencies",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_currencies: too many arguments.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_currencies: invalid second argument.", __LINE__,
{
"account_currencies",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"yup"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})"
},
{
"account_currencies: invalid accountID.", __LINE__,
{
"account_currencies",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
"account_currencies: floating point first argument.", __LINE__,
{
"account_currencies",
"3.14159",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_currencies",
"params" : [
{
"account" : "3.14159",
"strict" : 1
}
]
})"
},
// account_info ----------------------------------------------------------------
{
"account_info: minimal.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"account_info: with numeric ledger index.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"77777"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 77777
}
]
})"
},
{
"account_info: with text ledger index.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "closed"
}
]
})"
},
{
"account_info: with ledger hash.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
}
]
})"
},
{
// Note: this works, but it doesn't match the documentation.
"account_info: strict.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
// Note: Somewhat according to the docs, this is should be valid syntax.
"account_info: with ledger index and strict.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_info: too few arguments.", __LINE__,
{
"account_info",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_info: too many arguments.", __LINE__,
{
"account_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"strict",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_info: invalid accountID.", __LINE__,
{
"account_info",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_info",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
// account_lines ---------------------------------------------------------------
{
"account_lines: minimal.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
}
]
})"
},
{
"account_lines: peer.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_lines: peer and numeric ledger index.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"888888888"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 888888888,
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_lines: peer and text ledger index.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "closed",
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_lines: peer and ledger hash.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "FFFFEEEEDDDDCCCCBBBBAAAA9999888877776666555544443333222211110000",
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_lines: too few arguments.", __LINE__,
{
"account_lines",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"account_lines: four arguments.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"12345678",
"current"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 12345678,
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"account_lines: five arguments.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"12345678",
"current",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 12345678,
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})"
},
{
"account_lines: too many arguments.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"12345678",
"current",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_lines: first invalid accountID.", __LINE__,
{
"account_lines",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
"account_lines: second invalid accountID.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"" // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})",
},
{
"account_lines: invalid ledger selector.", __LINE__,
{
"account_lines",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"not_a_ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_lines",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0,
"peer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
}
]
})",
},
// account_objects -------------------------------------------------------------
{
"account_objects: minimal.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"account_objects: with numeric ledger index.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"77777"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 77777
}
]
})"
},
{
"account_objects: with text ledger index.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "closed"
}
]
})"
},
{
"account_objects: with ledger hash.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
}
]
})"
},
{
// Note: this works, but it doesn't match the documentation.
"account_objects: strict.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
"account_objects: with ledger index and strict.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "validated",
"strict" : 1
}
]
})"
},
{
"account_objects: too few arguments.", __LINE__,
{
"account_objects",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"account_objects: four arguments.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"account_objects: five arguments.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra1",
"extra2",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
"account_objects: too many arguments.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra1",
"extra2",
"extra3",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_objects: invalid accountID.", __LINE__,
{
"account_objects",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"account_objects: invalid ledger selection 1.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"account_objects: invalid ledger selection 2.", __LINE__,
{
"account_objects",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_objects",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0,
"strict" : 1
}
]
})",
},
// account_offers --------------------------------------------------------------
{
"account_offers: minimal.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"account_offers: with numeric ledger index.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"987654321"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 987654321
}
]
})"
},
{
"account_offers: with text ledger index.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "validated"
}
]
})"
},
{
"account_offers: with ledger hash.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
}
]
})"
},
{
// Note: this works, but it doesn't match the documentation.
"account_offers: strict.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
// Note: this works, but doesn't match the documentation.
"account_offers: with ledger index and strict.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "validated",
"strict" : 1
}
]
})"
},
{
"account_offers: too few arguments.", __LINE__,
{
"account_offers",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"account_offers: four arguments.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
"account_offers: too many arguments.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra1",
"extra2",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_offers: invalid accountID.", __LINE__,
{
"account_offers",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"account_offers: invalid ledger selection 1.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"account_offers: invalid ledger selection 2.", __LINE__,
{
"account_offers",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_offers",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0,
"strict" : 1
}
]
})",
},
// account_tx ------------------------------------------------------------------
{
"account_tx: minimal.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
}
]
})"
},
{
"account_tx: ledger_index .", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"444"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 444
}
]
})"
},
{
"account_tx: ledger_index plus trailing params.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"707",
"descending",
"binary",
"count"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"count" : true,
"binary" : true,
"descending" : true,
"ledger_index" : 707
}
]
})"
},
{
"account_tx: ledger_index_min and _max.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index_max" : -1,
"ledger_index_min" : -1
}
]
})"
},
{
"account_tx: ledger_index_min and _max plus trailing params.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"413",
"binary",
"count",
"descending"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"binary" : true,
"count" : true,
"descending" : true,
"ledger_index_max" : 413,
"ledger_index_min" : -1
}
]
})"
},
{
"account_tx: ledger_index_min and _max plus limit.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"247",
"-1",
"300"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index_max" : -1,
"ledger_index_min" : 247,
"limit" : 300
}
]
})"
},
{
"account_tx: ledger_index_min and _max, limit, trailing args.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"247",
"-1",
"300",
"count",
"descending",
"binary"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"binary" : true,
"count" : true,
"descending" : true,
"ledger_index_max" : -1,
"ledger_index_min" : 247,
"limit" : 300
}
]
})"
},
{
"account_tx: ledger_index_min and _max plus limit and offset.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"589",
"590",
"67",
"45"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index_max" : 590,
"ledger_index_min" : 589,
"limit" : 67,
"offset" : 45
}
]
})"
},
{
"account_tx: ledger_index_min and _max, limit, offset, trailing.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"589",
"590",
"67",
"45",
"descending",
"count"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"count" : true,
"descending" : true,
"ledger_index_max" : 590,
"ledger_index_min" : 589,
"limit" : 67,
"offset" : 45
}
]
})"
},
{
"account_tx: too few arguments.", __LINE__,
{
"account_tx",
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_tx: too many arguments.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"589",
"590",
"67",
"45",
"extra",
"descending",
"count",
"binary"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"account_tx: invalid accountID.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
// Note: not currently detected as bad input.
"account_tx: invalid ledger.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-478.7"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})",
},
{
"account_tx: max less than min.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"580",
"579"
},
RPCCallTestData::no_exception,
R"({
"method" : "account_tx",
"params" : [
{
"error" : "lgrIdxsInvalid",
"error_code" : 55,
"error_message" : "Ledger indexes invalid."
}
]
})",
},
{
// Note: this really shouldn't throw, but does at the moment.
"account_tx: non-integer min.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"Binary",
"-1"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"account_tx: non-integer max.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"counts"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"account_tx: non-integer offset.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1",
"decending"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"account_tx: non-integer limit.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1",
"300",
"false"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"account_tx: RIPD-1570.", __LINE__,
{
"account_tx",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1",
"2",
"false",
"false",
"false"
},
RPCCallTestData::bad_cast,
R"()"
},
// book_offers -----------------------------------------------------------------
{
"book_offers: minimal no issuer.", __LINE__,
{
"book_offers",
"USD",
"EUR",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"taker_gets" : {
"currency" : "EUR"
},
"taker_pays" : {
"currency" : "USD"
}
}
]
})"
},
{
"book_offers: minimal with currency/issuer", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD",
"issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
}
]
})"
},
{
// Note: documentation suggests that "issuer" is the wrong type.
// Should it be "taker" instead?
"book_offers: add issuer.", __LINE__,
{
"book_offers",
"USD",
"EUR",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"taker_gets" : {
"currency" : "EUR"
},
"taker_pays" : {
"currency" : "USD"
}
}
]
})"
},
{
"book_offers: add issuer and numeric ledger index.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"666"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_index" : 666,
"taker_gets" : {
"currency" : "EUR"
},
"taker_pays" : {
"currency" : "USD",
"issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
}
]
})"
},
{
"book_offers: add issuer and text ledger index.", __LINE__,
{
"book_offers",
"USD",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"current"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_index" : "current",
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD"
}
}
]
})"
},
{
"book_offers: add issuer and ledger hash.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD",
"issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
}
]
})"
},
{
"book_offers: issuer, ledger hash, and limit.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"junk", // Note: indexing bug in parseBookOffers() requires junk param.
"200",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"limit" : 200,
"proof" : true,
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD",
"issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
}
]
})"
},
{
// Note: parser supports "marker", but the docs don't cover it.
"book_offers: issuer, ledger hash, limit, and marker.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"junk", // Note: indexing bug in parseBookOffers() requires junk param.
"200",
"MyMarker"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"limit" : 200,
"marker" : "MyMarker",
"proof" : true,
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD",
"issuer" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
}
]
})"
},
{
"book_offers: too few arguments.", __LINE__,
{
"book_offers",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"book_offers: too many arguments.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"junk", // Note: indexing bug in parseBookOffers() requires junk param.
"200",
"MyMarker",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"book_offers: taker pays no currency.", __LINE__,
{
"book_offers",
"/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid currency/issuer '/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh'"
}
]
})"
},
{
"book_offers: taker gets no currency.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid currency/issuer '/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA'"
}
]
})"
},
{
"book_offers: invalid issuer.", __LINE__,
{
"book_offers",
"USD",
"EUR",
"not_a_valid_issuer"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "not_a_valid_issuer",
"taker_gets" : {
"currency" : "EUR"
},
"taker_pays" : {
"currency" : "USD"
}
}
]
})"
},
{
"book_offers: invalid text ledger index.", __LINE__,
{
"book_offers",
"USD",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"not_a_ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "book_offers",
"params" : [
{
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ledger_index" : 0,
"taker_gets" : {
"currency" : "EUR",
"issuer" : "rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA"
},
"taker_pays" : {
"currency" : "USD"
}
}
]
})"
},
{
// Note: this really shouldn't throw, but does at the moment.
"book_offers: non-numeric limit.", __LINE__,
{
"book_offers",
"USD/rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"EUR/rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"rnUy2SHTrB9DubsPmkJZUXTf5FcNDGrYEA",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"junk", // Note: indexing bug in parseBookOffers() requires junk param.
"not_a_number",
},
RPCCallTestData::bad_cast,
R"()"
},
// can_delete ------------------------------------------------------------------
{
"can_delete: minimal.", __LINE__,
{
"can_delete",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete"
})"
},
{
"can_delete: ledger index.", __LINE__,
{
"can_delete",
"4294967295",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : 4294967295
}
]
})"
},
{
"can_delete: ledger hash.", __LINE__,
{
"can_delete",
"FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"
}
]
})"
},
{
"can_delete: always.", __LINE__,
{
"can_delete",
"always",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : "always"
}
]
})"
},
{
"can_delete: never.", __LINE__,
{
"can_delete",
"never",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : "never"
}
]
})"
},
{
"can_delete: now.", __LINE__,
{
"can_delete",
"now",
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : "now"
}
]
})"
},
{
"can_delete: too many arguments.", __LINE__,
{
"can_delete",
"always",
"never"
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"can_delete: invalid argument.", __LINE__,
{
"can_delete",
"invalid"
},
RPCCallTestData::no_exception,
R"({
"method" : "can_delete",
"params" : [
{
"can_delete" : "invalid"
}
]
})"
},
{
// Note: this should return an error but not throw.
"can_delete: ledger index > 32 bits.", __LINE__,
{
"can_delete",
"4294967296",
},
RPCCallTestData::bad_cast,
R"()"
},
{
// Note: this really shouldn't throw since it's a legitimate ledger hash.
"can_delete: ledger hash with no alphas.", __LINE__,
{
"can_delete",
"0123456701234567012345670123456701234567012345670123456701234567",
},
RPCCallTestData::bad_cast,
R"()"
},
// channel_authorize -----------------------------------------------------------
{
"channel_authorize: minimal.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"18446744073709551615"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"amount" : "18446744073709551615",
"channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"secret" : "secret_can_be_anything"
}
]
})"
},
{
"channel_authorize: too few arguments.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"channel_authorize: too many arguments.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"whatever"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"channel_authorize: channel_id too short.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "channelMalformed",
"error_code" : 43,
"error_message" : "Payment channel is malformed."
}
]
})"
},
{
"channel_authorize: channel_id too long.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "channelMalformed",
"error_code" : 43,
"error_message" : "Payment channel is malformed."
}
]
})"
},
{
"channel_authorize: channel_id not hex.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEZ",
"2000"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "channelMalformed",
"error_code" : 43,
"error_message" : "Payment channel is malformed."
}
]
})"
},
{
"channel_authorize: negative amount.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "channelAmtMalformed",
"error_code" : 44,
"error_message" : "Payment channel amount is malformed."
}
]
})"
},
{
"channel_authorize: amount > 64 bits.", __LINE__,
{
"channel_authorize",
"secret_can_be_anything",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"18446744073709551616"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_authorize",
"params" : [
{
"error" : "channelAmtMalformed",
"error_code" : 44,
"error_message" : "Payment channel amount is malformed."
}
]
})"
},
// channel_verify --------------------------------------------------------------
{
"channel_verify: public key.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"0",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"amount" : "0",
"channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"public_key" : "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"signature" : "DEADBEEF"
}
]
})"
},
{
"channel_verify: public key hex.", __LINE__,
{
"channel_verify",
"021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"18446744073709551615",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"amount" : "18446744073709551615",
"channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"public_key" : "021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
"signature" : "DEADBEEF"
}
]
})"
},
{
"channel_verify: too few arguments.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"channel_verify: too many arguments.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"DEADBEEF",
"Whatever"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"channel_verify: malformed public key.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9GoV",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "publicMalformed",
"error_code" : 60,
"error_message" : "Public key is malformed."
}
]
})"
},
{
"channel_verify: malformed hex public key.", __LINE__,
{
"channel_verify",
"021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "publicMalformed",
"error_code" : 60,
"error_message" : "Public key is malformed."
}
]
})"
},
{
"channel_verify: invalid channel id.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"10123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "channelMalformed",
"error_code" : 43,
"error_message" : "Payment channel is malformed."
}
]
})"
},
{
"channel_verify: short channel id.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"2000",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "channelMalformed",
"error_code" : 43,
"error_message" : "Payment channel is malformed."
}
]
})"
},
{
"channel_verify: amount too small.", __LINE__,
{
"channel_verify",
"021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"-1",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "channelAmtMalformed",
"error_code" : 44,
"error_message" : "Payment channel amount is malformed."
}
]
})"
},
{
"channel_verify: amount too large.", __LINE__,
{
"channel_verify",
"021D93E21C44160A1B3B66DA1F37B86BE39FFEA3FC4B95FAA2063F82EE823599F6",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"18446744073709551616",
"DEADBEEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"error" : "channelAmtMalformed",
"error_code" : 44,
"error_message" : "Payment channel amount is malformed."
}
]
})"
},
{
"channel_verify: non-hex signature.", __LINE__,
{
"channel_verify",
"aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"40000000",
"ThisIsNotHexadecimal"
},
RPCCallTestData::no_exception,
R"({
"method" : "channel_verify",
"params" : [
{
"amount" : "40000000",
"channel_id" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF",
"public_key" : "aB4BXXLuPu8DpVuyq1DBiu3SrPdtK9AYZisKhu8mvkoiUD8J9Gov",
"signature" : "ThisIsNotHexadecimal"
}
]
})"
},
// connect ---------------------------------------------------------------------
{
"connect: minimal.", __LINE__,
{
"connect",
"ThereIsNoCheckingOnTheIPFormat",
},
RPCCallTestData::no_exception,
R"({
"method" : "connect",
"params" : [
{
"ip" : "ThereIsNoCheckingOnTheIPFormat"
}
]
})"
},
{
"connect: ip and port.", __LINE__,
{
"connect",
"ThereIsNoCheckingOnTheIPFormat",
"6561"
},
RPCCallTestData::no_exception,
R"({
"method" : "connect",
"params" : [
{
"ip" : "ThereIsNoCheckingOnTheIPFormat",
"port" : 6561
}
]
})"
},
{
"connect: too few arguments.", __LINE__,
{
"connect",
},
RPCCallTestData::no_exception,
R"({
"method" : "connect",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"connect: too many arguments.", __LINE__,
{
"connect",
"ThereIsNoCheckingOnTheIPFormat",
"6561",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "connect",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: this should return an error but not throw.
"connect: port too small.", __LINE__,
{
"connect",
"ThereIsNoCheckingOnTheIPFormat",
"-1",
},
RPCCallTestData::bad_cast,
R"()"
},
{
// Note: this should return an error but not throw.
"connect: port too large.", __LINE__,
{
"connect",
"ThereIsNoCheckingOnTheIPFormat",
"4294967296",
},
RPCCallTestData::bad_cast,
R"()"
},
// consensus_info --------------------------------------------------------------
{
"consensus_info: minimal.", __LINE__,
{
"consensus_info",
},
RPCCallTestData::no_exception,
R"({
"method" : "consensus_info",
})"
},
{
"consensus_info: too many arguments.", __LINE__,
{
"consensus_info",
"whatever"
},
RPCCallTestData::no_exception,
R"({
"method" : "consensus_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// deposit_authorized ----------------------------------------------------------
{
"deposit_authorized: minimal.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"destination_account" : "destination_account_NotValidated",
"source_account" : "source_account_NotValidated"
}
]
})"
},
{
"deposit_authorized: with text ledger index.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"destination_account" : "destination_account_NotValidated",
"ledger_index" : "validated",
"source_account" : "source_account_NotValidated"
}
]
})"
},
{
"deposit_authorized: with ledger index.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"destination_account" : "destination_account_NotValidated",
"ledger_index" : 4294967295,
"source_account" : "source_account_NotValidated"
}
]
})"
},
{
"deposit_authorized: with ledger hash.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"destination_account" : "destination_account_NotValidated",
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"source_account" : "source_account_NotValidated"
}
]
})"
},
{
"deposit_authorized: too few arguments.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"deposit_authorized: too many arguments.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789",
"spare"
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"deposit_authorized: invalid ledger selection.", __LINE__,
{
"deposit_authorized",
"source_account_NotValidated",
"destination_account_NotValidated",
"NotALedger",
},
RPCCallTestData::no_exception,
R"({
"method" : "deposit_authorized",
"params" : [
{
"destination_account" : "destination_account_NotValidated",
"ledger_index" : 0,
"source_account" : "source_account_NotValidated"
}
]
})"
},
// download_shard --------------------------------------------------------------
{
"download_shard: minimal.", __LINE__,
{
"download_shard",
"20",
"url_NotValidated",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"shards" : [
{
"index" : 20,
"url" : "url_NotValidated"
}
]
}
]
})"
},
{
"download_shard: novalidate.", __LINE__,
{
"download_shard",
"novalidate",
"20",
"url_NotValidated",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"shards" : [
{
"index" : 20,
"url" : "url_NotValidated"
}
],
"validate" : false
}
]
})"
},
{
"download_shard: many shards.", __LINE__,
{
"download_shard",
"200000000",
"url_NotValidated0",
"199999999",
"url_NotValidated1",
"199999998",
"url_NotValidated2",
"199999997",
"url_NotValidated3",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"shards" : [
{
"index" : 200000000,
"url" : "url_NotValidated0"
},
{
"index" : 199999999,
"url" : "url_NotValidated1"
},
{
"index" : 199999998,
"url" : "url_NotValidated2"
},
{
"index" : 199999997,
"url" : "url_NotValidated3"
}
]
}
]
})"
},
{
"download_shard: novalidate many shards.", __LINE__,
{
"download_shard",
"novalidate",
"2000000",
"url_NotValidated0",
"2000001",
"url_NotValidated1",
"2000002",
"url_NotValidated2",
"2000003",
"url_NotValidated3",
"2000004",
"url_NotValidated4",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"shards" : [
{
"index" : 2000000,
"url" : "url_NotValidated0"
},
{
"index" : 2000001,
"url" : "url_NotValidated1"
},
{
"index" : 2000002,
"url" : "url_NotValidated2"
},
{
"index" : 2000003,
"url" : "url_NotValidated3"
},
{
"index" : 2000004,
"url" : "url_NotValidated4"
}
],
"validate" : false
}
]
})"
},
{
"download_shard: too few arguments.", __LINE__,
{
"download_shard",
"20"
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: this should return an error but not throw.
"download_shard: novalidate too few arguments.", __LINE__,
{
"download_shard",
"novalidate",
"20"
},
RPCCallTestData::bad_cast,
R"()"
},
{
"download_shard: novalidate at end.", __LINE__,
{
"download_shard",
"20",
"url_NotValidated",
"novalidate",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"shards" : [
{
"index" : 20,
"url" : "url_NotValidated"
}
],
"validate" : false
}
]
})"
},
{
"download_shard: novalidate in middle.", __LINE__,
{
"download_shard",
"20",
"url_NotValidated20",
"novalidate",
"200",
"url_NotValidated200",
},
RPCCallTestData::no_exception,
R"({
"method" : "download_shard",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
// Note: this should return an error but not throw.
"download_shard: arguments swapped.", __LINE__,
{
"download_shard",
"url_NotValidated",
"20",
},
RPCCallTestData::bad_cast,
R"()"
},
{
"download_shard: index too small.", __LINE__,
{
"download_shard",
"-1",
"url_NotValidated",
},
RPCCallTestData::bad_cast,
R"()"
},
{
"download_shard: index too big.", __LINE__,
{
"download_shard",
"4294967296",
"url_NotValidated",
},
RPCCallTestData::bad_cast,
R"()"
},
// feature ---------------------------------------------------------------------
{
"feature: minimal.", __LINE__,
{
"feature",
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
})"
},
{
"feature: with name.", __LINE__,
{
"feature",
"featureNameOrHexIsNotValidated"
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
"params" : [
{
"feature" : "featureNameOrHexIsNotValidated"
}
]
})"
},
{
"feature: accept.", __LINE__,
{
"feature",
"FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
"accept"
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
"params" : [
{
"feature" : "FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210",
"vetoed" : false
}
]
})"
},
{
"feature: reject.", __LINE__,
{
"feature",
"0",
"reject"
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
"params" : [
{
"feature" : "0",
"vetoed" : true
}
]
})"
},
{
"feature: too many arguments.", __LINE__,
{
"feature",
"featureNameOrHexIsNotValidated",
"accept",
"anotherArg"
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"feature: neither accept nor reject.", __LINE__,
{
"feature",
"featureNameOrHexIsNotValidated",
"veto",
},
RPCCallTestData::no_exception,
R"({
"method" : "feature",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// fetch_info ------------------------------------------------------------------
{
"fetch_info: minimal.", __LINE__,
{
"fetch_info",
},
RPCCallTestData::no_exception,
R"({
"method" : "fetch_info",
})"
},
{
"fetch_info: clear.", __LINE__,
{
"fetch_info",
"clear"
},
RPCCallTestData::no_exception,
R"({
"method" : "fetch_info",
"params" : [
{
"clear" : true
}
]
})"
},
{
"fetch_info: too many arguments.", __LINE__,
{
"fetch_info",
"clear",
"other"
},
RPCCallTestData::no_exception,
R"({
"method" : "fetch_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"fetch_info: other trailing argument.", __LINE__,
{
"fetch_info",
"too"
},
RPCCallTestData::no_exception,
R"({
"method" : "fetch_info",
"params" : [
{
"too" : true
}
]
})"
},
// gateway_balances ------------------------------------------------------------
{
"gateway_balances: minimal.", __LINE__,
{
"gateway_balances",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
}
]
})"
},
{
"gateway_balances: with ledger index.", __LINE__,
{
"gateway_balances",
"890765",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "890765"
}
]
})"
},
{
"gateway_balances: with text ledger index.", __LINE__,
{
"gateway_balances",
"current",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "current"
}
]
})"
},
{
"gateway_balances: with 64 character ledger hash.", __LINE__,
{
"gateway_balances",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"gateway_balances: 1 hotwallet.", __LINE__,
{
"gateway_balances",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"hotwallet_is_not_validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"hotwallet" : [ "hotwallet_is_not_validated" ]
}
]
})"
},
{
"gateway_balances: 3 hotwallets.", __LINE__,
{
"gateway_balances",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"hotwallet_is_not_validated_1",
"hotwallet_is_not_validated_2",
"hotwallet_is_not_validated_3",
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"hotwallet" : [
"hotwallet_is_not_validated_1",
"hotwallet_is_not_validated_2",
"hotwallet_is_not_validated_3"
],
"ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"gateway_balances: too few arguments.", __LINE__,
{
"gateway_balances",
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"gateway_balances: empty first argument.", __LINE__,
{
"gateway_balances",
""
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid first parameter"
}
]
})"
},
{
"gateway_balances: with ledger index but no gateway.", __LINE__,
{
"gateway_balances",
"890765",
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid hotwallet"
}
]
})"
},
{
"gateway_balances: with text ledger index but no gateway.", __LINE__,
{
"gateway_balances",
"current",
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid hotwallet"
}
]
})"
},
{
"gateway_balances: with 64 character ledger hash but no gateway.", __LINE__,
{
"gateway_balances",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
},
RPCCallTestData::no_exception,
R"({
"method" : "gateway_balances",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid hotwallet"
}
]
})"
},
// get_counts ------------------------------------------------------------------
{
"get_counts: minimal.", __LINE__,
{
"get_counts",
},
RPCCallTestData::no_exception,
R"({
"method" : "get_counts"
})"
},
{
"get_counts: with maximum count.", __LINE__,
{
"get_counts",
"100"
},
RPCCallTestData::no_exception,
R"({
"method" : "get_counts",
"params" : [
{
"min_count" : 100
}
]
})"
},
{
"get_counts: too many arguments.", __LINE__,
{
"get_counts",
"100",
"whatever"
},
RPCCallTestData::no_exception,
R"({
"method" : "get_counts",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"get_counts: count too small.", __LINE__,
{
"get_counts",
"-1",
},
RPCCallTestData::bad_cast,
R"()"
},
{
"get_counts: count too large.", __LINE__,
{
"get_counts",
"4294967296"
},
RPCCallTestData::bad_cast,
R"()"
},
// json ------------------------------------------------------------------------
{
"json: minimal.", __LINE__,
{
"json",
"command",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "command",
"params" : [
{
"json_argument" : true,
"method" : "command"
}
]
})"
},
{
"json: null object.", __LINE__,
{
"json",
"command",
R"({})",
},
RPCCallTestData::no_exception,
R"({
"method" : "command",
"params" : [
{
"method" : "command"
}
]
})"
},
{
"json: too few arguments.", __LINE__,
{
"json",
"command"
},
RPCCallTestData::no_exception,
R"({
"method" : "json",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"json: too many arguments.", __LINE__,
{
"json",
"command",
R"({"json_argument":true})",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "json",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"json: array, not object.", __LINE__,
{
"json",
"command",
R"(["arg1","arg2"])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"json: invalid json (note closing comma).", __LINE__,
{
"json",
"command",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "json",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// json2 -----------------------------------------------------------------------
{
"json2: minimal object.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"params" : [
{
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: object with nested params.", __LINE__,
{
"json2",
R"({
"jsonrpc" : "2.0",
"ripplerpc" : "2.0",
"id" : "A1",
"method" : "call_1",
"params" : [{"inner_arg" : "yup"}]
})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"params" : [
{
"0" : {
"inner_arg" : "yup"
},
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: minimal array.", __LINE__,
{
"json2",
R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1"}])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
[
{
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"ripplerpc" : "2.0"
}
]
]
})"
},
{
"json2: array with object with nested params.", __LINE__,
{
"json2",
R"([
{"jsonrpc":"2.0",
"ripplerpc":"2.0",
"id":"A1",
"method":"call_1",
"params" : [{"inner_arg" : "yup"}]}
])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
[
{
"0" : {
"inner_arg" : "yup"
},
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "call_1",
"ripplerpc" : "2.0"
}
]
]})"
},
{
"json2: too few arguments.", __LINE__,
{
"json2",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"json2: too many arguments.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_this"})",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"json2: malformed json (note extra comma).", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.0",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: omit jsonrpc.", __LINE__,
{
"json2",
R"({"ripplerpc":"2.0","id":"A1","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: wrong jsonrpc version.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.1","ripplerpc":"2.0","id":"A1","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.1",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.1",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: omit ripplerpc.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","id":"A1","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.0"
}
]
})"
},
{
"json2: wrong ripplerpc version.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.00","id":"A1","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.0",
"ripplerpc" : "2.00"
}
],
"ripplerpc" : "2.00"
})"
},
{
"json2: omit id.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.0","method":"call_1"})",
},
RPCCallTestData::no_exception,
R"({
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"jsonrpc" : "2.0",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: omit method.", __LINE__,
{
"json2",
R"({"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1"})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.0",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
{
"json2: empty outer array.", __LINE__,
{
"json2",
R"([])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"json2: empty inner array.", __LINE__,
{
"json2",
R"([{"jsonrpc":"2.0","ripplerpc":"2.0","id":"A1","method":"call_1",[]}])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"json2: array with non-json2 object.", __LINE__,
{
"json2",
R"([
{"jsonrpc" : "2.1",
"ripplerpc" : "2.0",
"id" : "A1",
"method" : "call_1"
}
])",
},
RPCCallTestData::no_exception,
R"({
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"json2: non-object or -array inner params member.", __LINE__,
{
"json2",
R"({
"jsonrpc" : "2.0",
"ripplerpc" : "2.0",
"id" : "A1",
"method" : "call_1",
"params" : true
})",
},
RPCCallTestData::no_exception,
R"({
"id" : "A1",
"jsonrpc" : "2.0",
"method" : "json2",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters.",
"id" : "A1",
"jsonrpc" : "2.0",
"ripplerpc" : "2.0"
}
],
"ripplerpc" : "2.0"
})"
},
// ledger ----------------------------------------------------------------------
{
"ledger: minimal.", __LINE__,
{
"ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger"
})"
},
{
"ledger: ledger index.", __LINE__,
{
"ledger",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : 4294967295
}
]
})"
},
{
"ledger: text ledger index.", __LINE__,
{
"ledger",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : "validated"
}
]
})"
},
{
"ledger: ledger hash.", __LINE__,
{
"ledger",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
}
]
})"
},
{
"ledger: full.", __LINE__,
{
"ledger",
"current",
"full"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"full" : true,
"ledger_index" : "current"
}
]
})"
},
{
"ledger: tx.", __LINE__,
{
"ledger",
"closed",
"tx"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"expand" : true,
"ledger_index" : "closed",
"transactions" : true
}
]
})"
},
{
"ledger: too many arguments.", __LINE__,
{
"ledger",
"4294967295",
"spare"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : 4294967295
}
]
})"
},
{
"ledger: ledger index too small.", __LINE__,
{
"ledger",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger: ledger index too big.", __LINE__,
{
"ledger",
"4294967296"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger: invalid ledger text.", __LINE__,
{
"ledger",
"latest"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger: unsupported final argument.", __LINE__,
{
"ledger",
"current",
"expand"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger",
"params" : [
{
"ledger_index" : "current"
}
]
})"
},
// ledger_closed ---------------------------------------------------------------
{
"ledger_closed: minimal.", __LINE__,
{
"ledger_closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_closed"
})"
},
{
"ledger_closed: too many arguments.", __LINE__,
{
"ledger_closed",
"today"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_closed",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// ledger_current --------------------------------------------------------------
{
"ledger_current: minimal.", __LINE__,
{
"ledger_current"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_current"
})"
},
{
"ledger_current: too many arguments.", __LINE__,
{
"ledger_current",
"today"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_current",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// ledger_header ---------------------------------------------------------------
{
"ledger_header: ledger index.", __LINE__,
{
"ledger_header",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"ledger_index" : 4294967295
}
]
})"
},
{
"ledger_header: ledger hash.", __LINE__,
{
"ledger_header",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
}
]
})"
},
{
"ledger_header: too few arguments.", __LINE__,
{
"ledger_header",
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ledger_header: too many arguments.", __LINE__,
{
"ledger_header",
"4294967295",
"spare"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ledger_header: text ledger index.", __LINE__,
{
"ledger_header",
"current"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger_header: ledger index too small.", __LINE__,
{
"ledger_header",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger_header: ledger index too big.", __LINE__,
{
"ledger_header",
"4294967296"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_header",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
// ledger_request --------------------------------------------------------------
{
"ledger_request: ledger index.", __LINE__,
{
"ledger_request",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"ledger_index" : 4294967295
}
]
})"
},
{
"ledger_request: ledger hash.", __LINE__,
{
"ledger_request",
"ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"ledger_hash" : "ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789"
}
]
})"
},
{
"ledger_request: too few arguments.", __LINE__,
{
"ledger_request",
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ledger_request: too many arguments.", __LINE__,
{
"ledger_request",
"4294967295",
"spare"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ledger_request: text ledger index.", __LINE__,
{
"ledger_request",
"current"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger_request: ledger index too small.", __LINE__,
{
"ledger_request",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
{
"ledger_request: ledger index too big.", __LINE__,
{
"ledger_request",
"4294967296"
},
RPCCallTestData::no_exception,
R"({
"method" : "ledger_request",
"params" : [
{
"ledger_index" : 0
}
]
})"
},
// log_level -------------------------------------------------------------------
{
"log_level: minimal.", __LINE__,
{
"log_level",
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level"
})"
},
{
"log_level: fatal.", __LINE__,
{
"log_level",
"fatal"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "fatal"
}
]
})"
},
{
"log_level: error.", __LINE__,
{
"log_level",
"error"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "error"
}
]
})"
},
{
"log_level: warn.", __LINE__,
{
"log_level",
"warn"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "warn"
}
]
})"
},
{
"log_level: debug.", __LINE__,
{
"log_level",
"debug"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "debug"
}
]
})"
},
{
"log_level: trace.", __LINE__,
{
"log_level",
"trace"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "trace"
}
]
})"
},
{
"log_level: base partition.", __LINE__,
{
"log_level",
"base",
"trace"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"partition" : "base",
"severity" : "trace"
}
]
})"
},
{
"log_level: partiton_name.", __LINE__,
{
"log_level",
"partition_name",
"fatal"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"partition" : "partition_name",
"severity" : "fatal"
}
]
})"
},
{
"log_level: too many arguments.", __LINE__,
{
"log_level",
"partition_name",
"fatal",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"log_level: invalid severity.", __LINE__,
{
"log_level",
"err"
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"severity" : "err"
}
]
})"
},
{
"log_level: swap partition name and severity.", __LINE__,
{
"log_level",
"fatal",
"partition_name",
},
RPCCallTestData::no_exception,
R"({
"method" : "log_level",
"params" : [
{
"partition" : "fatal",
"severity" : "partition_name"
}
]
})"
},
// logrotate -------------------------------------------------------------------
{
"logrotate: minimal.", __LINE__,
{
"logrotate",
},
RPCCallTestData::no_exception,
R"({
"method" : "logrotate"
})"
},
{
"logrotate: too many arguments.", __LINE__,
{
"logrotate",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "logrotate",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// owner_info ------------------------------------------------------------------
{
"owner_info: minimal.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
}
]
})"
},
{
"owner_info: with numeric ledger index.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"987654321"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 987654321
}
]
})"
},
{
"owner_info: with text ledger index.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : "validated"
}
]
})"
},
{
"owner_info: with ledger hash.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_hash" : "0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF0123456789ABCDEF"
}
]
})"
},
{
// Note: this works, but it doesn't match the documentation.
"owner_info: strict.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"strict" : 1
}
]
})"
},
{
"owner_info: with ledger index and strict.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"validated",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"owner_info: too few arguments.", __LINE__,
{
"owner_info",
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"owner_info: too many arguments.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"current",
"extra",
"strict",
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"owner_info: invalid accountID.", __LINE__,
{
"owner_info",
"", // Note: very few values are detected as bad!
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"owner_info: invalid ledger selection 1.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})",
},
{
// Note: there is code in place to return rpcLGR_IDX_MALFORMED. That
// cannot currently occur because jvParseLedger() always returns true.
"owner_info: invalid ledger selection 2.", __LINE__,
{
"owner_info",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"no_ledger",
"strict"
},
RPCCallTestData::no_exception,
R"({
"method" : "owner_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})",
},
// peers -----------------------------------------------------------------------
{
"peers: minimal.", __LINE__,
{
"peers",
},
RPCCallTestData::no_exception,
R"({
"method" : "peers"
})"
},
{
"peers: too many arguments.", __LINE__,
{
"peers",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "peers",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// ping ------------------------------------------------------------------------
{
"ping: minimal.", __LINE__,
{
"ping",
},
RPCCallTestData::no_exception,
R"({
"method" : "ping"
})"
},
{
"ping: too many arguments.", __LINE__,
{
"ping",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "ping",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// print -----------------------------------------------------------------------
{
"print: minimal.", __LINE__,
{
"print",
},
RPCCallTestData::no_exception,
R"({
"method" : "print"
})"
},
{
// The docs indicate that no arguments are allowed. So should this error?
"print: extra argument.", __LINE__,
{
"print",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "print",
"params" : [
{
"params" : [ "extra" ]
}
]
})"
},
{
"print: too many arguments.", __LINE__,
{
"print",
"extra1",
"extra2"
},
RPCCallTestData::no_exception,
R"({
"method" : "print",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// random ----------------------------------------------------------------------
{
"random: minimal.", __LINE__,
{
"random",
},
RPCCallTestData::no_exception,
R"({
"method" : "random"
})"
},
{
"random: too many arguments.", __LINE__,
{
"random",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "random",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// ripple_path_find ------------------------------------------------------------
{
"ripple_path_find: minimal.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true
}
]
})"
},
{
"ripple_path_find: ledger index.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_index" : 4294967295
}
]
})"
},
{
"ripple_path_find: text ledger index.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"closed"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_index" : "closed"
}
]
})"
},
{
"ripple_path_find: ledger hash.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"ripple_path_find: too few arguments.", __LINE__,
{
"ripple_path_find",
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ripple_path_find: too many arguments.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"current",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"ripple_path_find: invalid json (note extra comma).", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"ripple_path_find: ledger index too small.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"-1"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_index" : 0
}
]
})"
},
{
"ripple_path_find: ledger index too big.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"4294967296"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_index" : 0
}
]
})"
},
{
"ripple_path_find: invalid text ledger index.", __LINE__,
{
"ripple_path_find",
R"({"json_argument":true})",
"cur"
},
RPCCallTestData::no_exception,
R"({
"method" : "ripple_path_find",
"params" : [
{
"json_argument" : true,
"ledger_index" : 0
}
]
})"
},
// sign ------------------------------------------------------------------------
{
"sign: minimal.", __LINE__,
{
"sign",
"my_secret",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"sign: offline.", __LINE__,
{
"sign",
"my_secret",
R"({"json_argument":true})",
"offline"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"offline" : true,
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"sign: too few arguments.", __LINE__,
{
"sign",
"contents_of_blob"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"sign: too many arguments.", __LINE__,
{
"sign",
"my_secret",
R"({"json_argument":true})",
"offline",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"sign: invalid JSON (note extra comma).", __LINE__,
{
"sign",
"my_secret",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"sign: invalid final argument.", __LINE__,
{
"sign",
"my_secret",
R"({"json_argument":true})",
"offlin"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// sign_for --------------------------------------------------------------------
{
"sign_for: minimal.", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"sign_for: offline.", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
R"({"json_argument":true})",
"offline"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"offline" : true,
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"sign_for: too few arguments.", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"sign_for: too many arguments.", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
R"({"json_argument":true})",
"offline",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"sign_for: invalid json (note extra comma).", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"sign_for: invalid final argument.", __LINE__,
{
"sign_for",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"my_secret",
R"({"json_argument":true})",
"ofline"
},
RPCCallTestData::no_exception,
R"({
"method" : "sign_for",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// submit ----------------------------------------------------------------------
{
"submit: blob.", __LINE__,
{
"submit",
"the blob is unvalidated and may be any length..."
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"tx_blob" : "the blob is unvalidated and may be any length..."
}
]
})"
},
{
"submit: json.", __LINE__,
{
"submit",
"my_secret",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"submit: too few arguments.", __LINE__,
{
"submit",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: I believe this _ought_ to be detected as too many arguments.
"submit: four arguments.", __LINE__,
{
"submit",
"my_secret",
R"({"json_argument":true})",
"offline"
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"offline" : true,
"secret" : "my_secret",
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"submit: too many arguments.", __LINE__,
{
"submit",
"my_secret",
R"({"json_argument":true})",
"offline",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"submit: invalid json (note extra comma).", __LINE__,
{
"submit",
"my_secret",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"submit: last argument not \"offline\".", __LINE__,
{
"submit",
"my_secret",
R"({"json_argument":true})",
"offlne"
},
RPCCallTestData::no_exception,
R"({
"method" : "submit",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// submit_multisigned ----------------------------------------------------------
{
"submit_multisigned: json.", __LINE__,
{
"submit_multisigned",
R"({"json_argument":true})",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit_multisigned",
"params" : [
{
"tx_json" : {
"json_argument" : true
}
}
]
})"
},
{
"submit_multisigned: too few arguments.", __LINE__,
{
"submit_multisigned",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit_multisigned",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"submit_multisigned: too many arguments.", __LINE__,
{
"submit_multisigned",
R"({"json_argument":true})",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "submit_multisigned",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"submit_multisigned: invalid json (note extra comma).", __LINE__,
{
"submit_multisigned",
R"({"json_argument":true,})",
},
RPCCallTestData::no_exception,
R"({
"method" : "submit_multisigned",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
}
]
})"
},
// server_info -----------------------------------------------------------------
{
"server_info: minimal.", __LINE__,
{
"server_info",
},
RPCCallTestData::no_exception,
R"({
"method" : "server_info",
})"
},
{
"server_info: counters.", __LINE__,
{
"server_info",
"counters"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_info",
"params" : [
{
"counters" : true
}
]
})"
},
{
"server_info: too many arguments.", __LINE__,
{
"server_info",
"counters",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_info",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"server_info: non-counters argument.", __LINE__,
{
"server_info",
"counter"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_info",
})"
},
// server_state ----------------------------------------------------------------
{
"server_state: minimal.", __LINE__,
{
"server_state",
},
RPCCallTestData::no_exception,
R"({
"method" : "server_state",
})"
},
{
"server_state: counters.", __LINE__,
{
"server_state",
"counters"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_state",
"params" : [
{
"counters" : true
}
]
})"
},
{
"server_state: too many arguments.", __LINE__,
{
"server_state",
"counters",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_state",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"server_state: non-counters argument.", __LINE__,
{
"server_state",
"counter"
},
RPCCallTestData::no_exception,
R"({
"method" : "server_state",
})"
},
// stop ------------------------------------------------------------------------
{
"stop: minimal.", __LINE__,
{
"stop",
},
RPCCallTestData::no_exception,
R"({
"method" : "stop",
})"
},
{
"stop: too many arguments.", __LINE__,
{
"stop",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "stop",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// transaction_entry -----------------------------------------------------------
{
"transaction_entry: ledger index.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"ledger_index" : 4294967295,
"tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"transaction_entry: text ledger index.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"current"
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"ledger_index" : "current",
"tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"transaction_entry: ledger hash.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210"
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"ledger_hash" : "VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210",
"tx_hash" : "0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV"
}
]
})"
},
{
"transaction_entry: too few arguments.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"transaction_entry: too many arguments.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"validated",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"transaction_entry: short tx_hash.", __LINE__,
{
"transaction_entry",
"123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"validated",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"transaction_entry: long tx_hash.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUVW",
"validated",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"transaction_entry: small ledger index.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"0",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"transaction_entry: large ledger index.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"4294967296",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"transaction_entry: short ledger hash.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA987654321",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
{
"transaction_entry: long ledger hash.", __LINE__,
{
"transaction_entry",
"0123456789ABCDEFGHIJKLMNOPQRSTUV0123456789ABCDEFGHIJKLMNOPQRSTUV",
"VUTSRQPONMLKJIHGFEDCBA9876543210VUTSRQPONMLKJIHGFEDCBA9876543210Z",
},
RPCCallTestData::no_exception,
R"({
"method" : "transaction_entry",
"params" : [
{
"error" : "invalidParams",
"error_code" : 31,
"error_message" : "Invalid parameters."
}
]
})"
},
// tx --------------------------------------------------------------------------
{
"tx: minimal.", __LINE__,
{
"tx",
"transaction_hash_is_not_validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx",
"params" : [
{
"transaction" : "transaction_hash_is_not_validated"
}
]
})"
},
{
"tx: binary.", __LINE__,
{
"tx",
"transaction_hash_is_not_validated",
"binary"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx",
"params" : [
{
"binary" : true,
"transaction" : "transaction_hash_is_not_validated"
}
]
})"
},
{
"tx: too few arguments.", __LINE__,
{
"tx",
},
RPCCallTestData::no_exception,
R"({
"method" : "tx",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"tx: too many arguments.", __LINE__,
{
"tx",
"transaction_hash_is_not_validated",
"binary",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"tx: invalid final argument is apparently ignored.", __LINE__,
{
"tx",
"transaction_hash_is_not_validated",
"bin"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx",
"params" : [
{
"transaction" : "transaction_hash_is_not_validated"
}
]
})"
},
// tx_account ------------------------------------------------------------------
{
"tx_account: minimal.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
}
]
})"
},
{
"tx_account: ledger_index .", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"4294967295"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 4294967295
}
]
})"
},
{
"tx_account: ledger_index plus trailing params.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"707",
"forward",
"binary",
"count"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"binary" : true,
"count" : true,
"forward" : true,
"ledger_index" : 707
}
]
})"
},
{
"tx_account: ledger_index_min and _max.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"2147483647",
"2147483647"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index_max" : 2147483647,
"ledger_index_min" : 2147483647
}
]
})"
},
{
"tx_account: ledger_index_min and _max plus trailing params.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"33333",
"2147483647",
"binary",
"count",
"forward"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"binary" : true,
"count" : true,
"forward" : true,
"ledger_index_max" : 2147483647,
"ledger_index_min" : 33333
}
]
})"
},
{
"tx_account: ledger_index_min and _max plus limit.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"2147483647",
"2147483647"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index_max" : 2147483647,
"ledger_index_min" : -1,
"limit" : 2147483647
}
]
})"
},
{
"tx_account: ledger_index_min and _max, limit, trailing args.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"1",
"1",
"-1",
"count",
"forward",
"binary"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"binary" : true,
"count" : true,
"forward" : true,
"ledger_index_max" : 1,
"ledger_index_min" : 1,
"limit" : -1
}
]
})"
},
{
"tx_account: too few arguments.", __LINE__,
{
"tx_account",
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"tx_account: too many arguments.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"589",
"590",
"67",
"extra",
"descending",
"count",
"binary"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"tx_account: invalid accountID.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj9!VRWn96DkukG4bwdtyTh"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"error" : "actMalformed",
"error_code" : 35,
"error_message" : "Account malformed."
}
]
})",
},
{
// Note: not currently detected as bad input.
"tx_account: invalid ledger.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-478.7"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"account" : "rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"ledger_index" : 0
}
]
})",
},
{
"tx_account: max less than min.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"580",
"579"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_account",
"params" : [
{
"error" : "lgrIdxsInvalid",
"error_code" : 55,
"error_message" : "Ledger indexes invalid."
}
]
})",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: min large but still valid.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"2147483648",
"2147483648"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: max large but still valid.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"2147483647",
"2147483648"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: large limit.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1",
"2147483648"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: non-integer min.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"Binary",
"-1"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: non-integer max.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"counts"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_account: non-integer limit.", __LINE__,
{
"tx_account",
"rHb9CJAWyB4rj91VRWn96DkukG4bwdtyTh",
"-1",
"-1",
"decending"
},
RPCCallTestData::bad_cast,
R"()",
},
// tx_history ------------------------------------------------------------------
{
"tx_history: minimal.", __LINE__,
{
"tx_history",
"0"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_history",
"params" : [
{
"start" : 0
}
]
})"
},
{
"tx_history: too few arguments.", __LINE__,
{
"tx_history",
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_history",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
"tx_history: too many arguments.", __LINE__,
{
"tx_history",
"0",
"1"
},
RPCCallTestData::no_exception,
R"({
"method" : "tx_history",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_history: start too small.", __LINE__,
{
"tx_history",
"-1"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_history: start too big.", __LINE__,
{
"tx_history",
"4294967296"
},
RPCCallTestData::bad_cast,
R"()",
},
{
// Note: this really shouldn't throw, but does at the moment.
"tx_history: start not integer.", __LINE__,
{
"tx_history",
"beginning"
},
RPCCallTestData::bad_cast,
R"()",
},
// unl_list --------------------------------------------------------------------
{
"unl_list: minimal.", __LINE__,
{
"unl_list",
},
RPCCallTestData::no_exception,
R"({
"method" : "unl_list",
})"
},
{
"unl_list: too many arguments.", __LINE__,
{
"unl_list",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "unl_list",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// validation_create -----------------------------------------------------------
{
"validation_create: minimal.", __LINE__,
{
"validation_create",
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_create"
})"
},
{
"validation_create: with secret.", __LINE__,
{
"validation_create",
"the form of the secret is not validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_create",
"params" : [
{
"secret" : "the form of the secret is not validated"
}
]
})"
},
{
"validation_create: too many arguments.", __LINE__,
{
"validation_create",
"the form of the secret is not validated",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_create",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// validation_seed -------------------------------------------------------------
{
"validation_seed: minimal.", __LINE__,
{
"validation_seed",
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_seed"
})"
},
{
"validation_seed: with secret.", __LINE__,
{
"validation_seed",
"the form of the secret is not validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_seed",
"params" : [
{
"secret" : "the form of the secret is not validated"
}
]
})"
},
{
"validation_seed: too many arguments.", __LINE__,
{
"validation_seed",
"the form of the secret is not validated",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "validation_seed",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// version ---------------------------------------------------------------------
{
"version: minimal.", __LINE__,
{
"version",
},
RPCCallTestData::no_exception,
R"({
"method" : "version",
})"
},
{
"version: too many arguments.", __LINE__,
{
"version",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "version",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// wallet_propose --------------------------------------------------------------
{
"wallet_propose: minimal.", __LINE__,
{
"wallet_propose",
},
RPCCallTestData::no_exception,
R"({
"method" : "wallet_propose"
})"
},
{
"wallet_propose: with passphrase.", __LINE__,
{
"wallet_propose",
"the form of the passphrase is not validated"
},
RPCCallTestData::no_exception,
R"({
"method" : "wallet_propose",
"params" : [
{
"passphrase" : "the form of the passphrase is not validated"
}
]
})"
},
{
"wallet_propose: too many arguments.", __LINE__,
{
"wallet_propose",
"the form of the passphrase is not validated",
"extra"
},
RPCCallTestData::no_exception,
R"({
"method" : "wallet_propose",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// internal --------------------------------------------------------------------
{
"internal: minimal.", __LINE__,
{
"internal",
"command_name"
},
RPCCallTestData::no_exception,
R"({
"method" : "internal",
"params" : [
{
"internal_command" : "command_name",
"params" : []
}
]
})"
},
{
"internal: with parameters.", __LINE__,
{
"internal",
"command_name",
"string_arg",
"1",
"-1",
"4294967296",
"3.14159"
},
RPCCallTestData::no_exception,
R"({
"method" : "internal",
"params" : [
{
"internal_command" : "command_name",
"params" : [ "string_arg", "1", "-1", "4294967296", "3.14159" ]
}
]
})"
},
{
"internal: too few arguments.", __LINE__,
{
"internal",
},
RPCCallTestData::no_exception,
R"({
"method" : "internal",
"params" : [
{
"error" : "badSyntax",
"error_code" : 1,
"error_message" : "Syntax error."
}
]
})"
},
// path_find -------------------------------------------------------------------
{
"path_find: minimal.", __LINE__,
{
"path_find",
},
RPCCallTestData::no_exception,
R"({
"method" : "path_find",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
{
"path_find: with arguments.", __LINE__,
{
"path_find",
"string_arg",
"1",
"-1",
"4294967296",
"3.14159"
},
RPCCallTestData::no_exception,
R"({
"method" : "path_find",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
// subscribe -------------------------------------------------------------------
{
"subscribe: minimal.", __LINE__,
{
"subscribe",
},
RPCCallTestData::no_exception,
R"({
"method" : "subscribe",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
{
"subscribe: with arguments.", __LINE__,
{
"subscribe",
"string_arg",
"1",
"-1",
"4294967296",
"3.14159"
},
RPCCallTestData::no_exception,
R"({
"method" : "subscribe",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
// unsubscribe -----------------------------------------------------------------
{
"unsubscribe: minimal.", __LINE__,
{
"unsubscribe",
},
RPCCallTestData::no_exception,
R"({
"method" : "unsubscribe",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
{
"unsubscribe: with arguments.", __LINE__,
{
"unsubscribe",
"string_arg",
"1",
"-1",
"4294967296",
"3.14159"
},
RPCCallTestData::no_exception,
R"({
"method" : "unsubscribe",
"params" : [
{
"error" : "noEvents",
"error_code" : 7,
"error_message" : "Current transport does not support events."
}
]
})"
},
// unknown_command -------------------------------------------------------------
{
"unknown_command: minimal.", __LINE__,
{
"unknown_command",
},
RPCCallTestData::no_exception,
R"({
"method" : "unknown_command"
})"
},
{
"unknown_command: with arguments.", __LINE__,
{
"unknown_command",
"string_arg",
"1",
"-1",
"4294967296",
"3.14159"
},
RPCCallTestData::no_exception,
R"({
"method" : "unknown_command",
"params" : [
{
"params" : [ "string_arg", "1", "-1", "4294967296", "3.14159" ]
}
]
})"
},
};
class RPCCall_test : public beast::unit_test::suite
{
public:
void testRPCCall()
{
testcase << "RPCCall";
test::jtx::Env env(*this); // Used only for its Journal.
// For each RPCCall test.
for (RPCCallTestData const& rpcCallTest : rpcCallTestArray)
{
std::vector<std::string> const args {
rpcCallTest.args.begin(), rpcCallTest.args.end()};
// Note that, over the long term, none of these tests should
// throw. But, for the moment, some of them do. So handle it.
Json::Value got;
try
{
got = cmdLineToJSONRPC (args, env.journal);
}
catch (std::bad_cast const&)
{
if ((rpcCallTest.throwsWhat == RPCCallTestData::bad_cast) &&
(std::strlen (rpcCallTest.exp) == 0))
{
pass();
}
else
{
fail (rpcCallTest.description, __FILE__, rpcCallTest.line);
}
// Try the next test.
continue;
}
Json::Value exp;
Json::Reader{}.parse (rpcCallTest.exp, exp);
// If there is an "error_code" field, remove it. Error codes
// are not expected to stay stable between releases.
got.removeMember ("error_code");
exp.removeMember ("error_code");
// Pass if we didn't expect a throw and we got what we expected.
if ((rpcCallTest.throwsWhat == RPCCallTestData::no_exception) &&
(got == exp))
{
pass();
}
else
{
fail (rpcCallTest.description, __FILE__, rpcCallTest.line);
}
}
}
void run() override
{
testRPCCall();
}
};
BEAST_DEFINE_TESTSUITE(RPCCall,app,ripple);
} // test
} // ripple
Reference in New Issue View Git Blame Copy Permalink