diff options
Diffstat (limited to 'test/comparisons.cpp')
-rw-r--r-- | test/comparisons.cpp | 306 |
1 files changed, 306 insertions, 0 deletions
diff --git a/test/comparisons.cpp b/test/comparisons.cpp new file mode 100644 index 0000000000..44a1cc1bdd --- /dev/null +++ b/test/comparisons.cpp @@ -0,0 +1,306 @@ +#include <iostream> +#include "gtest/gtest.h" + +#include <llmr/style/filter_comparison_private.hpp> +#include <llmr/style/filter_expression_private.hpp> + +#include <map> + + + +class MockExtractor { +public: + inline MockExtractor(const std::multimap<std::string, llmr::Value> &values) : values(values) {} + inline MockExtractor() {} + + inline std::vector<llmr::Value> getValues(const std::string &key) const { + std::vector<llmr::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; + } + +private: + const std::multimap<std::string, llmr::Value> values; +}; + + +TEST(FilterComparison, EqualsSingleStringValue) { + using namespace llmr; + + 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 llmr; + + 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 llmr; + + 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 llmr; + + 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 llmr; + + 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 llmr; + + 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 llmr; + + 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 llmr; + + 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) }}))); +} + + +TEST(FilterComparison, NotEqualsSingleDoubleValue) { + using namespace llmr; + + 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) }}))); +} + +TEST(FilterComparison, NotEqualsSingleUintValue) { + using namespace llmr; + + FilterComparison comparison("test"); + comparison.add(FilterComparison::Operator::NotEqual, std::vector<Value> { uint64_t(42) }); + // comparison is { "test": { "!=": 42 } } + + 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, NotEqualsSingleIntValue) { + using namespace llmr; + + 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, NotEqualsSingleBoolValue) { + using namespace llmr; + + 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, NotEqualsMultipleStringValues) { + using namespace llmr; + + 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, NotEqualsMultipleIdenticalStringValues) { + using namespace llmr; + + 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") }}))); +} |