C-STORE interoperability tests with DCMTK. More...

#include <catch2/catch_test_macros.hpp>
#include "dcmtk_tool.h"
#include "test_fixtures.h"
#include "kcenon/pacs/core/dicom_file.h"
#include "kcenon/pacs/encoding/transfer_syntax.h"
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/storage_scp.h"
#include "kcenon/pacs/services/storage_scu.h"
#include <atomic>
#include <filesystem>
#include <future>
#include <mutex>
#include <thread>
#include <vector>

Include dependency graph for test_dcmtk_store.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("C-STORE: pacs_system SCP receives from DCMTK storescu", "[dcmtk][interop][store]")

	TEST_CASE ("C-STORE: DCMTK storescp receives from pacs_system SCU", "[dcmtk][interop][store]")

	TEST_CASE ("C-STORE: Bidirectional round-trip verification", "[dcmtk][interop][store]")

	TEST_CASE ("C-STORE: Concurrent store operations", "[dcmtk][interop][store][stress]")

	TEST_CASE ("C-STORE: Error handling", "[dcmtk][interop][store][error]")

	TEST_CASE ("C-STORE: Data integrity verification", "[dcmtk][interop][store][integrity]")

Detailed Description

C-STORE interoperability tests with DCMTK.

Tests bidirectional C-STORE compatibility between pacs_system and DCMTK:

Scenario A: pacs_system SCP <- DCMTK storescu
Scenario B: DCMTK storescp <- pacs_system SCU

See also: Issue #452 - C-STORE Bidirectional Interoperability Test with DCMTK; Issue #449 - DCMTK Interoperability Test Automation Epic

Definition in file test_dcmtk_store.cpp.

Function Documentation

◆ TEST_CASE() [1/6]

TEST_CASE	(	"C-STORE: Bidirectional round-trip verification"	,
		""	[dcmtk][interop][store] )

