EventQueueTest.cpp File Reference

#include "modules/bentleyottmann/include/EventQueue.h"
#include "tests/Test.h"

Go to the source code of this file.

Classes
class	bentleyottmann::EventQueueTestingPeer
struct	TestEventHandler

Namespaces
namespace	bentleyottmann

Enumerations
enum	HasDeletions { kHasDeletions , kHasNoDeletions }

Functions
	DEF_TEST (BO_EventQueueOrdering, reporter)
	DEF_TEST (BO_EventQueueBasic, reporter)
	DEF_TEST (BO_EventQueueHandlerInterface, reporter)

Enumeration Type Documentation

HasDeletions

enum HasDeletions

Enumerator
kHasDeletions
kHasNoDeletions

Definition at line 130 of file EventQueueTest.cpp.

                  {
    kHasDeletions,   // The handleDeletions call should be called.
    kHasNoDeletions  // The handleDeletions call should not be called.
};

Function Documentation

DEF_TEST() [1/3]

DEF_TEST	(	BO_EventQueueBasic	,
		reporter
	)

Definition at line 51 of file EventQueueTest.cpp.

                                       {
    {
        EventQueue::Queue q;
        EventQueue eq{std::move(q)};
        REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
    }
    {
        EventQueue::Queue q;
        Point eventPoint = {100, 100};
        q.insert({eventPoint, Lower{} });
        EventQueue eq{std::move(q)};
        {
            REPORTER_ASSERT(reporter, eq.hasMoreEvents());
            Event e = EventQueueTestingPeer::NextEvent(&eq);
            REPORTER_ASSERT(reporter, e.where == eventPoint);
            REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
        }
    }
    { // Check that Lower events are de-duplicated.
        EventQueue::Queue q;
        Point eventPoint = {100, 100};
        q.insert({eventPoint, Lower{}});
        q.insert({eventPoint, Lower{}});
        EventQueue eq{std::move(q)};
        {
            // There should be only one lower because of queue de-duplication
            REPORTER_ASSERT(reporter, eq.hasMoreEvents());
            auto [p, _] = EventQueueTestingPeer::NextEvent(&eq);
            REPORTER_ASSERT(reporter, p == eventPoint);
            REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
        }
    }
    { // Check that Lower distinct Lower events are distinct.
        EventQueue::Queue q;
        Point eventPoint1 = {100, 100};
        Point eventPoint2 = {100, 101};
 
        q.insert({eventPoint1, Lower{}});
        q.insert({eventPoint2, Lower{}});
        EventQueue eq{std::move(q)};
        {
            // There should be only one lower because of queue de-duplication
            REPORTER_ASSERT(reporter, eq.hasMoreEvents());
            auto [p, _] = EventQueueTestingPeer::NextEvent(&eq);
            REPORTER_ASSERT(reporter, p == eventPoint1);
        }
        {
            // There should be only one lower because of queue de-duplication
            REPORTER_ASSERT(reporter, eq.hasMoreEvents());
            auto [p, _] = EventQueueTestingPeer::NextEvent(&eq);
            REPORTER_ASSERT(reporter, p == eventPoint2);
            REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
        }
    }
    { // Check that non-Lower events are separate.
        EventQueue::Queue q;
        Segment s0 {{0, 0}, {100, 100}};
        Segment s1 {{0, 0}, {-100, 100}};
        q.insert({Point{0, 0}, Upper{s0}});
        q.insert({Point{0, 0}, Upper{s1}});
        EventQueue eq{std::move(q)};
        {
            REPORTER_ASSERT(reporter, eq.hasMoreEvents());
            Event e = EventQueueTestingPeer::NextEvent(&eq);
            Point upperPt = Point{0, 0};
            REPORTER_ASSERT(reporter, e.where == upperPt);
            REPORTER_ASSERT(reporter, e.type.index() == 2);
            Upper upper = std::get<Upper>(e.type);
            REPORTER_ASSERT(reporter, !(upper < Upper{s1}) && !(Upper{s1} < upper));
            Event e2 = EventQueueTestingPeer::NextEvent(&eq);
            REPORTER_ASSERT(reporter, e2.where == upperPt);
            REPORTER_ASSERT(reporter, e2.type.index() == 2);
            Upper upper2 = std::get<Upper>(e2.type);
            REPORTER_ASSERT(reporter, !(upper2 < Upper{s0}) && !(Upper{s0} < upper2));
            REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
        }
    }
}

