debugging with github

Author: graph

.github/workflows/test.yml

@@ -30,4 +30,4 @@ jobs:
 
     - name: Test
       working-directory: ${{github.workspace}}/build
-      run: ctest -C ${{matrix.build_type}} --output-on-failure
+      run: ctest -C ${{matrix.build_type}} --output-on-failure -V

src/cpp/subprocess/ProcessBuilder.cpp

@@ -22,6 +22,8 @@
 #include "shell_utils.hpp"
 #include "utf8_to_utf16.hpp"
 
+#define HERE(format, ...) \
+    printf("[%s:%d] " format "\n", __FILE__, __LINE__, ##__VA_ARGS__)
 
 using std::nullptr_t;
 
@@ -206,7 +208,7 @@ namespace subprocess {
     }
     void Popen::init(CommandLine& command, RunOptions& options) {
         ProcessBuilder builder;
-
+        HERE("initializing builder");
         builder.cin_option  = get_pipe_option(options.cin);
         builder.cout_option = get_pipe_option(options.cout);
         builder.cerr_option = get_pipe_option(options.cerr);
@@ -230,19 +232,22 @@ namespace subprocess {
         builder.new_process_group = options.new_process_group;
         builder.env = options.env;
         builder.cwd = options.cwd;
-
+        HERE("running builder");
         *this = builder.run_command(command);
 
+        HERE("setting up redirects");
         cin_thread = setup_redirect_stream(options.cin, cin);
         cout_thread = setup_redirect_stream(cout, options.cout);
         cerr_thread = setup_redirect_stream(cerr, options.cerr);
+        HERE("closing unused pipes");
         // the background thread will take ownership and auto close the pipe
         if (cin_thread.joinable())
             cin = kBadPipeValue;
         if (cout_thread.joinable())
             cout = kBadPipeValue;
         if (cerr_thread.joinable())
             cerr = kBadPipeValue;
+        HERE("done start");
     }
 
     Popen::Popen(Popen&& other) {
@@ -586,10 +591,13 @@ namespace subprocess {
     }
 
     CompletedProcess run(CommandLine command, RunOptions options) {
+        HERE("starting command");
         Popen popen(command, std::move(options));
+        HERE("it started");
         CompletedProcess completed;
         std::thread cout_thread;
         std::thread cerr_thread;
+        HERE("starting threads\n");
         if (popen.cout != kBadPipeValue) {
             cout_thread = std::thread([&]() {
                 try {
@@ -611,6 +619,7 @@ namespace subprocess {
             });
         }
 
+        HERE("joining threads");
         if (cout_thread.joinable()) {
             cout_thread.join();
         }
@@ -619,26 +628,33 @@ namespace subprocess {
         }
 
         try {
+            HERE("waiting for timeout");
             popen.wait(options.timeout);
         } catch (subprocess::TimeoutExpired& expired) {
+            HERE("caught signal");
             popen.send_signal(subprocess::SigNum::PSIGTERM);
             /*  python source code sends SIGKILL, we'll be a bit more nice.
                 give it a bit of time to terminate. This is more practical.
             */
             try {
+                HERE("graceful wait");
                 popen.wait(1.0/20.0);
             } catch (subprocess::TimeoutExpired& expired) {
+                HERE("dirty kill");
                 popen.kill();
             }
+            HERE("final wait");
             popen.wait();
             subprocess::TimeoutExpired timeout("subprocess::run timeout reached");
             timeout.cmd = command;
             timeout.timeout = options.timeout;
             timeout.cout = std::move(completed.cout);
             timeout.cerr = std::move(completed.cerr);
+            HERE("second throw");
             throw timeout;
         }
 
+        HERE("all good");
         completed.returncode = popen.returncode;
         completed.args = command;
         if (options.check && completed.returncode != 0) {
@@ -647,6 +663,7 @@ namespace subprocess {
             error.returncode    = completed.returncode;
             error.cout          = std::move(completed.cout);
             error.cerr          = std::move(completed.cerr);
+            HERE("check bad");
             throw error;
         }
         return completed;

test/CMakeLists.txt

@@ -47,9 +47,9 @@ function(cxx_test source)
     # this is only a gcc option
     #set_target_properties(${target} PROPERTIES COMPILE_FLAGS "-Wno-effc++")
     if(CMAKE_HOST_SYSTEM_NAME STREQUAL "Linux" AND MINGW)
-        add_test(NAME ${target} COMMAND wine ${RUNTIME_OUTPUT_DIRECTORY}/${target}.exe)
+        add_test(NAME ${target} COMMAND wine ${RUNTIME_OUTPUT_DIRECTORY}/${target}.exe -v)
     else()
-        add_test(NAME ${target} COMMAND ${RUNTIME_OUTPUT_DIRECTORY}/${target})
+        add_test(NAME ${target} COMMAND ${RUNTIME_OUTPUT_DIRECTORY}/${target} -v)
     endif()
     #add_custom_command(TARGET test_all
     #    COMMAND $<TARGET_FILE:${target}>

test/basic_test.cpp

@@ -12,8 +12,9 @@ using subprocess::CompletedProcess;
 using subprocess::PipeOption;
 using subprocess::RunBuilder;
 
-#ifdef _WIN32
-#define EOL "\r\n"
+// github CI on windows uses LF
+#if defined(_WIN32) && !defined(EOL_IS_LF)
+#define EOL "\n"
 #else
 #define EOL "\n"
 #endif
@@ -113,7 +114,7 @@ class BasicSuite : public CxxTest::TestSuite {
         text.resize(32);
         double start = subprocess::monotonic_seconds();
 
-        ssize_t transferred = subprocess::pipe_read_some(
+        subprocess::ssize_t transferred = subprocess::pipe_read_some(
             pipe.input, text.data(), text.size()
         );
 
@@ -302,45 +303,61 @@ class BasicSuite : public CxxTest::TestSuite {
             ++count;
         TS_TRACE("poll did " + std::to_string(count) + " iterations");
         TS_ASSERT(count > 100);
-
+        TS_TRACE("HERE");
         popen.close();
-
+        TS_TRACE("HERE");
         double timeout = timer.seconds();
+        printf("timeout is %f\n", timeout);
         TS_ASSERT_DELTA(timeout, 3, 0.5);
+        TS_TRACE("HERE");
     }
 
     void testRunTimeout() {
+        TS_TRACE("HERE");
         subprocess::EnvGuard guard;
         prepend_this_to_path();
         subprocess::StopWatch timer;
         bool didThrow = false;
+        TS_TRACE("HERE");
         try {
+            TS_TRACE("HERE");
             auto completedProcess = subprocess::run({"sleep", "3"}, {.timeout = 1});
+            TS_TRACE("HERE");
         } catch (subprocess::TimeoutExpired& error) {
             didThrow = true;
+            TS_TRACE("HERE");
+        } catch (std::exception& error) {
+            TS_TRACE("HERE");
+            printf("OMG: %s\n", error.what());
+        } catch (...) {
+            TS_TRACE("catch all here :O");
         }
+        TS_TRACE("HERE");
         double timeout = timer.seconds();
         TS_ASSERT_EQUALS(didThrow, true);
         TS_ASSERT_DELTA(timeout, 1, 0.5);
+        TS_TRACE("HERE");
     }
 
     void testWaitTimeout() {
+        TS_TRACE("HERE");
         subprocess::EnvGuard guard;
         prepend_this_to_path();
         auto popen = RunBuilder({"sleep", "10"}).new_process_group(true).popen();
         subprocess::StopWatch timer;
-
+        TS_TRACE("HERE");
         TS_ASSERT_THROWS(popen.wait(3), subprocess::TimeoutExpired)
 
         popen.terminate();
         popen.close();
-
+        TS_TRACE("HERE");
         double timeout = timer.seconds();
         TS_ASSERT_DELTA(timeout, 3, 0.5);
 
     }
 
     void test2ProcessConnect() {
+        TS_TRACE("HERE");
         subprocess::EnvGuard guard;
         prepend_this_to_path();
 
@@ -502,7 +519,7 @@ class BasicSuite : public CxxTest::TestSuite {
         TS_ASSERT_DIFFERS(handle, subprocess::kBadPipeValue);
         std::vector<char> data;
         data.resize(1024);
-        ssize_t transferred = subprocess::pipe_read(handle, data.data(), data.size());
+        subprocess::ssize_t transferred = subprocess::pipe_read(handle, data.data(), data.size());
         TS_ASSERT_EQUALS(transferred, str.size());
         std::string str2 = data.data();
         TS_ASSERT_EQUALS(str, str2);

test/cat_child.cpp

@@ -3,7 +3,7 @@
 #include <string>
 #ifdef _WIN32
 #include <io.h>
-//const auto& read = _read;
+#include <fcntl.h>
 #else
 #include <unistd.h>
 #endif
@@ -25,6 +25,10 @@ enum ExitCode {
 };
 int main(int argc, char** argv) {
     std::vector<std::string> args;
+    #ifdef _WIN32
+    setmode(fileno(stdout), O_BINARY);
+    setmode(fileno(stderr), O_BINARY);
+    #endif
     for (int i = 1; i < argc; ++i)
         args.push_back(argv[i]);
 

test/echo_main.cpp

@@ -3,8 +3,8 @@
 #include <subprocess.hpp>
 
 #ifdef _WIN32
-  #include <io.h>
-  #include <fcntl.h>
+    #include <io.h>
+    #include <fcntl.h>
 #endif
 
 // no echo on windows, so we make this to help test the library
@@ -15,7 +15,10 @@ int main(int argc, char** argv) {
     if (binary.size() > 0 && binary != "0" && binary != "false") {
         setmode(fileno(stdout), O_BINARY);
     }
+    setmode(fileno(stdout), O_BINARY);
+    setmode(fileno(stderr), O_BINARY);
     #endif
+
     std::string use_cerr_str = subprocess::cenv["USE_CERR"];
     bool use_cerr = use_cerr_str == "1";
     auto output_file = use_cerr? stderr : stdout;

test/printenv_main.cpp

@@ -1,8 +1,16 @@
 #include <iostream>
 #include <subprocess.hpp>
 
+#ifdef _WIN32
+    #include <io.h>
+    #include <fcntl.h>
+#endif
+
 // no echo on windows, so we make this to help test the library
 int main(int argc, char** argv) {
+    #ifdef _WIN32
+    setmode(fileno(stdout), O_BINARY);
+    #endif
     if (argc != 2) {
         std::cout << "printenv <var-name>\n    Will print out contents of that variable\n";
         std::cout << "    Returns failure code if variable was not found.\n";