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

auto [actual, error] = parser.parse(str).get<int64_t>();

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

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

auto [actual, error] = parser.parse(buf, n).get<double>();

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 " << actual << " instead of " << expected << std::endl;

return false;

}

}

return true;

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

char buf[1024];

simdjson::dom::parser parser;

for (int i = -1000000; 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);

auto [actual, error] = parser.parse(buf, n).get<double>();

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 " << actual << " instead of " << expected << std::endl;

return false;

}

}

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

return true;

return small_integers() &&

powers_of_two() &&

powers_of_ten();

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

simdjson::padded_string badjson = "[7,7,7,7,6,7,7,7,6,7,7,6,[7,7,7,7,6,7,7,7,6,7,7,6,7,7,7,7,7,7,6"_padded;

simdjson::dom::parser parser;

auto error = parser.parse(badjson).error();

if (!error) {

printf("This json should not be valid %s.\n", badjson.data());

return false;

}

return true;

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

simdjson::padded_string smalljson = "[1,2,3]"_padded;

simdjson::dom::parser parser;

auto [doc, error] = parser.parse(smalljson).get<simdjson::dom::array>();

if (error) {

printf("This json should be valid %s.\n", smalljson.data());

return false;

}

if(doc.size() != 3) {

printf("This json should have size three but found %zu : %s.\n", doc.size(), smalljson.data());

return false;

}

return true;

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

simdjson::padded_string smalljson = "{\"1\":1,\"2\":1,\"3\":1}"_padded;

simdjson::dom::parser parser;

auto [doc, error] = parser.parse(smalljson).get<simdjson::dom::object>();

if (error) {

printf("This json should be valid %s.\n", smalljson.data());

return false;

}

if(doc.size() != 3) {

printf("This json should have size three but found %zu : %s.\n", doc.size(), smalljson.data());

return false;

}

return true;

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

simdjson::padded_string json = "{"

"\"Image\":{"

"\"Width\":800,"

"\"Height\":600,"

"\"Title\":\"View from 15th Floor\","

"\"Thumbnail\":{"

"\"Url\":\"http://www.example.com/image/481989943\","

"\"Height\":125,"

"\"Width\":100"

"},"

"\"Animated\":false,"

"\"IDs\":[116,943.3,234,38793]"

"}"

"}"_padded;

simdjson::dom::parser parser;

std::ostringstream myStream;

#if SIMDJSON_EXCEPTIONS

myStream << parser.parse(json);

#else

simdjson::dom::element doc;

simdjson::error_code error;

parser.parse(json).tie(doc, error);

myStream << doc;

#endif

std::string newjson = myStream.str();

if(static_cast<std::string>(json) != newjson) {

std::cout << "serialized json differs!" << std::endl;

std::cout << static_cast<std::string>(json) << std::endl;

std::cout << newjson << std::endl;

}

return newjson == static_cast<std::string>(json);

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

const size_t n_records = 100000;

std::vector<std::string> data;

char buf[1024];

for (size_t i = 0; i < n_records; ++i) {

size_t n = snprintf(buf, sizeof(buf),

"{\"id\": %zu, \"name\": \"name%zu\", \"gender\": \"%s\", "

"\"school\": {\"id\": %zu, \"name\": \"school%zu\"}}",

i, i, (i % 2) ? "male" : "female", i % 10, i % 10);

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

data.emplace_back(std::string(buf, n));

}

for (size_t i = 0; i < n_records; ++i) {

size_t n = snprintf(buf, sizeof(buf), "{\"counter\": %f, \"array\": [%s]}", static_cast<double>(i) * 3.1416,

(i % 2) ? "true" : "false");

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

data.emplace_back(std::string(buf, n));

}

for (size_t i = 0; i < n_records; ++i) {

size_t n = snprintf(buf, sizeof(buf), "{\"number\": %e}", static_cast<double>(i) * 10000.31321321);

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

data.emplace_back(std::string(buf, n));

}

data.emplace_back(std::string("true"));

data.emplace_back(std::string("false"));

data.emplace_back(std::string("null"));

data.emplace_back(std::string("0.1"));

size_t maxsize = 0;

for (auto &s : data) {

if (maxsize < s.size())

maxsize = s.size();

}

simdjson::dom::parser parser;

size_t counter = 0;

