Simplify test

fsaintjacques · Dec 26, 2019 · a0a2358 · a0a2358
1 parent 0fc1ae8
commit a0a2358
Show file tree

Hide file tree

Showing 3 changed files with 69 additions and 42 deletions.
diff --git a/tests/query/jit_test.cc b/tests/query/jit_test.cc
@@ -1,58 +1,82 @@
 #include "../query_test.h"
 
+#include <atomic>
+
 #include <jitmap/query/compiler.h>
 #include <jitmap/query/jit.h>
 #include <jitmap/query/parser.h>
 
 namespace jitmap {
 namespace query {
 
-class JitTest : public QueryTest {};
+class JitTest : public QueryTest {
+ public:
+ void AssertQueryResult(const std::string& query_expr,
+ std::vector<BitsetWordType> input_words,
+ BitsetWordType output_word) {
+ auto query_name = "query_" + std::to_string(id++);
+ auto query_fn = CompileAndLookup(query_expr, query_name);
+ ASSERT_NE(query_fn, nullptr);
 
-TEST_F(JitTest, CpuDetection) {
- auto engine = JitEngine();
+ // Populate input bitmaps each with a repeated word.
+ size_t n_bitmaps = input_words.size();
+ std::vector<std::vector<BitsetWordType>> bitmaps;
+ std::vector<const BitsetWordType*> inputs;
+ for (size_t i = 0; i < n_bitmaps; i++) {
+ auto repeated_word = input_words[i];
+ bitmaps.emplace_back(kWordsPerContainers, repeated_word);
+ inputs.emplace_back(bitmaps[i].data());
+ EXPECT_THAT(bitmaps[i], testing::Each(repeated_word));
+ }
 
- EXPECT_NE(engine.GetTargetCPU(), "");
- EXPECT_NE(engine.GetTargetFeatureString(), "");
- EXPECT_NE(engine.GetTargetTriple(), "");
-}
+ // Populate output bitmap
+ std::vector<BitsetWordType> output(kWordsPerContainers, 0UL);
+ EXPECT_THAT(output, testing::Each(0UL));
+
+ query_fn(inputs.data(), output.data());
+ EXPECT_THAT(output, testing::Each(output_word));
+ }
 
-void AssertQueryResult(const std::string& query_str,
- std::vector<BitsetWordType> input_words,
- BitsetWordType output_word) {
- auto engine = JitEngine();
- auto query = Query::Make("test_query", Parse(query_str, &_g_builder_));
- auto compiler = QueryIRCodeGen("jitest");
- compiler.Compile(query);
- engine.Compile(std::move(compiler));
-
- auto query_fn = engine.LookupUserQuery("test_query");
- ASSERT_NE(query_fn, nullptr);
-
- // Populate input bitmaps each with a repeated word.
- size_t n_bitmaps = input_words.size();
- std::vector<std::vector<BitsetWordType>> bitmaps;
- std::vector<const BitsetWordType*> inputs;
- for (size_t i = 0; i < n_bitmaps; i++) {
- auto repeated_word = input_words[i];
- bitmaps.emplace_back(kWordsPerContainers, repeated_word);
- inputs.emplace_back(bitmaps[i].data());
- EXPECT_THAT(bitmaps[i], testing::Each(repeated_word));
+ DenseEvalFn CompileAndLookup(std::string_view query_expr,
+ const std::string& query_name) {
+ auto query = Query::Make(query_name, Parse(query_expr));
+ auto compiler = QueryIRCodeGen("module_" + std::to_string(id++));
+ compiler.Compile(query);
+ engine_.Compile(std::move(compiler));
+ return engine_.LookupUserQuery(query_name);
  }
 
- // Populate output bitmap
- std::vector<BitsetWordType> output(kWordsPerContainers, 0UL);
- EXPECT_THAT(output, testing::Each(0UL));
+ protected:
+ std::atomic<uint32_t> id = 0;
+ JitEngine engine_;
+};
 
- query_fn(inputs.data(), output.data());
- EXPECT_THAT(output, testing::Each(output_word));
+TEST_F(JitTest, CpuDetection) {
+ EXPECT_NE(engine_.GetTargetCPU(), "");
+ EXPECT_NE(engine_.GetTargetFeatureString(), "");
+ EXPECT_NE(engine_.GetTargetTriple(), "");
 }
 
 TEST_F(JitTest, CompileAndExecuteTest) {
- AssertQueryResult("!a", {0x00FFFF00}, 0xFF0000FF);
- AssertQueryResult("a & b", {0x00FFFF00, 0xFF0000FF}, 0x00000000);
- AssertQueryResult("a | b", {0x00FFFF00, 0xFF0000FF}, 0xFFFFFFFF);
- AssertQueryResult("a ^ b", {0x00FFFF00, 0xFF0000FF}, 0xFFFFFFFF);
+ BitsetWordType full = 0xFFFFFFFF;
+ BitsetWordType empty = 0x0;
+
+ BitsetWordType a = 0b00010010110101011001001011010101;
+ BitsetWordType b = 0b11001000110101011101010101011011;
+ BitsetWordType c = 0b00000001110101111110101001111000;
+ BitsetWordType d = 0b11111111111110101111111100000011;
+ BitsetWordType e = 0b11111110100100001110000011010110;
+
+ AssertQueryResult("!a", {a}, ~a);
+ AssertQueryResult("a & b", {a, b}, a & b);
+ AssertQueryResult("a | b", {a, b}, a | b);
+ AssertQueryResult("a ^ b", {a, b}, a ^ b);
+
+ AssertQueryResult("full ^ b", {full, b}, full ^ b);
+ AssertQueryResult("empty | !empty", {empty, empty}, full);
+
+ AssertQueryResult("a & b & c & d & e", {a, b, c, d, e}, a & b & c & d & e);
+ AssertQueryResult("a | b | c | d | e", {a, b, c, d, e}, a | b | c | d | e);
 }
 
 } // namespace query

diff --git a/tests/query/parser_test.cc b/tests/query/parser_test.cc
@@ -47,12 +47,10 @@ class LexerTest : public QueryTest {
 class ParserTest : public QueryTest {
  protected:
  void ExpectParse(std::string_view query, Expr* expected) {
- ExprEq(Parse(query, &expr_builder_), expected);
+ ExprEq(Parse(query), expected);
  }
 
- void ExpectThrow(std::string_view query) {
- EXPECT_ANY_THROW(Parse(query, &expr_builder_));
- }
+ void ExpectThrow(std::string_view query) { EXPECT_ANY_THROW(Parse(query)); }
 };
 
 TEST_F(LexerTest, Basic) {

diff --git a/tests/query_test.h b/tests/query_test.h
@@ -1,13 +1,14 @@
 #pragma once
 
 #include <string>
+#include <string_view>
 
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include <jitmap/query/expr.h>
-#include <jitmap/query/query.h>
 #include <jitmap/query/parser.h>
+#include <jitmap/query/query.h>
 
 namespace jitmap {
 namespace query {
@@ -38,6 +39,10 @@ class QueryTest : public testing::Test {
  Expr* Or(Expr* lhs, Expr* rhs) { return expr_builder_.Or(lhs, rhs); }
  Expr* Xor(Expr* lhs, Expr* rhs) { return expr_builder_.Xor(lhs, rhs); }
 
+ Expr* Parse(std::string_view query) {
+ return jitmap::query::Parse(query, &expr_builder_);
+ }
+
  protected:
  ExprBuilder expr_builder_;
 };