test_fixtures.h

Go to the documentation of this file.

 
#ifndef PACS_INTEGRATION_TESTS_TEST_FIXTURES_HPP
#define PACS_INTEGRATION_TESTS_TEST_FIXTURES_HPP
 
#include "kcenon/pacs/core/dicom_dataset.h"
#include "kcenon/pacs/core/dicom_file.h"
#include "kcenon/pacs/core/dicom_tag_constants.h"
#include "kcenon/pacs/network/association.h"
#include "kcenon/pacs/network/dicom_server.h"
#include "kcenon/pacs/network/server_config.h"
#include "kcenon/pacs/services/storage_scp.h"
#include "kcenon/pacs/services/storage_scu.h"
#include "kcenon/pacs/services/verification_scp.h"
 
// Include comprehensive test data generator
#include "test_data_generator.h"
 
#include <array>
#include <atomic>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <filesystem>
#include <memory>
#include <random>
#include <sstream>
#include <string>
#include <thread>
#include <vector>
 
#ifdef _WIN32
#include <windows.h>
#else
#include <arpa/inet.h>
#include <cerrno>
#include <csignal>
#include <fcntl.h>
#include <netinet/in.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <unistd.h>
#endif
 
namespace kcenon::pacs::integration_test {
 
// =============================================================================
// CI Environment Detection
// =============================================================================
 
inline bool is_ci_environment() {
    static const bool ci_detected = []() {
        const char* ci_vars[] = {
            "CI", "GITHUB_ACTIONS", "GITLAB_CI",
            "JENKINS_URL", "CIRCLECI", "TRAVIS"
        };
        for (const auto* var : ci_vars) {
            if (std::getenv(var) != nullptr) {
                return true;
            }
        }
        return false;
    }();
    return ci_detected;
}
 
// =============================================================================
// Constants
// =============================================================================
 
constexpr uint16_t default_test_port = 41104;
 
inline std::chrono::milliseconds default_timeout() {
    return is_ci_environment()
        ? std::chrono::milliseconds{30000}
        : std::chrono::milliseconds{5000};
}
 
inline std::chrono::milliseconds server_ready_timeout() {
    return is_ci_environment()
        ? std::chrono::milliseconds{30000}
        : std::chrono::milliseconds{5000};
}
 
inline std::chrono::milliseconds dcmtk_server_ready_timeout() {
    return is_ci_environment()
        ? std::chrono::milliseconds{60000}
        : std::chrono::milliseconds{10000};
}
 
// =============================================================================
// Feature Detection
// =============================================================================
 
inline bool supports_real_tcp_dicom() {
    // Currently, pacs_system does not support real TCP connections
    // for DICOM protocol. The accept_worker accepts TCP connections
    // but immediately closes them without performing DICOM handshake.
    //
    // This causes DCMTK clients to receive "Peer aborted Association"
    // errors when attempting to connect.
    //
    // When real TCP support is implemented, update this to return true
    // or perform an actual connection test.
    return false;
}
 
constexpr const char* test_scp_ae_title = "TEST_SCP";
constexpr const char* test_scu_ae_title = "TEST_SCU";
 
// =============================================================================
// Utility Functions
// =============================================================================
 
inline std::string generate_uid(const std::string& root = "1.2.826.0.1.3680043.9.9999") {
    static std::atomic<uint64_t> counter{0};
    auto now = std::chrono::system_clock::now();
    auto timestamp = std::chrono::duration_cast<std::chrono::milliseconds>(
        now.time_since_epoch()).count();
 
    return root + "." + std::to_string(timestamp) + "." + std::to_string(++counter);
}
 
inline bool is_port_available(uint16_t port) {
#ifdef _WIN32
    SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        return false;
    }
 
    int reuse = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR,
               reinterpret_cast<const char*>(&reuse), sizeof(reuse));
 
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addr.sin_port = htons(port);
 
    bool available = (bind(sock, reinterpret_cast<sockaddr*>(&addr),
                           sizeof(addr)) == 0);
    closesocket(sock);
    return available;
