From 0a76b55a5ea0817d6f8d9c73857b0eb0f9193651 Mon Sep 17 00:00:00 2001 From: Jeremi Kurdek Date: Sun, 25 Aug 2024 17:08:21 +0200 Subject: [PATCH 1/3] Add raw filters --- .clang-tidy | 7 ++++-- include/sparser.h | 35 +++++++++++++++++++++++++++ src/sparser/sparser.cpp | 48 +++++++++++++++++++++++++++++++++++++ tests/sparser_test.cpp | 52 +++++++++++++++++++++++++++++++++++++++++ 4 files changed, 140 insertions(+), 2 deletions(-) diff --git a/.clang-tidy b/.clang-tidy index 104a75b..ffd1188 100644 --- a/.clang-tidy +++ b/.clang-tidy @@ -19,7 +19,10 @@ HeaderFilterRegex: '' FormatStyle: none CheckOptions: - - key: readability-identifier-length.IgnoredVariableNames + +- key: readability-identifier-length.IgnoredVariableNames value: 'x|y|z' - - key: readability-identifier-length.IgnoredParameterNames +- key: readability-identifier-length.IgnoredParameterNames value: 'x|y|z' +- key: bugprone-easily-swappable-parameters.MinimumLength + value: '3' diff --git a/include/sparser.h b/include/sparser.h index 439c809..311cfb8 100644 --- a/include/sparser.h +++ b/include/sparser.h @@ -1,8 +1,14 @@ #pragma once +#include +#include +#include #include +#include #include +constexpr size_t RFSZ = 4; + struct Predicate { std::string value; }; @@ -19,4 +25,33 @@ struct SparserQuery { PredicateDisjunction disjunction; [[nodiscard]] std::string generateOutput() const; + friend std::ostream& operator<<(std::ostream& os, const SparserQuery& query); +}; + +struct RawFilter { + RawFilter(const std::string_view& value, size_t conjunctiveIndex, size_t predicateIndex) + : value(value), conjunctiveIndex(conjunctiveIndex), predicateIndex(predicateIndex) {} + + std::string_view value; + size_t conjunctiveIndex; + size_t predicateIndex; + + bool operator==(const RawFilter& other) const; + + [[nodiscard]] std::string generateOutput() const; + friend std::ostream& operator<<(std::ostream& os, const RawFilter& filter); +}; + +struct RawFilterQuery { + std::unique_ptr query; + std::vector rawFilters; +}; + +class RawFilterQueryGenerator { + public: + static RawFilterQuery generateRawFilterQuery(std::unique_ptr query); + + static std::vector generateRawFilters(const SparserQuery& query); + + static std::vector generateRawFilters(const std::string_view& input); }; diff --git a/src/sparser/sparser.cpp b/src/sparser/sparser.cpp index 3aea67c..d001e62 100644 --- a/src/sparser/sparser.cpp +++ b/src/sparser/sparser.cpp @@ -25,3 +25,51 @@ std::string SparserQuery::generateOutput() const { oss << "\n"; return oss.str(); } + +std::ostream& operator<<(std::ostream& os, const SparserQuery& query) { + os << query.generateOutput(); + return os; +} + +bool RawFilter::operator==(const RawFilter& other) const { + return value == other.value && conjunctiveIndex == other.conjunctiveIndex && predicateIndex == other.predicateIndex; +} + +std::string RawFilter::generateOutput() const { + std::ostringstream oss; + oss << "RawFilter(value: " << value << ", conjunctiveIndex: " << conjunctiveIndex + << ", predicateIndex: " << predicateIndex << ")"; + return oss.str(); +} + +std::ostream& operator<<(std::ostream& os, const RawFilter& filter) { + os << filter.generateOutput(); + return os; +} + +RawFilterQuery RawFilterQueryGenerator::generateRawFilterQuery(std::unique_ptr query) { + return RawFilterQuery{std::move(query), generateRawFilters(*query)}; +} + +std::vector RawFilterQueryGenerator::generateRawFilters(const SparserQuery& query) { + std::vector rawFilters; + for (size_t conjunctiveIndex = 0; conjunctiveIndex < query.disjunction.conjunctions.size(); ++conjunctiveIndex) { + for (size_t predicateIndex = 0; + predicateIndex < query.disjunction.conjunctions[conjunctiveIndex].predicates.size(); ++predicateIndex) { + const auto& predicate = query.disjunction.conjunctions[conjunctiveIndex].predicates[predicateIndex]; + const auto filters = generateRawFilters(predicate.value); + for (const auto& filter : filters) { + rawFilters.emplace_back(filter, conjunctiveIndex, predicateIndex); + } + } + } + return rawFilters; +} + +std::vector RawFilterQueryGenerator::generateRawFilters(const std::string_view& input) { + std::vector rawFilters; + for (size_t i = 0; i < input.size() - RFSZ + 1; ++i) { + rawFilters.emplace_back(input.substr(i, RFSZ)); + } + return rawFilters; +} diff --git a/tests/sparser_test.cpp b/tests/sparser_test.cpp index 62cc5ef..fcfdbb4 100644 --- a/tests/sparser_test.cpp +++ b/tests/sparser_test.cpp @@ -3,6 +3,12 @@ #include #include +#include +#include + +RawFilter createRawFilter(const std::string_view& value, size_t conjunctiveIndex, size_t predicateIndex) { + return RawFilter{value, conjunctiveIndex, predicateIndex}; +} TEST(SparserQueryTest, GenerateOutput) { const Predicate pred1 = {"p1"}; @@ -21,3 +27,49 @@ TEST(SparserQueryTest, GenerateOutput) { ASSERT_EQ(expected, actual); } + +TEST(SparserQueryTest, GenerateRawFiltersForQueryTest) { + const Predicate pred1 = {"Lord of the Rings"}; + const Predicate pred2 = {"Harry Potter"}; + const Predicate pred3 = {"The Hobbit"}; + + const PredicateConjunction conj1 = {{pred1, pred2}}; + const PredicateConjunction conj2 = {{pred3}}; + const PredicateDisjunction disj = {{conj1, conj2}}; + const SparserQuery query = {disj}; + + const std::vector expected = { + createRawFilter("Lord", 0, 0), createRawFilter("ord ", 0, 0), createRawFilter("rd o", 0, 0), + createRawFilter("d of", 0, 0), createRawFilter(" of ", 0, 0), createRawFilter("of t", 0, 0), + createRawFilter("f th", 0, 0), createRawFilter(" the", 0, 0), createRawFilter("the ", 0, 0), + createRawFilter("he R", 0, 0), createRawFilter("e Ri", 0, 0), createRawFilter(" Rin", 0, 0), + createRawFilter("Ring", 0, 0), createRawFilter("ings", 0, 0), createRawFilter("Harr", 0, 1), + createRawFilter("arry", 0, 1), createRawFilter("rry ", 0, 1), createRawFilter("ry P", 0, 1), + createRawFilter("y Po", 0, 1), createRawFilter(" Pot", 0, 1), createRawFilter("Pott", 0, 1), + createRawFilter("otte", 0, 1), createRawFilter("tter", 0, 1), createRawFilter("The ", 1, 0), + createRawFilter("he H", 1, 0), createRawFilter("e Ho", 1, 0), createRawFilter(" Hob", 1, 0), + createRawFilter("Hobb", 1, 0), createRawFilter("obbi", 1, 0), createRawFilter("bbit", 1, 0), + }; + + const auto actual = RawFilterQueryGenerator::generateRawFilters(query); + + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < expected.size(); ++i) { + ASSERT_EQ(expected[i], actual[i]); + } +} + +TEST(SparserQueryTest, GenerateRawFiltersForSinglePredicate) { + const Predicate pred1 = {"Harry Potter"}; + + const std::vector expected = { + "Harr", "arry", "rry ", "ry P", "y Po", " Pot", "Pott", "otte", "tter", + }; + + const auto actual = RawFilterQueryGenerator::generateRawFilters(pred1.value); + + ASSERT_EQ(expected.size(), actual.size()); + for (size_t i = 0; i < expected.size(); ++i) { + ASSERT_EQ(expected[i], actual[i]); + } +} From cad9cad5bac9e47dc5f316a8f54b35d9311aab8a Mon Sep 17 00:00:00 2001 From: Jeremi Kurdek Date: Sun, 25 Aug 2024 17:43:21 +0200 Subject: [PATCH 2/3] Simplify initialization in tests --- tests/sparser_test.cpp | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/tests/sparser_test.cpp b/tests/sparser_test.cpp index fcfdbb4..5b916eb 100644 --- a/tests/sparser_test.cpp +++ b/tests/sparser_test.cpp @@ -11,34 +11,34 @@ RawFilter createRawFilter(const std::string_view& value, size_t conjunctiveIndex } TEST(SparserQueryTest, GenerateOutput) { - const Predicate pred1 = {"p1"}; - const Predicate pred2 = {"p2"}; - const Predicate pred3 = {"p3"}; - const Predicate pred4 = {"p4"}; + const Predicate pred1{"p1"}; + const Predicate pred2{"p2"}; + const Predicate pred3{"p3"}; + const Predicate pred4{"p4"}; - const PredicateConjunction conj1 = {{pred1, pred2}}; - const PredicateConjunction conj2 = {{pred3, pred4}}; + const PredicateConjunction conj1{{pred1, pred2}}; + const PredicateConjunction conj2{{pred3, pred4}}; - const PredicateDisjunction disj = {{conj1, conj2}}; - const SparserQuery query = {disj}; + const PredicateDisjunction disj{{conj1, conj2}}; + const SparserQuery query{disj}; - const std::string expected = "(p1 ∧ p2) ∨ (p3 ∧ p4)\n"; + const std::string expected{"(p1 ∧ p2) ∨ (p3 ∧ p4)\n"}; auto actual = query.generateOutput(); ASSERT_EQ(expected, actual); } TEST(SparserQueryTest, GenerateRawFiltersForQueryTest) { - const Predicate pred1 = {"Lord of the Rings"}; - const Predicate pred2 = {"Harry Potter"}; - const Predicate pred3 = {"The Hobbit"}; + const Predicate pred1{"Lord of the Rings"}; + const Predicate pred2{"Harry Potter"}; + const Predicate pred3{"The Hobbit"}; - const PredicateConjunction conj1 = {{pred1, pred2}}; - const PredicateConjunction conj2 = {{pred3}}; - const PredicateDisjunction disj = {{conj1, conj2}}; - const SparserQuery query = {disj}; + const PredicateConjunction conj1{{pred1, pred2}}; + const PredicateConjunction conj2{{pred3}}; + const PredicateDisjunction disj{{conj1, conj2}}; + const SparserQuery query{disj}; - const std::vector expected = { + const std::vector expected{ createRawFilter("Lord", 0, 0), createRawFilter("ord ", 0, 0), createRawFilter("rd o", 0, 0), createRawFilter("d of", 0, 0), createRawFilter(" of ", 0, 0), createRawFilter("of t", 0, 0), createRawFilter("f th", 0, 0), createRawFilter(" the", 0, 0), createRawFilter("the ", 0, 0), @@ -60,9 +60,9 @@ TEST(SparserQueryTest, GenerateRawFiltersForQueryTest) { } TEST(SparserQueryTest, GenerateRawFiltersForSinglePredicate) { - const Predicate pred1 = {"Harry Potter"}; + const Predicate pred1{"Harry Potter"}; - const std::vector expected = { + const std::vector expected{ "Harr", "arry", "rry ", "ry P", "y Po", " Pot", "Pott", "otte", "tter", }; From 400fad1bdd5af86f3b3a382ae1464d6ff4f531b8 Mon Sep 17 00:00:00 2001 From: Jeremi Kurdek Date: Mon, 26 Aug 2024 15:38:46 +0200 Subject: [PATCH 3/3] Change to data driven design and fix naming --- include/sparser.h | 57 ++++++++++++++++++------------ src/sparser/sparser.cpp | 50 +++++++++++++------------- tests/sparser_test.cpp | 78 ++++++++++++++++++++++------------------- 3 files changed, 101 insertions(+), 84 deletions(-) diff --git a/include/sparser.h b/include/sparser.h index 311cfb8..f6e4396 100644 --- a/include/sparser.h +++ b/include/sparser.h @@ -1,4 +1,5 @@ -#pragma once +#ifndef SPARSER_H_ +#define SPARSER_H_ #include #include @@ -7,7 +8,7 @@ #include #include -constexpr size_t RFSZ = 4; +constexpr size_t kRfSize = 4; struct Predicate { std::string value; @@ -21,37 +22,49 @@ struct PredicateDisjunction { std::vector conjunctions; }; -struct SparserQuery { - PredicateDisjunction disjunction; +class SparserQuery { + private: + PredicateDisjunction disjunction_; - [[nodiscard]] std::string generateOutput() const; + public: + explicit SparserQuery(const PredicateDisjunction& disjunction) : disjunction_(disjunction) {} + + [[nodiscard]] const PredicateDisjunction& get_disjunction() const { return disjunction_; } + + [[nodiscard]] std::string ToString() const; friend std::ostream& operator<<(std::ostream& os, const SparserQuery& query); }; -struct RawFilter { - RawFilter(const std::string_view& value, size_t conjunctiveIndex, size_t predicateIndex) - : value(value), conjunctiveIndex(conjunctiveIndex), predicateIndex(predicateIndex) {} +struct RawFilterData { + std::vector raw_filters; + std::vector conjunctive_indices; + std::vector predicate_indices; +}; + +class RawFilter { + private: + std::string_view value_; + size_t conjunctive_index_; + size_t predicate_index_; + + public: + explicit RawFilter(const std::string_view& value, size_t conjunctive_index, size_t predicate_index) + : value_(value), conjunctive_index_(conjunctive_index), predicate_index_(predicate_index) {} - std::string_view value; - size_t conjunctiveIndex; - size_t predicateIndex; + [[nodiscard]] std::string_view get_value() const { return value_; } + [[nodiscard]] size_t get_conjunctive_index() const { return conjunctive_index_; } + [[nodiscard]] size_t get_predicate_index() const { return predicate_index_; } bool operator==(const RawFilter& other) const; - [[nodiscard]] std::string generateOutput() const; + [[nodiscard]] std::string ToString() const; friend std::ostream& operator<<(std::ostream& os, const RawFilter& filter); }; -struct RawFilterQuery { - std::unique_ptr query; - std::vector rawFilters; -}; - class RawFilterQueryGenerator { public: - static RawFilterQuery generateRawFilterQuery(std::unique_ptr query); - - static std::vector generateRawFilters(const SparserQuery& query); - - static std::vector generateRawFilters(const std::string_view& input); + static RawFilterData GenerateRawFilters(const PredicateDisjunction& disjunction); + static std::vector GenerateRawFiltersFromPredicate(const std::string_view& input); }; + +#endif // SPARSER_H_ diff --git a/src/sparser/sparser.cpp b/src/sparser/sparser.cpp index d001e62..0bf7357 100644 --- a/src/sparser/sparser.cpp +++ b/src/sparser/sparser.cpp @@ -3,9 +3,9 @@ #include #include -std::string SparserQuery::generateOutput() const { +std::string SparserQuery::ToString() const { std::ostringstream oss; - for (const auto& conjunction : disjunction.conjunctions) { + for (const auto& conjunction : disjunction_.conjunctions) { if (!conjunction.predicates.empty()) { oss << "("; } @@ -18,7 +18,7 @@ std::string SparserQuery::generateOutput() const { if (!conjunction.predicates.empty()) { oss << ")"; } - if (&conjunction != &disjunction.conjunctions.back()) { + if (&conjunction != &disjunction_.conjunctions.back()) { oss << " ∨ "; } } @@ -27,49 +27,49 @@ std::string SparserQuery::generateOutput() const { } std::ostream& operator<<(std::ostream& os, const SparserQuery& query) { - os << query.generateOutput(); + os << query.ToString(); return os; } bool RawFilter::operator==(const RawFilter& other) const { - return value == other.value && conjunctiveIndex == other.conjunctiveIndex && predicateIndex == other.predicateIndex; + return value_ == other.value_ && conjunctive_index_ == other.conjunctive_index_ && + predicate_index_ == other.predicate_index_; } -std::string RawFilter::generateOutput() const { +std::string RawFilter::ToString() const { std::ostringstream oss; - oss << "RawFilter(value: " << value << ", conjunctiveIndex: " << conjunctiveIndex - << ", predicateIndex: " << predicateIndex << ")"; + oss << "RawFilter(value: " << value_ << ", conjunctiveIndex: " << conjunctive_index_ + << ", predicateIndex: " << predicate_index_ << ")"; return oss.str(); } std::ostream& operator<<(std::ostream& os, const RawFilter& filter) { - os << filter.generateOutput(); + os << filter.ToString(); return os; } -RawFilterQuery RawFilterQueryGenerator::generateRawFilterQuery(std::unique_ptr query) { - return RawFilterQuery{std::move(query), generateRawFilters(*query)}; -} - -std::vector RawFilterQueryGenerator::generateRawFilters(const SparserQuery& query) { - std::vector rawFilters; - for (size_t conjunctiveIndex = 0; conjunctiveIndex < query.disjunction.conjunctions.size(); ++conjunctiveIndex) { - for (size_t predicateIndex = 0; - predicateIndex < query.disjunction.conjunctions[conjunctiveIndex].predicates.size(); ++predicateIndex) { - const auto& predicate = query.disjunction.conjunctions[conjunctiveIndex].predicates[predicateIndex]; - const auto filters = generateRawFilters(predicate.value); +RawFilterData RawFilterQueryGenerator::GenerateRawFilters(const PredicateDisjunction& disjunction) { + RawFilterData raw_filter_data; + for (size_t conjunctive_index = 0; conjunctive_index < disjunction.conjunctions.size(); ++conjunctive_index) { + const auto& conjunction = disjunction.conjunctions[conjunctive_index]; + for (size_t predicate_index = 0; predicate_index < conjunction.predicates.size(); ++predicate_index) { + const auto& predicate = conjunction.predicates[predicate_index]; + const auto filters = GenerateRawFiltersFromPredicate(predicate.value); for (const auto& filter : filters) { - rawFilters.emplace_back(filter, conjunctiveIndex, predicateIndex); + raw_filter_data.raw_filters.push_back(filter); + raw_filter_data.conjunctive_indices.push_back(conjunctive_index); + raw_filter_data.predicate_indices.push_back(predicate_index); } } } - return rawFilters; + return raw_filter_data; } -std::vector RawFilterQueryGenerator::generateRawFilters(const std::string_view& input) { +std::vector RawFilterQueryGenerator::GenerateRawFiltersFromPredicate( + const std::string_view& predicate) { std::vector rawFilters; - for (size_t i = 0; i < input.size() - RFSZ + 1; ++i) { - rawFilters.emplace_back(input.substr(i, RFSZ)); + for (size_t i = 0; i < predicate.size() - kRfSize + 1; ++i) { + rawFilters.emplace_back(predicate.substr(i, kRfSize)); } return rawFilters; } diff --git a/tests/sparser_test.cpp b/tests/sparser_test.cpp index 5b916eb..d934ba0 100644 --- a/tests/sparser_test.cpp +++ b/tests/sparser_test.cpp @@ -6,67 +6,71 @@ #include #include -RawFilter createRawFilter(const std::string_view& value, size_t conjunctiveIndex, size_t predicateIndex) { - return RawFilter{value, conjunctiveIndex, predicateIndex}; -} - -TEST(SparserQueryTest, GenerateOutput) { - const Predicate pred1{"p1"}; - const Predicate pred2{"p2"}; - const Predicate pred3{"p3"}; - const Predicate pred4{"p4"}; +TEST(SparserQueryTest, ToString) { + const Predicate pred_1{"p1"}; + const Predicate pred_2{"p2"}; + const Predicate pred_3{"p3"}; + const Predicate pred_4{"p4"}; - const PredicateConjunction conj1{{pred1, pred2}}; - const PredicateConjunction conj2{{pred3, pred4}}; + const PredicateConjunction conj_1{{pred_1, pred_2}}; + const PredicateConjunction conj_2{{pred_3, pred_4}}; - const PredicateDisjunction disj{{conj1, conj2}}; + const PredicateDisjunction disj{{conj_1, conj_2}}; const SparserQuery query{disj}; const std::string expected{"(p1 ∧ p2) ∨ (p3 ∧ p4)\n"}; - auto actual = query.generateOutput(); + auto actual = query.ToString(); ASSERT_EQ(expected, actual); } TEST(SparserQueryTest, GenerateRawFiltersForQueryTest) { - const Predicate pred1{"Lord of the Rings"}; - const Predicate pred2{"Harry Potter"}; - const Predicate pred3{"The Hobbit"}; + const Predicate pred_1{"Lord of the Rings"}; + const Predicate pred_2{"Harry Potter"}; + const Predicate pred_3{"The Hobbit"}; - const PredicateConjunction conj1{{pred1, pred2}}; - const PredicateConjunction conj2{{pred3}}; - const PredicateDisjunction disj{{conj1, conj2}}; + const PredicateConjunction conj_1{{pred_1, pred_2}}; + const PredicateConjunction conj_2{{pred_3}}; + const PredicateDisjunction disj{{conj_1, conj_2}}; const SparserQuery query{disj}; - const std::vector expected{ - createRawFilter("Lord", 0, 0), createRawFilter("ord ", 0, 0), createRawFilter("rd o", 0, 0), - createRawFilter("d of", 0, 0), createRawFilter(" of ", 0, 0), createRawFilter("of t", 0, 0), - createRawFilter("f th", 0, 0), createRawFilter(" the", 0, 0), createRawFilter("the ", 0, 0), - createRawFilter("he R", 0, 0), createRawFilter("e Ri", 0, 0), createRawFilter(" Rin", 0, 0), - createRawFilter("Ring", 0, 0), createRawFilter("ings", 0, 0), createRawFilter("Harr", 0, 1), - createRawFilter("arry", 0, 1), createRawFilter("rry ", 0, 1), createRawFilter("ry P", 0, 1), - createRawFilter("y Po", 0, 1), createRawFilter(" Pot", 0, 1), createRawFilter("Pott", 0, 1), - createRawFilter("otte", 0, 1), createRawFilter("tter", 0, 1), createRawFilter("The ", 1, 0), - createRawFilter("he H", 1, 0), createRawFilter("e Ho", 1, 0), createRawFilter(" Hob", 1, 0), - createRawFilter("Hobb", 1, 0), createRawFilter("obbi", 1, 0), createRawFilter("bbit", 1, 0), - }; + const std::vector expected_filters{"Lord", "ord ", "rd o", "d of", " of ", "of t", "f th", " the", + "the ", "he R", "e Ri", " Rin", "Ring", "ings", "Harr", "arry", + "rry ", "ry P", "y Po", " Pot", "Pott", "otte", "tter", "The ", + "he H", "e Ho", " Hob", "Hobb", "obbi", "bbit"}; - const auto actual = RawFilterQueryGenerator::generateRawFilters(query); + const std::vector expected_conjunctive_indices{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1}; - ASSERT_EQ(expected.size(), actual.size()); - for (size_t i = 0; i < expected.size(); ++i) { - ASSERT_EQ(expected[i], actual[i]); + const std::vector expected_predicate_indices{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, + 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0}; + + const auto actual = RawFilterQueryGenerator::GenerateRawFilters(query.get_disjunction()); + + ASSERT_EQ(expected_filters.size(), actual.raw_filters.size()); + for (size_t i = 0; i < expected_filters.size(); ++i) { + ASSERT_EQ(expected_filters[i], actual.raw_filters[i]); + } + + ASSERT_EQ(expected_conjunctive_indices.size(), actual.conjunctive_indices.size()); + for (size_t i = 0; i < expected_conjunctive_indices.size(); ++i) { + ASSERT_EQ(expected_conjunctive_indices[i], actual.conjunctive_indices[i]); + } + + ASSERT_EQ(expected_predicate_indices.size(), actual.predicate_indices.size()); + for (size_t i = 0; i < expected_predicate_indices.size(); ++i) { + ASSERT_EQ(expected_predicate_indices[i], actual.predicate_indices[i]); } } TEST(SparserQueryTest, GenerateRawFiltersForSinglePredicate) { - const Predicate pred1{"Harry Potter"}; + const Predicate pred_1{"Harry Potter"}; const std::vector expected{ "Harr", "arry", "rry ", "ry P", "y Po", " Pot", "Pott", "otte", "tter", }; - const auto actual = RawFilterQueryGenerator::generateRawFilters(pred1.value); + const auto actual = RawFilterQueryGenerator::GenerateRawFiltersFromPredicate(pred_1.value); ASSERT_EQ(expected.size(), actual.size()); for (size_t i = 0; i < expected.size(); ++i) {