diff --git a/test/eventmanagertest.cpp b/test/eventmanagertest.cpp
index 4e5223c..0adfb15 100644
--- a/test/eventmanagertest.cpp
+++ b/test/eventmanagertest.cpp
@@ -9,10 +9,10 @@ using namespace icsneo;
 
 class EventManagerTest : public ::testing::Test {
 protected:
-    // Start with a clean instance of eventmanager for every test
-    void SetUp() override {
-        EventManager::GetInstance().ResetInstance();
-    }
+	// Start with a clean instance of eventmanager for every test
+	void SetUp() override {
+		EventManager::GetInstance().ResetInstance();
+	}
 };
 
 /**
@@ -21,68 +21,68 @@ protected:
  * Each callback also flushes the event buffer upon call.
  */
 TEST_F(EventManagerTest, MultithreadedEventCallbacksTest) {
-    int callCounter = 0;
-    std::mutex mutex;
+	int callCounter = 0;
+	std::mutex mutex;
 
-    std::thread t1([&callCounter, &mutex]() {
-        // increments counter when baudrate events show up
-        int id1 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter, &mutex](std::shared_ptr<APIEvent>){
-            std::lock_guard<std::mutex> lk(mutex);
-            callCounter++;
-            EventManager::GetInstance().get();
-        }, EventFilter(APIEvent::Type::BaudrateNotFound)));
+	std::thread t1([&callCounter, &mutex]() {
+		// increments counter when baudrate events show up
+		int id1 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter, &mutex](std::shared_ptr<APIEvent>){
+			std::lock_guard<std::mutex> lk(mutex);
+			callCounter++;
+			EventManager::GetInstance().get();
+		}, EventFilter(APIEvent::Type::BaudrateNotFound)));
 
-        // shouldn't add anything
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventWarning));
+		// shouldn't add anything
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventWarning));
 
-        // should add 1
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning));
+		// should add 1
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning));
 
-        EventManager::GetInstance().removeEventCallback(id1);
+		EventManager::GetInstance().removeEventCallback(id1);
 
-    });
+	});
 
-    std::thread t2([&callCounter, &mutex]() {
-        // increments counter when infos show up
-        int id2 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter, &mutex](std::shared_ptr<APIEvent>) {
-            std::lock_guard<std::mutex> lk(mutex);
-            callCounter++;
-            EventManager::GetInstance().get();
-        }, EventFilter(APIEvent::Severity::EventInfo)));
+	std::thread t2([&callCounter, &mutex]() {
+		// increments counter when infos show up
+		int id2 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter, &mutex](std::shared_ptr<APIEvent>) {
+			std::lock_guard<std::mutex> lk(mutex);
+			callCounter++;
+			EventManager::GetInstance().get();
+		}, EventFilter(APIEvent::Severity::EventInfo)));
 
-        // shouldn't add anything
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventWarning));
+		// shouldn't add anything
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventWarning));
 
-        // should add 1
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventInfo));
+		// should add 1
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::EventInfo));
 
-        EventManager::GetInstance().removeEventCallback(id2);
-    });
+		EventManager::GetInstance().removeEventCallback(id2);
+	});
 
-    t1.join();
-    t2.join();
+	t1.join();
+	t2.join();
 
-    EXPECT_EQ(EventCount(), 0);
+	EXPECT_EQ(EventCount(), 0);
 
-    EXPECT_EQ(callCounter, 2);
+	EXPECT_EQ(callCounter, 2);
 
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(EventCount(), 1);
+	EXPECT_EQ(EventCount(), 1);
 
-    EXPECT_EQ(callCounter, 2);
+	EXPECT_EQ(callCounter, 2);
 }
 
 /**
  * Tests behavior of adding and removing multiple event callbacks on a single thread.
  */
 TEST_F(EventManagerTest, SingleThreadEventCallbacksTest) {
-    int callCounter = 0;
+	int callCounter = 0;
 
 	// increments counter when baudrate events show up
-    int id1 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter](std::shared_ptr<APIEvent>){
-        callCounter++;
-    }, EventFilter(APIEvent::Type::BaudrateNotFound)));
+	int id1 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter](std::shared_ptr<APIEvent>){
+		callCounter++;
+	}, EventFilter(APIEvent::Type::BaudrateNotFound)));
 
 	// increments counter when infos show up
 	int id2 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter](std::shared_ptr<APIEvent>) {
@@ -95,7 +95,7 @@ TEST_F(EventManagerTest, SingleThreadEventCallbacksTest) {
 
 	EXPECT_EQ(callCounter, 0);
 
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning));
 
 	EXPECT_EQ(callCounter, 1);
 