#else
    int sock = socket(AF_INET, SOCK_STREAM, 0);
    if (sock < 0) {
        return false;
    }
 
    int reuse = 1;
    setsockopt(sock, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(reuse));
 
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
    addr.sin_port = htons(port);
 
    bool available = (bind(sock, reinterpret_cast<sockaddr*>(&addr),
                           sizeof(addr)) == 0);
    close(sock);
    return available;
#endif
}
 
inline uint16_t find_available_port(uint16_t start = default_test_port,
                                     int max_attempts = 200) {
    static std::atomic<uint16_t> port_offset{0};
 
    // Use a wider range and randomize starting point to reduce conflicts
    static std::random_device rd;
    static std::mt19937 gen(rd());
    std::uniform_int_distribution<uint16_t> dist(0, 500);
 
    uint16_t base_offset = port_offset.fetch_add(1) % 200;
    uint16_t random_offset = dist(gen);
 
    for (int attempt = 0; attempt < max_attempts; ++attempt) {
        uint16_t port = start + ((base_offset + random_offset + attempt) % 1000);
 
        // Avoid well-known ports and ensure we stay in a valid range
        if (port < 1024) {
            port += 40000;
        }
        if (port > 65000) {
            port = start + (attempt % 500);
        }
 
        if (is_port_available(port)) {
            return port;
        }
    }
 
    // Fallback: return incremental port (original behavior)
    return start + (port_offset++ % 100);
}
 
template <typename Func>
bool wait_for(
    Func&& condition,
    std::chrono::milliseconds timeout,
    std::chrono::milliseconds interval = std::chrono::milliseconds{50}) {
 
    auto start = std::chrono::steady_clock::now();
    while (!condition()) {
        auto elapsed = std::chrono::steady_clock::now() - start;
        if (elapsed >= timeout) {
            return false;
        }
        std::this_thread::sleep_for(interval);
    }
    return true;
}
 
template <typename Func>
bool wait_for(Func&& condition) {
    return wait_for(std::forward<Func>(condition), default_timeout());
}
 
// =============================================================================
// DICOM Dataset Generators
// =============================================================================
 
inline core::dicom_dataset generate_ct_dataset(
    const std::string& study_uid = "",
    const std::string& series_uid = "",
    const std::string& instance_uid = "") {
 
    core::dicom_dataset ds;
 
    // Patient module
    ds.set_string(core::tags::patient_name, encoding::vr_type::PN, "TEST^PATIENT");
    ds.set_string(core::tags::patient_id, encoding::vr_type::LO, "TEST001");
    ds.set_string(core::tags::patient_birth_date, encoding::vr_type::DA, "19800101");
    ds.set_string(core::tags::patient_sex, encoding::vr_type::CS, "M");
 
    // Study module
    ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI,
                  study_uid.empty() ? generate_uid() : study_uid);
    ds.set_string(core::tags::study_date, encoding::vr_type::DA, "20240101");
    ds.set_string(core::tags::study_time, encoding::vr_type::TM, "120000");
    ds.set_string(core::tags::accession_number, encoding::vr_type::SH, "ACC001");
    ds.set_string(core::tags::study_id, encoding::vr_type::SH, "STUDY001");
    ds.set_string(core::tags::study_description, encoding::vr_type::LO, "Integration Test Study");
 
    // Series module
    ds.set_string(core::tags::series_instance_uid, encoding::vr_type::UI,
                  series_uid.empty() ? generate_uid() : series_uid);
    ds.set_string(core::tags::modality, encoding::vr_type::CS, "CT");
    ds.set_string(core::tags::series_number, encoding::vr_type::IS, "1");
    ds.set_string(core::tags::series_description, encoding::vr_type::LO, "Test Series");
 
    // SOP Common module
    ds.set_string(core::tags::sop_class_uid, encoding::vr_type::UI, "1.2.840.10008.5.1.4.1.1.2");  // CT Image Storage
    ds.set_string(core::tags::sop_instance_uid, encoding::vr_type::UI,
                  instance_uid.empty() ? generate_uid() : instance_uid);
 
    // Image module (minimal)
    ds.set_numeric<uint16_t>(core::tags::rows, encoding::vr_type::US, 64);
    ds.set_numeric<uint16_t>(core::tags::columns, encoding::vr_type::US, 64);
    ds.set_numeric<uint16_t>(core::tags::bits_allocated, encoding::vr_type::US, 16);
    ds.set_numeric<uint16_t>(core::tags::bits_stored, encoding::vr_type::US, 12);
    ds.set_numeric<uint16_t>(core::tags::high_bit, encoding::vr_type::US, 11);
    ds.set_numeric<uint16_t>(core::tags::pixel_representation, encoding::vr_type::US, 0);
    ds.set_numeric<uint16_t>(core::tags::samples_per_pixel, encoding::vr_type::US, 1);
    ds.set_string(core::tags::photometric_interpretation, encoding::vr_type::CS, "MONOCHROME2");
 
    // Generate minimal pixel data (64x64 16-bit)
    std::vector<uint16_t> pixel_data(64 * 64, 512);
    core::dicom_element pixel_elem(core::tags::pixel_data, encoding::vr_type::OW);
    pixel_elem.set_value(std::span<const uint8_t>(
        reinterpret_cast<const uint8_t*>(pixel_data.data()),
        pixel_data.size() * sizeof(uint16_t)));
    ds.insert(std::move(pixel_elem));
 
    return ds;
}
 