Definition at line 357 of file test_dcmtk_store.cpp.

                  : Bidirectional round-trip verification",
          "[dcmtk][interop][store]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    test_directory original_dir;
    test_directory dcmtk_storage_dir;
 
    auto pacs_port = find_available_port();
    auto dcmtk_port = find_available_port();
 
    // Setup pacs_system storage server
    storage_test_server pacs_server(pacs_port, "PACS_SCP");
    REQUIRE(pacs_server.start());
 
    // Start DCMTK storescp
    auto dcmtk_server = dcmtk_tool::storescp(
        dcmtk_port, "DCMTK_SCP", dcmtk_storage_dir.path());
    REQUIRE(dcmtk_server.is_running());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(dcmtk_port);
    }, dcmtk_server_ready_timeout()));
 
    SECTION("DCMTK -> pacs_system -> DCMTK round-trip") {
        // Create original test file
        auto original_file = create_test_dicom(
            original_dir.path(), "original.dcm", "CT");
 
        // Read original for comparison
        auto original_result = dicom_file::open(original_file);
        REQUIRE(original_result.is_ok());
        auto orig_uid = original_result.value().dataset().get_string(
            tags::sop_instance_uid);
        REQUIRE_FALSE(orig_uid.empty());
 
        // Step 1: DCMTK storescu -> pacs_system SCP
        auto store1 = dcmtk_tool::storescu(
            "localhost", pacs_port, "PACS_SCP", {original_file});
        REQUIRE(store1.success());
        REQUIRE(pacs_server.stored_count() >= 1);
 
        // Get the stored files
        auto pacs_files = pacs_server.stored_files();
        REQUIRE(pacs_files.size() >= 1);
 
        // Step 2: pacs_system SCU -> DCMTK storescp
        auto read_result = dicom_file::open(pacs_files[0]);
        REQUIRE(read_result.is_ok());
 
        // Establish association with DCMTK storescp
        auto connect_result = test_association::connect(
            "localhost", dcmtk_port, "DCMTK_SCP", "PACS_SCU",
            {"1.2.840.10008.5.1.4.1.1.2"});  // CT Image Storage
        REQUIRE(connect_result.is_ok());
 
        auto& assoc = connect_result.value();
        storage_scu scu;
        auto send_result = scu.store(assoc, read_result.value().dataset());
        REQUIRE(send_result.is_ok());
        (void)assoc.release(default_timeout());
 
        // Verify DCMTK received the file
        std::this_thread::sleep_for(std::chrono::milliseconds{500});
        auto dcmtk_files = find_dicom_files(dcmtk_storage_dir.path());
        REQUIRE(dcmtk_files.size() >= 1);
 
        // Verify data integrity through round-trip
        auto final_result = dicom_file::open(dcmtk_files[0]);
        REQUIRE(final_result.is_ok());
 
        auto final_uid = final_result.value().dataset().get_string(
            tags::sop_instance_uid);
        REQUIRE_FALSE(final_uid.empty());
 
        // UIDs should match
        REQUIRE(final_uid == orig_uid);
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [2/6]

TEST_CASE	(	"C-STORE: Concurrent store operations"	,
		""	[dcmtk][interop][store][stress] )

Definition at line 447 of file test_dcmtk_store.cpp.

                  : Concurrent store operations", "[dcmtk][interop][store][stress]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto port = find_available_port();
    test_directory input_dir;
 
    // Setup storage server
    storage_test_server server(port, "STRESS_SCP");
    REQUIRE(server.start());
 
    SECTION("3 concurrent DCMTK storescu clients") {
        constexpr int num_clients = 3;
 
        // Create test files for each client
        std::vector<fs::path> files;
        for (int i = 0; i < num_clients; ++i) {
            auto file = create_test_dicom(
                input_dir.path(),
                "client_" + std::to_string(i) + ".dcm",
                "CT");
            files.push_back(file);
        }
 
        // Launch concurrent stores
        std::vector<std::future<dcmtk_result>> futures;
        for (int i = 0; i < num_clients; ++i) {
            futures.push_back(std::async(std::launch::async, [&, i]() {
                return dcmtk_tool::storescu(
                    "localhost", port, "STRESS_SCP",
                    {files[static_cast<size_t>(i)]},
                    "CLIENT_" + std::to_string(i));
            }));
        }
 
        // All should succeed
        for (size_t i = 0; i < futures.size(); ++i) {
            auto result = futures[i].get();
 
            INFO("Client " << i << " stdout: " << result.stdout_output);
            INFO("Client " << i << " stderr: " << result.stderr_output);
 
            REQUIRE(result.success());
        }
 
        // Verify all files were stored
        REQUIRE(server.stored_count() >= static_cast<size_t>(num_clients));
    }
}

References kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::test_directory::path(), kcenon::pacs::integration_test::dcmtk_tool::storescu(), and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

◆ TEST_CASE() [3/6]

TEST_CASE	(	"C-STORE: Data integrity verification"	,
		""	[dcmtk][interop][store][integrity] )

Definition at line 557 of file test_dcmtk_store.cpp.

                  : Data integrity verification", "[dcmtk][interop][store][integrity]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto port = find_available_port();
    test_directory input_dir;
 
    // Setup storage server
    storage_test_server server(port, "INTEGRITY_SCP");
    REQUIRE(server.start());
 
    SECTION("Patient demographics preserved") {
        // Create test file with specific patient data
        dicom_dataset ds = generate_ct_dataset();
        ds.set_string(tags::patient_name, vr_type::PN, "INTEGRITY^TEST^PATIENT");
        ds.set_string(tags::patient_id, vr_type::LO, "INTEG001");
 
        auto test_file = input_dir.path() / "integrity_test.dcm";
        auto file = dicom_file::create(
            std::move(ds),
            transfer_syntax::explicit_vr_little_endian);
        auto write_result = file.save(test_file);
        REQUIRE(write_result.is_ok());
 
        // Store via DCMTK
        auto result = dcmtk_tool::storescu(
            "localhost", port, "INTEGRITY_SCP", {test_file});
        REQUIRE(result.success());
 
        // Verify stored data
        auto stored_files = server.stored_files();
        REQUIRE(stored_files.size() >= 1);
 
        auto stored_result = dicom_file::open(stored_files[0]);
        REQUIRE(stored_result.is_ok());
 
        auto& stored_ds = stored_result.value().dataset();
 
        auto stored_name = stored_ds.get_string(tags::patient_name);
        auto stored_id = stored_ds.get_string(tags::patient_id);
 
        REQUIRE_FALSE(stored_name.empty());
        REQUIRE_FALSE(stored_id.empty());
        REQUIRE(stored_name == "INTEGRITY^TEST^PATIENT");
        REQUIRE(stored_id == "INTEG001");
    }
}

References kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::generate_ct_dataset(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::test_directory::path(), kcenon::pacs::core::dicom_dataset::set_string(), kcenon::pacs::integration_test::dcmtk_tool::storescu(), and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

◆ TEST_CASE() [4/6]

TEST_CASE	(	"C-STORE: DCMTK storescp receives from pacs_system SCU"	,
		""	[dcmtk][interop][store] )

Definition at line 265 of file test_dcmtk_store.cpp.

                  : DCMTK storescp receives from pacs_system SCU",
          "[dcmtk][interop][store]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed - skipping interoperability test");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto port = find_available_port();
    test_directory storage_dir;
    test_directory input_dir;
 
    // Start DCMTK storescp
    auto dcmtk_server = dcmtk_tool::storescp(port, "DCMTK_SCP", storage_dir.path());
    REQUIRE(dcmtk_server.is_running());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, dcmtk_server_ready_timeout()));
 
    SECTION("Single image via storage_scu") {
        auto test_file = create_test_dicom(input_dir.path(), "test.dcm", "CT");
 
        auto file_result = dicom_file::open(test_file);
        REQUIRE(file_result.is_ok());
 
        // Get SOP Class UID from the dataset
        auto sop_class = file_result.value().dataset().get_string(tags::sop_class_uid);
        REQUIRE_FALSE(sop_class.empty());
 
        // Establish association with DCMTK storescp
        auto connect_result = test_association::connect(
            "localhost", port, "DCMTK_SCP", "PACS_SCU", {sop_class});
        REQUIRE(connect_result.is_ok());
 
        auto& assoc = connect_result.value();
        storage_scu scu;
        auto send_result = scu.store(assoc, file_result.value().dataset());
        REQUIRE(send_result.is_ok());
 
        (void)assoc.release(default_timeout());
 
        // Wait for DCMTK to write the file
        std::this_thread::sleep_for(std::chrono::milliseconds{500});
        auto received = find_dicom_files(storage_dir.path());
        REQUIRE(received.size() >= 1);
    }
 
    SECTION("Multiple images via storage_scu") {
        // Load all datasets first to get SOP Class UIDs
        std::vector<std::pair<fs::path, dicom_file>> files;
        for (int i = 0; i < 3; ++i) {
            auto test_file = create_test_dicom(
                input_dir.path(),
                "test_" + std::to_string(i) + ".dcm",
                "CT");
 
            auto file_result = dicom_file::open(test_file);
            REQUIRE(file_result.is_ok());
            files.emplace_back(test_file, std::move(file_result.value()));
        }
 
        // Establish association
        auto connect_result = test_association::connect(
            "localhost", port, "DCMTK_SCP", "PACS_SCU",
            {"1.2.840.10008.5.1.4.1.1.2"});  // CT Image Storage
        REQUIRE(connect_result.is_ok());
 
        auto& assoc = connect_result.value();
        storage_scu scu;
 
        for (size_t i = 0; i < files.size(); ++i) {
            auto send_result = scu.store(assoc, files[i].second.dataset());
            INFO("Sending file " << i);
            REQUIRE(send_result.is_ok());
        }
 
        (void)assoc.release(default_timeout());
 
        std::this_thread::sleep_for(std::chrono::milliseconds{500});
        auto received = find_dicom_files(storage_dir.path());
        REQUIRE(received.size() >= 3);
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [5/6]

TEST_CASE	(	"C-STORE: Error handling"	,
		""	[dcmtk][interop][store][error] )

Definition at line 507 of file test_dcmtk_store.cpp.

                  : Error handling", "[dcmtk][interop][store][error]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    SECTION("storescu to non-existent server fails gracefully") {
        auto port = find_available_port();
        test_directory input_dir;
 
        REQUIRE_FALSE(process_launcher::is_port_listening(port));
 
        auto test_file = create_test_dicom(input_dir.path(), "test.dcm", "CT");
 
        auto result = dcmtk_tool::storescu(
            "localhost", port, "NONEXISTENT", {test_file},
            "STORESCU", std::chrono::seconds{5});
 
        REQUIRE_FALSE(result.success());
    }
 
    SECTION("pacs_system SCU to non-existent server fails gracefully") {
        // Use a high port range that's less likely to have conflicts
        auto port = find_available_port(59000);
 
        // Wait briefly and re-verify the port is truly free
        std::this_thread::sleep_for(std::chrono::milliseconds{100});
 
        // Ensure nothing is listening on this port
        if (process_launcher::is_port_listening(port)) {
            SKIP("Port " + std::to_string(port) + " is unexpectedly in use");
        }
 
        // Connection should fail - no server listening
        auto connect_result = test_association::connect(
            "localhost", port, "NONEXISTENT", "PACS_SCU",
            {"1.2.840.10008.5.1.4.1.1.2"});  // CT Image Storage
 
        REQUIRE_FALSE(connect_result.is_ok());
    }
}