@@ -117,31 +117,31 @@ TEST_F(EventManagerTest, SingleThreadEventCallbacksTest) {
 
 	EXPECT_EQ(callCounter, 5);
 
-    // increments counter when device currently open shows up
+	// increments counter when device currently open shows up
 	int id3 = EventManager::GetInstance().addEventCallback(EventCallback([&callCounter](std::shared_ptr<APIEvent>) {
 		callCounter++;
 	}, EventFilter(APIEvent::Type::DeviceCurrentlyOpen)));
 
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
 
 	EXPECT_EQ(callCounter, 6);
 
-    EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id2), false);
+	EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id2), false);
 	EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id1), true);
 	
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(callCounter, 6);
+	EXPECT_EQ(callCounter, 6);
 
 	EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
 
 	EXPECT_EQ(callCounter, 7);
 
-    EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id3), true);
+	EXPECT_EQ(EventManager::GetInstance().removeEventCallback(id3), true);
 
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOpen, APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(callCounter, 7);
+	EXPECT_EQ(callCounter, 7);
 }
 
 /**
@@ -210,110 +210,110 @@ TEST_F(EventManagerTest, ErrorDowngradingTest) {
  */
 TEST_F(EventManagerTest, MultithreadedTest) {
 
-    // Check that main thread has no errors
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+	// Check that main thread has no errors
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-    // Adds 500 {OutputTruncated, Warning} and 500 {OutputTruncated, Info}
-    // Adds and checks errors as well.
-    std::thread t1( []() {
-        for(int i = 0; i < 500; i++) {
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
-        }
+	// Adds 500 {OutputTruncated, Warning} and 500 {OutputTruncated, Info}
+	// Adds and checks errors as well.
+	std::thread t1( []() {
+		for(int i = 0; i < 500; i++) {
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
+		}
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::BufferInsufficient, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::BufferInsufficient, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::BufferInsufficient);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::BufferInsufficient);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::OutputTruncated);
-    });
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::OutputTruncated);
+	});
 
-    // Check that main thread has no errors
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+	// Check that main thread has no errors
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-    // Adds 500 {CANFDNotSupported, Warning} and 500 {CANFDSettingsNotAvailable, Info}
-    // Adds and checks errors as well.
-    std::thread t2( []() {
-        for(int i = 0; i < 500; i++) {
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo));
-        }
+	// Adds 500 {CANFDNotSupported, Warning} and 500 {CANFDSettingsNotAvailable, Info}
+	// Adds and checks errors as well.
+	std::thread t2( []() {
+		for(int i = 0; i < 500; i++) {
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo));
+		}
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error));
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyClosed, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOffline, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOffline);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOffline);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOnline, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::DeviceCurrentlyOnline, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOnline);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::DeviceCurrentlyOnline);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error));
-    });
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::Error));
+	});
 
-    // Check that main thread has no errors
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+	// Check that main thread has no errors
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-    // Adds 500 {CANFDNotSupported, Warning} and 500 {FailedToWrite, Info}
-    // Adds and checks errors as well.
-    std::thread t3( []() {
-        for(int i = 0; i < 500; i++) {
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
-            EventManager::GetInstance().add(APIEvent(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo));
-        }
+	// Adds 500 {CANFDNotSupported, Warning} and 500 {FailedToWrite, Info}
+	// Adds and checks errors as well.
+	std::thread t3( []() {
+		for(int i = 0; i < 500; i++) {
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
+			EventManager::GetInstance().add(APIEvent(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo));
+		}
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::NoSerialNumber, APIEvent::Severity::Error));
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsChecksumError, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::NoSerialNumber, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsChecksumError, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SettingsChecksumError);
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SettingsChecksumError);
 
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error));
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::Error));
 
-        EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SWCANSettingsNotAvailable);
-    });
+		EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+	});
 
-    // Check that main thread has no errors
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+	// Check that main thread has no errors
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-    // Wait for threads to finish
-    t1.join();
-    t2.join();
-    t3.join();
+	// Wait for threads to finish
+	t1.join();
+	t2.join();
+	t3.join();
 
-    // Check that main thread has no errors
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
+	// Check that main thread has no errors
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
 
