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

src/util/piped_process.cpp

@@ -1,14 +1,23 @@
+#ifdef _WIN32
+// Windows includes go here
+#else
 #include <cstring>
 #include <iostream>
 #include <unistd.h>
 #include <errno.h>
+#include <fcntl.h> // library for fcntl function
+#endif
 
+#include "invariant.h"
 #include "piped_process.h"
 
 
 piped_processt::piped_processt(const std::string &command)
 {
-    // piped_processt subp = piped_processt();
+    #ifdef _WIN32
+    // This should use the new error state from PR #6131 once that is done
+    INVARIANT(false, "New SMT2 backend WIP: Windows piped_process constructor.");
+    #else
     if (pipe(pipe_input) == -1) {
         throw std::runtime_error("Input pipe creation failed");
     }
@@ -19,6 +28,10 @@ piped_processt::piped_processt(const std::string &command)
     // Default state
     process_state = process_statet::NOT_CREATED;
 
+    if (fcntl(pipe_output[0], F_SETFL, O_NONBLOCK) < 0) {
+        throw std::runtime_error("Setting pipe non-blocking failed");
+    }
+
     // Create a new process for the child that will execute the
     // command and receive information via pipes.
     pid_t pid = fork();
@@ -39,7 +52,7 @@ piped_processt::piped_processt(const std::string &command)
         char **args = split_command_args(command);
         // Execute the command
         execvp(args[0], args);
-        // Only reachable if execpv failed
+        // Only reachable if execvp failed
         throw std::runtime_error("Launching \"" + command +
                 "\" failed with error: "  + strerror(errno));
     } else {
@@ -48,14 +61,19 @@ piped_processt::piped_processt(const std::string &command)
         close(pipe_input[0]);
         close(pipe_output[1]);
 
-        // get stream for sending to the child process
+        // Get stream for sending to the child process
         command_stream = fdopen(pipe_input[1], "w");
         process_state = process_statet::CREATED;
     }
+    #endif
 }
 
 bool piped_processt::send(const std::string &message)
 {
+    #ifdef _WIN32
+    // This should use the new error state from PR #6131 once that is done
+    INVARIANT(false, "New SMT2 backend WIP: Windows piped_processt::send.");
+    #else
     if(process_state != process_statet::CREATED)
     {
         return false;
@@ -70,10 +88,15 @@ bool piped_processt::send(const std::string &message)
         return false;
     }
     return true;
+    #endif
 }
 
 std::string piped_processt::receive()
 {
+    #ifdef _WIN32
+    // This should use the new error state from PR #6131 once that is done
+    INVARIANT(false, "New SMT2 backend WIP: Windows piped_processt::receive.");
+    #else
     if(process_state != process_statet::CREATED)
         return NULL;
     std::string response = std::string("");
@@ -82,12 +105,24 @@ std::string piped_processt::receive()
     while (true)
     {
         nbytes = read(pipe_output[0], buff, BUFSIZE);
-        if (nbytes == 0)
-            break;
-        response.append(buff);
+        switch (nbytes) {
+            case -1:
+                // Nothing more to read in the pipe
+                return response;
+            case 0:
+                // Pipe is closed.
+                process_state = process_statet::STOPPED;
+                 if (response == std::string("")) {
+                    return NULL;
+                }
+                return response;
+            default:
+                // Read some bytes, append them to the response and continue
+                response.append(buff, nbytes);
+        }
     }
-    // assume nothing can go wrong for now! :D
-    return response;
+    UNREACHABLE;
+    #endif
 }
 
 

src/util/piped_process.h

@@ -1,5 +1,9 @@
-#pragma once
+#ifndef CPROVER_UTIL_PIPED_PROCESS_H
+#define CPROVER_UTIL_PIPED_PROCESS_H
 
+// TODO: Revisit buffer size and storage location.
+// Note that this may impact number of characters correctly communicated
+// by the pipe, to check/fix.
 #define BUFSIZE 2048
 
 class piped_processt {
@@ -14,8 +18,6 @@ class piped_processt {
 protected:
     FILE *response_stream;
     FILE *command_stream;
-    // TODO: Revisit buffer size and storage location
-    // const int BUFSIZE = 2048;
     int pipe_input[2];
     int pipe_output[2];
     process_statet process_state;
@@ -31,3 +33,5 @@ class piped_processt {
     piped_processt(const std::string &command);
     // ~piped_processt();
 };
+
+#endif

unit/Makefile

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

unit/util/piped_process.cpp

@@ -0,0 +1,92 @@
+/// \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/piped_process.h>
+#include <unistd.h>
+
+TEST_CASE("We create a pipe and we can read from it", "[core][util][piped_process]")
+{
+    std::string to_be_echoed = "The Jaberwocky";
+    std::string binary       = "/bin/echo";
+    std::string command      = binary + " " + to_be_echoed;
+    piped_processt process = piped_processt(command);
+
+    sleep(1);
+
+    std::string response = process.receive();
+
+    // Trim newline from response string that causes match to fail.
+    response.erase(
+        std::remove(response.begin(), response.end(), '\n'), response.end());
+
+    REQUIRE(response == to_be_echoed);
+}
+
+TEST_CASE("We create a pipe, send and receive from it", "[core][util][piped_process]")
+{
+    std::string binary    = "/usr/local/bin/z3 -in";
+    std::string statement = "(echo \"hi\")";
+    std::string termination_statement = "(exit)";
+    piped_processt process = piped_processt(binary);
+    // Wait a moment for z3 to start
+    sleep(1);
+
+    bool res = process.send(statement);
+    REQUIRE(res == true);  // sending succeeded without problems
+
+    // Wait a moment for z3 to process the sent message
+    sleep(1);
+    std::string response = process.receive();
+    // Trim newline from response string that causes match to fail.
+    response.erase(
+        std::remove(response.begin(), response.end(), '\n'), response.end());
+    REQUIRE(response == std::string("hi"));
+    REQUIRE(response.length() == 2);
+    
+    // Tell z3 to terminate
+    res = process.send(termination_statement);
+    REQUIRE(res == true);
+}
+
+TEST_CASE("We create a pipe, interact", "[core][util][piped_process]")
+{
+    std::string binary    = "/usr/local/bin/z3 -in";
+    std::string statement = "(echo \"hi\")";
+    std::string termination_statement = "(exit)";
+    piped_processt process = piped_processt(binary);
+    // Wait a moment for z3 to start
+    sleep(1);
+
+    bool res = process.send(statement);
+    REQUIRE(res == true);  // sending succeeded without problems
+
+    // Wait a moment for z3 to process the sent message
+    sleep(1);
+    std::string response = process.receive();
+    // Trim newline from response string that causes match to fail.
+    response.erase(
+        std::remove(response.begin(), response.end(), '\n'), response.end());
+    REQUIRE(response == std::string("hi"));
+
+    statement = std::string("(echo \"Second string\")");
+    res = process.send(statement);
+    REQUIRE(res == true);  // sending succeeded without problems
+
+    // Wait a moment for z3 to process the sent message
+    sleep(1);
+    response = process.receive();
+    // Trim newline from response string that causes match to fail.
+    response.erase(
+        std::remove(response.begin(), response.end(), '\n'), response.end());
+    REQUIRE(response == std::string("Second string"));
+
+    // Tell z3 to terminate
+    res = process.send(termination_statement);
+    REQUIRE(res == true);
+}
+#endif