ARCHIVE/rippled
1
0
Fork 0
mirror of https://github.com/XRPLF/rippled.git synced 2026-06-03 08:46:46 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: Use more scoped enums (#7086)

Browse Source
This commit is contained in:
Alex Kremer
2026-05-11 16:39:48 +01:00
committed by GitHub
parent 779b49cd93
commit cdee9a675c
379 changed files with 2771 additions and 2864 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src/tests/libxrpl/basics/MallocTrim.cpp
View File

@@ -161,15 +161,15 @@ TEST(mallocTrim, with_debug_logging)
{
struct DebugSink : public beast::Journal::Sink
{
DebugSink() : Sink(beast::severities::KDebug, false)
DebugSink() : Sink(beast::Severity::Debug, false)
{
}
void
write(beast::severities::Severity, std::string const&) override
write(beast::Severity, std::string const&) override
{
}
void
writeAlways(beast::severities::Severity, std::string const&) override
writeAlways(beast::Severity, std::string const&) override
{
}
};

6
src/tests/libxrpl/helpers/TestServiceRegistry.h
View File

@@ -23,12 +23,12 @@ namespace test {
class TestLogs : public Logs
{
public:
explicit TestLogs(beast::severities::Severity level = beast::severities::KWarning) : Logs(level)
explicit TestLogs(beast::Severity level = beast::Severity::Warning) : Logs(level)
{
}
std::unique_ptr<beast::Journal::Sink>
makeSink(std::string const&, beast::severities::Severity threshold) override
makeSink(std::string const&, beast::Severity threshold) override
{
return std::make_unique<TestSink>(threshold);
}
@@ -62,7 +62,7 @@ private:
*/
class TestServiceRegistry : public ServiceRegistry
{
TestLogs logs_{beast::severities::KWarning};
TestLogs logs_{beast::Severity::Warning};
boost::asio::io_context io_context_;
TestFamily family_{logs_.journal("TestFamily")};
LoadFeeTrack feeTrack_{logs_.journal("LoadFeeTrack")};

34
src/tests/libxrpl/helpers/TestSink.cpp
View File

@@ -18,12 +18,12 @@
namespace xrpl {
TestSink::TestSink(beast::severities::Severity threshold) : Sink(threshold, false)
TestSink::TestSink(beast::Severity threshold) : Sink(threshold, false)
{
}
void
TestSink::write(beast::severities::Severity level, std::string const& text)
TestSink::write(beast::Severity level, std::string const& text)
{
if (level < threshold())
return;
@@ -31,7 +31,7 @@ TestSink::write(beast::severities::Severity level, std::string const& text)
}
void
TestSink::writeAlways(beast::severities::Severity level, std::string const& text)
TestSink::writeAlways(beast::Severity level, std::string const& text)
{
auto supportsColor = [] {
// 1. Check for "NO_COLOR" environment variable (Standard convention)
@@ -64,17 +64,17 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text
auto color = [level]() {
switch (level)
{
case beast::severities::KTrace:
case beast::Severity::Trace:
return "\033[34m"; // blue
case beast::severities::KDebug:
case beast::Severity::Debug:
return "\033[32m"; // green
case beast::severities::KInfo:
case beast::Severity::Info:
return "\033[36m"; // cyan
case beast::severities::KWarning:
case beast::Severity::Warning:
return "\033[33m"; // yellow
case beast::severities::KError:
case beast::Severity::Error:
return "\033[31m"; // red
case beast::severities::KFatal:
case beast::Severity::Fatal:
default:
break;
}
@@ -84,17 +84,17 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text
auto prefix = [level]() {
switch (level)
{
case beast::severities::KTrace:
case beast::Severity::Trace:
return "TRC:";
case beast::severities::KDebug:
case beast::Severity::Debug:
return "DBG:";
case beast::severities::KInfo:
case beast::Severity::Info:
return "INF:";
case beast::severities::KWarning:
case beast::Severity::Warning:
return "WRN:";
case beast::severities::KError:
case beast::Severity::Error:
return "ERR:";
case beast::severities::KFatal:
case beast::Severity::Fatal:
default:
break;
}
@@ -104,8 +104,8 @@ TestSink::writeAlways(beast::severities::Severity level, std::string const& text
auto& stream = [level]() -> std::ostream& {
switch (level)
{
case beast::severities::KError:
case beast::severities::KFatal:
case beast::Severity::Error:
case beast::Severity::Fatal:
return std::cerr;
default:
return std::cout;

6
src/tests/libxrpl/helpers/TestSink.h
View File

@@ -13,12 +13,12 @@ public:
return sink;
}
TestSink(beast::severities::Severity threshold = beast::severities::KDebug);
TestSink(beast::Severity threshold = beast::Severity::Debug);
void
write(beast::severities::Severity level, std::string const& text) override;
write(beast::Severity level, std::string const& text) override;
void
writeAlways(beast::severities::Severity level, std::string const& text) override;
writeAlways(beast::Severity level, std::string const& text) override;
};
} // namespace xrpl

288
src/tests/libxrpl/json/Value.cpp
View File

@@ -25,7 +25,7 @@ TEST(json_value, limits)
using namespace json;
static_assert(Value::kMIN_INT == Int(~(UInt(-1) / 2)));
static_assert(Value::kMAX_INT == Int(UInt(-1) / 2));
static_assert(Value::kMAX_U_INT == UInt(-1));
static_assert(Value::kMAX_UINT == UInt(-1));
}
TEST(json_value, construct_and_compare_Json_StaticString)
@@ -64,7 +64,7 @@ TEST(json_value, different_types)
return val;
};
{
json::Value const nullV{testCopy(json::NullValue)};
json::Value const nullV{testCopy(json::ValueType::Null)};
EXPECT_TRUE(nullV.isNull());
EXPECT_FALSE(nullV.isBool());
EXPECT_FALSE(nullV.isInt());
@@ -79,7 +79,7 @@ TEST(json_value, different_types)
EXPECT_TRUE(nullV.isObjectOrNull());
}
{
json::Value const intV{testCopy(json::IntValue)};
json::Value const intV{testCopy(json::ValueType::Int)};
EXPECT_FALSE(intV.isNull());
EXPECT_FALSE(intV.isBool());
EXPECT_TRUE(intV.isInt());
@@ -94,7 +94,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(intV.isObjectOrNull());
}
{
json::Value const uintV{testCopy(json::UintValue)};
json::Value const uintV{testCopy(json::ValueType::UInt)};
EXPECT_FALSE(uintV.isNull());
EXPECT_FALSE(uintV.isBool());
EXPECT_FALSE(uintV.isInt());
@@ -109,7 +109,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(uintV.isObjectOrNull());
}
{
json::Value const realV{testCopy(json::RealValue)};
json::Value const realV{testCopy(json::ValueType::Real)};
EXPECT_FALSE(realV.isNull());
EXPECT_FALSE(realV.isBool());
EXPECT_FALSE(realV.isInt());
@@ -124,7 +124,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(realV.isObjectOrNull());
}
{
json::Value const stringV{testCopy(json::StringValue)};
json::Value const stringV{testCopy(json::ValueType::String)};
EXPECT_FALSE(stringV.isNull());
EXPECT_FALSE(stringV.isBool());
EXPECT_FALSE(stringV.isInt());
@@ -142,8 +142,8 @@ TEST(json_value, different_types)
json::Value const staticStrV{kSTATIC_STR};
{
json::Value const cpy{staticStrV};
EXPECT_EQ(staticStrV.type(), json::StringValue);
EXPECT_EQ(cpy.type(), json::StringValue);
EXPECT_EQ(staticStrV.type(), json::ValueType::String);
EXPECT_EQ(cpy.type(), json::ValueType::String);
}
EXPECT_FALSE(staticStrV.isNull());
EXPECT_FALSE(staticStrV.isBool());
@@ -159,7 +159,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(staticStrV.isObjectOrNull());
}
{
json::Value const boolV{testCopy(json::BooleanValue)};
json::Value const boolV{testCopy(json::ValueType::Boolean)};
EXPECT_FALSE(boolV.isNull());
EXPECT_TRUE(boolV.isBool());
EXPECT_FALSE(boolV.isInt());
@@ -174,7 +174,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(boolV.isObjectOrNull());
}
{
json::Value const arrayV{testCopy(json::ArrayValue)};
json::Value const arrayV{testCopy(json::ValueType::Array)};
EXPECT_FALSE(arrayV.isNull());
EXPECT_FALSE(arrayV.isBool());
EXPECT_FALSE(arrayV.isInt());
@@ -189,7 +189,7 @@ TEST(json_value, different_types)
EXPECT_FALSE(arrayV.isObjectOrNull());
}
{
json::Value const objectV{testCopy(json::ObjectValue)};
json::Value const objectV{testCopy(json::ValueType::Object)};
EXPECT_FALSE(objectV.isNull());
EXPECT_FALSE(objectV.isBool());
EXPECT_FALSE(objectV.isInt());
@@ -223,24 +223,24 @@ TEST(json_value, compare_strings)
json::Value const null0;
json::Value const intNeg1{-1};
json::Value const int0{json::IntValue};
json::Value const int0{json::ValueType::Int};
json::Value const intPos1{1};
json::Value const uint0{json::UintValue};
json::Value const uint0{json::ValueType::UInt};
json::Value const uint1{1u};
json::Value const realNeg1{-1.0};
json::Value const real0{json::RealValue};
json::Value const real0{json::ValueType::Real};
json::Value const realPos1{1.0};
json::Value const str0{json::StringValue};
json::Value const str0{json::ValueType::String};
json::Value const str1{"1"};
json::Value const boolF{false};
json::Value const boolT{true};
json::Value const array0{json::ArrayValue};
json::Value const array0{json::ValueType::Array};
json::Value const array1{[]() {
json::Value array1;
array1[0u] = 1;
return array1;
}()};
json::Value const obj0{json::ObjectValue};
json::Value const obj0{json::ValueType::Object};
json::Value const obj1{[]() {
json::Value obj1;
obj1["one"] = 1;
@@ -571,12 +571,12 @@ TEST(json_value, bool)
EXPECT_TRUE(bool(json::Value(0)));
EXPECT_TRUE(bool(json::Value(1)));
json::Value array(json::ArrayValue);
json::Value array(json::ValueType::Array);
EXPECT_FALSE(array);
array.append(0);
EXPECT_TRUE(bool(array));
json::Value object(json::ObjectValue);
json::Value object(json::ValueType::Object);
EXPECT_FALSE(object);
object[""] = false;
EXPECT_TRUE(bool(object));
@@ -594,19 +594,19 @@ TEST(json_value, bad_json)
TEST(json_value, edge_cases)
{
std::uint32_t const maxUint = std::numeric_limits<std::uint32_t>::max();
std::uint32_t const maxUInt = std::numeric_limits<std::uint32_t>::max();
std::int32_t const maxInt = std::numeric_limits<std::int32_t>::max();
std::int32_t const minInt = std::numeric_limits<std::int32_t>::min();
std::uint32_t const aUint = maxUint - 1978;
std::uint32_t const aUInt = maxUInt - 1978;
std::int32_t const aLargeInt = maxInt - 1978;
std::int32_t const aSmallInt = minInt + 1978;
{
std::string json = "{\"max_uint\":" + std::to_string(maxUint);
std::string json = "{\"max_uint\":" + std::to_string(maxUInt);
json += ",\"max_int\":" + std::to_string(maxInt);
json += ",\"min_int\":" + std::to_string(minInt);
json += ",\"a_uint\":" + std::to_string(aUint);
json += ",\"a_uint\":" + std::to_string(aUInt);
json += ",\"a_large_int\":" + std::to_string(aLargeInt);
json += ",\"a_small_int\":" + std::to_string(aSmallInt);
json += "}";
@@ -615,26 +615,26 @@ TEST(json_value, edge_cases)
json::Reader r1;
EXPECT_TRUE(r1.parse(json, j1));
EXPECT_EQ(j1["max_uint"].asUInt(), maxUint);
EXPECT_EQ(j1["max_uint"].asAbsUInt(), maxUint);
EXPECT_EQ(j1["max_uint"].asUInt(), maxUInt);
EXPECT_EQ(j1["max_uint"].asAbsUInt(), maxUInt);
EXPECT_EQ(j1["max_int"].asInt(), maxInt);
EXPECT_EQ(j1["max_int"].asAbsUInt(), maxInt);
EXPECT_EQ(j1["min_int"].asInt(), minInt);
EXPECT_EQ(j1["min_int"].asAbsUInt(), static_cast<std::int64_t>(minInt) * -1);
EXPECT_EQ(j1["a_uint"].asUInt(), aUint);
EXPECT_EQ(j1["a_uint"].asAbsUInt(), aUint);
EXPECT_EQ(j1["a_uint"].asUInt(), aUInt);
EXPECT_EQ(j1["a_uint"].asAbsUInt(), aUInt);
EXPECT_GT(j1["a_uint"], aLargeInt);
EXPECT_GT(j1["a_uint"], aSmallInt);
EXPECT_EQ(j1["a_large_int"].asInt(), aLargeInt);
EXPECT_EQ(j1["a_large_int"].asAbsUInt(), aLargeInt);
EXPECT_EQ(j1["a_large_int"].asUInt(), aLargeInt);
EXPECT_LT(j1["a_large_int"], aUint);
EXPECT_LT(j1["a_large_int"], aUInt);
EXPECT_EQ(j1["a_small_int"].asInt(), aSmallInt);
EXPECT_EQ(j1["a_small_int"].asAbsUInt(), static_cast<std::int64_t>(aSmallInt) * -1);
EXPECT_LT(j1["a_small_int"], aUint);
EXPECT_LT(j1["a_small_int"], aUInt);
}
std::uint64_t const overflow = std::uint64_t(maxUint) + 1;
std::uint64_t const overflow = std::uint64_t(maxUInt) + 1;
{
std::string json = "{\"overflow\":";
json += std::to_string(overflow);
@@ -859,9 +859,7 @@ TEST(json_value, compact)
TEST(json_value, conversions)
{
// We have json::Int, but not json::Double or json::Real.
// We have json::Int, json::Value::Int, and json::ValueType::intValue.
// We have json::ValueType::realValue but json::Value::asDouble.
// We have json::ValueType::Real but json::Value::asDouble.
// TODO: What's the thinking here?
{
// null
@@ -875,14 +873,14 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), 0.0);
EXPECT_FALSE(val.asBool());
EXPECT_TRUE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_TRUE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_TRUE(val.isConvertibleTo(json::ArrayValue));
EXPECT_TRUE(val.isConvertibleTo(json::ObjectValue));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Object));
}
{
// int
@@ -896,14 +894,14 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), -1234.0);
EXPECT_TRUE(val.asBool());
EXPECT_FALSE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_FALSE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// uint
@@ -917,14 +915,14 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), 1234.0);
EXPECT_TRUE(val.asBool());
EXPECT_FALSE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_TRUE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// real
@@ -938,14 +936,14 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), 2.0);
EXPECT_TRUE(val.asBool());
EXPECT_FALSE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_TRUE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// numeric string
@@ -959,18 +957,18 @@ TEST(json_value, conversions)
EXPECT_THROW([&] { return val.asDouble(); }(), json::Error);
EXPECT_TRUE(val.asBool());
EXPECT_FALSE(val.isConvertibleTo(json::NullValue));
EXPECT_FALSE(val.isConvertibleTo(json::IntValue));
EXPECT_FALSE(val.isConvertibleTo(json::UintValue));
EXPECT_FALSE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// non-numeric string
json::Value const val(json::StringValue);
json::Value const val(json::ValueType::String);
EXPECT_TRUE(val.isString());
EXPECT_EQ(val.asCString(), nullptr);
EXPECT_EQ(val.asString(), "");
@@ -980,14 +978,14 @@ TEST(json_value, conversions)
EXPECT_THROW([&] { return val.asDouble(); }(), std::exception);
EXPECT_TRUE(val.asBool() == false);
EXPECT_TRUE(val.isConvertibleTo(json::NullValue));
EXPECT_FALSE(val.isConvertibleTo(json::IntValue));
EXPECT_FALSE(val.isConvertibleTo(json::UintValue));
EXPECT_FALSE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// bool false
@@ -1001,14 +999,14 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), 0.0);
EXPECT_FALSE(val.asBool());
EXPECT_TRUE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_TRUE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// bool true
@@ -1022,18 +1020,18 @@ TEST(json_value, conversions)
EXPECT_EQ(val.asDouble(), 1.0);
EXPECT_TRUE(val.asBool());
EXPECT_FALSE(val.isConvertibleTo(json::NullValue));
EXPECT_TRUE(val.isConvertibleTo(json::IntValue));
EXPECT_TRUE(val.isConvertibleTo(json::UintValue));
EXPECT_TRUE(val.isConvertibleTo(json::RealValue));
EXPECT_TRUE(val.isConvertibleTo(json::StringValue));
EXPECT_TRUE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::String));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// array type
json::Value const val(json::ArrayValue);
json::Value const val(json::ValueType::Array);
EXPECT_TRUE(val.isArray());
// val.asCString should trigger an assertion failure
EXPECT_THROW([&] { return val.asString(); }(), json::Error);
@@ -1043,18 +1041,18 @@ TEST(json_value, conversions)
EXPECT_THROW([&] { return val.asDouble(); }(), json::Error);
EXPECT_FALSE(val.asBool()); // empty or not
EXPECT_TRUE(val.isConvertibleTo(json::NullValue));
EXPECT_FALSE(val.isConvertibleTo(json::IntValue));
EXPECT_FALSE(val.isConvertibleTo(json::UintValue));
EXPECT_FALSE(val.isConvertibleTo(json::RealValue));
EXPECT_FALSE(val.isConvertibleTo(json::StringValue));
EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue));
EXPECT_TRUE(val.isConvertibleTo(json::ArrayValue));
EXPECT_FALSE(val.isConvertibleTo(json::ObjectValue));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::String));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Object));
}
{
// object type
json::Value const val(json::ObjectValue);
json::Value const val(json::ValueType::Object);
EXPECT_TRUE(val.isObject());
// val.asCString should trigger an assertion failure
EXPECT_THROW([&] { return val.asString(); }(), json::Error);
@@ -1064,29 +1062,29 @@ TEST(json_value, conversions)
EXPECT_THROW([&] { return val.asDouble(); }(), json::Error);
EXPECT_FALSE(val.asBool()); // empty or not
EXPECT_TRUE(val.isConvertibleTo(json::NullValue));
EXPECT_FALSE(val.isConvertibleTo(json::IntValue));
EXPECT_FALSE(val.isConvertibleTo(json::UintValue));
EXPECT_FALSE(val.isConvertibleTo(json::RealValue));
EXPECT_FALSE(val.isConvertibleTo(json::StringValue));
EXPECT_FALSE(val.isConvertibleTo(json::BooleanValue));
EXPECT_FALSE(val.isConvertibleTo(json::ArrayValue));
EXPECT_TRUE(val.isConvertibleTo(json::ObjectValue));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Null));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Int));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::UInt));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Real));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::String));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Boolean));
EXPECT_FALSE(val.isConvertibleTo(json::ValueType::Array));
EXPECT_TRUE(val.isConvertibleTo(json::ValueType::Object));
}
}
TEST(json_value, access_members)
{
json::Value val;
EXPECT_EQ(val.type(), json::NullValue);
EXPECT_EQ(val.type(), json::ValueType::Null);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
{
json::Value const constVal = val;
EXPECT_EQ(constVal[7u].type(), json::NullValue);
EXPECT_EQ(constVal[7u].type(), json::ValueType::Null);
EXPECT_FALSE(constVal.isMember("key"));
EXPECT_EQ(constVal["key"].type(), json::NullValue);
EXPECT_EQ(constVal["key"].type(), json::ValueType::Null);
EXPECT_TRUE(constVal.getMemberNames().empty());
EXPECT_EQ(constVal.get(1u, "default0"), "default0");
EXPECT_EQ(constVal.get(std::string("not"), "oh"), "oh");
@@ -1094,37 +1092,37 @@ TEST(json_value, access_members)
}
val = -7;
EXPECT_EQ(val.type(), json::IntValue);
EXPECT_EQ(val.type(), json::ValueType::Int);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
val = 42u;
EXPECT_EQ(val.type(), json::UintValue);
EXPECT_EQ(val.type(), json::ValueType::UInt);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
val = std::numbers::pi;
EXPECT_EQ(val.type(), json::RealValue);
EXPECT_EQ(val.type(), json::ValueType::Real);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
val = true;
EXPECT_EQ(val.type(), json::BooleanValue);
EXPECT_EQ(val.type(), json::ValueType::Boolean);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
val = "string";
EXPECT_EQ(val.type(), json::StringValue);
EXPECT_EQ(val.type(), json::ValueType::String);
EXPECT_EQ(val.size(), 0);
EXPECT_FALSE(val.isValidIndex(0));
EXPECT_FALSE(val.isMember("key"));
val = json::Value(json::ObjectValue);
EXPECT_EQ(val.type(), json::ObjectValue);
val = json::Value(json::ValueType::Object);
EXPECT_EQ(val.type(), json::ValueType::Object);
EXPECT_EQ(val.size(), 0);
static json::StaticString const kSTATIC_THREE("three");
val[kSTATIC_THREE] = 3;
@@ -1139,7 +1137,7 @@ TEST(json_value, access_members)
{
json::Value const constVal = val;
EXPECT_EQ(constVal["two"], 2);
EXPECT_EQ(constVal["four"].type(), json::NullValue);
EXPECT_EQ(constVal["four"].type(), json::ValueType::Null);
EXPECT_EQ(constVal[kSTATIC_THREE], 3);
EXPECT_TRUE(constVal.isMember("two"));
EXPECT_TRUE(constVal.isMember(kSTATIC_THREE));
@@ -1148,20 +1146,20 @@ TEST(json_value, access_members)
EXPECT_EQ(val.get("missing", "default2"), "default2");
}
val = json::Value(json::ArrayValue);
EXPECT_EQ(val.type(), json::ArrayValue);
val = json::Value(json::ValueType::Array);
EXPECT_EQ(val.type(), json::ValueType::Array);
EXPECT_EQ(val.size(), 0);
val[0u] = "zero";
val[1u] = "one";
EXPECT_EQ(val.size(), 2);
EXPECT_TRUE(val.isValidIndex(1));
EXPECT_FALSE(val.isValidIndex(2));
EXPECT_EQ(val[20u].type(), json::NullValue);
EXPECT_EQ(val[20u].type(), json::ValueType::Null);
EXPECT_FALSE(val.isMember("key"));
{
json::Value const constVal = val;
EXPECT_EQ(constVal[0u], "zero");
EXPECT_EQ(constVal[2u].type(), json::NullValue);
EXPECT_EQ(constVal[2u].type(), json::ValueType::Null);
EXPECT_FALSE(constVal.isMember("key"));
EXPECT_EQ(val.get(1u, "default0"), "one");
EXPECT_EQ(val.get(3u, "default1"), "default1");
@@ -1171,27 +1169,27 @@ TEST(json_value, access_members)
TEST(json_value, remove_members)
{
json::Value val;
EXPECT_EQ(val.removeMember(std::string("member")).type(), json::NullValue);
EXPECT_EQ(val.removeMember(std::string("member")).type(), json::ValueType::Null);
val = json::Value(json::ObjectValue);
val = json::Value(json::ValueType::Object);
static json::StaticString const kSTATIC_THREE("three");
val[kSTATIC_THREE] = 3;
val["two"] = 2;
EXPECT_EQ(val.size(), 2);
EXPECT_EQ(val.removeMember(std::string("six")).type(), json::NullValue);
EXPECT_EQ(val.removeMember(std::string("six")).type(), json::ValueType::Null);
EXPECT_EQ(val.size(), 2);
EXPECT_EQ(val.removeMember(kSTATIC_THREE), 3);
EXPECT_EQ(val.size(), 1);
EXPECT_EQ(val.removeMember(kSTATIC_THREE).type(), json::NullValue);
EXPECT_EQ(val.removeMember(kSTATIC_THREE).type(), json::ValueType::Null);
EXPECT_EQ(val.size(), 1);
EXPECT_EQ(val.removeMember(std::string("two")), 2);
EXPECT_EQ(val.size(), 0);
EXPECT_EQ(val.removeMember(std::string("two")).type(), json::NullValue);
EXPECT_EQ(val.removeMember(std::string("two")).type(), json::ValueType::Null);
EXPECT_EQ(val.size(), 0);
}
@@ -1199,7 +1197,7 @@ TEST(json_value, iterator)
{
{
// Iterating an array.
json::Value arr{json::ArrayValue};
json::Value arr{json::ValueType::Array};
arr[0u] = "zero";
arr[1u] = "one";
arr[2u] = "two";
@@ -1237,7 +1235,7 @@ TEST(json_value, iterator)
{
// Iterating a const object.
json::Value const obj{[]() {
json::Value obj{json::ObjectValue};
json::Value obj{json::ValueType::Object};
obj["0"] = 0;
obj["1"] = 1;
obj["2"] = 2;
@@ -1334,27 +1332,27 @@ TEST(json_value, memory_leak)
{
json::Value a;
a[0u] = 1;
EXPECT_EQ(a.type(), json::ArrayValue);
EXPECT_EQ(a[0u].type(), json::IntValue);
EXPECT_EQ(a.type(), json::ValueType::Array);
EXPECT_EQ(a[0u].type(), json::ValueType::Int);
a = std::move(a[0u]);
EXPECT_EQ(a.type(), json::IntValue);
EXPECT_EQ(a.type(), json::ValueType::Int);
}
{
json::Value b;
json::Value temp;
temp["a"] = "Probably avoids the small string optimization";
temp["b"] = "Also probably avoids the small string optimization";
EXPECT_EQ(temp.type(), json::ObjectValue);
EXPECT_EQ(temp.type(), json::ValueType::Object);
b.append(temp);
EXPECT_EQ(temp.type(), json::ObjectValue);
EXPECT_EQ(temp.type(), json::ValueType::Object);
EXPECT_EQ(b.size(), 1);
b.append(std::move(temp));
EXPECT_EQ(b.size(), 2);
// Note that the type() == nullValue check is implementation
// Note that the type() == ValueType::Null check is implementation
// specific and not guaranteed to be valid in the future.
EXPECT_EQ(temp.type(), json::NullValue); // NOLINT(bugprone-use-after-move)
EXPECT_EQ(temp.type(), json::ValueType::Null); // NOLINT(bugprone-use-after-move)
}
}

2
src/tests/libxrpl/json/Writer.cpp
View File

@@ -164,7 +164,7 @@ TEST_F(WriterFixture, complex_object)
TEST_F(WriterFixture, json_value)
{
json::Value value(json::ObjectValue);
json::Value value(json::ValueType::Object);
value["foo"] = 23;
writer_->startRoot(Writer::CollectionType::Object);
writer_->set("hello", value);

48
src/tests/libxrpl/protocol_autogen/TestHelpers.h
View File

@@ -28,60 +28,60 @@ namespace xrpl {
// Typed field canonical values
using Uint8Value = std::decay_t<typename SF_UINT8::type::value_type>;
inline Uint8Value
using UInt8Value = std::decay_t<typename SF_UINT8::type::value_type>;
inline UInt8Value
canonical_UINT8()
{
return Uint8Value{1};
return UInt8Value{1};
}
using Uint16Value = std::decay_t<typename SF_UINT16::type::value_type>;
inline Uint16Value
using UInt16Value = std::decay_t<typename SF_UINT16::type::value_type>;
inline UInt16Value
canonical_UINT16()
{
return Uint16Value{1};
return UInt16Value{1};
}
using Uint32Value = std::decay_t<typename SF_UINT32::type::value_type>;
inline Uint32Value
using UInt32Value = std::decay_t<typename SF_UINT32::type::value_type>;
inline UInt32Value
canonical_UINT32()
{
return Uint32Value{1};
return UInt32Value{1};
}
using Uint64Value = std::decay_t<typename SF_UINT64::type::value_type>;
inline Uint64Value
using UInt64Value = std::decay_t<typename SF_UINT64::type::value_type>;
inline UInt64Value
canonical_UINT64()
{
return Uint64Value{1};
return UInt64Value{1};
}
using Uint128Value = std::decay_t<typename SF_UINT128::type::value_type>;
inline Uint128Value
using UInt128Value = std::decay_t<typename SF_UINT128::type::value_type>;
inline UInt128Value
canonical_UINT128()
{
return Uint128Value{1};
return UInt128Value{1};
}
using Uint160Value = std::decay_t<typename SF_UINT160::type::value_type>;
inline Uint160Value
using UInt160Value = std::decay_t<typename SF_UINT160::type::value_type>;
inline UInt160Value
canonical_UINT160()
{
return Uint160Value{1};
return UInt160Value{1};
}
using Uint192Value = std::decay_t<typename SF_UINT192::type::value_type>;
inline Uint192Value
using UInt192Value = std::decay_t<typename SF_UINT192::type::value_type>;
inline UInt192Value
canonical_UINT192()
{
return Uint192Value{1};
return UInt192Value{1};
}
using Uint256Value = std::decay_t<typename SF_UINT256::type::value_type>;
inline Uint256Value
using UInt256Value = std::decay_t<typename SF_UINT256::type::value_type>;
inline UInt256Value
canonical_UINT256()
{
return Uint256Value{1};
return UInt256Value{1};
}
using Int32Value = std::decay_t<typename SF_INT32::type::value_type>;