-    // Should be 500 {OutputTruncated, Warning}, 500 {OutputTruncated, Info}, 1000 {CANFDNotSupported, Warning}, 500 {CANFDSettingsNotAvailable, Info}, 500 {FailedToWrite, Info}
-    EXPECT_EQ(EventCount(), 3000);
+	// Should be 500 {OutputTruncated, Warning}, 500 {OutputTruncated, Info}, 1000 {CANFDNotSupported, Warning}, 500 {CANFDSettingsNotAvailable, Info}, 500 {FailedToWrite, Info}
+	EXPECT_EQ(EventCount(), 3000);
 
-    auto events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
-    EXPECT_EQ(EventCount(), 2500);
-    EXPECT_EQ(events.size(), 500);
+	auto events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
+	EXPECT_EQ(EventCount(), 2500);
+	EXPECT_EQ(events.size(), 500);
 
-    events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
-    EXPECT_EQ(EventCount(), 2000);
-    EXPECT_EQ(events.size(), 500);
+	events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
+	EXPECT_EQ(EventCount(), 2000);
+	EXPECT_EQ(events.size(), 500);
 
-    events = GetEvents(EventFilter(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
-    EXPECT_EQ(EventCount(), 1000);
-    EXPECT_EQ(events.size(), 1000);
+	events = GetEvents(EventFilter(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
+	EXPECT_EQ(EventCount(), 1000);
+	EXPECT_EQ(events.size(), 1000);
 
-    events = GetEvents(EventFilter(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo));
-    EXPECT_EQ(EventCount(), 500);
-    EXPECT_EQ(events.size(), 500);
+	events = GetEvents(EventFilter(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo));
+	EXPECT_EQ(EventCount(), 500);
+	EXPECT_EQ(events.size(), 500);
 
-    events = GetEvents(EventFilter(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo));
-    EXPECT_EQ(EventCount(), 0);
-    EXPECT_EQ(events.size(), 500);
+	events = GetEvents(EventFilter(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo));
+	EXPECT_EQ(EventCount(), 0);
+	EXPECT_EQ(events.size(), 500);
 }
 
 /**
@@ -321,67 +321,67 @@ TEST_F(EventManagerTest, MultithreadedTest) {
  * Checks that EventCount() updates accordingly, even when overflowing (trying to add 11000 events when the limit is 10000)
  */
 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);
+	// 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));
+	// 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));
+	// 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);
+	EXPECT_EQ(EventCount(), 1);
 
-    // Add another actual event
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
-    EXPECT_EQ(EventCount(), 2);
+	// 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 info events (1)
+	GetEvents(EventFilter(APIEvent::Severity::EventInfo));
+	EXPECT_EQ(EventCount(), 1);
 
-    // Take all events
-    GetEvents();
-    EXPECT_EQ(EventCount(), 0);
+	// Take all events
+	GetEvents();
+	EXPECT_EQ(EventCount(), 0);
 
-    // default limit is 10000
-    for(int i = 0; i < 11000; 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::EventWarning));
 
-    EXPECT_EQ(EventCount(), 10000);
+	EXPECT_EQ(EventCount(), 10000);
 }
 
 /**
  * Checks that the default get() clears out and returns all events.
  */
 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);
+	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);
-    }
+		// errors should not go in events
+		EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
+	}
 
-    auto events = EventManager::GetInstance().get();
+	auto events = EventManager::GetInstance().get();
 
-    EXPECT_EQ(events.size(), 10);
-    EXPECT_EQ(EventCount(), 0);
+	EXPECT_EQ(events.size(), 10);
+	EXPECT_EQ(EventCount(), 0);
 
-    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);
+	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);
-    }
+		EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+		EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
+	}
 
-    // Check getting when 0 events exist doesn't break
-    events = EventManager::GetInstance().get();
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 0);
+	// Check getting when 0 events exist doesn't break
+	events = EventManager::GetInstance().get();
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
@@ -389,216 +389,216 @@ TEST_F(EventManagerTest, GetDefaultTest) {
  */
 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);
+	// 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);
-    }
+		// 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);
+	// Take 3 events, 7 left
+	auto events = EventManager::GetInstance().get(3);
 
-    EXPECT_EQ(events.size(), 3);
-    EXPECT_EQ(EventCount(), 7);
+	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);
+	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);
+	// Take 1 event, 6 left
+	events = EventManager::GetInstance().get(1);
 