for (auto &rec : data) {

if ((counter % 10000) == 0) {

printf(".");

fflush(NULL);

}

counter++;

auto error = parser.parse(rec.c_str(), rec.length()).error();

if (error != simdjson::error_code::SUCCESS) {

printf("Something is wrong in skyprophet_test: %s.\n", rec.c_str());

printf("Parsing failed. Error is %s\n", simdjson::error_message(error));

return false;

}

error = parser.parse(rec.c_str(), rec.length()).error();

if (error != simdjson::error_code::SUCCESS) {

printf("Something is wrong in skyprophet_test: %s.\n", rec.c_str());

printf("Parsing failed. Error is %s\n", simdjson::error_message(error));

return false;

}

}

printf("\n");

return true;

std::string input;

for(size_t i = 0; i < 200; i++) {

input += "[";

}

for(size_t i = 0; i < 200; i++) {

input += "]";

}

simdjson::dom::parser parser;

auto error = parser.parse(input).error();

if (error) { std::cerr << "Error: " << simdjson::error_message(error) << std::endl; return false; }

return true;

return bad_example() &&

count_array_example() &&

count_object_example() &&

stable_test() &&

skyprophet_test() &&

lots_of_brackets();

simdjson::dom::parser parser;

simdjson::padded_string str("{}",2);

simdjson::dom::document_stream s1 = parse_many_stream_return(parser, str);

simdjson::dom::parser parser;

size_t count = 0;

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

if (doc.error()) {

std::cerr << "Failed with simdjson error= " << doc.error() << std::endl;

return false;

}

count++;

}

if(count != expectedcount) {

std::cerr << "bad count" << std::endl;

return false;

}

return true;

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

auto single_message = R"({"error":[],"result":{"token":"xxx"}})"_padded;

auto two_messages = R"({"error":[],"result":{"token":"xxx"}}{"error":[],"result":{"token":"xxx"}})"_padded;

if(!parse_json_message_issue467(single_message, 1)) {

return false;

}

if(!parse_json_message_issue467(two_messages, 2)) {

return false;

}

return true;

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

fflush(NULL);

const size_t n_records = 10000;

std::string data;

char buf[1024];

for (size_t i = 0; i < n_records; ++i) {

size_t n = snprintf(buf,

sizeof(buf),

"{\"id\": %zu, \"name\": \"name%zu\", \"gender\": \"%s\", "

"\"ete\": {\"id\": %zu, \"name\": \"eventail%zu\"}}",

i, i, (i % 2) ? "homme" : "femme", i % 10, i % 10);

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

data += std::string(buf, n);

}

for(size_t batch_size = 1000; batch_size < 2000; batch_size += (batch_size>1050?10:1)) {

printf(".");

fflush(NULL);

simdjson::padded_string str(data);

simdjson::dom::parser parser;

size_t count = 0;

for (auto [doc, error] : parser.parse_many(str, batch_size)) {

if (error) {

printf("Error at on document %zd at batch size %zu: %s\n", count, batch_size, simdjson::error_message(error));

return false;

}

auto [keyid, error2] = doc["id"].get<int64_t>();

if (error2) {

printf("Error getting id as int64 on document %zd at batch size %zu: %s\n", count, batch_size, simdjson::error_message(error2));

return false;

}

if (keyid != int64_t(count)) {

printf("key does not match %" PRId64 ", expected %zd on document %zd at batch size %zu\n", keyid, count, count, batch_size);

return false;

}

count++;

}

if(count != n_records) {

printf("Found wrong number of documents %zd, expected %zd at batch size %zu\n", count, n_records, batch_size);

return false;

}

}

printf("ok\n");

return true;

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

fflush(NULL);

const size_t n_records = 10000;

std::string data;

char buf[1024];

for (size_t i = 0; i < n_records; ++i) {

size_t n = snprintf(buf,

sizeof(buf),

"{\"id\": %zu, \"name\": \"name%zu\", \"gender\": \"%s\", "

"\"été\": {\"id\": %zu, \"name\": \"éventail%zu\"}}",

i, i, (i % 2) ? "⺃" : "⺕", i % 10, i % 10);

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

data += std::string(buf, n);

}

