generalize variant comparison and add more operators

3 files changed, 213 insertions, 143 deletions

diff --git a/include/llmr/map/filter_expression.hpp b/include/llmr/map/filter_expression.hpp
index 29abb9a257..bf6d414802 100644
--- a/include/llmr/map/filter_expression.hpp
+++ b/include/llmr/map/filter_expression.hpp
@@ -11,7 +11,11 @@ namespace llmr {
 
 enum class FilterOperator {
     Equal,
-    NotEqual
+    NotEqual,
+    Greater,
+    GreaterEqual,
+    Less,
+    LessEqual
 };
 
 enum class ExpressionOperator {
@@ -25,6 +29,14 @@ inline FilterOperator filterOperatorType(const std::string &op) {
         return FilterOperator::NotEqual;
     } else if (op == "==" || op == "eq") {
         return FilterOperator::Equal;
+    } else if (op == ">" || op == "gt") {
+        return FilterOperator::Greater;
+    } else if (op == ">=" || op == "gte") {
+        return FilterOperator::GreaterEqual;
+    } else if (op == "<" || op == "lt") {
+        return FilterOperator::Less;
+    } else if (op == "<=" || op == "lte") {
+        return FilterOperator::LessEqual;
     } else {
         fprintf(stderr, "[WARNING] filter operator '%s' unrecognized\n", op.c_str());
         return FilterOperator::Equal;
@@ -74,10 +86,20 @@ public:
 
     inline bool compare(const Value &other) const {
         switch (op) {
+        case FilterOperator::Equal:
+            return util::relaxed_equal(value, other);
         case FilterOperator::NotEqual:
-            return !util::relaxed_equal(value)(other);
+            return !util::relaxed_equal(value, other);
+        case FilterOperator::Greater:
+            return util::relaxed_greater(value, other);
+        case FilterOperator::GreaterEqual:
+            return util::relaxed_greater_equal(value, other);
+        case FilterOperator::Less:
+            return util::relaxed_less(value, other);
+        case FilterOperator::LessEqual:
+            return util::relaxed_less_equal(value, other);
         default:
-            return util::relaxed_equal(value)(other);
+            return false;
         }
     }
 
diff --git a/include/llmr/style/value.hpp b/include/llmr/style/value.hpp
index f295903634..e1247af1d9 100644
--- a/include/llmr/style/value.hpp
+++ b/include/llmr/style/value.hpp
@@ -14,6 +14,8 @@ Value parseValue(pbf data);
 
 namespace util {
 
+namespace detail {
+
 inline int string_to_bool(std::string str) {
     std::transform(str.begin(), str.end(), str.begin(), ::tolower);
     if (str == "false" || str == "null" || !str.length()) return 0;
@@ -52,44 +54,85 @@ template <> struct string_to_number<uint64_t> {
     }
 };
 
-struct relaxed_equal_visitor {
-    bool operator()(bool lhs, bool rhs) const { return lhs == rhs; }
+template <typename Operator>
+struct relaxed_operator_visitor {
+    bool operator()(bool lhs, bool rhs) const { return Operator()(lhs, rhs); }
 
     template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
-    bool operator()(bool lhs, T rhs) const { return lhs == bool(rhs); }
+    bool operator()(bool lhs, T rhs) const { return Operator()(lhs, bool(rhs)); }
 
     template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
-    bool operator()(T lhs, bool rhs) const { return bool(lhs) == rhs; }
+    bool operator()(T lhs, bool rhs) const { return Operator()(bool(lhs), rhs); }
 
-    bool operator()(int64_t lhs, uint64_t rhs) const { return lhs < 0 ? false : uint64_t(lhs) == rhs; }
-    bool operator()(uint64_t lhs, int64_t rhs) const { return rhs < 0 ? false : lhs == uint64_t(rhs); }
+    bool operator()(int64_t lhs, uint64_t rhs) const { return lhs < 0 ? false : Operator()(uint64_t(lhs), rhs); }
+    bool operator()(uint64_t lhs, int64_t rhs) const { return rhs < 0 ? false : Operator()(lhs, uint64_t(rhs)); }
 
     template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
-    bool operator()(T lhs, const std::string &rhs) const try { return lhs == string_to_number<T>()(rhs); }
+    bool operator()(const std::string &lhs, T rhs) const try { return Operator()(string_to_number<T>()(lhs), rhs); }
     catch(...) { return false; }
 
     template <typename T, class = typename std::enable_if<std::is_arithmetic<T>::value>::type>
-    bool operator()(const std::string &lhs, T rhs) const try { return string_to_number<T>()(lhs) == rhs; }
+    bool operator()(T lhs, const std::string &rhs) const try { return Operator()(lhs, string_to_number<T>()(rhs)); }
     catch(...) { return false; }
 
     template <typename T0, typename T1>
+    bool operator()(T0 lhs, T1 rhs) const { return Operator()(lhs, rhs); }
+};
+
+struct relaxed_equal_operator {
+    template <typename T0, typename T1>
     bool operator()(T0 lhs, T1 rhs) const { return lhs == rhs; }
 };
 
-struct relaxed_equal {
-    relaxed_equal(Value const &lhs) : lhs(lhs) {}
+struct relaxed_greater_operator {
+    template <typename T0, typename T1>
+    bool operator()(T0 lhs, T1 rhs) const { return lhs > rhs; }
+};
 
-    bool operator()(Value const &rhs) const {
-        return apply_visitor(lhs, rhs, relaxed_equal_visitor());
-    }
-    Value const &lhs;
+struct relaxed_greater_equal_operator {
+    template <typename T0, typename T1>
+    bool operator()(T0 lhs, T1 rhs) const { return lhs >= rhs; }
+};
+
+struct relaxed_less_operator {
+    template <typename T0, typename T1>
+    bool operator()(T0 lhs, T1 rhs) const { return lhs < rhs; }
+};
+
+struct relaxed_less_equal_operator {
+    template <typename T0, typename T1>
+    bool operator()(T0 lhs, T1 rhs) const { return lhs <= rhs; }
 };
+
+
+} // end namespace detail
+
+inline bool relaxed_equal(Value const &lhs, Value const &rhs) {
+    return apply_visitor(lhs, rhs, detail::relaxed_operator_visitor<detail::relaxed_equal_operator>());
+}
+
+inline bool relaxed_greater(Value const &lhs, Value const &rhs) {
+    return apply_visitor(lhs, rhs, detail::relaxed_operator_visitor<detail::relaxed_greater_operator>());
+}
+
+inline bool relaxed_greater_equal(Value const &lhs, Value const &rhs) {
+    return apply_visitor(lhs, rhs, detail::relaxed_operator_visitor<detail::relaxed_greater_equal_operator>());
+}
+
+inline bool relaxed_less(Value const &lhs, Value const &rhs) {
+    return apply_visitor(lhs, rhs, detail::relaxed_operator_visitor<detail::relaxed_less_operator>());
+}
+
+inline bool relaxed_less_equal(Value const &lhs, Value const &rhs) {
+    return apply_visitor(lhs, rhs, detail::relaxed_operator_visitor<detail::relaxed_less_equal_operator>());
+}
+
 }
 
 
 template <typename T>
 T toNumber(const Value &value) {
-    if (value.is<std::string>()) return util::string_to_number<T>()(value.get<std::string>());
+    if (value.is<std::string>()) return util::detail::string_to_number<T>()(value.get<std::string>());
     else if (value.is<bool>()) return value.get<bool>();
     else if (value.is<int64_t>()) return value.get<int64_t>();
     else if (value.is<uint64_t>()) return value.get<uint64_t>();
diff --git a/test/variant.cpp b/test/variant.cpp
index 9a855d15c3..2cd545fe15 100644
--- a/test/variant.cpp
+++ b/test/variant.cpp
@@ -20,141 +20,146 @@ TEST(Variant, toString) {
 
 TEST(Variant, RelaxedEquality) {
     // Compare to bool
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(int64_t(386)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(int64_t(-7042)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(int64_t(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(uint64_t(386)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(uint64_t(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(double(386)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(double(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(std::string("386")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("false")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("False")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("null")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("nuLL")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(std::string("NULL")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false))(bool(false)));
-
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(int64_t(0)));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(uint64_t(0)));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(double(0)));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(std::string("")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(std::string("false")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(std::string("FALSE")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(std::string("null")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(std::string("Null")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false))(int64_t(-754)));
-    EXPECT_FALSE(util::relaxed_equal(bool(false))(uint64_t(3)));
-    EXPECT_FALSE(util::relaxed_equal(bool(false))(double(3.145)));
-    EXPECT_FALSE(util::relaxed_equal(bool(false))(std::string("test")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true))(bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(bool(false))(bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), int64_t(-7042)));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), int64_t(0)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), uint64_t(0)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), double(386)));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), double(0)));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string("386")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("false")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("False")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("null")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("nuLL")));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("NULL")));
+    EXPECT_TRUE(util::relaxed_equal(bool(true), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(bool(false), bool(false)));
+
+    EXPECT_FALSE(util::relaxed_equal(bool(true), int64_t(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), uint64_t(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), double(0)));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("false")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("FALSE")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("null")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("Null")));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), int64_t(-754)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), uint64_t(3)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), double(3.145)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("test")));
+    EXPECT_FALSE(util::relaxed_equal(bool(true), bool(false)));
+    EXPECT_FALSE(util::relaxed_equal(bool(false), bool(true)));
 
 
     // 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_TRUE(util::relaxed_equal(int64_t(386))(std::string("386")));
