uint64_t ua, ub;

memcpy(&ua, &a, sizeof(ua));

memcpy(&ub, &b, sizeof(ub));

if ((int64_t)(ub ^ ua) >= 0)

return (int64_t)(ua - ub) >= 0 ? (ua - ub) : (ub - ua);

return ua + ub + 0x80000000;

std::cout << __func__ << std::endl;

simdjson::dom::parser parser;

for (int m = 10; m < 20; m++) {

for (int i = -1024; i < 1024; i++) {

auto str = std::to_string(i);

int64_t actual;

ASSERT_SUCCESS(parser.parse(str).get(actual));

if (actual != i) {

std::cerr << "JSON '" << str << "' parsed to " << actual << " instead of " << i << std::endl;

return false;

}

}

}

return true;

std::cout << __func__ << std::endl;

char buf[1024];

simdjson::dom::parser parser;

uint64_t maxulp = 0;

for (int i = -1075; i < 1024; ++i) {// large negative values should be zero.

double expected = pow(2, i);

size_t n = snprintf(buf, sizeof(buf), "%.*e", std::numeric_limits<double>::max_digits10 - 1, expected);

if (n >= sizeof(buf)) { abort(); }

fflush(NULL);

double actual;

auto error = parser.parse(buf, n).get(actual);

if (error) { std::cerr << error << std::endl; return false; }

uint64_t ulp = f64_ulp_dist(actual,expected);

if(ulp > maxulp) maxulp = ulp;

if(ulp > 0) {

std::cerr << "JSON '" << buf << " parsed to ";

fprintf( stderr," %18.18g instead of %18.18g\n", actual, expected); // formatting numbers is easier with printf

SIMDJSON_SHOW_DEFINE(FLT_EVAL_METHOD);

return false;

}

}

return true;

std::cout << __func__ << std::endl;

char buf[1024];

simdjson::dom::parser parser;

bool is_pow_correct{1e-308 == std::pow(10,-308)};

int start_point = is_pow_correct ? -10000 : -307;

if(!is_pow_correct) {

std::cout << "On your system, the pow function is busted. Sorry about that. " << std::endl;

}

for (int i = start_point; i <= 308; ++i) {// large negative values should be zero.

size_t n = snprintf(buf, sizeof(buf), "1e%d", i);

if (n >= sizeof(buf)) { abort(); }

fflush(NULL);

double actual;

auto error = parser.parse(buf, n).get(actual);

if (error) { std::cerr << error << std::endl; return false; }

double expected = ((i >= -307) ? testing_power_of_ten[i + 307]: std::pow(10, i));

int ulp = (int) f64_ulp_dist(actual, expected);

if(ulp > 0) {

std::cerr << "JSON '" << buf << " parsed to ";

fprintf( stderr," %18.18g instead of %18.18g\n", actual, expected); // formatting numbers is easier with printf

SIMDJSON_SHOW_DEFINE(FLT_EVAL_METHOD);

return false;

}

}

printf("Powers of 10 can be parsed.\n");

return true;

return small_integers() &&

powers_of_two() &&

powers_of_ten();

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

dom::element doc;

ASSERT_SUCCESS( parser.parse(BASIC_JSON).get(doc) );

ASSERT_EQUAL( doc.is<dom::array>(), true );

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

int count = 0;

simdjson::dom::document_stream stream;

ASSERT_SUCCESS( parser.parse_many(BASIC_NDJSON).get(stream) );

for (auto doc : stream) {

UNUSED dom::array array;

ASSERT_SUCCESS( doc.get(array) );

count++;

}

ASSERT_EQUAL(count, 2);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

int count = 0;

for (auto doc : parser.parse_many(BASIC_NDJSON)) {

UNUSED dom::array array;

ASSERT_SUCCESS( doc.get(array) );

count++;

}

ASSERT_EQUAL(count, 2);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

int count = 0;

simdjson::dom::document_stream stream;

ASSERT_SUCCESS( parser.parse_many(EMPTY_NDJSON).get(stream) );

for (auto doc : stream) {

ASSERT_SUCCESS( doc );

count++;

}

ASSERT_EQUAL(count, 0);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

uint64_t count = 0;

constexpr const int BATCH_SIZE = 128;

uint8_t empty_batches_ndjson[BATCH_SIZE*16+SIMDJSON_PADDING];

memset(&empty_batches_ndjson[0], ' ', BATCH_SIZE*16+SIMDJSON_PADDING);

memcpy(&empty_batches_ndjson[BATCH_SIZE*3+2], "1", 1);

memcpy(&empty_batches_ndjson[BATCH_SIZE*10+4], "2", 1);