for(size_t batch_size = 1000; batch_size < 2000; batch_size += (batch_size>1050?10:1)) {

printf(".");

fflush(NULL);

simdjson::padded_string str(data);

simdjson::dom::parser parser;

size_t count = 0;

for (auto [doc, error] : parser.parse_many(str, batch_size)) {

if (error) {

printf("Error at on document %zd at batch size %zu: %s\n", count, batch_size, simdjson::error_message(error));

return false;

}

auto [keyid, error2] = doc["id"].get<int64_t>();

if (error2) {

printf("Error getting id as int64 on document %zd at batch size %zu: %s\n", count, batch_size, simdjson::error_message(error2));

return false;

}

if (keyid != int64_t(count)) {

printf("key does not match %" PRId64 ", expected %zd on document %zd at batch size %zu\n", keyid, count, count, batch_size);

return false;

}

count++;

}

if(count != n_records) {

printf("Found wrong number of documents %zd, expected %zd at batch size %zu\n", count, n_records, batch_size);

return false;

}

}

printf("ok\n");

return true;

return json_issue467() &&

document_stream_test() &&

document_stream_utf8_test();

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

dom::parser parser;

auto [doc, error] = parser.parse(BASIC_JSON);

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

if (!doc.is<dom::array>()) { cerr << "Document did not parse as an array" << endl; return false; }

return true;

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

dom::parser parser;

int count = 0;

for (auto [doc, error] : parser.parse_many(BASIC_NDJSON)) {

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

if (!doc.is<dom::array>()) { cerr << "Document did not parse as an array" << endl; return false; }

count++;

}

if (count != 2) { cerr << "parse_many returned " << count << " documents, expected 2" << endl; return false; }

return true;

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

dom::parser parser;

auto [doc, error] = parser.load(TWITTER_JSON);

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

if (!doc.is<dom::object>()) { cerr << "Document did not parse as an object" << endl; return false; }

return true;

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

dom::parser parser;

int count = 0;

for (auto [doc, error] : parser.load_many(AMAZON_CELLPHONES_NDJSON)) {

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

dom::array arr;

doc.get<dom::array>().tie(arr, error); // let us get the array

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

if(arr.size() != 9) { cerr << "bad array size"<< endl; return false; }

size_t c = 0;

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

if(c != 9) { cerr << "mismatched array size"<< endl; return false; }

count++;

}

if (count != 793) { cerr << "Expected 793 documents, but load_many loaded " << count << " documents." << endl; return false; }

return true;

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

dom::parser parser;

element doc = parser.parse(BASIC_JSON);

if (!doc.is<dom::array>()) { cerr << "Document did not parse as an array" << endl; return false; }

return true;

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

dom::parser parser;

int count = 0;

for (const element doc : parser.parse_many(BASIC_NDJSON)) {

if (!doc.is<dom::array>()) { cerr << "Document did not parse as an array" << endl; return false; }

count++;

}

if (count != 2) { cerr << "parse_many returned " << count << " documents, expected 2" << endl; return false; }

return true;

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

dom::parser parser;

const element doc = parser.load(TWITTER_JSON);

if (!doc.is<dom::object>()) { cerr << "Document did not parse as an object" << endl; return false; }

size_t c = 0;

dom::object obj = doc.get<dom::object>().value(); // let us get the object

for (auto x : obj) {

c++;

(void) x;

}

if(c != obj.size()) { cerr << "Mismatched size" << endl; return false; }

return true;

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

dom::parser parser;

int count = 0;

for (const element doc : parser.load_many(AMAZON_CELLPHONES_NDJSON)) {

if (!doc.is<dom::array>()) { cerr << "Document did not parse as an array" << endl; return false; }

count++;

}

if (count != 793) { cerr << "Expected 1 document, but load_many loaded " << count << " documents." << endl; return false; }

return true;

return parser_parse() &&

parser_parse_many() &&

parser_load() &&

parser_load_many() &&

#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 };

int i = 0;

dom::parser parser;

auto [object, error] = parser.parse(json).get<dom::object>();

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

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

if (key != expected_key[i] || value.get<uint64_t>().first != expected_value[i]) { cerr << "Expected " << expected_key[i] << " = " << expected_value[i] << ", got " << key << "=" << value << endl; return false; }

i++;

}

if (i*sizeof(uint64_t) != sizeof(expected_value)) { cout << "Expected " << sizeof(expected_value) << " values, got " << i << endl; return false; }

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;

auto [array, error] = parser.parse(json).get<dom::array>();

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

