sven
/
libicsneo
mirror of https://github.com/intrepidcs/libicsneo.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Wrote more tests, fixed bug with eventmanager::get(size), optimized eventmanager adding and shrinking, prevented trying to add TooManyEvents

checksum-failure-logging
EricLiu2000 2019-06-27 15:50:22 -04:00
parent d0c6aba0fc
commit 1d3b3359ca
3 changed files with 121 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
api/icsneocpp/eventmanager.cpp
View File

@ -28,7 +28,7 @@ void EventManager::get(std::vector<APIEvent>& 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;
}

11
include/icsneo/api/eventmanager.h
View File

@ -96,11 +96,11 @@ private:
*/
void add_internal_error(APIEvent event) {
std::thread::id id = std::this_thread::get_id();
std::map<std::thread::id, APIEvent>::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);
}
}

117
test/eventmanagertest.cpp
View File

@ -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