driven_table_test.cc

Go to the documentation of this file.

 
#include <gtest/gtest.h>
#include <driven_table.H>
#include <string>
 
using namespace std;
 
// =============================================================================
// Helper Functions for Legacy Events (void* interface)
// =============================================================================
 
// Simple event that returns a string
void* event_hello(void* data) {
    (void)data;
    static string msg = "Hello";
    return &msg;
}
 
// Event that increments a counter passed as data
void* event_increment(void* data) {
    int* counter = static_cast<int*>(data);
    if (counter) {
        (*counter)++;
    }
    return counter;
}
 
// Event that returns the input data directly
void* event_echo(void* data) {
    return data;
}
 
// =============================================================================
// Legacy Static_Event_Table Tests (void* interface)
// =============================================================================
 
TEST(LegacyStaticEventTableTest, ConstructorAndSize) {
    Legacy_Static_Event_Table table(10);
    EXPECT_EQ(table.size(), 10u);
}
 
TEST(LegacyStaticEventTableTest, RegisterAndExecute) {
    Legacy_Static_Event_Table table(5);
 
    // Register at specific index
    table.register_event(0, event_hello);
 
    // Execute
    void* result = table.execute_event(0);
    string* msg = static_cast<string*>(result);
    EXPECT_EQ(*msg, "Hello");
}
 
TEST(LegacyStaticEventTableTest, RegisterWithAutoIndex) {
    Legacy_Static_Event_Table table(5);
 
    // Note: register_event(fct) appends to the END of the table.
    // For Static_Event_Table, this means writing to index size().
    // But Static_Event_Table has fixed size, so writing to size() is out of bounds!
    //
    // Wait, let's check the implementation of append_event_to_table:
    // void append_event_to_table(Event_Fct fct) { write_table(size(), fct); }
    //
    // And Static_Event_Table::write_table checks: if (i >= size_table) error.
    //
    // So register_event(fct) on a Static_Event_Table will ALWAYS fail
    // because it tries to append beyond the fixed size.
    // This seems to be a design limitation or intended behavior for dynamic tables only.
    // Let's verify this behavior.
 
    EXPECT_THROW(table.register_event(event_hello), std::range_error);
}
 
TEST(LegacyStaticEventTableTest, ExecuteWithData) {
    Legacy_Static_Event_Table table(5);
    table.register_event(2, event_increment);
 
    int counter = 0;
    table.execute_event(2, &counter);
    EXPECT_EQ(counter, 1);
 
    table.execute_event(2, &counter);
    EXPECT_EQ(counter, 2);
}
 
TEST(LegacyStaticEventTableTest, UnregisterEvent) {
    Legacy_Static_Event_Table table(5);
    table.register_event(1, event_hello);
 
    EXPECT_TRUE(table.check(1, event_hello));
 
    table.unregister_event(1);
 
    // Should be nullptr now
    EXPECT_FALSE(table.check(1, event_hello));
 
    // Executing unregistered event should throw
    EXPECT_THROW(table.execute_event(1), std::range_error);
}
 
TEST(LegacyStaticEventTableTest, OutOfBoundsAccess) {
    Legacy_Static_Event_Table table(5);
 
    EXPECT_THROW(table.register_event(5, event_hello), std::range_error);
    EXPECT_THROW(table.execute_event(5), std::range_error); // read_table checks range first
}
 
TEST(LegacyStaticEventTableTest, RegisterOnUsedSlot) {
    Legacy_Static_Event_Table table(5);
    table.register_event(0, event_hello);
 
    EXPECT_THROW(table.register_event(0, event_echo), std::range_error);
}
 
TEST(LegacyStaticEventTableTest, UnregisterUnusedSlot) {
    Legacy_Static_Event_Table table(5);
    EXPECT_THROW(table.unregister_event(0), std::range_error);
}
 
