Add new unit tests for the gdb api

This adds new unit tests for gdb_apit. The tests compile a test file test.c and
then run gdb on it (via gdb_apit).

Author: danpoe

src/memory-analyzer/gdb_api.h

@@ -22,7 +22,7 @@ class gdb_apit
   std::string get_value(const std::string &variable);
   std::string get_memory(const std::string &variable);
 
-private:
+protected:
   const char *binary_name;
   FILE *input_stream;
   FILE *output_stream;

unit/memory-analyzer/gdb_api.cpp

@@ -2,235 +2,143 @@
 #include <testing-utils/use_catch.h>
 
 #ifdef __linux__
-//  \file Test that the regex expression used work as expected.
-#define private public
-#include <memory-analyzer/gdb_api.cpp>
+
+#include <cstdio>
+#include <cstdlib>
+#include <regex>
 #include <string>
 
-SCENARIO(
-  "gdb_apit uses regex as expected for memory",
-  "[core][memory-analyzer]")
+#include <fstream>
+#include <iostream>
+
+#include <memory-analyzer/gdb_api.cpp>
+
+void compile_test_file()
 {
-  gdb_apit gdb_api("");
-  GIVEN("The result of a struct pointer")
-  {
-    const std::string line = "$2 = (struct cycle_buffer *) 0x601050 <buffer>";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x601050");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x601050");
-    }
-  }
+  std::string test_file("memory-analyzer/test.c");
 
-  GIVEN("The result of a typedef pointer")
-  {
-    const std::string line = "$4 = (cycle_buffer_entry_t *) 0x602010";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x602010");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x602010");
-    }
-  }
+  std::string cmd("gcc -g -o test ");
+  cmd += test_file;
 
-  GIVEN("The result of a char pointer")
-  {
-    const std::string line = "$5 = 0x400734 \"snow\"";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x400734");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x400734");
-    }
-  }
+  const int r = system(cmd.c_str());
+  REQUIRE(!r);
+}
 
-  GIVEN("The result of a null pointer")
+class gdb_api_testt : public gdb_apit
+{
+  gdb_api_testt(const char *binary) : gdb_apit(binary)
   {
-    const std::string line = "$2 = 0x0";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x0");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x0");
-    }
   }
 
-  GIVEN("The result of a char pointer at very low address")
-  {
-    const std::string line = "$34 = 0x007456 \"snow\"";
-    THEN("the result matches the memory address and not nullpointer")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x007456");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x007456");
-    }
-  }
+  friend void gdb_api_internals_test();
+};
 
-  GIVEN("The result of a char pointer with some more whitespaces")
-  {
-    const std::string line = "$12 = 0x400752 \"thunder storm\"\n";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x400752");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x400752");
-    }
-  }
+void gdb_api_internals_test()
+{
+  compile_test_file();
 
-  GIVEN("The result of an array pointer")
+  SECTION("parse gdb output record")
   {
-    const std::string line = "$5 = (struct a_sub_type_t (*)[4]) 0x602080";
-    THEN("the result matches the memory address in the output")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x602080");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x602080");
-    }
-  }
+    gdb_api_testt gdb_api("test");
 
-  GIVEN("A constant struct pointer pointing to 0x0")
-  {
-    const std::string line = "$3 = (const struct name *) 0x0";
-    THEN("the returned memory address should be 0x0")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x0");
-    }
-  }
+    gdb_api_testt::gdb_output_recordt gor;
 
-  GIVEN("An enum address")
-  {
-    const std::string line = "$2 = (char *(*)[5]) 0x7e5500 <abc>";
-    THEN("the returned address is the address of the enum")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x7e5500");
-    }
+    gor = gdb_api.parse_gdb_output_record(
+      "a = \"1\", b = \"2\", c = {1, 2}, d = [3, 4], e=\"0x0\"");
+
+    REQUIRE(gor["a"] == "1");
+    REQUIRE(gor["b"] == "2");
+    REQUIRE(gor["c"] == "{1, 2}");
+    REQUIRE(gor["d"] == "[3, 4]");
+    REQUIRE(gor["e"] == "0x0");
   }
 
-  GIVEN("The result of an int pointer")
+  SECTION("read a line from an input stream")
   {
-    const std::string line = "$1 = (int *) 0x601088 <e>\n";
-    THEN("the result is the value of memory address of the int pointer")
-    {
-      REQUIRE(gdb_api.extract_memory(line) == "0x601088");
-    }
-    THEN("adding '(gdb) ' to the line doesn't have an influence")
-    {
-      REQUIRE(gdb_api.extract_memory("(gdb) " + line) == "0x601088");
-    }
+    gdb_api_testt gdb_api("test");
+
+    FILE *f = fopen("memory-analyzer/input.txt", "r");
+    gdb_api.input_stream = f;
+
+    std::string line;
+
+    line = gdb_api.read_next_line();
+    REQUIRE(line == "abc\n");
+
+    line = gdb_api.read_next_line();
+    REQUIRE(line == std::string(1120, 'a') + "\n");
+
+    line = gdb_api.read_next_line();
+    REQUIRE(line == "xyz");
   }
 