-    EXPECT_EQ(events.size(), 1);
-    EXPECT_EQ(EventCount(), 6);
+	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);
+	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);
+	// 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);
+	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);
-    }
+		EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+		EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
+	}
 
-    // Check getting when 0 events exist doesn't break
-    events = EventManager::GetInstance().get(5);
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 0);
+	// Check getting when 0 events exist doesn't break
+	events = EventManager::GetInstance().get(5);
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
  * Checks that get() with a filter param only flushes and returns the events matching the filter.
  */
 TEST_F(EventManagerTest, GetFilterTest) {
-    // Add 20 events
-    for(int i = 0; i < 5; i++) {
-        // {network, warning}, {settings, info}, {network, info}, {mismatch, warning}
-        EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning);
-        EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::SettingsStructureMismatch, APIEvent::Severity::EventWarning);
+	// Add 20 events
+	for(int i = 0; i < 5; i++) {
+		// {network, warning}, {settings, info}, {network, info}, {mismatch, warning}
+		EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning);
+		EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::SettingsStructureMismatch, APIEvent::Severity::EventWarning);
 
-        // errors should not go in events
-        EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
-    }
+		// errors should not go in events
+		EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
+	}
 
-    // Get all 5 {network, warning}. 15 left.
-    auto events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
+	// Get all 5 {network, warning}. 15 left.
+	auto events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
 
-    EXPECT_EQ(events.size(), 5);
-    EXPECT_EQ(EventCount(), 15);
+	EXPECT_EQ(events.size(), 5);
+	EXPECT_EQ(EventCount(), 15);
 
-    for(APIEvent event : events) {
-        EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
-        EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
-    }
+	for(APIEvent event : events) {
+		EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
+		EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
+	}
 
-    // Get all 10 infos. 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(EventFilter(APIEvent::Severity::EventInfo));
+	// Get all 10 infos. 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(EventFilter(APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(events.size(), 10);
-    EXPECT_EQ(EventCount(), 5);
+	EXPECT_EQ(events.size(), 10);
+	EXPECT_EQ(EventCount(), 5);
 
-    for(int i = 0; i < 5; i++) {
-        EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
-        EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
+	for(int i = 0; i < 5; i++) {
+		EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+		EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
 
-        EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
-        EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
-    }
+		EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
+		EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
+	}
 
-    // (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 5);
+	// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 5);
 
-    // Get the 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SettingsStructureMismatch));
-    EXPECT_EQ(events.size(), 5);
-    EXPECT_EQ(EventCount(), 0);
+	// Get the 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SettingsStructureMismatch));
+	EXPECT_EQ(events.size(), 5);
+	EXPECT_EQ(EventCount(), 0);
 
-    for(APIEvent event : events) {
-        EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
-        EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
-    }
+	for(APIEvent event : events) {
+		EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
+		EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
+	}
 
-    // Check getting when 0 events exist doesn't break
-    events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 0);
+	// Check getting when 0 events exist doesn't break
+	events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
  * Checks that get() with both a size and filter param only flushes and returns the desired amount of events matching the filter.
  */
 TEST_F(EventManagerTest, GetSizeFilterTest) {
-    // Add 20 events
-    for(int i = 0; i < 5; i++) {
-        // {network, warning}, {settings, info}, {network, info}, {mismatch, warning}
-        EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning);
-        EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::SettingsStructureMismatch, APIEvent::Severity::EventWarning);
+	// Add 20 events
+	for(int i = 0; i < 5; i++) {
+		// {network, warning}, {settings, info}, {network, info}, {mismatch, warning}
+		EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning);
+		EventManager::GetInstance().add(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::SettingsStructureMismatch, APIEvent::Severity::EventWarning);
 
-        // errors should not go in events
-        EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
-    }
+		// errors should not go in events
+		EventManager::GetInstance().add(APIEvent::Type::SettingsVersionError, APIEvent::Severity::Error);
+	}
 
-    // Get all 5 {network, warning}. 15 left.
-    auto events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
+	// Get all 5 {network, warning}. 15 left.
+	auto events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
 
-    EXPECT_EQ(events.size(), 5);
-    EXPECT_EQ(EventCount(), 15);
+	EXPECT_EQ(events.size(), 5);
+	EXPECT_EQ(EventCount(), 15);
 
