Added utilite tests

utilite/test/test_uevents.cpp

@@ -0,0 +1,478 @@
+#include "gtest/gtest.h"
+#include "rtabmap/utilite/UEvent.h"
+#include "rtabmap/utilite/UEventsHandler.h"
+#include "rtabmap/utilite/UEventsManager.h"
+#include "rtabmap/utilite/UEventsSender.h"
+#include "rtabmap/utilite/UTimer.h"
+#include <thread>
+#include <chrono>
+#include <atomic>
+
+// Test event classes
+class TestEvent : public UEvent
+{
+public:
+    TestEvent(int code = 0) : UEvent(code) {}
+    virtual ~TestEvent() {}
+    virtual std::string getClassName() const {return "TestEvent";}
+};
+
+class AnotherEvent : public UEvent
+{
+public:
+    AnotherEvent() : UEvent(0) {}
+    virtual ~AnotherEvent() {}
+    virtual std::string getClassName() const {return "AnotherEvent";}
+};
+
+// Test handler class
+class TestHandler : public UEventsHandler
+{
+public:
+    TestHandler() : eventCount_(0), lastEventCode_(0){}
+    
+    int getEventCount() const { return eventCount_; }
+    int getLastEventCode() const { return lastEventCode_; }
+    const std::string & getLastEventClassName() const { return lastEventClassName_; }
+    void reset() { eventCount_ = 0; lastEventCode_ = 0; lastEventClassName_.clear(); }
+    
+protected:
+    virtual bool handleEvent(UEvent * event)
+    {
+        eventCount_++;
+        lastEventCode_ = event->getCode();
+        lastEventClassName_ = event->getClassName();
+        return false;
+    }
+
+private:
+    int eventCount_;
+    int lastEventCode_;
+    std::string lastEventClassName_;
+    bool ownershipTaken_;
+};
+
+// Handler that takes ownership
+class OwnershipHandler : public UEventsHandler
+{
+public:
+    OwnershipHandler() : event_(nullptr) {}
+    ~OwnershipHandler() {delete event_;}
+    const UEvent * getEvent() const {return event_;} 
+    void reset() { delete event_; event_ = nullptr;}
+    
+protected:
+    virtual bool handleEvent(UEvent * event)
+    {
+        event_ = event; // Take ownership
+        return true;
+    }
+    
+private:
+    UEvent * event_;
+};
+
+// Handler that filters events
+class FilteringHandler : public UEventsHandler
+{
+public:
+    FilteringHandler() : testEventCount_(0), anotherEventCount_(0) {}
+    int getTestEventCount() const { return testEventCount_; }
+    int getAnotherEventCount() const { return anotherEventCount_; }
+    void reset() { testEventCount_ = 0; anotherEventCount_ = 0; }
+    
+protected:
+    virtual bool handleEvent(UEvent * event)
+    {
+        if(event->getClassName() == "TestEvent")
+        {
+            testEventCount_++;
+        }
+        else if(event->getClassName() == "AnotherEvent")
+        {
+            anotherEventCount_++;
+        }
+        return false;
+    }
+    
+private:
+    int testEventCount_;
+    int anotherEventCount_;
+};
+
+// Test sender class that can post events
+class TestSender : public UEventsSender
+{
+public:
+    TestSender() {}
+    
+    // Public method to test protected post() method
+    void testPost(UEvent* event, bool async = true) const
+    {
+        post(event, async);
+    }
+};
+
+TEST(UEventsTest, UEventGetClassName)
+{
+    TestEvent event;
+    EXPECT_EQ(event.getClassName(), "TestEvent");
+    EXPECT_EQ(event.getCode(), 0);
+}
+
+TEST(UEventsTest, UEventGetCode)
+{
+    TestEvent event(42);
+    EXPECT_EQ(event.getCode(), 42);
+}
+
+TEST(UEventsTest, UEventsHandlerRegisterUnregister)
+{
+    TestHandler handler;
+    
+    // Register handler
+    handler.registerToEventsManager();
+    
+    // Post an event
+    UEventsManager::post(new TestEvent(), true);
+    
+    // Give time for event to be processed
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_GT(handler.getEventCount(), 0);
+    
+    // Unregister handler
+    handler.unregisterFromEventsManager();
+    
+    // Post another event
+    int countBefore = handler.getEventCount();
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    // Should not receive event after unregister
+    EXPECT_EQ(handler.getEventCount(), countBefore);
+}
+
+TEST(UEventsTest, UEventsHandlerDestructorUnregisters)
+{
+    TestHandler* handler = new TestHandler();
+    handler->registerToEventsManager();
+    
+    // Post an event
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+
+    EXPECT_EQ(handler->getEventCount(), 1);
+    
+    // Delete handler (should unregister automatically)
+    handler->unregisterFromEventsManager();
+    
+    // Post another event
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_EQ(handler->getEventCount(), 1);
+}
+
+TEST(UEventsTest, UEventsManagerAddRemoveHandler)
+{
+    TestHandler handler1;
+    TestHandler handler2;
+    
+    UEventsManager::addHandler(&handler1);
+    UEventsManager::addHandler(&handler2);
+    
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_GT(handler1.getEventCount(), 0);
+    EXPECT_GT(handler2.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler1);
+    
+    int count1Before = handler1.getEventCount();
+    int count2Before = handler2.getEventCount();
+    
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_EQ(handler1.getEventCount(), count1Before);
+    EXPECT_GT(handler2.getEventCount(), count2Before);
+    
+    UEventsManager::removeHandler(&handler2);
+}
+
+TEST(UEventsTest, UEventsManagerPostAsync)
+{
+    TestHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    UEventsManager::post(new TestEvent(), true);
+    
+    // Give time for async processing
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    
+    EXPECT_GT(handler.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsManagerPostSync)
+{
+    TestHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    UEventsManager::post(new TestEvent(), false);
+    
+    // Sync should be immediate
+    EXPECT_GT(handler.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsManagerMultipleHandlers)
+{
+    TestHandler handler1;
+    TestHandler handler2;
+    TestHandler handler3;
+    
+    UEventsManager::addHandler(&handler1);
+    UEventsManager::addHandler(&handler2);
+    UEventsManager::addHandler(&handler3);
+    
+    handler1.reset();
+    handler2.reset();
+    handler3.reset();
+    
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_GT(handler1.getEventCount(), 0);
+    EXPECT_GT(handler2.getEventCount(), 0);
+    EXPECT_GT(handler3.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler1);
+    UEventsManager::removeHandler(&handler2);
+    UEventsManager::removeHandler(&handler3);
+}
+
+TEST(UEventsTest, UEventsManagerEventOrdering)
+{
+    TestHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    // Post multiple events
+    UEventsManager::post(new TestEvent(1), true);
+    UEventsManager::post(new TestEvent(2), true);
+    UEventsManager::post(new TestEvent(3), true);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    
+    // Should receive all events (order may vary in async mode)
+    EXPECT_GE(handler.getEventCount(), 3);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsHandlerOwnership)
+{
+    OwnershipHandler handler;
+    TestHandler handler0;
+    TestHandler handler2;
+    UEventsManager::addHandler(&handler0);
+    UEventsManager::addHandler(&handler);
+    UEventsManager::addHandler(&handler2);
+    
+    UEventsManager::post(new TestEvent(42), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_NE(handler.getEvent(), nullptr);
+    EXPECT_EQ(handler.getEvent()->getCode(), 42);
+
+    // Should have received the event
+    EXPECT_GT(handler0.getEventCount(), 0);
+
+    // Should not have received the event
+    EXPECT_EQ(handler2.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler0);
+    UEventsManager::removeHandler(&handler);
+    UEventsManager::removeHandler(&handler2);
+}
+
+TEST(UEventsTest, UEventsHandlerFiltering)
+{
+    FilteringHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    UEventsManager::post(new TestEvent(), true);
+    UEventsManager::post(new AnotherEvent(), true);
+    UEventsManager::post(new TestEvent(), true);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    
+    EXPECT_EQ(handler.getTestEventCount(), 2);
+    EXPECT_EQ(handler.getAnotherEventCount(), 1);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsSenderPost)
+{
+    TestSender sender;
+    TestHandler handler;
+    
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    // Test protected post() method through TestSender
+    sender.testPost(new TestEvent(), true);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_GT(handler.getEventCount(), 0);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsSenderDestructorRemovesPipes)
+{
+    TestSender* sender = new TestSender();
+    TestHandler handler;
+    
+    UEventsManager::addHandler(&handler);
+    UEventsManager::createPipe(sender, &handler, "TestEvent");
+    
+    // Delete sender - should remove pipes automatically
+    delete sender;
+    
+    // Should not crash and pipes should be removed
+    SUCCEED();
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, UEventsManagerCreateRemovePipe)
+{
+    TestSender sender;
+    TestHandler handler;
+    TestHandler handler2;
+    
+    UEventsManager::addHandler(&handler);
+    UEventsManager::addHandler(&handler2);
+    
+    // Create a pipe
+    UEventsManager::createPipe(&sender, &handler, "TestEvent");
+    
+    handler.reset();
+    
+    // Post event with sender
+    sender.testPost(new TestEvent());
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT_EQ(handler.getEventCount(), 1);
+    EXPECT_EQ(handler2.getEventCount(), 0);
+
+    // Post event with sender using UEventsManager
+    UEventsManager::post(new TestEvent(), true, &sender);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT_EQ(handler.getEventCount(), 2);
+    EXPECT_EQ(handler2.getEventCount(), 0);
+
+    // Post global event
+    UEventsManager::post(new TestEvent(), true);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT_EQ(handler.getEventCount(), 3);
+    EXPECT_EQ(handler2.getEventCount(), 1);
+    
+    // Remove pipe
+    UEventsManager::removePipe(&sender, &handler, "TestEvent");
+    
+
+    // Post another event
+    UEventsManager::post(new TestEvent(), true, &sender);
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    // Should still receive events, no pipe filtering
+    EXPECT_EQ(handler.getEventCount(), 4);
+    EXPECT_EQ(handler2.getEventCount(), 2);
+    
+    UEventsManager::removeHandler(&handler);
+    UEventsManager::removeHandler(&handler2);
+}
+
+TEST(UEventsTest, UEventsManagerRemoveAllPipes)
+{
+    TestSender sender;
+    TestHandler handler1;
+    TestHandler handler2;
+    
+    UEventsManager::addHandler(&handler1);
+    UEventsManager::addHandler(&handler2);
+    
+    UEventsManager::createPipe(&sender, &handler1, "TestEvent");
+    UEventsManager::createPipe(&sender, &handler2, "AnotherEvent");
+
+    sender.testPost(new TestEvent());
+    sender.testPost(new AnotherEvent());
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT_EQ(handler1.getEventCount(), 1);
+    EXPECT_EQ(handler2.getEventCount(), 1);
+    
+    UEventsManager::removeAllPipes(&sender);
+    
+    sender.testPost(new TestEvent());
+    sender.testPost(new AnotherEvent());
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    EXPECT_EQ(handler1.getEventCount(), 3);
+    EXPECT_EQ(handler2.getEventCount(), 3);
+    
+    UEventsManager::removeHandler(&handler1);
+    UEventsManager::removeHandler(&handler2);
+}
+
+TEST(UEventsTest, MultipleEventTypes)
+{
+    FilteringHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    UEventsManager::post(new TestEvent(), true);
+    UEventsManager::post(new AnotherEvent(), true);
+    UEventsManager::post(new TestEvent(), true);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(100));
+    
+    EXPECT_EQ(handler.getTestEventCount(), 2);
+    EXPECT_EQ(handler.getAnotherEventCount(), 1);
+    
+    UEventsManager::removeHandler(&handler);
+}
+
+TEST(UEventsTest, HandlerReceivesCorrectEvent)
+{
+    TestHandler handler;
+    UEventsManager::addHandler(&handler);
+    
+    handler.reset();
+    
+    TestEvent* event = new TestEvent(42);
+    UEventsManager::post(event, true);
+    
+    std::this_thread::sleep_for(std::chrono::milliseconds(50));
+    
+    EXPECT_EQ(handler.getLastEventCode(), 42);
+    EXPECT_STREQ(handler.getLastEventClassName().c_str(), "TestEvent");
+    
+    UEventsManager::removeHandler(&handler);
+}
+