DEF_TEST() [2/3]

DEF_TEST	(	BO_EventQueueHandlerInterface	,
		reporter
	)

Definition at line 191 of file EventQueueTest.cpp.

                                                  {
    { // Check that a Lower event is added while processing the Upper event.
        EventQueue::Queue q;
        static constexpr Point eventPoint = {100, 100};
        static constexpr Point endPoint = {200, 200};
        static constexpr Segment s = {eventPoint, endPoint};
        q.insert(Event{eventPoint, Upper{s}});
        EventQueue eq{std::move(q)};
 
        REPORTER_ASSERT(reporter, eq.hasMoreEvents());
 
 
        TestEventHandler eh1{reporter, eventPoint, {}, {s}, {}, kHasNoDeletions};
        eq.handleNextEventPoint(&eh1);
 
        TestEventHandler eh2{reporter, endPoint, {}, {}, {}};
        eq.handleNextEventPoint(&eh2);
 
        REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
    }
 
    { // Check an entire crossing event.
        EventQueue::Queue q;
        static constexpr Point b0 = {100, 100};
        static constexpr Point e0 = {200, 200};
        static constexpr Segment s0 = {b0, e0};
        static constexpr Point b1 = {200, 100};
        static constexpr Point e1 = {100, 200};
        static constexpr Segment s1 = {b1, e1};
        static constexpr Point crossingPoint = {150, 150};
 
        // Load crossing segments into the queue
        q.insert(Event{b0, Upper{s0}});
        q.insert(Event{b1, Upper{s1}});
        EventQueue eq{std::move(q)};
 
        REPORTER_ASSERT(reporter, eq.hasMoreEvents());
 
        TestEventHandler eh1{reporter, b0, {}, {s0}, {}, kHasNoDeletions};
        eq.handleNextEventPoint(&eh1);
 
        TestEventHandler eh2{reporter, b1, {}, {s1}, {{s0, s1, crossingPoint}}, kHasNoDeletions};
        eq.handleNextEventPoint(&eh2);
 
        TestEventHandler eh3{reporter, crossingPoint, {s0, s1}, {s0, s1}, {}};
        eq.handleNextEventPoint(&eh3);
 
        TestEventHandler eh4{reporter, e1, {}, {}, {}};
        eq.handleNextEventPoint(&eh4);
 
        TestEventHandler eh5{reporter, e0, {}, {}, {}};
        eq.handleNextEventPoint(&eh5);
 
        REPORTER_ASSERT(reporter, !eq.hasMoreEvents());
    }
}

DEF_TEST() [3/3]

DEF_TEST	(	BO_EventQueueOrdering	,
		reporter
	)

Definition at line 28 of file EventQueueTest.cpp.

                                          {
    { // Check that event types are ordered correctly.
        EventQueue::Queue q;
 
        // Insert the events in reverse order.
        Point eventPoint = {100, 100};
        Segment s = {{100, 100}, {200, 200}};
        q.insert(Event{eventPoint, Upper{s}});
        Segment s0 = {{50, 50}, {150, 150}},
                s1 = {{150, 50}, {50, 150}};
        q.insert(Event{eventPoint, Cross{s0, s1}});
        q.insert(Event{eventPoint, Lower{}});
 
        // Make sure that the events are in the right order.
        auto cursor = q.begin();
        REPORTER_ASSERT(reporter, std::holds_alternative<Lower>(cursor->type));
        ++cursor;
        REPORTER_ASSERT(reporter, std::holds_alternative<Cross>(cursor->type));
        ++cursor;
        REPORTER_ASSERT(reporter, std::holds_alternative<Upper>(cursor->type));
    }
}