inline core::dicom_dataset generate_mr_dataset(const std::string& study_uid = "") {
    core::dicom_dataset ds;
 
    // Patient module
    ds.set_string(core::tags::patient_name, encoding::vr_type::PN, "TEST^MR^PATIENT");
    ds.set_string(core::tags::patient_id, encoding::vr_type::LO, "TESTMR001");
    ds.set_string(core::tags::patient_birth_date, encoding::vr_type::DA, "19900215");
    ds.set_string(core::tags::patient_sex, encoding::vr_type::CS, "F");
 
    // Study module
    ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI,
                  study_uid.empty() ? generate_uid() : study_uid);
    ds.set_string(core::tags::study_date, encoding::vr_type::DA, "20240115");
    ds.set_string(core::tags::study_time, encoding::vr_type::TM, "140000");
    ds.set_string(core::tags::accession_number, encoding::vr_type::SH, "ACCMR001");
    ds.set_string(core::tags::study_id, encoding::vr_type::SH, "STUDYMR001");
    ds.set_string(core::tags::study_description, encoding::vr_type::LO, "MR Integration Test");
 
    // Series module
    ds.set_string(core::tags::series_instance_uid, encoding::vr_type::UI, generate_uid());
    ds.set_string(core::tags::modality, encoding::vr_type::CS, "MR");
    ds.set_string(core::tags::series_number, encoding::vr_type::IS, "1");
    ds.set_string(core::tags::series_description, encoding::vr_type::LO, "T1 FLAIR");
 
    // SOP Common module
    ds.set_string(core::tags::sop_class_uid, encoding::vr_type::UI, "1.2.840.10008.5.1.4.1.1.4");  // MR Image Storage
    ds.set_string(core::tags::sop_instance_uid, encoding::vr_type::UI, generate_uid());
 
    // Image module (minimal)
    ds.set_numeric<uint16_t>(core::tags::rows, encoding::vr_type::US, 64);
    ds.set_numeric<uint16_t>(core::tags::columns, encoding::vr_type::US, 64);
    ds.set_numeric<uint16_t>(core::tags::bits_allocated, encoding::vr_type::US, 16);
    ds.set_numeric<uint16_t>(core::tags::bits_stored, encoding::vr_type::US, 12);
    ds.set_numeric<uint16_t>(core::tags::high_bit, encoding::vr_type::US, 11);
    ds.set_numeric<uint16_t>(core::tags::pixel_representation, encoding::vr_type::US, 0);
    ds.set_numeric<uint16_t>(core::tags::samples_per_pixel, encoding::vr_type::US, 1);
    ds.set_string(core::tags::photometric_interpretation, encoding::vr_type::CS, "MONOCHROME2");
 
    // Generate minimal pixel data
    std::vector<uint16_t> pixel_data(64 * 64, 256);
    core::dicom_element pixel_elem(core::tags::pixel_data, encoding::vr_type::OW);
    pixel_elem.set_value(std::span<const uint8_t>(
        reinterpret_cast<const uint8_t*>(pixel_data.data()),
        pixel_data.size() * sizeof(uint16_t)));
    ds.insert(std::move(pixel_elem));
 
    return ds;
}
 