memcpy(&empty_batches_ndjson[BATCH_SIZE*11+6], "3", 1);

simdjson::dom::document_stream stream;

ASSERT_SUCCESS( parser.parse_many(empty_batches_ndjson, BATCH_SIZE*16).get(stream) );

for (auto doc : stream) {

count++;

uint64_t val;

ASSERT_SUCCESS( doc.get(val) );

ASSERT_EQUAL( val, count );

}

ASSERT_EQUAL(count, 3);

return true;

std::cout << "Running " << __func__ << " on " << TWITTER_JSON << std::endl;

dom::parser parser;

dom::object object;

ASSERT_SUCCESS( parser.load(TWITTER_JSON).get(object) );

return true;

std::cout << "Running " << __func__ << " on " << AMAZON_CELLPHONES_NDJSON << std::endl;

dom::parser parser;

int count = 0;

simdjson::dom::document_stream stream;

ASSERT_SUCCESS( parser.load_many(AMAZON_CELLPHONES_NDJSON).get(stream) );

for (auto doc : stream) {

dom::array arr;

ASSERT_SUCCESS( doc.get(arr) ); // let us get the array

ASSERT_EQUAL( arr.size(), 9 );

size_t arr_count = 0;

for (auto v : arr) { arr_count++; (void)v; }

ASSERT_EQUAL( arr_count, 9 );

count++;

}

ASSERT_EQUAL(count, AMAZON_CELLPHONES_NDJSON_DOC_COUNT);

return true;

std::cout << "Running " << __func__ << " on " << AMAZON_CELLPHONES_NDJSON << std::endl;

dom::parser parser;

int count = 0;

for (auto doc : parser.load_many(AMAZON_CELLPHONES_NDJSON)) {

dom::array arr;

ASSERT_SUCCESS( doc.get(arr) );

ASSERT_EQUAL( arr.size(), 9 );

size_t arr_count = 0;

for (auto v : arr) { arr_count++; (void)v; }

ASSERT_EQUAL( arr_count, 9 );

count++;

}

ASSERT_EQUAL( count, AMAZON_CELLPHONES_NDJSON_DOC_COUNT );

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

UNUSED dom::array array = parser.parse(BASIC_JSON);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

int count = 0;

for (UNUSED dom::array doc : parser.parse_many(BASIC_NDJSON)) {

count++;

}

ASSERT_EQUAL(count, 2);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

size_t count = 0;

dom::object object = parser.load(TWITTER_JSON);

for (UNUSED auto field : object) {

count++;

}

ASSERT_EQUAL( count, object.size() );

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

int count = 0;

for (UNUSED dom::array doc : parser.load_many(AMAZON_CELLPHONES_NDJSON)) {

count++;

}

ASSERT_EQUAL( count, AMAZON_CELLPHONES_NDJSON_DOC_COUNT );

return true;

return parser_parse() &&

parser_parse_many() &&

parser_parse_many_deprecated() &&

parser_parse_many_empty() &&

parser_parse_many_empty_batches() &&

parser_load() &&

parser_load_many() &&

parser_load_many_deprecated() &&

#if SIMDJSON_EXCEPTIONS

parser_parse_exception() &&

parser_parse_many_exception() &&

parser_load_exception() &&

parser_load_many_exception() &&

#endif

true;

std::cout << "Running " << __func__ << std::endl;

simdjson::padded_string json = R"({

})"_padded;

simdjson::ParsedJson pj = build_parsed_json(json);

if (pj.error) {

printf("Could not parse '%s': %s\n", json.data(), simdjson::error_message(pj.error));

return false;

}

simdjson::ParsedJson::Iterator iter(pj);

if (!iter.is_object()) {

printf("Root should be object\n");

return false;

}

if (iter.move_to_key("bad key")) {

printf("We should not move to a non-existing key\n");

return false;

}

if (!iter.is_object()) {

printf("We should have remained at the object.\n");

return false;

}

if (iter.move_to_key_insensitive("bad key")) {

printf("We should not move to a non-existing key\n");

return false;

}

if (!iter.is_object()) {

printf("We should have remained at the object.\n");

return false;

}

if (!iter.down()) {

printf("Root should not be emtpy\n");

return false;

}

if (!iter.is_string()) {

printf("Object should start with string key\n");

return false;

}

if (iter.prev()) {

printf("We should not be able to go back from the start of the scope.\n");

return false;

}

if (strcmp(iter.get_string(),"Image")!=0) {

printf("There should be a single key, image.\n");

return false;

}

iter.move_to_value();

if(!iter.is_object()) {

printf("Value of image should be object\n");

return false;

}

