Add unit tests for the piped_processt class.

Add validation code for the `piped_processt` class, in
the form of Catch unit tests, under `unit/util/`.

Co-authored-by: Fotis Koutoulakis <[email protected]>
Co-authored-by: Thomas Given-Wilson <[email protected]>

Author: NlightNFotis

unit/Makefile

@@ -123,6 +123,7 @@ SRC += analyses/ai/ai.cpp \
        util/optional.cpp \
        util/optional_utils.cpp \
        util/parse_options.cpp \
+       util/piped_process.cpp \
        util/pointer_offset_size.cpp \
        util/prefix_filter.cpp \
        util/range.cpp \

unit/util/piped_process.cpp

@@ -0,0 +1,272 @@
+/// \file
+/// \author Diffblue Ltd.
+/// Unit tests for checking the piped process communication mechanism.
+
+#ifdef _WIN32
+// No unit tests yet!
+#else
+
+#  include <testing-utils/use_catch.h>
+#  include <util/optional.h>
+#  include <util/piped_process.h>
+#  include <util/string_utils.h>
+
+TEST_CASE(
+  "Creating a sub process and reading its output.",
+  "[core][util][piped_process]")
+{
+  const std::string to_be_echoed = "The Jabberwocky";
+  // Need to give path to avoid shell built-in invocation
+  std::vector<std::string> commands;
+  commands.push_back("/bin/echo");
+  commands.push_back(to_be_echoed);
+  piped_processt process = piped_processt(commands);
+
+  // This is an indirect way to detect when the pipe has something since
+  // -1 is an infinite timeout wait. This could (in theory) also return
+  // when there is an error, but this unit test is not doing error handling.
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+
+  REQUIRE(response == to_be_echoed);
+}
+
+TEST_CASE(
+  "Creating a sub process with a binary that doesn't exist.",
+  "[core][util][piped_process]")
+{
+  const std::string expected_error(
+    "Launching jkfadsjfkljdskalfjksdakjfkjdskjflkjasljdflksdjj failed");
+  // Need to give path to avoid shell built-in invocation
+  std::vector<std::string> commands;
+  commands.push_back("jkfadsjfkljdskalfjksdakjfkjdskjflkjasljdflksdjj");
+  piped_processt process = piped_processt(commands);
+
+  // This is an indirect way to detect when the pipe has something since
+  // -1 is an infinite timeout wait. This could (in theory) also return
+  // when there is an error, but this unit test is not doing error handling.
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = process.receive();
+  // This tracks how many times we tried, if for some reason we are stuck
+  // give up eventually for this test.
+  int too_many_tries = 0;
+  // The expected length of the output string is 6 characters, keep
+  // trying up to the retry limit of 5 or the string is long enough
+  while(too_many_tries < 5 && response.length() < 64)
+  {
+    // Wait a short amount of time to try and receive
+    process.can_receive(10);
+    response += process.receive();
+    too_many_tries++;
+  }
+
+  REQUIRE(response.substr(0, 64) == expected_error);
+}
+
+TEST_CASE(
+  "Creating a sub process of z3 and read a response from an echo command.",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  piped_processt process = piped_processt(commands);
+
+  REQUIRE(
+    process.send("(echo \"hi\")\n") ==
+    piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "hi");
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Creating a sub process and interacting with it.",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  const std::string termination_statement = "(exit)\n";
+  piped_processt process = piped_processt(commands);
+
+  REQUIRE(
+    process.send("(echo \"hi\")\n") ==
+    piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "hi");
+
+  std::string statement = std::string("(echo \"Second string\")\n");
+  REQUIRE(process.send(statement) == piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  response = strip_string(process.receive());
+  REQUIRE(response == "Second string");
+
+  REQUIRE(
+    process.send(termination_statement) ==
+    piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Use a created piped process instance of z3 to solve a simple SMT problem",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  commands.push_back("-smt2");
+  piped_processt process = piped_processt(commands);
+
+  std::string message =
+    "(set-logic QF_LIA) (declare-const x Int) (declare-const y Int) (assert (> "
+    "(+ (mod x 4) (* 3 (div y 2))) (- x y)))  (check-sat)\n";
+  REQUIRE(process.send(message) == piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "sat");
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Use a created piped process instance of z3 to solve a simple SMT problem "
+  "with wait_receive",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  commands.push_back("-smt2");
+  piped_processt process = piped_processt(commands);
+
+  std::string statement =
+    "(set-logic QF_LIA) (declare-const x Int) (declare-const y Int) (assert (> "
+    "(+ (mod x 4) (* 3 (div y 2))) (- x y)))  (check-sat)\n";
+
+  REQUIRE(process.send(statement) == piped_processt::send_responset::SUCCEEDED);
+
+  std::string response = strip_string(process.wait_receive());
+  REQUIRE(response == "sat");
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Use a created piped process instance of z3 to test wait_receivable",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  piped_processt process = piped_processt(commands);
+
+  REQUIRE(
+    process.send("(echo \"hi\")\n") ==
+    piped_processt::send_responset::SUCCEEDED);
+
+  process.wait_receivable(100);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "hi");
+
+  std::string statement = std::string("(echo \"Second string\")\n");
+  REQUIRE(process.send(statement) == piped_processt::send_responset::SUCCEEDED);
+
+  process.wait_receivable(100);
+  response = strip_string(process.receive());
+  REQUIRE(response == "Second string");
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Use piped process instance of z3 to solve a simple SMT problem and get the "
+  "model, with wait_receivable/can_receive",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  commands.push_back("-smt2");
+  piped_processt process = piped_processt(commands);
+
+  std::string statement =
+    "(set-logic QF_LIA) (declare-const x Int) (declare-const y Int) (assert (> "
+    "(+ (mod x 4) (* 3 (div y 2))) (- x y)))  (check-sat)\n";
+  REQUIRE(process.send(statement) == piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "sat");
+
+  REQUIRE(
+    process.send("(get-model)\n") == piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  // If we receive here we can get less than the full (expected) output.
+  // The normal expectation is that the caller will handle parsing and
+  // checking of the received data (i.e. it is not the responsibility
+  // of the piped_process to know how big the response should be).
+  // Therefore, we need to rebuild the string here.
+  response = process.receive();
+  // This tracks how many times we tried, if for some reason we are stuck
+  // give up eventually for this test.
+  int too_many_tries = 0;
+  // The expected length of the output string is 74 characters, keep
+  // trying up to the retry limit of 5 or the string is long enough
+  while(too_many_tries < 5 && response.length() < 74)
+  {
+    // Wait a short amount of time to try and receive
+    process.can_receive(10);
+    response += process.receive();
+    too_many_tries++;
+  }
+  // It would be nice to check then whole model, but this is non-deterministic
+  // and so causes problems.
+  // Note that the above loop would need to read 74 characters to safely check
+  // the model commented out here.
+  // const std::string expected_response = std::string(
+  //   "(model \n  (define-fun y () Int\n    0)\n  "
+  //   "(define-fun x () Int\n    (- 4))\n)\n");
+  // REQUIRE(response == expected_response);
+  REQUIRE(response.find("(define-fun") != std::string::npos);
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+TEST_CASE(
+  "Use a created piped process instance of z3 to solve a simple SMT problem "
+  "and get the model, using infinite wait can_receive(...)",
+  "[core][util][piped_process]")
+{
+  std::vector<std::string> commands;
+  commands.push_back("z3");
+  commands.push_back("-in");
+  commands.push_back("-smt2");
+  piped_processt process = piped_processt(commands);
+
+  std::string statement =
+    "(set-logic QF_LIA) (declare-const x Int) (declare-const y Int) (assert (> "
+    "(+ (mod x 4) (* 3 (div y 2))) (- x y)))  (check-sat)\n";
+  REQUIRE(process.send(statement) == piped_processt::send_responset::SUCCEEDED);
+
+  process.can_receive(PIPED_PROCESS_INFINITE_TIMEOUT);
+  std::string response = strip_string(process.receive());
+  REQUIRE(response == "sat");
+
+  REQUIRE(
+    process.send("(exit)\n") == piped_processt::send_responset::SUCCEEDED);
+}
+
+#endif