test_thread_adapter.cpp File Reference

Unit tests for thread_adapter (Phase 4) More...

#include "../../database/integrated/adapters/thread_adapter.h"
#include <atomic>
#include <chrono>
#include <iostream>
#include <thread>

Include dependency graph for test_thread_adapter.cpp:

Go to the source code of this file.

Macros
#define	TEST(name)
#define	RUN_TEST(name)
#define	ASSERT_TRUE(condition)
#define	ASSERT_FALSE(condition)

Functions
void	test_configuration_construction ()
void	test_adapter_construction ()
void	test_api_availability_submit ()
void	test_api_availability_priority ()
void	test_api_availability_stats ()
void	test_multiple_instances ()
void	test_move_semantics ()
void	test_destructor_safety ()
void	test_shutdown_without_init ()
void	test_double_initialization ()
int	main ()

Variables
int	tests_passed = 0
int	tests_failed = 0

Detailed Description

Unit tests for thread_adapter (Phase 4)

These are lightweight API tests that verify the adapter interface without requiring deep integration with thread_system.

For full integration testing, run the integration test suite instead.

Definition in file test_thread_adapter.cpp.

Macro Definition Documentation

ASSERT_FALSE

#define ASSERT_FALSE

(

condition

)

Value:

ASSERT_TRUE(!(condition))

Definition at line 47 of file test_thread_adapter.cpp.

ASSERT_TRUE

#define ASSERT_TRUE

(

condition

)