if(!iter.down()) {

printf("Image key should not be emtpy\n");

return false;

}

if(!iter.next()) {

printf("key should have a value\n");

return false;

}

if(!iter.prev()) {

printf("We should go back to the key.\n");

return false;

}

if (strcmp(iter.get_string(),"Width")!=0) {

printf("There should be a key Width.\n");

return false;

}

if (!iter.up()) {

return false;

}

if (!iter.move_to_key("IDs")) {

printf("We should be able to move to an existing key\n");

return false;

}

if (!iter.is_array()) {

printf("Value of IDs should be array, it is %c \n", iter.get_type());

return false;

}

if (iter.move_to_index(4)) {

printf("We should not be able to move to a non-existing index\n");

return false;

}

if (!iter.is_array()) {

printf("We should have remained at the array\n");

return false;

}

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "a": 1, "b": 2, "c": 3 })");

const char* expected_key[] = { "a", "b", "c" };

uint64_t expected_value[] = { 1, 2, 3 };

dom::parser parser;

dom::object object;

ASSERT_SUCCESS( parser.parse(json).get(object) );

int i = 0;

for (auto [key, value] : object) {

ASSERT_EQUAL( key, expected_key[i] );

ASSERT_EQUAL( value.get<uint64_t>().first, expected_value[i] );

i++;

}

ASSERT_EQUAL( i*sizeof(uint64_t), sizeof(expected_value) );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ 1, 10, 100 ])");

uint64_t expected_value[] = { 1, 10, 100 };

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

int i=0;

for (auto value : array) {

uint64_t v;

ASSERT_SUCCESS( value.get(v) );

ASSERT_EQUAL( v, expected_value[i] );

i++;

}

ASSERT_EQUAL( i*sizeof(uint64_t), sizeof(expected_value) );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({})");

int i = 0;

dom::parser parser;

dom::object object;

ASSERT_SUCCESS( parser.parse(json).get(object) );

for (UNUSED auto field : object) {

TEST_FAIL("Unexpected field");

i++;

}

ASSERT_EQUAL(i, 0);

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([])");

int i=0;

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

for (UNUSED auto value : array) {

TEST_FAIL("Unexpected value");

i++;

}

ASSERT_EQUAL(i, 0);

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ "hi", "has backslash\\" ])");

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

auto iter = array.begin();

std::string_view val;

ASSERT_SUCCESS( (*iter).get(val) );

ASSERT_EQUAL( val, "hi" );

++iter;

ASSERT_SUCCESS( (*iter).get(val) );

ASSERT_EQUAL( val, "has backslash\\" );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ 0, 1, -1, 1.1 ])");

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

auto iter = array.begin();

ASSERT_EQUAL( (*iter).get<uint64_t>().first, 0 );

ASSERT_EQUAL( (*iter).get<int64_t>().first, 0 );

ASSERT_EQUAL( (*iter).get<double>().first, 0 );

++iter;

ASSERT_EQUAL( (*iter).get<uint64_t>().first, 1 );

ASSERT_EQUAL( (*iter).get<int64_t>().first, 1 );

ASSERT_EQUAL( (*iter).get<double>().first, 1 );

++iter;

ASSERT_EQUAL( (*iter).get<int64_t>().first, -1 );

ASSERT_EQUAL( (*iter).get<double>().first, -1 );

++iter;

ASSERT_EQUAL( (*iter).get<double>().first, 1.1 );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ true, false ])");

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

auto val = array.begin();

ASSERT_EQUAL( (*val).get<bool>().first, true );

++val;

ASSERT_EQUAL( (*val).get<bool>().first, false );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ null ])");

dom::parser parser;

dom::array array;

ASSERT_SUCCESS( parser.parse(json).get(array) );

auto val = array.begin();

ASSERT_EQUAL( !(*val).is_null(), 0 );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "a": 1, "b": 2, "c/d": 3})");

dom::parser parser;

dom::object object;

ASSERT_SUCCESS( parser.parse(json).get(object) );

ASSERT_EQUAL( object["a"].get<uint64_t>().first, 1 );

ASSERT_EQUAL( object["b"].get<uint64_t>().first, 2 );

ASSERT_EQUAL( object["c/d"].get<uint64_t>().first, 3 );

// Check all three again in backwards order, to ensure we can go backwards

ASSERT_EQUAL( object["c/d"].get<uint64_t>().first, 3 );

ASSERT_EQUAL( object["b"].get<uint64_t>().first, 2 );

ASSERT_EQUAL( object["a"].get<uint64_t>().first, 1 );

simdjson::error_code error;

UNUSED element val;