for (auto value : array) {

if (value.get<uint64_t>().first != expected_value[i]) { cerr << "Expected " << expected_value[i] << ", got " << value << endl; return false; }

i++;

}

if (i*sizeof(uint64_t) != sizeof(expected_value)) { cout << "Expected " << sizeof(expected_value) << " values, got " << i << endl; return false; }

return true;

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

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

int i = 0;

dom::parser parser;

auto [object, error] = parser.parse(json).get<dom::object>();

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

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

cout << "Unexpected " << key << " = " << value << endl;

i++;

}

if (i > 0) { cout << "Expected 0 values, got " << i << endl; return false; }

return true;

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

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

int i=0;

dom::parser parser;

auto [array, error] = parser.parse(json).get<dom::array>();

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

for (auto value : array) {

cout << "Unexpected value " << value << endl;

i++;

}

if (i > 0) { cout << "Expected 0 values, got " << i << endl; return false; }

return true;

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

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

dom::parser parser;

auto [array, error] = parser.parse(json).get<dom::array>();

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

auto val = array.begin();

if ((*val).get<std::string_view>().first != "hi") { cerr << "Expected value to be \"hi\", was " << (*val).get<std::string_view>().first << endl; return false; }

++val;

if ((*val).get<std::string_view>().first != "has backslash\\") { cerr << "Expected string_view(\"has backslash\\\\\") to be \"has backslash\\\", was " << (*val).get<std::string_view>().first << endl; return false; }

return true;

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

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

dom::parser parser;

auto [array, error] = parser.parse(json).get<dom::array>();

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

auto val = array.begin();

if ((*val).get<uint64_t>().first != 0) { cerr << "Expected uint64_t(0) to be 0, was " << (*val) << endl; return false; }

if ((*val).get<int64_t>().first != 0) { cerr << "Expected int64_t(0) to be 0, was " << (*val).get<int64_t>().first << endl; return false; }

if ((*val).get<double>().first != 0) { cerr << "Expected double(0) to be 0, was " << (*val).get<double>().first << endl; return false; }

++val;

if ((*val).get<uint64_t>().first != 1) { cerr << "Expected uint64_t(1) to be 1, was " << (*val) << endl; return false; }

if ((*val).get<int64_t>().first != 1) { cerr << "Expected int64_t(1) to be 1, was " << (*val).get<int64_t>().first << endl; return false; }

if ((*val).get<double>().first != 1) { cerr << "Expected double(1) to be 1, was " << (*val).get<double>().first << endl; return false; }

++val;

if ((*val).get<int64_t>().first != -1) { cerr << "Expected int64_t(-1) to be -1, was " << (*val).get<int64_t>().first << endl; return false; }

if ((*val).get<double>().first != -1) { cerr << "Expected double(-1) to be -1, was " << (*val).get<double>().first << endl; return false; }

++val;

if ((*val).get<double>().first != 1.1) { cerr << "Expected double(1.1) to be 1.1, was " << (*val).get<double>().first << endl; return false; }

return true;

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

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

dom::parser parser;

auto [array, error] = parser.parse(json).get<dom::array>();

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

auto val = array.begin();

if ((*val).get<bool>().first != true) { cerr << "Expected bool(true) to be true, was " << (*val) << endl; return false; }

++val;

if ((*val).get<bool>().first != false) { cerr << "Expected bool(false) to be false, was " << (*val) << endl; return false; }

return true;

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

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

dom::parser parser;

auto [array, error] = parser.parse(json).get<dom::array>();

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

auto val = array.begin();

if (!(*val).is_null()) { cerr << "Expected null to be null!" << endl; return false; }

return true;

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

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

dom::parser parser;

auto [doc, error] = parser.parse(json);

