Implement v6 filters

2 files changed, 206 insertions, 500 deletions

diff --git a/test/comparisons.cpp b/test/comparisons.cpp
index 4ffcf2e2ec..9b74d6e36f 100644
--- a/test/comparisons.cpp
+++ b/test/comparisons.cpp
@@ -1,306 +1,103 @@
 #include <iostream>
 #include "gtest/gtest.h"
 
-#include <mbgl/style/filter_comparison_private.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 MockExtractor {
+class Extractor {
 public:
-    inline MockExtractor(const std::multimap<std::string, mbgl::Value> &values_) : values(values_) {}
-    inline MockExtractor() {}
+    inline Extractor(const Properties& properties_, FeatureType type_)
+        : properties(properties_)
+        , type(type_)
+    {}
+
+    mapbox::util::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 mapbox::util::optional<Value>();
+        return it->second;
+    }
 
-    inline std::vector<mbgl::Value> getValues(const std::string &key) const {
-        std::vector<mbgl::Value> result;
-        // Find all values with the requested key.
-        const auto ret = values.equal_range(key);
-        for (auto it = ret.first; it != ret.second; it++) {
-            // Append the newly found value to the forward list.
-            result.emplace_back(it->second);
-        }
-        return result;
+    FeatureType getType() const {
+        return type;
     }
 
 private:
-    const std::multimap<std::string, mbgl::Value> values;
+    const Properties properties;
+    FeatureType type;
 };
 
-
-TEST(FilterComparison, EqualsSingleStringValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { std::string("bar") });
-    // comparison is { "test": { "==": "bar" } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor()));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("barst") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(32.8) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-}
-
-
-TEST(FilterComparison, EqualsSingleDoubleValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { double(32.8) });
-    // comparison is { "test": { "==": 32.8 } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(32.8) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("32.8") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", double(32.8) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(32.8) }, { "test", std::string("booz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", double(32.8) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor()));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(32.9) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-}
-
-TEST(FilterComparison, EqualsSingleUintValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { uint64_t(42) });
-    // comparison is { "test": { "==": 42 } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("42") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", uint64_t(42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(42) }, { "test", std::string("booz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", uint64_t(42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor()));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(43) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-}
-
-TEST(FilterComparison, EqualsSingleIntValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { int64_t(-42) });
-    // comparison is { "test": { "==": -42 } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(-42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("-42") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", int64_t(-42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-42) }, { "test", std::string("booz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", int64_t(-42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor()));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-43) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(-43) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(-42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-}
-
-TEST(FilterComparison, EqualsSingleBoolValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { bool(true) });
-    // comparison is { "test": { "==": true } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(1) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(1) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(1) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("1") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", bool(true) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }, { "test", std::string("booz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", bool(true) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor()));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-}
-
-
-
-TEST(FilterComparison, EqualsMultipleStringValues) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { std::string("bar"), std::string("baz") });
-    // comparison is { "test": { "==": ["bar", "baz"]̇ } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("baz") }, { "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("baz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }, { "test", std::string("boo") }})));
-}
-
-TEST(FilterComparison, EqualsMultipleIdenticalStringValues) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::Equal, std::vector<Value> { std::string("bar"), std::string("bar") });
-    // comparison is { "test": { "==": ["bar", "bar"]̇ } }
-
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("baz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }})));
-}
-
-
-
-TEST(FilterComparison, NotEqualsSingleStringValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { std::string("bar") });
-    // comparison is { "test": { "!=": "bar" } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor()));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("barst") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(32.8) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
+FilterExpression parse(const char * expression) {
+    rapidjson::Document doc;
+    doc.Parse<0>(expression);
+    return parseFilterExpression(doc);
 }
 
-
-TEST(FilterComparison, NotEqualsSingleDoubleValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { double(32.8) });
-    // comparison is { "test": { "!=": 32.8 } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(32.8) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("32.8") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", double(32.8) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(32.8) }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", double(32.8) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor()));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(32.9) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
+bool evaluate(const FilterExpression& expression, const Properties& properties, FeatureType type = FeatureType::Unknown) {
+    return mbgl::evaluate(expression, Extractor(properties, type));
 }
 
