Skip to content

Commit 6c24aa3

Browse files
MartinRixhamMartinRixham
committed
Consistently use gtest expectations.
1 parent 357e67e commit 6c24aa3

4 files changed

Lines changed: 47 additions & 48 deletions

File tree

‎test/repository/rocksdb_repository_test.cpp‎

Lines changed: 13 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -1,6 +1,5 @@
11
#include <set>
22
#include <vector>
3-
#include <filesystem>
43

54
#include <gtest/gtest.h>
65
#include <rocksdb/db.h>
@@ -31,10 +30,10 @@ TEST_F(repository_test, create_and_read_tables)
3130
std::set<table::table> table_set = repository.list_tables();
3231
std::vector<table::table> tables(table_set.begin(), table_set.end());
3332

34-
ASSERT_EQ(tables.size(), 2);
33+
EXPECT_EQ(tables.size(), 2);
3534

36-
ASSERT_EQ(tables[0].name, "first table");
37-
ASSERT_EQ(tables[1].name, "second table");
35+
EXPECT_EQ(tables[0].name, "first table");
36+
EXPECT_EQ(tables[1].name, "second table");
3837
}
3938

4039
TEST_F(repository_test, read_table)
@@ -43,10 +42,10 @@ TEST_F(repository_test, read_table)
4342

4443
table::table table = repository.read_table("a table");
4544

46-
ASSERT_EQ(table.is_valid, true);
47-
ASSERT_EQ(table.name, "a table");
48-
ASSERT_EQ(table.json["name"].as_string(), "a table");
49-
ASSERT_EQ(table.json["dependencies"].as_array().size(), 0);
45+
EXPECT_EQ(table.is_valid, true);
46+
EXPECT_EQ(table.name, "a table");
47+
EXPECT_EQ(table.json["name"].as_string(), "a table");
48+
EXPECT_EQ(table.json["dependencies"].as_array().size(), 0);
5049
}
5150

5251
TEST_F(repository_test, fail_to_read_table_that_does_not_exist)
@@ -55,9 +54,9 @@ TEST_F(repository_test, fail_to_read_table_that_does_not_exist)
5554

5655
table::table table = repository.read_table("not a table");
5756

58-
ASSERT_EQ(table.is_valid, false);
59-
ASSERT_EQ(table.name, "");
60-
ASSERT_EQ(table.json["error"], "No table with name \"not a table\" found in data store.");
57+
EXPECT_EQ(table.is_valid, false);
58+
EXPECT_EQ(table.name, "");
59+
EXPECT_EQ(table.json["error"], "No table with name \"not a table\" found in data store.");
6160
}
6261

6362
TEST_F(repository_test, does_not_have_invalid_table)
@@ -66,7 +65,7 @@ TEST_F(repository_test, does_not_have_invalid_table)
6665

6766
std::set<table::table> tables = repository.list_tables();
6867

69-
ASSERT_EQ(tables.size(), 0);
68+
EXPECT_EQ(tables.size(), 0);
7069
}
7170

7271
TEST_F(repository_test, has_valid_table)
@@ -75,7 +74,7 @@ TEST_F(repository_test, has_valid_table)
7574

7675
bool has_table = repository.has_table("a table");
7776

78-
ASSERT_TRUE(has_table);
77+
EXPECT_TRUE(has_table);
7978
}
8079

8180
TEST_F(repository_test, does_not_have_table)
@@ -84,5 +83,5 @@ TEST_F(repository_test, does_not_have_table)
8483

8584
bool has_table = repository.has_table("not a table");
8685

87-
ASSERT_FALSE(has_table);
86+
EXPECT_FALSE(has_table);
8887
}

‎test/router/router_test.cpp‎

Lines changed: 23 additions & 23 deletions
Original file line numberDiff line numberDiff line change
@@ -15,10 +15,10 @@ TEST(router_test, nonsense)
1515

1616
router::response response = router.post("/wibble", request);
1717

18-
ASSERT_EQ(response.status, boost::beast::http::status::bad_request);
19-
ASSERT_EQ(response.body["error"].as_string(), "Request to invalid route /wibble.");
18+
EXPECT_EQ(response.status, boost::beast::http::status::bad_request);
19+
EXPECT_EQ(response.body["error"].as_string(), "Request to invalid route /wibble.");
2020

21-
ASSERT_FALSE(repository.has_table("really a real table"));
21+
EXPECT_FALSE(repository.has_table("really a real table"));
2222
}
2323

2424
TEST(router_test, create_table)
@@ -29,8 +29,8 @@ TEST(router_test, create_table)
2929