TEST(LegacyStaticEventTableTest, MoveSemantics) {
    Legacy_Static_Event_Table table1(5);
    table1.register_event(0, event_hello);
 
    // Move constructor
    Legacy_Static_Event_Table table2(std::move(table1));
    EXPECT_EQ(table2.size(), 5u);
    EXPECT_EQ(table1.size(), 0u); // Moved from
 
    void* result = table2.execute_event(0);
    EXPECT_EQ(*static_cast<string*>(result), "Hello");
 
    // Move assignment
    Legacy_Static_Event_Table table3(2);
    table3 = std::move(table2);
    EXPECT_EQ(table3.size(), 5u);
    EXPECT_EQ(table2.size(), 0u);
 
    result = table3.execute_event(0);
    EXPECT_EQ(*static_cast<string*>(result), "Hello");
}
 
// =============================================================================
// Dynamic_Event_Table Tests
// =============================================================================
 
TEST(LegacyDynamicEventTableTest, ConstructorAndSize) {
    Legacy_Dynamic_Event_Table table(5);
    EXPECT_EQ(table.size(), 5u);
}
 
TEST(LegacyDynamicEventTableTest, RegisterAndExecute) {
    Legacy_Dynamic_Event_Table table; // Empty
 
    // Auto-append
    size_t id1 = table.register_event(event_hello);
    EXPECT_EQ(id1, 0u);
    EXPECT_EQ(table.size(), 1u);
 
    size_t id2 = table.register_event(event_echo);
    EXPECT_EQ(id2, 1u);
    EXPECT_EQ(table.size(), 2u);
 
    // Execute
    void* result = table.execute_event(id1);
    EXPECT_EQ(*static_cast<string*>(result), "Hello");
 
    int data = 42;
    result = table.execute_event(id2, &data);
    EXPECT_EQ(*static_cast<int*>(result), 42);
}
 
TEST(LegacyDynamicEventTableTest, RegisterAtSpecificIndex) {
    Legacy_Dynamic_Event_Table table(10); // Pre-allocate
 
    table.register_event(5, event_hello);
    EXPECT_TRUE(table.check(5, event_hello));
 
    // Should grow if we write beyond the current size?
    // The base class register_event(index, fct) checks: index >= size() -> range_error
    // So we cannot register at arbitrary index beyond size using register_event(index, fct).
    // We must use register_event(fct) to append.
 
    EXPECT_THROW(table.register_event(20, event_hello), std::range_error);
}
 
TEST(LegacyDynamicEventTableTest, UnregisterAndShrink) {
    Legacy_Dynamic_Event_Table table;
    table.register_event(event_hello);
    size_t id1 = table.register_event(event_echo);
 
    EXPECT_EQ(table.size(), 2u);
 
    // Unregister last event: slot is cleared but table does not shrink
    // (size stays the same because the base class only shrinks when
    // index == size(), which is unreachable after the range check).
    table.unregister_event(id1);
    EXPECT_EQ(table.size(), 2u);
    EXPECT_FALSE(table.check(id1, event_echo));
 
    // Verify event at id0 was not corrupted by unregistering id1
    EXPECT_TRUE(table.check(0, event_hello));
    void* result = table.execute_event(0);
    EXPECT_EQ(*static_cast<string*>(result), "Hello");
 
    // The cleared slot can be reused via register_event(index, fct)
    table.register_event(id1, event_hello);
    EXPECT_TRUE(table.check(id1, event_hello));
}
 
TEST(LegacyDynamicEventTableTest, ReuseSlot) {
    Legacy_Dynamic_Event_Table table(1);
    table.register_event(0, event_hello);
    table.unregister_event(0);
 
    // Now slot 0 is free
    table.register_event(0, event_echo);
    EXPECT_TRUE(table.check(0, event_echo));
}
 
// =============================================================================
// Modern Type-Safe Event Table Tests (with lambdas and templates)
// =============================================================================
 
// Test void(int) signature
TEST(ModernStaticEventTableTest, VoidIntSignature) {
    Static_Event_Table<void(int)> table(5);
    EXPECT_EQ(table.size(), 5u);
 
    int counter = 0;
    table.register_event(0, [&counter](int x) { counter += x; });
 
    table.execute_event(0, 10);
    EXPECT_EQ(counter, 10);
 
    table.execute_event(0, 5);
    EXPECT_EQ(counter, 15);
}
 
