Skip to content

Commit 79ce71c

Browse files
trflynn89trflynn89
committed
Include tests for std::*set<fly::Json>
Now that std::hash is specialized and the relative comparison operators are defined for fly::Json, these tests can be included. This also changes the fly::test::run_test_for_[object,array]_types callbacks to be templated lambdas.
1 parent c5c9235 commit 79ce71c

File tree

3 files changed

+98
-174
lines changed

3 files changed

+98
-174
lines changed

‎test/types/json/json_conversion.cpp

+16-38
Original file line numberDiff line numberDiff line change
@@ -37,17 +37,13 @@ CATCH_JSON_STRING_TEST_CASE("JsonConversion")
3737

3838
CATCH_SECTION("Convert a JSON instance to object-like types")
3939
{
40-
auto validate = [&json](auto *name, auto &test1, auto &test2, auto &test3)
40+
auto validate = [&json]<typename T1, typename T2, typename T3>(const char *name)
4141
{
4242
CATCH_CAPTURE(name);
4343

44-
using T1 = std::decay_t<decltype(test1)>;
45-
using T2 = std::decay_t<decltype(test2)>;
46-
using T3 = std::decay_t<decltype(test3)>;
47-
48-
test1 = T1 {{J_STR("a"), 2}, {J_STR("b"), 4}};
49-
test2 = T2 {{J_STR("a"), "2"}, {J_STR("b"), "4"}};
50-
test3 = T3 {{J_STR("a"), 2}, {J_STR("b"), "4"}};
44+
auto test1 = T1 {{J_STR("a"), 2}, {J_STR("b"), 4}};
45+
auto test2 = T2 {{J_STR("a"), "2"}, {J_STR("b"), "4"}};
46+
auto test3 = T3 {{J_STR("a"), 2}, {J_STR("b"), "4"}};
5147

5248
json = test1;
5349
CATCH_CHECK(T1(json) == test1);
@@ -69,12 +65,10 @@ CATCH_JSON_STRING_TEST_CASE("JsonConversion")
6965
CATCH_CHECK_THROWS_JSON(T1(json), "JSON type is not numeric: ({})", json["a"]);
7066
};
7167

72-
auto invalidate = [&json](auto *name, auto &test)
68+
auto invalidate = [&json]<typename T>(const char *name)
7369
{
7470
CATCH_CAPTURE(name);
7571

76-
using T = std::decay_t<decltype(test)>;
77-
7872
CATCH_CHECK_THROWS_JSON(
7973
FLY_UNUSED((T(json))),
8074
"JSON type is not an object: ({})",
@@ -88,15 +82,13 @@ CATCH_JSON_STRING_TEST_CASE("JsonConversion")
8882

8983
CATCH_SECTION("Convert a JSON instance to array-like types")
9084
{
91-
auto validate2 = [&json](auto *name, auto &test1, auto &test2)
85+
auto validate = [&json]<typename T1, typename T2, typename T3>(const char *name)
9286
{
9387
CATCH_CAPTURE(name);
9488

95-
using T1 = std::decay_t<decltype(test1)>;
96-
using T2 = std::decay_t<decltype(test2)>;
97-
98-
test1 = T1 {50, 60, 70, 80};
99-
test2 = T2 {J_STR("50"), J_STR("60"), J_STR("70"), J_STR("80")};
89+
auto test1 = T1 {50, 60, 70, 80};
90+
auto test2 = T2 {J_STR("50"), J_STR("60"), J_STR("70"), J_STR("80")};
91+
auto test3 = T3 {50, J_STR("60"), 70, J_STR("80")};
10092

10193
json = test1;
10294
CATCH_CHECK(T1(json) == test1);
@@ -106,6 +98,11 @@ CATCH_JSON_STRING_TEST_CASE("JsonConversion")
10698
CATCH_CHECK(T1(json) == test1);
10799
CATCH_CHECK(T2(json) == test2);
108100

101+
json = test3;
102+
CATCH_CHECK(T1(json) == test1);
103+
CATCH_CHECK(T2(json) == test2);
104+
CATCH_CHECK(T3(json) == test3);
105+
109106
json = {true};
110107
CATCH_CHECK_THROWS_JSON(
111108
FLY_UNUSED((std::array<int, 1>(json))),
@@ -119,34 +116,15 @@ CATCH_JSON_STRING_TEST_CASE("JsonConversion")
119116
json[0]);
120117
};
121118

122-
auto validate3 = [&json, &validate2](auto *name, auto &test1, auto &test2, auto &test3)
123-
{
124-
validate2(name, test1, test2);
125-
126-
using T1 = std::decay_t<decltype(test1)>;
127-
using T2 = std::decay_t<decltype(test2)>;
128-
using T3 = std::decay_t<decltype(test3)>;
129-
130-
test3 = T3 {50, J_STR("60"), 70, J_STR("80")};
131-
132-
json = test3;
133-
CATCH_CHECK(T1(json) == test1);
134-
CATCH_CHECK(T2(json) == test2);
135-
CATCH_CHECK(T3(json) == test3);
136-
};
137-
138-
auto invalidate = [&json](auto *name, auto &test)
119+
auto invalidate = [&json]<typename T>(const char *name)
139120
{
140121
CATCH_CAPTURE(name);
141122

142-
using T = std::decay_t<decltype(test)>;
143-
144123
CATCH_CHECK_THROWS_JSON(FLY_UNUSED((T(json))), "JSON type is not an array: ({})", json);
145124
};
146125

147126
fly::test::run_test_for_array_types<json_type, string_type>(
148-
std::move(validate2),
149-
std::move(validate3),
127+
std::move(validate),
150128
std::move(invalidate));
151129

152130
// Extra test to ensure std::array lengths are accounted for.

‎test/types/json/json_helpers.hpp

+61-99
Original file line numberDiff line numberDiff line change
@@ -196,130 +196,92 @@ void run_test_for_object_types(Validator validate, Invalidator invalidate)
196196
{
197197
if constexpr (AllowForType)
198198
{
199-
std::map<StringType, int> map1;
200-
std::map<StringType, std::string> map2;
201-
std::map<StringType, fly::Json> map3;
202-
validate("map", map1, map2, map3);
203-
204-
std::multimap<StringType, int> multimap1;
205-
std::multimap<StringType, std::string> multimap2;
206-
std::multimap<StringType, fly::Json> multimap3;
207-
validate("multimap", multimap1, multimap2, multimap3);
208-
209-
std::unordered_map<StringType, int> unordered_map1;
210-
std::unordered_map<StringType, std::string> unordered_map2;
211-
std::unordered_map<StringType, fly::Json> unordered_map3;
212-
validate("unordered_map", unordered_map1, unordered_map2, unordered_map3);
213-
214-
std::unordered_multimap<StringType, int> unordered_multimap1;
215-
std::unordered_multimap<StringType, std::string> unordered_multimap2;
216-
std::unordered_multimap<StringType, fly::Json> unordered_multimap3;
217-
validate(
218-
"unordered_multimap",
219-
unordered_multimap1,
220-
unordered_multimap2,
221-
unordered_multimap3);
199+
validate.template operator()<
200+
std::map<StringType, int>,
201+
std::map<StringType, std::string>,
202+
std::map<StringType, fly::Json>>("map");
203+
204+
validate.template operator()<
205+
std::multimap<StringType, int>,
206+
std::multimap<StringType, std::string>,
207+
std::multimap<StringType, fly::Json>>("multimap");
208+
209+
validate.template operator()<
210+
std::unordered_map<StringType, int>,
211+
std::unordered_map<StringType, std::string>,
212+
std::unordered_map<StringType, fly::Json>>("unordered_map");
213+
214+
validate.template operator()<
215+
std::unordered_multimap<StringType, int>,
216+
std::unordered_multimap<StringType, std::string>,
217+
std::unordered_multimap<StringType, fly::Json>>("unordered_multimap");
222218
}
223219
else
224220
{
225-
std::map<StringType, fly::Json> map;
226-
invalidate("map", map);
227-
228-
std::multimap<StringType, fly::Json> multimap;
229-
invalidate("multimap", multimap);
230-
231-
std::unordered_map<StringType, fly::Json> unordered_map;
232-
invalidate("unordered_map", unordered_map);
233-
234-
std::unordered_multimap<StringType, fly::Json> unordered_multimap;
235-
invalidate("unordered_multimap", unordered_multimap);
221+
invalidate.template operator()<std::map<StringType, fly::Json>>("map");
222+
invalidate.template operator()<std::multimap<StringType, fly::Json>>("multimap");
223+
invalidate.template operator()<std::unordered_map<StringType, fly::Json>>("unordered_map");
224+
invalidate.template operator()<std::unordered_multimap<StringType, fly::Json>>(
225+
"unordered_multimap");
236226
}
237227
}
238228

239229
template <
240230
typename JsonType,
241231
typename StringType,
242-
typename Validator2,
243-
typename Validator3,
232+
typename Validator,
244233
typename Invalidator,
245234
bool AllowForType = std::is_same_v<JsonType, fly::json_array_type>>
246-
void run_test_for_array_types(Validator2 validate2, Validator3 validate3, Invalidator invalidate)
235+
void run_test_for_array_types(Validator &&validate, Invalidator &&invalidate)
247236
{
248237
if constexpr (AllowForType)
249238
{
250-
std::array<int, 4> array1;
251-
std::array<StringType, 4> array2;
252-
std::array<fly::Json, 4> array3;
253-
validate3("array", array1, array2, array3);
239+
validate.template
240+
operator()<std::array<int, 4>, std::array<StringType, 4>, std::array<fly::Json, 4>>(
241+
"array");
254242

255-
std::deque<int> deque1;
256-
std::deque<StringType> deque2;
257-
std::deque<fly::Json> deque3;
258-
validate3("deque", deque1, deque2, deque3);
243+
validate.template
244+
operator()<std::deque<int>, std::deque<StringType>, std::deque<fly::Json>>("deque");
259245

260-
std::forward_list<int> forward_list1;
261-
std::forward_list<StringType> forward_list2;
262-
std::forward_list<fly::Json> forward_list3;
263-
validate3("forward_list", forward_list1, forward_list2, forward_list3);
246+
validate.template operator()<
247+
std::forward_list<int>,
248+
std::forward_list<StringType>,
249+
std::forward_list<fly::Json>>("forward_list");
264250

265-
std::list<int> list1;
266-
std::list<StringType> list2;
267-
std::list<fly::Json> list3;
268-
validate3("list", list1, list2, list3);
251+
validate.template operator()<std::list<int>, std::list<StringType>, std::list<fly::Json>>(
252+
"list");
269253

270-
std::multiset<int> multiset1;
271-
std::multiset<StringType> multiset2;
272-
// std::multiset<fly::Json> multiset3;
273-
validate2("multiset", multiset1, multiset2);
254+
validate.template
255+
operator()<std::multiset<int>, std::multiset<StringType>, std::multiset<fly::Json>>(
256+
"multiset");
274257

275-
std::set<int> set1;
276-
std::set<StringType> set2;
277-
// std::set<fly::Json> set3;
278-
validate2("set", set1, set2);
258+
validate.template operator()<std::set<int>, std::set<StringType>, std::set<fly::Json>>(
259+
"set");
279260

280-
std::unordered_multiset<int> unordered_multiset1;
281-
std::unordered_multiset<StringType> unordered_multiset2;
282-
// std::unordered_multiset<fly::Json> unordered_multiset3;
283-
validate2("unordered_multiset", unordered_multiset1, unordered_multiset2);
261+
validate.template operator()<
262+
std::unordered_multiset<int>,
263+
std::unordered_multiset<StringType>,
264+
std::unordered_multiset<fly::Json>>("unordered_multiset");
284265

285-
std::unordered_set<int> unordered_set1;
286-
std::unordered_set<StringType> unordered_set2;
287-
// std::unordered_set<fly::Json> unordered_set3;
288-
validate2("unordered_set", unordered_set1, unordered_set2);
266+
validate.template operator()<
267+
std::unordered_set<int>,
268+
std::unordered_set<StringType>,
269+
std::unordered_set<fly::Json>>("unordered_set");
289270

290-
std::vector<int> vector1;
291-
std::vector<StringType> vector2;
292-
std::vector<fly::Json> vector3;
293-
validate3("vector", vector1, vector2, vector3);
271+
validate.template
272+
operator()<std::vector<int>, std::vector<StringType>, std::vector<fly::Json>>("vector");
294273
}
295274
else
296275
{
297-
std::array<int, 4> array;
298-
invalidate("array", array);
299-
300-
std::deque<int> deque;
301-
invalidate("deque", deque);
302-
303-
std::forward_list<int> forward_list;
304-
invalidate("forward_list", forward_list);
305-
306-
std::list<int> list;
307-
invalidate("list", list);
308-
309-
std::multiset<int> multiset;
310-
invalidate("multiset", multiset);
311-
312-
std::set<int> set;
313-
invalidate("set", set);
314-
315-
std::unordered_multiset<int> unordered_multiset;
316-
invalidate("unordered_multiset", unordered_multiset);
317-
318-
std::unordered_set<int> unordered_set;
319-
invalidate("unordered_set", unordered_set);
320-
321-
std::vector<int> vector;
322-
invalidate("vector", vector);
276+
invalidate.template operator()<std::array<int, 4>>("array");
277+
invalidate.template operator()<std::deque<int>>("deque");
278+
invalidate.template operator()<std::forward_list<int>>("forward_list");
279+
invalidate.template operator()<std::list<int>>("list");
280+
invalidate.template operator()<std::multiset<int>>("multiset");
281+
invalidate.template operator()<std::set<int>>("set");
282+
invalidate.template operator()<std::unordered_multiset<int>>("unordered_multiset");
283+
invalidate.template operator()<std::unordered_set<int>>("unordered_set");
284+
invalidate.template operator()<std::vector<int>>("vector");
323285
}
324286
}
325287

0 commit comments

Comments
 (0)