3030
router::response response = router.post("/table", request);
3131

32-
ASSERT_EQ(response.status, boost::beast::http::status::ok);
33-
ASSERT_TRUE(repository.has_table("really a real table"));
32+
EXPECT_EQ(response.status, boost::beast::http::status::ok);
33+
EXPECT_TRUE(repository.has_table("really a real table"));
3434
}
3535

3636
TEST(router_test, fail_to_create_table_with_empty_name)
@@ -41,8 +41,8 @@ TEST(router_test, fail_to_create_table_with_empty_name)
4141

4242
router::response response = router.post("/table", request);
4343

44-
ASSERT_EQ(response.status, boost::beast::http::status::bad_request);
45-
ASSERT_EQ(response.body["error"].as_string(), "Table requires name of length greater than 0.");
44+
EXPECT_EQ(response.status, boost::beast::http::status::bad_request);
45+
EXPECT_EQ(response.body["error"].as_string(), "Table requires name of length greater than 0.");
4646
}
4747

4848
TEST(router_test, fail_to_create_duplicate_table)
@@ -55,8 +55,8 @@ TEST(router_test, fail_to_create_duplicate_table)
5555

5656
router::response response = router.post("/table", request);
5757

58-
ASSERT_EQ(response.status, boost::beast::http::status::bad_request);
59-
ASSERT_EQ(response.body["error"].as_string(), "A table with the name \"table name\" already exists.");
58+
EXPECT_EQ(response.status, boost::beast::http::status::bad_request);
59+
EXPECT_EQ(response.body["error"].as_string(), "A table with the name \"table name\" already exists.");
6060
}
6161

6262
TEST(router_test, read_table)
@@ -69,9 +69,9 @@ TEST(router_test, read_table)
6969

7070
router::response response = router.get("/table?name=really a real table");
7171

72-
ASSERT_EQ(response.status, boost::beast::http::status::ok);
73-
ASSERT_EQ(response.body["name"], "really a real table");
74-
ASSERT_EQ(response.body["dependencies"].as_array().size(), 0);
72+
EXPECT_EQ(response.status, boost::beast::http::status::ok);
73+
EXPECT_EQ(response.body["name"], "really a real table");
74+
EXPECT_EQ(response.body["dependencies"].as_array().size(), 0);
7575
}
7676

7777
TEST(router_test, fail_to_read_unknown_table)
@@ -84,7 +84,7 @@ TEST(router_test, fail_to_read_unknown_table)
8484

8585
router::response response = router.get("/table?name=not really a real table");
8686

87-
ASSERT_EQ(response.status, boost::beast::http::status::not_found);
87+
EXPECT_EQ(response.status, boost::beast::http::status::not_found);
8888
}
8989

9090
TEST(router_test, fail_to_read_unknown_parameter)
@@ -97,7 +97,7 @@ TEST(router_test, fail_to_read_unknown_parameter)
9797

9898
router::response response = router.get("/table?lame=really a real table");
9999

100-
ASSERT_EQ(response.status, boost::beast::http::status::not_found);
100+
EXPECT_EQ(response.status, boost::beast::http::status::not_found);
101101
}
102102

103103
TEST(router_test, read_tables)
@@ -118,17 +118,17 @@ TEST(router_test, read_tables)
118118

119119
router::response response = router.get("/tables");
120120

121-
ASSERT_EQ(response.status, boost::beast::http::status::ok);
121+
EXPECT_EQ(response.status, boost::beast::http::status::ok);
122122

123123
boost::json::array tables = response.body["tables"].as_array();
124124

125-
ASSERT_EQ(tables.size(), 2);
126-
ASSERT_EQ(tables[0].as_object()["name"], "first table");
125+
EXPECT_EQ(tables.size(), 2);
126+
EXPECT_EQ(tables[0].as_object()["name"], "first table");
127127

128128
boost::json::object second_table = tables[1].as_object();
129129

130-
ASSERT_EQ(second_table["name"], "second table");
131-
ASSERT_EQ(second_table["dependencies"].as_array()[0], "first table");
130+
EXPECT_EQ(second_table["name"], "second table");
131+
EXPECT_EQ(second_table["dependencies"].as_array()[0], "first table");
132132
}
133133

134134
TEST(router_test, fail_to_create_table_with_invalid_dependency)
@@ -147,11 +147,11 @@ TEST(router_test, fail_to_create_table_with_invalid_dependency)
147147

148148
router::response response = router.post("/table", second_request);
149149