-  GIVEN("Non matching result")
+  SECTION("start and exit gdb")
   {
-    const std::string line = "Something that must not match 0x605940";
-    THEN("an exception is thrown")
-    {
-      REQUIRE_THROWS_AS(
-        gdb_api.extract_memory(line), gdb_interaction_exceptiont);
-    }
+    gdb_api_testt gdb_api("test");
+
+    gdb_api.create_gdb_process();
+
+    // check input and output streams
+    REQUIRE(!ferror(gdb_api.input_stream));
+    REQUIRE(!ferror(gdb_api.output_stream));
+
+    gdb_api.terminate_gdb_process();
   }
 }
 
-SCENARIO(
-  "gdb_apit uses regex as expected for value extraction",
-  "[core][memory-analyzer]")
+TEST_CASE("gdb api internals test")
 {
-  gdb_apit gdb_api("");
-  GIVEN("An integer value")
-  {
-    const std::string line = "$90 = 100";
-    THEN("the result schould be '100'")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "100");
-    }
-  }
+  gdb_api_internals_test();
+}
 
-  GIVEN("A string value")
-  {
-    const std::string line = "$5 = 0x602010 \"snow\"";
-    THEN("the result should be 'snow'")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "snow");
-    }
-  }
+TEST_CASE("gdb api test")
+{
+  compile_test_file();
 
-  GIVEN("A string with withe spaces")
-  {
-    const std::string line = "$1323 = 0x1243253 \"thunder storm\"\n";
-    THEN("the result should be 'thunder storm'")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "thunder storm");
-    }
-  }
+  gdb_apit gdb_api("test");
 
-  GIVEN("A byte value")
-  {
-    const std::string line = "$2 = 243 '\363'";
-    THEN("the result should be 243")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "243");
-    }
-  }
+  gdb_api.create_gdb_process();
 
-  GIVEN("A negative int value")
+  SECTION("breakpoint is hit")
   {
-    const std::string line = "$8 = -32";
-    THEN("the result should be -32")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "-32");
-    }
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint");
+    REQUIRE(r);
   }
 
-  GIVEN("An enum value")
+  SECTION("breakpoint is not hit")
   {
-    const std::string line = "$1 = INFO";
-    THEN("the result should be INFO")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "INFO");
-    }
+    const bool r = gdb_api.run_gdb_to_breakpoint("checkpoint2");
+    REQUIRE(!r);
   }
 
-  GIVEN("A void pointer value")
+  SECTION("breakpoint does not exist")
   {
-    const std::string line = "$6 = (const void *) 0x71";
-    THEN("the requried result should be 0x71")
-    {
-      REQUIRE(gdb_api.extract_value(line) == "0x71");
-    }
+    REQUIRE_THROWS_AS(
+      gdb_api.run_gdb_to_breakpoint("checkpoint3"), gdb_interaction_exceptiont);
   }
 
-  GIVEN("A gdb response that contains 'cannot access memory'")
+  SECTION("query memory")
   {
-    const std::string line = "Cannot access memory at address 0x71";
-    THEN("a gdb_inaccesible_memoryt excepition must be raised")
+    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]*)");
+
     {
-      REQUIRE_THROWS_AS(
-        gdb_api.extract_value(line), gdb_inaccessible_memory_exceptiont);
+      std::string address = gdb_api.get_memory("p");
+      REQUIRE(std::regex_match(address, regex));
     }
-  }
 
-  GIVEN("A value that must not match")
-  {
-    const std::string line = "$90 = must not match 20";
-    THEN("an exception is raised")
     {
-      REQUIRE_THROWS_AS(
-        gdb_api.extract_value(line), gdb_interaction_exceptiont);
+      std::string address = gdb_api.get_memory("vp");
+      REQUIRE(std::regex_match(address, regex));
     }
   }
+
+  gdb_api.terminate_gdb_process();
 }
+
 #endif

unit/memory-analyzer/input.txt

@@ -0,0 +1,3 @@
+abc
+aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+xyz

unit/memory-analyzer/test.c

@@ -0,0 +1,27 @@
+int x;
+char *s = "abc";
+int *p;
+void *vp;
+
+void checkpoint()
+{
+}
+void checkpoint2()
+{
+}
+
+void func()
+{
+  checkpoint2();
+}
+
+int main()
+{
+  x = 8;
+  p = &x;
+  vp = (void *)&x;
+
+  checkpoint();
+
+  return 0;
+}