-    for(APIEvent event : events) {
-        EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
-        EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
-    }
+	for(APIEvent event : events) {
+		EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
+		EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
+	}
 
-    // Get 6 infos. 4 infos and 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Severity::EventInfo));
+	// Get 6 infos. 4 infos and 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(events.size(), 6);
-    EXPECT_EQ(EventCount(), 9);
+	EXPECT_EQ(events.size(), 6);
+	EXPECT_EQ(EventCount(), 9);
 
-    for(int i = 0; i < 3; i++) {
-        EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
-        EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
+	for(int i = 0; i < 3; i++) {
+		EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+		EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
 
-        EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
-        EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
-    }
+		EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
+		EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
+	}
 
-    // Get 4 remaining infos. 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(4, EventFilter(APIEvent::Severity::EventInfo));
+	// Get 4 remaining infos. 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(4, EventFilter(APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(events.size(), 4);
-    EXPECT_EQ(EventCount(), 5);
+	EXPECT_EQ(events.size(), 4);
+	EXPECT_EQ(EventCount(), 5);
 
-    for(int i = 0; i < 2; i++) {
-        EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
-        EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
+	for(int i = 0; i < 2; i++) {
+		EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+		EXPECT_EQ(events.at(2 * i).getSeverity(), APIEvent::Severity::EventInfo);
 
-        EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
-        EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
-    }
+		EXPECT_EQ(events.at(2 * i + 1).getType(), APIEvent::Type::UnexpectedNetworkType);
+		EXPECT_EQ(events.at(2 * i + 1).getSeverity(), APIEvent::Severity::EventInfo);
+	}
 
-    // (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(-1, EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 5);
+	// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(-1, EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 5);
 
-    // Get the 5 {mismatch, warning} remaining.
-    events = EventManager::GetInstance().get(5, EventFilter(APIEvent::Type::SettingsStructureMismatch));
-    EXPECT_EQ(events.size(), 5);
-    EXPECT_EQ(EventCount(), 0);
+	// Get the 5 {mismatch, warning} remaining.
+	events = EventManager::GetInstance().get(5, EventFilter(APIEvent::Type::SettingsStructureMismatch));
+	EXPECT_EQ(events.size(), 5);
+	EXPECT_EQ(EventCount(), 0);
 
-    for(APIEvent event : events) {
-        EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
-        EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
-    }
+	for(APIEvent event : events) {
+		EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
+		EXPECT_EQ(event.getSeverity(), APIEvent::Severity::EventWarning);
+	}
 
-    // Check getting when 0 events exist doesn't break
-    events = EventManager::GetInstance().get(2, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
-    EXPECT_EQ(events.size(), 0);
-    EXPECT_EQ(EventCount(), 0);
+	// Check getting when 0 events exist doesn't break
+	events = EventManager::GetInstance().get(2, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
+	EXPECT_EQ(events.size(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
  * Checks that adding 1 error and calling GetLastError() twice will first return the error then return a NoErrorFound info message. Singlethreaded.
  */
 TEST_F(EventManagerTest, GetLastErrorSingleTest) {
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::OutputTruncated);
-    auto err = GetLastError();
-    EXPECT_EQ(err.getType(), APIEvent::Type::NoErrorFound);
-    EXPECT_EQ(err.getSeverity(), APIEvent::Severity::EventInfo);
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::OutputTruncated);
+	auto err = GetLastError();
+	EXPECT_EQ(err.getType(), APIEvent::Type::NoErrorFound);
+	EXPECT_EQ(err.getSeverity(), APIEvent::Severity::EventInfo);
 }
 
 /**
  * Checks that adding multiple errors and calling GetLastError() twice will first return the last error then return a NoErrorFound info message. Singlethreaded.
  */
 TEST_F(EventManagerTest, GetLastErrorMultipleTest) {
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error));
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsNotAvailable, APIEvent::Severity::Error));
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SettingsNotAvailable);
-    auto err = GetLastError();
-    EXPECT_EQ(err.getType(), APIEvent::Type::NoErrorFound);
-    EXPECT_EQ(err.getSeverity(), APIEvent::Severity::EventInfo);
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::Error));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsNotAvailable, APIEvent::Severity::Error));
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::SettingsNotAvailable);
+	auto err = GetLastError();
+	EXPECT_EQ(err.getType(), APIEvent::Type::NoErrorFound);
+	EXPECT_EQ(err.getSeverity(), APIEvent::Severity::EventInfo);
 }
 
 /**
@@ -607,32 +607,32 @@ TEST_F(EventManagerTest, GetLastErrorMultipleTest) {
  */
 TEST_F(EventManagerTest, TestAddWarningsOverflow) {
 
-    // space for 49 normal events, 1 reserved for TooManyEvents
-    SetEventLimit(50);
+	// space for 49 normal events, 1 reserved for TooManyEvents
+	SetEventLimit(50);
 
-    // 3 of these
-    for(int i = 0; i < 3; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
+	// 3 of these
+	for(int i = 0; i < 3; i++)
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
 
-    // 1 info
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo));
+	// 1 info
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::SWCANSettingsNotAvailable, APIEvent::Severity::EventInfo));
 
