ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 16:56:48 +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

49
src/test/basics/base_uint_test.cpp
View File

@@ -17,8 +17,8 @@
*/
//==============================================================================
#include <ripple/basics/base_uint.h>
#include <ripple/basics/Blob.h>
#include <ripple/basics/base_uint.h>
#include <ripple/basics/hardened_hash.h>
#include <ripple/beast/unit_test.h>
#include <boost/algorithm/string.hpp>
@@ -41,14 +41,16 @@ struct nonhash
nonhash() = default;
void
operator() (void const* key, std::size_t len) noexcept
operator()(void const* key, std::size_t len) noexcept
{
assert(len == WIDTH);
memcpy(data_.data(), key, len);
}
explicit
operator std::size_t() noexcept { return WIDTH; }
explicit operator std::size_t() noexcept
{
return WIDTH;
}
};
struct base_uint_test : beast::unit_test::suite
@@ -57,17 +59,20 @@ struct base_uint_test : beast::unit_test::suite
static_assert(std::is_copy_constructible<test96>::value, "");
static_assert(std::is_copy_assignable<test96>::value, "");
void run() override
void
run() override
{
static_assert(!std::is_constructible<test96, std::complex<double>>::value, "");
static_assert(!std::is_assignable<test96&, std::complex<double>>::value, "");
static_assert(
!std::is_constructible<test96, std::complex<double>>::value, "");
static_assert(
!std::is_assignable<test96&, std::complex<double>>::value, "");
// used to verify set insertion (hashing required)
std::unordered_set<test96, hardened_hash<>> uset;
Blob raw { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };
Blob raw{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
BEAST_EXPECT(test96::bytes == raw.size());
test96 u { raw };
test96 u{raw};
uset.insert(u);
BEAST_EXPECT(raw.size() == u.size());
BEAST_EXPECT(to_string(u) == "0102030405060708090A0B0C");
@@ -87,10 +92,10 @@ struct base_uint_test : beast::unit_test::suite
// back into another base_uint (w) for comparison with the original
nonhash<96> h;
hash_append(h, u);
test96 w {std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
test96 w{std::vector<std::uint8_t>(h.data_.begin(), h.data_.end())};
BEAST_EXPECT(w == u);
test96 v { ~u };
test96 v{~u};
uset.insert(v);
BEAST_EXPECT(to_string(v) == "FEFDFCFBFAF9F8F7F6F5F4F3");
BEAST_EXPECT(*v.data() == 0xfe);
@@ -110,7 +115,7 @@ struct base_uint_test : beast::unit_test::suite
v = u;
BEAST_EXPECT(v == u);
test96 z { beast::zero };
test96 z{beast::zero};
uset.insert(z);
BEAST_EXPECT(to_string(z) == "000000000000000000000000");
BEAST_EXPECT(*z.data() == 0);
@@ -125,7 +130,7 @@ struct base_uint_test : beast::unit_test::suite
BEAST_EXPECT(d == 0);
}
test96 n { z };
test96 n{z};
n++;
BEAST_EXPECT(n == test96(1));
n--;
@@ -136,11 +141,11 @@ struct base_uint_test : beast::unit_test::suite
n = beast::zero;
BEAST_EXPECT(n == z);
test96 zp1 { z };
test96 zp1{z};
zp1++;
test96 zm1 { z };
test96 zm1{z};
zm1--;
test96 x { zm1 ^ zp1 };
test96 x{zm1 ^ zp1};
uset.insert(x);
BEAST_EXPECTS(to_string(x) == "FFFFFFFFFFFFFFFFFFFFFFFE", to_string(x));
@@ -153,11 +158,11 @@ struct base_uint_test : beast::unit_test::suite
fromHex = z;
// fails with extra char
BEAST_EXPECT(! fromHex.SetHexExact("A" + to_string(u)));
BEAST_EXPECT(!fromHex.SetHexExact("A" + to_string(u)));
fromHex = z;
// fails with extra char at end
BEAST_EXPECT(! fromHex.SetHexExact(to_string(u) + "A"));
BEAST_EXPECT(!fromHex.SetHexExact(to_string(u) + "A"));
// NOTE: the value fromHex is actually correctly parsed
// in this case, but that is an implementation detail and
// not guaranteed, thus we don't check the value here.
@@ -178,7 +183,7 @@ struct base_uint_test : beast::unit_test::suite
fromHex = z;
// invalid hex chars should fail (0 replaced with Z here)
BEAST_EXPECT(! fromHex.SetHex(
BEAST_EXPECT(!fromHex.SetHex(
boost::algorithm::replace_all_copy(to_string(u), "0", "Z")));
fromHex = z;
@@ -187,16 +192,16 @@ struct base_uint_test : beast::unit_test::suite
fromHex = z;
// strict mode fails with leading chars
BEAST_EXPECT(! fromHex.SetHex(" 0x" + to_string(u), true));
BEAST_EXPECT(!fromHex.SetHex(" 0x" + to_string(u), true));
fromHex = z;
// SetHex ignores extra leading hexits, so the parsed value
// is still correct for the following case (strict or non-strict)
BEAST_EXPECT(fromHex.SetHex("DEAD" + to_string(u), true ));
BEAST_EXPECT(fromHex.SetHex("DEAD" + to_string(u), true));
BEAST_EXPECT(fromHex == u);
fromHex = z;
BEAST_EXPECT(fromHex.SetHex("DEAD" + to_string(u), false ));
BEAST_EXPECT(fromHex.SetHex("DEAD" + to_string(u), false));
BEAST_EXPECT(fromHex == u);
fromHex = z;
}