inline core::dicom_dataset generate_xa_dataset(const std::string& study_uid = "") {
    core::dicom_dataset ds;
 
    // Patient module
    ds.set_string(core::tags::patient_name, encoding::vr_type::PN, "TEST^XA^PATIENT");
    ds.set_string(core::tags::patient_id, encoding::vr_type::LO, "TESTXA001");
    ds.set_string(core::tags::patient_birth_date, encoding::vr_type::DA, "19750610");
    ds.set_string(core::tags::patient_sex, encoding::vr_type::CS, "F");
 
    // Study module
    ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI,
                  study_uid.empty() ? generate_uid() : study_uid);
    ds.set_string(core::tags::study_date, encoding::vr_type::DA, "20240220");
    ds.set_string(core::tags::study_time, encoding::vr_type::TM, "103000");
    ds.set_string(core::tags::accession_number, encoding::vr_type::SH, "ACCXA001");
    ds.set_string(core::tags::study_id, encoding::vr_type::SH, "STUDYXA001");
    ds.set_string(core::tags::study_description, encoding::vr_type::LO, "XA Integration Test");
 
    // Series module
    ds.set_string(core::tags::series_instance_uid, encoding::vr_type::UI, generate_uid());
    ds.set_string(core::tags::modality, encoding::vr_type::CS, "XA");
    ds.set_string(core::tags::series_number, encoding::vr_type::IS, "1");
    ds.set_string(core::tags::series_description, encoding::vr_type::LO, "Coronary Angio");
 
    // SOP Common module
    ds.set_string(core::tags::sop_class_uid, encoding::vr_type::UI, "1.2.840.10008.5.1.4.1.1.12.1");  // XA Image Storage
    ds.set_string(core::tags::sop_instance_uid, encoding::vr_type::UI, generate_uid());
 
    // Image module
    ds.set_numeric<uint16_t>(core::tags::rows, encoding::vr_type::US, 512);
    ds.set_numeric<uint16_t>(core::tags::columns, encoding::vr_type::US, 512);
    ds.set_numeric<uint16_t>(core::tags::bits_allocated, encoding::vr_type::US, 16);
    ds.set_numeric<uint16_t>(core::tags::bits_stored, encoding::vr_type::US, 12);
    ds.set_numeric<uint16_t>(core::tags::high_bit, encoding::vr_type::US, 11);
    ds.set_numeric<uint16_t>(core::tags::pixel_representation, encoding::vr_type::US, 0);
    ds.set_numeric<uint16_t>(core::tags::samples_per_pixel, encoding::vr_type::US, 1);
    ds.set_string(core::tags::photometric_interpretation, encoding::vr_type::CS, "MONOCHROME2");
 
    // XA Specific
    // Note: Using raw tag numbers if constants are not defined yet
    // Positioner Primary Angle
    ds.set_string({0x0018, 0x1510}, encoding::vr_type::DS, "0");
    // Positioner Secondary Angle
    ds.set_string({0x0018, 0x1511}, encoding::vr_type::DS, "0");
    // KVP
    ds.set_string({0x0018, 0x0060}, encoding::vr_type::DS, "80");
    // X-Ray Tube Current
    ds.set_numeric<uint16_t>({0x0018, 0x1151}, encoding::vr_type::IS, 500);
    // Exposure Time
    ds.set_numeric<uint16_t>({0x0018, 0x1150}, encoding::vr_type::IS, 100);
 
    // Generate minimal pixel data
    std::vector<uint16_t> pixel_data(512 * 512, 128);
    core::dicom_element pixel_elem(core::tags::pixel_data, encoding::vr_type::OW);
    pixel_elem.set_value(std::span<const uint8_t>(
        reinterpret_cast<const uint8_t*>(pixel_data.data()),
        pixel_data.size() * sizeof(uint16_t)));
    ds.insert(std::move(pixel_elem));
 
    return ds;
}
 
