add more comparison tests
This commit is contained in:
@@ -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;
|
||||
|
||||
|
||||
@@ -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 &);
|
||||
};
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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);
|
||||
}
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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") }})));
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user