#ifndef _LIBCPP_VERSION // should work everywhere but with libc++, must include the <ciso646> header.

std::tie(val,error) = object["d"];

ASSERT_ERROR( error, NO_SUCH_FIELD );

std::tie(std::ignore,error) = object["d"];

ASSERT_ERROR( error, NO_SUCH_FIELD );

#endif

// tie(val, error) = object["d"]; fails with "no viable overloaded '='" on Apple clang version 11.0.0 tie(val, error) = doc["d"];

object["d"].tie(val, error);

ASSERT_ERROR( error, NO_SUCH_FIELD );

ASSERT_ERROR( object["d"].get(val), NO_SUCH_FIELD );

ASSERT_ERROR( object["d"], NO_SUCH_FIELD );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "obj": { "a": 1, "b": 2, "c/d": 3 } })");

dom::parser parser;

dom::element doc;

ASSERT_SUCCESS( parser.parse(json).get(doc) );

ASSERT_EQUAL( doc["obj"]["a"].get<uint64_t>().first, 1);

object obj;

ASSERT_SUCCESS( doc.get(obj) );

ASSERT_EQUAL( obj["obj"]["a"].get<uint64_t>().first, 1);

ASSERT_SUCCESS( obj["obj"].get(obj) );

ASSERT_EQUAL( obj["a"].get<uint64_t>().first, 1 );

ASSERT_EQUAL( obj["b"].get<uint64_t>().first, 2 );

ASSERT_EQUAL( obj["c/d"].get<uint64_t>().first, 3 );

// Check all three again in backwards order, to ensure we can go backwards

ASSERT_EQUAL( obj["c/d"].get<uint64_t>().first, 3 );

ASSERT_EQUAL( obj["b"].get<uint64_t>().first, 2 );

ASSERT_EQUAL( obj["a"].get<uint64_t>().first, 1 );

UNUSED element val;

ASSERT_ERROR( doc["d"].get(val), NO_SUCH_FIELD);

return true;

std::cout << "Running " << __func__ << std::endl;

// Prints the number of results in twitter.json

dom::parser parser;

uint64_t result_count;

ASSERT_SUCCESS( parser.load(TWITTER_JSON)["search_metadata"]["count"].get(result_count) );

ASSERT_EQUAL( result_count, 100 );

return true;

std::cout << "Running " << __func__ << std::endl;

// Print users with a default profile.

set<string_view> default_users;

dom::parser parser;

dom::array tweets;

ASSERT_SUCCESS( parser.load(TWITTER_JSON)["statuses"].get(tweets) );

for (auto tweet : tweets) {

object user;

ASSERT_SUCCESS( tweet["user"].get(user) );

bool default_profile;

ASSERT_SUCCESS( user["default_profile"].get(default_profile) );

if (default_profile) {

std::string_view screen_name;

ASSERT_SUCCESS( user["screen_name"].get(screen_name) );

default_users.insert(screen_name);

}

}

ASSERT_EQUAL( default_users.size(), 86 );

return true;

std::cout << "Running " << __func__ << std::endl;

// Print image names and sizes

set<pair<uint64_t, uint64_t>> image_sizes;

simdjson::error_code error;

dom::parser parser;

dom::array tweets;

ASSERT_SUCCESS( parser.load(TWITTER_JSON)["statuses"].get(tweets) );

for (auto tweet : tweets) {

dom::array media;

if (not (error = tweet["entities"]["media"].get(media))) {

for (auto image : media) {

object sizes;

ASSERT_SUCCESS( image["sizes"].get(sizes) );

for (auto size : sizes) {

uint64_t width, height;

ASSERT_SUCCESS( size.value["w"].get(width) );

ASSERT_SUCCESS( size.value["h"].get(height) );

image_sizes.insert(make_pair(width, height));

}

}

}

}

ASSERT_EQUAL( image_sizes.size(), 15 );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "a": 1, "b": 2, "c": 3 })");

const char* expected_key[] = { "a", "b", "c" };

uint64_t expected_value[] = { 1, 2, 3 };

int i = 0;

dom::parser parser;

for (auto [key, value] : dom::object(parser.parse(json))) {

ASSERT_EQUAL( key, expected_key[i]);

ASSERT_EQUAL( uint64_t(value), expected_value[i] );

i++;

}

ASSERT_EQUAL( i*sizeof(uint64_t), sizeof(expected_value) );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"([ 1, 10, 100 ])");

uint64_t expected_value[] = { 1, 10, 100 };

int i=0;

dom::parser parser;

for (uint64_t value : parser.parse(json)) {

ASSERT_EQUAL( value, expected_value[i] );

i++;

}

