Add check that gdb is on the path

unit/memory-analyzer/gdb_api.cpp

@@ -23,24 +23,19 @@ Author: Malte Mues <mail.mues@gmail.com>
 #ifdef RUN_GDB_API_TESTS
 
 #include <cstdio>
-#include <cstdlib>
 #include <regex>
 #include <string>
 
 #include <fstream>
 #include <iostream>
 
 #include <memory-analyzer/gdb_api.cpp>
+#include <util/run.h>
 
 void compile_test_file()
 {
-  std::string test_file("memory-analyzer/test.c");
-
-  std::string cmd("gcc -g -o test ");
-  cmd += test_file;
-
-  const int r = system(cmd.c_str());
-  REQUIRE(!r);
+  REQUIRE(
+    run("gcc", {"gcc", "-g", "-o", "test", "memory-analyzer/test.c"}) == 0);
 }
 
 class gdb_api_testt : public gdb_apit
@@ -99,99 +94,117 @@ void gdb_api_internals_test()
   }
 }
 
+bool check_for_gdb()
+{
+  const bool has_gdb = run("gdb", {"gdb", "--version"}) == 0;
+
+  SECTION("check gdb is on the PATH")
+  {
+    REQUIRE(has_gdb);
+  }
+  return has_gdb;
+}
+
 #endif
 
 TEST_CASE("gdb api internals test", "[core][memory-analyzer]")
 {
 #ifdef RUN_GDB_API_TESTS
-  gdb_api_internals_test();
+  if(check_for_gdb())
+  {
+    gdb_api_internals_test();
+  }
 #endif
 }
 
 TEST_CASE("gdb api test", "[core][memory-analyzer]")
 {
 #ifdef RUN_GDB_API_TESTS
-  compile_test_file();
-
+  if(check_for_gdb())
   {
-    gdb_apit gdb_api("test", true);
-    gdb_api.create_gdb_process();
+    compile_test_file();
 
-    try
     {
-      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
-      REQUIRE(r);
-    }
-    catch(const gdb_interaction_exceptiont &e)
-    {
-      std::cerr << "warning: cannot fully unit test GDB API as program cannot "
-                << "be run with gdb\n";
-      std::cerr << "warning: this may be due to not having the required "
-                << "permissions (e.g., to invoke ptrace() or to disable ASLR)"
-                << "\n";
-      std::cerr << "gdb_interaction_exceptiont:" << '\n';
-      std::cerr << e.what() << '\n';
-
-      std::ifstream file("gdb.txt");
-      CHECK_RETURN(file.is_open());
-      std::string line;
-
-      std::cerr << "=== gdb log begin ===\n";
+      gdb_apit gdb_api("test", true);
+      gdb_api.create_gdb_process();
 
-      while(getline(file, line))
+      try
       {
-        std::cerr << line << '\n';
+        const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+        REQUIRE(r);
       }
+      catch(const gdb_interaction_exceptiont &e)
+      {
+        std::cerr
+          << "warning: cannot fully unit test GDB API as program cannot "
+          << "be run with gdb\n";
+        std::cerr << "warning: this may be due to not having the required "
+                  << "permissions (e.g., to invoke ptrace() or to disable ASLR)"
+                  << "\n";
+        std::cerr << "gdb_interaction_exceptiont:" << '\n';
+        std::cerr << e.what() << '\n';
 
-      file.close();
-
-      std::cerr << "=== gdb log end ===\n";
+        std::ifstream file("gdb.txt");
+        CHECK_RETURN(file.is_open());
+        std::string line;
 
-      return;
-    }
-  }
+        std::cerr << "=== gdb log begin ===\n";
 
-  gdb_apit gdb_api("test");
-  gdb_api.create_gdb_process();
+        while(getline(file, line))
+        {
+          std::cerr << line << '\n';
+        }
 
-  SECTION("breakpoint is hit")
-  {
-    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
-    REQUIRE(r);
-  }
+        file.close();
 
-  SECTION("breakpoint is not hit")
-  {
-    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint2");
-    REQUIRE(!r);
-  }
+        std::cerr << "=== gdb log end ===\n";
 
-  SECTION("breakpoint does not exist")
-  {
-    REQUIRE_THROWS_AS(
-      gdb_api.run_gdb_to_breakpoint("checkpoint3"), gdb_interaction_exceptiont);
-  }
+        return;
+      }
+    }
 
-  SECTION("query memory")
-  {
-    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
-    REQUIRE(r);
+    gdb_apit gdb_api("test");
+    gdb_api.create_gdb_process();
 
-    REQUIRE(gdb_api.get_value("x") == "8");
-    REQUIRE(gdb_api.get_value("s") == "abc");
+    SECTION("breakpoint is hit")
+    {
+      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+      REQUIRE(r);
+    }
 
-    const std::regex regex(R"(0x[1-9a-f][0-9a-f]*)");
+    SECTION("breakpoint is not hit")
+    {
+      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint2");
+      REQUIRE(!r);
+    }
 
+    SECTION("breakpoint does not exist")
     {
-      std::string address = gdb_api.get_memory("p");
-      REQUIRE(std::regex_match(address, regex));
+      REQUIRE_THROWS_AS(
+        gdb_api.run_gdb_to_breakpoint("checkpoint3"),
+        gdb_interaction_exceptiont);
     }
 
+    SECTION("query memory")
     {
-      std::string address = gdb_api.get_memory("vp");
-      REQUIRE(std::regex_match(address, regex));
+      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+      REQUIRE(r);
+
+      REQUIRE(gdb_api.get_value("x") == "8");
+      REQUIRE(gdb_api.get_value("s") == "abc");
+
+      const std::regex regex(R"(0x[1-9a-f][0-9a-f]*)");
+
+      {
+        std::string address = gdb_api.get_memory("p");
+        REQUIRE(std::regex_match(address, regex));
+      }
+
+      {
+        std::string address = gdb_api.get_memory("vp");
+        REQUIRE(std::regex_match(address, regex));
+      }
     }
   }
-
 #endif
 }

unit/memory-analyzer/module_dependencies.txt

@@ -1,2 +1,3 @@
 memory-analyzer
 testing-utils
+util