-TEST(FilterComparison, NotEqualsSingleUintValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { uint64_t(42) });
-    // comparison is { "test": { "!=": 42 } }
+TEST(FilterComparison, EqualsString) {
+    FilterExpression f = parse("[\"==\", \"foo\", \"bar\"]");
+    ASSERT_TRUE(evaluate(f, {{ "foo", std::string("bar") }}));
+    ASSERT_FALSE(evaluate(f, {{ "foo", std::string("baz") }}));
+};
 
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("42") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", uint64_t(42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(42) }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", uint64_t(42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor()));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(43) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
+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, NotEqualsSingleIntValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { int64_t(-42) });
-    // comparison is { "test": { "!=": -42 } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(-42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(-42) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("-42") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", int64_t(-42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-42) }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", int64_t(-42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor()));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-43) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", double(-43) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(-42) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
+TEST(FilterComparison, EqualsType) {
+    FilterExpression f = parse("[\"==\", \"$type\", \"LineString\"]");
+    ASSERT_FALSE(evaluate(f, {{}}, FeatureType::Point));
+    ASSERT_TRUE(evaluate(f, {{}}, FeatureType::LineString));
 }
 
-
-TEST(FilterComparison, NotEqualsSingleBoolValue) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { bool(true) });
-    // comparison is { "test": { "!=": true } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", bool(true) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", int64_t(1) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", uint64_t(1) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", double(1) }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("1") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "other", std::string("bar") }, { "test", bool(true) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(true) }, { "test", std::string("booz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "other", bool(true) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor()));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", bool(false) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", int64_t(-18932) }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", uint64_t(18932) }})));
+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, NotEqualsMultipleStringValues) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { std::string("bar"), std::string("baz") });
-    // comparison is { "test": { "!=": ["bar", "baz"]̇ } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("baz") }, { "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("baz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }, { "test", std::string("boo") }})));
+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, NotEqualsMultipleIdenticalStringValues) {
-    using namespace mbgl;
-
-    FilterComparison comparison("test");
-    comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { std::string("bar"), std::string("bar") });
-    // comparison is { "test": { "!=": ["bar", "bar"]̇ } }
-
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }})));
-    ASSERT_FALSE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("bar") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("baz") }})));
-    ASSERT_TRUE(comparison.compare(MockExtractor({{ "test", std::string("bar") }, { "test", std::string("baz") }})));
+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/variant.cpp b/test/variant.cpp
index 4557465cfa..e4caba9f2d 100644
--- a/test/variant.cpp
+++ b/test/variant.cpp
@@ -17,110 +17,26 @@ TEST(Variant, toString) {
     EXPECT_EQ("false", toString( false ));
 }
 
-
-TEST(Variant, RelaxedEqualityStringToBool) {
-    // 1-ish values are true
-    EXPECT_TRUE(util::relaxed_equal(std::string("1"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("1.0"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 1"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0x1"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0X1"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 1.0"), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 1  "), bool(true)));
-
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string("1")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string("1.0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string(" 1")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string(" 0x1")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string(" 0X1")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string(" 1.0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string(" 1  ")));
-
-    // 0-ish values are false
-    EXPECT_TRUE(util::relaxed_equal(std::string("0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("0.0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0x0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0X0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0.0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(" 0  "), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string(""), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("  "), bool(false)));
-
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("0.0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string(" 0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string(" 0x0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string(" 0X0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string(" 0.0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string(" 0  ")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("  ")));
-
-
-    // other string values are neither true nor false
-    EXPECT_FALSE(util::relaxed_equal(std::string(" 1.0 g"), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("foo"), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("true"), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("false"), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" inf "), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" inFINITY "), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" nan "), bool(true)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" NAN "), bool(true)));
-
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string(" 1.0 g")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("foo")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("true")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string("false")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string(" inf ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string(" inFINITY ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string(" nan ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(true), std::string(" NAN ")));
-
-
-    EXPECT_FALSE(util::relaxed_equal(std::string(" 1.0 g"), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("foo"), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("true"), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string("false"), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" inf "), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" inFINITY "), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" nan "), bool(false)));
-    EXPECT_FALSE(util::relaxed_equal(std::string(" NAN "), bool(false)));
-
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string(" 1.0 g")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("foo")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("true")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string("false")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string(" inf ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string(" inFINITY ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string(" nan ")));
-    EXPECT_FALSE(util::relaxed_equal(bool(false), std::string(" NAN ")));
-}
-
 TEST(Variant, RelaxedEquality) {
     // Compare to bool
     EXPECT_TRUE(util::relaxed_equal(bool(false), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), int64_t(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), uint64_t(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), double(0)));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("0")));