Value:

    if (!(condition)) { \
        throw std::runtime_error("Assertion failed: " #condition); \
    }

Definition at line 42 of file test_thread_adapter.cpp.

#define ASSERT_TRUE(condition) \
    if (!(condition)) { \
        throw std::runtime_error("Assertion failed: " #condition); \
    }

Referenced by test_api_availability_priority(), test_api_availability_submit(), and test_configuration_construction().

RUN_TEST

#define RUN_TEST

(

name

)

Value:

    do { \
        std::cout << "Running test: " << #name << " ... "; \
        try { \
            test_##name(); \
            std::cout << "PASSED\n"; \
            tests_passed++; \
        } catch (const std::exception& e) { \
            std::cout << "FAILED: " << e.what() << "\n"; \
            tests_failed++; \
        } \
    } while(0)

Definition at line 29 of file test_thread_adapter.cpp.

#define RUN_TEST(name) \
    do { \
        std::cout << "Running test: " << #name << " ... "; \
        try { \
            test_##name(); \
            std::cout << "PASSED\n"; \
            tests_passed++; \
        } catch (const std::exception& e) { \
            std::cout << "FAILED: " << e.what() << "\n"; \
            tests_failed++; \
        } \
    } while(0)

Referenced by main().

TEST

#define TEST

(

name

)

Value:

void test_##name()

Definition at line 28 of file test_thread_adapter.cpp.

Function Documentation

main()

int main

(

)

Definition at line 242 of file test_thread_adapter.cpp.

           {
    std::cout << "=== Thread Adapter API Tests (Phase 4) ===\n";
    std::cout << "Note: These tests verify API availability and basic functionality.\n";
    std::cout << "Some tests may be skipped if thread_system is not available.\n\n";
 
    RUN_TEST(configuration_construction);
    RUN_TEST(adapter_construction);
    RUN_TEST(api_availability_submit);
    RUN_TEST(api_availability_priority);
    RUN_TEST(api_availability_stats);
    RUN_TEST(multiple_instances);
    RUN_TEST(move_semantics);
    RUN_TEST(destructor_safety);
    RUN_TEST(shutdown_without_init);
    RUN_TEST(double_initialization);
 
    std::cout << "\n=== Test Summary ===\n";
    std::cout << "Passed: " << tests_passed << "\n";
    std::cout << "Failed: " << tests_failed << "\n";
 
    if (tests_failed == 0) {
        std::cout << "=== All tests passed! ✓ ===\n";
        return 0;
    } else {
        std::cout << "=== Some tests failed! ✗ ===\n";
        return 1;
    }
}

References RUN_TEST, tests_failed, and tests_passed.

test_adapter_construction()

void test_adapter_construction

(

)

Definition at line 67 of file test_thread_adapter.cpp.

                           {
    db_thread_config config;
    config.thread_count = 2;
 
    // Should be able to construct adapter
    thread_adapter adapter(config);
 
    // Construction should succeed
}

References database::integrated::db_thread_config::thread_count.

test_api_availability_priority()

void test_api_availability_priority

(

)

Definition at line 107 of file test_thread_adapter.cpp.

                                {
    db_thread_config config;
    config.thread_count = 1;
    // Note: enable_priority_scheduling flag exists but priority is not implemented in backend pattern
 
    thread_adapter adapter(config);
 
    auto init_result = adapter.initialize();
 
    if (init_result.is_ok()) {
        std::atomic<bool> executed{false};
 
        // Backend pattern removed priority support for simplification
        // Use regular submit instead
        auto future = adapter.submit([&executed]() {
            executed = true;
        });
 
        future.get();
        ASSERT_TRUE(executed);
 
        adapter.shutdown();
    }
}

References ASSERT_TRUE, database::integrated::adapters::thread_adapter::initialize(), database::integrated::adapters::thread_adapter::shutdown(), database::integrated::adapters::thread_adapter::submit(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_api_availability_stats()

void test_api_availability_stats

(

)

Definition at line 133 of file test_thread_adapter.cpp.

                             {
    db_thread_config config;
    config.thread_count = 4;
 
    thread_adapter adapter(config);
 
    // Should be able to query stats even without initialization
    auto worker_count = adapter.worker_count();
    auto queue_size = adapter.queue_size();
 
    // Values may be 0 if not initialized, but API should work
    (void)worker_count;
    (void)queue_size;
}

References database::integrated::adapters::thread_adapter::queue_size(), database::integrated::db_thread_config::thread_count, and database::integrated::adapters::thread_adapter::worker_count().

Here is the call graph for this function:

test_api_availability_submit()

void test_api_availability_submit

(

)

Definition at line 78 of file test_thread_adapter.cpp.

                              {
    db_thread_config config;
    config.thread_count = 2;
 
    thread_adapter adapter(config);
 
    // Try to initialize (may fail without thread_system, that's ok)
    auto init_result = adapter.initialize();
 
    // If initialization succeeded, test submit
    if (init_result.is_ok()) {
        std::atomic<bool> executed{false};
 
        auto future = adapter.submit([&executed]() {
            executed = true;
            return 42;
        });
 
        // Wait for completion
        auto value = future.get();
        ASSERT_TRUE(value == 42);
        ASSERT_TRUE(executed);
 
        adapter.shutdown();
    }
    // If init failed, that's acceptable for unit test
}

References ASSERT_TRUE, database::integrated::adapters::thread_adapter::initialize(), database::integrated::adapters::thread_adapter::shutdown(), database::integrated::adapters::thread_adapter::submit(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_configuration_construction()

void test_configuration_construction

(

)

Definition at line 54 of file test_thread_adapter.cpp.

                                 {
    db_thread_config config;
    config.thread_count = 4;
    config.max_queue_size = 100;
    config.pool_type = thread_pool_type::standard;
    config.enable_priority_scheduling = false;
 
    // Should be able to create config
    ASSERT_TRUE(config.thread_count == 4);
    ASSERT_TRUE(config.max_queue_size == 100);
}

References ASSERT_TRUE, database::integrated::db_thread_config::enable_priority_scheduling, database::integrated::db_thread_config::max_queue_size, database::integrated::db_thread_config::pool_type, and database::integrated::db_thread_config::thread_count.

test_destructor_safety()

void test_destructor_safety

(

)

Definition at line 181 of file test_thread_adapter.cpp.

                        {
    // Test that adapter can be constructed and destroyed safely
    {
        db_thread_config config;
        config.thread_count = 2;
 
        thread_adapter adapter(config);
 
        // Try to initialize
        auto init_result = adapter.initialize();
 
        if (init_result.is_ok()) {
            // Submit a task
            auto future = adapter.submit([]() { return 1; });
            future.get();
        }
 
        // Destructor will be called here (should call shutdown internally)
    }
 
    // Should not crash
}

References database::integrated::adapters::thread_adapter::initialize(), database::integrated::adapters::thread_adapter::submit(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_double_initialization()

void test_double_initialization

(

)

Definition at line 219 of file test_thread_adapter.cpp.

                            {
    db_thread_config config;
    config.thread_count = 2;
 
    thread_adapter adapter(config);
 
    auto init1 = adapter.initialize();
 
    if (init1.is_ok()) {
        // Second initialization may succeed (idempotent) or fail
        // The important thing is it doesn't crash
        auto init2 = adapter.initialize();
        // Either behavior is acceptable
        (void)init2;
 
        adapter.shutdown();
    }
}

References database::integrated::adapters::thread_adapter::initialize(), database::integrated::adapters::thread_adapter::shutdown(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_move_semantics()

void test_move_semantics

(

)

Definition at line 164 of file test_thread_adapter.cpp.

                     {
    db_thread_config config;
    config.thread_count = 2;
 
    thread_adapter adapter1(config);
 
    // Should support move construction
    thread_adapter adapter2(std::move(adapter1));
 
    // Moved-to instance should be usable
    auto init_result = adapter2.initialize();
    if (init_result.is_ok()) {
        adapter2.shutdown();
    }
}

References database::integrated::adapters::thread_adapter::initialize(), database::integrated::adapters::thread_adapter::shutdown(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

test_multiple_instances()

void test_multiple_instances

(

)

Definition at line 149 of file test_thread_adapter.cpp.

                         {
    db_thread_config config1;
    config1.thread_count = 2;
 
    db_thread_config config2;
    config2.thread_count = 3;
 
    // Should be able to create multiple adapters
    thread_adapter adapter1(config1);
    thread_adapter adapter2(config2);
 
    // Both should be constructible
}

References database::integrated::db_thread_config::thread_count.

test_shutdown_without_init()

void test_shutdown_without_init

(

)

Definition at line 205 of file test_thread_adapter.cpp.

                            {
    db_thread_config config;
    config.thread_count = 2;
 
    thread_adapter adapter(config);
 
    // Should be able to shutdown without initialize
    auto result = adapter.shutdown();
 
    // Should succeed or handle gracefully
    (void)result;
}

References database::integrated::adapters::thread_adapter::shutdown(), and database::integrated::db_thread_config::thread_count.

Here is the call graph for this function:

Variable Documentation

tests_failed

int tests_failed = 0

Definition at line 26 of file test_thread_adapter.cpp.

Referenced by main().

tests_passed

int tests_passed = 0

Definition at line 25 of file test_thread_adapter.cpp.

Referenced by main().