2016-08-04 07:24:46 +02:00
|
|
|
/*
|
|
|
|
__ _____ _____ _____
|
|
|
|
__| | __| | | | JSON for Modern C++ (test suite)
|
2017-12-29 18:31:13 +01:00
|
|
|
| | |__ | | | | | | version 3.0.1
|
2016-08-04 07:24:46 +02:00
|
|
|
|_____|_____|_____|_|___| https://github.com/nlohmann/json
|
|
|
|
|
|
|
|
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
|
2017-01-02 09:40:00 +01:00
|
|
|
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
|
2016-08-04 07:24:46 +02:00
|
|
|
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
|
|
in the Software without restriction, including without limitation the rights
|
|
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
|
|
|
|
The above copyright notice and this permission notice shall be included in all
|
|
|
|
copies or substantial portions of the Software.
|
|
|
|
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
|
|
SOFTWARE.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "catch.hpp"
|
2016-08-04 21:55:47 +02:00
|
|
|
|
2018-01-29 11:21:11 +01:00
|
|
|
#include <nlohmann/json.hpp>
|
2016-08-04 21:55:47 +02:00
|
|
|
using nlohmann::json;
|
|
|
|
|
2017-09-10 22:38:04 +02:00
|
|
|
#include <iostream>
|
2016-08-15 22:44:14 +02:00
|
|
|
#include <valarray>
|
|
|
|
|
2016-08-04 21:55:47 +02:00
|
|
|
TEST_CASE("deserialization")
|
|
|
|
{
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("successful deserialization")
|
2016-08-04 21:55:47 +02:00
|
|
|
{
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("stream")
|
|
|
|
{
|
2017-06-16 19:23:55 +02:00
|
|
|
std::stringstream ss1, ss2;
|
|
|
|
ss1 << "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
ss2 << "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
json j = json::parse(ss1);
|
|
|
|
CHECK(json::accept(ss2));
|
2016-08-30 23:44:15 +02:00
|
|
|
CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
|
2016-08-31 18:07:18 +02:00
|
|
|
SECTION("string literal")
|
|
|
|
{
|
|
|
|
auto s = "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
json j = json::parse(s);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(s));
|
2016-08-31 18:07:18 +02:00
|
|
|
CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
|
2016-08-31 18:07:18 +02:00
|
|
|
SECTION("string_t")
|
2016-08-30 23:44:15 +02:00
|
|
|
{
|
|
|
|
json::string_t s = "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
json j = json::parse(s);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(s));
|
2016-08-30 23:44:15 +02:00
|
|
|
CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
2016-08-15 22:44:14 +02:00
|
|
|
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("operator<<")
|
|
|
|
{
|
|
|
|
std::stringstream ss;
|
|
|
|
ss << "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
json j;
|
|
|
|
j << ss;
|
|
|
|
CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("operator>>")
|
|
|
|
{
|
|
|
|
std::stringstream ss;
|
|
|
|
ss << "[\"foo\",1,2,3,false,{\"one\":1}]";
|
|
|
|
json j;
|
|
|
|
ss >> j;
|
|
|
|
CHECK(j == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("user-defined string literal")
|
|
|
|
{
|
|
|
|
CHECK("[\"foo\",1,2,3,false,{\"one\":1}]"_json == json({"foo", 1, 2, 3, false, {{"one", 1}}}));
|
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
}
|
|
|
|
|
2016-08-31 18:07:18 +02:00
|
|
|
SECTION("unsuccessful deserialization")
|
2016-08-04 21:55:47 +02:00
|
|
|
{
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("stream")
|
|
|
|
{
|
2017-07-27 20:33:11 +02:00
|
|
|
std::stringstream ss1, ss2, ss3, ss4;
|
2016-11-02 15:44:46 +01:00
|
|
|
ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
|
|
|
ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
2017-06-16 19:23:55 +02:00
|
|
|
ss3 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
2017-07-27 20:33:11 +02:00
|
|
|
ss4 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(ss1), json::parse_error&);
|
2017-03-01 21:28:44 +01:00
|
|
|
CHECK_THROWS_WITH(json::parse(ss2),
|
2017-03-24 19:49:02 +01:00
|
|
|
"[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(ss3));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(ss1, nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-08-30 23:44:15 +02:00
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
|
2016-08-30 23:44:15 +02:00
|
|
|
SECTION("string")
|
|
|
|
{
|
|
|
|
json::string_t s = "[\"foo\",1,2,3,false,{\"one\":1}";
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(s), json::parse_error&);
|
2017-03-01 21:28:44 +01:00
|
|
|
CHECK_THROWS_WITH(json::parse(s),
|
2017-03-24 19:49:02 +01:00
|
|
|
"[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(s));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(s, nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-08-30 23:44:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("operator<<")
|
|
|
|
{
|
2016-11-02 15:44:46 +01:00
|
|
|
std::stringstream ss1, ss2;
|
|
|
|
ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
|
|
|
ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
2016-08-30 23:44:15 +02:00
|
|
|
json j;
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(j << ss1, json::parse_error&);
|
2017-03-01 21:28:44 +01:00
|
|
|
CHECK_THROWS_WITH(j << ss2,
|
2017-03-24 19:49:02 +01:00
|
|
|
"[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
|
2016-08-30 23:44:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("operator>>")
|
|
|
|
{
|
2016-11-02 15:44:46 +01:00
|
|
|
std::stringstream ss1, ss2;
|
|
|
|
ss1 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
|
|
|
ss2 << "[\"foo\",1,2,3,false,{\"one\":1}";
|
2016-08-30 23:44:15 +02:00
|
|
|
json j;
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(ss1 >> j, json::parse_error&);
|
2017-03-01 21:28:44 +01:00
|
|
|
CHECK_THROWS_WITH(ss2 >> j,
|
2017-03-24 19:49:02 +01:00
|
|
|
"[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
|
2016-08-30 23:44:15 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("user-defined string literal")
|
|
|
|
{
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS("[\"foo\",1,2,3,false,{\"one\":1}"_json, json::parse_error&);
|
2016-08-30 23:44:15 +02:00
|
|
|
CHECK_THROWS_WITH("[\"foo\",1,2,3,false,{\"one\":1}"_json,
|
2017-03-24 19:49:02 +01:00
|
|
|
"[json.exception.parse_error.101] parse error at 29: syntax error - unexpected end of input; expected ']'");
|
2016-08-30 23:44:15 +02:00
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
}
|
2016-08-15 22:44:14 +02:00
|
|
|
|
|
|
|
SECTION("contiguous containers")
|
|
|
|
{
|
2016-08-20 20:29:33 +02:00
|
|
|
SECTION("directly")
|
2016-08-15 22:44:14 +02:00
|
|
|
{
|
2016-08-20 20:29:33 +02:00
|
|
|
SECTION("from std::vector")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::vector<uint8_t> v = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::array")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::array<uint8_t, 5> v { {'t', 'r', 'u', 'e'} };
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from array")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
uint8_t v[] = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
2016-08-31 18:23:46 +02:00
|
|
|
SECTION("from chars")
|
|
|
|
{
|
2016-08-31 21:27:23 +02:00
|
|
|
uint8_t* v = new uint8_t[5];
|
2016-08-31 18:23:46 +02:00
|
|
|
v[0] = 't';
|
|
|
|
v[1] = 'r';
|
|
|
|
v[2] = 'u';
|
|
|
|
v[3] = 'e';
|
|
|
|
v[4] = '\0';
|
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-31 18:23:46 +02:00
|
|
|
delete[] v;
|
|
|
|
}
|
|
|
|
|
2016-08-20 20:29:33 +02:00
|
|
|
SECTION("from std::string")
|
|
|
|
{
|
|
|
|
std::string v = {'t', 'r', 'u', 'e'};
|
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::initializer_list")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::initializer_list<uint8_t> v = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(v) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(v));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
2016-08-21 12:35:40 +02:00
|
|
|
|
|
|
|
SECTION("empty container")
|
|
|
|
{
|
|
|
|
std::vector<uint8_t> v;
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(v), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(v));
|
2016-08-21 12:35:40 +02:00
|
|
|
}
|
2016-08-15 22:44:14 +02:00
|
|
|
}
|
|
|
|
|
2016-08-20 20:29:33 +02:00
|
|
|
SECTION("via iterator range")
|
2016-08-15 22:44:14 +02:00
|
|
|
{
|
2016-08-20 20:29:33 +02:00
|
|
|
SECTION("from std::vector")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::vector<uint8_t> v = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::array")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::array<uint8_t, 5> v { {'t', 'r', 'u', 'e'} };
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from array")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
uint8_t v[] = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::string")
|
|
|
|
{
|
|
|
|
std::string v = {'t', 'r', 'u', 'e'};
|
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::initializer_list")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::initializer_list<uint8_t> v = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("from std::valarray")
|
|
|
|
{
|
2016-08-23 22:38:05 +02:00
|
|
|
std::valarray<uint8_t> v = {'t', 'r', 'u', 'e'};
|
2016-08-20 20:29:33 +02:00
|
|
|
CHECK(json::parse(std::begin(v), std::end(v)) == json(true));
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("with empty range")
|
|
|
|
{
|
|
|
|
std::vector<uint8_t> v;
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2016-08-20 20:29:33 +02:00
|
|
|
}
|
2016-08-15 22:44:14 +02:00
|
|
|
}
|
2016-09-01 00:29:42 +02:00
|
|
|
|
|
|
|
// these cases are required for 100% line coverage
|
|
|
|
SECTION("error cases")
|
|
|
|
{
|
|
|
|
SECTION("case 1")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u'};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-09-01 00:29:42 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 2")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1'};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-09-01 00:29:42 +02:00
|
|
|
}
|
2016-10-10 21:58:31 +02:00
|
|
|
|
|
|
|
SECTION("case 3")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', '\\', 'u', '1', '1', '1', '1', '1', '1', '1', '1'};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-10 21:58:31 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 4")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 'a', 'a', 'a', 'a', 'a', 'a', 'u', '1', '1', '1', '1', '1', '1', '1', '1', '\\'};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-10 21:58:31 +02:00
|
|
|
}
|
2016-10-30 17:10:11 +01:00
|
|
|
|
|
|
|
SECTION("case 5")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xC1};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:10:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 6")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xDF, 0x7F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-09-09 11:04:58 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(std::begin(v), std::end(v)),
|
2017-09-10 01:12:03 +02:00
|
|
|
"[json.exception.parse_error.101] parse error at 4: syntax error - invalid string: ill-formed UTF-8 byte; last read: '\"\x7f\xdf\x7f'");
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:10:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 7")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xDF, 0xC0};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:10:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 8")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xE0, 0x9F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:10:11 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 9")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xEF, 0xC0};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:10:11 +01:00
|
|
|
}
|
2016-10-30 17:46:00 +01:00
|
|
|
|
|
|
|
SECTION("case 10")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xED, 0x7F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 11")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xF0, 0x8F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 12")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xF0, 0xC0};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 13")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xF3, 0x7F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 14")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xF3, 0xC0};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("case 15")
|
|
|
|
{
|
|
|
|
uint8_t v[] = {'\"', 0x7F, 0xF4, 0x7F};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-16 19:23:55 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2016-10-30 17:46:00 +01:00
|
|
|
}
|
2017-06-20 21:09:26 +02:00
|
|
|
|
|
|
|
SECTION("case 16")
|
|
|
|
{
|
2017-06-20 22:35:31 +02:00
|
|
|
uint8_t v[] = {'{', '\"', '\"', ':', '1', '1'};
|
2017-07-07 22:41:22 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::begin(v), std::end(v)), json::parse_error&);
|
2017-06-20 21:09:26 +02:00
|
|
|
CHECK(not json::accept(std::begin(v), std::end(v)));
|
2017-07-27 20:33:11 +02:00
|
|
|
|
|
|
|
json j_error;
|
|
|
|
CHECK_NOTHROW(j_error = json::parse(std::begin(v), std::end(v), nullptr, false));
|
|
|
|
CHECK(j_error.is_discarded());
|
2017-06-20 21:09:26 +02:00
|
|
|
}
|
2016-09-01 00:29:42 +02:00
|
|
|
}
|
2016-08-15 22:44:14 +02:00
|
|
|
}
|
2017-09-10 22:38:04 +02:00
|
|
|
|
|
|
|
SECTION("ignoring byte-order marks")
|
|
|
|
{
|
|
|
|
std::string bom = "\xEF\xBB\xBF";
|
|
|
|
|
|
|
|
SECTION("BOM only")
|
|
|
|
{
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(bom), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(bom),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::istringstream(bom)), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(std::istringstream(bom)),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("BOM and content")
|
|
|
|
{
|
|
|
|
CHECK(json::parse(bom + "1") == 1);
|
|
|
|
CHECK(json::parse(std::istringstream(bom + "1")) == 1);
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("2 byte of BOM")
|
|
|
|
{
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(bom.substr(0, 2)), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(bom),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::istringstream(bom.substr(0, 2))), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(std::istringstream(bom)),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("1 byte of BOM")
|
|
|
|
{
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(bom.substr(0, 1)), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(bom),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(std::istringstream(bom.substr(0, 1))), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
CHECK_THROWS_WITH(json::parse(std::istringstream(bom)),
|
|
|
|
"[json.exception.parse_error.101] parse error at 1: syntax error - unexpected end of input; expected '[', '{', or a literal");
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("variations")
|
|
|
|
{
|
|
|
|
// calculate variations of each byte of the BOM to make sure
|
|
|
|
// that the BOM and only the BOM is skipped
|
|
|
|
for (int i0 = -1; i0 < 2; ++i0)
|
|
|
|
{
|
|
|
|
for (int i1 = -1; i1 < 2; ++i1)
|
|
|
|
{
|
|
|
|
for (int i2 = -1; i2 < 2; ++i2)
|
|
|
|
{
|
|
|
|
// debug output for the variations
|
|
|
|
CAPTURE(i0);
|
|
|
|
CAPTURE(i1);
|
|
|
|
CAPTURE(i2);
|
|
|
|
|
|
|
|
std::string s = "";
|
2017-09-30 11:00:26 +02:00
|
|
|
s.push_back(static_cast<char>(bom[0] + i0));
|
|
|
|
s.push_back(static_cast<char>(bom[1] + i1));
|
|
|
|
s.push_back(static_cast<char>(bom[2] + i2));
|
2017-09-10 22:38:04 +02:00
|
|
|
|
|
|
|
if (i0 == 0 and i1 == 0 and i2 == 0)
|
|
|
|
{
|
|
|
|
// without any variation, we skip the BOM
|
|
|
|
CHECK(json::parse(s + "null") == json());
|
|
|
|
CHECK(json::parse(std::istringstream(s + "null")) == json());
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
// any variation is an error
|
2017-09-30 11:00:26 +02:00
|
|
|
CHECK_THROWS_AS(json::parse(s + "null"), json::parse_error&);
|
|
|
|
CHECK_THROWS_AS(json::parse(std::istringstream(s + "null")), json::parse_error&);
|
2017-09-10 22:38:04 +02:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
SECTION("preserve state after parsing")
|
|
|
|
{
|
|
|
|
std::istringstream s(bom + "123 456");
|
|
|
|
json j;
|
|
|
|
j << s;
|
|
|
|
CHECK(j == 123);
|
|
|
|
j << s;
|
|
|
|
CHECK(j == 456);
|
|
|
|
}
|
|
|
|
}
|
2016-08-04 21:55:47 +02:00
|
|
|
}
|