C-FIND (Query) interoperability tests with DCMTK. More...

#include <catch2/catch_test_macros.hpp>
#include "dcmtk_tool.h"
#include "test_fixtures.h"
#include "kcenon/pacs/core/dicom_dataset.h"
#include "kcenon/pacs/core/dicom_tag_constants.h"
#include "kcenon/pacs/encoding/transfer_syntax.h"
#include "kcenon/pacs/network/dimse/dimse_message.h"
#include "kcenon/pacs/services/query_scp.h"
#include "kcenon/pacs/services/storage_scp.h"
#include "kcenon/pacs/services/verification_scp.h"
#include <future>
#include <mutex>
#include <set>
#include <thread>
#include <vector>

Include dependency graph for test_dcmtk_find.cpp:

Go to the source code of this file.

Functions
	TEST_CASE ("C-FIND: pacs_system SCP with DCMTK findscu", "[dcmtk][interop][find]")

	TEST_CASE ("C-FIND: pacs_system SCU query operations", "[dcmtk][interop][find]")

	TEST_CASE ("C-FIND: Concurrent query operations", "[dcmtk][interop][find][stress]")

	TEST_CASE ("C-FIND: Connection error handling", "[dcmtk][interop][find][error]")

	TEST_CASE ("C-FIND: Query level variations", "[dcmtk][interop][find][levels]")

	TEST_CASE ("C-FIND: Special character handling", "[dcmtk][interop][find][special]")

Detailed Description

C-FIND (Query) interoperability tests with DCMTK.

Tests bidirectional C-FIND compatibility between pacs_system and DCMTK:

Scenario A: pacs_system SCP <- DCMTK findscu
Scenario B: DCMTK SCP <- pacs_system SCU (using association)

See also: Issue #453 - C-FIND Interoperability Test with DCMTK; Issue #449 - DCMTK Interoperability Test Automation Epic

Definition in file test_dcmtk_find.cpp.

Function Documentation

◆ TEST_CASE() [1/6]

TEST_CASE	(	"C-FIND: Concurrent query operations"	,
		""	[dcmtk][interop][find][stress] )