inline core::dicom_dataset generate_worklist_item() {
    core::dicom_dataset ds;
 
    // Patient module
    ds.set_string(core::tags::patient_name, encoding::vr_type::PN, "WORKLIST^PATIENT");
    ds.set_string(core::tags::patient_id, encoding::vr_type::LO, "WL001");
    ds.set_string(core::tags::patient_birth_date, encoding::vr_type::DA, "19850520");
    ds.set_string(core::tags::patient_sex, encoding::vr_type::CS, "M");
 
    // Scheduled Procedure Step
    ds.set_string(core::tags::scheduled_procedure_step_start_date, encoding::vr_type::DA, "20240201");
    ds.set_string(core::tags::scheduled_procedure_step_start_time, encoding::vr_type::TM, "090000");
    ds.set_string(core::tags::modality, encoding::vr_type::CS, "CT");
    ds.set_string(core::tags::scheduled_station_ae_title, encoding::vr_type::AE, "CT_SCANNER");
    ds.set_string(core::tags::scheduled_procedure_step_description, encoding::vr_type::LO, "CT Chest");
 
    // Requested Procedure
    ds.set_string(core::tags::requested_procedure_id, encoding::vr_type::SH, "RP001");
    ds.set_string(core::tags::accession_number, encoding::vr_type::SH, "WLACC001");
    ds.set_string(core::tags::study_instance_uid, encoding::vr_type::UI, generate_uid());
 
    return ds;
}
 
// =============================================================================
// Test Server Fixture
// =============================================================================
 
class test_server {
public:
    explicit test_server(
        uint16_t port = 0,
        const std::string& ae_title = test_scp_ae_title)
        : port_(port == 0 ? find_available_port() : port)
        , ae_title_(ae_title) {
 
        network::server_config config;
        config.ae_title = ae_title_;
        config.port = port_;
        config.max_associations = 20;
        config.idle_timeout = std::chrono::seconds{60};
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.1";
        config.implementation_version_name = "TEST_SCP";
 
        server_ = std::make_unique<network::dicom_server>(config);
    }
 
    ~test_server() {
        stop();
    }
 
    // Non-copyable, non-movable
    test_server(const test_server&) = delete;
    test_server& operator=(const test_server&) = delete;
    test_server(test_server&&) = delete;
    test_server& operator=(test_server&&) = delete;
 
    template <typename Service>
    void register_service(std::shared_ptr<Service> service) {
        server_->register_service(std::move(service));
    }
 
    [[nodiscard]] bool start() {
        auto result = server_->start();
        if (!result.is_ok()) {
            return false;
        }
 
        running_ = true;
 
        // Wait for port to actually be listening
        // This is more reliable than a fixed delay, especially in CI
        auto timeout = server_ready_timeout();
        auto start_time = std::chrono::steady_clock::now();
 
        while (std::chrono::steady_clock::now() - start_time < timeout) {
            if (check_port_listening(port_)) {
                return true;
            }
            std::this_thread::sleep_for(std::chrono::milliseconds{50});
        }
 
        // Timeout waiting for port - stop the server and return failure
        server_->stop();
        running_ = false;
        return false;
    }
 
    void stop() {
        if (running_) {
            server_->stop();
            running_ = false;
        }
    }
 
    [[nodiscard]] uint16_t port() const noexcept { return port_; }
 
    [[nodiscard]] const std::string& ae_title() const noexcept { return ae_title_; }
 
    [[nodiscard]] bool is_running() const noexcept { return running_; }
 
    [[nodiscard]] network::dicom_server& server() { return *server_; }
 
private:
    static bool check_port_listening(uint16_t port) {
        const long timeout_us = is_ci_environment() ? 1000000 : 200000;
 
#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; }
 
        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("127.0.0.1");
 
        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);
        int result = select(0, nullptr, &writefds, nullptr, &tv);
 
