Explicitly compare size() in tests with size_t

Author: wravery

test/ArgumentTests.cpp

@@ -27,7 +27,7 @@ TEST(ArgumentsCase, ListArgumentStrings)
 		FAIL() << response::toJSON(ex.getErrors());
 	}
 
-	ASSERT_EQ(3, actual.size()) << "should get 3 entries";
+	ASSERT_EQ(size_t { 3 }, actual.size()) << "should get 3 entries";
 	EXPECT_EQ("string1", actual[0]) << "entry should match";
 	EXPECT_EQ("string2", actual[1]) << "entry should match";
 	EXPECT_EQ("string3", actual[2]) << "entry should match";
@@ -80,7 +80,7 @@ TEST(ArgumentsCase, ListArgumentStringsNullable)
 		FAIL() << response::toJSON(ex.getErrors());
 	}
 
-	ASSERT_EQ(4, actual.size()) << "should get 4 entries";
+	ASSERT_EQ(size_t { 4 }, actual.size()) << "should get 4 entries";
 	ASSERT_TRUE(actual[0].has_value()) << "should not be null";
 	EXPECT_EQ("string1", *actual[0]) << "entry should match";
 	ASSERT_TRUE(actual[1].has_value()) << "should not be null";
@@ -108,11 +108,11 @@ TEST(ArgumentsCase, ListArgumentListArgumentStrings)
 		FAIL() << response::toJSON(ex.getErrors());
 	}
 
-	ASSERT_EQ(2, actual.size()) << "should get 2 entries";
-	ASSERT_EQ(2, actual[0].size()) << "should get 2 entries";
+	ASSERT_EQ(size_t { 2 }, actual.size()) << "should get 2 entries";
+	ASSERT_EQ(size_t { 2 }, actual[0].size()) << "should get 2 entries";
 	EXPECT_EQ("list1string1", actual[0][0]) << "entry should match";
 	EXPECT_EQ("list1string2", actual[0][1]) << "entry should match";
-	ASSERT_EQ(2, actual[1].size()) << "should get 2 entries";
+	ASSERT_EQ(size_t { 2 }, actual[1].size()) << "should get 2 entries";
 	EXPECT_EQ("list2string1", actual[1][0]) << "entry should match";
 	EXPECT_EQ("list2string2", actual[1][1]) << "entry should match";
 }
@@ -136,9 +136,9 @@ TEST(ArgumentsCase, ListArgumentNullableListArgumentStrings)
 		FAIL() << response::toJSON(ex.getErrors());
 	}
 
-	ASSERT_EQ(2, actual.size()) << "should get 2 entries";
+	ASSERT_EQ(size_t { 2 }, actual.size()) << "should get 2 entries";
 	EXPECT_FALSE(actual[0].has_value()) << "should be null";
-	ASSERT_EQ(2, actual[1]->size()) << "should get 2 entries";
+	ASSERT_EQ(size_t { 2 }, actual[1]->size()) << "should get 2 entries";
 	EXPECT_EQ("list2string1", (*actual[1])[0]) << "entry should match";
 	EXPECT_EQ("list2string2", (*actual[1])[1]) << "entry should match";
 }
@@ -227,7 +227,7 @@ TEST(ArgumentsCase, ScalarArgumentMap)
 
 	ASSERT_EQ(response::Type::Map, actual.type()) << "should parse the object";
 	values = actual.release<response::MapType>();
-	ASSERT_EQ(1, values.size()) << "should have a single key/value";
+	ASSERT_EQ(size_t { 1 }, values.size()) << "should have a single key/value";
 	ASSERT_EQ("foo", values.front().first) << "should match the key";
 	ASSERT_EQ("bar", values.front().second.get<std::string>()) << "should match the value";
 }
@@ -250,7 +250,7 @@ TEST(ArgumentsCase, ScalarArgumentList)
 
 	ASSERT_EQ(response::Type::List, actual.type()) << "should parse the array";
 	values = actual.release<response::ListType>();
