cpp-ipc/test/test_semaphore.cpp

/**
 * @file test_semaphore.cpp
 * @brief Comprehensive unit tests for ipc::sync::semaphore class
 * 
 * This test suite covers:
 * - Semaphore construction (default and named with count)
 * - Wait and post operations
 * - Timed wait with timeout
 * - Named semaphore for inter-process synchronization
 * - Resource cleanup (clear, clear_storage)
 * - Producer-consumer patterns
 * - Multiple wait/post scenarios
 */

#include <gtest/gtest.h>
#include <thread>
#include <chrono>
#include <atomic>
#include <vector>
#include "libipc/semaphore.h"
#include "libipc/def.h"

using namespace ipc;
using namespace ipc::sync;

namespace {

std::string generate_unique_sem_name(const char* prefix) {
    static int counter = 0;
    return std::string(prefix) + "_sem_" + std::to_string(++counter);
}

} // anonymous namespace

class SemaphoreTest : public ::testing::Test {
protected:
    void TearDown() override {
        std::this_thread::sleep_for(std::chrono::milliseconds(10));
    }
};

// Test default constructor
TEST_F(SemaphoreTest, DefaultConstructor) {
    semaphore sem;
    // Default constructed semaphore
}

// Test named constructor with count
TEST_F(SemaphoreTest, NamedConstructorWithCount) {
    std::string name = generate_unique_sem_name("named_count");
    
    semaphore sem(name.c_str(), 5);
    EXPECT_TRUE(sem.valid());
}

// Test named constructor with zero count
TEST_F(SemaphoreTest, NamedConstructorZeroCount) {
    std::string name = generate_unique_sem_name("zero_count");
    
    semaphore sem(name.c_str(), 0);
    EXPECT_TRUE(sem.valid());
}

// Test native() methods
TEST_F(SemaphoreTest, NativeHandle) {
    std::string name = generate_unique_sem_name("native");
    
    semaphore sem(name.c_str(), 1);
    ASSERT_TRUE(sem.valid());
    
    const void* const_handle = static_cast<const semaphore&>(sem).native();
    void* handle = sem.native();
    
    EXPECT_NE(const_handle, nullptr);
    EXPECT_NE(handle, nullptr);
}

// Test valid() method
TEST_F(SemaphoreTest, Valid) {
    semaphore sem1;
    
    std::string name = generate_unique_sem_name("valid");
    semaphore sem2(name.c_str(), 1);
    EXPECT_TRUE(sem2.valid());
}

// Test open() method
TEST_F(SemaphoreTest, Open) {
    std::string name = generate_unique_sem_name("open");
    
    semaphore sem;
    bool result = sem.open(name.c_str(), 3);
    
    EXPECT_TRUE(result);
    EXPECT_TRUE(sem.valid());
}

// Test close() method
TEST_F(SemaphoreTest, Close) {
    std::string name = generate_unique_sem_name("close");
    
    semaphore sem(name.c_str(), 1);
    ASSERT_TRUE(sem.valid());
    
    sem.close();
    EXPECT_FALSE(sem.valid());
}

// Test clear() method
TEST_F(SemaphoreTest, Clear) {
    std::string name = generate_unique_sem_name("clear");
    
    semaphore sem(name.c_str(), 1);
    ASSERT_TRUE(sem.valid());
    
    sem.clear();
    EXPECT_FALSE(sem.valid());
}

// Test clear_storage() static method
TEST_F(SemaphoreTest, ClearStorage) {
    std::string name = generate_unique_sem_name("clear_storage");
    
    {
        semaphore sem(name.c_str(), 1);
        EXPECT_TRUE(sem.valid());
    }
    
    semaphore::clear_storage(name.c_str());
}

// Test basic wait and post
TEST_F(SemaphoreTest, WaitPost) {
    std::string name = generate_unique_sem_name("wait_post");
    
    semaphore sem(name.c_str(), 1);
    ASSERT_TRUE(sem.valid());
    
    bool waited = sem.wait();
    EXPECT_TRUE(waited);
    
    bool posted = sem.post();
    EXPECT_TRUE(posted);
}

// Test post with count
TEST_F(SemaphoreTest, PostWithCount) {
    std::string name = generate_unique_sem_name("post_count");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    bool posted = sem.post(5);
    EXPECT_TRUE(posted);
    
    // Now should be able to wait 5 times
    for (int i = 0; i < 5; ++i) {
        EXPECT_TRUE(sem.wait(10)); // 10ms timeout
    }
}

