Changes after review

src/common/string_utils.cpp

@@ -19,7 +19,7 @@ std::vector<std::string> StringUtils::split(
     return result;
 }
 
-std::vector<std::string> StringUtils::splitByAnySpace(const std::string& input) {
+std::vector<std::string> StringUtils::splitBySpace(const std::string& input) {
     std::istringstream iss(input);
     std::vector<std::string> result;
     std::string token;

src/include/common/string_utils.h

@@ -21,7 +21,7 @@ class StringUtils {
 
     static std::vector<std::string> split(const std::string& input, const std::string& delimiter);
 
-    static std::vector<std::string> splitByAnySpace(const std::string& input);
+    static std::vector<std::string> splitBySpace(const std::string& input);
 
     static void toUpper(std::string& input) {
         std::transform(input.begin(), input.end(), input.begin(), ::toupper);

test/common/string_test.cpp

@@ -5,9 +5,9 @@
 
 using namespace kuzu::common;
 
-TEST(StringTest, splitByAnySpace) {
+TEST(StringTest, splitBySpace) {
     std::string str = " a b  c\td ";
-    std::vector<std::string> result = StringUtils::splitByAnySpace(str);
+    std::vector<std::string> result = StringUtils::splitBySpace(str);
     EXPECT_EQ(result.size(), 4);
     EXPECT_EQ(result[0], "a");
     EXPECT_EQ(result[1], "b");

test/include/test_runner/test_case.h

@@ -10,7 +10,6 @@ namespace testing {
 struct TestStatement {
     std::string name;
     std::string query;
-    std::string blockName;
     uint64_t numThreads = 4;
     std::string encodedJoin;
     uint64_t expectedNumTuples = 0;
@@ -27,7 +26,7 @@ struct TestCase {
     std::string name;
     std::string dataset;
     std::vector<std::unique_ptr<TestStatement>> statements;
-    std::vector<std::unique_ptr<TestStatement>> variableStatements;
+    std::unordered_map<std::string, std::vector<std::unique_ptr<TestStatement>>> variableStatements;
 
     bool skipTest = false;
 

test/include/test_runner/test_parser.h

@@ -1,11 +1,8 @@
 #include <cstring>
 
 #include "common/file_utils.h"
-#include "main/kuzu.h"
 #include "test_runner/test_case.h"
 
-using namespace kuzu::main;
-
 namespace kuzu {
 namespace testing {
 
@@ -75,6 +72,8 @@ class TestParser {
 
     void extractStatementBlock();
 
+    void addStatementBlock(const std::string& blockName);
+
     inline bool endOfFile() { return fileStream.eof(); }
 
     inline bool nextLine() { return static_cast<bool>(getline(fileStream, line)); }
@@ -87,7 +86,7 @@ class TestParser {
 
     TestStatement* extractStatement(TestStatement* currentStatement);
 
-    TestStatement* addNewStatement(std::vector<std::unique_ptr<TestStatement>>& statements);
+    TestStatement* addNewStatement();
 };
 
 } // namespace testing

test/include/test_runner/test_runner.h

@@ -1,13 +1,10 @@
 #include "common/file_utils.h"
 #include "gtest/gtest.h"
-#include "main/kuzu.h"
 #include "parser/parser.h"
 #include "planner/logical_plan/logical_plan_util.h"
 #include "planner/planner.h"
 #include "test_runner/test_case.h"
 
-using namespace kuzu::main;
-using namespace kuzu::common;
 using namespace kuzu::planner;
 
 namespace kuzu {

test/test_files/tinysnb/agg/hash.test

@@ -1,5 +1,5 @@
 -GROUP TinySnbReadTest
--TEST Agg
+-TEST AggHash
 -DATASET tinysnb
 
 --

test/test_files/tinysnb/agg/multi_label.test

@@ -1,5 +1,5 @@
 -GROUP TinySnbReadTest
--TEST Agg
+-TEST AggMultiLabel
 -DATASET tinysnb
 
 --

test/test_runner/test_parser.cpp

@@ -51,7 +51,6 @@ void TestParser::parseHeader() {
         }
         case TokenType::SEPARATOR: {
             return;
-            break;
         }
         default: {
             throw Exception("Invalid statement in test header");
@@ -96,7 +95,6 @@ TestStatement* TestParser::extractStatement(TestStatement* statement) {
     case TokenType::RESULT: {
         extractExpectedResult(statement);
         return statement;
-        break;
     }
     case TokenType::CHECK_ORDER: {
         statement->checkOutputOrder = true;
@@ -133,9 +131,9 @@ void TestParser::extractStatementBlock() {
         if (currentToken.type == TokenType::END_OF_STATEMENT_BLOCK) {
             break;
         } else {
-            TestStatement* statement = addNewStatement(testCase->variableStatements);
-            statement->blockName = blockName;
-            extractStatement(statement);
+            auto statement = std::make_unique<TestStatement>();
+            extractStatement(statement.get());
+            testCase->variableStatements[blockName].push_back(std::move(statement));
         }
     }
 }
@@ -157,33 +155,36 @@ void TestParser::parseBody() {
         }
         case TokenType::STATEMENT_BLOCK: {
             checkMinimumParams(1);
-            for (auto& statement : testCase->variableStatements) {
-                if (statement->blockName == currentToken.params[1]) {
-                    statement->name = name;
-                    testCase->statements.push_back(std::make_unique<TestStatement>(*statement));
-                }
-            }
+            addStatementBlock(currentToken.params[1]);
             break;
         }
         case TokenType::EMPTY: {
             break;
         }
         default: {
-            // if its not special case, then it has to be a statement
-            TestStatement* statement = addNewStatement(testCase->statements);
+            // if its not a special case, then it has to be a statement
+            TestStatement* statement = addNewStatement();
             statement->name = name;
             extractStatement(statement);
         }
         }
     }
 }
 
-TestStatement* TestParser::addNewStatement(
-    std::vector<std::unique_ptr<TestStatement>>& statementsVector) {
-    TestStatement* currentStatement;
+void TestParser::addStatementBlock(const std::string& blockName) {
+    if (testCase->variableStatements.find(blockName) != testCase->variableStatements.end()) {
+        for (const auto& statementPtr : testCase->variableStatements[blockName]) {
+            testCase->statements.push_back(std::make_unique<TestStatement>(*statementPtr));
+        }
+    } else {
+        throw Exception("Statement block not found [" + blockName + "]");
+    }
+}
+
+TestStatement* TestParser::addNewStatement() {
     auto statement = std::make_unique<TestStatement>();
-    currentStatement = statement.get();
-    statementsVector.push_back(std::move(statement));
+    TestStatement* currentStatement = statement.get();
+    testCase->statements.push_back(std::move(statement));
     return currentStatement;
 }
 
@@ -209,7 +210,7 @@ void TestParser::openFile(const std::string& path) {
 }
 
 void TestParser::tokenize() {
-    currentToken.params = StringUtils::splitByAnySpace(line);
+    currentToken.params = StringUtils::splitBySpace(line);
     if ((currentToken.params.size() == 0) || (currentToken.params[0][0] == '#')) {
         currentToken.type = TokenType::EMPTY;
     } else {