Remove validate tests and unimplemented cast tests from ondemand

This commit is contained in:
John Keiser 2020-10-02 08:57:49 -07:00
parent 5327ab9903
commit 1974a46fe0
1 changed files with 0 additions and 404 deletions

View File

@ -789,408 +789,6 @@ namespace twitter_tests {
} }
} }
// namespace type_tests {
// using namespace simdjson;
// using namespace std;
// const padded_string ALL_TYPES_JSON = R"(
// {
// "array": [],
// "object": {},
// "string": "foo",
// "0": 0,
// "1": 1,
// "-1": -1,
// "9223372036854775807": 9223372036854775807,
// "-9223372036854775808": -9223372036854775808,
// "9223372036854775808": 9223372036854775808,
// "18446744073709551615": 18446744073709551615,
// "0.0": 0.0,
// "0.1": 0.1,
// "1e0": 1e0,
// "1e100": 1e100,
// "true": true,
// "false": false,
// "null": null
// }
// )"_padded;
// template<typename T>
// bool test_cast(simdjson_result<ondemand::element> result, T expected) {
// cast_tester<T> tester;
// std::cout << " test_cast<" << typeid(T).name() << "> expecting " << expected << std::endl;
// // Grab the element out and check success
// ondemand::element element = result.first;
// RUN_TEST( tester.test_get_t(element, expected) );
// RUN_TEST( tester.test_get_t(result, expected) );
// RUN_TEST( tester.test_get(element, expected) );
// RUN_TEST( tester.test_get(result, expected) );
// // RUN_TEST( tester.test_named_get(element, expected) );
// // RUN_TEST( tester.test_named_get(result, expected) );
// RUN_TEST( tester.test_is(element, true) );
// RUN_TEST( tester.test_is(result, true) );
// // RUN_TEST( tester.test_named_is(element, true) );
// // RUN_TEST( tester.test_named_is(result, true) );
// #if SIMDJSON_EXCEPTIONS
// RUN_TEST( tester.test_implicit_cast(element, expected) );
// RUN_TEST( tester.test_implicit_cast(result, expected) );
// #endif
// return true;
// }
// template<typename T>
// bool test_cast(simdjson_result<ondemand::element> result) {
// cast_tester<T> tester;
// std::cout << " test_cast<" << typeid(T).name() << ">" << std::endl;
// // Grab the element out and check success
// ondemand::element element = result.first;
// RUN_TEST( tester.test_get_t(element) );
// RUN_TEST( tester.test_get_t(result) );
// RUN_TEST( tester.test_get(element) );
// RUN_TEST( tester.test_get(result) );
// RUN_TEST( tester.test_named_get(element) );
// RUN_TEST( tester.test_named_get(result) );
// RUN_TEST( tester.test_is(element, true) );
// RUN_TEST( tester.test_is(result, true) );
// RUN_TEST( tester.test_named_is(element, true) );
// RUN_TEST( tester.test_named_is(result, true) );
// #if SIMDJSON_EXCEPTIONS
// RUN_TEST( tester.test_implicit_cast(element) );
// RUN_TEST( tester.test_implicit_cast(result) );
// #endif
// return true;
// }
// //
// // Test that we get errors when we cast to the wrong type
// //
// template<typename T>
// bool test_cast_error(simdjson_result<ondemand::element> result, simdjson::error_code expected_error) {
// std::cout << " test_cast_error<" << typeid(T).name() << "> expecting error '" << expected_error << "'" << std::endl;
// ondemand::element element = result.first;
// cast_tester<T> tester;
// RUN_TEST( tester.test_get_error(element, expected_error) );
// RUN_TEST( tester.test_get_error(result, expected_error) );
// RUN_TEST( tester.test_named_get_error(element, expected_error) );
// RUN_TEST( tester.test_named_get_error(result, expected_error) );
// RUN_TEST( tester.test_is(element, false) );
// RUN_TEST( tester.test_is(result, false) );
// RUN_TEST( tester.test_named_is(element, false) );
// RUN_TEST( tester.test_named_is(result, false) );
// #if SIMDJSON_EXCEPTIONS
// RUN_TEST( tester.test_implicit_cast_error(element, expected_error) );
// RUN_TEST( tester.test_implicit_cast_error(result, expected_error) );
// #endif
// return true;
// }
// bool test_type(simdjson_result<ondemand::element> result, ondemand::element_type expected_type) {
// std::cout << " test_type() expecting " << expected_type << std::endl;
// ondemand::element element = result.first;
// ondemand::element_type actual_type;
// auto error = result.type().get(actual_type);
// ASSERT_SUCCESS(error);
// ASSERT_EQUAL(actual_type, expected_type);
// actual_type = element.type();
// ASSERT_SUCCESS(error);
// ASSERT_EQUAL(actual_type, expected_type);
// #if SIMDJSON_EXCEPTIONS
// try {
// actual_type = result.type();
// ASSERT_EQUAL(actual_type, expected_type);
// } catch(simdjson_error &e) {
// std::cerr << e.error() << std::endl;
// return false;
// }
// #endif // SIMDJSON_EXCEPTIONS
// return true;
// }
// bool test_is_null(simdjson_result<ondemand::element> result, bool expected_is_null) {
// std::cout << " test_is_null() expecting " << expected_is_null << std::endl;
// // Grab the element out and check success
// ondemand::element element = result.first;
// ASSERT_EQUAL(result.is_null(), expected_is_null);
// ASSERT_EQUAL(element.is_null(), expected_is_null);
// return true;
// }
// bool cast_array() {
// TEST_START();
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)["array"];
// return true
// && test_type(result, ondemand::element_type::ARRAY)
// && test_cast<ondemand::array>(result)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast_error<double>(result, INCORRECT_TYPE)
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_object() {
// TEST_START();
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)["object"];
// return true
// && test_type(result, ondemand::element_type::OBJECT)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast<ondemand::object>(result)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast_error<double>(result, INCORRECT_TYPE)
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_string() {
// TEST_START();
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)["string"];
// return true
// && test_type(result, ondemand::element_type::STRING)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast<std::string_view>(result, "foo")
// && test_cast<const char *>(result, "foo")
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast_error<double>(result, INCORRECT_TYPE)
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_int64(const char *key, int64_t expected_value) {
// std::cout << "Running " << __func__ << "(" << key << ")" << std::endl;
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)[key];
// return true
// && test_type(result, ondemand::element_type::INT64)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast<int64_t>(result, expected_value)
// && (expected_value >= 0 ?
// test_cast<uint64_t>(result, expected_value) :
// test_cast_error<uint64_t>(result, NUMBER_OUT_OF_RANGE))
// && test_cast<double>(result, static_cast<double>(expected_value))
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_uint64(const char *key, uint64_t expected_value) {
// std::cout << "Running " << __func__ << "(" << key << ")" << std::endl;
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)[key];
// return true
// && test_type(result, ondemand::element_type::UINT64)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, NUMBER_OUT_OF_RANGE)
// && test_cast<uint64_t>(result, expected_value)
// && test_cast<double>(result, static_cast<double>(expected_value))
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_double(const char *key, double expected_value) {
// std::cout << "Running " << __func__ << "(" << key << ")" << std::endl;
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)[key];
// return true
// && test_type(result, ondemand::element_type::DOUBLE)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast<double>(result, expected_value)
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, false);
// }
// bool cast_bool(const char *key, bool expected_value) {
// std::cout << "Running " << __func__ << "(" << key << ")" << std::endl;
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)[key];
// return true
// && test_type(result, ondemand::element_type::BOOL)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast_error<double>(result, INCORRECT_TYPE)
// && test_cast<bool>(result, expected_value)
// && test_is_null(result, false);
// }
// bool cast_null() {
// TEST_START();
// ondemand::parser parser;
// simdjson_result<ondemand::element> result = parser.iterate(ALL_TYPES_JSON)["null"];
// return true
// && test_type(result, ondemand::element_type::NULL_VALUE)
// && test_cast_error<ondemand::array>(result, INCORRECT_TYPE)
// && test_cast_error<ondemand::object>(result, INCORRECT_TYPE)
// && test_cast_error<std::string_view>(result, INCORRECT_TYPE)
// && test_cast_error<const char *>(result, INCORRECT_TYPE)
// && test_cast_error<int64_t>(result, INCORRECT_TYPE)
// && test_cast_error<uint64_t>(result, INCORRECT_TYPE)
// && test_cast_error<double>(result, INCORRECT_TYPE)
// && test_cast_error<bool>(result, INCORRECT_TYPE)
// && test_is_null(result, true);
// }
// bool run() {
// return cast_array() &&
// cast_object() &&
// cast_string() &&
// cast_int64("0", 0) &&
// cast_int64("1", 1) &&
// cast_int64("-1", -1) &&
// cast_int64("9223372036854775807", 9223372036854775807LL) &&
// cast_int64("-9223372036854775808", -1 - 9223372036854775807LL) &&
// cast_uint64("9223372036854775808", 9223372036854775808ULL) &&
// cast_uint64("18446744073709551615", 18446744073709551615ULL) &&
// cast_double("0.0", 0.0) &&
// cast_double("0.1", 0.1) &&
// cast_double("1e0", 1e0) &&
// cast_double("1e100", 1e100) &&
// cast_bool("true", true) &&
// cast_bool("false", false) &&
// cast_null() &&
// true;
// }
// }
// namespace validate_tests {
// bool test_validate() {
// TEST_START();
// const std::string test = R"({ "foo" : 1, "bar" : [ 1, 2, 3 ], "baz": { "a": 1, "b": 2, "c": 3 } })";
// if(!simdjson::validate_utf8(test.data(), test.size())) {
// return false;
// }
// return true;
// }
// bool test_range() {
// TEST_START();
// for(size_t len = 0; len <= 128; len++) {
// std::vector<uint8_t> source(len,' ');
// if(!simdjson::validate_utf8((const char*)source.data(), source.size())) { return false; }
// }
// return true;
// }
// bool test_bad_validate() {
// TEST_START();
// const std::string test = "\x80\x81";
// if(simdjson::validate_utf8(test.data(), test.size())) {
// return false;
// }
// return true;
// }
// bool test_issue1169() {
// TEST_START();
// std::vector<uint8_t> source(64,' ');
// for(size_t idx = 0; idx < 64; idx++) {
// source[idx] = 255;
// if(simdjson::validate_utf8((const char*)source.data(), source.size())) { return false; }
// source[idx] = 0;
// }
// return true;
// }
// bool test_issue1169_long() {
// TEST_START();
// for(size_t len = 1; len <= 128; len++) {
// std::vector<uint8_t> source(len,' ');
// source[len-1] = 255;
// if(simdjson::validate_utf8((const char*)source.data(), source.size())) { return false; }
// }
// return true;
// }
// bool test_random() {
// TEST_START();
// std::vector<uint8_t> source(64,' ');
// const simdjson::implementation *impl_fallback = simdjson::available_implementations["fallback"];
// if(!impl_fallback) { return true; }
// for(size_t i = 0; i < 10000; i++) {
// std::vector<uint8_t>& s(source);
// s[i%64] ^= uint8_t(1235 * i);
// const bool active_ok = simdjson::active_implementation->validate_utf8((const char*)s.data(), s.size());
// const bool fallback_ok = impl_fallback->validate_utf8((const char*)s.data(), s.size());
// if(active_ok != fallback_ok) { return false; }
// s[i%64] ^= uint8_t(1235 * i);
// }
// return true;
// }
// bool run() {
// return test_range() &&
// test_issue1169_long() &&
// test_issue1169() &&
// test_random() &&
// test_validate() &&
// test_bad_validate();
// }
// }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
std::cout << std::unitbuf; std::cout << std::unitbuf;
int c; int c;
@ -1223,11 +821,9 @@ int main(int argc, char *argv[]) {
std::cout << "Running basic tests." << std::endl; std::cout << "Running basic tests." << std::endl;
if ( if (
// validate_tests::run() &&
parse_api_tests::run() && parse_api_tests::run() &&
dom_api_tests::run() && dom_api_tests::run() &&
twitter_tests::run() && twitter_tests::run() &&
// type_tests::run() &&
number_tests::run() number_tests::run()
) { ) {
std::cout << "Basic tests are ok." << std::endl; std::cout << "Basic tests are ok." << std::endl;