        bool listening = false;
        if (result > 0) {
            int error = 0;
            int len = sizeof(error);
            getsockopt(sock, SOL_SOCKET, SO_ERROR, reinterpret_cast<char*>(&error), &len);
            listening = (error == 0);
        }
        closesocket(sock);
        WSACleanup();
        return listening;
#else
        int sock = socket(AF_INET, SOCK_STREAM, 0);
        if (sock < 0) return false;
 
        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);
        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
 
        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);
        int result = select(sock + 1, nullptr, &writefds, nullptr, &tv);
 
        bool listening = false;
        if (result > 0) {
            int error = 0;
            socklen_t len = sizeof(error);
            getsockopt(sock, SOL_SOCKET, SO_ERROR, &error, &len);
            listening = (error == 0);
        }
        close(sock);
        return listening;
#endif
    }
 
    uint16_t port_;
    std::string ae_title_;
    std::unique_ptr<network::dicom_server> server_;
    bool running_{false};
};
 
// =============================================================================
// Test Association Helper
// =============================================================================
 
class test_association {
public:
    static network::Result<network::association> connect(
        const std::string& host,
        uint16_t port,
        const std::string& called_ae,
        const std::string& calling_ae = test_scu_ae_title,
        const std::vector<std::string>& sop_classes = {"1.2.840.10008.1.1"}) {
 
        network::association_config config;
        config.calling_ae_title = calling_ae;
        config.called_ae_title = called_ae;
        config.implementation_class_uid = "1.2.826.0.1.3680043.9.9999.2";
        config.implementation_version_name = "TEST_SCU";
 
        uint8_t context_id = 1;
        for (const auto& sop_class : sop_classes) {
            config.proposed_contexts.push_back({
                context_id,
                sop_class,
                {
                    "1.2.840.10008.1.2.1",  // Explicit VR Little Endian
                    "1.2.840.10008.1.2"     // Implicit VR Little Endian
                }
            });
            context_id += 2;
        }
 
        return network::association::connect(host, port, config, default_timeout());
    }
};
 
// =============================================================================
// Test Data Directory
// =============================================================================
 
class test_directory {
public:
    explicit test_directory(const std::string& prefix = "pacs_test_") {
        auto temp_base = std::filesystem::temp_directory_path();
        path_ = temp_base / (prefix + std::to_string(
            std::chrono::system_clock::now().time_since_epoch().count()));
        std::filesystem::create_directories(path_);
    }
 
    ~test_directory() {
        if (std::filesystem::exists(path_)) {
            std::filesystem::remove_all(path_);
        }
    }
 
    // Non-copyable, non-movable
    test_directory(const test_directory&) = delete;
    test_directory& operator=(const test_directory&) = delete;
    test_directory(test_directory&&) = delete;
    test_directory& operator=(test_directory&&) = delete;
 
    [[nodiscard]] const std::filesystem::path& path() const noexcept { return path_; }
 
    [[nodiscard]] std::string string() const { return path_.string(); }
 
private:
    std::filesystem::path path_;
};
 
// =============================================================================
// Test Result Counters
// =============================================================================
 
class test_counter {
public:
    void increment_success() { ++success_; }
    void increment_failure() { ++failure_; }
    void increment_warning() { ++warning_; }
 
    [[nodiscard]] size_t success() const noexcept { return success_.load(); }
    [[nodiscard]] size_t failure() const noexcept { return failure_.load(); }
    [[nodiscard]] size_t warning() const noexcept { return warning_.load(); }
    [[nodiscard]] size_t total() const noexcept {
        return success_.load() + failure_.load() + warning_.load();
    }
 
    void reset() {
        success_ = 0;
        failure_ = 0;
        warning_ = 0;
    }
 
private:
    std::atomic<size_t> success_{0};
    std::atomic<size_t> failure_{0};
    std::atomic<size_t> warning_{0};
};
 
// =============================================================================
// Process Launcher for Binary Integration Tests
// =============================================================================
 
