ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-04-29 15:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Format first-party source according to .clang-format

Browse Source
This commit is contained in:
Pretty Printer
2020-04-17 09:56:34 -05:00
committed by manojsdoshi
parent 65dfc5d19e
commit 50760c6935
1076 changed files with 86161 additions and 77449 deletions
Download Patch File Download Diff File Expand all files Collapse all files

87
src/test/protocol/STAccount_test.cpp
View File

@@ -17,8 +17,8 @@
*/
//==============================================================================
#include <ripple/protocol/STAccount.h>
#include <ripple/beast/unit_test.h>
#include <ripple/protocol/STAccount.h>
namespace ripple {
@@ -33,91 +33,92 @@ struct STAccount_test : public beast::unit_test::suite
BEAST_EXPECT(defaultAcct.getSType() == STI_ACCOUNT);
BEAST_EXPECT(defaultAcct.getText() == "");
BEAST_EXPECT(defaultAcct.isDefault() == true);
BEAST_EXPECT(defaultAcct.value() == AccountID {});
BEAST_EXPECT(defaultAcct.value() == AccountID{});
{
#ifdef NDEBUG // Qualified because the serialization asserts in a debug build.
#ifdef NDEBUG // Qualified because the serialization asserts in a debug build.
Serializer s;
defaultAcct.add (s); // Asserts in debug build
defaultAcct.add(s); // Asserts in debug build
BEAST_EXPECT(s.size() == 1);
BEAST_EXPECT(s.getHex() == "00");
SerialIter sit (s.slice ());
STAccount const deserializedDefault (sit, sfAccount);
BEAST_EXPECT(deserializedDefault.isEquivalent (defaultAcct));
#endif // NDEBUG
SerialIter sit(s.slice());
STAccount const deserializedDefault(sit, sfAccount);
BEAST_EXPECT(deserializedDefault.isEquivalent(defaultAcct));
#endif // NDEBUG
}
{
// Construct a deserialized default STAccount.
Serializer s;
s.addVL (nullptr, 0);
SerialIter sit (s.slice ());
STAccount const deserializedDefault (sit, sfAccount);
BEAST_EXPECT(deserializedDefault.isEquivalent (defaultAcct));
s.addVL(nullptr, 0);
SerialIter sit(s.slice());
STAccount const deserializedDefault(sit, sfAccount);
BEAST_EXPECT(deserializedDefault.isEquivalent(defaultAcct));
}
// Test constructor from SField.
STAccount const sfAcct {sfAccount};
STAccount const sfAcct{sfAccount};
BEAST_EXPECT(sfAcct.getSType() == STI_ACCOUNT);
BEAST_EXPECT(sfAcct.getText() == "");
BEAST_EXPECT(sfAcct.isDefault());
BEAST_EXPECT(sfAcct.value() == AccountID {});
BEAST_EXPECT(sfAcct.isEquivalent (defaultAcct));
BEAST_EXPECT(sfAcct.value() == AccountID{});
BEAST_EXPECT(sfAcct.isEquivalent(defaultAcct));
{
Serializer s;
sfAcct.add (s);
sfAcct.add(s);
BEAST_EXPECT(s.size() == 1);
BEAST_EXPECT(s.getHex() == "00");
SerialIter sit (s.slice ());
STAccount const deserializedSf (sit, sfAccount);
SerialIter sit(s.slice());
STAccount const deserializedSf(sit, sfAccount);
BEAST_EXPECT(deserializedSf.isEquivalent(sfAcct));
}
// Test constructor from SField and AccountID.
STAccount const zeroAcct {sfAccount, AccountID{}};
STAccount const zeroAcct{sfAccount, AccountID{}};
BEAST_EXPECT(zeroAcct.getText() == "rrrrrrrrrrrrrrrrrrrrrhoLvTp");
BEAST_EXPECT(! zeroAcct.isDefault());
BEAST_EXPECT(zeroAcct.value() == AccountID {0});
BEAST_EXPECT(! zeroAcct.isEquivalent (defaultAcct));
BEAST_EXPECT(! zeroAcct.isEquivalent (sfAcct));
BEAST_EXPECT(!zeroAcct.isDefault());
BEAST_EXPECT(zeroAcct.value() == AccountID{0});
BEAST_EXPECT(!zeroAcct.isEquivalent(defaultAcct));
BEAST_EXPECT(!zeroAcct.isEquivalent(sfAcct));
{
Serializer s;
zeroAcct.add (s);
zeroAcct.add(s);
BEAST_EXPECT(s.size() == 21);
BEAST_EXPECT(s.getHex() ==
"140000000000000000000000000000000000000000");
SerialIter sit (s.slice ());
STAccount const deserializedZero (sit, sfAccount);
BEAST_EXPECT(deserializedZero.isEquivalent (zeroAcct));
BEAST_EXPECT(
s.getHex() == "140000000000000000000000000000000000000000");
SerialIter sit(s.slice());
STAccount const deserializedZero(sit, sfAccount);
BEAST_EXPECT(deserializedZero.isEquivalent(zeroAcct));
}
{
// Construct from a VL that is not exactly 160 bits.
Serializer s;
const std::uint8_t bits128[] {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
s.addVL (bits128, sizeof (bits128));
SerialIter sit (s.slice ());
const std::uint8_t bits128[]{
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
s.addVL(bits128, sizeof(bits128));
SerialIter sit(s.slice());
try
{
// Constructing an STAccount with a bad size should throw.
STAccount const deserializedBadSize (sit, sfAccount);
STAccount const deserializedBadSize(sit, sfAccount);
}
catch (std::runtime_error const& ex)
{
BEAST_EXPECT(ex.what() == std::string("Invalid STAccount size"));
BEAST_EXPECT(
ex.what() == std::string("Invalid STAccount size"));
}
}
// Interestingly, equal values but different types are equivalent!
STAccount const regKey {sfRegularKey, AccountID{}};
BEAST_EXPECT(regKey.isEquivalent (zeroAcct));
STAccount const regKey{sfRegularKey, AccountID{}};
BEAST_EXPECT(regKey.isEquivalent(zeroAcct));
// Test assignment.
STAccount assignAcct;
BEAST_EXPECT(assignAcct.isEquivalent (defaultAcct));
BEAST_EXPECT(assignAcct.isEquivalent(defaultAcct));
BEAST_EXPECT(assignAcct.isDefault());
assignAcct = AccountID{};
BEAST_EXPECT(! assignAcct.isEquivalent (defaultAcct));
BEAST_EXPECT(assignAcct.isEquivalent (zeroAcct));
BEAST_EXPECT(! assignAcct.isDefault());
BEAST_EXPECT(!assignAcct.isEquivalent(defaultAcct));
BEAST_EXPECT(assignAcct.isEquivalent(zeroAcct));
BEAST_EXPECT(!assignAcct.isDefault());
}
}
@@ -128,6 +129,6 @@ struct STAccount_test : public beast::unit_test::suite
}
};
BEAST_DEFINE_TESTSUITE(STAccount,protocol,ripple);
BEAST_DEFINE_TESTSUITE(STAccount, protocol, ripple);
}
} // namespace ripple