-    EXPECT_TRUE(util::relaxed_equal(bool(false), std::string("")));
-
     EXPECT_TRUE(util::relaxed_equal(bool(true), bool(true)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), int64_t(1)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), uint64_t(1)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), double(1)));
-    EXPECT_TRUE(util::relaxed_equal(bool(true), std::string("1")));
-
-
     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)));
@@ -135,10 +51,9 @@ TEST(Variant, RelaxedEquality) {
     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_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)));
@@ -151,16 +66,14 @@ TEST(Variant, RelaxedEquality) {
     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_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)));
@@ -173,17 +86,15 @@ TEST(Variant, RelaxedEquality) {
     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_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)));
@@ -205,16 +116,14 @@ TEST(Variant, RelaxedEquality) {
     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(""), bool(false)));
-    EXPECT_TRUE(util::relaxed_equal(std::string("1"), bool(true)));
-
+    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)));
@@ -239,46 +148,46 @@ TEST(Variant, RelaxedEquality) {
 
 TEST(Variant, RelaxedGreater) {
     EXPECT_TRUE(util::relaxed_greater(std::string("387"), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater(int64_t(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater(double(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater(bool(true), std::string("0")));
+    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_TRUE(util::relaxed_greater(std::string("387"), uint64_t(386)));
+    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_TRUE(util::relaxed_greater(bool(true), uint64_t(0)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), uint64_t(0)));
 
-    EXPECT_TRUE(util::relaxed_greater(std::string("387"), int64_t(386)));
+    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_TRUE(util::relaxed_greater(bool(true), int64_t(0)));
+    EXPECT_FALSE(util::relaxed_greater(bool(true), int64_t(0)));
 
-    EXPECT_TRUE(util::relaxed_greater(std::string("387"), double(386.7)));
+    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_TRUE(util::relaxed_greater(bool(true), double(0)));
-
-    EXPECT_TRUE(util::relaxed_greater(std::string("387"), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater(std::string("387"), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(int64_t(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(double(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(double(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(uint64_t(387), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater(int64_t(387), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater(double(387), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater(double(387), bool(true)));
-
-    EXPECT_TRUE(util::relaxed_greater(bool(true), double(0)));
-    EXPECT_TRUE(util::relaxed_greater(bool(true), double(0.5)));
-    EXPECT_TRUE(util::relaxed_greater(bool(true), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater(bool(true), int64_t(0)));
-    EXPECT_TRUE(util::relaxed_greater(bool(true), uint64_t(0)));
+    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)));
 
 
 
@@ -315,52 +224,52 @@ TEST(Variant, RelaxedGreater) {
 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_TRUE(util::relaxed_greater_equal(uint64_t(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_greater_equal(double(387), std::string("386")));
-    EXPECT_TRUE(util::relaxed_greater_equal(double(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_greater_equal(bool(true), std::string("0")));
-
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), uint64_t(386)));
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), uint64_t(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_TRUE(util::relaxed_greater_equal(bool(true), uint64_t(0)));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), uint64_t(0)));
 
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), int64_t(386)));
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), int64_t(387)));
+    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_TRUE(util::relaxed_greater_equal(bool(true), int64_t(0)));
+    EXPECT_FALSE(util::relaxed_greater_equal(bool(true), int64_t(0)));
 
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), double(386.7)));
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), double(387)));
+    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_TRUE(util::relaxed_greater_equal(bool(true), double(0)));
-
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater_equal(std::string("387"), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater_equal(uint64_t(387), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater_equal(int64_t(387), bool(true)));
-    EXPECT_TRUE(util::relaxed_greater_equal(double(387), bool(false)));
-    EXPECT_TRUE(util::relaxed_greater_equal(double(387), bool(true)));
+    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)));
 
