fix(core-clp): Construct file paths in test cases relative to test file location rather than working directory (fixes #124). (#1114)

Co-authored-by: kirkrodrigues <[email protected]>

Author: quinntaylormitchell

components/core/tests/test-GrepCore.cpp

@@ -1,3 +1,4 @@
+#include <filesystem>
 #include <string>
 
 #include <catch2/catch_test_macros.hpp>
@@ -17,9 +18,20 @@ using log_surgeon::SchemaParser;
 using log_surgeon::SchemaVarAST;
 using std::string;
 
+namespace {
+[[nodiscard]] auto get_tests_dir() -> std::filesystem::path;
+
+auto get_tests_dir() -> std::filesystem::path {
+    std::filesystem::path const current_file_path{__FILE__};
+    return std::filesystem::canonical(current_file_path.parent_path());
+}
+}  // namespace
+
 TEST_CASE("get_bounds_of_next_potential_var", "[get_bounds_of_next_potential_var]") {
+    auto const test_schema_files_dir = get_tests_dir() / "test_schema_files";
+    auto const search_schema_path = test_schema_files_dir / "search_schema.txt";
     ByteLexer lexer;
-    load_lexer_from_file("../tests/test_schema_files/search_schema.txt", lexer);
+    load_lexer_from_file(search_schema_path.string(), lexer);
 
     string str;
     size_t begin_pos;

components/core/tests/test-ParserWithUserSchema.cpp

@@ -3,10 +3,10 @@
 
 #include <sys/stat.h>
 
+#include <filesystem>
 #include <string>
 #include <utility>
 
-#include <boost/filesystem.hpp>
 #include <catch2/catch_test_macros.hpp>
 #include <catch2/matchers/catch_matchers.hpp>
 #include <log_surgeon/LogParser.hpp>
@@ -28,6 +28,25 @@ using log_surgeon::SchemaAST;
 using log_surgeon::SchemaVarAST;
 using log_surgeon::Token;
 
+namespace {
+[[nodiscard]] auto get_tests_dir() -> std::filesystem::path;
+[[nodiscard]] auto get_test_schema_files_dir() -> std::filesystem::path;
+[[nodiscard]] auto get_test_queries_dir() -> std::filesystem::path;
+
+auto get_tests_dir() -> std::filesystem::path {
+    std::filesystem::path const current_file_path{__FILE__};
+    return std::filesystem::canonical(current_file_path.parent_path());
+}
+
+auto get_test_schema_files_dir() -> std::filesystem::path {
+    return get_tests_dir() / "test_schema_files";
+}
+
+auto get_test_queries_dir() -> std::filesystem::path {
+    return get_tests_dir() / "test_search_queries";
+}
+}  // namespace
+
 std::unique_ptr<SchemaAST> generate_schema_ast(std::string const& schema_file) {
     std::unique_ptr<SchemaAST> schema_ast = log_surgeon::SchemaParser::try_schema_file(schema_file);
     REQUIRE(schema_ast.get() != nullptr);
@@ -79,56 +98,60 @@ void decompress(std::string archive_dir, std::string output_dir) {
 }
 
 TEST_CASE("Test error for missing schema file", "[LALR1Parser][SchemaParser]") {
-    std::string file_path = "../tests/test_schema_files/missing_schema.txt";
-    std::string file_name = boost::filesystem::weakly_canonical(file_path).string();
+    auto const file_path = get_test_schema_files_dir() / "missing_schema.txt";
+    auto const file_path_string = file_path.string();
     REQUIRE_THROWS_WITH(
-            generate_schema_ast(file_path),
-            "Failed to read '" + file_path + "', error_code="
+            generate_schema_ast(file_path_string),
+            "Failed to read '" + file_path_string + "', error_code="
                     + std::to_string(static_cast<int>(log_surgeon::ErrorCode::FileNotFound))
     );
 }
 
 TEST_CASE("Test error for empty schema file", "[LALR1Parser][SchemaParser]") {
-    std::string file_path = "../tests/test_schema_files/empty_schema.txt";
+    auto const file_path = get_test_schema_files_dir() / "empty_schema.txt";
     REQUIRE_THROWS_WITH(
-            generate_schema_ast(file_path),
+            generate_schema_ast(file_path.string()),
             "Schema:1:1: error: empty file\n"
             "          \n"
             "^\n"
     );
 }
 
 TEST_CASE("Test error for colon missing schema file", "[LALR1Parser][SchemaParser]") {
-    std::string file_path = "../tests/test_schema_files/colon_missing_schema.txt";
+    auto const file_path = get_test_schema_files_dir() / "colon_missing_schema.txt";
     REQUIRE_THROWS_WITH(
-            generate_schema_ast(file_path),
+            generate_schema_ast(file_path.string()),
             "Schema:3:4: error: expected '>',':','AlphaNumeric' before ' ' token\n"
             "          int [0-9]+\n"
             "             ^\n"
     );
 }
 
 TEST_CASE("Test error for multi-character tokens in schema file", "[LALR1Parser][SchemaParser]") {
-    std::string file_path = "../tests/test_schema_files/schema_with_multicharacter_token_error.txt";
+    auto const file_path
+            = get_test_schema_files_dir() / "schema_with_multicharacter_token_error.txt";
     REQUIRE_THROWS_WITH(
-            generate_schema_ast(file_path),
+            generate_schema_ast(file_path.string()),
             "Schema:2:11: error: expected ':' before ' ' token\n"
             "          delimiters : \\r\\n\n"
             "                    ^\n"
     );
 }
 
 TEST_CASE("Test creating schema parser", "[LALR1Parser][SchemaParser]") {
-    generate_schema_ast("../tests/test_schema_files/easy_schema.txt");
+    auto const schema_file_path = get_test_schema_files_dir() / "easy_schema.txt";
+    generate_schema_ast(schema_file_path.string());
 }
 
 TEST_CASE("Test creating log parser with delimiters", "[LALR1Parser][LogParser]") {
-    generate_log_parser("../tests/test_schema_files/schema_with_delimiters.txt");
+    auto const schema_file_path = get_test_schema_files_dir() / "schema_with_delimiters.txt";
+    generate_log_parser(schema_file_path.string());
 }
 
 TEST_CASE("Test creating log parser without delimiters", "[LALR1Parser][LogParser]") {
+    auto const schema_file_path = get_test_schema_files_dir() / "schema_without_delimiters.txt";
     REQUIRE_THROWS_WITH(
-            generate_log_parser("../tests/test_schema_files/schema_without_delimiters.txt"),
+            generate_log_parser(schema_file_path.string()),
             "When using --schema-path, \"delimiters:\" line must be used."
     );
 }
@@ -158,10 +181,10 @@ TEST_CASE("Test creating log parser without delimiters", "[LALR1Parser][LogParse
 
 TEST_CASE("Test lexer", "[Search]") {
     ByteLexer lexer;
-    std::string schema_file_name = "../tests/test_schema_files/search_schema.txt";
-    std::string schema_file_path = boost::filesystem::weakly_canonical(schema_file_name).string();
-    load_lexer_from_file(schema_file_path, lexer);
-    FileReader file_reader{"../tests/test_search_queries/easy.txt"};
+    auto const schema_file_path = get_test_schema_files_dir() / "search_schema.txt";
+    load_lexer_from_file(schema_file_path.string(), lexer);
+    auto const query_file_path = get_test_queries_dir() / "easy.txt";
+    FileReader file_reader{query_file_path.string()};
     LogSurgeonReader reader_wrapper(file_reader);
     log_surgeon::ParserInputBuffer parser_input_buffer;
     parser_input_buffer.read_if_safe(reader_wrapper);