ARCHIVE/xahaud
3
0
Fork 0
mirror of https://github.com/Xahau/xahaud.git synced 2025-12-06 17:27:52 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
fd7a2835e475f68802d4ab0d9d5a0d898c099218
xahaud/src/test/Env_test.cpp
Brad Chase 8f97889176 Don't include unit test sources in code coverage (RIPD-1132): 
Most files containing unit test code are moved to
src/test. JTx and the test client code are not yet moved.
2016-09-02 15:26:16 -04:00

658 lines
21 KiB
C++
Raw Blame History

//------------------------------------------------------------------------------
/*
This file is part of rippled: https://github.com/ripple/rippled
Copyright (c) 2012, 2013 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 <BeastConfig.h>
#include <ripple/basics/Log.h>
#include <ripple/test/jtx.h>
#include <ripple/json/to_string.h>
#include <ripple/protocol/Feature.h>
#include <ripple/protocol/JsonFields.h>
#include <ripple/protocol/TxFlags.h>
#include <ripple/beast/hash/uhash.h>
#include <ripple/beast/unit_test.h>
#include <boost/lexical_cast.hpp>
#include <utility>
namespace ripple {
namespace test {
class Env_test : public beast::unit_test::suite
{
public:
template <class T>
static
std::string
to_string (T const& t)
{
return boost::lexical_cast<
std::string>(t);
}
// Declarations in Account.h
void
testAccount()
{
using namespace jtx;
{
Account a;
Account b(a);
a = b;
a = std::move(b);
Account c(std::move(a));
}
Account("alice");
Account("alice", KeyType::secp256k1);
Account("alice", KeyType::ed25519);
auto const gw = Account("gw");
[](AccountID){}(gw);
auto const USD = gw["USD"];
void(Account("alice") < gw);
std::set<Account>().emplace(gw);
std::unordered_set<Account,
beast::uhash<>>().emplace("alice");
}
// Declarations in amount.h
void
testAmount()
{
using namespace jtx;
PrettyAmount(0);
PrettyAmount(1);
PrettyAmount(0u);
PrettyAmount(1u);
PrettyAmount(-1);
static_assert(! std::is_constructible<
PrettyAmount, char>::value, "");
static_assert(! std::is_constructible<
PrettyAmount, unsigned char>::value, "");
static_assert(! std::is_constructible<
PrettyAmount, short>::value, "");
static_assert(! std::is_constructible<
PrettyAmount, unsigned short>::value, "");
try
{
XRP(0.0000001);
fail("missing exception");
}
catch(std::domain_error const&)
{
pass();
}
XRP(-0.000001);
try
{
XRP(-0.0000009);
fail("missing exception");
}
catch(std::domain_error const&)
{
pass();
}
BEAST_EXPECT(to_string(XRP(5)) == "5 XRP");
BEAST_EXPECT(to_string(XRP(.80)) == "0.8 XRP");
BEAST_EXPECT(to_string(XRP(.005)) == "5000 drops");
BEAST_EXPECT(to_string(XRP(0.1)) == "0.1 XRP");
BEAST_EXPECT(to_string(XRP(10000)) == "10000 XRP");
BEAST_EXPECT(to_string(drops(10)) == "10 drops");
BEAST_EXPECT(to_string(drops(123400000)) == "123.4 XRP");
BEAST_EXPECT(to_string(XRP(-5)) == "-5 XRP");
BEAST_EXPECT(to_string(XRP(-.99)) == "-0.99 XRP");
BEAST_EXPECT(to_string(XRP(-.005)) == "-5000 drops");
BEAST_EXPECT(to_string(XRP(-0.1)) == "-0.1 XRP");
BEAST_EXPECT(to_string(drops(-10)) == "-10 drops");
BEAST_EXPECT(to_string(drops(-123400000)) == "-123.4 XRP");
BEAST_EXPECT(XRP(1) == drops(1000000));
BEAST_EXPECT(XRP(1) == STAmount(1000000));
BEAST_EXPECT(STAmount(1000000) == XRP(1));
auto const gw = Account("gw");
auto const USD = gw["USD"];
BEAST_EXPECT(to_string(USD(0)) == "0/USD(gw)");
BEAST_EXPECT(to_string(USD(10)) == "10/USD(gw)");
BEAST_EXPECT(to_string(USD(-10)) == "-10/USD(gw)");
BEAST_EXPECT(USD(0) == STAmount(USD, 0));
BEAST_EXPECT(USD(1) == STAmount(USD, 1));
BEAST_EXPECT(USD(-1) == STAmount(USD, -1));
auto const get = [](AnyAmount a){ return a; };
BEAST_EXPECT(! get(USD(10)).is_any);
BEAST_EXPECT(get(any(USD(10))).is_any);
}
// Test Env
void
testEnv()
{
using namespace jtx;
auto const n = XRP(10000);
auto const gw = Account("gw");
auto const USD = gw["USD"];
auto const alice = Account("alice");
// unfunded
{
Env env(*this);
env(pay("alice", "bob", XRP(1000)), seq(1), fee(10), sig("alice"), ter(terNO_ACCOUNT));
}
// fund
{
Env env(*this);
// variadics
env.fund(n, "alice");
env.fund(n, "bob", "carol");
env.fund(n, "dave", noripple("eric"));
env.fund(n, "fred", noripple("gary", "hank"));
env.fund(n, noripple("irene"));
env.fund(n, noripple("jim"), "karen");
env.fund(n, noripple("lisa", "mary"));
// flags
env.fund(n, noripple("xavier"));
env.require(nflags("xavier", asfDefaultRipple));
env.fund(n, "yana");
env.require(flags("yana", asfDefaultRipple));
}
// trust
{
Env env(*this);
env.fund(n, "alice", "bob", gw);
env(trust("alice", USD(100)), require(lines("alice", 1)));
}
// balance
{
Env env(*this);
BEAST_EXPECT(env.balance(alice) == 0);
BEAST_EXPECT(env.balance(alice, USD) != 0);
BEAST_EXPECT(env.balance(alice, USD) == USD(0));
env.fund(n, alice, gw);
BEAST_EXPECT(env.balance(alice) == n);
BEAST_EXPECT(env.balance(gw) == n);
env.trust(USD(1000), alice);
env(pay(gw, alice, USD(10)));
BEAST_EXPECT(to_string(env.balance("alice", USD)) == "10/USD(gw)");
BEAST_EXPECT(to_string(env.balance(gw, alice["USD"])) == "-10/USD(alice)");
}
// seq
{
Env env(*this);
env.fund(n, noripple("alice", gw));
BEAST_EXPECT(env.seq("alice") == 1);
BEAST_EXPECT(env.seq(gw) == 1);
}
// autofill
{
Env env(*this);
env.fund(n, "alice");
env.require(balance("alice", n));
env(noop("alice"), fee(1), ter(telINSUF_FEE_P));
env(noop("alice"), seq(none), ter(temMALFORMED));
env(noop("alice"), seq(none), fee(10), ter(temMALFORMED));
env(noop("alice"), fee(none), ter(temMALFORMED));
env(noop("alice"), sig(none), ter(temMALFORMED));
env(noop("alice"), fee(autofill));
env(noop("alice"), fee(autofill), seq(autofill));
env(noop("alice"), fee(autofill), seq(autofill), sig(autofill));
}
}
// Env::require
void
testRequire()
{
using namespace jtx;
Env env(*this);
auto const gw = Account("gw");
auto const USD = gw["USD"];
env.require(balance("alice", none));
env.require(balance("alice", XRP(none)));
env.fund(XRP(10000), "alice", gw);
env.require(balance("alice", USD(none)));
env.trust(USD(100), "alice");
env.require(balance("alice", XRP(10000))); // fee refunded
env.require(balance("alice", USD(0)));
env(pay(gw, "alice", USD(10)), require(balance("alice", USD(10))));
env.require(nflags("alice", asfRequireDest));
env(fset("alice", asfRequireDest), require(flags("alice", asfRequireDest)));
env(fclear("alice", asfRequireDest), require(nflags("alice", asfRequireDest)));
}
// Signing with secp256k1 and ed25519 keys
void
testKeyType()
{
using namespace jtx;
Env env(*this);
Account const alice("alice", KeyType::ed25519);
Account const bob("bob", KeyType::secp256k1);
Account const carol("carol");
env.fund(XRP(10000), alice, bob);
// Master key only
env(noop(alice));
env(noop(bob));
env(noop(alice), sig("alice"), ter(tefBAD_AUTH_MASTER));
env(noop(alice), sig(Account("alice",
KeyType::secp256k1)), ter(tefBAD_AUTH_MASTER));
env(noop(bob), sig(Account("bob",
KeyType::ed25519)), ter(tefBAD_AUTH_MASTER));
env(noop(alice), sig(carol), ter(tefBAD_AUTH_MASTER));
// Master and Regular key
env(regkey(alice, bob));
env(noop(alice));
env(noop(alice), sig(bob));
env(noop(alice), sig(alice));
// Regular key only
env(fset(alice, asfDisableMaster), sig(alice));
env(noop(alice));
env(noop(alice), sig(bob));
env(noop(alice), sig(alice), ter(tefMASTER_DISABLED));
env(fclear(alice, asfDisableMaster), sig(alice), ter(tefMASTER_DISABLED));
env(fclear(alice, asfDisableMaster), sig(bob));
env(noop(alice), sig(alice));
}
// Payment basics
void
testPayments()
{
using namespace jtx;
Env env(*this);
auto const gw = Account("gateway");
auto const USD = gw["USD"];
env.fund(XRP(10000), "alice", "bob", "carol", gw);
env.require(balance("alice", XRP(10000)));
env.require(balance("bob", XRP(10000)));
env.require(balance("carol", XRP(10000)));
env.require(balance(gw, XRP(10000)));
env(pay(env.master, "alice", XRP(1000)), fee(none), ter(temMALFORMED));
env(pay(env.master, "alice", XRP(1000)), fee(1), ter(telINSUF_FEE_P));
env(pay(env.master, "alice", XRP(1000)), seq(none), ter(temMALFORMED));
env(pay(env.master, "alice", XRP(1000)), seq(20), ter(terPRE_SEQ));
env(pay(env.master, "alice", XRP(1000)), sig(none), ter(temMALFORMED));
env(pay(env.master, "alice", XRP(1000)), sig("bob"), ter(tefBAD_AUTH_MASTER));
env(pay(env.master, "dilbert", XRP(1000)), sig(env.master));
env.trust(USD(100), "alice", "bob", "carol");
env.require(owners("alice", 1), lines("alice", 1));
env(rate(gw, 1.05));
env(pay(gw, "carol", USD(50)));
env.require(balance("carol", USD(50)));
env.require(balance(gw, Account("carol")["USD"](-50)));
env(offer("carol", XRP(50), USD(50)), require(owners("carol", 2)));
env(pay("alice", "bob", any(USD(10))), ter(tecPATH_DRY));
env(pay("alice", "bob", any(USD(10))),
paths(XRP), sendmax(XRP(10)), ter(tecPATH_PARTIAL));
env(pay("alice", "bob", any(USD(10))), paths(XRP),
sendmax(XRP(20)));
env.require(balance("bob", USD(10)));
env.require(balance("carol", USD(39.5)));
env.memoize("eric");
env(regkey("alice", "eric"));
env(noop("alice"));
env(noop("alice"), sig("alice"));
env(noop("alice"), sig("eric"));
env(noop("alice"), sig("bob"), ter(tefBAD_AUTH));
env(fset("alice", asfDisableMaster), ter(tecNEED_MASTER_KEY));
env(fset("alice", asfDisableMaster), sig("eric"), ter(tecNEED_MASTER_KEY));
env.require(nflags("alice", asfDisableMaster));
env(fset("alice", asfDisableMaster), sig("alice"));
env.require(flags("alice", asfDisableMaster));
env(regkey("alice", disabled), ter(tecNO_ALTERNATIVE_KEY));
env(noop("alice"));
env(noop("alice"), sig("alice"), ter(tefMASTER_DISABLED));
env(noop("alice"), sig("eric"));
env(noop("alice"), sig("bob"), ter(tefBAD_AUTH));
env(fclear("alice", asfDisableMaster), sig("bob"), ter(tefBAD_AUTH));
env(fclear("alice", asfDisableMaster), sig("alice"), ter(tefMASTER_DISABLED));
env(fclear("alice", asfDisableMaster));
env.require(nflags("alice", asfDisableMaster));
env(regkey("alice", disabled));
env(noop("alice"), sig("eric"), ter(tefBAD_AUTH_MASTER));
env(noop("alice"));
}
// Multi-sign basics
void
testMultiSign()
{
using namespace jtx;
Env env(*this, features(featureMultiSign));
env.fund(XRP(10000), "alice");
env(signers("alice", 1,
{ { "alice", 1 }, { "bob", 2 } }), ter(temBAD_SIGNER));
env(signers("alice", 1,
{ { "bob", 1 }, { "carol", 2 } }));
env(noop("alice"));
auto const baseFee = env.current()->fees().base;
env(noop("alice"), msig("bob"), fee(2 * baseFee));
env(noop("alice"), msig("carol"), fee(2 * baseFee));
env(noop("alice"), msig("bob", "carol"), fee(3 * baseFee));
env(noop("alice"), msig("bob", "carol", "dilbert"),
fee(4 * baseFee), ter(tefBAD_SIGNATURE));
env(signers("alice", none));
}
void
testTicket()
{
using namespace jtx;
// create syntax
ticket::create("alice", "bob");
ticket::create("alice", 60);
ticket::create("alice", "bob", 60);
ticket::create("alice", 60, "bob");
{
Env env(*this, features(featureTickets));
env.fund(XRP(10000), "alice");
env(noop("alice"), require(owners("alice", 0), tickets("alice", 0)));
env(ticket::create("alice"), require(owners("alice", 1), tickets("alice", 1)));
env(ticket::create("alice"), require(owners("alice", 2), tickets("alice", 2)));
}
}
struct UDT
{
};
void testJTxProperties()
{
struct T { };
using namespace jtx;
JTx jt1;
// Test a straightforward
// property
BEAST_EXPECT(!jt1.get<int>());
jt1.set<int>(7);
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 7);
BEAST_EXPECT(!jt1.get<UDT>());
// Test that the property is
// replaced if it exists.
jt1.set<int>(17);
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 17);
BEAST_EXPECT(!jt1.get<UDT>());
// Test that modifying the
// returned prop is saved
*jt1.get<int>() = 42;
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 42);
BEAST_EXPECT(!jt1.get<UDT>());
// Test get() const
auto const& jt2 = jt1;
BEAST_EXPECT(jt2.get<int>());
BEAST_EXPECT(*jt2.get<int>() == 42);
BEAST_EXPECT(!jt2.get<UDT>());
}
void testProp()
{
using namespace jtx;
Env env(*this);
env.fund(XRP(100000), "alice");
auto jt1 = env.jt(noop("alice"));
BEAST_EXPECT(!jt1.get<std::uint16_t>());
auto jt2 = env.jt(noop("alice"),
prop<std::uint16_t>(-1));
BEAST_EXPECT(jt2.get<std::uint16_t>());
BEAST_EXPECT(*jt2.get<std::uint16_t>() ==
65535);
auto jt3 = env.jt(noop("alice"),
prop<std::string>(
"Hello, world!"),
prop<bool>(false));
BEAST_EXPECT(jt3.get<std::string>());
BEAST_EXPECT(*jt3.get<std::string>() ==
"Hello, world!");
BEAST_EXPECT(jt3.get<bool>());
BEAST_EXPECT(!*jt3.get<bool>());
}
void testJTxCopy()
{
struct T { };
using namespace jtx;
JTx jt1;
jt1.set<int>(7);
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 7);
BEAST_EXPECT(!jt1.get<UDT>());
JTx jt2(jt1);
BEAST_EXPECT(jt2.get<int>());
BEAST_EXPECT(*jt2.get<int>() == 7);
BEAST_EXPECT(!jt2.get<UDT>());
JTx jt3;
jt3 = jt1;
BEAST_EXPECT(jt3.get<int>());
BEAST_EXPECT(*jt3.get<int>() == 7);
BEAST_EXPECT(!jt3.get<UDT>());
}
void testJTxMove()
{
struct T { };
using namespace jtx;
JTx jt1;
jt1.set<int>(7);
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 7);
BEAST_EXPECT(!jt1.get<UDT>());
JTx jt2(std::move(jt1));
BEAST_EXPECT(!jt1.get<int>());
BEAST_EXPECT(!jt1.get<UDT>());
BEAST_EXPECT(jt2.get<int>());
BEAST_EXPECT(*jt2.get<int>() == 7);
BEAST_EXPECT(!jt2.get<UDT>());
jt1 = std::move(jt2);
BEAST_EXPECT(!jt2.get<int>());
BEAST_EXPECT(!jt2.get<UDT>());
BEAST_EXPECT(jt1.get<int>());
BEAST_EXPECT(*jt1.get<int>() == 7);
BEAST_EXPECT(!jt1.get<UDT>());
}
void
testMemo()
{
using namespace jtx;
Env env(*this);
env.fund(XRP(10000), "alice");
env(noop("alice"), memodata("data"));
env(noop("alice"), memoformat("format"));
env(noop("alice"), memotype("type"));
env(noop("alice"), memondata("format", "type"));
env(noop("alice"), memonformat("data", "type"));
env(noop("alice"), memontype("data", "format"));
env(noop("alice"), memo("data", "format", "type"));
env(noop("alice"), memo("data1", "format1", "type1"), memo("data2", "format2", "type2"));
}
void
testAdvance()
{
using namespace jtx;
Env env(*this);
auto seq = env.current()->seq();
BEAST_EXPECT(seq == env.closed()->seq() + 1);
env.close();
BEAST_EXPECT(env.closed()->seq() == seq);
BEAST_EXPECT(env.current()->seq() == seq + 1);
env.close();
BEAST_EXPECT(env.closed()->seq() == seq + 1);
BEAST_EXPECT(env.current()->seq() == seq + 2);
}
void
testClose()
{
using namespace jtx;
Env env(*this);
env.close();
env.close();
env.fund(XRP(100000), "alice", "bob");
env.close();
env(pay("alice", "bob", XRP(100)));
env.close();
env(noop("alice"));
env.close();
env(noop("bob"));
}
void
testPath()
{
using namespace jtx;
Env env(*this);
auto const gw = Account("gw");
auto const USD = gw["USD"];
env.fund(XRP(10000), "alice", "bob");
env.json(
pay("alice", "bob", USD(10)),
path(Account("alice")),
path("bob"),
path(USD),
path(~XRP),
path(~USD),
path("bob", USD, ~XRP, ~USD)
);
}
// Test that jtx can re-sign a transaction that's already been signed.
void testResignSigned()
{
using namespace jtx;
Env env(*this);
env.fund(XRP(10000), "alice");
auto const baseFee = env.current()->fees().base;
std::uint32_t const aliceSeq = env.seq ("alice");
// Sign jsonNoop.
Json::Value jsonNoop = env.json (
noop ("alice"), fee(baseFee), seq(aliceSeq), sig("alice"));
// Re-sign jsonNoop.
JTx jt = env.jt (jsonNoop);
env (jt);
}
void testSignAndSubmit()
{
using namespace jtx;
Env env(*this);
Env_ss envs(env);
auto const alice = Account("alice");
env.fund(XRP(10000), alice);
{
envs(noop(alice), fee(none), seq(none))();
// Make sure we get the right account back.
auto tx = env.tx();
if (BEAST_EXPECT(tx))
{
BEAST_EXPECT(tx->getAccountID(sfAccount) == alice.id());
BEAST_EXPECT(tx->getTxnType() == ttACCOUNT_SET);
}
}
{
auto params = Json::Value(Json::nullValue);
envs(noop(alice), fee(none), seq(none))(params);
// Make sure we get the right account back.
auto tx = env.tx();
if (BEAST_EXPECT(tx))
{
BEAST_EXPECT(tx->getAccountID(sfAccount) == alice.id());
BEAST_EXPECT(tx->getTxnType() == ttACCOUNT_SET);
}
}
{
auto params = Json::Value(Json::objectValue);
// Force the factor low enough to fail
params[jss::fee_mult_max] = 1;
params[jss::fee_div_max] = 2;
// RPC errors result in temINVALID
envs(noop(alice), fee(none),
seq(none), ter(temINVALID))(params);
auto tx = env.tx();
BEAST_EXPECT(!tx);
}
}
void
run()
{
testAccount();
testAmount();
testEnv();
testRequire();
testKeyType();
testPayments();
testMultiSign();
testTicket();
testJTxProperties();
testProp();
testJTxCopy();
testJTxMove();
testMemo();
testAdvance();
testClose();
testPath();
testResignSigned();
testSignAndSubmit();
}
};
BEAST_DEFINE_TESTSUITE(Env,app,ripple);
} // test
} // ripple
Reference in New Issue View Git Blame Copy Permalink