add more comparison tests

This commit is contained in:
Konstantin Käfer
2014-07-16 17:57:11 -07:00
parent becce08a32
commit a1d7da71c6
9 changed files with 263 additions and 98 deletions

View File

@@ -46,7 +46,7 @@ public:
VectorTileTagExtractor(const VectorTileLayer &layer);
void setTags(const pbf &pbf);
std::forward_list<Value> getValues(const std::string &key) const;
std::vector<Value> getValues(const std::string &key) const;
void setType(FilterExpression::GeometryType type);
FilterExpression::GeometryType getType() const;

View File

@@ -4,10 +4,9 @@
#include <llmr/style/value.hpp>
#include <llmr/util/recursive_wrapper.hpp>
#include <forward_list>
#include <vector>
#include <string>
#include <ostream>
#include <iostream>
#include <iosfwd>
namespace llmr {
@@ -26,20 +25,14 @@ public:
class Instance {
public:
Instance(Operator op, std::forward_list<Value> &&values)
Instance(Operator op, std::vector<Value> &&values)
: op(op), values(values) {}
bool compare(const Value &property_value) const;
bool compare(const std::forward_list<Value> &property_values) const;
private:
template <typename Comparer> inline bool includes(const Value &property_value, const Comparer &comparer) const;
template <typename Comparer> inline bool compare(const Value &property_value, const Comparer &comparer) const;
template <typename Comparer> inline bool all(const std::forward_list<Value> &property_values, const Comparer &comparer) const;
bool compare(const std::vector<Value> &property_values) const;
private:
Operator op = Operator::Equal;
std::forward_list<Value> values;
std::vector<Value> values;
friend std::ostream& operator <<(std::ostream &, const Instance &);
};
@@ -52,12 +45,12 @@ public:
template <typename ...Args>
inline void add(Args&& ...args) {
instances.emplace_front(::std::forward<Args>(args)...);
instances.emplace_back(::std::forward<Args>(args)...);
}
private:
std::string field;
std::forward_list<Instance> instances;
std::vector<Instance> instances;
friend std::ostream& operator <<(std::ostream &, const FilterComparison &);
};
@@ -101,8 +94,8 @@ public:
private:
Operator op = Operator::And;
GeometryType type = GeometryType::Any;
std::forward_list<FilterComparison> comparisons;
std::forward_list<FilterExpression::Wrapper> expressions;
std::vector<FilterComparison> comparisons;
std::vector<FilterExpression::Wrapper> expressions;
friend std::ostream& operator <<(std::ostream &, const FilterExpression &);
};

View File

