rearrange tests and add storage tests

11 files changed, 1321 insertions, 0 deletions

diff --git a/test/miscellaneous/clip_ids.cpp b/test/miscellaneous/clip_ids.cpp
new file mode 100644
index 0000000000..ebd819e264
--- /dev/null
+++ b/test/miscellaneous/clip_ids.cpp
@@ -0,0 +1,251 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <algorithm>
+
+#include <mbgl/util/clip_ids.hpp>
+#include <mbgl/util/std.hpp>
+
+using namespace mbgl;
+
+template <typename T> void generate(const T &sources) {
+    ClipIDGenerator generator;
+
+    for (size_t j = 0; j < sources.size(); j++) {
+        std::forward_list<Tile *> tile_ptrs;
+        std::transform(sources[j].begin(), sources[j].end(), std::front_inserter(tile_ptrs), [](const std::shared_ptr<Tile> &tile) { return tile.get(); });
+        generator.update(tile_ptrs);
+    }
+}
+
+template <typename T> void print(const T &sources) {
+    for (size_t j = 0; j < sources.size(); j++) {
+        for (size_t i = 0; i < sources[j].size(); i++) {
+            std::cout << "    ASSERT_EQ(ClipID(\"" << sources[j][i]->clip.mask << "\", \"" << sources[j][i]->clip.reference << "\"), sources[" << j << "][" << i << "]->clip);\n";
+        }
+    }
+}
+
+TEST(ClipIDs, ParentAndFourChildren) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 1, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 0, 1 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000011"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000101"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000001"), sources[0][4]->clip);
+}
+
+TEST(ClipIDs, ParentAndFourChildrenNegative) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 1, -2, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, -2, 1 }),
+            std::make_shared<Tile>(Tile::ID { 1, -1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, -1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 0, -1, 0 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000011"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000101"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000001"), sources[0][4]->clip);
+}
+
+TEST(ClipIDs, NegativeParentAndMissingLevel) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 1, -1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, -1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, -2, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, -1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, -2, 0 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000111", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000011"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000101"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[0][4]->clip);
+}
+
+
+TEST(ClipIDs, SevenOnSameLevel) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 0, 2 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 2 }),
+            std::make_shared<Tile>(Tile::ID { 2, 2, 0 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000111", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000011"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000101"), sources[0][4]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000110"), sources[0][5]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000111"), sources[0][6]->clip);
+}
+
+TEST(ClipIDs, MultipleLevels) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
+                std::make_shared<Tile>(Tile::ID { 3, 0, 0 }),
+                std::make_shared<Tile>(Tile::ID { 3, 0, 1 }),
+                    std::make_shared<Tile>(Tile::ID { 4, 0, 2 }),
+                    std::make_shared<Tile>(Tile::ID { 4, 1, 2 }),
+                    std::make_shared<Tile>(Tile::ID { 4, 0, 3 }),
+                    std::make_shared<Tile>(Tile::ID { 4, 1, 3 }),
+                std::make_shared<Tile>(Tile::ID { 3, 1, 0 }),
+                std::make_shared<Tile>(Tile::ID { 3, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 0 }),
+                std::make_shared<Tile>(Tile::ID { 3, 2, 0 }),
+                std::make_shared<Tile>(Tile::ID { 3, 2, 1 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00001111", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000011"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000100"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001001"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001011"), sources[0][4]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001010"), sources[0][5]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001100"), sources[0][6]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000101"), sources[0][7]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000110"), sources[0][8]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000010"), sources[0][9]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000111"), sources[0][10]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001000"), sources[0][11]->clip);
+}
+
+
+TEST(ClipIDs, Bug206) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 10, 162, 395 }),
+            std::make_shared<Tile>(Tile::ID { 10, 162, 396 }),
+            std::make_shared<Tile>(Tile::ID { 10, 163, 395 }),
+                std::make_shared<Tile>(Tile::ID { 11, 326, 791 }),
+                std::make_shared<Tile>(Tile::ID { 12, 654, 1582 }),
+                std::make_shared<Tile>(Tile::ID { 12, 654, 1583 }),
+                std::make_shared<Tile>(Tile::ID { 12, 655, 1582 }),
+                std::make_shared<Tile>(Tile::ID { 12, 655, 1583 }),
+            std::make_shared<Tile>(Tile::ID { 10, 163, 396 }),
+            std::make_shared<Tile>(Tile::ID { 10, 164, 395 }),
+            std::make_shared<Tile>(Tile::ID { 10, 164, 396 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00001111", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000010"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000011"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000111"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001000"), sources[0][4]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001001"), sources[0][5]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001010"), sources[0][6]->clip);
+    ASSERT_EQ(ClipID("00001111", "00001011"), sources[0][7]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000100"), sources[0][8]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000101"), sources[0][9]->clip);
+    ASSERT_EQ(ClipID("00001111", "00000110"), sources[0][10]->clip);
+}
+
+
+TEST(ClipIDs, MultipleSources) {
+    const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 2, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 2, 2 }),
+        },
+        {
+            std::make_shared<Tile>(Tile::ID { 0, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 2, 2 }),
+        },
+        {
+            std::make_shared<Tile>(Tile::ID { 1, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 0, 1 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 0 }),
+            std::make_shared<Tile>(Tile::ID { 1, 1, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 1, 1 }),
+        },
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000111", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000011"), sources[0][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[0][3]->clip);
+    ASSERT_EQ(ClipID("00011000", "00001000"), sources[1][0]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000010"), sources[1][1]->clip);
+    ASSERT_EQ(ClipID("00011000", "00010000"), sources[1][2]->clip);
+    ASSERT_EQ(ClipID("00000111", "00000100"), sources[1][3]->clip);
+    ASSERT_EQ(ClipID("11100000", "00100000"), sources[2][0]->clip);
+    ASSERT_EQ(ClipID("11100000", "01000000"), sources[2][1]->clip);
+    ASSERT_EQ(ClipID("11100000", "01100000"), sources[2][2]->clip);
+    ASSERT_EQ(ClipID("11100000", "10000000"), sources[2][3]->clip);
+    ASSERT_EQ(ClipID("00011000", "00010000"), sources[2][4]->clip);
+}
+
+
+TEST(ClipIDs, DuplicateIDs) {
+        const std::vector<std::vector<std::shared_ptr<Tile>>> sources = {
+        {
+            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+        },
+        {
+            std::make_shared<Tile>(Tile::ID { 2, 0, 0 }),
+            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+            std::make_shared<Tile>(Tile::ID { 2, 0, 1 }),
+        }
+    };
+
+    generate(sources);
+    // print(sources);
+
+    ASSERT_EQ(ClipID("00000011", "00000001"), sources[0][0]->clip);
+    ASSERT_EQ(ClipID("00000011", "00000010"), sources[0][1]->clip);
+    ASSERT_EQ(ClipID("00000011", "00000001"), sources[1][0]->clip);
+    ASSERT_EQ(ClipID("00000011", "00000010"), sources[1][1]->clip);
+    ASSERT_EQ(ClipID("00000011", "00000010"), sources[1][2]->clip);
+}
diff --git a/test/miscellaneous/comparisons.cpp b/test/miscellaneous/comparisons.cpp
new file mode 100644
index 0000000000..0daa78ab77
--- /dev/null
+++ b/test/miscellaneous/comparisons.cpp
@@ -0,0 +1,103 @@
+#include <iostream>
+#include "../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_)
+    {}
+
+    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;
+    }
+
+    FeatureType getType() const {
+        return type;
+    }
+
+private:
+    const Properties properties;
+    FeatureType type;
+};
+
+FilterExpression parse(const char * expression) {
+    rapidjson::Document 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, 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/miscellaneous/enums.cpp b/test/miscellaneous/enums.cpp
new file mode 100644
index 0000000000..dc71645128
--- /dev/null
+++ b/test/miscellaneous/enums.cpp
@@ -0,0 +1,35 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <algorithm>
+
+#include <mbgl/style/types.hpp>
+
+using namespace mbgl;
+
+TEST(Enums, StyleLayerType) {
+    ASSERT_EQ(StyleLayerType::Unknown, StyleLayerTypeClass("unknown"));
+    ASSERT_EQ(StyleLayerType::Fill, StyleLayerTypeClass("fill"));
+    ASSERT_EQ(StyleLayerType::Line, StyleLayerTypeClass("line"));
+    ASSERT_EQ(StyleLayerType::Symbol, StyleLayerTypeClass("symbol"));
+    ASSERT_EQ(StyleLayerType::Raster, StyleLayerTypeClass("raster"));
+    ASSERT_EQ(StyleLayerType::Background, StyleLayerTypeClass("background"));
+
+    ASSERT_EQ(StyleLayerType::Unknown, StyleLayerTypeClass(StyleLayerType::Unknown));
+    ASSERT_EQ(StyleLayerType::Fill, StyleLayerTypeClass(StyleLayerType::Fill));
+    ASSERT_EQ(StyleLayerType::Line, StyleLayerTypeClass(StyleLayerType::Line));
+    ASSERT_EQ(StyleLayerType::Symbol, StyleLayerTypeClass(StyleLayerType::Symbol));
+    ASSERT_EQ(StyleLayerType::Raster, StyleLayerTypeClass(StyleLayerType::Raster));
+    ASSERT_EQ(StyleLayerType::Background, StyleLayerTypeClass(StyleLayerType::Background));
+
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Unknown), StyleLayerTypeClass(StyleLayerType::Unknown));
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Fill), StyleLayerTypeClass(StyleLayerType::Fill));
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Line), StyleLayerTypeClass(StyleLayerType::Line));
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Symbol), StyleLayerTypeClass(StyleLayerType::Symbol));
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Raster), StyleLayerTypeClass(StyleLayerType::Raster));
+    ASSERT_EQ(StyleLayerTypeClass(StyleLayerType::Background), StyleLayerTypeClass(StyleLayerType::Background));
+
+    ASSERT_FALSE(StyleLayerTypeClass("").valid());
+    ASSERT_FALSE(StyleLayerTypeClass("Backgrund").valid());
+}
+
diff --git a/test/miscellaneous/functions.cpp b/test/miscellaneous/functions.cpp
new file mode 100644
index 0000000000..6543a32d1f
--- /dev/null
+++ b/test/miscellaneous/functions.cpp
@@ -0,0 +1,58 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <mbgl/style/function_properties.hpp>
+
+using namespace mbgl;
+
+TEST(Function, Constant) {
+    EXPECT_EQ(2.0f, mbgl::ConstantFunction<float>(2).evaluate(0));
+    EXPECT_EQ(3.8f, mbgl::ConstantFunction<float>(3.8).evaluate(0));
+    EXPECT_EQ(22.0f, mbgl::ConstantFunction<float>(22).evaluate(0));
+    EXPECT_EQ(2.0f, mbgl::ConstantFunction<float>(2).evaluate(4));
+    EXPECT_EQ(3.8f, mbgl::ConstantFunction<float>(3.8).evaluate(4));
+    EXPECT_EQ(22.0f, mbgl::ConstantFunction<float>(22).evaluate(4));
+    EXPECT_EQ(2.0f, mbgl::ConstantFunction<float>(2).evaluate(22));
+    EXPECT_EQ(3.8f, mbgl::ConstantFunction<float>(3.8).evaluate(22));
+    EXPECT_EQ(22.0f, mbgl::ConstantFunction<float>(22).evaluate(22));
+}
+
+TEST(Function, Stops) {
+    // Explicit constant slope in fringe regions.
+    mbgl::StopsFunction<float> slope_1({ { 0, 1.5 }, { 6, 1.5 }, { 8, 3 }, { 22, 3 } }, 1.75);
+    EXPECT_EQ(1.5, slope_1.evaluate(0));
+    EXPECT_EQ(1.5, slope_1.evaluate(4));
+    EXPECT_EQ(1.5, slope_1.evaluate(6));
+    ASSERT_FLOAT_EQ(2.0454545454545454, slope_1.evaluate(7));
+    EXPECT_EQ(3.0, slope_1.evaluate(8));
+    EXPECT_EQ(3.0, slope_1.evaluate(9));
+    EXPECT_EQ(3.0, slope_1.evaluate(15));
+    EXPECT_EQ(3.0, slope_1.evaluate(22));
+
+
+    // Test constant values in fringe regions.
+    mbgl::StopsFunction<float> slope_2({ { 6, 1.5 }, { 8, 3 } }, 1.75);
+    EXPECT_EQ(1.5, slope_2.evaluate(0));
+    EXPECT_EQ(1.5, slope_2.evaluate(4));
+    EXPECT_EQ(1.5, slope_2.evaluate(6));
+    ASSERT_FLOAT_EQ(2.0454545454545454, slope_2.evaluate(7));
+    EXPECT_EQ(3.0, slope_2.evaluate(8));
+    EXPECT_EQ(3.0, slope_2.evaluate(9));
+    EXPECT_EQ(3.0, slope_2.evaluate(15));
+    EXPECT_EQ(3.0, slope_2.evaluate(22));
+
+    // Test no values.
+    mbgl::StopsFunction<float> slope_3({}, 1.75);
+    EXPECT_EQ(1, slope_3.evaluate(2));
+    EXPECT_EQ(1, slope_3.evaluate(6));
+    EXPECT_EQ(1, slope_3.evaluate(12));
+
+
+    // Explicit constant slope in fringe regions.
+    mbgl::StopsFunction<float> slope_4({ { 0, 2 }, { 8, 10 } }, 1);
+    EXPECT_EQ(2, slope_4.evaluate(0));
+    EXPECT_EQ(3, slope_4.evaluate(1));
+    EXPECT_EQ(4, slope_4.evaluate(2));
+    EXPECT_EQ(4.75, slope_4.evaluate(2.75));
+    EXPECT_EQ(10, slope_4.evaluate(8));
+}
diff --git a/test/miscellaneous/merge_lines.cpp b/test/miscellaneous/merge_lines.cpp
new file mode 100644
index 0000000000..0e7328d195
--- /dev/null
+++ b/test/miscellaneous/merge_lines.cpp
@@ -0,0 +1,75 @@
+#include "../fixtures/util.hpp"
+
+#include <mbgl/util/merge_lines.hpp>
+
+const std::u32string a = U"a";
+const std::u32string b = U"b";
+
+TEST(MergeLines, SameText) {
+    // merges lines with the same text
+    std::vector<mbgl::SymbolFeature> input1 = {
+        { {{{0, 0}, {1, 0}, {2, 0}}}, a, "" },
+        { {{{4, 0}, {5, 0}, {6, 0}}}, b, "" },
+        { {{{8, 0}, {9, 0}}}, a, "" },
+        { {{{2, 0}, {3, 0}, {4, 0}}}, a, "" },
+        { {{{6, 0}, {7, 0}, {8, 0}}}, a, "" },
+        { {{{5, 0}, {6, 0}}}, a, "" }
+    };
+
+    const std::vector<mbgl::SymbolFeature> expected1 = {
+        { {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}}}, a, "" },
+        { {{{4, 0}, {5, 0}, {6, 0}}}, b, "" },
+        { {{{5, 0}, {6, 0}, {7, 0}, {8, 0}, {9, 0}}}, a, "" },
+        { {{}}, a, "" },
+        { {{}}, a, "" },
+        { {{}}, a, "" }
+    };
+
+    mbgl::util::mergeLines(input1);
+
+    for (int i = 0; i < 6; i++) {
+        EXPECT_EQ(input1[i].geometry, expected1[i].geometry);
+    }
+}
+
+TEST(MergeLines, BothEnds) {
+    // mergeLines handles merge from both ends
+    std::vector<mbgl::SymbolFeature> input2 = {
+        { {{{0, 0}, {1, 0}, {2, 0}}}, a, "" },
+        { {{{4, 0}, {5, 0}, {6, 0}}}, a, "" },
+        { {{{2, 0}, {3, 0}, {4, 0}}}, a, "" }
+    };
+
+    const std::vector<mbgl::SymbolFeature> expected2 = {
+        { {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {5, 0}, {6, 0}}}, a, "" },
+        { {{}}, a, "" },
+        { {{}}, a, "" }
+    };
+
+    mbgl::util::mergeLines(input2);
+
+    for (int i = 0; i < 3; i++) {
+        EXPECT_EQ(input2[i].geometry, expected2[i].geometry);
+    }
+}
+
+TEST(MergeLines, CircularLines) {
+    // mergeLines handles circular lines
+    std::vector<mbgl::SymbolFeature> input3 = {
+        { {{{0, 0}, {1, 0}, {2, 0}}}, a, "" },
+        { {{{2, 0}, {3, 0}, {4, 0}}}, a, "" },
+        { {{{4, 0}, {0, 0}}}, a, "" }
+    };
+
+    const std::vector<mbgl::SymbolFeature> expected3 = {
+        { {{{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}, {0, 0}}}, a, "" },
+        { {{}}, a, "" },
+        { {{}}, a, "" }
+    };
+
+    mbgl::util::mergeLines(input3);
+
+    for (int i = 0; i < 3; i++) {
+        EXPECT_EQ(input3[i].geometry, expected3[i].geometry);
+    }
+}
diff --git a/test/miscellaneous/miscellaneous.gypi b/test/miscellaneous/miscellaneous.gypi
new file mode 100644
index 0000000000..023f28fa6d
--- /dev/null
+++ b/test/miscellaneous/miscellaneous.gypi
@@ -0,0 +1,26 @@
+{
+  'targets': [
+    { 'target_name': 'test_miscellaneous',
+      'type': 'executable',
+      'dependencies': [
+        'test_base',
+        '../mapboxgl.gyp:mbgl-core',
+        '../mapboxgl.gyp:mbgl-<(platform)',
+        '../mapboxgl.gyp:mbgl-headless',
+        '../deps/gtest/gtest.gyp:gtest'
+      ],
+      'sources': [
+        'main.cpp',
+        'clip_ids.cpp',
+        'comparisons.cpp',
+        'enums.cpp',
+        'functions.cpp',
+        'rotation_range.cpp',
+        'style_parser.cpp',
+        'text_conversions.cpp',
+        'tile.cpp',
+        'variant.cpp',
+      ],
+    },
+  ],
+}
diff --git a/test/miscellaneous/rotation_range.cpp b/test/miscellaneous/rotation_range.cpp
new file mode 100644
index 0000000000..3106e900f6
--- /dev/null
+++ b/test/miscellaneous/rotation_range.cpp
@@ -0,0 +1,139 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <algorithm>
+
+#include <mbgl/text/rotation_range.hpp>
+
+using namespace mbgl;
+
+double deg(double x) { return x / M_PI * 180.0; }
+
+TEST(RotationRange, mergeCollisions) {
+    // merge overlapping ranges
+    EXPECT_EQ(
+        CollisionRange({{1.0 / 8.0 * M_PI, 6.0 / 8.0 * M_PI}}),
+        mergeCollisions(
+            CollisionList(
+                {{CollisionRange({{3.0 / 8.0 * M_PI, 5.0 / 8.0 * M_PI}}),
+                  CollisionRange({{4.0 / 8.0 * M_PI, 6.0 / 8.0 * M_PI}}),
+                  CollisionRange({{1.0 / 8.0 * M_PI, 2.0 / 8.0 * M_PI}})}}),
+            PlacementRange({{2.0 * M_PI, 0.0}})));
+
+    // ignore collision within ignore range
+    EXPECT_EQ(
+        CollisionRange({{5.0 / 4.0 * M_PI, 6.0 / 4.0 * M_PI}}),
+        mergeCollisions(CollisionList({{CollisionRange({{M_PI / 2, M_PI}}),
+                                        CollisionRange({{5.0 / 4.0 * M_PI,
+                                                         6.0 / 4.0 * M_PI}})}}),
+                        PlacementRange({{0, M_PI}})));
+
+    // crop collision that ends within ignore range
+    EXPECT_EQ(CollisionRange({{1.0 / 2.0 * M_PI, 3.0 / 4.0 * M_PI}}),
+              mergeCollisions(
+                  CollisionList({{CollisionRange({{1.0 / 2.0 * M_PI, M_PI}})}}),
+                  PlacementRange({{3.0 / 4.0 * M_PI, 3.0 / 2.0 * M_PI}})));
+
+    // crop collision that starts within ignore range
+    EXPECT_EQ(CollisionRange({{3.0 / 4.0 * M_PI, M_PI}}),
+              mergeCollisions(
+                  CollisionList({{CollisionRange({{1.0 / 2.0 * M_PI, M_PI}})}}),
+                  PlacementRange({{1.0 / 4.0 * M_PI, 3.0 / 4.0 * M_PI}})));
+}
+
+TEST(RotationRange, rotatingFixedCollisions) {
+    // returns collisions
+
+    auto collisions = rotatingFixedCollisions(
+        CollisionRect{CollisionPoint{-1, 0}, CollisionPoint{0, 1}},
+        CollisionRect{CollisionPoint{1.4142, -10}, CollisionPoint{10, 10}});
+
+    EXPECT_EQ(static_cast<std::size_t>(1), collisions.size());
+    EXPECT_EQ(135, std::round(deg(collisions.front()[0])));
+    EXPECT_EQ(135, std::round(deg(collisions.front()[1])));
+}
+
+TEST(RotationRange, cornerBoxCollisions) {
+    {
+        // returns intersections in sorted order as angles 0..2PI
+        CollisionList list;
+        cornerBoxCollisions(
+            std::back_inserter(list), CollisionPoint{1, 1},
+            CollisionCorners{{CollisionPoint{0, 0},   CollisionPoint{0, 10},
+                              CollisionPoint{10, 10}, CollisionPoint{10, 0}}});
+        EXPECT_EQ(static_cast<std::size_t>(1), list.size());
+        EXPECT_EQ((CollisionRange{{M_PI / 4.0, M_PI * 7.0 / 4.0}}), list[0]);
+    }
+
+    {
+        // handles no intersections
+        CollisionList list;
+        cornerBoxCollisions(
+            std::back_inserter(list), CollisionPoint{200, 200},
+            CollisionCorners{{CollisionPoint{1, 1},   CollisionPoint{1, 10},
+                              CollisionPoint{10, 10}, CollisionPoint{10, 1}}});
+        EXPECT_EQ(static_cast<std::size_t>(0), list.size());
+    }
+}
+
+TEST(RotationRange, circleEdgeCollisions) {
+    {
+        // handles two intersection points
+        CollisionAngles list;
+        circleEdgeCollisions(std::back_inserter(list), CollisionPoint{0, 1}, 1,
+                             CollisionPoint{-10, 0}, CollisionPoint{10, 0});
+        std::sort(list.begin(), list.end());
+        EXPECT_EQ(static_cast<std::size_t>(2), list.size());
+        EXPECT_EQ(static_cast<float>(M_PI / 2), list[0]);
+        EXPECT_EQ(static_cast<float>(M_PI * 3.0 / 2.0), list[1]);
+    }
+
+    {
+        // handles one intersection point
+        CollisionAngles list;
+        circleEdgeCollisions(std::back_inserter(list), CollisionPoint{0, 1}, 1,
+                             CollisionPoint{0, 0}, CollisionPoint{10, 0});
+        EXPECT_EQ(static_cast<std::size_t>(1), list.size());
+        EXPECT_EQ(static_cast<float>(M_PI / 2), list[0]);
+    }
+
+    {
+        // only returns intersections within the line segment
+        CollisionAngles list;
+        circleEdgeCollisions(std::back_inserter(list), CollisionPoint{0, 1}, 1,
+                             CollisionPoint{3, 1}, CollisionPoint{30, 1});
+        EXPECT_EQ(static_cast<std::size_t>(0), list.size());
+    }
+
+    {
+        // doesnt count tangetial intersections as collisions
+        CollisionAngles list;
+        circleEdgeCollisions(std::back_inserter(list), CollisionPoint{0, 1}, 1,
+                             CollisionPoint{-10, 1}, CollisionPoint{10, 1});
+        EXPECT_EQ(static_cast<std::size_t>(0), list.size());
+    }
+}
+
+TEST(RotationRange, rotatingRotatingCollisions) {
+    {
+        // basically works
+        CollisionList c = rotatingRotatingCollisions(
+            CollisionRect{{-1, 0}, {1, 0}}, CollisionRect{{-1, 0}, {1, 0}},
+            CollisionAnchor{1, 1});
+
+        EXPECT_EQ(static_cast<std::size_t>(2), c.size());
+        EXPECT_EQ(135, std::round(deg(c[0][0])));
+        EXPECT_EQ(135, std::round(deg(c[0][1])));
+        EXPECT_EQ(315, std::round(deg(c[1][0])));
+        EXPECT_EQ(315, std::round(deg(c[1][1])));
+    }
+
+    {
+        // checks if the two boxes are close enough to collide at that angle
+        CollisionList c = rotatingRotatingCollisions(
+            CollisionRect{{-1, 0}, {1, 0}}, CollisionRect{{-1, 0}, {1, 0}},
+            CollisionAnchor{2, 2});
+
+        EXPECT_EQ(static_cast<std::size_t>(0), c.size());
+    }
+}
diff --git a/test/miscellaneous/style_parser.cpp b/test/miscellaneous/style_parser.cpp
new file mode 100644
index 0000000000..3cef6ae614
--- /dev/null
+++ b/test/miscellaneous/style_parser.cpp
@@ -0,0 +1,94 @@
+#include "../util.hpp"
+
+#include <mbgl/style/style.hpp>
+#include <mbgl/util/io.hpp>
+
+#include <rapidjson/document.h>
+
+#include "../fixtures/fixture_log.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 = "test/fixtures/style_parser/" + GetParam();
+
+    const std::string style_path = base + ".style.json";
+    const std::string info = util::read_file(base + ".info.json");
+
+    // Parse settings.
+    rapidjson::Document doc;
+    doc.Parse<0>((const char *const)info.c_str());
+    ASSERT_FALSE(doc.HasParseError());
+    ASSERT_TRUE(doc.IsObject());
+
+    std::ifstream stylefile(style_path);
+    ASSERT_TRUE(stylefile.good());
+    std::stringstream stylejson;
+    stylejson << stylefile.rdbuf();
+
+    const FixtureLogBackend &log = Log::Set<FixtureLogBackend>();
+
+    Style style;
+    style.loadJSON((const uint8_t *)stylejson.str().c_str());
+
+    for (auto it = doc.MemberBegin(), end = doc.MemberEnd(); it != end; it++) {
+        const std::string name { it->name.GetString(), it->name.GetStringLength() };
+        const rapidjson::Value &value = it->value;
+        ASSERT_EQ(true, value.IsObject());
+
+        if (value.HasMember("log")) {
+            const rapidjson::Value &js_log = value["log"];
+            ASSERT_EQ(true, js_log.IsArray());
+            for (rapidjson::SizeType i = 0; i < js_log.Size(); i++) {
+                const rapidjson::Value &js_entry = js_log[i];
+                ASSERT_EQ(true, js_entry.IsArray());
+
+                const uint32_t count = js_entry[rapidjson::SizeType(0)].GetUint();
+                const FixtureLogBackend::LogMessage message {
+                    EventSeverityClass(js_entry[rapidjson::SizeType(1)].GetString()),
+                    EventClass(js_entry[rapidjson::SizeType(2)].GetString()),
+                    js_entry[rapidjson::SizeType(3)].GetString()
+                };
+
+                EXPECT_EQ(count, log.count(message)) << "Message: " << message << std::endl;
+            }
+        }
+
+        const auto &unchecked = log.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;
+}()));
diff --git a/test/miscellaneous/text_conversions.cpp b/test/miscellaneous/text_conversions.cpp
new file mode 100644
index 0000000000..4ea62b4686
--- /dev/null
+++ b/test/miscellaneous/text_conversions.cpp
@@ -0,0 +1,35 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <mbgl/util/utf.hpp>
+#include <mbgl/platform/platform.hpp>
+
+using namespace mbgl;
+
+TEST(TextConversions, to_upper) {
+    EXPECT_EQ(std::string("STREET"), platform::uppercase("strEEt"));  // EN
+    EXPECT_EQ(std::string("ROAD"), platform::uppercase("rOAd"));      // EN
+
+    EXPECT_EQ(std::string("STRASSE"), platform::uppercase("straße")); // DE
+    EXPECT_EQ(std::string("MASSE"), platform::uppercase("maße"));     // DE
+    EXPECT_EQ(std::string("WEISSKOPFSEEADLER"), platform::uppercase("weißkopfseeadler")); // DE
+
+    EXPECT_EQ(std::string("AZƏRBAYCAN"), platform::uppercase("Azərbaycan")); // AZ
+
+    EXPECT_EQ(std::string("ὈΔΥΣΣΕΎΣ"), platform::uppercase("Ὀδυσσεύς")); // GR
+}
+
+
+TEST(TextConversions, to_lower) {
+    EXPECT_EQ(std::string("street"), platform::lowercase("strEEt"));  // EN
+    EXPECT_EQ(std::string("road"), platform::lowercase("rOAd"));      // EN
+
+    EXPECT_EQ(std::string("straße"), platform::lowercase("Straße"));   // DE
+    EXPECT_EQ(std::string("strasse"), platform::lowercase("STRASSE")); // DE
+    EXPECT_EQ(std::string("masse"), platform::lowercase("MASSE"));     // DE
+    EXPECT_EQ(std::string("weisskopfseeadler"), platform::lowercase("weiSSkopfseeadler")); // DE
+
+    EXPECT_EQ(std::string("azərbaycan"), platform::lowercase("AZƏRBAYCAN")); // AZ
+    EXPECT_EQ(std::string("ὀδυσσεύς"), platform::lowercase("ὈΔΥΣΣΕΎΣ")); // GR
+
+}
diff --git a/test/miscellaneous/tile.cpp b/test/miscellaneous/tile.cpp
new file mode 100644
index 0000000000..70ffd1ecd8
--- /dev/null
+++ b/test/miscellaneous/tile.cpp
@@ -0,0 +1,50 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <mbgl/map/tile.hpp>
+
+using namespace mbgl;
+
+
+TEST(Variant, isChild) {
+    ASSERT_TRUE(Tile::ID(1, 0, 0).isChildOf(Tile::ID(0, 0, 0)));
+    ASSERT_TRUE(Tile::ID(1, 1, 0).isChildOf(Tile::ID(0, 0, 0)));
+    ASSERT_TRUE(Tile::ID(1, 2, 0).isChildOf(Tile::ID(0, 1, 0)));
+    ASSERT_TRUE(Tile::ID(1, 3, 0).isChildOf(Tile::ID(0, 1, 0)));
+    ASSERT_TRUE(Tile::ID(1, 4, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(1, 5, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(2, 0, 0).isChildOf(Tile::ID(0, 0, 0)));
+
+    ASSERT_TRUE(Tile::ID(2, 8, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(2, 9, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(2, 10, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(2, 11, 0).isChildOf(Tile::ID(0, 2, 0)));
+    ASSERT_TRUE(Tile::ID(2, 12, 0).isChildOf(Tile::ID(0, 3, 0)));
+    ASSERT_TRUE(Tile::ID(2, 13, 0).isChildOf(Tile::ID(0, 3, 0)));
+
+    ASSERT_TRUE(Tile::ID(1, -1, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(1, -2, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(1, -3, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(1, -4, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(2, -1, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -2, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -3, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -4, 0).isChildOf(Tile::ID(0, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -5, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(2, -6, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(2, -7, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(2, -8, 0).isChildOf(Tile::ID(0, -2, 0)));
+
+    ASSERT_FALSE(Tile::ID(4, -16, 0).isChildOf(Tile::ID(0, -2, 0)));
+    ASSERT_TRUE(Tile::ID(4, -17, 0).isChildOf(Tile::ID(0, -2, 0)));
+
+    ASSERT_TRUE(Tile::ID(2, -1, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -2, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(2, -3, 0).isChildOf(Tile::ID(1, -2, 0)));
+    ASSERT_TRUE(Tile::ID(2, -4, 0).isChildOf(Tile::ID(1, -2, 0)));
+    ASSERT_TRUE(Tile::ID(3, -1, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(3, -2, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(3, -3, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(3, -4, 0).isChildOf(Tile::ID(1, -1, 0)));
+    ASSERT_TRUE(Tile::ID(3, -5, 0).isChildOf(Tile::ID(1, -2, 0)));
+}
diff --git a/test/miscellaneous/variant.cpp b/test/miscellaneous/variant.cpp
new file mode 100644
index 0000000000..979d73925e
--- /dev/null
+++ b/test/miscellaneous/variant.cpp
@@ -0,0 +1,455 @@
+#include <iostream>
+#include "../util.hpp"
+
+#include <mbgl/style/value.hpp>
+#include <mbgl/style/value_comparison.hpp>
+
+using namespace mbgl;
+
+TEST(Variant, toString) {
+    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)));
+}