kcenon::pacs::integration_test::process_launcher Class Reference

Cross-platform process launcher for binary integration testing. More...

#include <test_fixtures.h>

Collaboration diagram for kcenon::pacs::integration_test::process_launcher:

Public Types
using	pid_type = pid_t
	Start a process in the background.

Static Public Member Functions
static process_result	run (const std::string &executable, const std::vector< std::string > &args={}, std::chrono::seconds timeout=std::chrono::seconds{30})
	Run a process and wait for completion.
static pid_type	start_background (const std::string &executable, const std::vector< std::string > &args={})
static bool	stop_background (pid_type pid)
	Stop a background process.
static bool	is_running (pid_type pid)
	Check if a process is still running.
static bool	wait_for_port (uint16_t port, std::chrono::seconds timeout=std::chrono::seconds{10}, const std::string &host="127.0.0.1")
	Wait for a port to be listening.
static bool	is_port_listening (uint16_t port, const std::string &host="127.0.0.1")
	Check if a port is currently listening.

Static Public Attributes
static constexpr pid_type	invalid_pid = 0
	Invalid PID constant (0 is reserved on both platforms)

Static Private Member Functions
static process_result	run_posix (const std::string &executable, const std::vector< std::string > &args, std::chrono::seconds timeout)
static pid_t	start_background_posix (const std::string &executable, const std::vector< std::string > &args)
static bool	stop_background_posix (pid_t pid)

Detailed Description

Cross-platform process launcher for binary integration testing.

Provides utilities to run external processes, capture their output, and manage background processes for integration tests.

See also

Issue #136 - Binary Integration Test Scripts

Definition at line 861 of file test_fixtures.h.

Member Typedef Documentation

pid_type

using kcenon::pacs::integration_test::process_launcher::pid_type = pid_t

Start a process in the background.

Parameters

executable	Path to executable
args	Command line arguments

Returns

Process ID (pid_t on POSIX, DWORD on Windows), or -1 on error

Definition at line 900 of file test_fixtures.h.

Member Function Documentation

is_port_listening()

static bool kcenon::pacs::integration_test::process_launcher::is_port_listening ( uint16_t port, const std::string & host = "127.0.0.1" )

inlinestatic

Check if a port is currently listening.

Parameters

port	Port number
host	Host address

Returns

true if port is accepting connections

Uses adaptive timeout based on environment:

• Normal: 200ms for quick responsiveness
• CI: 1000ms to account for slower VM/container environments

Definition at line 992 of file test_fixtures.h.

                                                                                      {
        // Adaptive timeout: longer in CI environments where VMs may be slower
        const long timeout_us = is_ci_environment() ? 1000000 : 200000;  // 1s CI, 200ms normal
 
#ifdef _WIN32
        WSADATA wsa_data;
        if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0) {
            return false;
        }
 
        SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (sock == INVALID_SOCKET) {
            WSACleanup();
            return false;
        }
 
        // Set non-blocking
        u_long mode = 1;
        ioctlsocket(sock, FIONBIO, &mode);
 
        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
        addr.sin_addr.s_addr = inet_addr(host.c_str());
 
        int result = connect(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
 
        fd_set writefds;
        FD_ZERO(&writefds);
        FD_SET(sock, &writefds);
 
        timeval tv{};
        tv.tv_sec = static_cast<decltype(tv.tv_sec)>(timeout_us / 1000000);
        tv.tv_usec = static_cast<decltype(tv.tv_usec)>(timeout_us % 1000000);
        result = select(0, nullptr, &writefds, nullptr, &tv);
 
        if (result > 0) {
            // Check if connection actually succeeded
            int error = 0;
            int len = sizeof(error);
            getsockopt(sock, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len);
            closesocket(sock);
            WSACleanup();
            return error == 0;
        }
 
        closesocket(sock);
        WSACleanup();
 
        return false;
#else
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0) {
            return false;
        }
 
        // Set socket to non-blocking
        int flags = fcntl(sock, F_GETFL, 0);
        fcntl(sock, F_SETFL, flags | O_NONBLOCK);
 
        sockaddr_in addr{};
        addr.sin_family = AF_INET;
        addr.sin_port = htons(port);
 
        if (inet_pton(AF_INET, host.c_str(), &addr.sin_addr) != 1) {
            close(sock);
            return false;
        }
 
        int result = connect(sock, reinterpret_cast<sockaddr*>(&addr), sizeof(addr));
 
        if (result == 0) {
            close(sock);
            return true;
        }
 
        if (errno == EINPROGRESS || errno == EWOULDBLOCK) {
            fd_set writefds;
            FD_ZERO(&writefds);
            FD_SET(sock, &writefds);
 
            timeval tv{};
            tv.tv_sec = static_cast<decltype(tv.tv_sec)>(timeout_us / 1000000);
            tv.tv_usec = static_cast<decltype(tv.tv_usec)>(timeout_us % 1000000);
            result = select(sock + 1, nullptr, &writefds, nullptr, &tv);
 
            if (result > 0) {
                int error = 0;
                socklen_t len = sizeof(error);
                getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len);
                close(sock);
                return error == 0;
            }
        }
 
        close(sock);
        return false;