// Test timed wait with timeout
TEST_F(SemaphoreTest, TimedWait) {
    std::string name = generate_unique_sem_name("timed_wait");
    
    semaphore sem(name.c_str(), 1);
    ASSERT_TRUE(sem.valid());
    
    bool waited = sem.wait(100); // 100ms timeout
    EXPECT_TRUE(waited);
}

// Test wait timeout scenario
TEST_F(SemaphoreTest, WaitTimeout) {
    std::string name = generate_unique_sem_name("wait_timeout");
    
    semaphore sem(name.c_str(), 0); // Zero count
    ASSERT_TRUE(sem.valid());
    
    auto start = std::chrono::steady_clock::now();
    bool waited = sem.wait(50); // 50ms timeout
    auto end = std::chrono::steady_clock::now();
    
    auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count();
    
    // Should timeout
    EXPECT_FALSE(waited);
    EXPECT_GE(elapsed, 40); // Allow some tolerance
}

// Test infinite wait
TEST_F(SemaphoreTest, InfiniteWait) {
    std::string name = generate_unique_sem_name("infinite_wait");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    std::atomic<bool> wait_started{false};
    std::atomic<bool> wait_succeeded{false};
    
    std::thread waiter([&]() {
        wait_started.store(true);
        bool result = sem.wait(invalid_value);
        wait_succeeded.store(result);
    });
    
    // Wait for thread to start waiting
    while (!wait_started.load()) {
        std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }
    
    std::this_thread::sleep_for(std::chrono::milliseconds(50));
    
    // Post to release the waiter
    sem.post();
    
    waiter.join();
    
    EXPECT_TRUE(wait_succeeded.load());
}

// Test producer-consumer pattern
TEST_F(SemaphoreTest, ProducerConsumer) {
    std::string name = generate_unique_sem_name("prod_cons");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    std::atomic<int> produced{0};
    std::atomic<int> consumed{0};
    const int count = 10;
    
    std::thread producer([&]() {
        for (int i = 0; i < count; ++i) {
            ++produced;
            sem.post();
            std::this_thread::sleep_for(std::chrono::milliseconds(1));
        }
    });
    
    std::thread consumer([&]() {
        for (int i = 0; i < count; ++i) {
            sem.wait();
            ++consumed;
        }
    });
    
    producer.join();
    consumer.join();
    
    EXPECT_EQ(produced.load(), count);
    EXPECT_EQ(consumed.load(), count);
}

// Test multiple producers and consumers
TEST_F(SemaphoreTest, MultipleProducersConsumers) {
    std::string name = generate_unique_sem_name("multi_prod_cons");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    std::atomic<int> total_produced{0};
    std::atomic<int> total_consumed{0};
    const int items_per_producer = 5;
    const int num_producers = 3;
    const int num_consumers = 3;
    
    std::vector<std::thread> producers;
    for (int i = 0; i < num_producers; ++i) {
        producers.emplace_back([&]() {
            for (int j = 0; j < items_per_producer; ++j) {
                ++total_produced;
                sem.post();
                std::this_thread::yield();
            }
        });
    }
    
    std::vector<std::thread> consumers;
    for (int i = 0; i < num_consumers; ++i) {
        consumers.emplace_back([&]() {
            for (int j = 0; j < items_per_producer; ++j) {
                if (sem.wait(1000)) {
                    ++total_consumed;
                }
            }
        });
    }
    
    for (auto& t : producers) t.join();
    for (auto& t : consumers) t.join();
    
    EXPECT_EQ(total_produced.load(), items_per_producer * num_producers);
    EXPECT_EQ(total_consumed.load(), items_per_producer * num_producers);
}

// Test semaphore with initial count
TEST_F(SemaphoreTest, InitialCount) {
    std::string name = generate_unique_sem_name("initial_count");
    const uint32_t initial = 3;
    
    semaphore sem(name.c_str(), initial);
    ASSERT_TRUE(sem.valid());
    
    // Should be able to wait 'initial' times without blocking
    for (uint32_t i = 0; i < initial; ++i) {
        EXPECT_TRUE(sem.wait(10));
    }
    
    // Next wait should timeout
    EXPECT_FALSE(sem.wait(10));
}