if (doc["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(doc[\"a\"]) to be 1, was " << doc["a"].first << endl; return false; }

if (doc["b"].get<uint64_t>().first != 2) { cerr << "Expected uint64_t(doc[\"b\"]) to be 2, was " << doc["b"].first << endl; return false; }

if (doc["c/d"].get<uint64_t>().first != 3) { cerr << "Expected uint64_t(doc[\"c/d\"]) to be 3, was " << doc["c"].first << endl; return false; }

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

if (doc["c/d"].get<uint64_t>().first != 3) { cerr << "Expected uint64_t(doc[\"c/d\"]) to be 3, was " << doc["c"].first << endl; return false; }

if (doc["b"].get<uint64_t>().first != 2) { cerr << "Expected uint64_t(doc[\"b\"]) to be 2, was " << doc["b"].first << endl; return false; }

if (doc["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(doc[\"a\"]) to be 1, was " << doc["a"].first << endl; return false; }

UNUSED element val;

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

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

if (error != simdjson::NO_SUCH_FIELD) { cerr << "Expected NO_SUCH_FIELD error for uint64_t(doc[\"d\"]), got " << error << endl; return false; }

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

if (error != simdjson::NO_SUCH_FIELD) { cerr << "Expected NO_SUCH_FIELD error for uint64_t(doc[\"d\"]), got " << error << endl; return false; }

#endif

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

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

if (error != simdjson::NO_SUCH_FIELD) { cerr << "Expected NO_SUCH_FIELD error for uint64_t(doc[\"d\"]), got " << error << endl; return false; }

error = doc["d"].error();

if (error != simdjson::NO_SUCH_FIELD) { cerr << "Expected NO_SUCH_FIELD error for uint64_t(doc[\"d\"]), got " << error << endl; return false; }

return true;

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

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

dom::parser parser;

auto [doc, error] = parser.parse(json);

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

if (doc["obj"]["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(doc[\"obj\"][\"a\"]) to be 1, was " << doc["obj"]["a"].first << endl; return false; }

object obj;

doc.get<dom::object>().tie(obj, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0

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

if (obj["obj"]["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(doc[\"obj\"][\"a\"]) to be 1, was " << doc["obj"]["a"].first << endl; return false; }

obj["obj"].get<dom::object>().tie(obj, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0

if (obj["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(obj[\"a\"]) to be 1, was " << obj["a"].first << endl; return false; }

if (obj["b"].get<uint64_t>().first != 2) { cerr << "Expected uint64_t(obj[\"b\"]) to be 2, was " << obj["b"].first << endl; return false; }

if (obj["c/d"].get<uint64_t>().first != 3) { cerr << "Expected uint64_t(obj[\"c\"]) to be 3, was " << obj["c"].first << endl; return false; }

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

if (obj["c/d"].get<uint64_t>().first != 3) { cerr << "Expected uint64_t(obj[\"c\"]) to be 3, was " << obj["c"].first << endl; return false; }

if (obj["b"].get<uint64_t>().first != 2) { cerr << "Expected uint64_t(obj[\"b\"]) to be 2, was " << obj["b"].first << endl; return false; }

if (obj["a"].get<uint64_t>().first != 1) { cerr << "Expected uint64_t(obj[\"a\"]) to be 1, was " << obj["a"].first << endl; return false; }

UNUSED element val;

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

if (error != simdjson::NO_SUCH_FIELD) { cerr << "Expected NO_SUCH_FIELD error for uint64_t(obj[\"d\"]), got " << error << endl; return false; }

return true;

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

// Prints the number of results in twitter.json

dom::parser parser;

auto [result_count, error] = parser.load(TWITTER_JSON)["search_metadata"]["count"].get<uint64_t>();

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

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;

auto [tweets, error] = parser.load(TWITTER_JSON)["statuses"].get<dom::array>();

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

for (auto tweet : tweets) {

object user;

tweet["user"].get<dom::object>().tie(user, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

bool default_profile;

user["default_profile"].get<bool>().tie(default_profile, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

if (default_profile) {

std::string_view screen_name;

user["screen_name"].get<std::string_view>().tie(screen_name, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

default_users.insert(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;

auto [tweets, error] = parser.load(TWITTER_JSON)["statuses"].get<dom::array>();

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

for (auto tweet : tweets) {

auto [media, not_found] = tweet["entities"]["media"].get<dom::array>();

if (!not_found) {

for (auto image : media) {

object sizes;

image["sizes"].get<dom::object>().tie(sizes, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

for (auto size : sizes) {

uint64_t width, height;

size.value["w"].get<uint64_t>().tie(width, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

size.value["h"].get<uint64_t>().tie(height, error); // tie(...) = fails with "no viable overloaded '='" on Apple clang version 11.0.0;

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

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

}

}

}

}

if (image_sizes.size() != 15) { cerr << "Expected twitter.json[statuses][entities][media][sizes] to contain 15 different sizes, got " << image_sizes.size() << endl; return false; }

return true;

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

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