#endif
    }

References kcenon::pacs::integration_test::is_ci_environment().

Referenced by TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), TEST_CASE(), and TEST_CASE().

Here is the call graph for this function:

Here is the caller graph for this function:

is_running()

static bool kcenon::pacs::integration_test::process_launcher::is_running ( pid_type pid )

inlinestatic

Check if a process is still running.

Parameters

pid	Process ID to check

Returns

true if process is running

Definition at line 935 of file test_fixtures.h.

                                         {
#ifdef _WIN32
        HANDLE process = OpenProcess(PROCESS_QUERY_INFORMATION, FALSE, pid);
        if (process == nullptr) {
            return false;
        }
        DWORD exit_code;
        if (GetExitCodeProcess(process, &exit_code)) {
            CloseHandle(process);
            return exit_code == STILL_ACTIVE;
        }
        CloseHandle(process);
        return false;
#else
        return kill(pid, 0) == 0;
#endif
    }

Referenced by kcenon::pacs::integration_test::background_process_guard::is_running().

Here is the caller graph for this function:

run()

static process_result kcenon::pacs::integration_test::process_launcher::run ( const std::string & executable, const std::vector< std::string > & args = {}, std::chrono::seconds timeout = std::chrono::seconds{30} )

inlinestatic

Run a process and wait for completion.

Parameters

executable	Path to executable
args	Command line arguments
timeout	Maximum execution time

Returns

Process execution result

Definition at line 870 of file test_fixtures.h.

                                           {},
        std::chrono::seconds timeout = std::chrono::seconds{30}) {
 
        process_result result;
        auto start_time = std::chrono::steady_clock::now();
 
#ifdef _WIN32
        result = run_windows(executable, args, timeout);
#else
        result = run_posix(executable, args, timeout);
#endif
 
        auto end_time = std::chrono::steady_clock::now();
        result.duration = std::chrono::duration_cast<std::chrono::milliseconds>(
            end_time - start_time);
 
        return result;
    }

Referenced by kcenon::pacs::integration_test::dcmtk_tool::run_tool().

Here is the caller graph for this function:

run_posix()

static process_result kcenon::pacs::integration_test::process_launcher::run_posix ( const std::string & executable, const std::vector< std::string > & args, std::chrono::seconds timeout )

inlinestaticprivate

