mirror of
https://github.com/Xahau/xahaud.git
synced 2026-04-29 15:37:46 +00:00
299 lines
10 KiB
C++
299 lines
10 KiB
C++
//------------------------------------------------------------------------------
|
|
/*
|
|
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 <ripple/beast/unit_test.h>
|
|
#include <ripple/protocol/TER.h>
|
|
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
|
|
namespace ripple {
|
|
|
|
struct TER_test : public beast::unit_test::suite
|
|
{
|
|
void
|
|
testTransResultInfo()
|
|
{
|
|
for (auto i = -400; i < 400; ++i)
|
|
{
|
|
TER t = TER::fromInt(i);
|
|
auto inRange = isTelLocal(t) || isTemMalformed(t) ||
|
|
isTefFailure(t) || isTerRetry(t) || isTesSuccess(t) ||
|
|
isTecClaim(t);
|
|
|
|
std::string token, text;
|
|
auto good = transResultInfo(t, token, text);
|
|
BEAST_EXPECT(inRange || !good);
|
|
BEAST_EXPECT(transToken(t) == (good ? token : "-"));
|
|
BEAST_EXPECT(transHuman(t) == (good ? text : "-"));
|
|
|
|
auto code = transCode(token);
|
|
BEAST_EXPECT(good == !!code);
|
|
BEAST_EXPECT(!code || *code == t);
|
|
}
|
|
}
|
|
|
|
// Helper template that makes sure two types are not convertible or
|
|
// assignable if not the same.
|
|
// o I1 one tuple index.
|
|
// o I2 other tuple index.
|
|
// o Tup is expected to be a tuple.
|
|
// It's a functor, rather than a function template, since a class template
|
|
// can be a template argument without being full specified.
|
|
template <std::size_t I1, std::size_t I2>
|
|
class NotConvertible
|
|
{
|
|
public:
|
|
template <typename Tup>
|
|
void
|
|
operator()(Tup const& tup, beast::unit_test::suite&) const
|
|
{
|
|
// Entries in the tuple should not be convertible or assignable
|
|
// unless they are the same types.
|
|
using To_t = std::decay_t<decltype(std::get<I1>(tup))>;
|
|
using From_t = std::decay_t<decltype(std::get<I2>(tup))>;
|
|
static_assert(
|
|
std::is_same<From_t, To_t>::value ==
|
|
std::is_convertible<From_t, To_t>::value,
|
|
"Convert err");
|
|
static_assert(
|
|
std::is_same<To_t, From_t>::value ==
|
|
std::is_constructible<To_t, From_t>::value,
|
|
"Construct err");
|
|
static_assert(
|
|
std::is_same<To_t, From_t>::value ==
|
|
std::is_assignable<To_t&, From_t const&>::value,
|
|
"Assign err");
|
|
|
|
// Assignment or conversion from integer to type should never work.
|
|
static_assert(
|
|
!std::is_convertible<int, To_t>::value, "Convert err");
|
|
static_assert(
|
|
!std::is_constructible<To_t, int>::value, "Construct err");
|
|
static_assert(
|
|
!std::is_assignable<To_t&, int const&>::value, "Assign err");
|
|
}
|
|
};
|
|
|
|
// Fast iteration over the tuple.
|
|
template <
|
|
std::size_t I1,
|
|
std::size_t I2,
|
|
template <std::size_t, std::size_t>
|
|
class Func,
|
|
typename Tup>
|
|
std::enable_if_t<I1 != 0>
|
|
testIterate(Tup const& tup, beast::unit_test::suite& s)
|
|
{
|
|
Func<I1, I2> func;
|
|
func(tup, s);
|
|
testIterate<I1 - 1, I2, Func>(tup, s);
|
|
}
|
|
|
|
// Slow iteration over the tuple.
|
|
template <
|
|
std::size_t I1,
|
|
std::size_t I2,
|
|
template <std::size_t, std::size_t>
|
|
class Func,
|
|
typename Tup>
|
|
std::enable_if_t<I1 == 0 && I2 != 0>
|
|
testIterate(Tup const& tup, beast::unit_test::suite& s)
|
|
{
|
|
Func<I1, I2> func;
|
|
func(tup, s);
|
|
testIterate<std::tuple_size<Tup>::value - 1, I2 - 1, Func>(tup, s);
|
|
}
|
|
|
|
// Finish iteration over the tuple.
|
|
template <
|
|
std::size_t I1,
|
|
std::size_t I2,
|
|
template <std::size_t, std::size_t>
|
|
class Func,
|
|
typename Tup>
|
|
std::enable_if_t<I1 == 0 && I2 == 0>
|
|
testIterate(Tup const& tup, beast::unit_test::suite& s)
|
|
{
|
|
Func<I1, I2> func;
|
|
func(tup, s);
|
|
}
|
|
|
|
void
|
|
testConversion()
|
|
{
|
|
// Verify that valid conversions are valid and invalid conversions
|
|
// are not valid.
|
|
|
|
// Examples of each kind of enum.
|
|
static auto const terEnums = std::make_tuple(
|
|
telLOCAL_ERROR,
|
|
temMALFORMED,
|
|
tefFAILURE,
|
|
terRETRY,
|
|
tesSUCCESS,
|
|
tecCLAIM);
|
|
static const int hiIndex{
|
|
std::tuple_size<decltype(terEnums)>::value - 1};
|
|
|
|
// Verify that enums cannot be converted to other enum types.
|
|
testIterate<hiIndex, hiIndex, NotConvertible>(terEnums, *this);
|
|
|
|
// Lambda that verifies assignability and convertibility.
|
|
auto isConvertable = [](auto from, auto to) {
|
|
using From_t = std::decay_t<decltype(from)>;
|
|
using To_t = std::decay_t<decltype(to)>;
|
|
static_assert(
|
|
std::is_convertible<From_t, To_t>::value, "Convert err");
|
|
static_assert(
|
|
std::is_constructible<To_t, From_t>::value, "Construct err");
|
|
static_assert(
|
|
std::is_assignable<To_t&, From_t const&>::value, "Assign err");
|
|
};
|
|
|
|
// Verify the right types convert to NotTEC.
|
|
NotTEC const notTec;
|
|
isConvertable(telLOCAL_ERROR, notTec);
|
|
isConvertable(temMALFORMED, notTec);
|
|
isConvertable(tefFAILURE, notTec);
|
|
isConvertable(terRETRY, notTec);
|
|
isConvertable(tesSUCCESS, notTec);
|
|
isConvertable(notTec, notTec);
|
|
|
|
// Lambda that verifies types and not assignable or convertible.
|
|
auto notConvertible = [](auto from, auto to) {
|
|
using To_t = std::decay_t<decltype(to)>;
|
|
using From_t = std::decay_t<decltype(from)>;
|
|
static_assert(
|
|
!std::is_convertible<From_t, To_t>::value, "Convert err");
|
|
static_assert(
|
|
!std::is_constructible<To_t, From_t>::value, "Construct err");
|
|
static_assert(
|
|
!std::is_assignable<To_t&, From_t const&>::value, "Assign err");
|
|
};
|
|
|
|
// Verify types that shouldn't convert to NotTEC.
|
|
TER const ter;
|
|
notConvertible(tecCLAIM, notTec);
|
|
notConvertible(ter, notTec);
|
|
notConvertible(4, notTec);
|
|
|
|
// Verify the right types convert to TER.
|
|
isConvertable(telLOCAL_ERROR, ter);
|
|
isConvertable(temMALFORMED, ter);
|
|
isConvertable(tefFAILURE, ter);
|
|
isConvertable(terRETRY, ter);
|
|
isConvertable(tesSUCCESS, ter);
|
|
isConvertable(tecCLAIM, ter);
|
|
isConvertable(notTec, ter);
|
|
isConvertable(ter, ter);
|
|
|
|
// Verify that you can't convert from int to ter.
|
|
notConvertible(4, ter);
|
|
}
|
|
|
|
// Helper template that makes sure two types are comparable. Also
|
|
// verifies that one of the types does not compare to int.
|
|
// o I1 one tuple index.
|
|
// o I2 other tuple index.
|
|
// o Tup is expected to be a tuple.
|
|
// It's a functor, rather than a function template, since a class template
|
|
// can be a template argument without being full specified.
|
|
template <std::size_t I1, std::size_t I2>
|
|
class CheckComparable
|
|
{
|
|
public:
|
|
template <typename Tup>
|
|
void
|
|
operator()(Tup const& tup, beast::unit_test::suite& s) const
|
|
{
|
|
// All entries in the tuple should be comparable one to the other.
|
|
auto const lhs = std::get<I1>(tup);
|
|
auto const rhs = std::get<I2>(tup);
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator==(lhs, rhs)), bool>::value,
|
|
"== err");
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator!=(lhs, rhs)), bool>::value,
|
|
"!= err");
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator<(lhs, rhs)), bool>::value,
|
|
"< err");
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator<=(lhs, rhs)), bool>::value,
|
|
"<= err");
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator>(lhs, rhs)), bool>::value,
|
|
"> err");
|
|
|
|
static_assert(
|
|
std::is_same<decltype(operator>=(lhs, rhs)), bool>::value,
|
|
">= err");
|
|
|
|
// Make sure a sampling of TER types exhibit the expected behavior
|
|
// for all comparison operators.
|
|
s.expect((lhs == rhs) == (TERtoInt(lhs) == TERtoInt(rhs)));
|
|
s.expect((lhs != rhs) == (TERtoInt(lhs) != TERtoInt(rhs)));
|
|
s.expect((lhs < rhs) == (TERtoInt(lhs) < TERtoInt(rhs)));
|
|
s.expect((lhs <= rhs) == (TERtoInt(lhs) <= TERtoInt(rhs)));
|
|
s.expect((lhs > rhs) == (TERtoInt(lhs) > TERtoInt(rhs)));
|
|
s.expect((lhs >= rhs) == (TERtoInt(lhs) >= TERtoInt(rhs)));
|
|
}
|
|
};
|
|
|
|
void
|
|
testComparison()
|
|
{
|
|
// All of the TER-related types should be comparable.
|
|
|
|
// Examples of all the types we expect to successfully compare.
|
|
static auto const ters = std::make_tuple(
|
|
telLOCAL_ERROR,
|
|
temMALFORMED,
|
|
tefFAILURE,
|
|
terRETRY,
|
|
tesSUCCESS,
|
|
tecCLAIM,
|
|
NotTEC{telLOCAL_ERROR},
|
|
TER{tecCLAIM});
|
|
static const int hiIndex{std::tuple_size<decltype(ters)>::value - 1};
|
|
|
|
// Verify that all types in the ters tuple can be compared with all
|
|
// the other types in ters.
|
|
testIterate<hiIndex, hiIndex, CheckComparable>(ters, *this);
|
|
}
|
|
|
|
void
|
|
run() override
|
|
{
|
|
testTransResultInfo();
|
|
testConversion();
|
|
testComparison();
|
|
}
|
|
};
|
|
|
|
BEAST_DEFINE_TESTSUITE(TER, protocol, ripple);
|
|
|
|
} // namespace ripple
|