//

// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)

// Copyright (c) 2020 Krystian Stasiowski (sdkrystian@gmail.com)

//

// Distributed under the Boost Software License, Version 1.0. (See accompanying

// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)

//

// Official repository: https://github.com/boostorg/json

//

// Test that header file is self-contained.

#include <boost/json/basic_parser_impl.hpp>

#include <boost/core/detail/static_assert.hpp>

#include <boost/mp11/algorithm.hpp>

#include <boost/mp11/bind.hpp>

#include <memory>

#include <string>

#include <utility>

#include "parse-vectors.hpp"

#include "test.hpp"

#include "test_suite.hpp"

namespace boost {

namespace json {

namespace {

template <std::size_t N, std::size_t I>

struct to_bits

{

using type = mp11::mp_push_back<

typename to_bits<N-1, I/2>::type, mp11::mp_bool<I % 2> >;

};

template <std::size_t I>

struct to_bits<0, I>

{

using type = mp11::mp_list<>;

};

template <class N, class I>

using to_bits_t = typename to_bits<N::value, I::value>::type;

template< std::size_t N >

using enumerate_bit_vectors = mp11::mp_transform_q<

mp11::mp_bind_front< to_bits_t, mp11::mp_int<N> >,

mp11::mp_iota_c< (1 << N) - 1 > >;

} // namespace

BOOST_CORE_STATIC_ASSERT(

std::is_nothrow_destructible<basic_parser<int>>::value );

namespace base64 {

std::size_t constexpr

decoded_size(std::size_t n)

{

return n / 4 * 3; // requires n&3==0, smaller

}

signed char const*

get_inverse()

{

static signed char constexpr tab[] = {

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0-15

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16-31

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, // 32-47

52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, // 48-63

-1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 64-79

15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, // 80-95

-1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 96-111

41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, // 112-127

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 128-143

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 144-159

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 160-175

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 176-191

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 192-207

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 208-223

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224-239

-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240-255

};

return &tab[0];

}

std::pair<std::size_t, std::size_t>

decode(void* dest, char const* src, std::size_t len)

{

char* out = static_cast<char*>(dest);

auto in = reinterpret_cast<unsigned char const*>(src);

unsigned char c3[3], c4[4];

int i = 0;

int j = 0;

auto const inverse = base64::get_inverse();

while(len-- && *in != '=')

{

auto const v = inverse[*in];

if(v == -1)

break;

++in;

c4[i] = v;

if(++i == 4)

{

c3[0] = (c4[0] << 2) + ((c4[1] & 0x30) >> 4);

c3[1] = ((c4[1] & 0xf) << 4) + ((c4[2] & 0x3c) >> 2);

c3[2] = ((c4[2] & 0x3) << 6) + c4[3];

for(i = 0; i < 3; i++)

*out++ = c3[i];

i = 0;

}

}

if(i)

{

c3[0] = ( c4[0] << 2) + ((c4[1] & 0x30) >> 4);

c3[1] = ((c4[1] & 0xf) << 4) + ((c4[2] & 0x3c) >> 2);

c3[2] = ((c4[2] & 0x3) << 6) + c4[3];

for(j = 0; j < i - 1; j++)

*out++ = c3[j];

}

return {out - static_cast<char*>(dest),

in - reinterpret_cast<unsigned char const*>(src)};

}

} // base64

namespace {

bool

validate( string_view s )

{

// Parse with the null parser and return false on error

null_parser p;

system::error_code ec;

p.write( s.data(), s.size(), ec );

if( ec )

return false;

// The string is valid JSON.

return true;

}

parse_options

make_options(

bool comments,

bool commas,

bool utf8,

bool allow_special_numbers)

{

parse_options opt;

opt.allow_comments = comments;

opt.allow_trailing_commas = commas;

opt.allow_invalid_utf8 = utf8;

opt.allow_infinity_and_nan = allow_special_numbers;

return opt;

}

template< template< class... > class L, class... Bools >

parse_options

make_options( L<Bools...> )

{

return make_options( Bools::value... );

}

class options_maker

{

private:

std::vector<parse_options>& result_;

public:

options_maker(std::vector<parse_options>& result)

: result_(result)

{}

template< class Bools >

void operator()(Bools b) const

{

result_.push_back( make_options(b) );

}

};

} // (anon)

class basic_parser_test

{

public:

::test_suite::log_type log;

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable: 4456) // non dll-interface class used as base for dll-interface class

#endif

#define TEST_GRIND_ONE(s, good, po) \

do { \

string_view _test_gr1_s = s; \

system::error_code ec; \

fail_parser p((po)); \

auto sz = p.write(false, _test_gr1_s.data(), _test_gr1_s.size(), ec); \

if(good) \

{ \

if(! BOOST_TEST(!ec) ) \

{ \

log << " " << ec.what() << " after " << sz << " characters of " << _test_gr1_s << '\n'; \

} \

} \

else \

BOOST_TEST(ec); \

} while (false)

#define TEST_GRIND(s, good, po) \

do { \

TEST_GRIND_ONE((s), (good), (po)); \

string_view _test_gr_s = s; \

/* split/errors matrix*/ \

if(! _test_gr_s.empty()) \

{ \

for(std::size_t i = 1; i < _test_gr_s.size(); ++i) \

{ \

for(std::size_t j = 1;;++j) \

{ \

system::error_code ec; \

fail_parser p(j, (po)); \

auto sz = p.write(true, _test_gr_s.data(), i, ec); \

if(ec == error::test_failure) \

continue; \

if(! ec) \

{ \

sz += p.write(false, \

_test_gr_s.data() + i, \

_test_gr_s.size() - i, \

ec); \

if(ec == error::test_failure) \

continue; \

} \

if(good) \

{ \

if(! BOOST_TEST(!ec) ) \

{ \

log << " " << ec.what() << " after " << sz << " characters of " << _test_gr_s << '\n'; \

} \

} \

else \

BOOST_TEST(ec); \

break; \

} \

} \

} \

/* split/exceptions matrix */ \

if(! _test_gr_s.empty()) \

{ \

for(std::size_t i = 1; i < _test_gr_s.size(); ++i) \

{ \

for(std::size_t j = 1;;++j) \

{ \

system::error_code ec; \

throw_parser p(j, (po)); \

try \

{ \

auto sz = p.write(true, _test_gr_s.data(), i, ec); \

if(! ec) \

sz += p.write(false, \

_test_gr_s.data() + i, \

_test_gr_s.size() - i, \

ec); \

if(good) \

{ \

if(! BOOST_TEST(!ec) ) \

{ \

log << " " << ec.what() << " after " << sz << " characters of " << _test_gr_s << '\n'; \

} \

} \

else \

BOOST_TEST(ec); \

break; \

} \

catch(test_exception const&) \

{ \

continue; \

} \

catch(std::exception const& e) \

{ \

BOOST_TEST_FAIL(); \

log << " " << e.what() << std::endl; \

} \

} \

} \

} \

} while (false)

#define TEST_BAD_EXT(s, po) TEST_GRIND((s), false, (po))

#define TEST_BAD_ONE_EXT(s, po) TEST_GRIND_ONE((s), false, (po))

#define TEST_BAD(s) TEST_BAD_EXT((s), parse_options())

#define TEST_BAD_ONE(s) TEST_BAD_ONE_EXT((s), parse_options())

#define TEST_GOOD_EXT(s, po) TEST_GRIND((s), true, (po))

#define TEST_GOOD_ONE_EXT(s, po) TEST_GRIND_ONE((s), true, (po))

#define TEST_GOOD(s) TEST_GOOD_EXT((s), parse_options())

#define TEST_GOOD_ONE(s) TEST_GOOD_ONE_EXT((s), parse_options())

//------------------------------------------------------

void

testNull()

{

TEST_GOOD("null");

TEST_GOOD(" null");

TEST_GOOD("null ");

TEST_GOOD("\tnull");

TEST_GOOD("null\t");

TEST_GOOD("\r\n\t null\r\n\t ");

TEST_BAD ("n ");

TEST_BAD ("nu ");

TEST_BAD ("nul ");

TEST_BAD ("n--- ");

TEST_BAD ("nu-- ");

TEST_BAD ("nul- ");

TEST_BAD ("NULL");

TEST_BAD ("Null");

TEST_BAD ("nulls");

}

void

testBoolean()

{

TEST_GOOD("true");

TEST_GOOD(" true");

TEST_GOOD("true ");

TEST_GOOD("\ttrue");

TEST_GOOD("true\t");

TEST_GOOD("\r\n\t true\r\n\t ");

TEST_BAD ("t ");

TEST_BAD ("tr ");

TEST_BAD ("tru ");

TEST_BAD ("t--- ");

TEST_BAD ("tr-- ");

TEST_BAD ("tru- ");

TEST_BAD ("TRUE");

TEST_BAD ("True");

TEST_BAD ("truer");

TEST_GOOD("false");

TEST_GOOD(" false");

TEST_GOOD("false ");

TEST_GOOD("\tfalse");

TEST_GOOD("false\t");

TEST_GOOD("\r\n\t false\r\n\t ");

TEST_BAD ("f ");

TEST_BAD ("fa ");

TEST_BAD ("fal ");

TEST_BAD ("fals ");

TEST_BAD ("f---- ");

TEST_BAD ("fa--- ");

TEST_BAD ("fal-- ");

TEST_BAD ("fals- ");

TEST_BAD ("FALSE");

TEST_BAD ("False");

TEST_BAD ("falser");

}

void

testSpecialNumbers()

{

parse_options with_special_numbers;

with_special_numbers.allow_infinity_and_nan = true;

TEST_GOOD_EXT("Infinity", with_special_numbers);

TEST_GOOD_EXT(" Infinity", with_special_numbers);

TEST_GOOD_EXT("Infinity ", with_special_numbers);

TEST_GOOD_EXT("\tInfinity", with_special_numbers);

TEST_GOOD_EXT("Infinity\t", with_special_numbers);

TEST_GOOD_EXT("\r\n\t Infinity\r\n\t ", with_special_numbers);

TEST_BAD_EXT("I ", with_special_numbers);

TEST_BAD_EXT("In ", with_special_numbers);

TEST_BAD_EXT("Inf ", with_special_numbers);

TEST_BAD_EXT("Infi ", with_special_numbers);

TEST_BAD_EXT("Infin ", with_special_numbers);

TEST_BAD_EXT("Infini ", with_special_numbers);

TEST_BAD_EXT("Infinit ", with_special_numbers);

TEST_BAD_EXT("I------- ", with_special_numbers);

TEST_BAD_EXT("In------ ", with_special_numbers);

TEST_BAD_EXT("Inf----- ", with_special_numbers);

TEST_BAD_EXT("Infi---- ", with_special_numbers);

TEST_BAD_EXT("Infin--- ", with_special_numbers);

TEST_BAD_EXT("Infini-- ", with_special_numbers);

TEST_BAD_EXT("Infinit- ", with_special_numbers);

TEST_BAD_EXT("INFINITY", with_special_numbers);

TEST_BAD_EXT("infinity", with_special_numbers);

TEST_BAD_EXT("Infinitys", with_special_numbers);

TEST_GOOD_EXT("-Infinity", with_special_numbers);

TEST_GOOD_EXT(" -Infinity", with_special_numbers);

TEST_GOOD_EXT("-Infinity ", with_special_numbers);

TEST_GOOD_EXT("\t-Infinity", with_special_numbers);

TEST_GOOD_EXT("-Infinity\t", with_special_numbers);

TEST_GOOD_EXT("\r\n\t -Infinity\r\n\t ", with_special_numbers);

// trigger fast path

TEST_GOOD_EXT("-Infinity ", with_special_numbers);

TEST_BAD_EXT("-I ", with_special_numbers);

TEST_BAD_EXT("-In ", with_special_numbers);

TEST_BAD_EXT("-Inf ", with_special_numbers);

TEST_BAD_EXT("-Infi ", with_special_numbers);

TEST_BAD_EXT("-Infin ", with_special_numbers);

TEST_BAD_EXT("-Infini ", with_special_numbers);

TEST_BAD_EXT("-Infinit ", with_special_numbers);

TEST_BAD_EXT("-I------- ", with_special_numbers);

TEST_BAD_EXT("-In------ ", with_special_numbers);

TEST_BAD_EXT("-Inf----- ", with_special_numbers);

TEST_BAD_EXT("-Infi---- ", with_special_numbers);

TEST_BAD_EXT("-Infin--- ", with_special_numbers);

TEST_BAD_EXT("-Infini-- ", with_special_numbers);

TEST_BAD_EXT("-Infinit- ", with_special_numbers);

TEST_BAD_EXT("-INFINITY", with_special_numbers);

TEST_BAD_EXT("-infinity", with_special_numbers);

TEST_BAD_EXT("-Infinitys", with_special_numbers);

TEST_GOOD_EXT("NaN", with_special_numbers);

TEST_GOOD_EXT(" NaN", with_special_numbers);

TEST_GOOD_EXT("NaN ", with_special_numbers);

TEST_GOOD_EXT("\tNaN", with_special_numbers);

TEST_GOOD_EXT("NaN\t", with_special_numbers);

TEST_GOOD_EXT("\r\n\t NaN\r\n\t ", with_special_numbers);

TEST_BAD_EXT("N ", with_special_numbers);

TEST_BAD_EXT("Na ", with_special_numbers);

TEST_BAD_EXT("N-- ", with_special_numbers);

TEST_BAD_EXT("Na- ", with_special_numbers);

TEST_BAD_EXT("NAN", with_special_numbers);

TEST_BAD_EXT("nan", with_special_numbers);

}

void

testString()

{

TEST_GOOD(R"jv( "x" )jv");

TEST_GOOD(R"jv( "xy" )jv");

TEST_GOOD(R"jv( "x y" )jv");

// escapes

TEST_GOOD(R"jv(" \" ")jv");

TEST_GOOD(R"jv(" \\ ")jv");

TEST_GOOD(R"jv(" \/ ")jv");

TEST_GOOD(R"jv(" \b ")jv");

TEST_GOOD(R"jv(" \f ")jv");

TEST_GOOD(R"jv(" \n ")jv");

TEST_GOOD(R"jv(" \r ")jv");

TEST_GOOD(R"jv(" \t ")jv");

// utf-16 escapes

TEST_GOOD(R"jv( " \u0000 " )jv");

TEST_GOOD(R"jv( " \ud7ff " )jv");

TEST_GOOD(R"jv( " \ue000 " )jv");

TEST_GOOD(R"jv( " \uffff " )jv");

TEST_GOOD(R"jv( " \ud800\udc00 " )jv");

TEST_GOOD(R"jv( " \udbff\udfff " )jv");

TEST_GOOD(R"jv( " \n\u0000 " )jv");

// escape in key

TEST_GOOD(R"jv( {" \n":null} )jv");

// incomplete

TEST_BAD ("\"");

// illegal control character

TEST_BAD ((string_view{ "\"" "\x00" "\"", 3 }));

TEST_BAD ("\"" "\x1f" "\"");

TEST_BAD ("\"" "\\n" "\x1f" "\"");

// incomplete escape

TEST_BAD (R"jv( "\" )jv");

// invalid escape

TEST_BAD (R"jv( "\z" )jv");

// utf-16 escape, fast path,

// invalid surrogate

TEST_BAD (R"jv( " \u---- " )jv");

TEST_BAD (R"jv( " \ud--- " )jv");

TEST_BAD (R"jv( " \ud8-- " )jv");

TEST_BAD (R"jv( " \ud80- " )jv");

// invalid low surrogate

TEST_BAD (R"jv( " \ud800------ " )jv");

TEST_BAD (R"jv( " \ud800\----- " )jv");

TEST_BAD (R"jv( " \ud800\u---- " )jv");

TEST_BAD (R"jv( " \ud800\ud--- " )jv");

TEST_BAD (R"jv( " \ud800\udc-- " )jv");

TEST_BAD (R"jv( " \ud800\udc0- " )jv");

// illegal leading surrogate

TEST_BAD (R"jv( " \udc00 " )jv");

TEST_BAD (R"jv( " \udfff " )jv");

// illegal trailing surrogate

TEST_BAD (R"jv( " \ud800\udbff " )jv");

TEST_BAD (R"jv( " \ud800\ue000 " )jv");

}

void

testNumber()

{

TEST_GOOD("0");

TEST_GOOD("0 ");

TEST_GOOD("0e0 ");

TEST_GOOD("0E0 ");

TEST_GOOD("0e00 ");

TEST_GOOD("0E01 ");

TEST_GOOD("0e+0 ");

TEST_GOOD("0e-0 ");

TEST_GOOD("0.0 ");

TEST_GOOD("0.01 ");

TEST_GOOD("0.0e0 ");

TEST_GOOD("0.01e+0 ");

TEST_GOOD("0.02E-0 ");

TEST_GOOD("1 ");

TEST_GOOD("12 ");

TEST_GOOD("1e0 ");

TEST_GOOD("1E0 ");

TEST_GOOD("1e00 ");

TEST_GOOD("1E01 ");

TEST_GOOD("1e+0 ");

TEST_GOOD("1e-0 ");

TEST_GOOD("1.0 ");

TEST_GOOD("1.01 ");

TEST_GOOD("1.0e0 ");

TEST_GOOD("1.01e+0 ");

TEST_GOOD("1.02E-0 ");

TEST_GOOD("1.0");

TEST_GOOD("-0 ");

TEST_GOOD("-0e0 ");

TEST_GOOD("-0E0 ");

TEST_GOOD("-0e00 ");

TEST_GOOD("-0E01 ");

TEST_GOOD("-0e+0 ");

TEST_GOOD("-0e-0 ");

TEST_GOOD("-0.0 ");

TEST_GOOD("-0.01 ");

TEST_GOOD("-0.0e0 ");

TEST_GOOD("-0.01e+0 ");

TEST_GOOD("-0.02E-0 ");

TEST_GOOD("-1 ");

TEST_GOOD("-12 ");

TEST_GOOD("-1 ");

TEST_GOOD("-1e0 ");

TEST_GOOD("-1E0 ");

TEST_GOOD("-1e00 ");

TEST_GOOD("-1E01 ");

TEST_GOOD("-1e+0 ");

TEST_GOOD("-1e-0 ");

TEST_GOOD("-1.0 ");

TEST_GOOD("-1.01 ");

TEST_GOOD("-1.0e0 ");

TEST_GOOD("-1.01e+0 ");

TEST_GOOD("-1.02E-0 ");

TEST_GOOD("-1.0");

TEST_GOOD("1.1e309 ");

TEST_GOOD("9223372036854775807 ");

TEST_GOOD("-9223372036854775807 ");

TEST_GOOD("18446744073709551615 ");

TEST_GOOD("-18446744073709551615 ");

TEST_GOOD("1234567890123456");

TEST_GOOD("-1234567890123456");

TEST_GOOD("10000000000000000000000000");

TEST_GOOD("0.900719925474099178 ");

TEST_GOOD("0.0e2147483648");

TEST_GOOD("10.0e2147483648");

TEST_GOOD("0.01e-2147483648");

// non-significant digits

TEST_GOOD("1000000000000000000000000 ");

TEST_GOOD("1000000000000000000000000e1 ");

TEST_GOOD("1000000000000000000000000.0 ");

TEST_GOOD("1000000000000000000000000.00 ");

TEST_GOOD("1000000000000000000000000.000000000001");

TEST_GOOD("1000000000000000000000000.0e1 ");

TEST_GOOD("1000000000000000000000000.0 ");

TEST_GOOD("1000000000.1000000000 ");

TEST_BAD("");

TEST_BAD("- ");

TEST_BAD("00 ");

TEST_BAD("01 ");

TEST_BAD("00. ");

TEST_BAD("00.0 ");

TEST_BAD("-00 ");

TEST_BAD("-01 ");

TEST_BAD("-00. ");

TEST_BAD("-00.0 ");

TEST_BAD("1a ");

TEST_BAD("-a ");

TEST_BAD(". ");

TEST_BAD("1. ");

TEST_BAD("1+ ");

TEST_BAD("0.0+ ");

TEST_BAD("0.0e+ ");

TEST_BAD("0.0e- ");

TEST_BAD("0.0e0- ");

TEST_BAD("0.0e ");

TEST_BAD("1eX ");

TEST_BAD("1000000000000000000000000.e ");

TEST_BAD("0.");

TEST_BAD("0.0e+");

}

void

testArray()

{

TEST_GOOD("[]");

TEST_GOOD("[ ]");

TEST_GOOD("[ \t ]");

TEST_GOOD("[ \"\" ]");

TEST_GOOD("[ \" \" ]");

TEST_GOOD("[ \"x\" ]");

TEST_GOOD("[ \"x\", \"y\" ]");

TEST_GOOD("[1,2,3]");

TEST_GOOD(" [1,2,3]");

TEST_GOOD("[1,2,3] ");

TEST_GOOD(" [1,2,3] ");

TEST_GOOD("[1,2,3]");

TEST_GOOD("[ 1,2,3]");

TEST_GOOD("[1 ,2,3]");

TEST_GOOD("[1, 2,3]");

TEST_GOOD("[1,2 ,3]");

TEST_GOOD("[1,2, 3]");

TEST_GOOD("[1,2,3 ]");

TEST_GOOD(" [ 1 , 2 \t\n , \n3]");

TEST_BAD ("[");

TEST_BAD (" [");

TEST_BAD (" []]");

TEST_BAD ("[{]");

TEST_BAD (R"jv( [ null ; 1 ] )jv");

}

void

testObject()

{

TEST_GOOD("{}");

TEST_GOOD("{ }");

TEST_GOOD("{ \t }");

TEST_GOOD("{\"x\":null}");

TEST_GOOD("{ \"x\":null}");

TEST_GOOD("{\"x\" :null}");

TEST_GOOD("{\"x\": null}");

TEST_GOOD("{\"x\":null }");

TEST_GOOD("{ \"x\" : null }");

TEST_GOOD("{ \"x\" : {} }");

TEST_GOOD("{ \"x\" : [] }");

TEST_GOOD("{ \"x\" : { \"y\" : null } }");

TEST_GOOD("{ \"x\" : [{}] }");

TEST_GOOD("{\"x\\ny\\u0022\":null}");

TEST_GOOD("{ \"x\":1, \"y\":null}");

TEST_GOOD("{\"x\":1,\"y\":2,\"z\":3}");

TEST_GOOD(" {\"x\":1,\"y\":2,\"z\":3}");

TEST_GOOD("{\"x\":1,\"y\":2,\"z\":3} ");

TEST_GOOD(" {\"x\":1,\"y\":2,\"z\":3} ");

TEST_GOOD("{ \"x\":1,\"y\":2,\"z\":3}");

TEST_GOOD("{\"x\" :1,\"y\":2,\"z\":3}");

TEST_GOOD("{\"x\":1 ,\"y\":2,\"z\":3}");

TEST_GOOD("{\"x\":1,\"y\" :2,\"z\":3}");

TEST_GOOD("{\"x\":1,\"y\": 2,\"z\":3}");

TEST_GOOD("{\"x\":1,\"y\":2 ,\"z\":3}");

TEST_GOOD("{\"x\":1,\"y\":2, \"z\":3}");

TEST_GOOD("{\"x\":1,\"y\":2, \"z\" :3}");

TEST_GOOD("{\"x\":1,\"y\":2, \"z\": 3}");

TEST_GOOD("{\"x\":1,\"y\":2, \"z\":3 }");

TEST_GOOD(" \t { \"x\" \n : 1, \"y\" :2, \"z\" : 3} \n");

TEST_GOOD("[{\"x\":[{\"y\":null}]}]");

TEST_BAD ("{");

TEST_BAD (" {");

TEST_BAD (" {}}");

TEST_BAD ("{{}}");

TEST_BAD ("{[]}");

TEST_BAD (R"jv( {"x";null} )jv");

TEST_BAD (R"jv( {"x":null . "y":0} )jv");

}

void

testParser()

{

auto const check =

[this]( string_view s,

bool done)

{

fail_parser p;

system::error_code ec;

p.write_some(

true,

s.data(), s.size(),

ec);

if(! BOOST_TEST(! ec))

{

log << " failed to parse: " << s << '\n';

return;

}

BOOST_TEST(done == p.done());

};

// done()

check("{}", true);

check("{} ", true);

check("{}x", true);

check("{} x", true);

check("[]", true);

check("[] ", true);

check("[]x", true);

check("[] x", true);

check("\"a\"", true);

check("\"a\" ", true);

check("\"a\"x", true);

check("\"a\" x", true);

check("0", false);

check("0 ", true);

check("0x", true);

check("0 x", true);

check("0.", false);

check("0.0", false);

check("0.0 ", true);

check("0.0 x", true);

check("true", true);

check("true ", true);

check("truex", true);

check("true x", true);

check("false", true);

check("false ", true);

check("falsex", true);

check("false x", true);

check("null", true);

check("null ", true);

check("nullx", true);

check("null x", true);

// flush

{

{

for(auto esc :

{ "\\\"", "\\\\", "\\/", "\\b",

"\\f", "\\n", "\\r", "\\t", "\\u0000"

})

{

std::string const big =

"\\\"" + std::string(

BOOST_JSON_STACK_BUFFER_SIZE-4, '*') + esc;

std::string const s =

"{\"" + big + "\":\"" + big + "\"}";

TEST_GOOD_ONE(s);

}

}

{

std::string big;

big = "\\\"" +

std::string(

BOOST_JSON_STACK_BUFFER_SIZE+ 1, '*');

std::string s;

s = "{\"" + big + "\":\"" + big + "\"}";

TEST_GOOD_ONE(s);

}

}

// no input

{

system::error_code ec;

fail_parser p;

p.write(false, nullptr, 0, ec);

BOOST_TEST(ec);

}

}

void

testMembers()

{

fail_parser p;

std::size_t n;

system::error_code ec;

n = p.write_some(true, "null", 4, ec );

if(BOOST_TEST(! ec))

{

BOOST_TEST(n == 4);

BOOST_TEST(p.done());

n = p.write_some(false, " \t42", 4, ec);

BOOST_TEST(n == 2);

BOOST_TEST(! ec);

}

p.reset();

n = p.write_some(false, "[1,2,3]", 7, ec);

if(BOOST_TEST(! ec))

{

BOOST_TEST(n == 7);

BOOST_TEST(p.done());

}

}

void

testParseVectors()

{

using all_param_combinations = enumerate_bit_vectors<4>;

std::vector<parse_options> all_configs ;

mp11::mp_for_each<all_param_combinations>(

options_maker(all_configs));

parse_vectors pv;

for(auto const& v : pv)

{

// skip these , because basic_parser

// doesn't have a max_depth setting.

if( v.name == "structure_100000_opening_arrays" ||

v.name == "structure_open_array_object")

{

continue;

}

for (const parse_options& po : all_configs)

{

if(v.result == 'i')

{

system::error_code ec;

fail_parser p(po);

p.write(

false,

v.text.data(),

v.text.size(),

ec);

if(! ec)

TEST_GOOD_ONE_EXT(v.text, po);

else

TEST_BAD_ONE_EXT(v.text, po);

}

else if(v.result == 'y')

TEST_GOOD_ONE_EXT(v.text, po);

else

TEST_BAD_ONE_EXT(v.text, po);

}

}

}

// https://github.com/boostorg/json/issues/13

void

testIssue13()

{

validate("\"~QQ36644632 {n");

}

void

testIssue20()

{

string_view s =

"WyL//34zOVx1ZDg0ZFx1ZGM4M2RcdWQ4M2RcdWRlM2M4dWRlMTlcdWQ4M2RcdWRlMzlkZWUzOVx1"

"ZDg0ZFx1ZGM4M2RcdWQ4M2RcdWRlMzlcXHVkY2M4M1x1ZDg5ZFx1ZGUzOVx1ZDgzZFx1ZGUzOWRb"

"IGZhbHNlLDMzMzMzMzMzMzMzMzMzMzMzNDMzMzMzMTY1MzczNzMwLDMzMzMzMzMzMzMzMzMzMzMz"

"MzM3ODAsMzMzMzMzMzMzMzM0MzMzMzMxNjUzNzM3MzAsMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMz"

"MzM3ODAsMzMzMzMzMzMzMzMzMzQzMzMzMzE2NTM3MzczMCwzMzMzMzMzMzMzMzMzMzMzMzMzNzgw"

"LDMzMzMzMzM4MzU1MzMwNzQ3NDYwLDMzMTY2NTAwMDAzMzMzMzMwNzQ3MzMzMzMzMzc3OSwzMzMz"

"MzMzMzMzMzMzMzMzNDMzMzMzMzMwNzQ3NDYwLDMzMzMzMzMzMzMzMzMzMzMzMzMzNzgwLDMzMzMz"

"MzMzMzMzMzMzMzA4ODM1NTMzMDc0Mzc4MCwzMzMzMzMzMzMzMzMzMzMwODgzNTUzMzA3NDc0NjAs"

"MzMzMzMzMzMxNjY1MDAwMDMzMzMzNDc0NjAsMzMzMzMzMzMzMzMzMzMzMzMzMzc4MCwzMzMzMzMz"

"MzMzMzM3MzMzMzE2NjUwMDAwMzMzMzMzMDc0NzMzMzMzMzM3NzksMzMzMzMzMzMzMzMzMzMzMzQz"

"MzMzMzMwNzQ3NDYwLDMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzc4MCwzMzMzMzMzMzMzNzgw"

"LDMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0NzQ2MCwzMzE2NjUwMDAwMzMzMzMzMDc0NzMzMzMzMzM3"

"NzksMzMzMzMzMzMzMzMzMzMzMzQzMzMzMzMwNzQ3NDYwLDMzMzMzMzMzMzMzMzMzMzMzMzMzNzgw"

"LDMzMzMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0Mzc4MCwzMzMzMzMzMzMzMzMzMzMzMzMwODgzNTUz"

"MzA3NDM3ODAsMzMzMzMzMzMzMzMzMzMzMDg4MzU1MzMwNzQ3NDYwLDMzMzMzMzMzMzMzMDczMzM3"

"NDc0NjAsMzMzMzMzMzMzMzMzMzMzMzMzNzgwLDMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0NzQ2MCwz"

"MzE2NjUwMDAwMzMzMzMzMDc0NzMzMzMzMzM3NzksMzMzMzMzMzMzMzMzMzMzMzQzMzMzMzMzMDc0"

"NzQ2MCwzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzMzM3ODAsMzMzMzMzMzMzMzMzMzMzMDg4"

"MzU1MzMwNzQzNzgwLDMzMzMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0NzQ2MCwzMzMzMzMzMzMzMzMz"

"MzMzMzM0MjQ3LDMzMzMzMzMzMzMzMzMzMzQzMzMzMzMzMzMzMzMzMzM3MzMzMzQzMzMzMzMzMDc0"

"NzQ2MCwzMzMzMzMzMzMzMzMzMzMzMzMzNzgwLDMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0NzQ2MCwz"

"MzE2NjUwMDAwMzMzMzMzMDc0NzMzMzMzMzM3NzksMzMzMzMzMzMzMzMzMzMzMzQzMzMzMzMwNzQ3"

"NDYwLDMzMzMzMzMzMzMzMzMzMzMzMzMzNzgwLDMzMzMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0Mzc4"

"MCwzMzMzMzMzMzMzMzMzMzMwODgzNTUzMzA3NDc0NjAsMzMzMzMzMzMzLDMzMzMzMzMzMzMzMzMz"

"MzMzMzM3ODAsMzMzMzMzMzMzMzc4MCwzMzMzMzMzMzMzMzMwODgzNTUzMzA3NDc0NjAsMzMxNjY1"

"MDAwMDMzMzMzMzA3NDczMzMzMzMzNzc5LDMzMzMzMzMzMzM3ODAsMzMzMzMzMzgzNTUzMzA3NDc0"

"NjAsMzMxNjY1MDAwMDMzMzMzMzA3NDczMzMzMzMzNzc5LDMzMzMzMzMzMzMzMzMzMzM0MzMzMzMz"

"MzA3NDc0NjAsMzMzMzMzMzMzMzMzMzMzMzMzMzM3ODAsMzMzMzMzMzMzMzMzMzMzMDg4MzU1MzMw"

"NzQzNzgwLDMzMzMzMzMzMzMzMzMzMzA4ODM1NTMzMDc0NzQ2MCwzMzMzMzMzMzE2NjUwMDAwMzMz"

"MzM0NzQ2MCwzMzMzMzMzMzMzMzMzMzMzMzMzNzgwLDMzMzMzMzMzMzMzMzM0MzMzMzMxNjUzNzM3"

"MzAsMzMzMzMzMzMzMzMzMzMzMzMzMzc4MCwzMzMzMzMzODM1NTMzMDc0NzQ2MCwzMzE2NjUwMDAw"

"MzMzMzMzMDc0NzMzMzMzMzM3NzksMzMzMzMzMzMzMzMzMzMzMzQzMzMzMzMzMDc0NzQ2MCwzMzMz"

"MzMzMzMzMzMzMzMzMzMzMzc4MCwzMzMzMzMzMzMzMzMzMzMwODgzNTUzMzA3NDM3ODAsMzMzMzMz"

"MzMzMzMzMzMzMDg4MzU1MzMwNzQ3NDYwLDMzMzMzMzMzMTY2NTAwMDAzMzMzMzQ3NDYwLDMzMzMz"

"MzMzMzMzMzMzMzMzMzM3ODAsMzMzMzMzMzMzMzMzNzMzMzM0MzMzMzMzMzA3NDc0NjAsMzMzMzMz"

"MzMzMzMzMzMzMzMzMzc4MCwzMzMzMzMzMzMzMzMwODgzNTUzMzA3NDc0NjAsMzMxNjY1MDAwMDMz"

"MzMzMzA3NDczMzMzMzMzNzc5LDMzMzMzMzMzMzMzMzMzMzM0MzMzMzNcdWQ4N2RcdWRlZGV1ZGM4"

"ZGUzOVx1ZDg0ZFx1ZGM4M2RcdWQ4OGRcdWRlMzlcdWQ4OWRcdWRlMjM5MzMzZWUzOVxk";

auto const len = base64::decoded_size(s.size());

std::unique_ptr<char[]> p(new char[len]);

base64::decode(

p.get(), s.data(), s.size());

string_view const js(p.get(), len);

BOOST_TEST(! validate(js));

}

void

testIssue113()

{

string_view s =

"\"\\r\\n section id='description'>\\r\\nAll mbers form the uncountable set "

"\\u211D. Among its subsets, relatively simple are the convex sets, each expressed "

"as a range between two real numbers <i>a</i> and <i>b</i> where <i>a</i> \\u2264 <i>"

"b</i>. There are actually four cases for the meaning of \\\"between\\\", depending "

"on open or closed boundary:\\r\\n\\r\\n<ul>\\r\\n <li>[<i>a</i>, <i>b</i>]: {<i>"

"x</i> | <i>a</i> \\u2264 <i>x</i> and <i>x</i> \\u2264 <i>b</i> }</li>\\r\\n <li>"

"(<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> < <i>x</i> and <i>x</i> < <i>b</i> }"

"</li>\\r\\n <li>[<i>a</i>, <i>b</i>): {<i>x</i> | <i>a</i> \\u2264 <i>x</i> and "

"<i>x</i> < <i>b</i> }</li>\\r\\n <li>(<i>a</i>, <i>b</i>]: {<i>x</i> | <i>a</i> "

"< <i>x</i> and <i>x</i> \\u2264 <i>b</i> }</li>\\r\\n</ul>\\r\\n\\r\\nNote that "

"if <i>a</i> = <i>b</i>, of the four only [<i>a</i>, <i>a</i>] would be non-empty."

"\\r\\n\\r\\n<strong>Task</strong>\\r\\n\\r\\n<ul>\\r\\n <li>Devise a way to "

"represent any set of real numbers, for the definition of \\\"any\\\" in the "

"implementation notes below.</li>\\r\\n <li>Provide methods for these common "

"set operations (<i>x</i> is a real number; <i>A</i> and <i>B</i> are sets):</li>"

"\\r\\n <ul>\\r\\n <li>\\r\\n <i>x</i> \\u2208 <i>A</i>: determine if <i>"

"x</i> is an element of <i>A</i><br>\\r\\n example: 1 is in [1, 2), while 2, "

"3, ... are not.\\r\\n </li>\\r\\n <li>\\r\\n <i>A</i> \\u222A <i>B</i>: "

"union of <i>A</i> and <i>B</i>, i.e. {<i>x</i> | <i>x</i> \\u2208 <i>A</i> or <i>x"

"</i> \\u2208 <i>B</i>}<br>\\r\\n example: [0, 2) \\u222A (1, 3) = [0, 3); "

"[0, 1) \\u222A (2, 3] = well, [0, 1) \\u222A (2, 3]\\r\\n </li>\\r\\n <li>"

"\\r\\n <i>A</i> \\u2229 <i>B</i>: intersection of <i>A</i> and <i>B</i>, i.e. "

"{<i>x</i> | <i>x</i> \\u2208 <i>A</i> and <i>x</i> \\u2208 <i>B</i>}<br>\\r\\n "

"example: [0, 2) \\u2229 (1, 3) = (1, 2); [0, 1) \\u2229 (2, 3] = empty set\\r\\n "

"</li>\\r\\n <li>\\r\\n <i>A</i> - <i>B</i>: difference between <i>A</i> and "

"<i>B</i>, also written as <i>A</i> \\\\ <i>B</i>, i.e. {<i>x</i> | <i>x</i> \\u2208 "

"<i>A</i> and <i>x</i> \\u2209 <i>B</i>}<br>\\r\\n example: [0, 2) \\u2212 (1, "

"3) = [0, 1]\\r\\n </li>\\r\\n </ul>\\r\\n</ul>\\r\\n</section>\\r\\n\"\n";

TEST_GOOD_ONE(s);

}

class comment_parser

{

struct handler

{

constexpr static std::size_t max_object_size = std::size_t(-1);

constexpr static std::size_t max_array_size = std::size_t(-1);

constexpr static std::size_t max_key_size = std::size_t(-1);

constexpr static std::size_t max_string_size = std::size_t(-1);

std::string captured = "";

bool on_document_begin( system::error_code& ) { return true; }

bool on_document_end( system::error_code& ) { return true; }

bool on_object_begin( system::error_code& ) { return true; }

bool on_object_end( std::size_t, system::error_code& ) { return true; }

bool on_array_begin( system::error_code& ) { return true; }

bool on_array_end( std::size_t, system::error_code& ) { return true; }

bool on_key_part( string_view, std::size_t, system::error_code& ) { return true; }

bool on_key( string_view, std::size_t, system::error_code& ) { return true; }

bool on_string_part( string_view, std::size_t, system::error_code& ) { return true; }

bool on_string( string_view, std::size_t, system::error_code& ) { return true; }

bool on_number_part( string_view, system::error_code&) { return true; }

bool on_int64( std::int64_t, string_view, system::error_code& ) { return true; }

bool on_uint64( std::uint64_t, string_view, system::error_code& ) { return true; }

bool on_double( double, string_view, system::error_code& ) { return true; }

bool on_bool( bool, system::error_code& ) { return true; }

bool on_null( system::error_code& ) { return true; }

bool on_comment_part( string_view s, system::error_code& )

{

captured.append(s.data(), s.size());

return true;

}

bool on_comment( string_view s, system::error_code& )

{

captured.append(s.data(), s.size());

return true;

}

};

basic_parser<handler> p_;

public:

comment_parser()

: p_(make_options(true, false, false, false))

{