150-
ASSERT_EQ(response.status, boost::beast::http::status::bad_request);
151-
ASSERT_EQ(response.body["error"], "Dependency \"not a table\" is not a table.");
150+
EXPECT_EQ(response.status, boost::beast::http::status::bad_request);
151+
EXPECT_EQ(response.body["error"], "Dependency \"not a table\" is not a table.");
152152

153153
boost::json::array tables = router.get("/tables").body["tables"].as_array();
154154

155-
ASSERT_EQ(tables.size(), 1);
156-
ASSERT_EQ(tables[0].as_object()["name"], "first table");
155+
EXPECT_EQ(tables.size(), 1);
156+
EXPECT_EQ(tables[0].as_object()["name"], "first table");
157157
}

‎test/server/server_test.cpp‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -127,7 +127,7 @@ TEST_F(server_test, invalid_post_request)
127127
boost::json::object response_object = boost::json::parse(response).as_object();
128128
std::string error = std::string(response_object["error"].as_string());
129129

130-
EXPECT_EQ(error.length() > 0, true);
130+
EXPECT_TRUE(error.length() > 0);
131131
}
132132

133133
TEST_F(server_test, head_request)

‎test/table/table_test.cpp‎

Lines changed: 10 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -14,8 +14,8 @@ TEST(table_test, deserialise_and_serialise)
1414

1515
table::table table = table::parse_table(json, std::set<std::string>{ "dependency one", "dependency two" });
1616

17-
ASSERT_TRUE(table.is_valid);
18-
ASSERT_EQ(boost::json::serialize(table.json), "{\"name\":\"table name\",\"dependencies\":[\"dependency one\",\"dependency two\"]}");
17+
EXPECT_TRUE(table.is_valid);
18+
EXPECT_EQ(boost::json::serialize(table.json), "{\"name\":\"table name\",\"dependencies\":[\"dependency one\",\"dependency two\"]}");
1919
}
2020

2121
TEST(table_test, fail_to_deserialise_table_with_empty_name)
@@ -28,8 +28,8 @@ TEST(table_test, fail_to_deserialise_table_with_empty_name)
2828

2929
table::table table = table::parse_table(json, std::set<std::string>{});
3030

31-
ASSERT_FALSE(table.is_valid);
32-
ASSERT_EQ(boost::json::serialize(table.json), "{\"error\":\"Table requires name of length greater than 0.\"}");
31+
EXPECT_FALSE(table.is_valid);
32+
EXPECT_EQ(boost::json::serialize(table.json), "{\"error\":\"Table requires name of length greater than 0.\"}");
3333
}
3434

3535
TEST(table_test, fail_to_deserialise_table_with_no_name)
@@ -42,8 +42,8 @@ TEST(table_test, fail_to_deserialise_table_with_no_name)
4242

4343
table::table table = table::parse_table(json, std::set<std::string>{});
4444

45-
ASSERT_FALSE(table.is_valid);
46-
ASSERT_EQ(boost::json::serialize(table.json), "{\"error\":\"Table requires name of length greater than 0.\"}");
45+
EXPECT_FALSE(table.is_valid);
46+
EXPECT_EQ(boost::json::serialize(table.json), "{\"error\":\"Table requires name of length greater than 0.\"}");
4747
}
4848

4949
TEST(table_test, fail_to_deserialise_table_with_duplicate_name)
@@ -52,8 +52,8 @@ TEST(table_test, fail_to_deserialise_table_with_duplicate_name)
5252

5353
table::table table = table::parse_table(json, std::set<std::string>{"table name"});
5454

55-
ASSERT_FALSE(table.is_valid);
56-
ASSERT_EQ(boost::json::serialize(table.json), "{\"error\":\"A table with the name \\\"table name\\\" already exists.\"}");
55+
EXPECT_FALSE(table.is_valid);
56+
EXPECT_EQ(boost::json::serialize(table.json), "{\"error\":\"A table with the name \\\"table name\\\" already exists.\"}");
5757
}
5858

5959
TEST(table_test, fail_to_deserialise_table_with_invalid_dependency)
@@ -67,6 +67,6 @@ TEST(table_test, fail_to_deserialise_table_with_invalid_dependency)
6767

6868
table::table table = table::parse_table(json, std::set<std::string>{"dependency one"});
6969

70-
ASSERT_FALSE(table.is_valid);
71-
ASSERT_EQ(boost::json::serialize(table.json), "{\"error\":\"Dependency \\\"dependency two\\\" is not a table.\"}");
70+
EXPECT_FALSE(table.is_valid);
71+
EXPECT_EQ(boost::json::serialize(table.json), "{\"error\":\"Dependency \\\"dependency two\\\" is not a table.\"}");
7272
}

0 commit comments

Comments
 (0)