From 1d3b3359ca50fae886fdb31c219b0793185d5dbd Mon Sep 17 00:00:00 2001 From: EricLiu2000 Date: Thu, 27 Jun 2019 15:50:22 -0400 Subject: [PATCH] Wrote more tests, fixed bug with eventmanager::get(size), optimized eventmanager adding and shrinking, prevented trying to add TooManyEvents --- api/icsneocpp/eventmanager.cpp | 13 +++- include/icsneo/api/eventmanager.h | 11 +-- test/eventmanagertest.cpp | 117 +++++++++++++++++++++++++++--- 3 files changed, 121 insertions(+), 20 deletions(-) diff --git a/api/icsneocpp/eventmanager.cpp b/api/icsneocpp/eventmanager.cpp index a917678..c2c2c60 100644 --- a/api/icsneocpp/eventmanager.cpp +++ b/api/icsneocpp/eventmanager.cpp @@ -28,7 +28,7 @@ void EventManager::get(std::vector& eventOutput, size_t max, EventFilt if(filter.match(*it)) { eventOutput.push_back(*it); it = events.erase(it); - if(count++ >= max) + if(++count >= max) break; // We now have as many written to output as we can } else { it++; @@ -73,8 +73,12 @@ size_t EventManager::count_internal(EventFilter filter) const { * Returns true if any events were removed in the process of doing so. */ bool EventManager::enforceLimit() { - // Remove all TooManyEvents before checking - events.remove_if([](icsneo::APIEvent err){ return err.getType() == APIEvent::Type::TooManyEvents; }); + // Remove all TooManyEvents from the end before checking + auto filter = EventFilter(APIEvent::Type::TooManyEvents); + auto it = events.rbegin(); + while(it != events.rend() && filter.match(*it)) { + it = decltype(it){events.erase( std::next(it).base() )}; + } // We are not overflowing if(events.size() < eventLimit) @@ -97,6 +101,9 @@ APIEvent::Severity EventManager::lowestCurrentSeverity() const { if((*it).getSeverity() < lowest) lowest = (*it).getSeverity(); it++; + + if(lowest == APIEvent::Severity::EventInfo) + return lowest; } return lowest; } diff --git a/include/icsneo/api/eventmanager.h b/include/icsneo/api/eventmanager.h index 8e77284..e060172 100644 --- a/include/icsneo/api/eventmanager.h +++ b/include/icsneo/api/eventmanager.h @@ -96,11 +96,11 @@ private: */ void add_internal_error(APIEvent event) { std::thread::id id = std::this_thread::get_id(); - std::map::iterator iter = lastUserErrors.find(id); - if(iter == lastUserErrors.end()) + auto it = lastUserErrors.find(id); + if(it == lastUserErrors.end()) lastUserErrors.insert({id, event}); else - iter->second = event; + it->second = event; } /** @@ -114,14 +114,15 @@ private: // We are exactly full, either because the list was truncated or because we were simply full before if(events.size() == eventLimit - 1) { // If the event is worth adding - if(event.getSeverity() >= lowestCurrentSeverity()) { + if(event.getType() != APIEvent::Type::TooManyEvents && event.getSeverity() >= lowestCurrentSeverity()) { discardLeastSevere(1); events.push_back(event); } events.push_back(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning)); } else { - events.push_back(event); + if (event.getType() != APIEvent::Type::TooManyEvents) + events.push_back(event); } } diff --git a/test/eventmanagertest.cpp b/test/eventmanagertest.cpp index 058552c..671b185 100644 --- a/test/eventmanagertest.cpp +++ b/test/eventmanagertest.cpp @@ -58,29 +58,113 @@ TEST_F(EventManagerTest, GetLastErrorMultipleTest) { // Tests that adding and removing events properly updates EventCount(). Also tests that EventCount() does not go past the limit. TEST_F(EventManagerTest, CountTest) { + // Add an error event, should not go into events list. EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error)); EXPECT_EQ(EventCount(), 0); + + // Adds actual event EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); + + // Manually tries to add some TooManyEvents, these should not be added. + EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning)); + EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventInfo)); + EXPECT_EQ(EventCount(), 1); + + // Add another actual event EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo)); EXPECT_EQ(EventCount(), 2); + + // Take all info events (1) GetEvents(EventFilter(APIEvent::Severity::EventInfo)); EXPECT_EQ(EventCount(), 1); + + // Take all events GetEvents(); EXPECT_EQ(EventCount(), 0); - SetEventLimit(50); - for(int i = 0; i < 60; i++) - EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); + // default limit is 10000 + for(int i = 0; i < 11000; i++) + EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo)); - EXPECT_EQ(EventCount(), 50); + EXPECT_EQ(EventCount(), 10000); } -// -TEST_F(EventManagerTest, GetTest) { +// Test default get params +TEST_F(EventManagerTest, GetDefaultTest) { + for(int i = 0; i < 5; i++) { + EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning); + EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo); + // errors should not go in events + EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error); + } + + auto events = EventManager::GetInstance().get(); + + EXPECT_EQ(events.size(), 10); + + for(int i = 0; i < 5; i++) { + EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType); + EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventWarning); + + EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::SWCANSettingsNotAvailable); + EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo); + } } +// Test get with a size limit +TEST_F(EventManagerTest, GetSizeTest) { + + // Add 10 events + for(int i = 0; i < 5; i++) { + EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning); + EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo); + + // errors should not go in events + EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error); + } + + // Take 3 events, 7 left + auto events = EventManager::GetInstance().get(3); + + EXPECT_EQ(events.size(), 3); + EXPECT_EQ(EventCount(), 7); + + EXPECT_EQ(events.at(0).getType(), APIEvent::Type::UnexpectedNetworkType); + EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventWarning); + EXPECT_EQ(events.at(1).getType(), APIEvent::Type::SWCANSettingsNotAvailable); + EXPECT_EQ(events.at(1).getSeverity(), APIEvent::Severity::EventInfo); + EXPECT_EQ(events.at(2).getType(), APIEvent::Type::UnexpectedNetworkType); + EXPECT_EQ(events.at(2).getSeverity(), APIEvent::Severity::EventWarning); + + // Take 1 event, 6 left + events = EventManager::GetInstance().get(1); + + EXPECT_EQ(events.size(), 1); + EXPECT_EQ(EventCount(), 6); + + EXPECT_EQ(events.at(0).getType(), APIEvent::Type::SWCANSettingsNotAvailable); + EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventInfo); + + // Try to take 8 events, should actually take the 6 remaining. 0 left. + events = EventManager::GetInstance().get(8); + EXPECT_EQ(events.size(), 6); + EXPECT_EQ(EventCount(), 0); + + for(int i = 0; i < 3; i++) { + EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType); + EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventWarning); + + EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::SWCANSettingsNotAvailable); + EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo); + } +} + +// Test get with a filter (type, device, severity) + +// Test get with both size limit and filter + // Tests that setting the event limit works in normal conditions, if the new limit is too small, and if the list needs truncating TEST_F(EventManagerTest, SetEventLimitTest) { // Test if event limit too low to be set @@ -89,16 +173,25 @@ TEST_F(EventManagerTest, SetEventLimitTest) { EXPECT_EQ(GetLastError().getType(), APIEvent::Type::ParameterOutOfRange); // Test truncating existing list when new limit set - for(int i = 0; i < 100; i++) + for(int i = 0; i < 9001; i++) EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); - EXPECT_EQ(EventCount(), 100); + EXPECT_EQ(EventCount(), 9001); - SetEventLimit(50); - EXPECT_EQ(GetEventLimit(), 50); + SetEventLimit(5000); + EXPECT_EQ(GetEventLimit(), 5000); + EXPECT_EQ(EventCount(), 5000); + + // auto events = GetEvents(); + // for(int i = 0; i < 4998; i++) { + // EXPECT_EQ(events.at(i).getType(), APIEvent::Type::OutputTruncated); + // } + // EXPECT_EQ(events.at(4999).getType(), APIEvent::Type::TooManyEvents); +} + +// Tests that setting the event limit when already overflowing works +TEST_F(EventManagerTest, SetEventLimitOverflowTest) { - // maybe 5001? since TooManyEvents is in there too. - EXPECT_EQ(EventCount(), 50); } // Tests the case where too many warnings are added