-    // 48 of these
-    for(int i = 0; i < 48; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::EventWarning));
+	// 48 of these
+	for(int i = 0; i < 48; i++)
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::EventWarning));
 
-    auto events = GetEvents();
+	auto events = GetEvents();
 
-    EXPECT_EQ(events.at(0).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
-    EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventInfo);
+	EXPECT_EQ(events.at(0).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
+	EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventInfo);
 
-    for(int i = 1; i < 49; i++) {
-        EXPECT_EQ(events.at(i).getType(), APIEvent::Type::ParameterOutOfRange);
-        EXPECT_EQ(events.at(i).getSeverity(), APIEvent::Severity::EventWarning);
-    }
+	for(int i = 1; i < 49; i++) {
+		EXPECT_EQ(events.at(i).getType(), APIEvent::Type::ParameterOutOfRange);
+		EXPECT_EQ(events.at(i).getSeverity(), APIEvent::Severity::EventWarning);
+	}
 
-    EXPECT_EQ(events.at(49).getType(), APIEvent::Type::TooManyEvents);
-    EXPECT_EQ(events.at(49).getSeverity(), APIEvent::Severity::EventWarning);
+	EXPECT_EQ(events.at(49).getType(), APIEvent::Type::TooManyEvents);
+	EXPECT_EQ(events.at(49).getSeverity(), APIEvent::Severity::EventWarning);
 }
 
 /**
@@ -641,109 +641,109 @@ TEST_F(EventManagerTest, TestAddWarningsOverflow) {
  */
 TEST_F(EventManagerTest, TestAddWarningsInfoOverflow) {
 
-    // space for 49 normal events, 1 reserved for TooManyEvents
-    SetEventLimit(50);
+	// space for 49 normal events, 1 reserved for TooManyEvents
+	SetEventLimit(50);
 
-    // Event list filling: 1 warning, 3 info, 47 warning.
-    // Expect to see: 2 info, 47 warning, 1 TooManyEvents
+	// Event list filling: 1 warning, 3 info, 47 warning.
+	// Expect to see: 2 info, 47 warning, 1 TooManyEvents
 
-    EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsVersionError, APIEvent::Severity::EventWarning));
+	EventManager::GetInstance().add(APIEvent(APIEvent::Type::SettingsVersionError, APIEvent::Severity::EventWarning));
 
-    // 3 of these
-    for(int i = 0; i < 3; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
+	// 3 of these
+	for(int i = 0; i < 3; i++)
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
 
-    // 47 of these
-    for(int i = 0; i < 47; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::EventWarning));
+	// 47 of these
+	for(int i = 0; i < 47; i++)
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::ParameterOutOfRange, APIEvent::Severity::EventWarning));
 
-    auto events = GetEvents();
+	auto events = GetEvents();
 
-    for(int i = 0; i < 2; i++) {
-        EXPECT_EQ(events.at(i).getType(), APIEvent::Type::OutputTruncated);
-    }
+	for(int i = 0; i < 2; i++) {
+		EXPECT_EQ(events.at(i).getType(), APIEvent::Type::OutputTruncated);
+	}
 
-    for(int i = 2; i < 49; i++)
-        EXPECT_EQ(events.at(i).getType(), APIEvent::Type::ParameterOutOfRange);
+	for(int i = 2; i < 49; i++)
+		EXPECT_EQ(events.at(i).getType(), APIEvent::Type::ParameterOutOfRange);
 