// Test int(int, int) signature with return value
TEST(ModernStaticEventTableTest, IntIntIntSignature) {
    Static_Event_Table<int(int, int)> table(3);
 
    // Lambda that adds two numbers
    table.register_event(0, [](int a, int b) { return a + b; });
 
    // Lambda that multiplies
    table.register_event(1, [](int a, int b) { return a * b; });
 
    EXPECT_EQ(table.execute_event(0, 3, 4), 7);
    EXPECT_EQ(table.execute_event(1, 3, 4), 12);
}
 
// Test string(string) with complex objects
TEST(ModernStaticEventTableTest, StringSignature) {
    Static_Event_Table<string(const string&)> table(2);
 
    table.register_event(0, [](const string& s) { return "Hello, " + s; });
    table.register_event(1, [](const string& s) {
        string upper = s;
        for (auto& c : upper) c = toupper(c);
        return upper;
    });
 
    EXPECT_EQ(table.execute_event(0, "World"), "Hello, World");
    EXPECT_EQ(table.execute_event(1, "test"), "TEST");
}
 
// Test Dynamic_Event_Table with lambdas
TEST(ModernDynamicEventTableTest, AutoGrowth) {
    Dynamic_Event_Table<int(int)> table;
 
    auto id1 = table.register_event([](int x) { return x * 2; });
    auto id2 = table.register_event([](int x) { return x * 3; });
    auto id3 = table.register_event([](int x) { return x * 5; });
 
    EXPECT_EQ(table.size(), 3u);
 
    EXPECT_EQ(table.execute_event(id1, 10), 20);
    EXPECT_EQ(table.execute_event(id2, 10), 30);
    EXPECT_EQ(table.execute_event(id3, 10), 50);
}
 
// Test with stateful lambdas (captures)
TEST(ModernDynamicEventTableTest, StatefulLambdas) {
    Dynamic_Event_Table<void(int)> table;
 
    int total = 0;
    int count = 0;
 
    // Lambda capturing by reference
    auto avg_id = table.register_event([&](int value) {
        total += value;
        count++;
    });
 
    table.execute_event(avg_id, 10);
    table.execute_event(avg_id, 20);
    table.execute_event(avg_id, 30);
 
    EXPECT_EQ(total, 60);
    EXPECT_EQ(count, 3);
}
 
// Test std::function directly
TEST(ModernDynamicEventTableTest, StdFunctionSupport) {
    Dynamic_Event_Table<double(double)> table;
 
    std::function<double(double)> square = [](double x) { return x * x; };
    std::function<double(double)> cube = [](double x) { return x * x * x; };
 
    auto square_id = table.register_event(square);
    auto cube_id = table.register_event(cube);
 
    EXPECT_DOUBLE_EQ(table.execute_event(square_id, 5.0), 25.0);
    EXPECT_DOUBLE_EQ(table.execute_event(cube_id, 3.0), 27.0);
}
 
// Test is_registered
TEST(ModernDynamicEventTableTest, IsRegistered) {
    Dynamic_Event_Table<void()> table;
 
    auto id1 = table.register_event([]() {});
    auto id2 = table.register_event([]() {});
 
    EXPECT_TRUE(table.is_registered(id1));
    EXPECT_TRUE(table.is_registered(id2));
    EXPECT_FALSE(table.is_registered(999));
 
    table.unregister_event(id1);
    EXPECT_FALSE(table.is_registered(id1));
    EXPECT_TRUE(table.is_registered(id2));
}
 
// Test move semantics
TEST(ModernStaticEventTableTest, MoveSemantics) {
    Static_Event_Table<int(int)> table1(3);
    table1.register_event(0, [](int x) { return x * 10; });
 
    // Move constructor
    Static_Event_Table<int(int)> table2(std::move(table1));
    EXPECT_EQ(table2.size(), 3u);
    EXPECT_EQ(table1.size(), 0u);
 
    EXPECT_EQ(table2.execute_event(0, 5), 50);
 
    // Move assignment
    Static_Event_Table<int(int)> table3(1);
    table3 = std::move(table2);
    EXPECT_EQ(table3.size(), 3u);
    EXPECT_EQ(table2.size(), 0u);
 
    EXPECT_EQ(table3.execute_event(0, 5), 50);
}
 
// =============================================================================
// Main
// =============================================================================