Skip to content

Commit d8428f9

Browse files
jkeiserjkeiser
committed
Add cast_tester.h
1 parent 60f17d2 commit d8428f9

2 files changed

Lines changed: 285 additions & 0 deletions

File tree

‎tests/basictests.cpp‎

Lines changed: 1 addition & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -14,6 +14,7 @@
1414
#include <unistd.h>
1515

1616
#include "simdjson.h"
17+
#include "cast_tester.h"
1718
#include "test_macros.h"
1819

1920
namespace number_tests {

‎tests/cast_tester.h‎

Lines changed: 284 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,284 @@
1+
#ifndef CAST_TESTER_H
2+
#define CAST_TESTER_H
3+
4+
#include "simdjson.h"
5+
#include "test_macros.h"
6+
7+
namespace {
8+
using simdjson::error_code;
9+
using simdjson::simdjson_error;
10+
using simdjson::simdjson_result;
11+
using simdjson::dom::array;
12+
using simdjson::dom::element;
13+
using simdjson::dom::object;
14+
}
15+
16+
// cast_tester<T> tester;
17+
// tester.test_implicit(value, [](T value) { return true; })
18+
// tester.test_implicit_error(value, error)
19+
// Used to test casts to a type. In the case of const char * in particular, we don't test
20+
// implicit casts at all, so that method always returns true.
21+
template<typename T>
22+
class cast_tester {
23+
public:
24+
bool test_get(element element, T expected);
25+
bool test_get(simdjson_result<element> element, T expected);
26+
bool test_get_error(element element, error_code expected_error);
27+
bool test_get_error(simdjson_result<element> element, error_code expected_error);
28+
29+
#if SIMDJSON_EXCEPTIONS
30+
bool test_implicit_cast(element element, T expected);
31+
bool test_implicit_cast(simdjson_result<element> element, T expected);
32+
bool test_implicit_cast_error(element element, error_code expected_error);
33+
bool test_implicit_cast_error(simdjson_result<element> element, error_code expected_error);
34+
#endif // SIMDJSON_EXCEPTIONS
35+
36+
bool test_is(element element, bool expected);
37+
bool test_is(simdjson_result<element> element, bool expected);
38+
bool test_is_error(simdjson_result<element> element, error_code expected_error);
39+
40+
// bool test_named_get(element element, T expected);
41+
// bool test_named_get(simdjson_result<element> element, T expected);
42+
// bool test_named_get_error(element element, error_code expected_error);
43+
// bool test_named_get_error(simdjson_result<element> element, error_code expected_error);
44+
45+
// bool test_named_is(element element, bool expected);
46+
// bool test_named_is(simdjson_result<element> element, bool expected);
47+
// bool test_named_is_error(simdjson_result<element> element, error_code expected_error);
48+
49+
private:
50+
// simdjson_result<T> named_get(element element);
51+
// simdjson_result<T> named_get(simdjson_result<element> element);
52+
// bool named_is(element element);
53+
// simdjson_result<bool> named_is(simdjson_result<element> element);
54+
bool assert_equal(const T& expected, const T& actual);
55+
};
56+
57+
template<typename T>
58+
bool cast_tester<T>::test_get(element element, T expected) {
59+
T actual;
60+
error_code error;
61+
element.get<T>().tie(actual, error);
62+
ASSERT_SUCCESS(error);
63+
return assert_equal(actual, expected);
64+
}
65+
66+
template<typename T>
67+
bool cast_tester<T>::test_get(simdjson_result<element> element, T expected) {
68+
T actual;
69+
error_code error;
70+
element.get<T>().tie(actual, error);
71+
ASSERT_SUCCESS(error);
72+
return assert_equal(actual, expected);
73+
}
74+
75+
template<typename T>
76+
bool cast_tester<T>::test_get_error(element element, error_code expected_error) {
77+
T actual;
78+
error_code error;
79+
element.get<T>().tie(actual, error);
80+
ASSERT_EQUAL(error, expected_error);
81+
return true;
82+
}
83+
84+
template<typename T>
85+
bool cast_tester<T>::test_get_error(simdjson_result<element> element, error_code expected_error) {
86+
T actual;
87+
error_code error;
88+
element.get<T>().tie(actual, error);
89+
ASSERT_EQUAL(error, expected_error);
90+
return true;
91+
}
92+
93+
// template<typename T>
94+
// bool cast_tester<T>::test_named_get(element element, T expected) {
95+
// T actual;
96+
// error_code error;
97+
// named_get(element).tie(actual, error);
98+
// ASSERT_SUCCESS(error);
99+
// return assert_equal(actual, expected);
100+
// }
101+
102+
// template<typename T>
103+
// bool cast_tester<T>::test_named_get(simdjson_result<element> element, T expected) {
104+
// T actual;
105+
// error_code error;
106+
// named_get(element).tie(actual, error);
107+
// ASSERT_SUCCESS(error);
108+
// return assert_equal(actual, expected);
109+
// }
110+
111+
// template<typename T>
112+
// bool cast_tester<T>::test_named_get_error(element element, error_code expected_error) {
113+
// T actual;
114+
// error_code error;
115+
// named_get(element).tie(actual, error);
116+
// ASSERT_EQUAL(error, expected_error);
117+
// return true;
118+
// }
119+
120+
// template<typename T>
121+
// bool cast_tester<T>::test_named_get_error(simdjson_result<element> element, error_code expected_error) {
122+
// T actual;
123+
// error_code error;
124+
// named_get(element).tie(actual, error);
125+
// ASSERT_EQUAL(error, expected_error);
126+
// return true;
127+
// }
128+
129+
#if SIMDJSON_EXCEPTIONS
130+
131+
template<typename T>
132+
bool cast_tester<T>::test_implicit_cast(element element, T expected) {
133+
T actual;
134+
try {
135+
actual = element;
136+
} catch(simdjson_error &e) {
137+
std::cerr << e.error() << std::endl;
138+
return false;
139+
}
140+
return assert_equal(actual, expected);
141+
}
142+
143+
template<typename T>
144+
bool cast_tester<T>::test_implicit_cast(simdjson_result<element> element, T expected) {
145+
T actual;
146+
try {
147+
actual = element;
148+
} catch(simdjson_error &e) {
149+
std::cerr << e.error() << std::endl;
150+
return false;
151+
}
152+
return assert_equal(actual, expected);
153+
}
154+
155+
template<typename T>
156+
bool cast_tester<T>::test_implicit_cast_error(element element, error_code expected_error) {
157+
try {
158+
UNUSED T actual;
159+
actual = element;
160+
return false;
161+
} catch(simdjson_error &e) {
162+
ASSERT_EQUAL(e.error(), expected_error);
163+
return true;
164+
}
165+
}
166+
167+
template<typename T>
168+
bool cast_tester<T>::test_implicit_cast_error(simdjson_result<element> element, error_code expected_error) {
169+
try {
170+
UNUSED T actual;
171+
actual = element;
172+
return false;
173+
} catch(simdjson_error &e) {
174+
ASSERT_EQUAL(e.error(), expected_error);
175+
return true;
176+
}
177+
}
178+
179+
template<> bool cast_tester<const char *>::test_implicit_cast(element, const char *) { return true; }
180+
template<> bool cast_tester<const char *>::test_implicit_cast(simdjson_result<element>, const char *) { return true; }
181+
template<> bool cast_tester<const char *>::test_implicit_cast_error(element, error_code) { return true; }
182+
template<> bool cast_tester<const char *>::test_implicit_cast_error(simdjson_result<element>, error_code) { return true; }
183+
184+
#endif // SIMDJSON_EXCEPTIONS
185+
186+
template<typename T>
187+
bool cast_tester<T>::test_is(element element, bool expected) {
188+
ASSERT_EQUAL(element.is<T>(), expected);
189+
return true;
190+
}
191+
192+
template<typename T>
193+
bool cast_tester<T>::test_is(simdjson_result<element> element, bool expected) {
194+
bool actual;
195+
error_code error;
196+
element.is<T>().tie(actual, error);
197+
ASSERT_SUCCESS(error);
198+
ASSERT_EQUAL(actual, expected);
199+
return true;
200+
}
201+
202+
template<typename T>
203+
bool cast_tester<T>::test_is_error(simdjson_result<element> element, error_code expected_error) {
204+
UNUSED bool actual;
205+
error_code error;
206+
element.is<T>().tie(actual, error);
207+
ASSERT_EQUAL(error, expected_error);
208+
return true;
209+
}
210+
211+
// template<typename T>
212+
// bool cast_tester<T>::test_named_is(element element, bool expected) {
213+
// ASSERT_EQUAL(named_is(element), expected);
214+
// return true;
215+
// }
216+
217+
// template<typename T>
218+
// bool cast_tester<T>::test_named_is(simdjson_result<element> element, bool expected) {
219+
// bool actual;
220+
// error_code error;
221+
// named_is(element).tie(actual, error);
222+
// ASSERT_SUCCESS(error);
223+
// ASSERT_EQUAL(actual, expected);
224+
// return true;
225+
// }
226+
227+
// template<typename T>
228+
// bool cast_tester<T>::test_named_is_error(simdjson_result<element> element, error_code expected_error) {
229+
// bool actual;
230+
// error_code error;
231+
// named_is(element, error).tie(actual, error);
232+
// ASSERT_EQUAL(error, expected_error);
233+
// return true;
234+
// }
235+
236+
// template<> simdjson_result<array> cast_tester<array>::named_get(element element) { return element.get_array(); }
237+
// template<> simdjson_result<object> cast_tester<object>::named_get(element element) { return element.get_object(); }
238+
// template<> simdjson_result<const char *> cast_tester<const char *>::named_get(element element) { return element.get_c_str(); }
239+
// template<> simdjson_result<std::string_view> cast_tester<std::string_view>::named_get(element element) { return element.get_string(); }
240+
// template<> simdjson_result<uint64_t> cast_tester<uint64_t>::named_get(element element) { return element.get_uint64_t(); }
241+
// template<> simdjson_result<int64_t> cast_tester<int64_t>::named_get(element element) { return element.get_int64_t(); }
242+
// template<> simdjson_result<double> cast_tester<double>::named_get(element element) { return element.get_double(); }
243+
// template<> simdjson_result<bool> cast_tester<bool>::named_get(element element) { return element.get_bool(); }
244+
245+
// template<> simdjson_result<array> cast_tester<array>::named_get(simdjson_result<element> element) { return element.get_array(); }
246+
// template<> simdjson_result<object> cast_tester<object>::named_get(simdjson_result<element> element) { return element.get_object(); }
247+
// template<> simdjson_result<const char *> cast_tester<const char *>::named_get(simdjson_result<element> element) { return element.get_c_str(); }
248+
// template<> simdjson_result<std::string_view> cast_tester<std::string_view>::named_get(simdjson_result<element> element) { return element.get_string(); }
249+
// template<> simdjson_result<uint64_t> cast_tester<uint64_t>::named_get(simdjson_result<element> element) { return element.get_uint64_t(); }
250+
// template<> simdjson_result<int64_t> cast_tester<int64_t>::named_get(simdjson_result<element> element) { return element.get_int64_t(); }
251+
// template<> simdjson_result<double> cast_tester<double>::named_get(simdjson_result<element> element) { return element.get_double(); }
252+
// template<> simdjson_result<bool> cast_tester<bool>::named_get(simdjson_result<element> element) { return element.get_bool(); }
253+
254+
// template<> bool cast_tester<array>::named_is(element element) { return element.is_array(); }
255+
// template<> bool cast_tester<object>::named_is(element element) { return element.is_object(); }
256+
// template<> bool cast_tester<const char *>::named_is(element element) { return element.is_string(); }
257+
// template<> bool cast_tester<std::string_view>::named_is(element element) { return element.is_string(); }
258+
// template<> bool cast_tester<uint64_t>::named_is(element element) { return element.is_uint64_t(); }
259+
// template<> bool cast_tester<int64_t>::named_is(element element) { return element.is_int64_t(); }
260+
// template<> bool cast_tester<double>::named_is(element element) { return element.is_double(); }
261+
// template<> bool cast_tester<bool>::named_is(element element) { return element.is_bool(); }
262+
263+
// template<> simdjson_result<bool> cast_tester<array>::named_is(simdjson_result<element> element) { return element.is_array(); }
264+
// template<> simdjson_result<bool> cast_tester<object>::named_is(simdjson_result<element> element) { return element.is_object(); }
265+
// template<> simdjson_result<bool> cast_tester<const char *>::named_is(simdjson_result<element> element) { return element.is_string(); }
266+
// template<> simdjson_result<bool> cast_tester<std::string_view>::named_is(simdjson_result<element> element) { return element.is_string(); }
267+
// template<> simdjson_result<bool> cast_tester<uint64_t>::named_is(simdjson_result<element> element) { return element.is_uint64_t(); }
268+
// template<> simdjson_result<bool> cast_tester<int64_t>::named_is(simdjson_result<element> element) { return element.is_int64_t(); }
269+
// template<> simdjson_result<bool> cast_tester<double>::named_is(simdjson_result<element> element) { return element.is_double(); }
270+
// template<> simdjson_result<bool> cast_tester<bool>::named_is(simdjson_result<element> element) { return element.is_bool(); }
271+
272+
template<typename T> bool cast_tester<T>::assert_equal(const T& expected, const T& actual) {
273+
ASSERT_EQUAL(expected, actual);
274+
return true;
275+
}
276+
// We don't actually check objects and arrays, just check that they actually cast
277+
template<> bool cast_tester<array>::assert_equal(const array&, const array&) {
278+
return true;
279+
}
280+
template<> bool cast_tester<object>::assert_equal(const object&, const object&) {
281+
return true;
282+
}
283+
284+
#endif

0 commit comments

Comments
 (0)