@@ -7,7 +7,7 @@ namespace llmr {
template <typename Extractor>
inline bool FilterComparison::compare(const Extractor &extractor) const {
const std::forward_list<Value> values = extractor.getValues(field);
const std::vector<Value> values = extractor.getValues(field);
// All instances are ANDed together.
for (const Instance &instance : instances) {

View File

@@ -91,7 +91,7 @@ private:
FilterExpression parseFilter(JSVal, FilterExpression::Operator op);
FilterExpression parseFilter(JSVal);
Value parseValue(JSVal value);
std::forward_list<Value> parseValues(JSVal values);
std::vector<Value> parseValues(JSVal values);
private:
std::unordered_map<std::string, const rapidjson::Value *> constants;

View File

@@ -51,6 +51,11 @@ struct relaxed_equal_operator {
inline bool operator()(T0 lhs, T1 rhs) const { return lhs == rhs; }
};
struct relaxed_not_equal_operator {
template <typename T0, typename T1>
inline bool operator()(T0 lhs, T1 rhs) const { return lhs != rhs; }
};
struct relaxed_greater_operator {
template <typename T0, typename T1>
inline bool operator()(T0 lhs, T1 rhs) const { return lhs > rhs; }
@@ -77,6 +82,10 @@ inline bool relaxed_equal(Value const &lhs, Value const &rhs) {
return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_equal_operator>(), lhs, rhs);
}
inline bool relaxed_not_equal(Value const &lhs, Value const &rhs) {
return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_not_equal_operator>(), lhs, rhs);
}
inline bool relaxed_greater(Value const &lhs, Value const &rhs) {
return apply_visitor(detail::relaxed_operator_visitor<detail::relaxed_greater_operator>(), lhs, rhs);
}

View File

@@ -203,12 +203,11 @@ void VectorTileTagExtractor::setTags(const pbf &pbf) {
tags_ = pbf;
}
std::forward_list<Value> VectorTileTagExtractor::getValues(const std::string &key) const {
std::forward_list<Value> values;
std::vector<Value> VectorTileTagExtractor::getValues(const std::string &key) const {
std::vector<Value> values;
auto field_it = layer_.key_index.find(key);
if (field_it != layer_.key_index.end()) {
auto it = values.before_begin();
const uint32_t filter_key = field_it->second;
// Now loop through all the key/value pair tags.
@@ -227,7 +226,7 @@ std::forward_list<Value> VectorTileTagExtractor::getValues(const std::string &ke
if (tag_key == filter_key) {
if (layer_.values.size() > tag_val) {
it = values.emplace_after(it, layer_.values[tag_val]);
values.emplace_back(layer_.values[tag_val]);
} else {
fprintf(stderr, "[WARNING] feature references out of range value\n");
break;

View File

@@ -3,13 +3,14 @@
#include <llmr/style/value_comparison.hpp>
#include <ostream>
namespace llmr {
template <typename Comparer>
inline bool FilterComparison::Instance::includes(const Value &property_value, const Comparer &comparer) const {
for (const Value &filter_value : values) {
if (comparer(property_value, filter_value)) {
inline bool includes(const Value &property_value, const std::vector<Value> &filter_values) {
for (const Value &filter_value : filter_values) {
if (util::relaxed_equal(property_value, filter_value)) {
return true;
}
}
@@ -17,8 +18,8 @@ inline bool FilterComparison::Instance::includes(const Value &property_value, co
}
template <typename Comparer>
inline bool FilterComparison::Instance::compare(const Value &property_value, const Comparer &comparer) const {
for (const Value &filter_value : values) {
inline bool compare(const Value &property_value, const std::vector<Value> &filter_values, const Comparer &comparer) {
for (const Value &filter_value : filter_values) {
if (!comparer(property_value, filter_value)) {
return false;
}
@@ -27,9 +28,9 @@ inline bool FilterComparison::Instance::compare(const Value &property_value, con
}
template <typename Comparer>
inline bool FilterComparison::Instance::all(const std::forward_list<Value> &property_values, const Comparer &comparer) const {
inline bool all(const std::vector<Value> &property_values, const std::vector<Value> &filter_values, const Comparer &comparer) {
for (const Value &property_value : property_values) {
if (!compare(property_value, comparer)) {
if (!compare(property_value, filter_values, comparer)) {
return false;
}
}
@@ -37,66 +38,54 @@ inline bool FilterComparison::Instance::all(const std::forward_list<Value> &prop
}
bool FilterComparison::Instance::compare(const Value &property_value) const {
switch (op) {
case Operator::Equal:
case Operator::In:
return includes(property_value, util::relaxed_equal);
case Operator::NotEqual:
case Operator::NotIn:
return !includes(property_value, util::relaxed_equal);
case Operator::Greater:
return compare(property_value, util::relaxed_greater);
case Operator::GreaterEqual:
return compare(property_value, util::relaxed_greater_equal);
case Operator::Less:
return compare(property_value, util::relaxed_less);
case Operator::LessEqual:
return compare(property_value, util::relaxed_less_equal);
default:
inline bool set_equal(const std::vector<Value> &property_values, const std::vector<Value> &filter_values) {
for (const Value &property_value : property_values) {
if (!includes(property_value, filter_values)) {
return false;
}
}
if (property_values.size() == filter_values.size()) {
// Optimization: When the count is the same, the set is guaranteed to be identical.
return true;
}
// Otherwise, check again for identical reverse-mapped values.
for (const Value &filter_value : filter_values) {
if (!includes(filter_value, property_values)) {
return false;
}
}
return true;
}
bool FilterComparison::Instance::compare(const std::forward_list<Value> &property_values) const {
bool FilterComparison::Instance::compare(const std::vector<Value> &property_values) const {
switch (op) {
case Operator::Equal:
for (const Value &property_value : property_values) {
if (includes(property_value, util::relaxed_equal)) {
return true;
}
}
return false;
return set_equal(property_values, values);
case Operator::NotEqual:
for (const Value &property_value : property_values) {
if (includes(property_value, util::relaxed_equal)) {
return false;
}
}
return true;
return !set_equal(property_values, values);
case Operator::In:
for (const Value &property_value : property_values) {
if (includes(property_value, util::relaxed_equal)) {
if (includes(property_value, values)) {
return true;
}
}
return false;
case Operator::NotIn:
for (const Value &property_value : property_values) {
if (!includes(property_value, util::relaxed_equal)) {
if (!includes(property_value, values)) {
return true;
}
}
return false;
case Operator::Greater:
return all(property_values, util::relaxed_greater);
return all(property_values, values, util::relaxed_greater);
case Operator::GreaterEqual:
return all(property_values, util::relaxed_greater_equal);
return all(property_values, values, util::relaxed_greater_equal);
case Operator::Less:
return all(property_values, util::relaxed_less);
return all(property_values, values, util::relaxed_less);
case Operator::LessEqual:
return all(property_values, util::relaxed_less_equal);
return all(property_values, values, util::relaxed_less_equal);
default:
return false;
}
@@ -176,11 +165,11 @@ bool FilterExpression::empty() const {
}
void FilterExpression::add(const FilterComparison &comparison) {
comparisons.emplace_front(comparison);
comparisons.emplace_back(comparison);
}
void FilterExpression::add(const FilterExpression &expression) {
expressions.emplace_front(expression);
expressions.emplace_back(expression);
}
void FilterExpression::setGeometryType(GeometryType g) {

View File

@@ -792,7 +792,7 @@ FilterExpression StyleParser::parseFilter(JSVal value, FilterExpression::Operato
} else if (filterValue.IsArray()) {
comparison.add(FilterComparison::Operator::In, parseValues(filterValue));
} else {
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value>({ parseValue(filterValue) }));
comparison.add(FilterComparison::Operator::Equal, std::vector<Value>({ parseValue(filterValue) }));
}
expression.add(comparison);
}
@@ -830,15 +830,14 @@ Value StyleParser::parseValue(JSVal value) {
}
}
std::forward_list<Value> StyleParser::parseValues(JSVal value) {
std::forward_list<Value> values;
std::vector<Value> StyleParser::parseValues(JSVal value) {
std::vector<Value> values;
if (value.IsArray()) {
auto it = values.before_begin();
for (rapidjson::SizeType i = 0; i < value.Size(); i++) {
it = values.emplace_after(it, parseValue(replaceConstant(value[i])));
values.emplace_back(parseValue(replaceConstant(value[i])));
}
} else {
values.emplace_front(parseValue(value));
values.emplace_back(parseValue(value));
}
return values;
}

View File

@@ -10,17 +10,16 @@
class MockExtractor {
public:
MockExtractor(const std::multimap<std::string, llmr::Value> &values) : values(values) {}
MockExtractor() {}
inline MockExtractor(const std::multimap<std::string, llmr::Value> &values) : values(values) {}
inline MockExtractor() {}
inline std::forward_list<llmr::Value> getValues(const std::string &key) const {
std::forward_list<llmr::Value> result;
auto rit = result.before_begin();
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.
rit = result.emplace_after(rit, it->second);
result.emplace_back(it->second);
}
return result;
}
@@ -30,15 +29,16 @@ private:
};
TEST(FilterComparison, SingleStringValue) {
TEST(FilterComparison, EqualsSingleStringValue) {
using namespace llmr;
FilterComparison comparison("test");
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value> { std::string("bar") });
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("booz") }})));
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()));
@@ -51,80 +51,256 @@ TEST(FilterComparison, SingleStringValue) {
}
TEST(FilterComparison, SingleDoubleValue) {
TEST(FilterComparison, EqualsSingleDoubleValue) {
using namespace llmr;
FilterComparison comparison("test");
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value> { double(32.8) });
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({{ "test", double(32.8) }, { "test", std::string("booz") }})));
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, SingleUintValue) {
TEST(FilterComparison, EqualsSingleUintValue) {
using namespace llmr;
FilterComparison comparison("test");
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value> { uint64_t(42) });
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({{ "test", uint64_t(42) }, { "test", std::string("booz") }})));
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, SingleIntValue) {
TEST(FilterComparison, EqualsSingleIntValue) {
using namespace llmr;
FilterComparison comparison("test");
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value> { int64_t(-42) });
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({{ "test", int64_t(-42) }, { "test", std::string("booz") }})));
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, SingleBoolValue) {
TEST(FilterComparison, EqualsSingleBoolValue) {
using namespace llmr;
FilterComparison comparison("test");
comparison.add(FilterComparison::Operator::Equal, std::forward_list<Value> { bool(true) });
// comparison is { "test": { "==": 32.8 } }
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({{ "test", bool(true) }, { "test", std::string("booz") }})));
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") }})));
}