struct process_result {
    int exit_code{-1};                      
    std::string stdout_output;               
    std::string stderr_output;               
    std::chrono::milliseconds duration{0};   
    bool timed_out{false};                   
};
 
class process_launcher {
public:
    static process_result run(
        const std::string& executable,
        const std::vector<std::string>& args = {},
        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;
    }
 
#ifdef _WIN32
    using pid_type = DWORD;
#else
    using pid_type = pid_t;
#endif
 
    static constexpr pid_type invalid_pid = 0;
 
    static pid_type start_background(
        const std::string& executable,
        const std::vector<std::string>& args = {}) {
 
#ifdef _WIN32
        return start_background_windows(executable, args);
#else
        return start_background_posix(executable, args);
#endif
    }
 
    static bool stop_background(pid_type pid) {
#ifdef _WIN32
        return stop_background_windows(pid);
#else
        return stop_background_posix(pid);
#endif
    }
 
    static bool is_running(pid_type pid) {
#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
    }
 
    static bool wait_for_port(
        uint16_t port,
        std::chrono::seconds timeout = std::chrono::seconds{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);
        }
    }
 
    static bool is_port_listening(uint16_t port, const std::string& host = "127.0.0.1") {
        // 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
    }
 
private:
#ifndef _WIN32
    // POSIX implementation
    static process_result run_posix(
        const std::string& executable,
        const std::vector<std::string>& args,
        std::chrono::seconds timeout) {
 
        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;
    }
 
    static pid_t start_background_posix(
        const std::string& executable,
        const std::vector<std::string>& args) {
 
        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;
    }
 
    static bool stop_background_posix(pid_t pid) {
        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;
    }