-	ASSERT_EQ(2, values.size()) << "should have 2 values";
+	ASSERT_EQ(size_t { 2 }, values.size()) << "should have 2 values";
 	ASSERT_EQ("foo", values.front().get<std::string>()) << "should match the value";
 	ASSERT_EQ("bar", values.back().get<std::string>()) << "should match the value";
 }

test/ClientTests.cpp

@@ -130,10 +130,11 @@ TEST_F(ClientCase, QueryEverything)
 		auto serviceResponse = client::parseServiceResponse(std::move(result));
 		const auto response = parseResponse(std::move(serviceResponse.data));
 
-		EXPECT_EQ(0, serviceResponse.errors.size()) << "no errors expected";
+		EXPECT_EQ(size_t {}, serviceResponse.errors.size()) << "no errors expected";
 
 		ASSERT_TRUE(response.appointments.edges.has_value()) << "appointments should be set";
-		ASSERT_EQ(1, response.appointments.edges->size()) << "appointments should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, response.appointments.edges->size())
+			<< "appointments should have 1 entry";
 		ASSERT_TRUE((*response.appointments.edges)[0].has_value()) << "edge should be set";
 		const auto& appointmentNode = (*response.appointments.edges)[0]->node;
 		ASSERT_TRUE(appointmentNode.has_value()) << "node should be set";
@@ -146,7 +147,7 @@ TEST_F(ClientCase, QueryEverything)
 		EXPECT_EQ("Appointment", appointmentNode->_typename) << "__typename should match";
 
 		ASSERT_TRUE(response.tasks.edges.has_value()) << "tasks should be set";
-		ASSERT_EQ(1, response.tasks.edges->size()) << "tasks should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, response.tasks.edges->size()) << "tasks should have 1 entry";
 		ASSERT_TRUE((*response.tasks.edges)[0].has_value()) << "edge should be set";
 		const auto& taskNode = (*response.tasks.edges)[0]->node;
 		ASSERT_TRUE(taskNode.has_value()) << "node should be set";
@@ -157,7 +158,8 @@ TEST_F(ClientCase, QueryEverything)
 		EXPECT_EQ("Task", taskNode->_typename) << "__typename should match";
 
 		ASSERT_TRUE(response.unreadCounts.edges.has_value()) << "unreadCounts should be set";
-		ASSERT_EQ(1, response.unreadCounts.edges->size()) << "unreadCounts should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, response.unreadCounts.edges->size())
+			<< "unreadCounts should have 1 entry";
 		ASSERT_TRUE((*response.unreadCounts.edges)[0].has_value()) << "edge should be set";
 		const auto& unreadCountNode = (*response.unreadCounts.edges)[0]->node;
 		ASSERT_TRUE(unreadCountNode.has_value()) << "node should be set";
@@ -170,7 +172,7 @@ TEST_F(ClientCase, QueryEverything)
 		EXPECT_EQ(client::query::Query::TaskState::Unassigned, response.testTaskState)
 			<< "testTaskState should match";
 
-		ASSERT_EQ(1, response.anyType.size()) << "anyType should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, response.anyType.size()) << "anyType should have 1 entry";
 		ASSERT_TRUE(response.anyType[0].has_value()) << "appointment should be set";
 		const auto& anyType = *response.anyType[0];
 		EXPECT_EQ("Appointment", anyType._typename) << "__typename should match";
@@ -208,7 +210,7 @@ TEST_F(ClientCase, MutateCompleteTask)
 		auto serviceResponse = client::parseServiceResponse(std::move(result));
 		const auto response = parseResponse(std::move(serviceResponse.data));
 
-		EXPECT_EQ(0, serviceResponse.errors.size()) << "no errors expected";
+		EXPECT_EQ(size_t {}, serviceResponse.errors.size()) << "no errors expected";
 
 		const auto& completedTask = response.completedTask;
 		const auto& task = completedTask.completedTask;
@@ -256,7 +258,7 @@ TEST_F(ClientCase, SubscribeNextAppointmentChangeDefault)
 		auto serviceResponse = client::parseServiceResponse(std::move(result));
 		const auto response = parseResponse(std::move(serviceResponse.data));
 