Definition at line 1095 of file test_fixtures.h.

                                  {
 
        process_result result;
 
        // Create pipes for stdout and stderr
        int stdout_pipe[2];
        int stderr_pipe[2];
 
        if (pipe(stdout_pipe) != 0 || pipe(stderr_pipe) != 0) {
            result.exit_code = -1;
            result.stderr_output = "Failed to create pipes";
            return result;
        }
 
        pid_t pid = fork();
 
        if (pid < 0) {
            result.exit_code = -1;
            result.stderr_output = "Failed to fork";
            close(stdout_pipe[0]);
            close(stdout_pipe[1]);
            close(stderr_pipe[0]);
            close(stderr_pipe[1]);
            return result;
        }
 
        if (pid == 0) {
            // Child process
            close(stdout_pipe[0]);
            close(stderr_pipe[0]);
 
            dup2(stdout_pipe[1], STDOUT_FILENO);
            dup2(stderr_pipe[1], STDERR_FILENO);
 
            close(stdout_pipe[1]);
            close(stderr_pipe[1]);
 
            // Build argv
            std::vector<char*> argv;
            argv.push_back(const_cast<char*>(executable.c_str()));
            for (const auto& arg : args) {
                argv.push_back(const_cast<char*>(arg.c_str()));
            }
            argv.push_back(nullptr);
 
            execv(executable.c_str(), argv.data());
            _exit(127);  // execv failed
        }
 
        // Parent process
        close(stdout_pipe[1]);
        close(stderr_pipe[1]);
 
        // Set pipes to non-blocking
        fcntl(stdout_pipe[0], F_SETFL, O_NONBLOCK);
        fcntl(stderr_pipe[0], F_SETFL, O_NONBLOCK);
 
        auto start = std::chrono::steady_clock::now();
        int status = 0;
        bool child_exited = false;
 
        std::array<char, 4096> buffer{};
 
        while (!child_exited) {
            // Check timeout
            auto elapsed = std::chrono::steady_clock::now() - start;
            if (elapsed >= timeout) {
                kill(pid, SIGKILL);
                waitpid(pid, &status, 0);
                result.timed_out = true;
                result.exit_code = -1;
                break;
            }
 
            // Check if child has exited
            pid_t wait_result = waitpid(pid, &status, WNOHANG);
            if (wait_result > 0) {
                child_exited = true;
                if (WIFEXITED(status)) {
                    result.exit_code = WEXITSTATUS(status);
                } else if (WIFSIGNALED(status)) {
                    result.exit_code = -WTERMSIG(status);
                }
            } else if (wait_result < 0) {
                break;
            }
 
            // Read available output
            ssize_t n;
            while ((n = read(stdout_pipe[0], buffer.data(), buffer.size() - 1)) > 0) {
                buffer[static_cast<size_t>(n)] = '\0';
                result.stdout_output += buffer.data();
            }
            while ((n = read(stderr_pipe[0], buffer.data(), buffer.size() - 1)) > 0) {
                buffer[static_cast<size_t>(n)] = '\0';
                result.stderr_output += buffer.data();
            }
 
            if (!child_exited) {
                std::this_thread::sleep_for(std::chrono::milliseconds{10});
            }
        }
 
        // Read any remaining output
        ssize_t n;
        while ((n = read(stdout_pipe[0], buffer.data(), buffer.size() - 1)) > 0) {
            buffer[static_cast<size_t>(n)] = '\0';
            result.stdout_output += buffer.data();
        }
        while ((n = read(stderr_pipe[0], buffer.data(), buffer.size() - 1)) > 0) {
            buffer[static_cast<size_t>(n)] = '\0';
            result.stderr_output += buffer.data();
        }
 
        close(stdout_pipe[0]);
        close(stderr_pipe[0]);
 
        return result;
    }

References kcenon::pacs::integration_test::process_result::exit_code, kcenon::pacs::integration_test::process_result::stderr_output, kcenon::pacs::integration_test::process_result::stdout_output, and kcenon::pacs::integration_test::process_result::timed_out.

start_background()

static pid_type kcenon::pacs::integration_test::process_launcher::start_background ( const std::string & executable, const std::vector< std::string > & args = {} )

inlinestatic

Definition at line 906 of file test_fixtures.h.

                                           {}) {
 
#ifdef _WIN32
        return start_background_windows(executable, args);
#else
        return start_background_posix(executable, args);
#endif
    }

Referenced by kcenon::pacs::integration_test::dcmtk_server_guard::dcmtk_server_guard(), and kcenon::pacs::integration_test::dcmtk_tool::start_tool_background().

Here is the caller graph for this function:

start_background_posix()

static pid_t kcenon::pacs::integration_test::process_launcher::start_background_posix ( const std::string & executable, const std::vector< std::string > & args )

inlinestaticprivate