@@ -391,43 +300,43 @@ TEST(Variant, RelaxedGreaterEqual) {
 
 TEST(Variant, RelaxedLess) {
     EXPECT_TRUE(util::relaxed_less(std::string("387"), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less(uint64_t(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less(int64_t(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less(double(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less(bool(false), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less(bool(false), std::string("1")));
+    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_TRUE(util::relaxed_less(std::string("387"), uint64_t(388)));
+    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_TRUE(util::relaxed_less(bool(false), uint64_t(388)));
-    EXPECT_TRUE(util::relaxed_less(bool(false), uint64_t(1)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), uint64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), uint64_t(1)));
 
-    EXPECT_TRUE(util::relaxed_less(std::string("387"), int64_t(388)));
+    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_TRUE(util::relaxed_less(bool(false), int64_t(388)));
-    EXPECT_TRUE(util::relaxed_less(bool(false), int64_t(1)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), int64_t(388)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), int64_t(1)));
 
-    EXPECT_TRUE(util::relaxed_less(std::string("387"), double(387.7)));
+    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_TRUE(util::relaxed_less(bool(false), double(387)));
-    EXPECT_TRUE(util::relaxed_less(bool(false), double(1)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), double(387)));
+    EXPECT_FALSE(util::relaxed_less(bool(false), double(1)));
 
-    EXPECT_TRUE(util::relaxed_less(std::string("0"), bool(true)));
-    EXPECT_TRUE(util::relaxed_less(uint64_t(0), bool(true)));
-    EXPECT_TRUE(util::relaxed_less(int64_t(0), bool(true)));
-    EXPECT_TRUE(util::relaxed_less(double(0), bool(true)));
+    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_TRUE(util::relaxed_less(bool(true), std::string("386")));
-    EXPECT_TRUE(util::relaxed_less(bool(true), uint64_t(386)));
-    EXPECT_TRUE(util::relaxed_less(bool(true), int64_t(386)));
-    EXPECT_TRUE(util::relaxed_less(bool(true), double(386)));
+    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)));
 
 
 
@@ -464,60 +373,60 @@ TEST(Variant, RelaxedLess) {
 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_TRUE(util::relaxed_less_equal(uint64_t(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less_equal(int64_t(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_less_equal(double(387), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less_equal(double(387), std::string("387")));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), std::string("388")));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), std::string("1")));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), std::string("0")));
-
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), uint64_t(388)));
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), uint64_t(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_TRUE(util::relaxed_less_equal(bool(false), uint64_t(388)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), uint64_t(1)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), uint64_t(0)));
+    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_TRUE(util::relaxed_less_equal(std::string("387"), int64_t(388)));
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), int64_t(387)));
+    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_TRUE(util::relaxed_less_equal(bool(false), int64_t(388)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), int64_t(1)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), int64_t(0)));
+    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_TRUE(util::relaxed_less_equal(std::string("387"), double(387.7)));
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("387"), double(387)));
+    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_TRUE(util::relaxed_less_equal(bool(false), double(387)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), double(1)));
-    EXPECT_TRUE(util::relaxed_less_equal(bool(false), double(0)));
-
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("0"), bool(true)));
-    EXPECT_TRUE(util::relaxed_less_equal(std::string("0"), bool(false)));
-    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(0), bool(true)));
-    EXPECT_TRUE(util::relaxed_less_equal(uint64_t(0), bool(false)));
-    EXPECT_TRUE(util::relaxed_less_equal(int64_t(0), bool(true)));
-    EXPECT_TRUE(util::relaxed_less_equal(int64_t(0), bool(false)));
-    EXPECT_TRUE(util::relaxed_less_equal(double(0), bool(true)));
-    EXPECT_TRUE(util::relaxed_less_equal(double(0), bool(false)));
+    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)));