References kcenon::pacs::integration_test::test_association::connect(), kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::process_launcher::is_port_listening(), kcenon::pacs::integration_test::test_directory::path(), kcenon::pacs::integration_test::dcmtk_tool::storescu(), and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

◆ TEST_CASE() [6/6]

TEST_CASE	(	"C-STORE: pacs_system SCP receives from DCMTK storescu"	,
		""	[dcmtk][interop][store] )

Definition at line 183 of file test_dcmtk_store.cpp.

                  : pacs_system SCP receives from DCMTK storescu",
          "[dcmtk][interop][store]") {
    if (!dcmtk_tool::is_available()) {
        SKIP("DCMTK not installed - skipping interoperability test");
    }
 
    // Skip if real TCP DICOM connections are not supported yet
    if (!supports_real_tcp_dicom()) {
        SKIP("pacs_system does not support real TCP DICOM connections yet");
    }
 
    auto port = find_available_port();
    test_directory input_dir;
 
    // Setup storage server
    storage_test_server server(port, "PACS_STORE");
    REQUIRE(server.start());
 
    SECTION("Single CT image storage") {
        auto test_file = create_test_dicom(input_dir.path(), "test_ct.dcm", "CT");
 
        auto result = dcmtk_tool::storescu(
            "localhost", port, "PACS_STORE", {test_file});
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
        REQUIRE(server.stored_count() >= 1);
    }
 
    SECTION("MR image storage") {
        auto test_file = create_test_dicom(input_dir.path(), "test_mr.dcm", "MR");
 
        auto result = dcmtk_tool::storescu(
            "localhost", port, "PACS_STORE", {test_file});
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
        REQUIRE(server.stored_count() >= 1);
    }
 
    SECTION("Multiple images in single association") {
        std::vector<fs::path> files;
        for (int i = 0; i < 3; ++i) {
            auto file = create_test_dicom(
                input_dir.path(),
                "test_" + std::to_string(i) + ".dcm",
                "CT");
            files.push_back(file);
        }
 
        auto result = dcmtk_tool::storescu(
            "localhost", port, "PACS_STORE", files);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
        REQUIRE(server.stored_count() >= 3);
    }
 
    SECTION("Multiple modality images") {
        std::vector<fs::path> files;
        files.push_back(create_test_dicom(input_dir.path(), "ct.dcm", "CT"));
        files.push_back(create_test_dicom(input_dir.path(), "mr.dcm", "MR"));
        files.push_back(create_test_dicom(input_dir.path(), "xa.dcm", "XA"));
 
        auto result = dcmtk_tool::storescu(
            "localhost", port, "PACS_STORE", files);
 
        REQUIRE(result.success());
        REQUIRE(server.stored_count() >= 3);
    }
}

References kcenon::pacs::integration_test::find_available_port(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::test_directory::path(), kcenon::pacs::integration_test::dcmtk_tool::storescu(), and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

Functions

Detailed Description

Function Documentation

◆ TEST_CASE() [1/6]

◆ TEST_CASE() [2/6]

◆ TEST_CASE() [3/6]

◆ TEST_CASE() [4/6]

◆ TEST_CASE() [5/6]

◆ TEST_CASE() [6/6]