// Test rapid post operations
TEST_F(SemaphoreTest, RapidPost) {
    std::string name = generate_unique_sem_name("rapid_post");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    const int post_count = 100;
    for (int i = 0; i < post_count; ++i) {
        EXPECT_TRUE(sem.post());
    }
    
    // Should be able to wait post_count times
    int wait_count = 0;
    for (int i = 0; i < post_count; ++i) {
        if (sem.wait(10)) {
            ++wait_count;
        }
    }
    
    EXPECT_EQ(wait_count, post_count);
}

// Test concurrent post operations
TEST_F(SemaphoreTest, ConcurrentPost) {
    std::string name = generate_unique_sem_name("concurrent_post");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    std::atomic<int> post_count{0};
    const int threads = 5;
    const int posts_per_thread = 10;
    
    std::vector<std::thread> posters;
    for (int i = 0; i < threads; ++i) {
        posters.emplace_back([&]() {
            for (int j = 0; j < posts_per_thread; ++j) {
                if (sem.post()) {
                    ++post_count;
                }
            }
        });
    }
    
    for (auto& t : posters) t.join();
    
    EXPECT_EQ(post_count.load(), threads * posts_per_thread);
    
    // Verify by consuming
    int consumed = 0;
    for (int i = 0; i < threads * posts_per_thread; ++i) {
        if (sem.wait(10)) {
            ++consumed;
        }
    }
    
    EXPECT_EQ(consumed, threads * posts_per_thread);
}

// Test reopen after close
TEST_F(SemaphoreTest, ReopenAfterClose) {
    std::string name = generate_unique_sem_name("reopen");
    
    semaphore sem;
    
    ASSERT_TRUE(sem.open(name.c_str(), 2));
    EXPECT_TRUE(sem.valid());
    
    sem.close();
    EXPECT_FALSE(sem.valid());
    
    ASSERT_TRUE(sem.open(name.c_str(), 3));
    EXPECT_TRUE(sem.valid());
}

// Test named semaphore sharing between threads
TEST_F(SemaphoreTest, NamedSemaphoreSharing) {
    std::string name = generate_unique_sem_name("sharing");
    
    std::atomic<int> value{0};
    
    std::thread t1([&]() {
        semaphore sem(name.c_str(), 0);
        ASSERT_TRUE(sem.valid());
        
        sem.wait(); // Wait for signal
        value.store(100);
    });
    
    std::thread t2([&]() {
        std::this_thread::sleep_for(std::chrono::milliseconds(50));
        
        semaphore sem(name.c_str(), 0);
        ASSERT_TRUE(sem.valid());
        
        sem.post(); // Signal t1
    });
    
    t1.join();
    t2.join();
    
    EXPECT_EQ(value.load(), 100);
}

// Test post multiple count at once
TEST_F(SemaphoreTest, PostMultiple) {
    std::string name = generate_unique_sem_name("post_multiple");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    const uint32_t count = 10;
    bool posted = sem.post(count);
    EXPECT_TRUE(posted);
    
    // Consume all
    for (uint32_t i = 0; i < count; ++i) {
        EXPECT_TRUE(sem.wait(10));
    }
    
    // Should be empty now
    EXPECT_FALSE(sem.wait(10));
}

// Test semaphore after clear
TEST_F(SemaphoreTest, AfterClear) {
    std::string name = generate_unique_sem_name("after_clear");
    
    semaphore sem(name.c_str(), 5);
    ASSERT_TRUE(sem.valid());
    
    sem.wait();
    sem.clear();
    EXPECT_FALSE(sem.valid());
    
    // Operations after clear should fail gracefully
    EXPECT_FALSE(sem.wait(10));
    EXPECT_FALSE(sem.post());
}

// Test zero timeout
TEST_F(SemaphoreTest, ZeroTimeout) {
    std::string name = generate_unique_sem_name("zero_timeout");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    bool waited = sem.wait(0);
    // Should return immediately (either success or timeout)
}

// Test high-frequency wait/post
TEST_F(SemaphoreTest, HighFrequency) {
    std::string name = generate_unique_sem_name("high_freq");
    
    semaphore sem(name.c_str(), 0);
    ASSERT_TRUE(sem.valid());
    
    std::thread poster([&]() {
        for (int i = 0; i < 1000; ++i) {
            sem.post();
        }
    });
    
    std::thread waiter([&]() {
        for (int i = 0; i < 1000; ++i) {
            sem.wait(100);
        }
    });
    
    poster.join();
    waiter.join();
}