-    EXPECT_TRUE(util::relaxed_equal(int64_t(1))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(int64_t(0))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(int64_t(1))(std::string("true")));
-    EXPECT_TRUE(util::relaxed_equal(int64_t(0))(std::string("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("false")));
-    EXPECT_FALSE(util::relaxed_equal(int64_t(0))(std::string("true")));
+    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_TRUE(util::relaxed_equal(int64_t(386), std::string("386")));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(1), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(0), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(1), std::string("true")));
+    EXPECT_TRUE(util::relaxed_equal(int64_t(0), std::string("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("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_TRUE(util::relaxed_equal(uint64_t(386))(std::string("386")));
-    EXPECT_TRUE(util::relaxed_equal(uint64_t(1))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(uint64_t(0))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(uint64_t(1))(std::string("true")));
-    EXPECT_TRUE(util::relaxed_equal(uint64_t(0))(std::string("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("false")));
-    EXPECT_FALSE(util::relaxed_equal(uint64_t(0))(std::string("true")));
+    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_TRUE(util::relaxed_equal(uint64_t(386), std::string("386")));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(1), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(0), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(1), std::string("true")));
+    EXPECT_TRUE(util::relaxed_equal(uint64_t(0), std::string("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("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_TRUE(util::relaxed_equal(double(386))(std::string("386")));
-    EXPECT_TRUE(util::relaxed_equal(double(1))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(double(0))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(double(1))(std::string("true")));
-    EXPECT_TRUE(util::relaxed_equal(double(1))(std::string("TRue")));
-    EXPECT_TRUE(util::relaxed_equal(double(0))(std::string("false")));
-    EXPECT_TRUE(util::relaxed_equal(double(0))(std::string("FALSe")));
-    EXPECT_TRUE(util::relaxed_equal(double(0))(std::string("null")));
-    EXPECT_TRUE(util::relaxed_equal(double(0))(std::string("Null")));
-
-    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("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")));
+    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_TRUE(util::relaxed_equal(double(386), std::string("386")));
+    EXPECT_TRUE(util::relaxed_equal(double(1), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(double(0), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(double(1), std::string("true")));
+    EXPECT_TRUE(util::relaxed_equal(double(1), std::string("TRue")));
+    EXPECT_TRUE(util::relaxed_equal(double(0), std::string("false")));
+    EXPECT_TRUE(util::relaxed_equal(double(0), std::string("FALSe")));
+    EXPECT_TRUE(util::relaxed_equal(double(0), std::string("null")));
+    EXPECT_TRUE(util::relaxed_equal(double(0), std::string("Null")));
+
+    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("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_TRUE(util::relaxed_equal(std::string("386"))(int64_t(386)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("-386"))(int64_t(-386)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("386"))(uint64_t(386)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("386.36"))(double(386.36)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("true"))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("True"))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("some string"))(bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("false"))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("fAlse"))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("null"))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("NULl"))(bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(""))(bool(false)));
-
-    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("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)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("lord"), std::string("lord")));
+    EXPECT_TRUE(util::relaxed_equal(std::string("386"), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("-386"), int64_t(-386)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("386"), uint64_t(386)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("386.36"), double(386.36)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("true"), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("True"), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("some string"), bool(true)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("false"), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("fAlse"), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("null"), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(std::string("NULl"), bool(false)));
+    EXPECT_TRUE(util::relaxed_equal(std::string(""), bool(false)));
+
+    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("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"), int64_t(386)));
+    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), int64_t(386)));
 }