ASSERT_EQUAL( i*sizeof(uint64_t), sizeof(expected_value) );

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

ASSERT_EQUAL( (const char *)parser.parse(R"("hi")"_padded), "hi" );

ASSERT_EQUAL( string_view(parser.parse(R"("hi")"_padded)), "hi" );

ASSERT_EQUAL( (const char *)parser.parse(R"("has backslash\\")"_padded), "has backslash\\");

ASSERT_EQUAL( string_view(parser.parse(R"("has backslash\\")"_padded)), "has backslash\\" );

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

ASSERT_EQUAL( uint64_t(parser.parse("0"_padded)), 0);

ASSERT_EQUAL( int64_t(parser.parse("0"_padded)), 0);

ASSERT_EQUAL( double(parser.parse("0"_padded)), 0);

ASSERT_EQUAL( uint64_t(parser.parse("1"_padded)), 1);

ASSERT_EQUAL( int64_t(parser.parse("1"_padded)), 1);

ASSERT_EQUAL( double(parser.parse("1"_padded)), 1);

ASSERT_EQUAL( int64_t(parser.parse("-1"_padded)), -1);

ASSERT_EQUAL( double(parser.parse("-1"_padded)), -1);

ASSERT_EQUAL( double(parser.parse("1.1"_padded)), 1.1);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

ASSERT_EQUAL( bool(parser.parse("true"_padded)), true);

ASSERT_EQUAL( bool(parser.parse("false"_padded)), false);

return true;

std::cout << "Running " << __func__ << std::endl;

dom::parser parser;

ASSERT_EQUAL( bool(parser.parse("null"_padded).is_null()), true );

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "a": 1, "b": 2, "c": 3})");

dom::parser parser;

auto obj = parser.parse(json);

ASSERT_EQUAL(uint64_t(obj["a"]), 1);

return true;

std::cout << "Running " << __func__ << std::endl;

string json(R"({ "obj": { "a": 1, "b": 2, "c": 3 } })");

dom::parser parser;

object obj = parser.parse(json)["obj"];

ASSERT_EQUAL( uint64_t(obj["a"]), 1);

return true;

std::cout << "Running " << __func__ << std::endl;

// Prints the number of results in twitter.json

dom::parser parser;

element doc = parser.load(TWITTER_JSON);

uint64_t result_count = doc["search_metadata"]["count"];

if (result_count != 100) { cerr << "Expected twitter.json[metadata_count][count] = 100, got " << result_count << endl; return false; }

return true;

std::cout << "Running " << __func__ << std::endl;

// Print users with a default profile.

set<string_view> default_users;

dom::parser parser;

element doc = parser.load(TWITTER_JSON);

for (object tweet : doc["statuses"].get<dom::array>()) {

object user = tweet["user"];

if (user["default_profile"]) {

default_users.insert(user["screen_name"]);

}

}

if (default_users.size() != 86) { cerr << "Expected twitter.json[statuses][user] to contain 86 default_profile users, got " << default_users.size() << endl; return false; }

return true;

std::cout << "Running " << __func__ << std::endl;

// Print image names and sizes

set<pair<uint64_t, uint64_t>> image_sizes;

dom::parser parser;

for (object tweet : parser.load(TWITTER_JSON)["statuses"]) {

auto media = tweet["entities"]["media"];

if (!media.error()) {

for (object image : media) {

for (auto size : object(image["sizes"])) {

image_sizes.insert(make_pair(size.value["w"], size.value["h"]));

}

}

}

}

ASSERT_EQUAL( image_sizes.size(), 15 );

return true;

return ParsedJson_Iterator_test() &&

object_iterator() &&

array_iterator() &&

object_iterator_empty() &&

array_iterator_empty() &&

string_value() &&

numeric_values() &&

boolean_values() &&

null_value() &&

document_object_index() &&

object_index() &&

twitter_count() &&

twitter_default_profile() &&

twitter_image_sizes() &&

#if SIMDJSON_EXCEPTIONS

object_iterator_exception() &&

array_iterator_exception() &&

string_value_exception() &&

numeric_values_exception() &&

boolean_values_exception() &&

null_value_exception() &&

document_object_index() &&

twitter_count_exception() &&

twitter_default_profile_exception() &&

twitter_image_sizes_exception() &&

#endif

true;

cast_tester<T> tester;

std::cout << " test_cast<" << typeid(T).name() << "> expecting " << expected << std::endl;

// Grab the element out and check success

dom::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;

cast_tester<T> tester;

std::cout << " test_cast<" << typeid(T).name() << ">" << std::endl;

// Grab the element out and check success

dom::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) );