Definition at line 1218 of file test_fixtures.h.

                                          {
 
        pid_t pid = fork();
 
        if (pid < 0) {
            return -1;
        }
 
        if (pid == 0) {
            // Child process
            // Redirect stdout and stderr to /dev/null
            int null_fd = open("/dev/null", O_RDWR);
            if (null_fd >= 0) {
                dup2(null_fd, STDOUT_FILENO);
                dup2(null_fd, STDERR_FILENO);
                close(null_fd);
            }
 
            // Create new session to detach from terminal
            setsid();
 
            // Build argv
            std::vector<char*> argv;
            argv.push_back(const_cast<char*>(executable.c_str()));
            for (const auto& arg : args) {
                argv.push_back(const_cast<char*>(arg.c_str()));
            }
            argv.push_back(nullptr);
 
            execv(executable.c_str(), argv.data());
            _exit(127);
        }
 
        return pid;
    }

stop_background()

static bool kcenon::pacs::integration_test::process_launcher::stop_background ( pid_type pid )

inlinestatic

Stop a background process.

Parameters

pid	Process ID to stop

Returns

true if process was stopped successfully

Definition at line 922 of file test_fixtures.h.

                                              {
#ifdef _WIN32
        return stop_background_windows(pid);
#else
        return stop_background_posix(pid);
#endif
    }

References stop_background_posix().

Referenced by kcenon::pacs::integration_test::background_process_guard::stop().

Here is the call graph for this function:

Here is the caller graph for this function:

stop_background_posix()

static bool kcenon::pacs::integration_test::process_launcher::stop_background_posix ( pid_t pid )

inlinestaticprivate

Definition at line 1256 of file test_fixtures.h.

                                                 {
        if (pid <= 0) {
            return false;
        }
 
        // Send SIGTERM first for graceful shutdown
        if (kill(pid, SIGTERM) != 0) {
            return errno == ESRCH;  // Process already gone
        }
 
        // Wait for process to terminate (up to 5 seconds)
        for (int i = 0; i < 50; ++i) {
            int status;
            pid_t result = waitpid(pid, &status, WNOHANG);
            if (result > 0 || (result < 0 && errno == ECHILD)) {
                return true;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds{100});
        }
 
        // Force kill if still running
        kill(pid, SIGKILL);
        waitpid(pid, nullptr, 0);
 
        return true;
    }

Referenced by stop_background().

Here is the caller graph for this function:

wait_for_port()

static bool kcenon::pacs::integration_test::process_launcher::wait_for_port ( uint16_t port, std::chrono::seconds timeout = std::chrono::seconds{10}, const std::string & host = "127.0.0.1" )

inlinestatic

Wait for a port to be listening.

Parameters

port	Port number to check
timeout	Maximum wait time
host	Host to check (default: localhost)

Returns

true if port is listening before timeout

Definition at line 960 of file test_fixtures.h.

                                                   {10},
        const std::string& host = "127.0.0.1") {
 
        auto start = std::chrono::steady_clock::now();
        auto interval = std::chrono::milliseconds{100};
 
        while (true) {
            if (is_port_listening(port, host)) {
                return true;
            }
 
            auto elapsed = std::chrono::steady_clock::now() - start;
            if (elapsed >= timeout) {
                return false;
            }
 
            std::this_thread::sleep_for(interval);
        }
    }

Referenced by kcenon::pacs::integration_test::dcmtk_tool::echoscp(), and kcenon::pacs::integration_test::dcmtk_tool::storescp().

Here is the caller graph for this function:

Member Data Documentation

invalid_pid

pid_type kcenon::pacs::integration_test::process_launcher::invalid_pid = 0

staticconstexpr

Invalid PID constant (0 is reserved on both platforms)

Definition at line 904 of file test_fixtures.h.

Referenced by kcenon::pacs::integration_test::background_process_guard::background_process_guard(), kcenon::pacs::integration_test::dcmtk_tool::echoscp(), kcenon::pacs::integration_test::background_process_guard::operator=(), kcenon::pacs::integration_test::background_process_guard::release(), kcenon::pacs::integration_test::background_process_guard::stop(), kcenon::pacs::integration_test::dcmtk_tool::storescp(), TEST_CASE(), TEST_CASE(), and TEST_CASE().

---

The documentation for this class was generated from the following file:

• examples/integration_tests/test_fixtures.h