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

api/icsneocpp/eventmanager.cpp

@@ -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
+	// Remove all TooManyEvents from the end before checking
-	events.remove_if([](icsneo::APIEvent err){ return err.getType() == APIEvent::Type::TooManyEvents; });
+	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;
 }

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<std::thread::id, APIEvent>::iterator iter = lastUserErrors.find(id);
+		auto it = lastUserErrors.find(id);
-		if(iter == lastUserErrors.end())
+		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);
 		}
 	}
 

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);
+    // default limit is 10000
-    for(int i = 0; i < 60; i++)
+    for(int i = 0; i < 11000; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
+        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
     
-    EXPECT_EQ(EventCount(), 50);
+    EXPECT_EQ(EventCount(), 10000);
 }
 
-// 
+// Test default get params
-TEST_F(EventManagerTest, GetTest) {
+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);
+    SetEventLimit(5000);
-    EXPECT_EQ(GetEventLimit(), 50);
+    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