-    EXPECT_EQ(events.at(49).getType(), APIEvent::Type::TooManyEvents);
+	EXPECT_EQ(events.at(49).getType(), APIEvent::Type::TooManyEvents);
 }
 
 /**
  * Checks that discarding with no params flushes every event.
  */
 TEST_F(EventManagerTest, DiscardDefault) {
-    for(int i = 0; i < 3000; i++) {
-        EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning);
-        EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
-    }
+	for(int i = 0; i < 3000; i++) {
+		EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning);
+		EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
+	}
 
-    EXPECT_EQ(EventCount(), 9000);
+	EXPECT_EQ(EventCount(), 9000);
 
-    DiscardEvents();
+	DiscardEvents();
 
-    EXPECT_EQ(EventCount(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
  * Checks that discarding with a filter only flushes events matching the filter.
  */
 TEST_F(EventManagerTest, DiscardFilter) {
-    for(int i = 0; i < 3000; i++) {
-        EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo);
-        EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning);
-        EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
-    }
+	for(int i = 0; i < 3000; i++) {
+		EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo);
+		EventManager::GetInstance().add(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventWarning);
+		EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
+	}
 
-    EXPECT_EQ(EventCount(), 9000);
+	EXPECT_EQ(EventCount(), 9000);
 
-    DiscardEvents(EventFilter(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
+	DiscardEvents(EventFilter(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(EventCount(), 6000);
+	EXPECT_EQ(EventCount(), 6000);
 
-    DiscardEvents(EventFilter(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventInfo));
+	DiscardEvents(EventFilter(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventInfo));
 
-    EXPECT_EQ(EventCount(), 6000);
+	EXPECT_EQ(EventCount(), 6000);
 
-    DiscardEvents(EventFilter(APIEvent::Severity::EventWarning));
+	DiscardEvents(EventFilter(APIEvent::Severity::EventWarning));
 
-    EXPECT_EQ(EventCount(), 0);
+	EXPECT_EQ(EventCount(), 0);
 }
 
 /**
  * Checks setting the event limit when truncating is not required, when the new limit is < 10, and when the new limit < num events.
  */
 TEST_F(EventManagerTest, SetEventLimitTest) {
-    // Test if event limit too low to be set
-    EventManager::GetInstance().setEventLimit(9);
-    EXPECT_EQ(GetEventLimit(), 10000);
-    EXPECT_EQ(GetLastError().getType(), APIEvent::Type::ParameterOutOfRange);
+	// Test if event limit too low to be set
+	EventManager::GetInstance().setEventLimit(9);
+	EXPECT_EQ(GetEventLimit(), 10000);
+	EXPECT_EQ(GetLastError().getType(), APIEvent::Type::ParameterOutOfRange);
 
-    // Test truncating existing list when new limit set
-    for(int i = 0; i < 9001; i++)
-        EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
+	// Test truncating existing list when new limit set
+	for(int i = 0; i < 9001; i++)
+		EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
 
-    EXPECT_EQ(EventCount(), 9001);
+	EXPECT_EQ(EventCount(), 9001);
 
-    // Sets new limit to be exactly full.
-    SetEventLimit(9002);
-    EXPECT_EQ(GetEventLimit(), 9002);
-    EXPECT_EQ(EventCount(), 9001);
+	// Sets new limit to be exactly full.
+	SetEventLimit(9002);
+	EXPECT_EQ(GetEventLimit(), 9002);
+	EXPECT_EQ(EventCount(), 9001);
 
-    // 1 overflowed.
-    SetEventLimit(9001);
-    EXPECT_EQ(GetEventLimit(), 9001);
-    EXPECT_EQ(EventCount(), 9001);
+	// 1 overflowed.
+	SetEventLimit(9001);
+	EXPECT_EQ(GetEventLimit(), 9001);
+	EXPECT_EQ(EventCount(), 9001);
 
-    // Truncate a lot
-    SetEventLimit(5000);
-    EXPECT_EQ(GetEventLimit(), 5000);
-    EXPECT_EQ(EventCount(), 5000);
+	// Truncate a lot
+	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);
+	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);
 }
\ No newline at end of file
diff --git a/test/main.cpp b/test/main.cpp
index 8401258..a99181d 100644
--- a/test/main.cpp
+++ b/test/main.cpp
@@ -1,6 +1,6 @@
 #include "gtest/gtest.h"
 
 int main(int argc, char** argv) {
-    ::testing::InitGoogleTest(&argc, argv);
-    return RUN_ALL_TESTS();
+	::testing::InitGoogleTest(&argc, argv);
+	return RUN_ALL_TESTS();
 }
\ No newline at end of file