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

Tests: Resolve MSVC x86 warnings

add-device-sharing
Paul Hollinsky 2022-02-22 10:46:30 -05:00
parent 95de93aa84
commit 2c282fe396
2 changed files with 82 additions and 82 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
test/ethernetpacketizertest.cpp
View File

@ -35,7 +35,7 @@ TEST_F(EthernetPacketizerTest, DownSmallSinglePacket)
{ {
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 1); ASSERT_EQ(output.size(), 1u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -53,7 +53,7 @@ TEST_F(EthernetPacketizerTest, DownSmallMultiplePackets)
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee });
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 1); ASSERT_EQ(output.size(), 1u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -73,7 +73,7 @@ TEST_F(EthernetPacketizerTest, DownSmallMultiplePacketsOverflow)
packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee });
packetizer->inputDown(std::vector<uint8_t>(1480)); // Near the max packetizer->inputDown(std::vector<uint8_t>(1480)); // Near the max
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 2); ASSERT_EQ(output.size(), 2u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -105,7 +105,7 @@ TEST_F(EthernetPacketizerTest, DownOverflowSmallMultiplePackets)
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee });
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 2); ASSERT_EQ(output.size(), 2u);
std::vector<uint8_t> bigOutput({ std::vector<uint8_t> bigOutput({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -137,7 +137,7 @@ TEST_F(EthernetPacketizerTest, DownBigSmallSmall)
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); // Not enough room for this one packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); // Not enough room for this one
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 2); ASSERT_EQ(output.size(), 2u);
std::vector<uint8_t> bigOutput({ std::vector<uint8_t> bigOutput({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -169,7 +169,7 @@ TEST_F(EthernetPacketizerTest, DownJumboSmallSmall)
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee }); packetizer->inputDown({ 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee, 0xc0, 0xff, 0xee });
const auto output = packetizer->outputDown(); const auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 3); ASSERT_EQ(output.size(), 3u);
std::vector<uint8_t> bigOutput({ std::vector<uint8_t> bigOutput({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -211,7 +211,7 @@ TEST_F(EthernetPacketizerTest, PacketNumberIncrement)
{ {
packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
auto output = packetizer->outputDown(); auto output = packetizer->outputDown();
ASSERT_EQ(output.size(), 1); ASSERT_EQ(output.size(), 1u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -225,7 +225,7 @@ TEST_F(EthernetPacketizerTest, PacketNumberIncrement)
packetizer->inputDown({ 0x12, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x12, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
output = packetizer->outputDown(); output = packetizer->outputDown();
ASSERT_EQ(output.size(), 1); ASSERT_EQ(output.size(), 1u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,
@ -239,7 +239,7 @@ TEST_F(EthernetPacketizerTest, PacketNumberIncrement)
packetizer->inputDown({ 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 }); packetizer->inputDown({ 0x13, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, 0x99 });
output = packetizer->outputDown(); output = packetizer->outputDown();
ASSERT_EQ(output.size(), 1); ASSERT_EQ(output.size(), 1u);
EXPECT_EQ(output.front(), std::vector<uint8_t>({ EXPECT_EQ(output.front(), std::vector<uint8_t>({
0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
0x12, 0x23, 0x34, 0x45, 0x56, 0x67, 0x12, 0x23, 0x34, 0x45, 0x56, 0x67,

146
test/eventmanagertest.cpp
View File

@ -62,13 +62,13 @@ TEST_F(EventManagerTest, MultithreadedEventCallbacksTest) {
t1.join(); t1.join();
t2.join(); t2.join();
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
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(), 1u);
EXPECT_EQ(callCounter, 2); EXPECT_EQ(callCounter, 2);
} }
@ -293,27 +293,27 @@ TEST_F(EventManagerTest, MultithreadedTest) {
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound); EXPECT_EQ(GetLastError().getType(), APIEvent::Type::NoErrorFound);
// Should be 500 {OutputTruncated, Warning}, 500 {OutputTruncated, Info}, 1000 {CANFDNotSupported, Warning}, 500 {CANFDSettingsNotAvailable, Info}, 500 {FailedToWrite, Info} // Should be 500 {OutputTruncated, Warning}, 500 {OutputTruncated, Info}, 1000 {CANFDNotSupported, Warning}, 500 {CANFDSettingsNotAvailable, Info}, 500 {FailedToWrite, Info}
EXPECT_EQ(EventCount(), 3000); EXPECT_EQ(EventCount(), 3000u);
auto events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); auto events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 2500); EXPECT_EQ(EventCount(), 2500u);
EXPECT_EQ(events.size(), 500); EXPECT_EQ(events.size(), 500u);
events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo)); events = GetEvents(EventFilter(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 2000); EXPECT_EQ(EventCount(), 2000u);
EXPECT_EQ(events.size(), 500); EXPECT_EQ(events.size(), 500u);
events = GetEvents(EventFilter(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning)); events = GetEvents(EventFilter(APIEvent::Type::CANFDNotSupported, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 1000); EXPECT_EQ(EventCount(), 1000u);
EXPECT_EQ(events.size(), 1000); EXPECT_EQ(events.size(), 1000u);
events = GetEvents(EventFilter(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo)); events = GetEvents(EventFilter(APIEvent::Type::CANFDSettingsNotAvailable, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 500); EXPECT_EQ(EventCount(), 500u);
EXPECT_EQ(events.size(), 500); EXPECT_EQ(events.size(), 500u);
events = GetEvents(EventFilter(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo)); events = GetEvents(EventFilter(APIEvent::Type::FailedToWrite, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
EXPECT_EQ(events.size(), 500); EXPECT_EQ(events.size(), 500u);
} }
/** /**
@ -323,7 +323,7 @@ TEST_F(EventManagerTest, MultithreadedTest) {
TEST_F(EventManagerTest, CountTest) { TEST_F(EventManagerTest, CountTest) {
// Add an error event, should not go into events list. // Add an error event, should not go into events list.
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::Error));
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
// Adds actual event // Adds actual event
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
@ -332,25 +332,25 @@ TEST_F(EventManagerTest, CountTest) {
EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventWarning));
EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventInfo)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::TooManyEvents, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 1); EXPECT_EQ(EventCount(), 1u);
// Add another actual event // Add another actual event
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 2); EXPECT_EQ(EventCount(), 2u);
// Take all info events (1) // Take all info events (1)
GetEvents(EventFilter(APIEvent::Severity::EventInfo)); GetEvents(EventFilter(APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 1); EXPECT_EQ(EventCount(), 1u);
// Take all events // Take all events
GetEvents(); GetEvents();
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
// default limit is 10000 // default limit is 10000
for(int i = 0; i < 11000; 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::EventWarning));
EXPECT_EQ(EventCount(), 10000); EXPECT_EQ(EventCount(), 10000u);
} }
/** /**
@ -367,8 +367,8 @@ TEST_F(EventManagerTest, GetDefaultTest) {
auto events = EventManager::GetInstance().get(); auto events = EventManager::GetInstance().get();
EXPECT_EQ(events.size(), 10); EXPECT_EQ(events.size(), 10u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
for(int i = 0; i < 5; i++) { for(int i = 0; i < 5; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType); EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType);
@ -380,8 +380,8 @@ TEST_F(EventManagerTest, GetDefaultTest) {
// Check getting when 0 events exist doesn't break // Check getting when 0 events exist doesn't break
events = EventManager::GetInstance().get(); events = EventManager::GetInstance().get();
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -401,8 +401,8 @@ TEST_F(EventManagerTest, GetSizeTest) {
// Take 3 events, 7 left // Take 3 events, 7 left
auto events = EventManager::GetInstance().get(3); auto events = EventManager::GetInstance().get(3);
EXPECT_EQ(events.size(), 3); EXPECT_EQ(events.size(), 3u);
EXPECT_EQ(EventCount(), 7); EXPECT_EQ(EventCount(), 7u);
EXPECT_EQ(events.at(0).getType(), APIEvent::Type::UnexpectedNetworkType); EXPECT_EQ(events.at(0).getType(), APIEvent::Type::UnexpectedNetworkType);
EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventWarning); EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventWarning);
@ -414,16 +414,16 @@ TEST_F(EventManagerTest, GetSizeTest) {
// Take 1 event, 6 left // Take 1 event, 6 left
events = EventManager::GetInstance().get(1); events = EventManager::GetInstance().get(1);
EXPECT_EQ(events.size(), 1); EXPECT_EQ(events.size(), 1u);
EXPECT_EQ(EventCount(), 6); EXPECT_EQ(EventCount(), 6u);
EXPECT_EQ(events.at(0).getType(), APIEvent::Type::SWCANSettingsNotAvailable); EXPECT_EQ(events.at(0).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventInfo); EXPECT_EQ(events.at(0).getSeverity(), APIEvent::Severity::EventInfo);
// Try to take 8 events, should actually take the 6 remaining. 0 left. // Try to take 8 events, should actually take the 6 remaining. 0 left.
events = EventManager::GetInstance().get(8); events = EventManager::GetInstance().get(8);
EXPECT_EQ(events.size(), 6); EXPECT_EQ(events.size(), 6u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType); EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::UnexpectedNetworkType);
@ -435,8 +435,8 @@ TEST_F(EventManagerTest, GetSizeTest) {
// Check getting when 0 events exist doesn't break // Check getting when 0 events exist doesn't break
events = EventManager::GetInstance().get(5); events = EventManager::GetInstance().get(5);
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -458,8 +458,8 @@ TEST_F(EventManagerTest, GetFilterTest) {
// Get all 5 {network, warning}. 15 left. // Get all 5 {network, warning}. 15 left.
auto events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning)); auto events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
EXPECT_EQ(events.size(), 5); EXPECT_EQ(events.size(), 5u);
EXPECT_EQ(EventCount(), 15); EXPECT_EQ(EventCount(), 15u);
for(APIEvent event : events) { for(APIEvent event : events) {
EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType); EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
@ -469,8 +469,8 @@ TEST_F(EventManagerTest, GetFilterTest) {
// Get all 10 infos. 5 {mismatch, warning} remaining. // Get all 10 infos. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(EventFilter(APIEvent::Severity::EventInfo)); events = EventManager::GetInstance().get(EventFilter(APIEvent::Severity::EventInfo));
EXPECT_EQ(events.size(), 10); EXPECT_EQ(events.size(), 10u);
EXPECT_EQ(EventCount(), 5); EXPECT_EQ(EventCount(), 5u);
for(int i = 0; i < 5; i++) { for(int i = 0; i < 5; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable); EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
@ -482,13 +482,13 @@ TEST_F(EventManagerTest, GetFilterTest) {
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining. // (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SWCANSettingsNotAvailable)); events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SWCANSettingsNotAvailable));
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 5); EXPECT_EQ(EventCount(), 5u);
// Get the 5 {mismatch, warning} remaining. // Get the 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SettingsStructureMismatch)); events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::SettingsStructureMismatch));
EXPECT_EQ(events.size(), 5); EXPECT_EQ(events.size(), 5u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
for(APIEvent event : events) { for(APIEvent event : events) {
EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch); EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
@ -497,8 +497,8 @@ TEST_F(EventManagerTest, GetFilterTest) {
// Check getting when 0 events exist doesn't break // Check getting when 0 events exist doesn't break
events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning)); events = EventManager::GetInstance().get(EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -520,8 +520,8 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
// Get all 5 {network, warning}. 15 left. // Get all 5 {network, warning}. 15 left.
auto events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning)); auto events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
EXPECT_EQ(events.size(), 5); EXPECT_EQ(events.size(), 5u);
EXPECT_EQ(EventCount(), 15); EXPECT_EQ(EventCount(), 15u);
for(APIEvent event : events) { for(APIEvent event : events) {
EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType); EXPECT_EQ(event.getType(), APIEvent::Type::UnexpectedNetworkType);
@ -531,8 +531,8 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
// Get 6 infos. 4 infos and 5 {mismatch, warning} remaining. // Get 6 infos. 4 infos and 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Severity::EventInfo)); events = EventManager::GetInstance().get(6, EventFilter(APIEvent::Severity::EventInfo));
EXPECT_EQ(events.size(), 6); EXPECT_EQ(events.size(), 6u);
EXPECT_EQ(EventCount(), 9); EXPECT_EQ(EventCount(), 9u);
for(int i = 0; i < 3; i++) { for(int i = 0; i < 3; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable); EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
@ -545,8 +545,8 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
// Get 4 remaining infos. 5 {mismatch, warning} remaining. // Get 4 remaining infos. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(4, EventFilter(APIEvent::Severity::EventInfo)); events = EventManager::GetInstance().get(4, EventFilter(APIEvent::Severity::EventInfo));
EXPECT_EQ(events.size(), 4); EXPECT_EQ(events.size(), 4u);
EXPECT_EQ(EventCount(), 5); EXPECT_EQ(EventCount(), 5u);
for(int i = 0; i < 2; i++) { for(int i = 0; i < 2; i++) {
EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable); EXPECT_EQ(events.at(2 * i).getType(), APIEvent::Type::SWCANSettingsNotAvailable);
@ -558,13 +558,13 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
// (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining. // (Incorrectly) try to get settings type again. 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(APIEvent::Type::SWCANSettingsNotAvailable); events = EventManager::GetInstance().get(APIEvent::Type::SWCANSettingsNotAvailable);
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 5); EXPECT_EQ(EventCount(), 5u);
// Get the 5 {mismatch, warning} remaining. // Get the 5 {mismatch, warning} remaining.
events = EventManager::GetInstance().get(5, EventFilter(APIEvent::Type::SettingsStructureMismatch)); events = EventManager::GetInstance().get(5, EventFilter(APIEvent::Type::SettingsStructureMismatch));
EXPECT_EQ(events.size(), 5); EXPECT_EQ(events.size(), 5u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
for(APIEvent event : events) { for(APIEvent event : events) {
EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch); EXPECT_EQ(event.getType(), APIEvent::Type::SettingsStructureMismatch);
@ -573,8 +573,8 @@ TEST_F(EventManagerTest, GetSizeFilterTest) {
// Check getting when 0 events exist doesn't break // Check getting when 0 events exist doesn't break
events = EventManager::GetInstance().get(2, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning)); events = EventManager::GetInstance().get(2, EventFilter(APIEvent::Type::UnexpectedNetworkType, APIEvent::Severity::EventWarning));
EXPECT_EQ(events.size(), 0); EXPECT_EQ(events.size(), 0u);
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -608,7 +608,7 @@ TEST_F(EventManagerTest, GetLastErrorMultipleTest) {
TEST_F(EventManagerTest, TestAddWarningsOverflow) { TEST_F(EventManagerTest, TestAddWarningsOverflow) {
// space for 49 normal events, 1 reserved for TooManyEvents // space for 49 normal events, 1 reserved for TooManyEvents
SetEventLimit(50); SetEventLimit(50u);
// 3 of these // 3 of these
for(int i = 0; i < 3; i++) for(int i = 0; i < 3; i++)
@ -642,7 +642,7 @@ TEST_F(EventManagerTest, TestAddWarningsOverflow) {
TEST_F(EventManagerTest, TestAddWarningsInfoOverflow) { TEST_F(EventManagerTest, TestAddWarningsInfoOverflow) {
// space for 49 normal events, 1 reserved for TooManyEvents // space for 49 normal events, 1 reserved for TooManyEvents
SetEventLimit(50); SetEventLimit(50u);
// Event list filling: 1 warning, 3 info, 47 warning. // Event list filling: 1 warning, 3 info, 47 warning.
// Expect to see: 2 info, 47 warning, 1 TooManyEvents // Expect to see: 2 info, 47 warning, 1 TooManyEvents
@ -679,11 +679,11 @@ TEST_F(EventManagerTest, DiscardDefault) {
EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning); EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
} }
EXPECT_EQ(EventCount(), 9000); EXPECT_EQ(EventCount(), 9000u);
DiscardEvents(); DiscardEvents();
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -696,19 +696,19 @@ TEST_F(EventManagerTest, DiscardFilter) {
EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning); EventManager::GetInstance().add(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventWarning);
} }
EXPECT_EQ(EventCount(), 9000); EXPECT_EQ(EventCount(), 9000u);
DiscardEvents(EventFilter(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo)); DiscardEvents(EventFilter(APIEvent::Type::BaudrateNotFound, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 6000); EXPECT_EQ(EventCount(), 6000u);
DiscardEvents(EventFilter(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventInfo)); DiscardEvents(EventFilter(APIEvent::Type::BufferInsufficient, APIEvent::Severity::EventInfo));
EXPECT_EQ(EventCount(), 6000); EXPECT_EQ(EventCount(), 6000u);
DiscardEvents(EventFilter(APIEvent::Severity::EventWarning)); DiscardEvents(EventFilter(APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 0); EXPECT_EQ(EventCount(), 0u);
} }
/** /**
@ -716,30 +716,30 @@ TEST_F(EventManagerTest, DiscardFilter) {
*/ */
TEST_F(EventManagerTest, SetEventLimitTest) { TEST_F(EventManagerTest, SetEventLimitTest) {
// Test if event limit too low to be set // Test if event limit too low to be set
EventManager::GetInstance().setEventLimit(9); EventManager::GetInstance().setEventLimit(9u);
EXPECT_EQ(GetEventLimit(), 10000); EXPECT_EQ(GetEventLimit(), 10000u);
EXPECT_EQ(GetLastError().getType(), APIEvent::Type::ParameterOutOfRange); EXPECT_EQ(GetLastError().getType(), APIEvent::Type::ParameterOutOfRange);
// Test truncating existing list when new limit set // Test truncating existing list when new limit set
for(int i = 0; i < 9001; i++) for(int i = 0; i < 9001; i++)
EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning)); EventManager::GetInstance().add(APIEvent(APIEvent::Type::OutputTruncated, APIEvent::Severity::EventWarning));
EXPECT_EQ(EventCount(), 9001); EXPECT_EQ(EventCount(), 9001u);
// Sets new limit to be exactly full. // Sets new limit to be exactly full.
SetEventLimit(9002); SetEventLimit(9002u);
EXPECT_EQ(GetEventLimit(), 9002); EXPECT_EQ(GetEventLimit(), 9002u);
EXPECT_EQ(EventCount(), 9001); EXPECT_EQ(EventCount(), 9001u);
// 1 overflowed. // 1 overflowed.
SetEventLimit(9001); SetEventLimit(9001u);
EXPECT_EQ(GetEventLimit(), 9001); EXPECT_EQ(GetEventLimit(), 9001u);
EXPECT_EQ(EventCount(), 9001); EXPECT_EQ(EventCount(), 9001u);
// Truncate a lot // Truncate a lot
SetEventLimit(5000); SetEventLimit(5000u);
EXPECT_EQ(GetEventLimit(), 5000); EXPECT_EQ(GetEventLimit(), 5000u);
EXPECT_EQ(EventCount(), 5000); EXPECT_EQ(EventCount(), 5000u);
auto events = GetEvents(); auto events = GetEvents();
for(int i = 0; i < 4998; i++) { for(int i = 0; i < 4998; i++) {