-		EXPECT_EQ(0, serviceResponse.errors.size()) << "no errors expected";
+		EXPECT_EQ(size_t {}, serviceResponse.errors.size()) << "no errors expected";
 
 		const auto& appointmentNode = response.nextAppointment;
 		ASSERT_TRUE(appointmentNode.has_value()) << "should get back a task";

test/NoIntrospectionTests.cpp

@@ -174,7 +174,7 @@ TEST_F(NoIntrospectionServiceCase, QueryEverything)
 		const auto appointments = service::ScalarArgument::require("appointments", data);
 		const auto appointmentEdges =
 			service::ScalarArgument::require<service::TypeModifier::List>("edges", appointments);
-		ASSERT_EQ(1, appointmentEdges.size()) << "appointments should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, appointmentEdges.size()) << "appointments should have 1 entry";
 		ASSERT_TRUE(appointmentEdges[0].type() == response::Type::Map)
 			<< "appointment should be an object";
 		const auto appointmentNode = service::ScalarArgument::require("node", appointmentEdges[0]);
@@ -192,7 +192,7 @@ TEST_F(NoIntrospectionServiceCase, QueryEverything)
 		const auto tasks = service::ScalarArgument::require("tasks", data);
 		const auto taskEdges =
 			service::ScalarArgument::require<service::TypeModifier::List>("edges", tasks);
-		ASSERT_EQ(1, taskEdges.size()) << "tasks should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, taskEdges.size()) << "tasks should have 1 entry";
 		ASSERT_TRUE(taskEdges[0].type() == response::Type::Map) << "task should be an object";
 		const auto taskNode = service::ScalarArgument::require("node", taskEdges[0]);
 		EXPECT_EQ(_fakeTaskId, service::IdArgument::require("id", taskNode))
@@ -207,7 +207,7 @@ TEST_F(NoIntrospectionServiceCase, QueryEverything)
 		const auto unreadCounts = service::ScalarArgument::require("unreadCounts", data);
 		const auto unreadCountEdges =
 			service::ScalarArgument::require<service::TypeModifier::List>("edges", unreadCounts);
-		ASSERT_EQ(1, unreadCountEdges.size()) << "unreadCounts should have 1 entry";
+		ASSERT_EQ(size_t { 1 }, unreadCountEdges.size()) << "unreadCounts should have 1 entry";
 		ASSERT_TRUE(unreadCountEdges[0].type() == response::Type::Map)
 			<< "unreadCount should be an object";
 		const auto unreadCountNode = service::ScalarArgument::require("node", unreadCountEdges[0]);

test/PegtlCombinedTests.cpp

@@ -14,6 +14,6 @@ using namespace tao::graphqlpeg;
 
 TEST(PegtlCombinedCase, AnalyzeMixedGrammar)
 {
-	ASSERT_EQ(0, analyze<mixed_document>(true))
+	ASSERT_EQ(size_t {}, analyze<mixed_document>(true))
 		<< "there shouldn't be any infinite loops in the PEG version of the grammar";
 }

test/PegtlExecutableTests.cpp

@@ -136,6 +136,6 @@ TEST(PegtlExecutableCase, ParseVariableDefaultEmptyList)
 
 TEST(PegtlExecutableCase, AnalyzeExecutableGrammar)
 {
-	ASSERT_EQ(0, analyze<executable_document>(true))
+	ASSERT_EQ(size_t {}, analyze<executable_document>(true))
 		<< "there shouldn't be any infinite loops in the PEG version of the grammar";
 }

test/PegtlSchemaTests.cpp

@@ -219,6 +219,6 @@ TEST(PegtlSchemaCase, ParseTodaySchema)
 
 TEST(PegtlSchemaCase, AnalyzeSchemaGrammar)
 {
-	ASSERT_EQ(0, analyze<schema_document>(true))
+	ASSERT_EQ(size_t {}, analyze<schema_document>(true))
 		<< "there shouldn't be any infinite loops in the PEG version of the grammar";
 }