#else
    // Windows implementation
    static process_result run_windows(
        const std::string& executable,
        const std::vector<std::string>& args,
        std::chrono::seconds timeout) {
 
        process_result result;
 
        // Build command line
        std::ostringstream cmd;
        cmd << "\"" << executable << "\"";
        for (const auto& arg : args) {
            cmd << " \"" << arg << "\"";
        }
        std::string cmd_line = cmd.str();
 
        // Create pipes for stdout and stderr
        SECURITY_ATTRIBUTES sa{};
        sa.nLength = sizeof(sa);
        sa.bInheritHandle = TRUE;
        sa.lpSecurityDescriptor = nullptr;
 
        HANDLE stdout_read, stdout_write;
        HANDLE stderr_read, stderr_write;
 
        if (!CreatePipe(&stdout_read, &stdout_write, &sa, 0) ||
            !CreatePipe(&stderr_read, &stderr_write, &sa, 0)) {
            result.exit_code = -1;
            result.stderr_output = "Failed to create pipes";
            return result;
        }
 
        SetHandleInformation(stdout_read, HANDLE_FLAG_INHERIT, 0);
        SetHandleInformation(stderr_read, HANDLE_FLAG_INHERIT, 0);
 
        STARTUPINFOA si{};
        si.cb = sizeof(si);
        si.dwFlags = STARTF_USESTDHANDLES;
        si.hStdOutput = stdout_write;
        si.hStdError = stderr_write;
        si.hStdInput = nullptr;
 
        PROCESS_INFORMATION pi{};
 
        if (!CreateProcessA(
                nullptr,
                const_cast<char*>(cmd_line.c_str()),
                nullptr,
                nullptr,
                TRUE,
                0,
                nullptr,
                nullptr,
                &si,
                &pi)) {
            result.exit_code = -1;
            result.stderr_output = "Failed to create process";
            CloseHandle(stdout_read);
            CloseHandle(stdout_write);
            CloseHandle(stderr_read);
            CloseHandle(stderr_write);
            return result;
        }
 
        CloseHandle(stdout_write);
        CloseHandle(stderr_write);
 
        // Wait for process with timeout
        DWORD timeout_ms = static_cast<DWORD>(
            std::chrono::duration_cast<std::chrono::milliseconds>(timeout).count());
        DWORD wait_result = WaitForSingleObject(pi.hProcess, timeout_ms);
 
        if (wait_result == WAIT_TIMEOUT) {
            TerminateProcess(pi.hProcess, 1);
            result.timed_out = true;
            result.exit_code = -1;
        } else {
            DWORD exit_code;
            GetExitCodeProcess(pi.hProcess, &exit_code);
            result.exit_code = static_cast<int>(exit_code);
        }
 
        // Read output
        char buffer[4096];
        DWORD bytes_read;
 
        while (ReadFile(stdout_read, buffer, sizeof(buffer) - 1, &bytes_read, nullptr) && bytes_read > 0) {
            buffer[bytes_read] = '\0';
            result.stdout_output += buffer;
        }
 
        while (ReadFile(stderr_read, buffer, sizeof(buffer) - 1, &bytes_read, nullptr) && bytes_read > 0) {
            buffer[bytes_read] = '\0';
            result.stderr_output += buffer;
        }
 
        CloseHandle(stdout_read);
        CloseHandle(stderr_read);
        CloseHandle(pi.hProcess);
        CloseHandle(pi.hThread);
 
        return result;
    }
 
    static DWORD start_background_windows(
        const std::string& executable,
        const std::vector<std::string>& args) {
 
        std::ostringstream cmd;
        cmd << "\"" << executable << "\"";
        for (const auto& arg : args) {
            cmd << " \"" << arg << "\"";
        }
        std::string cmd_line = cmd.str();
 
        STARTUPINFOA si{};
        si.cb = sizeof(si);
 
        PROCESS_INFORMATION pi{};
 
        if (!CreateProcessA(
                nullptr,
                const_cast<char*>(cmd_line.c_str()),
                nullptr,
                nullptr,
                FALSE,
                DETACHED_PROCESS,
                nullptr,
                nullptr,
                &si,
                &pi)) {
            return 0;
        }
 
        CloseHandle(pi.hThread);
        DWORD pid = pi.dwProcessId;
        CloseHandle(pi.hProcess);
 
        return pid;
    }
 
    static bool stop_background_windows(DWORD pid) {
        if (pid == 0) {
            return false;
        }
 
        HANDLE process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE, FALSE, pid);
        if (process == nullptr) {
            return GetLastError() == ERROR_INVALID_PARAMETER;  // Process already gone
        }
 
        TerminateProcess(process, 0);
        WaitForSingleObject(process, 5000);
        CloseHandle(process);
 
        return true;
    }
#endif
};
 
class background_process_guard {
public:
    explicit background_process_guard(
        process_launcher::pid_type pid = process_launcher::invalid_pid)
        : pid_(pid) {}
 
    ~background_process_guard() {
        stop();
    }
 
    // Non-copyable
    background_process_guard(const background_process_guard&) = delete;
    background_process_guard& operator=(const background_process_guard&) = delete;
 
    // Movable
    background_process_guard(background_process_guard&& other) noexcept
        : pid_(other.pid_) {
        other.pid_ = process_launcher::invalid_pid;
    }
 
    background_process_guard& operator=(background_process_guard&& other) noexcept {
        if (this != &other) {
            stop();
            pid_ = other.pid_;
            other.pid_ = process_launcher::invalid_pid;
        }
        return *this;
    }
 
    void set_pid(process_launcher::pid_type pid) { pid_ = pid; }
 
    [[nodiscard]] process_launcher::pid_type pid() const noexcept { return pid_; }
 
    [[nodiscard]] bool is_running() const {
        return pid_ > 0 && process_launcher::is_running(pid_);
    }
 
    void stop() {
        if (pid_ > 0) {
            process_launcher::stop_background(pid_);
            pid_ = process_launcher::invalid_pid;
        }
    }
 
    process_launcher::pid_type release() {
        auto p = pid_;
        pid_ = process_launcher::invalid_pid;
        return p;
    }
 
private:
    process_launcher::pid_type pid_{process_launcher::invalid_pid};
};
 
}  // namespace kcenon::pacs::integration_test
 
#endif  // PACS_INTEGRATION_TESTS_TEST_FIXTURES_HPP