Remove redundant check of return value of check_for_gdb() in gdb api unit tests

check_for_gdb() could only return true since if the gdb invocation in its body
failed a REQUIRE(...) in its body would fail. This changes check_for_gdb() the
return type of check_for_gdb() to void and refactors its callees.

Author: danpoe

unit/memory-analyzer/gdb_api.cpp

@@ -38,6 +38,11 @@ void compile_test_file()
     run("gcc", {"gcc", "-g", "-o", "test", "memory-analyzer/test.c"}) == 0);
 }
 
+void check_for_gdb()
+{
+  REQUIRE(run("gdb", {"gdb", "--version"}, "", "/dev/null", "/dev/null") == 0);
+}
+
 class gdb_api_testt : public gdb_apit
 {
   explicit gdb_api_testt(const char *binary) : gdb_apit(binary)
@@ -49,6 +54,7 @@ class gdb_api_testt : public gdb_apit
 
 void gdb_api_internals_test()
 {
+  check_for_gdb();
   compile_test_file();
 
   SECTION("parse gdb output record")
@@ -94,117 +100,98 @@ void gdb_api_internals_test()
   }
 }
 
-bool check_for_gdb()
-{
-  const bool has_gdb =
-    run("gdb", {"gdb", "--version"}, "", "/dev/null", "/dev/null") == 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
-  if(check_for_gdb())
-  {
-    gdb_api_internals_test();
-  }
+  gdb_api_internals_test();
 #endif
 }
 
 TEST_CASE("gdb api test", "[core][memory-analyzer]")
 {
 #ifdef RUN_GDB_API_TESTS
-  if(check_for_gdb())
+  check_for_gdb();
+  compile_test_file();
+
   {
-    compile_test_file();
+    gdb_apit gdb_api("test", true);
+    gdb_api.create_gdb_process();
 
+    try
+    {
+      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+      REQUIRE(r);
+    }
+    catch(const gdb_interaction_exceptiont &e)
     {
-      gdb_apit gdb_api("test", true);
-      gdb_api.create_gdb_process();
+      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;
 
-      try
+      std::cerr << "=== gdb log begin ===\n";
+
+      while(getline(file, line))
       {
-        const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
-        REQUIRE(r);
+        std::cerr << line << '\n';
       }
-      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;
+      file.close();
+
+      std::cerr << "=== gdb log end ===\n";
 
-        std::cerr << "=== gdb log begin ===\n";
+      return;
+    }
+  }
 
-        while(getline(file, line))
-        {
-          std::cerr << line << '\n';
-        }
+  gdb_apit gdb_api("test");
+  gdb_api.create_gdb_process();
 
-        file.close();
+  SECTION("breakpoint is hit")
+  {
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+    REQUIRE(r);
+  }
 
-        std::cerr << "=== gdb log end ===\n";
+  SECTION("breakpoint is not hit")
+  {
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint2");
+    REQUIRE(!r);
+  }
 
-        return;
-      }
-    }
+  SECTION("breakpoint does not exist")
+  {
+    REQUIRE_THROWS_AS(
+      gdb_api.run_gdb_to_breakpoint("checkpoint3"), gdb_interaction_exceptiont);
+  }
 
-    gdb_apit gdb_api("test");
-    gdb_api.create_gdb_process();
+  SECTION("query memory")
+  {
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+    REQUIRE(r);
 
-    SECTION("breakpoint is hit")
-    {
-      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");
 
-    SECTION("breakpoint is not hit")
-    {
-      const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint2");
-      REQUIRE(!r);
-    }
+    const std::regex regex(R"(0x[1-9a-f][0-9a-f]*)");
 
-    SECTION("breakpoint does not exist")
     {
-      REQUIRE_THROWS_AS(
-        gdb_api.run_gdb_to_breakpoint("checkpoint3"),
-        gdb_interaction_exceptiont);
+      std::string address = gdb_api.get_memory("p");
+      REQUIRE(std::regex_match(address, regex));
     }
 
-    SECTION("query memory")
     {
-      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));
-      }
+      std::string address = gdb_api.get_memory("vp");
+      REQUIRE(std::regex_match(address, regex));
     }
   }
 #endif