[tests] Reorganize tests to match src structure

4 files changed, 743 insertions, 0 deletions

diff --git a/test/style/comparisons.cpp b/test/style/comparisons.cpp
new file mode 100644
index 0000000000..dc2d74bf11
--- /dev/null
+++ b/test/style/comparisons.cpp
@@ -0,0 +1,110 @@
+#include <iostream>
+#include "../fixtures/util.hpp"
+
+#include <mbgl/map/vector_tile.hpp>
+#include <mbgl/style/filter_expression.hpp>
+#include <mbgl/style/filter_expression_private.hpp>
+
+#include <map>
+
+using namespace mbgl;
+
+typedef std::multimap<std::string, mbgl::Value> Properties;
+
+class Extractor {
+public:
+    inline Extractor(const Properties& properties_, FeatureType type_)
+        : properties(properties_)
+        , type(type_)
+    {}
+
+    optional<Value> getValue(const std::string &key) const {
+        if (key == "$type")
+            return Value(uint64_t(type));
+        auto it = properties.find(key);
+        if (it == properties.end())
+            return optional<Value>();
+        return it->second;
+    }
+
+    FeatureType getType() const {
+        return type;
+    }
+
+private:
+    const Properties properties;
+    FeatureType type;
+};
+
+FilterExpression parse(const char * expression) {
+    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> doc;
+    doc.Parse<0>(expression);
+    return parseFilterExpression(doc);
+}
+
+bool evaluate(const FilterExpression& expression, const Properties& properties, FeatureType type = FeatureType::Unknown) {
+    return mbgl::evaluate(expression, Extractor(properties, type));
+}
+
+TEST(FilterComparison, EqualsString) {
+    FilterExpression f = parse("[\"==\", \"foo\", \"bar\"]");
+    ASSERT_TRUE(evaluate(f, {{ "foo", std::string("bar") }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", std::string("baz") }}));
+};
+
+TEST(FilterComparison, EqualsNumber) {
+    FilterExpression f = parse("[\"==\", \"foo\", 0]");
+    ASSERT_TRUE(evaluate(f, {{ "foo", int64_t(0) }}));
+    ASSERT_TRUE(evaluate(f, {{ "foo", uint64_t(0) }}));
+    ASSERT_TRUE(evaluate(f, {{ "foo", double(0) }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", int64_t(1) }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", uint64_t(1) }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", double(1) }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", std::string("0") }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", false }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", true }}));
+    ASSERT_FALSE(evaluate(f, {{}}));
+}
+
+TEST(FilterComparison, EqualsType) {
+    FilterExpression f = parse("[\"==\", \"$type\", \"LineString\"]");
+    ASSERT_FALSE(evaluate(f, {{}}, FeatureType::Point));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::LineString));
+}
+
+TEST(FilterComparison, InType) {
+    FilterExpression f = parse("[\"in\", \"$type\", \"LineString\", \"Polygon\"]");
+    ASSERT_FALSE(evaluate(f, {{}}, FeatureType::Point));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::LineString));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::Polygon));
+}
+
+TEST(FilterComparison, Any) {
+    ASSERT_FALSE(evaluate(parse("[\"any\"]"), {{}}));
+    ASSERT_TRUE(evaluate(parse("[\"any\", [\"==\", \"foo\", 1]]"),
+                         {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_FALSE(evaluate(parse("[\"any\", [\"==\", \"foo\", 0]]"),
+                          {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_TRUE(evaluate(parse("[\"any\", [\"==\", \"foo\", 0], [\"==\", \"foo\", 1]]"),
+                         {{ std::string("foo"), int64_t(1) }}));
+}
+
+TEST(FilterComparison, All) {
+    ASSERT_TRUE(evaluate(parse("[\"all\"]"), {{}}));
+    ASSERT_TRUE(evaluate(parse("[\"all\", [\"==\", \"foo\", 1]]"),
+                         {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_FALSE(evaluate(parse("[\"all\", [\"==\", \"foo\", 0]]"),
+                          {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_FALSE(evaluate(parse("[\"all\", [\"==\", \"foo\", 0], [\"==\", \"foo\", 1]]"),
+                          {{ std::string("foo"), int64_t(1) }}));
+}
+
+TEST(FilterComparison, None) {
+    ASSERT_TRUE(evaluate(parse("[\"none\"]"), {{}}));
+    ASSERT_FALSE(evaluate(parse("[\"none\", [\"==\", \"foo\", 1]]"),
+                          {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_TRUE(evaluate(parse("[\"none\", [\"==\", \"foo\", 0]]"),
+                         {{ std::string("foo"), int64_t(1) }}));
+    ASSERT_FALSE(evaluate(parse("[\"none\", [\"==\", \"foo\", 0], [\"==\", \"foo\", 1]]"),
+                          {{ std::string("foo"), int64_t(1) }}));
+}
diff --git a/test/style/functions.cpp b/test/style/functions.cpp
new file mode 100644
index 0000000000..d19d2ea88e
--- /dev/null
+++ b/test/style/functions.cpp
@@ -0,0 +1,59 @@
+#include <iostream>
+#include "../fixtures/util.hpp"
+
+#include <mbgl/style/function.hpp>
+#include <mbgl/style/style_calculation_parameters.hpp>
+
+using namespace mbgl;
+
+TEST(Function, Constant) {
+    EXPECT_EQ(2.0f, mbgl::Function<float>(2).evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(3.8f, mbgl::Function<float>(3.8).evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(22.0f, mbgl::Function<float>(22).evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(2.0f, mbgl::Function<float>(2).evaluate(StyleCalculationParameters(4)));
+    EXPECT_EQ(3.8f, mbgl::Function<float>(3.8).evaluate(StyleCalculationParameters(4)));
+    EXPECT_EQ(22.0f, mbgl::Function<float>(22).evaluate(StyleCalculationParameters(4)));
+    EXPECT_EQ(2.0f, mbgl::Function<float>(2).evaluate(StyleCalculationParameters(22)));
+    EXPECT_EQ(3.8f, mbgl::Function<float>(3.8).evaluate(StyleCalculationParameters(22)));
+    EXPECT_EQ(22.0f, mbgl::Function<float>(22).evaluate(StyleCalculationParameters(22)));
+}
+
+TEST(Function, Stops) {
+    // Explicit constant slope in fringe regions.
+    mbgl::Function<float> slope_1({ { 0, 1.5 }, { 6, 1.5 }, { 8, 3 }, { 22, 3 } }, 1.75);
+    EXPECT_EQ(1.5, slope_1.evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(1.5, slope_1.evaluate(StyleCalculationParameters(4)));
+    EXPECT_EQ(1.5, slope_1.evaluate(StyleCalculationParameters(6)));
+    ASSERT_FLOAT_EQ(2.0454545454545454, slope_1.evaluate(StyleCalculationParameters(7)));
+    EXPECT_EQ(3.0, slope_1.evaluate(StyleCalculationParameters(8)));
+    EXPECT_EQ(3.0, slope_1.evaluate(StyleCalculationParameters(9)));
+    EXPECT_EQ(3.0, slope_1.evaluate(StyleCalculationParameters(15)));
+    EXPECT_EQ(3.0, slope_1.evaluate(StyleCalculationParameters(22)));
+
+
+    // Test constant values in fringe regions.
+    mbgl::Function<float> slope_2({ { 6, 1.5 }, { 8, 3 } }, 1.75);
+    EXPECT_EQ(1.5, slope_2.evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(1.5, slope_2.evaluate(StyleCalculationParameters(4)));
+    EXPECT_EQ(1.5, slope_2.evaluate(StyleCalculationParameters(6)));
+    ASSERT_FLOAT_EQ(2.0454545454545454, slope_2.evaluate(StyleCalculationParameters(7)));
+    EXPECT_EQ(3.0, slope_2.evaluate(StyleCalculationParameters(8)));
+    EXPECT_EQ(3.0, slope_2.evaluate(StyleCalculationParameters(9)));
+    EXPECT_EQ(3.0, slope_2.evaluate(StyleCalculationParameters(15)));
+    EXPECT_EQ(3.0, slope_2.evaluate(StyleCalculationParameters(22)));
+
+    // Test no values.
+    mbgl::Function<float> slope_3({}, 1.75);
+    EXPECT_EQ(1, slope_3.evaluate(StyleCalculationParameters(2)));
+    EXPECT_EQ(1, slope_3.evaluate(StyleCalculationParameters(6)));
+    EXPECT_EQ(1, slope_3.evaluate(StyleCalculationParameters(12)));
+
+
+    // Explicit constant slope in fringe regions.
+    mbgl::Function<float> slope_4({ { 0, 2 }, { 8, 10 } }, 1);
+    EXPECT_EQ(2, slope_4.evaluate(StyleCalculationParameters(0)));
+    EXPECT_EQ(3, slope_4.evaluate(StyleCalculationParameters(1)));
+    EXPECT_EQ(4, slope_4.evaluate(StyleCalculationParameters(2)));
+    EXPECT_EQ(4.75, slope_4.evaluate(StyleCalculationParameters(2.75)));
+    EXPECT_EQ(10, slope_4.evaluate(StyleCalculationParameters(8)));
+}
diff --git a/test/style/style_parser.cpp b/test/style/style_parser.cpp
new file mode 100644
index 0000000000..22b5acb12b
--- /dev/null
+++ b/test/style/style_parser.cpp
@@ -0,0 +1,115 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/style/style_parser.hpp>
+#include <mbgl/util/io.hpp>
+
+#include <rapidjson/document.h>
+
+#include "../fixtures/fixture_log_observer.hpp"
+
+#include <iostream>
+#include <fstream>
+
+#include <dirent.h>
+
+using namespace mbgl;
+
+typedef std::pair<uint32_t, std::string> Message;
+typedef std::vector<Message> Messages;
+
+class StyleParserTest : public ::testing::TestWithParam<std::string> {};
+
+TEST_P(StyleParserTest, ParseStyle) {
+    const std::string base = std::string("test/fixtures/style_parser/") + GetParam();
+
+    rapidjson::GenericDocument<rapidjson::UTF8<>, rapidjson::CrtAllocator> infoDoc;
+    infoDoc.Parse<0>(util::read_file(base + ".info.json").c_str());
+    ASSERT_FALSE(infoDoc.HasParseError());
+    ASSERT_TRUE(infoDoc.IsObject());
+
+    FixtureLogObserver* observer = new FixtureLogObserver();
+    Log::setObserver(std::unique_ptr<Log::Observer>(observer));
+
+    StyleParser parser;
+    parser.parse(util::read_file(base + ".style.json"));
+
+    for (auto it = infoDoc.MemberBegin(), end = infoDoc.MemberEnd(); it != end; it++) {
+        const std::string name { it->name.GetString(), it->name.GetStringLength() };
+        const JSValue &value = it->value;
+        ASSERT_EQ(true, value.IsObject());
+
+        if (value.HasMember("log")) {
+            const JSValue &js_log = value["log"];
+            ASSERT_EQ(true, js_log.IsArray());
+            for (rapidjson::SizeType i = 0; i < js_log.Size(); i++) {
+                const JSValue &js_entry = js_log[i];
+                ASSERT_EQ(true, js_entry.IsArray());
+
+                const uint32_t count = js_entry[rapidjson::SizeType(0)].GetUint();
+                const FixtureLogObserver::LogMessage message {
+                    EventSeverityClass(js_entry[rapidjson::SizeType(1)].GetString()),
+                    EventClass(js_entry[rapidjson::SizeType(2)].GetString()),
+                    int64_t(-1),
+                    js_entry[rapidjson::SizeType(3)].GetString()
+                };
+
+                EXPECT_EQ(count, observer->count(message)) << "Message: " << message << std::endl;
+            }
+        }
+
+        const auto &unchecked = observer->unchecked();
+        if (unchecked.size()) {
+            std::cerr << "Unchecked Log Messages (" << base << "/" << name << "): " << std::endl << unchecked;
+        }
+
+        ASSERT_EQ(0ul, unchecked.size());
+    }
+}
+
+INSTANTIATE_TEST_CASE_P(StyleParser, StyleParserTest, ::testing::ValuesIn([] {
+    std::vector<std::string> names;
+    const std::string ending = ".info.json";
+
+    const std::string style_directory = "test/fixtures/style_parser";
+    DIR *dir = opendir(style_directory.c_str());
+    if (dir != nullptr) {
+        for (dirent *dp = nullptr; (dp = readdir(dir)) != nullptr;) {
+            const std::string name = dp->d_name;
+            if (name.length() >= ending.length() && name.compare(name.length() - ending.length(), ending.length(), ending) == 0) {
+                names.push_back(name.substr(0, name.length() - ending.length()));
+            }
+        }
+        closedir(dir);
+    }
+
+    EXPECT_GT(names.size(), 0ul);
+    return names;
+}()));
+
+TEST(StyleParser, ParseTileJSONRaster) {
+    auto result = StyleParser::parseTileJSON(
+        util::read_file("test/fixtures/style_parser/tilejson.raster.json"),
+        "mapbox://mapbox.satellite",
+        SourceType::Raster);
+
+    EXPECT_EQ(0, result->minZoom);
+    EXPECT_EQ(15, result->maxZoom);
+    EXPECT_EQ("attribution", result->attribution);
+#if !defined(__ANDROID__) && !defined(__APPLE__)
+    EXPECT_EQ("http://a.tiles.mapbox.com/mapbox.satellite/{z}-{x}-{y}{ratio}.webp?access_token=key", result->tiles[0]);
+#else
+    EXPECT_EQ("http://a.tiles.mapbox.com/mapbox.satellite/{z}-{x}-{y}{ratio}.png?access_token=key", result->tiles[0]);
+#endif
+}
+
+TEST(StyleParser, ParseTileJSONVector) {
+    auto result = StyleParser::parseTileJSON(
+        util::read_file("test/fixtures/style_parser/tilejson.vector.json"),
+        "mapbox://mapbox.streets",
+        SourceType::Vector);
+
+    EXPECT_EQ(0, result->minZoom);
+    EXPECT_EQ(15, result->maxZoom);
+    EXPECT_EQ("attribution", result->attribution);
+    EXPECT_EQ("http://a.tiles.mapbox.com/mapbox.streets/{z}-{x}-{y}.vector.pbf?access_token=key", result->tiles[0]);
+}
diff --git a/test/style/variant.cpp b/test/style/variant.cpp
new file mode 100644
index 0000000000..c55de3d27f
--- /dev/null
+++ b/test/style/variant.cpp
@@ -0,0 +1,459 @@
+#include <iostream>
+#include "../fixtures/util.hpp"
+
+#include <mbgl/style/value.hpp>
+#include <mbgl/style/value_comparison.hpp>
+
+using namespace mbgl;
+
+TEST(Variant, toString) {
+    // Force the default locale so we don't
+    // get results like "3,14" instead of "3.14".
+    std::locale::global(std::locale::classic());
+
+    EXPECT_EQ("lord", toString( (std::string)"lord" ));
+    EXPECT_EQ("36", toString( (uint64_t)36 ));
+    EXPECT_EQ("-239", toString( (int64_t)-239 ));
+    EXPECT_EQ("0", toString( (int64_t)0 ));
+    EXPECT_EQ("3.14159268", toString( (double)3.14159268 ));
+    EXPECT_EQ("3.1415926535897931", toString( (double)3.1415926535897931 ));
+    EXPECT_EQ("true", toString( true ));
+    EXPECT_EQ("false", toString( false ));
+}
+
+TEST(Variant, RelaxedEquality) {
+    // Compare to bool
+    EXPECT_TRUE(util::relaxed_equal(bool(false), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), int64_t(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), uint64_t(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), double(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("0")));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("")));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), int64_t(-7042)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), double(3.145)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("386")));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("test")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), int64_t(1)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), uint64_t(1)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), double(1)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("1")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), int64_t(-7042)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), double(3.145)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("386")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("test")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("")));
+
+    // Compare to int64_t
+    EXPECT_TRUE(util::relaxed_equal(int64_t(386), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(-7042), int64_t(-7042)));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(386), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(386), double(386)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(386), std::string("386")));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(1), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(0), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(386), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(-7042), int64_t(-7043)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(386), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(386), double(387)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(386), std::string("387")));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(1), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(1), std::string("true")));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(0), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(1), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(int64_t(0), std::string("true")));
+
+    // Compare to uint64_t
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(386), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(386), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(0), uint64_t(0)));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(386), double(386)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(386), std::string("386")));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(1), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(0), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(386), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(386), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(0), uint64_t(1)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(386), double(387)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(386), std::string("387")));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(1), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(1), std::string("true")));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(0), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(1), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(uint64_t(0), std::string("true")));
+
+    // Compare to double
+    EXPECT_TRUE(util::relaxed_equal(double(3.159385), double(3.159385)));
+    EXPECT_TRUE(util::relaxed_equal(double(386), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(double(386), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(double(0), uint64_t(0)));
+    EXPECT_TRUE(util::relaxed_equal(double(386), double(386)));
+    EXPECT_FALSE(util::relaxed_equal(double(386), std::string("386")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(double(0), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(double(3.159385), double(3.159383)));
+    EXPECT_FALSE(util::relaxed_equal(double(386), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(double(386), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(double(0), uint64_t(1)));
+    EXPECT_FALSE(util::relaxed_equal(double(386), double(387)));
+    EXPECT_FALSE(util::relaxed_equal(double(386), std::string("387")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(double(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("true")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("TRue")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("FALSe")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("null")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("Null")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("False")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("null")));
+    EXPECT_FALSE(util::relaxed_equal(double(1), std::string("NULL")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("true")));
+    EXPECT_FALSE(util::relaxed_equal(double(0), std::string("TRUE")));
+
+    // Compare to string
+    EXPECT_TRUE(util::relaxed_equal(std::string("lord"), std::string("lord")));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386"), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("-386"), int64_t(-386)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386"), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386.36"), double(386.36)));
+    EXPECT_FALSE(util::relaxed_equal(std::string(""), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("1"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("lord"), std::string("baron")));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386"), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("-386"), int64_t(-387)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386"), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("386.36"), double(386.37)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("some string"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("true"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("True"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("false"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("fAlse"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("null"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("NULl"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("true"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("TRUE"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("some string"), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("false"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("FALSE"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("null"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string("NULl"), bool(true)));
+    EXPECT_FALSE(util::relaxed_equal(std::string(""), bool(true)));
+}
+
+TEST(Variant, RelaxedGreater) {
+    EXPECT_TRUE(util::relaxed_greater(std::string("387"), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater(double(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), std::string("0")));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(int64_t(387), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(double(387), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), uint64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(int64_t(387), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(double(387), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), int64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater(int64_t(387), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater(double(387), double(386.7)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), double(0)));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), bool(true)));
+
+    EXPECT_FALSE(util::relaxed_greater(bool(true), double(0)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), double(0.5)));
+    EXPECT_TRUE(util::relaxed_greater(bool(true), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), int64_t(0)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), uint64_t(0)));
+
+
+
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater(double(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), std::string("388")));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), uint64_t(388)));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), int64_t(388)));
+
+    EXPECT_FALSE(util::relaxed_greater(std::string("387"), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater(uint64_t(387), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater(int64_t(387), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater(double(387), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), double(388)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater(bool(false), bool(false)));
+}
+
+
+
+TEST(Variant, RelaxedGreaterEqual) {
+    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), std::string("386")));
+    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), std::string("387")));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), std::string("0")));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), uint64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), int64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), double(386.7)));
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), double(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), double(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), double(387)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), double(386.7)));
+    EXPECT_TRUE(util::relaxed_greater_equal(double(387), double(387)));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), double(0)));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), bool(false)));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), bool(true)));
+    EXPECT_TRUE(util::relaxed_greater_equal(bool(true), bool(false)));
+    EXPECT_TRUE(util::relaxed_greater_equal(bool(true), bool(true)));
+
+
+
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), std::string("388")));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), uint64_t(388)));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), int64_t(388)));
+
+    EXPECT_FALSE(util::relaxed_greater_equal(std::string("387"), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater_equal(uint64_t(387), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater_equal(int64_t(387), double(388.7)));
+    EXPECT_FALSE(util::relaxed_greater_equal(double(387), double(388.7)));
+}
+
+
+TEST(Variant, RelaxedLess) {
+    EXPECT_TRUE(util::relaxed_less(std::string("387"), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less(double(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less(bool(false), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less(bool(false), std::string("1")));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(uint64_t(387), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(int64_t(387), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(double(387), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), uint64_t(1)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(uint64_t(387), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(int64_t(387), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less(double(387), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), int64_t(1)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less(uint64_t(387), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less(int64_t(387), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less(double(387), double(387.7)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), double(387)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), double(1)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("0"), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(int64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(double(0), bool(true)));
+    EXPECT_TRUE(util::relaxed_less(bool(false), bool(true)));
+
+    EXPECT_FALSE(util::relaxed_less(bool(true), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less(bool(true), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(bool(true), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(bool(true), double(386)));
+
+
+
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less(double(387), std::string("386")));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(double(387), uint64_t(386)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less(double(387), int64_t(386)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less(double(387), double(386.7)));
+
+    EXPECT_FALSE(util::relaxed_less(std::string("387"), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(uint64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(int64_t(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(double(387), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(bool(true), bool(true)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), bool(false)));
+}
+
+
+TEST(Variant, RelaxedLessEqual) {
+    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), std::string("388")));
+    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), std::string("387")));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), std::string("387")));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), std::string("388")));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), std::string("1")));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), std::string("0")));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), uint64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), uint64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), uint64_t(387)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), uint64_t(1)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), uint64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), int64_t(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), int64_t(388)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), int64_t(387)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), int64_t(1)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), int64_t(0)));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), double(387.7)));
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), double(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), double(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), double(387)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), double(387.7)));
+    EXPECT_TRUE(util::relaxed_less_equal(double(387), double(387)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), double(387)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), double(1)));
+    EXPECT_FALSE(util::relaxed_less_equal(bool(false), double(0)));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("0"), bool(true)));
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("0"), bool(false)));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(0), bool(false)));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(0), bool(false)));
+    EXPECT_FALSE(util::relaxed_less_equal(double(0), bool(true)));
+    EXPECT_FALSE(util::relaxed_less_equal(double(0), bool(false)));
+    EXPECT_TRUE(util::relaxed_less_equal(bool(false), bool(true)));
+    EXPECT_TRUE(util::relaxed_less_equal(bool(false), bool(false)));
+
+
+
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), std::string("386")));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), std::string("386")));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), uint64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), uint64_t(386)));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), int64_t(386)));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), int64_t(386)));
+
+    EXPECT_FALSE(util::relaxed_less_equal(std::string("387"), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less_equal(uint64_t(387), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less_equal(int64_t(387), double(386.7)));
+    EXPECT_FALSE(util::relaxed_less_equal(double(387), double(386.7)));
+}