Definition at line 592 of file test_dcmtk_find.cpp.

                 : Concurrent query operations", "[dcmtk][interop][find][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();
    const std::string ae_title = "STRESS_FIND_SCP";
 
    test_query_database db;
    for (int i = 0; i < 10; ++i) {
        db.add_study(create_test_study(
            "PAT" + std::to_string(i),
            "PATIENT^" + std::to_string(i),
            "20240" + std::to_string(100 + i),
            "CT"));
    }
 
    test_server server(port, ae_title);
 
    auto query_scp_ptr = std::make_shared<query_scp>();
    query_scp_ptr->set_handler([&db](
        query_level /* level */,
        const dicom_dataset& query_keys,
        const std::string& /* calling_ae */) -> std::vector<dicom_dataset> {
        return db.find_studies(query_keys);
    });
    server.register_service(query_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("3 concurrent DCMTK findscu clients") {
        constexpr int num_clients = 3;
        std::vector<std::future<dcmtk_result>> futures;
        futures.reserve(num_clients);
 
        for (int i = 0; i < num_clients; ++i) {
            futures.push_back(std::async(std::launch::async, [&, i]() {
                std::vector<std::pair<std::string, std::string>> keys = {
                    {"PatientID", ""},
                    {"StudyInstanceUID", ""}
                };
                return dcmtk_tool::findscu(
                    "localhost", port, ae_title, "STUDY", keys,
                    "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());
        }
    }
 
    SECTION("3 concurrent pacs_system SCU clients") {
        constexpr int num_clients = 3;
        std::vector<std::future<bool>> futures;
        futures.reserve(num_clients);
 
        for (int i = 0; i < num_clients; ++i) {
            futures.push_back(std::async(std::launch::async, [&, i]() {
                auto connect_result = test_association::connect(
                    "localhost", port, ae_title,
                    "PACS_CLIENT_" + std::to_string(i),
                    {std::string(study_root_find_sop_class_uid)});
 
                if (!connect_result.is_ok()) return false;
 
                auto& assoc = connect_result.value();
                auto context_id = assoc.accepted_context_id(study_root_find_sop_class_uid);
                if (!context_id.has_value()) return false;
 
                dicom_dataset query_keys;
                query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
                query_keys.set_string(tags::patient_id, vr_type::LO, "");
                query_keys.set_string(tags::study_instance_uid, vr_type::UI, "");
 
                auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
                find_rq.set_dataset(std::move(query_keys));
                auto send_result = assoc.send_dimse(*context_id, find_rq);
                if (!send_result.is_ok()) return false;
 
                // Receive all responses
                while (true) {
                    auto recv_result = assoc.receive_dimse();
                    if (!recv_result.is_ok()) return false;
 
                    auto& [recv_ctx, rsp] = recv_result.value();
                    if (rsp.status() == status_success) break;
                    if (rsp.status() != status_pending) return false;
                }
 
                return true;
            }));
        }
 
        // All should succeed
        for (size_t i = 0; i < futures.size(); ++i) {
            bool success = futures[i].get();
            INFO("Client " << i);
            REQUIRE(success);
        }
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [2/6]

TEST_CASE	(	"C-FIND: Connection error handling"	,
		""	[dcmtk][interop][find][error] )

Definition at line 713 of file test_dcmtk_find.cpp.

                 : Connection error handling", "[dcmtk][interop][find][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("findscu to non-existent server fails gracefully") {
        auto port = find_available_port();
 
        // Ensure nothing is listening
        REQUIRE_FALSE(process_launcher::is_port_listening(port));
 
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, "NONEXISTENT", "STUDY", keys,
            "FINDSCU", std::chrono::seconds{5});
 
        // Should fail - no server listening
        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
        if (process_launcher::is_port_listening(port)) {
            SKIP("Port " + std::to_string(port) + " is unexpectedly in use");
        }
 
        auto connect_result = test_association::connect(
            "localhost", port, "NONEXISTENT", "PACS_SCU",
            {std::string(study_root_find_sop_class_uid)});
 
        // Should fail - no server listening
        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::findscu(), kcenon::pacs::integration_test::dcmtk_tool::is_available(), kcenon::pacs::integration_test::process_launcher::is_port_listening(), kcenon::pacs::services::study_root_find_sop_class_uid, and kcenon::pacs::integration_test::supports_real_tcp_dicom().

Here is the call graph for this function:

◆ TEST_CASE() [3/6]

TEST_CASE	(	"C-FIND: pacs_system SCP with DCMTK findscu"	,
		""	[dcmtk][interop][find] )

Definition at line 251 of file test_dcmtk_find.cpp.

                 : pacs_system SCP with DCMTK findscu", "[dcmtk][interop][find]") {
    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");
    }
 
    // Setup: Start pacs_system query server with test data
    auto port = find_available_port();
    const std::string ae_title = "PACS_FIND_SCP";
 
    test_query_database db;
 
    // Populate test data
    db.add_study(create_test_study("PAT001", "SMITH^JOHN", "20231201", "CT"));
    db.add_study(create_test_study("PAT002", "SMITH^JANE", "20231215", "MR"));
    db.add_study(create_test_study("PAT003", "JONES^WILLIAM", "20240101", "CT"));
    db.add_study(create_test_study("PAT004", "BROWN^ALICE", "20240115", "XA"));
 
    test_server server(port, ae_title);
 
    // Register query SCP with handler
    auto query_scp_ptr = std::make_shared<query_scp>();
    query_scp_ptr->set_handler([&db](
        query_level level,
        const dicom_dataset& query_keys,
        const std::string& /* calling_ae */) -> std::vector<dicom_dataset> {
 
        if (level == query_level::patient) {
            return db.find_patients(query_keys);
        }
        return db.find_studies(query_keys);
    });
    server.register_service(query_scp_ptr);
    server.register_service(std::make_shared<verification_scp>());
 
    REQUIRE(server.start());
 
    // Wait for server to be ready
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("Basic study-level query succeeds") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", ""},
            {"PatientName", ""},
            {"StudyDate", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
 
    SECTION("Query with PatientID filter") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", "PAT001"},
            {"PatientName", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
 
    SECTION("Query with wildcard PatientName") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientName", "SMITH*"},
            {"PatientID", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
 
    SECTION("Query with date range") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"StudyDate", "20231201-20231231"},
            {"PatientID", ""},
            {"PatientName", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
 
    SECTION("Query with no matching results") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", "NONEXISTENT"},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        // Should succeed even with no results (returns 0 matches)
        REQUIRE(result.success());
    }
 
    SECTION("Multiple consecutive queries") {
        for (int i = 0; i < 3; ++i) {
            std::vector<std::pair<std::string, std::string>> keys = {
                {"PatientID", ""},
                {"StudyInstanceUID", ""}
            };
 
            auto result = dcmtk_tool::findscu(
                "localhost", port, ae_title, "STUDY", keys,
                "FINDSCU_" + std::to_string(i));
 
            INFO("Iteration: " << i);
            INFO("stdout: " << result.stdout_output);
            INFO("stderr: " << result.stderr_output);
 
            REQUIRE(result.success());
        }
    }
 
    SECTION("Patient-level query") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", ""},
            {"PatientName", ""},
            {"PatientBirthDate", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "PATIENT", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        REQUIRE(result.success());
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [4/6]

TEST_CASE	(	"C-FIND: pacs_system SCU query operations"	,
		""	[dcmtk][interop][find] )

Definition at line 419 of file test_dcmtk_find.cpp.

                 : pacs_system SCU query operations", "[dcmtk][interop][find]") {
    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");
    }
 
    // Setup: Start pacs_system server with query capability
    auto port = find_available_port();
    const std::string ae_title = "QUERY_SCP";
 
    test_query_database db;
    db.add_study(create_test_study("PAT001", "DOE^JOHN", "20240101", "CT"));
    db.add_study(create_test_study("PAT002", "DOE^JANE", "20240115", "MR"));
 
    test_server server(port, ae_title);
 
    auto query_scp_ptr = std::make_shared<query_scp>();
    query_scp_ptr->set_handler([&db](
        query_level level,
        const dicom_dataset& query_keys,
        const std::string& /* calling_ae */) -> std::vector<dicom_dataset> {
 
        if (level == query_level::patient) {
            return db.find_patients(query_keys);
        }
        return db.find_studies(query_keys);
    });
    server.register_service(query_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("pacs_system SCU sends C-FIND successfully") {
        auto connect_result = test_association::connect(
            "localhost", port, ae_title, "PACS_SCU",
            {std::string(study_root_find_sop_class_uid)});
 
        REQUIRE(connect_result.is_ok());
        auto& assoc = connect_result.value();
 
        REQUIRE(assoc.has_accepted_context(study_root_find_sop_class_uid));
        auto context_id = assoc.accepted_context_id(study_root_find_sop_class_uid);
        REQUIRE(context_id.has_value());
 
        // Create query keys
        dicom_dataset query_keys;
        query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
        query_keys.set_string(tags::patient_id, vr_type::LO, "");
        query_keys.set_string(tags::patient_name, vr_type::PN, "");
        query_keys.set_string(tags::study_instance_uid, vr_type::UI, "");
 
        // Send C-FIND request
        auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
        find_rq.set_dataset(std::move(query_keys));
        auto send_result = assoc.send_dimse(*context_id, find_rq);
        REQUIRE(send_result.is_ok());
 
        // Receive responses
        std::vector<dicom_dataset> results;
        while (true) {
            auto recv_result = assoc.receive_dimse();
            REQUIRE(recv_result.is_ok());
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) {
                break;  // Final response
            } else if (rsp.status() == status_pending) {
                if (rsp.has_dataset()) {
                    auto ds_result = rsp.dataset();
                    if (ds_result.is_ok()) {
                        results.push_back(ds_result.value().get());
                    }
                }
            } else {
                FAIL("Unexpected C-FIND response status");
            }
        }
 
        // Should get 2 study results
        REQUIRE(results.size() == 2);
    }
 
    SECTION("Query with specific PatientName filter") {
        auto connect_result = test_association::connect(
            "localhost", port, ae_title, "PACS_SCU",
            {std::string(study_root_find_sop_class_uid)});
 
        REQUIRE(connect_result.is_ok());
        auto& assoc = connect_result.value();
 
        auto context_id = assoc.accepted_context_id(study_root_find_sop_class_uid);
        REQUIRE(context_id.has_value());
 
        dicom_dataset query_keys;
        query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
        query_keys.set_string(tags::patient_name, vr_type::PN, "DOE^JOHN");
        query_keys.set_string(tags::study_instance_uid, vr_type::UI, "");
 
        auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
        find_rq.set_dataset(std::move(query_keys));
        auto send_result = assoc.send_dimse(*context_id, find_rq);
        REQUIRE(send_result.is_ok());
 
        std::vector<dicom_dataset> results;
        while (true) {
            auto recv_result = assoc.receive_dimse();
            REQUIRE(recv_result.is_ok());
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) break;
            if (rsp.status() == status_pending && rsp.has_dataset()) {
                auto ds_result = rsp.dataset();
                if (ds_result.is_ok()) {
                    results.push_back(ds_result.value().get());
                }
            }
        }
 
        // Should find exactly 1 matching study
        REQUIRE(results.size() == 1);
        REQUIRE(results[0].get_string(tags::patient_name) == "DOE^JOHN");
    }
 
    SECTION("Query with wildcard pattern") {
        auto connect_result = test_association::connect(
            "localhost", port, ae_title, "PACS_SCU",
            {std::string(study_root_find_sop_class_uid)});
 
        REQUIRE(connect_result.is_ok());
        auto& assoc = connect_result.value();
 
        auto context_id = assoc.accepted_context_id(study_root_find_sop_class_uid);
        REQUIRE(context_id.has_value());
 
        dicom_dataset query_keys;
        query_keys.set_string(tags::query_retrieve_level, vr_type::CS, "STUDY");
        query_keys.set_string(tags::patient_name, vr_type::PN, "DOE*");
        query_keys.set_string(tags::study_instance_uid, vr_type::UI, "");
 
        auto find_rq = make_c_find_rq(1, study_root_find_sop_class_uid);
        find_rq.set_dataset(std::move(query_keys));
        (void)assoc.send_dimse(*context_id, find_rq);
 
        std::vector<dicom_dataset> results;
        while (true) {
            auto recv_result = assoc.receive_dimse();
            if (recv_result.is_err()) break;
 
            auto& [recv_ctx, rsp] = recv_result.value();
            if (rsp.status() == status_success) break;
            if (rsp.status() == status_pending && rsp.has_dataset()) {
                auto ds_result = rsp.dataset();
                if (ds_result.is_ok()) {
                    results.push_back(ds_result.value().get());
                }
            }
        }
 
        // Both DOE^JOHN and DOE^JANE should match
        REQUIRE(results.size() == 2);
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [5/6]

TEST_CASE	(	"C-FIND: Query level variations"	,
		""	[dcmtk][interop][find][levels] )

Definition at line 767 of file test_dcmtk_find.cpp.

                 : Query level variations", "[dcmtk][interop][find][levels]") {
    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();
    const std::string ae_title = "LEVEL_TEST_SCP";
 
    test_query_database db;
    db.add_study(create_test_study("PAT001", "TEST^PATIENT", "20240101", "CT"));
 
    test_server server(port, ae_title);
 
    auto query_scp_ptr = std::make_shared<query_scp>();
    query_scp_ptr->set_handler([&db](
        query_level level,
        const dicom_dataset& query_keys,
        const std::string& /* calling_ae */) -> std::vector<dicom_dataset> {
 
        if (level == query_level::patient) {
            return db.find_patients(query_keys);
        }
        return db.find_studies(query_keys);
    });
    server.register_service(query_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("STUDY level query") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", "PAT001"},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        REQUIRE(result.success());
    }
 
    SECTION("PATIENT level query") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", ""},
            {"PatientName", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "PATIENT", keys);
 
        REQUIRE(result.success());
    }
}

Here is the call graph for this function:

◆ TEST_CASE() [6/6]

TEST_CASE	(	"C-FIND: Special character handling"	,
		""	[dcmtk][interop][find][special] )

Definition at line 832 of file test_dcmtk_find.cpp.

                 : Special character handling", "[dcmtk][interop][find][special]") {
    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();
    const std::string ae_title = "SPECIAL_CHAR_SCP";
 
    test_query_database db;
    // Add study with special characters in patient name
    db.add_study(create_test_study("PAT001", "O'BRIEN^MARY", "20240101", "CT"));
    db.add_study(create_test_study("PAT002", "MÜLLER^HANS", "20240101", "MR"));
 
    test_server server(port, ae_title);
 
    auto query_scp_ptr = std::make_shared<query_scp>();
    query_scp_ptr->set_handler([&db](
        query_level /* level */,
        const dicom_dataset& query_keys,
        const std::string& /* calling_ae */) -> std::vector<dicom_dataset> {
        return db.find_studies(query_keys);
    });
    server.register_service(query_scp_ptr);
    REQUIRE(server.start());
 
    REQUIRE(wait_for([&]() {
        return process_launcher::is_port_listening(port);
    }, server_ready_timeout()));
 
    SECTION("Query with special characters in response") {
        std::vector<std::pair<std::string, std::string>> keys = {
            {"PatientID", "PAT001"},
            {"PatientName", ""},
            {"StudyInstanceUID", ""}
        };
 
        auto result = dcmtk_tool::findscu(
            "localhost", port, ae_title, "STUDY", keys);
 
        INFO("stdout: " << result.stdout_output);
        INFO("stderr: " << result.stderr_output);
 
        // Should succeed despite special characters
        REQUIRE(result.success());
    }
}

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]