Team2890/allwpilib
4
0
Fork 0
mirror of https://github.com/wpilibsuite/allwpilib synced 2026-07-02 02:51:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

Update json from upstream version 3.1.2.

Browse Source 
This adds support for ubjson and makes a number of bugfixes.

Binary input and output have switched from strings to uint8_t arrays.
This commit is contained in:
Peter Johnson
2018-05-14 22:53:22 -07:00
parent c274d1790f
commit f8ed48af98
20 changed files with 8915 additions and 6854 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1525
wpiutil/src/main/native/cpp/json.cpp
View File

File diff suppressed because it is too large Load Diff

1686
wpiutil/src/main/native/cpp/json_binary_reader.cpp
View File

File diff suppressed because it is too large Load Diff

806
wpiutil/src/main/native/cpp/json_binary_writer.cpp
View File

File diff suppressed because it is too large Load Diff

1612
wpiutil/src/main/native/cpp/json_parser.cpp
View File

File diff suppressed because it is too large Load Diff

316
wpiutil/src/main/native/cpp/json_pointer.cpp
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Modifications Copyright (c) FIRST 2017. All Rights Reserved. */
/* Modifications Copyright (c) 2017-2018 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -7,11 +7,11 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++
| | |__ | | | | | | version 2.1.1
| | |__ | | | | | | version 3.1.2
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -34,32 +34,50 @@ SOFTWARE.
#define WPI_JSON_IMPLEMENTATION
#include "wpi/json.h"
#include <algorithm>
#include <numeric> // accumulate
using namespace wpi;
#include "wpi/SmallString.h"
std::string json::json_pointer::to_string() const noexcept
namespace wpi {
std::string json_pointer::to_string() const noexcept
{
return std::accumulate(reference_tokens.begin(),
reference_tokens.end(), std::string{},
return std::accumulate(reference_tokens.begin(), reference_tokens.end(),
std::string{},
[](const std::string & a, const std::string & b)
{
return a + "/" + escape(b);
});
}
json::reference json::json_pointer::get_and_create(reference j) const
int json_pointer::array_index(const Twine& s)
{
pointer result = &j;
SmallString<128> buf;
StringRef str = s.toNullTerminatedStringRef(buf);
std::size_t processed_chars = 0;
const int res = std::stoi(str, &processed_chars);
// in case no reference tokens exist, return a reference to the
// JSON value j which will be overwritten by a primitive value
// check if the string was completely read
if (JSON_UNLIKELY(processed_chars != str.size()))
{
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + Twine(s) + "'"));
}
return res;
}
json& json_pointer::get_and_create(json& j) const
{
using size_type = typename json::size_type;
auto result = &j;
// in case no reference tokens exist, return a reference to the JSON value
// j which will be overwritten by a primitive value
for (const auto& reference_token : reference_tokens)
{
switch (result->m_type)
{
case value_t::null:
case detail::value_t::null:
{
if (reference_token == "0")
{
@@ -74,86 +92,80 @@ json::reference json::json_pointer::get_and_create(reference j) const
break;
}
case value_t::object:
case detail::value_t::object:
{
// create an entry in the object
result = &result->operator[](reference_token);
break;
}
case value_t::array:
case detail::value_t::array:
{
// create an entry in the array
JSON_TRY
{
result = &result->operator[](static_cast<size_type>(std::stoi(reference_token)));
result = &result->operator[](static_cast<size_type>(array_index(reference_token)));
}
JSON_CATCH (std::invalid_argument&)
JSON_CATCH(std::invalid_argument&)
{
JSON_THROW(parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + Twine(reference_token) + "' is not a number"));
}
break;
}
/*
The following code is only reached if there exists a
reference token _and_ the current value is primitive. In
this case, we have an error situation, because primitive
values may only occur as single value; that is, with an
empty list of reference tokens.
The following code is only reached if there exists a reference
token _and_ the current value is primitive. In this case, we have
an error situation, because primitive values may only occur as
single value; that is, with an empty list of reference tokens.
*/
default:
{
JSON_THROW(type_error::create(313, "invalid value to unflatten"));
}
JSON_THROW(detail::type_error::create(313, "invalid value to unflatten"));
}
}
return *result;
}
json::reference json::json_pointer::get_unchecked(pointer ptr) const
json& json_pointer::get_unchecked(json* ptr) const
{
using size_type = typename json::size_type;
for (const auto& reference_token : reference_tokens)
{
// convert null values to arrays or objects before continuing
if (ptr->m_type == value_t::null)
if (ptr->m_type == detail::value_t::null)
{
// check if reference token is a number
const bool nums = std::all_of(reference_token.begin(),
reference_token.end(),
[](const char x)
const bool nums =
std::all_of(reference_token.begin(), reference_token.end(),
[](const char x)
{
return (x >= '0' && x <= '9');
return (x >= '0' and x <= '9');
});
// change value to array for numbers or "-" or to object
// otherwise
if (nums || reference_token == "-")
{
*ptr = value_t::array;
}
else
{
*ptr = value_t::object;
}
// change value to array for numbers or "-" or to object otherwise
*ptr = (nums or reference_token == "-")
? detail::value_t::array
: detail::value_t::object;
}
switch (ptr->m_type)
{
case value_t::object:
case detail::value_t::object:
{
// use unchecked object access
ptr = &ptr->operator[](reference_token);
break;
}
case value_t::array:
case detail::value_t::array:
{
// error condition (cf. RFC 6901, Sect. 4)
if (reference_token.size() > 1 && reference_token[0] == '0')
if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(parse_error::create(106, 0, "array index '" + reference_token + "' must not begin with '0'"));
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + Twine(reference_token) +
"' must not begin with '0'"));
}
if (reference_token == "-")
@@ -166,193 +178,200 @@ json::reference json::json_pointer::get_unchecked(pointer ptr) const
// convert array index to number; unchecked access
JSON_TRY
{
ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
ptr = &ptr->operator[](
static_cast<size_type>(array_index(reference_token)));
}
JSON_CATCH (std::invalid_argument&)
JSON_CATCH(std::invalid_argument&)
{
JSON_THROW(parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + Twine(reference_token) + "' is not a number"));
}
}
break;
}
default:
{
JSON_THROW(out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
}
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + Twine(reference_token) + "'"));
}
}
return *ptr;
}
json::reference json::json_pointer::get_checked(pointer ptr) const
json& json_pointer::get_checked(json* ptr) const
{
using size_type = typename json::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->m_type)
{
case value_t::object:
case detail::value_t::object:
{
// note: at performs range check
ptr = &ptr->at(reference_token);
break;
}
case value_t::array:
case detail::value_t::array:
{
if (reference_token == "-")
if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(out_of_range::create(402, "array index '-' (" +
std::to_string(ptr->m_value.array->size()) +
") is out of range"));
JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + Twine(ptr->m_value.array->size()) +
") is out of range"));
}
// error condition (cf. RFC 6901, Sect. 4)
if (reference_token.size() > 1 && reference_token[0] == '0')
if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(parse_error::create(106, 0, "array index '" + reference_token + "' must not begin with '0'"));
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + Twine(reference_token) +
"' must not begin with '0'"));
}
// note: at performs range check
JSON_TRY
{
ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
}
JSON_CATCH (std::invalid_argument&)
JSON_CATCH(std::invalid_argument&)
{
JSON_THROW(parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + Twine(reference_token) + "' is not a number"));
}
break;
}
default:
{
JSON_THROW(out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
}
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + Twine(reference_token) + "'"));
}
}
return *ptr;
}
json::const_reference json::json_pointer::get_unchecked(const_pointer ptr) const
const json& json_pointer::get_unchecked(const json* ptr) const
{
using size_type = typename json::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->m_type)
{
case value_t::object:
case detail::value_t::object:
{
// use unchecked object access
ptr = &ptr->operator[](reference_token);
break;
}
case value_t::array:
case detail::value_t::array:
{
if (reference_token == "-")
if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" cannot be used for const access
JSON_THROW(out_of_range::create(402, "array index '-' (" +
std::to_string(ptr->m_value.array->size()) +
") is out of range"));
JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + Twine(ptr->m_value.array->size()) +
") is out of range"));
}
// error condition (cf. RFC 6901, Sect. 4)
if (reference_token.size() > 1 && reference_token[0] == '0')
if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(parse_error::create(106, 0, "array index '" + reference_token + "' must not begin with '0'"));
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + Twine(reference_token) +
"' must not begin with '0'"));
}
// use unchecked array access
JSON_TRY
{
ptr = &ptr->operator[](static_cast<size_type>(std::stoi(reference_token)));
ptr = &ptr->operator[](
static_cast<size_type>(array_index(reference_token)));
}
JSON_CATCH (std::invalid_argument&)
JSON_CATCH(std::invalid_argument&)
{
JSON_THROW(parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + Twine(reference_token) + "' is not a number"));
}
break;
}
default:
{
JSON_THROW(out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
}
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + Twine(reference_token) + "'"));
}
}
return *ptr;
}
json::const_reference json::json_pointer::get_checked(const_pointer ptr) const
const json& json_pointer::get_checked(const json* ptr) const
{
using size_type = typename json::size_type;
for (const auto& reference_token : reference_tokens)
{
switch (ptr->m_type)
{
case value_t::object:
case detail::value_t::object:
{
// note: at performs range check
ptr = &ptr->at(reference_token);
break;
}
case value_t::array:
case detail::value_t::array:
{
if (reference_token == "-")
if (JSON_UNLIKELY(reference_token == "-"))
{
// "-" always fails the range check
JSON_THROW(out_of_range::create(402, "array index '-' (" +
std::to_string(ptr->m_value.array->size()) +
") is out of range"));
JSON_THROW(detail::out_of_range::create(402,
"array index '-' (" + Twine(ptr->m_value.array->size()) +
") is out of range"));
}
// error condition (cf. RFC 6901, Sect. 4)
if (reference_token.size() > 1 && reference_token[0] == '0')
if (JSON_UNLIKELY(reference_token.size() > 1 and reference_token[0] == '0'))
{
JSON_THROW(parse_error::create(106, 0, "array index '" + reference_token + "' must not begin with '0'"));
JSON_THROW(detail::parse_error::create(106, 0,
"array index '" + Twine(reference_token) +
"' must not begin with '0'"));
}
// note: at performs range check
JSON_TRY
{
ptr = &ptr->at(static_cast<size_type>(std::stoi(reference_token)));
ptr = &ptr->at(static_cast<size_type>(array_index(reference_token)));
}
JSON_CATCH (std::invalid_argument&)
JSON_CATCH(std::invalid_argument&)
{
JSON_THROW(parse_error::create(109, 0, "array index '" + reference_token + "' is not a number"));
JSON_THROW(detail::parse_error::create(109, 0, "array index '" + Twine(reference_token) + "' is not a number"));
}
break;
}
default:
{
JSON_THROW(out_of_range::create(404, "unresolved reference token '" + reference_token + "'"));
}
JSON_THROW(detail::out_of_range::create(404, "unresolved reference token '" + Twine(reference_token) + "'"));
}
}
return *ptr;
}
std::vector<std::string> json::json_pointer::split(const std::string& reference_string)
std::vector<std::string> json_pointer::split(const Twine& reference_string)
{
SmallString<128> ref_str_buf;
StringRef ref_str = reference_string.toStringRef(ref_str_buf);
std::vector<std::string> result;
// special case: empty reference string -> no reference tokens
if (reference_string.empty())
if (ref_str.empty())
{
return result;
}
// check if nonempty reference string begins with slash
if (reference_string[0] != '/')
if (JSON_UNLIKELY(ref_str[0] != '/'))
{
JSON_THROW(parse_error::create(107, 1, "JSON pointer must be empty or begin with '/' - was: '" + reference_string + "'"));
JSON_THROW(detail::parse_error::create(107, 1,
"JSON pointer must be empty or begin with '/' - was: '" +
Twine(ref_str) + "'"));
}
// extract the reference tokens:
@@ -360,7 +379,7 @@ std::vector<std::string> json::json_pointer::split(const std::string& reference_
// - start: position after the previous slash
for (
// search for the first slash after the first character
size_t slash = reference_string.find_first_of('/', 1),
std::size_t slash = ref_str.find_first_of('/', 1),
// set the beginning of the first reference token
start = 1;
// we can stop if start == string::npos+1 = 0
@@ -369,120 +388,102 @@ std::vector<std::string> json::json_pointer::split(const std::string& reference_
// (will eventually be 0 if slash == std::string::npos)
start = slash + 1,
// find next slash
slash = reference_string.find_first_of('/', start))
slash = ref_str.find_first_of('/', start))
{
// use the text between the beginning of the reference token
// (start) and the last slash (slash).
auto reference_token = reference_string.substr(start, slash - start);
auto reference_token = ref_str.slice(start, slash);
// check reference tokens are properly escaped
for (size_t pos = reference_token.find_first_of('~');
pos != std::string::npos;
for (std::size_t pos = reference_token.find_first_of('~');
pos != StringRef::npos;
pos = reference_token.find_first_of('~', pos + 1))
{
assert(reference_token[pos] == '~');
// ~ must be followed by 0 or 1
if (pos == reference_token.size() - 1 ||
(reference_token[pos + 1] != '0' &&
reference_token[pos + 1] != '1'))
if (JSON_UNLIKELY(pos == reference_token.size() - 1 or
(reference_token[pos + 1] != '0' and
reference_token[pos + 1] != '1')))
{
JSON_THROW(parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
JSON_THROW(detail::parse_error::create(108, 0, "escape character '~' must be followed with '0' or '1'"));
}
}
// finally, store the reference token
unescape(reference_token);
result.push_back(reference_token);
std::string ref_tok = reference_token;
unescape(ref_tok);
result.emplace_back(std::move(ref_tok));
}
return result;
}
/*!
@brief replace all occurrences of a substring by another string
@param[in,out] s the string to manipulate; changed so that all
occurrences of @a f are replaced with @a t
@param[in] f the substring to replace with @a t
@param[in] t the string to replace @a f
@pre The search string @a f must not be empty. **This precondition is
enforced with an assertion.**
@since version 2.0.0
*/
void json::json_pointer::replace_substring(std::string& s,
const std::string& f,
void json_pointer::replace_substring(std::string& s, const std::string& f,
const std::string& t)
{
assert(!f.empty());
for (
size_t pos = s.find(f); // find first occurrence of f
pos != std::string::npos; // make sure f was found
s.replace(pos, f.size(), t), // replace with t
pos = s.find(f, pos + t.size()) // find next occurrence of f
);
assert(not f.empty());
for (auto pos = s.find(f); // find first occurrence of f
pos != std::string::npos; // make sure f was found
s.replace(pos, f.size(), t), // replace with t, and
pos = s.find(f, pos + t.size())) // find next occurrence of f
{}
}
/// escape tilde and slash
std::string json::json_pointer::escape(std::string s)
std::string json_pointer::escape(std::string s)
{
// escape "~"" to "~0" and "/" to "~1"
replace_substring(s, "~", "~0");
replace_substring(s, "/", "~1");
return s;
}
/// unescape tilde and slash
void json::json_pointer::unescape(std::string& s)
/// unescape "~1" to tilde and "~0" to slash (order is important!)
void json_pointer::unescape(std::string& s)
{
// first transform any occurrence of the sequence '~1' to '/'
replace_substring(s, "~1", "/");
// then transform any occurrence of the sequence '~0' to '~'
replace_substring(s, "~0", "~");
}
void json::json_pointer::flatten(const std::string& reference_string,
void json_pointer::flatten(const Twine& reference_string,
const json& value,
json& result)
{
switch (value.m_type)
{
case value_t::array:
case detail::value_t::array:
{
if (value.m_value.array->empty())
{
// flatten empty array as null
result[reference_string] = nullptr;
SmallString<64> buf;
result[reference_string.toStringRef(buf)] = nullptr;
}
else
{
// iterate array and use index as reference string
for (size_t i = 0; i < value.m_value.array->size(); ++i)
for (std::size_t i = 0; i < value.m_value.array->size(); ++i)
{
flatten(reference_string + "/" + std::to_string(i),
flatten(reference_string + "/" + Twine(i),
value.m_value.array->operator[](i), result);
}
}
break;
}
case value_t::object:
case detail::value_t::object:
{
if (value.m_value.object->empty())
{
// flatten empty object as null
result[reference_string] = nullptr;
SmallString<64> buf;
result[reference_string.toStringRef(buf)] = nullptr;
}
else
{
// iterate object and use keys as reference string
for (const auto& element : *value.m_value.object)
{
flatten(reference_string + "/" + escape(element.first()),
element.second, result);
flatten(reference_string + "/" + Twine(escape(element.first())), element.second, result);
}
}
break;
@@ -491,17 +492,19 @@ void json::json_pointer::flatten(const std::string& reference_string,
default:
{
// add primitive value with its reference string
result[reference_string] = value;
SmallString<64> buf;
result[reference_string.toStringRef(buf)] = value;
break;
}
}
}
json json::json_pointer::unflatten(const json& value)
json
json_pointer::unflatten(const json& value)
{
if (!value.is_object())
if (JSON_UNLIKELY(not value.is_object()))
{
JSON_THROW(type_error::create(314, "only objects can be unflattened"));
JSON_THROW(detail::type_error::create(314, "only objects can be unflattened"));
}
// we need to iterate over the object values in sorted key order
@@ -511,7 +514,7 @@ json json::json_pointer::unflatten(const json& value)
{
if (!i->second.is_primitive())
{
JSON_THROW(type_error::create(315, "values in object must be primitive"));
JSON_THROW(detail::type_error::create(315, "values in object must be primitive"));
}
sorted.push_back(i);
}
@@ -538,3 +541,4 @@ json json::json_pointer::unflatten(const json& value)
return result;
}
} // namespace wpi

1521
wpiutil/src/main/native/cpp/json_serializer.cpp
View File

File diff suppressed because it is too large Load Diff

134
wpiutil/src/main/native/cpp/json_serializer.h
View File

@@ -1,5 +1,5 @@
/*----------------------------------------------------------------------------*/
/* Modifications Copyright (c) FIRST 2017. All Rights Reserved. */
/* Modifications Copyright (c) 2017-2018 FIRST. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
@@ -7,11 +7,11 @@
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++
| | |__ | | | | | | version 2.1.1
| | |__ | | | | | | version 3.1.2
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
Copyright (c) 2013-2018 Niels Lohmann <http://nlohmann.me>.
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
@@ -34,38 +34,41 @@ SOFTWARE.
#include "wpi/json.h"
#include <clocale> // lconv, localeconv
#include <cmath> // labs, isfinite, isnan, signbit, ldexp
#include <locale> // locale
#include "wpi/raw_ostream.h"
namespace wpi {
/*!
@brief wrapper around the serialization functions
*/
class json::serializer
{
public:
serializer(const serializer&) = delete;
serializer& operator=(const serializer&) = delete;
static constexpr uint8_t UTF8_ACCEPT = 0;
static constexpr uint8_t UTF8_REJECT = 1;
public:
/*!
@param[in] s output stream to serialize to
@param[in] ichar indentation character to use
*/
explicit serializer(raw_ostream& s)
serializer(raw_ostream& s, const char ichar)
: o(s), loc(std::localeconv()),
thousands_sep(!loc->thousands_sep ? '\0' : loc->thousands_sep[0]),
decimal_point(!loc->decimal_point ? '\0' : loc->decimal_point[0])
thousands_sep(loc->thousands_sep == nullptr ? '\0' : * (loc->thousands_sep)),
decimal_point(loc->decimal_point == nullptr ? '\0' : * (loc->decimal_point)),
indent_char(ichar), indent_string(512, indent_char)
{}
// delete because of pointer members
serializer(const serializer&) = delete;
serializer& operator=(const serializer&) = delete;
/*!
@brief internal implementation of the serialization function
This function is called by the public member function dump and
organizes the serialization internally. The indentation level is
propagated as additional parameter. In case of arrays and objects, the
function is called recursively.
This function is called by the public member function dump and organizes
the serialization internally. The indentation level is propagated as
additional parameter. In case of arrays and objects, the function is
called recursively.
- strings and object keys are escaped using `escape_string()`
- integer numbers are converted implicitly via `operator<<`
@@ -76,45 +79,128 @@ class json::serializer
@param[in] indent_step the indent level
@param[in] current_indent the current indent level (only used internally)
*/
void dump(const json& val,
const bool pretty_print,
void dump(const json& val, const bool pretty_print,
const bool ensure_ascii,
const unsigned int indent_step,
const unsigned int current_indent = 0);
private:
/*!
@brief dump escaped string
Escape a string by replacing certain special characters by a sequence
of an escape character (backslash) and another character and other
control characters by a sequence of "\u" followed by a four-digit hex
Escape a string by replacing certain special characters by a sequence of an
escape character (backslash) and another character and other control
characters by a sequence of "\u" followed by a four-digit hex
representation. The escaped string is written to output stream @a o.
@param[in] s the string to escape
@param[in] ensure_ascii whether to escape non-ASCII characters with
\uXXXX sequences
@complexity Linear in the length of string @a s.
*/
void dump_escaped(StringRef s) const;
void dump_escaped(StringRef s, const bool ensure_ascii);
/*!
@brief dump an integer
Dump a given integer to output stream @a o. Works internally with
@a number_buffer.
@param[in] x integer number (signed or unsigned) to dump
@tparam NumberType either @a int64_t or @a uint64_t
*/
template<typename NumberType, detail::enable_if_t<
std::is_same<NumberType, uint64_t>::value or
std::is_same<NumberType, int64_t>::value,
int> = 0>
void dump_integer(NumberType x)
{
// special case for "0"
if (x == 0)
{
o << '0';
return;
}
const bool is_negative = (x <= 0) and (x != 0); // see issue #755
std::size_t i = 0;
while (x != 0)
{
// spare 1 byte for '\0'
assert(i < number_buffer.size() - 1);
const auto digit = std::labs(static_cast<long>(x % 10));
number_buffer[i++] = static_cast<char>('0' + digit);
x /= 10;
}
if (is_negative)
{
// make sure there is capacity for the '-'
assert(i < number_buffer.size() - 2);
number_buffer[i++] = '-';
}
std::reverse(number_buffer.begin(), number_buffer.begin() + i);
o.write(number_buffer.data(), i);
}
/*!
@brief dump a floating-point number
Dump a given floating-point number to output stream @a o. Works
internally with @a number_buffer.
Dump a given floating-point number to output stream @a o. Works internally
with @a number_buffer.
@param[in] x floating-point number to dump
*/
void dump_float(double x);
/*!
@brief check whether a string is UTF-8 encoded
The function checks each byte of a string whether it is UTF-8 encoded. The
result of the check is stored in the @a state parameter. The function must
be called initially with state 0 (accept). State 1 means the string must
be rejected, because the current byte is not allowed. If the string is
completely processed, but the state is non-zero, the string ended
prematurely; that is, the last byte indicated more bytes should have
followed.
@param[in,out] state the state of the decoding
@param[in,out] codep codepoint (valid only if resulting state is UTF8_ACCEPT)
@param[in] byte next byte to decode
@return new state
@note The function has been edited: a std::array is used.
@copyright Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
@sa http://bjoern.hoehrmann.de/utf-8/decoder/dfa/
*/
static uint8_t decode(uint8_t& state, uint32_t& codep, const uint8_t byte) noexcept;
private:
/// the output of the serializer
raw_ostream& o;
/// a (hopefully) large enough character buffer
std::array<char, 64> number_buffer{{}};
/// the locale
const std::lconv* loc = nullptr;
/// the locale's thousand separator character
const char thousands_sep = '\0';
/// the locale's decimal point character
const char decimal_point = '\0';
/// string buffer
std::array<char, 512> string_buffer{{}};
/// the indentation character
const char indent_char;
/// the indentation string
std::string indent_string;
};
} // namespace wpi

6158
wpiutil/src/main/native/include/wpi/json.h
View File

File diff suppressed because it is too large Load Diff

462
wpiutil/src/test/native/cpp/json/unit-cbor.cpp
View File

@@ -50,7 +50,7 @@ TEST(CborDiscardedTest, Case)
TEST(CborNullTest, Case)
{
json j = nullptr;
std::string expected = "\xf6";
std::vector<uint8_t> expected = {0xf6};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -61,7 +61,7 @@ TEST(CborNullTest, Case)
TEST(CborBooleanTest, True)
{
json j = true;
std::string expected = "\xf5";
std::vector<uint8_t> expected = {0xf5};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -72,7 +72,7 @@ TEST(CborBooleanTest, True)
TEST(CborBooleanTest, False)
{
json j = false;
std::string expected = "\xf4";
std::vector<uint8_t> expected = {0xf4};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -91,17 +91,17 @@ TEST_P(CborSignedNeg8Test, Case)
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x3b));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x3b));
uint64_t positive = static_cast<uint64_t>(-1 - GetParam());
expected.push_back(static_cast<char>((positive >> 56) & 0xff));
expected.push_back(static_cast<char>((positive >> 48) & 0xff));
expected.push_back(static_cast<char>((positive >> 40) & 0xff));
expected.push_back(static_cast<char>((positive >> 32) & 0xff));
expected.push_back(static_cast<char>((positive >> 24) & 0xff));
expected.push_back(static_cast<char>((positive >> 16) & 0xff));
expected.push_back(static_cast<char>((positive >> 8) & 0xff));
expected.push_back(static_cast<char>(positive & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 56) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 48) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 40) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 32) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(positive & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -153,13 +153,13 @@ TEST_P(CborSignedNeg4Test, Case)
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x3a));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x3a));
uint32_t positive = static_cast<uint32_t>(static_cast<uint64_t>(-1 - GetParam()) & 0x00000000ffffffff);
expected.push_back(static_cast<char>((positive >> 24) & 0xff));
expected.push_back(static_cast<char>((positive >> 16) & 0xff));
expected.push_back(static_cast<char>((positive >> 8) & 0xff));
expected.push_back(static_cast<char>(positive & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(positive & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -205,11 +205,11 @@ TEST(CborSignedTest, Neg2)
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x39));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x39));
uint16_t positive = static_cast<uint16_t>(-1 - i);
expected.push_back(static_cast<char>((positive >> 8) & 0xff));
expected.push_back(static_cast<char>(positive & 0xff));
expected.push_back(static_cast<uint8_t>((positive >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(positive & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -231,7 +231,7 @@ TEST(CborSignedTest, Neg2)
TEST(CborSignedTest, NegInt16)
{
json j = -9263;
std::string expected = "\x39\x24\x2e";
std::vector<uint8_t> expected = {0x39,0x24,0x2e};
const auto result = json::to_cbor(j);
ASSERT_EQ(result, expected);
@@ -257,9 +257,9 @@ TEST(CborSignedTest, Neg1)
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(0x38);
expected.push_back(static_cast<char>(-1 - i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x38));
expected.push_back(static_cast<uint8_t>(-1 - i));
// compare result + size
const auto result = json::to_cbor(j);
@@ -289,8 +289,8 @@ TEST(CborSignedTest, Neg0)
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x20 - 1 - static_cast<uint8_t>(i)));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x20 - 1 - static_cast<uint8_t>(i)));
// compare result + size
const auto result = json::to_cbor(j);
@@ -314,14 +314,14 @@ TEST(CborSignedTest, Pos0)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_cbor(j);
@@ -329,7 +329,7 @@ TEST(CborSignedTest, Pos0)
ASSERT_EQ(result.size(), 1u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(i));
EXPECT_EQ(result[0], static_cast<uint8_t>(i));
// roundtrip
EXPECT_EQ(json::from_cbor(result), j);
@@ -345,15 +345,15 @@ TEST(CborSignedTest, Pos1)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x18));
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x18));
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_cbor(j);
@@ -362,7 +362,7 @@ TEST(CborSignedTest, Pos1)
// check individual bytes
EXPECT_EQ(result[0], 0x18);
EXPECT_EQ(result[1], static_cast<char>(i));
EXPECT_EQ(result[1], static_cast<uint8_t>(i));
// roundtrip
EXPECT_EQ(json::from_cbor(result), j);
@@ -378,16 +378,16 @@ TEST(CborSignedTest, Pos2)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x19));
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x19));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -410,19 +410,19 @@ TEST_P(CborSignedPos4Test, Case)
{
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() =
static_cast<json::number_integer_t>(GetParam());
j.get_ref<int64_t&>() =
static_cast<int64_t>(GetParam());
// check type
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x1a);
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -456,23 +456,23 @@ TEST_P(CborSignedPos8Test, Case)
{
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() =
static_cast<json::number_integer_t>(GetParam());
j.get_ref<int64_t&>() =
static_cast<int64_t>(GetParam());
// check type
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x1b);
expected.push_back(static_cast<char>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -517,10 +517,10 @@ INSTANTIATE_TEST_CASE_P(CborSignedPos8Tests, CborSignedPos8Test,
ASSERT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0xd1);
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -552,8 +552,8 @@ TEST(CborUnsignedTest, Pos0)
ASSERT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_cbor(j);
@@ -561,7 +561,7 @@ TEST(CborUnsignedTest, Pos0)
ASSERT_EQ(result.size(), 1u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(i));
EXPECT_EQ(result[0], static_cast<uint8_t>(i));
// roundtrip
EXPECT_EQ(json::from_cbor(result), j);
@@ -582,9 +582,9 @@ TEST(CborUnsignedTest, Pos1)
ASSERT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x18);
expected.push_back(static_cast<char>(i));
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_cbor(j);
@@ -615,10 +615,10 @@ TEST(CborUnsignedTest, Pos2)
ASSERT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x19);
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -646,12 +646,12 @@ TEST_P(CborUnsignedPos4Test, Case)
ASSERT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x1a);
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -684,16 +684,16 @@ TEST_P(CborUnsignedPos8Test, Case)
ASSERT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x1b);
expected.push_back(static_cast<char>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_cbor(j);
@@ -724,7 +724,7 @@ TEST(CborFloatTest, Number)
{
double v = 3.1415925;
json j = v;
std::string expected = "\xfb\x40\x09\x21\xfb\x3f\xa6\xde\xfc";
std::vector<uint8_t> expected = {0xfb,0x40,0x09,0x21,0xfb,0x3f,0xa6,0xde,0xfc};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -735,16 +735,16 @@ TEST(CborFloatTest, Number)
TEST(CborFloatTest, HalfInfinity)
{
json j = json::from_cbor(wpi::StringRef("\xf9\x7c\x00", 3));
json::number_float_t d = j;
json j = json::from_cbor(std::vector<uint8_t>({0xf9,0x7c,0x00}));
double d = j;
EXPECT_FALSE(std::isfinite(d));
EXPECT_EQ(j.dump(), "null");
}
TEST(CborFloatTest, HalfNaN)
{
json j = json::from_cbor("\xf9\x7c\x01");
json::number_float_t d = j;
json j = json::from_cbor(std::vector<uint8_t>({0xf9,0x7c,0x01}));
double d = j;
EXPECT_TRUE(std::isnan(d));
EXPECT_EQ(j.dump(), "null");
}
@@ -761,9 +761,12 @@ TEST(CborStringTest, String1)
json j = s;
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0x60 + N));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x60 + N));
for (size_t i = 0; i < N; ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_cbor(j);
@@ -792,10 +795,13 @@ TEST(CborStringTest, String2)
json j = s;
// create expected byte vector
std::string expected;
expected.push_back(0x78);
expected.push_back(static_cast<char>(N));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0x78));
expected.push_back(static_cast<uint8_t>(N));
for (size_t i = 0; i < N; ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_cbor(j);
@@ -818,11 +824,14 @@ TEST_P(CborString3Test, Case)
json j = s;
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x79);
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.append(s);
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
for (size_t i = 0; i < GetParam(); ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_cbor(j);
@@ -856,13 +865,16 @@ TEST_P(CborString5Test, Case)
json j = s;
// create expected byte vector
std::string expected;
std::vector<uint8_t> expected;
expected.push_back(0x7a);
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.append(s);
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
for (size_t i = 0; i < GetParam(); ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_cbor(j);
@@ -887,7 +899,7 @@ INSTANTIATE_TEST_CASE_P(CborString5Tests, CborString5Test,
TEST(CborArrayTest, Empty)
{
json j = json::array();
std::string expected = "\x80";
std::vector<uint8_t> expected = {0x80};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -899,7 +911,7 @@ TEST(CborArrayTest, Empty)
TEST(CborArrayTest, Null)
{
json j = {nullptr};
std::string expected = "\x81\xf6";
std::vector<uint8_t> expected = {0x81,0xf6};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -911,7 +923,7 @@ TEST(CborArrayTest, Null)
TEST(CborArrayTest, Simple)
{
json j = json::parse("[1,2,3,4,5]");
std::string expected = "\x85\x01\x02\x03\x04\x05";
std::vector<uint8_t> expected = {0x85,0x01,0x02,0x03,0x04,0x05};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -923,7 +935,7 @@ TEST(CborArrayTest, Simple)
TEST(CborArrayTest, NestEmpty)
{
json j = json::parse("[[[[]]]]");
std::string expected = "\x81\x81\x81\x80";
std::vector<uint8_t> expected = {0x81,0x81,0x81,0x80};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -935,7 +947,7 @@ TEST(CborArrayTest, NestEmpty)
TEST(CborArrayTest, UInt16)
{
json j(257, nullptr);
std::string expected(j.size() + 3, static_cast<char>(0xf6)); // all null
std::vector<uint8_t> expected(j.size() + 3, 0xf6); // all null
expected[0] = static_cast<char>(0x99); // array 16 bit
expected[1] = 0x01; // size (0x0101), byte 0
expected[2] = 0x01; // size (0x0101), byte 1
@@ -950,7 +962,7 @@ TEST(CborArrayTest, UInt16)
TEST(CborArrayTest, UInt32)
{
json j(65793, nullptr);
std::string expected(j.size() + 5, static_cast<char>(0xf6)); // all null
std::vector<uint8_t> expected(j.size() + 5, 0xf6); // all null
expected[0] = static_cast<char>(0x9a); // array 32 bit
expected[1] = 0x00; // size (0x00010101), byte 0
expected[2] = 0x01; // size (0x00010101), byte 1
@@ -968,7 +980,7 @@ TEST(CborArrayTest, UInt32)
TEST(CborArrayTest, UInt64)
{
json j(4294967296, nullptr);
std::string expected(j.size() + 9, static_cast<char>(0xf6)); // all null
std::vector<uint8_t> expected(j.size() + 9, 0xf6); // all null
expected[0] = 0x9b; // array 64 bit
expected[1] = 0x00; // size (0x0000000100000000), byte 0
expected[2] = 0x00; // size (0x0000000100000000), byte 1
@@ -989,7 +1001,7 @@ TEST(CborArrayTest, UInt64)
TEST(CborObjectTest, Empty)
{
json j = json::object();
std::string expected = "\xa0";
std::vector<uint8_t> expected = {0xa0};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -1001,7 +1013,7 @@ TEST(CborObjectTest, Empty)
TEST(CborObjectTest, EmptyKey)
{
json j = {{"", nullptr}};
std::string expected = "\xa1\x60\xf6";
std::vector<uint8_t> expected = {0xa1,0x60,0xf6};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -1013,7 +1025,7 @@ TEST(CborObjectTest, EmptyKey)
TEST(CborObjectTest, NestedEmpty)
{
json j = json::parse("{\"a\": {\"b\": {\"c\": {}}}}");
std::string expected = "\xa1\x61\x61\xa1\x61\x62\xa1\x61\x63\xa0";
std::vector<uint8_t> expected = {0xa1,0x61,0x61,0xa1,0x61,0x62,0xa1,0x61,0x63,0xa0};
const auto result = json::to_cbor(j);
EXPECT_EQ(result, expected);
@@ -1042,8 +1054,8 @@ TEST(CborObjectTest, UInt8)
// size and the overall size. The rest is then handled in the
// roundtrip check.
ASSERT_EQ(result.size(), 1787u); // 1 type, 1 size, 255*7 content
EXPECT_EQ(result[0], static_cast<char>(0xb8)); // map 8 bit
EXPECT_EQ(result[1], static_cast<char>(0xff)); // size byte (0xff)
EXPECT_EQ(result[0], static_cast<uint8_t>(0xb8)); // map 8 bit
EXPECT_EQ(result[1], static_cast<uint8_t>(0xff)); // size byte (0xff)
// roundtrip
EXPECT_EQ(json::from_cbor(result), j);
}
@@ -1069,7 +1081,7 @@ TEST(CborObjectTest, UInt16)
// size and the overall size. The rest is then handled in the
// roundtrip check.
ASSERT_EQ(result.size(), 1795u); // 1 type, 2 size, 256*7 content
EXPECT_EQ(result[0], static_cast<char>(0xb9)); // map 16 bit
EXPECT_EQ(result[0], static_cast<uint8_t>(0xb9)); // map 16 bit
EXPECT_EQ(result[1], 0x01); // byte 0 of size (0x0100)
EXPECT_EQ(result[2], 0x00); // byte 1 of size (0x0100)
@@ -1098,7 +1110,7 @@ TEST(CborObjectTest, UInt32)
// size and the overall size. The rest is then handled in the
// roundtrip check.
ASSERT_EQ(result.size(), 458757u); // 1 type, 4 size, 65536*7 content
EXPECT_EQ(result[0], static_cast<char>(0xba)); // map 32 bit
EXPECT_EQ(result[0], static_cast<uint8_t>(0xba)); // map 32 bit
EXPECT_EQ(result[1], 0x00); // byte 0 of size (0x00010000)
EXPECT_EQ(result[2], 0x01); // byte 1 of size (0x00010000)
EXPECT_EQ(result[3], 0x00); // byte 2 of size (0x00010000)
@@ -1111,7 +1123,7 @@ TEST(CborObjectTest, UInt32)
// 0x7b (string)
TEST(CborAdditionalDeserializationTest, Case7b)
{
std::string given("\x7b\x00\x00\x00\x00\x00\x00\x00\x01\x61", 10);
std::vector<uint8_t> given{0x7b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x61};
json j = json::from_cbor(given);
EXPECT_EQ(j, "a");
}
@@ -1119,7 +1131,7 @@ TEST(CborAdditionalDeserializationTest, Case7b)
// 0x9b (array)
TEST(CborAdditionalDeserializationTest, Case9b)
{
std::string given("\x9b\x00\x00\x00\x00\x00\x00\x00\x01\xf4", 10);
std::vector<uint8_t> given{0x9b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0xf4};
json j = json::from_cbor(given);
EXPECT_EQ(j, json::parse("[false]"));
}
@@ -1127,101 +1139,101 @@ TEST(CborAdditionalDeserializationTest, Case9b)
// 0xbb (map)
TEST(CborAdditionalDeserializationTest, Casebb)
{
std::string given("\xbb\x00\x00\x00\x00\x00\x00\x00\x01\x60\xf4", 11);
std::vector<uint8_t> given{0xbb,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x60,0xf4};
json j = json::from_cbor(given);
EXPECT_EQ(j, json::parse("{\"\": false}"));
}
TEST(CborErrorTest, TooShortByteVector)
{
EXPECT_THROW_MSG(json::from_cbor("\x18"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x18})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor("\x19"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x19})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x19\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x19,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor("\x1a"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1a})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1a\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1a,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1a\x00\x00", 3)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1a,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 4: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1a\x00\x00\x00", 4)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1a,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 5: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor("\x1b"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00", 3)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 4: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00\x00", 4)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 5: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00\x00\x00", 5)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 6: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00\x00\x00\x00", 6)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 7: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00\x00\x00\x00\x00", 7)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 8: unexpected end of input");
EXPECT_THROW_MSG(json::from_cbor(wpi::StringRef("\x1b\x00\x00\x00\x00\x00\x00\x00", 8)), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1b,0x00,0x00,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 9: unexpected end of input");
}
TEST(CborErrorTest, UnsupportedBytesConcrete)
{
EXPECT_THROW_MSG(json::from_cbor("\x1c"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0x1c})), json::parse_error,
"[json.exception.parse_error.112] parse error at 1: error reading CBOR; last byte: 0x1c");
EXPECT_THROW_MSG(json::from_cbor("\xf8"), json::parse_error,
EXPECT_THROW_MSG(json::from_cbor(std::vector<uint8_t>({0xf8})), json::parse_error,
"[json.exception.parse_error.112] parse error at 1: error reading CBOR; last byte: 0xf8");
}
class CborUnsupportedBytesTest : public ::testing::TestWithParam<const char*> {
class CborUnsupportedBytesTest : public ::testing::TestWithParam<uint8_t> {
};
TEST_P(CborUnsupportedBytesTest, Case)
{
EXPECT_THROW(json::from_cbor(GetParam()), json::parse_error);
EXPECT_THROW(json::from_cbor(std::vector<uint8_t>({GetParam()})), json::parse_error);
}
static const char* unsupported_bytes_cases[] = {
static const uint8_t unsupported_bytes_cases[] = {
// ?
"\x1c\x1d\x1e\x1f",
0x1c, 0x1d, 0x1e, 0x1f,
// ?
"\x3c\x3d\x3e\x3f",
0x3c, 0x3d, 0x3e, 0x3f,
// byte strings
"\x40\x41\x42\x43\x44\x45\x46\x47\x48\x49\x50\x51\x52\x53\x54\x55\x56\x57",
0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57,
// byte strings
"\x58\x59\x5a\x5b",
0x58, 0x59, 0x5a, 0x5b,
// ?
"\x5c\x5d\x5e",
0x5c, 0x5d, 0x5e,
// byte string
"\x5f",
0x5f,
// ?
"\x7c\x7d\x7e",
0x7c, 0x7d, 0x7e,
// ?
"\x9c\x9d\x9e",
0x9c, 0x9d, 0x9e,
// ?
"\xbc\xbd\xbe",
0xbc, 0xbd, 0xbe,
// date/time
"\xc0\xc1",
0xc0, 0xc1,
// bignum
"\xc2\xc3",
0xc2, 0xc3,
// fraction
"\xc4",
0xc4,
// bigfloat
"\xc5",
0xc5,
// tagged item
"\xc6\xc7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4",
0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xcb, 0xcc, 0xcd, 0xce, 0xcf, 0xd0, 0xd1, 0xd2, 0xd3, 0xd4,
// expected conversion
"\xd5\xd6\xd7",
0xd5, 0xd6, 0xd7,
// more tagged items
"\xd8\xd9\xda\xdb",
0xd8, 0xd9, 0xda, 0xdb,
// ?
"\xdc\xdd\xde\xdf",
0xdc, 0xdd, 0xde, 0xdf,
// (simple value)
"\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3",
0xe0, 0xe1, 0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea, 0xeb, 0xec, 0xed, 0xee, 0xef, 0xf0, 0xf1, 0xf2, 0xf3,
// undefined
"\xf7",
0xf7,
// simple value
"\xf8",
0xf8,
};
INSTANTIATE_TEST_CASE_P(CborUnsupportedBytesTests, CborUnsupportedBytesTest,
@@ -1543,11 +1555,11 @@ TEST(CborFirstBytesTest, Unsupported)
for (auto i = 0; i < 256; ++i)
{
const auto byte = static_cast<char>(i);
const auto byte = static_cast<uint8_t>(i);
try
{
json::from_cbor(wpi::StringRef(&byte, 1));
json::from_cbor(std::vector<uint8_t>(1, byte));
}
catch (const json::parse_error& e)
{
@@ -1571,7 +1583,7 @@ TEST(CborFirstBytesTest, Unsupported)
namespace internal {
struct CborRoundtripTestParam {
const char* plain;
wpi::StringRef encoded;
std::vector<uint8_t> encoded;
bool test_encode;
};
} // namespace internal
@@ -1589,100 +1601,100 @@ TEST_P(CborRoundtripTest, Case)
}
static const internal::CborRoundtripTestParam rfc7049_appendix_a_numbers[] = {
{"0", wpi::StringRef("\x00", 1), true},
{"1", "\x01", true},
{"10", "\x0a", true},
{"23", "\x17", true},
{"24", "\x18\x18", true},
{"25", "\x18\x19", true},
{"100", "\x18\x64", true},
{"1000", "\x19\x03\xe8", true},
{"1000000", wpi::StringRef("\x1a\x00\x0f\x42\x40", 5), true},
{"1000000000000", wpi::StringRef("\x1b\x00\x00\x00\xe8\xd4\xa5\x10\x00", 9), true},
{"18446744073709551615", "\x1b\xff\xff\xff\xff\xff\xff\xff\xff", true},
{"0", {0x00}, true},
{"1", {0x01}, true},
{"10", {0x0a}, true},
{"23", {0x17}, true},
{"24", {0x18,0x18}, true},
{"25", {0x18,0x19}, true},
{"100", {0x18,0x64}, true},
{"1000", {0x19,0x03,0xe8}, true},
{"1000000", {0x1a,0x00,0x0f,0x42,0x40}, true},
{"1000000000000", {0x1b,0x00,0x00,0x00,0xe8,0xd4,0xa5,0x10,0x00}, true},
{"18446744073709551615", {0x1b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}, true},
// positive bignum is not supported
//{"18446744073709551616", wpi::StringRef("\xc2\x49\x01\x00\x00\x00\x00\x00\x00\x00\x00", 11), true},
//{"-18446744073709551616", "\x3b\xff\xff\xff\xff\xff\xff\xff\xff", true},
//{"18446744073709551616", {0xc2,0x49,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00", 11), true},
//{"-18446744073709551616", {0x3b,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff}, true},
// negative bignum is not supported
//{"-18446744073709551617", wpi::StringRef("\xc3\x49\x01\x00\x00\x00\x00\x00\x00\x00\x00", 11), true},
{"-1", "\x20", true},
{"-10", "\x29", true},
{"-100", "\x38\x63", true},
{"-1000", "\x39\x03\xe7", true},
//{"-18446744073709551617", {0xc3,0x49,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}, true},
{"-1", {0x20}, true},
{"-10", {0x29}, true},
{"-100", {0x38,0x63}, true},
{"-1000", {0x39,0x03,0xe7}, true},
// half-precision float
{"0.0", wpi::StringRef("\xf9\x00\x00", 3), false},
{"0.0", {0xf9,0x00,0x00}, false},
// half-precision float
{"-0.0", wpi::StringRef("\xf9\x80\x00", 3), false},
{"-0.0", {0xf9,0x80,0x00}, false},
// half-precision float
{"1.0", wpi::StringRef("\xf9\x3c\x00", 3), false},
{"1.1", "\xfb\x3f\xf1\x99\x99\x99\x99\x99\x9a", true},
{"1.0", {0xf9,0x3c,0x00}, false},
{"1.1", {0xfb,0x3f,0xf1,0x99,0x99,0x99,0x99,0x99,0x9a}, true},
// half-precision float
{"1.5", wpi::StringRef("\xf9\x3e\x00", 3), false},
{"1.5", {0xf9,0x3e,0x00}, false},
// half-precision float
{"65504.0", "\xf9\x7b\xff", false},
{"100000.0", wpi::StringRef("\xfa\x47\xc3\x50\x00", 5), false},
{"3.4028234663852886e+38", "\xfa\x7f\x7f\xff\xff", false},
{"1.0e+300", wpi::StringRef("\xfb\x7e\x37\xe4\x3c\x88\x00\x75\x9c", 9), true},
{"65504.0", {0xf9,0x7b,0xff}, false},
{"100000.0", {0xfa,0x47,0xc3,0x50,0x00}, false},
{"3.4028234663852886e+38", {0xfa,0x7f,0x7f,0xff,0xff}, false},
{"1.0e+300", {0xfb,0x7e,0x37,0xe4,0x3c,0x88,0x00,0x75,0x9c}, true},
// half-precision float
{"5.960464477539063e-8", wpi::StringRef("\xf9\x00\x01", 3), false},
{"5.960464477539063e-8", {0xf9,0x00,0x01}, false},
// half-precision float
{"0.00006103515625", wpi::StringRef("\xf9\x04\x00", 3), false},
{"0.00006103515625", {0xf9,0x04,0x00}, false},
// half-precision float
{"-4.0", wpi::StringRef("\xf9\xc4\x00", 3), false},
{"-4.1", "\xfb\xc0\x10\x66\x66\x66\x66\x66\x66", true},
{"-4.0", {0xf9,0xc4,0x00}, false},
{"-4.1", {0xfb,0xc0,0x10,0x66,0x66,0x66,0x66,0x66,0x66}, true},
};
INSTANTIATE_TEST_CASE_P(CborRfc7049AppendixANumberTests, CborRoundtripTest,
::testing::ValuesIn(rfc7049_appendix_a_numbers), );
static const internal::CborRoundtripTestParam rfc7049_appendix_a_simple_values[] = {
{"false", "\xf4", true},
{"true", "\xf5", true},
{"false", {0xf4}, true},
{"true", {0xf5}, true},
};
INSTANTIATE_TEST_CASE_P(CborRfc7049AppendixASimpleValueTests, CborRoundtripTest,
::testing::ValuesIn(rfc7049_appendix_a_simple_values), );
static const internal::CborRoundtripTestParam rfc7049_appendix_a_strings[] = {
{"\"\"", "\x60", true},
{"\"a\"", "\x61\x61", true},
{"\"IETF\"", "\x64\x49\x45\x54\x46", true},
{"\"\\u00fc\"", "\x62\xc3\xbc", true},
{"\"\\u6c34\"", "\x63\xe6\xb0\xb4", true},
{"\"\\ud800\\udd51\"", "\x64\xf0\x90\x85\x91", true},
{"\"\"", {0x60}, true},
{"\"a\"", {0x61,0x61}, true},
{"\"IETF\"", {0x64,0x49,0x45,0x54,0x46}, true},
{"\"\\u00fc\"", {0x62,0xc3,0xbc}, true},
{"\"\\u6c34\"", {0x63,0xe6,0xb0,0xb4}, true},
{"\"\\ud800\\udd51\"", {0x64,0xf0,0x90,0x85,0x91}, true},
// indefinite length strings
{"\"streaming\"", "\x7f\x73\x74\x72\x65\x61\x6d\x69\x6e\x67\xff", false},
{"\"streaming\"", {0x7f,0x65,0x73,0x74,0x72,0x65,0x61,0x64,0x6d,0x69,0x6e,0x67,0xff}, false},
};
INSTANTIATE_TEST_CASE_P(CborRfc7049AppendixAStringTests, CborRoundtripTest,
::testing::ValuesIn(rfc7049_appendix_a_strings), );
static const internal::CborRoundtripTestParam rfc7049_appendix_a_arrays[] = {
{"[]", "\x80", true},
{"[1, 2, 3]", "\x83\x01\x02\x03", true},
{"[1, [2, 3], [4, 5]]", "\x83\x01\x82\x02\x03\x82\x04\x05", true},
{"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]", "\x98\x19\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x18\x18\x19", true},
{"[]", {0x80}, true},
{"[1, 2, 3]", {0x83,0x01,0x02,0x03}, true},
{"[1, [2, 3], [4, 5]]", {0x83,0x01,0x82,0x02,0x03,0x82,0x04,0x05}, true},
{"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]", {0x98,0x19,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x18,0x18,0x19}, true},
// indefinite length arrays
{"[]", "\x9f\xff", false},
{"[1, [2, 3], [4, 5]] ", "\x9f\x01\x82\x02\x03\x9f\x04\x05\xff\xff", false},
{"[1, [2, 3], [4, 5]]", "\x9f\x01\x82\x02\x03\x82\x04\x05\xff", false},
{"[1, [2, 3], [4, 5]]", "\x83\x01\x82\x02\x03\x9f\x04\x05\xff", false},
{"[1, [2, 3], [4, 5]]", "\x83\x01\x9f\x02\x03\xff\x82\x04\x05", false},
{"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]", "\x9f\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0a\x0b\x0c\x0d\x0e\x0f\x10\x11\x12\x13\x14\x15\x16\x17\x18\x18\x18\x19\xff", false},
{"[]", {0x9f,0xff}, false},
{"[1, [2, 3], [4, 5]] ", {0x9f,0x01,0x82,0x02,0x03,0x9f,0x04,0x05,0xff,0xff}, false},
{"[1, [2, 3], [4, 5]]", {0x9f,0x01,0x82,0x02,0x03,0x82,0x04,0x05,0xff}, false},
{"[1, [2, 3], [4, 5]]", {0x83,0x01,0x82,0x02,0x03,0x9f,0x04,0x05,0xff}, false},
{"[1, [2, 3], [4, 5]]", {0x83,0x01,0x9f,0x02,0x03,0xff,0x82,0x04,0x05}, false},
{"[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25]", {0x9f,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b,0x0c,0x0d,0x0e,0x0f,0x10,0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x18,0x18,0x19,0xff}, false},
};
INSTANTIATE_TEST_CASE_P(CborRfc7049AppendixAArrayTests, CborRoundtripTest,
::testing::ValuesIn(rfc7049_appendix_a_arrays), );
static const internal::CborRoundtripTestParam rfc7049_appendix_a_objects[] = {
{"{}", "\xa0", true},
{"{\"a\": 1, \"b\": [2, 3]}", "\xa2\x61\x61\x01\x61\x62\x82\x02\x03", true},
{"[\"a\", {\"b\": \"c\"}]", "\x82\x61\x61\xa1\x61\x62\x61\x63", true},
{"{\"a\": \"A\", \"b\": \"B\", \"c\": \"C\", \"d\": \"D\", \"e\": \"E\"}", "\xa5\x61\x61\x61\x41\x61\x62\x61\x42\x61\x63\x61\x43\x61\x64\x61\x44\x61\x65\x61\x45", true},
{"{}", {0xa0}, true},
{"{\"a\": 1, \"b\": [2, 3]}", {0xa2,0x61,0x61,0x01,0x61,0x62,0x82,0x02,0x03}, true},
{"[\"a\", {\"b\": \"c\"}]", {0x82,0x61,0x61,0xa1,0x61,0x62,0x61,0x63}, true},
{"{\"a\": \"A\", \"b\": \"B\", \"c\": \"C\", \"d\": \"D\", \"e\": \"E\"}", {0xa5,0x61,0x61,0x61,0x41,0x61,0x62,0x61,0x42,0x61,0x63,0x61,0x43,0x61,0x64,0x61,0x44,0x61,0x65,0x61,0x45}, true},
// indefinite length objects
{"{\"a\": 1, \"b\": [2, 3]}", "\xbf\x61\x61\x01\x61\x62\x9f\x02\x03\xff\xff", false},
{"[\"a\", {\"b\": \"c\"}]", "\x82\x61\x61\xbf\x61\x62\x61\x63\xff", false},
{"{\"Fun\": true, \"Amt\": -2}", "\xbf\x63\x46\x75\x6e\xf5\x63\x41\x6d\x74\x21\xff", false},
{"{\"a\": 1, \"b\": [2, 3]}", {0xbf,0x61,0x61,0x01,0x61,0x62,0x9f,0x02,0x03,0xff,0xff}, false},
{"[\"a\", {\"b\": \"c\"}]", {0x82,0x61,0x61,0xbf,0x61,0x62,0x61,0x63,0xff}, false},
{"{\"Fun\": true, \"Amt\": -2}", {0xbf,0x63,0x46,0x75,0x6e,0xf5,0x63,0x41,0x6d,0x74,0x21,0xff}, false},
};
INSTANTIATE_TEST_CASE_P(CborRfc7049AppendixAObjectTests, CborRoundtripTest,

59
wpiutil/src/test/native/cpp/json/unit-constructor1.cpp
View File

@@ -106,10 +106,10 @@ class JsonConstructObjectImplicitTest : public ::testing::Test {
json j_reference;
};
// std::map<json::string_t, json>
// std::map<std::string, json>
TEST_F(JsonConstructObjectImplicitTest, StdMapStringJson)
{
std::map<json::string_t, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
std::map<std::string, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
json j(o);
EXPECT_EQ(j.type(), json::value_t::object);
EXPECT_EQ(j, j_reference);
@@ -151,28 +151,28 @@ TEST_F(JsonConstructObjectImplicitTest, StdMapCharPointerJson)
EXPECT_EQ(j, j_reference);
}
// std::multimap<json::string_t, json>
// std::multimap<std::string, json>
TEST_F(JsonConstructObjectImplicitTest, StdMultiMapStringJson)
{
std::multimap<json::string_t, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
std::multimap<std::string, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
json j(o);
EXPECT_EQ(j.type(), json::value_t::object);
EXPECT_EQ(j, j_reference);
}
// std::unordered_map<json::string_t, json>
// std::unordered_map<std::string, json>
TEST_F(JsonConstructObjectImplicitTest, StdUnorderedMapStringJson)
{
std::unordered_map<json::string_t, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
std::unordered_map<std::string, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
json j(o);
EXPECT_EQ(j.type(), json::value_t::object);
EXPECT_EQ(j, j_reference);
}
// std::unordered_multimap<json::string_t, json>
// std::unordered_multimap<std::string, json>
TEST_F(JsonConstructObjectImplicitTest, StdUnorderedMultiMapStringJson)
{
std::unordered_multimap<json::string_t, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
std::unordered_multimap<std::string, json> o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};
json j(o);
EXPECT_EQ(j.type(), json::value_t::object);
EXPECT_EQ(j, j_reference);
@@ -264,14 +264,14 @@ TEST(JsonConstructArrayContainerTest, Case)
TEST(JsonConstructStringExplicitTest, Empty)
{
json::string_t s;
std::string s;
json j(s);
EXPECT_EQ(j.type(), json::value_t::string);
}
TEST(JsonConstructStringExplicitTest, Filled)
{
json::string_t s {"Hello world"};
std::string s {"Hello world"};
json j(s);
EXPECT_EQ(j.type(), json::value_t::string);
}
@@ -281,7 +281,7 @@ class JsonConstructStringTest : public ::testing::Test {
JsonConstructStringTest() : j_reference(s_reference) {}
protected:
json::string_t s_reference {"Hello world"};
std::string s_reference {"Hello world"};
json j_reference;
};
@@ -322,7 +322,7 @@ TEST_F(JsonConstructStringTest, StringLiteral)
TEST(JsonConstructBooleanExplicitTest, Empty)
{
json::boolean_t b{};
bool b{};
json j(b);
EXPECT_EQ(j.type(), json::value_t::boolean);
}
@@ -341,14 +341,14 @@ TEST(JsonConstructBooleanExplicitTest, False)
TEST(JsonConstructIntegerExplicitTest, Uninitialized)
{
json::number_integer_t n{};
int64_t n{};
json j(n);
EXPECT_EQ(j.type(), json::value_t::number_integer);
}
TEST(JsonConstructIntegerExplicitTest, Initialized)
{
json::number_integer_t n(42);
int64_t n(42);
json j(n);
EXPECT_EQ(j.type(), json::value_t::number_integer);
}
@@ -360,9 +360,9 @@ class JsonConstructIntegerTest : public ::testing::Test {
: j_reference(n_reference), j_unsigned_reference(n_unsigned_reference) {}
protected:
json::number_integer_t n_reference = 42;
int64_t n_reference = 42;
json j_reference;
json::number_unsigned_t n_unsigned_reference = 42u;
uint64_t n_unsigned_reference = 42u;
json j_unsigned_reference;
};
@@ -429,9 +429,9 @@ class JsonConstructIntegerLiteralTest : public ::testing::Test {
: j_reference(n_reference), j_unsigned_reference(n_unsigned_reference) {}
protected:
json::number_integer_t n_reference = 42;
int64_t n_reference = 42;
json j_reference;
json::number_unsigned_t n_unsigned_reference = 42u;
uint64_t n_unsigned_reference = 42u;
json j_unsigned_reference;
};
@@ -479,14 +479,14 @@ TEST_F(JsonConstructIntegerLiteralTest, ULL)
TEST(JsonConstructFloatExplicitTest, Uninitialized)
{
json::number_float_t n{};
double n{};
json j(n);
EXPECT_EQ(j.type(), json::value_t::number_float);
}
TEST(JsonConstructFloatExplicitTest, Initialized)
{
json::number_float_t n(42.23);
double n(42.23);
json j(n);
EXPECT_EQ(j.type(), json::value_t::number_float);
}
@@ -494,12 +494,12 @@ TEST(JsonConstructFloatExplicitTest, Initialized)
TEST(JsonConstructFloatExplicitTest, Infinity)
{
// infinity is stored properly, but serialized to null
json::number_float_t n(std::numeric_limits<json::number_float_t>::infinity());
double n(std::numeric_limits<double>::infinity());
json j(n);
EXPECT_EQ(j.type(), json::value_t::number_float);
// check round trip of infinity
json::number_float_t d = j;
double d = j;
EXPECT_EQ(d, n);
// check that inf is serialized to null
@@ -512,7 +512,7 @@ class JsonConstructFloatTest : public ::testing::Test {
JsonConstructFloatTest() : j_reference(n_reference) {}
protected:
json::number_float_t n_reference {42.23};
double n_reference {42.23};
json j_reference;
};
@@ -540,7 +540,7 @@ class JsonConstructFloatLiteralTest : public ::testing::Test {
JsonConstructFloatLiteralTest() : j_reference(n_reference) {}
protected:
json::number_float_t n_reference {42.23};
double n_reference {42.23};
json j_reference;
};
@@ -575,8 +575,7 @@ TEST_F(JsonConstructFloatLiteralTest, L)
TEST(JsonConstructInitializerEmptyTest, Explicit)
{
std::initializer_list<json> l;
json j(l);
json j(json::initializer_list_t{});
EXPECT_EQ(j.type(), json::value_t::object);
}
@@ -725,17 +724,15 @@ TEST(JsonConstructInitializerExplicitTest, ObjectError)
TEST(JsonConstructInitializerPairErrorTest, WrongFieldNumber)
{
json j{{"too", "much"}, {"string", "fields"}};
EXPECT_THROW_MSG((j.get<std::pair<std::string, std::string>>()), json::other_error,
"[json.exception.other_error.502] conversion "
"to std::pair requires the object to have "
"exactly one field, but it has 2");
EXPECT_THROW_MSG((j.get<std::pair<std::string, std::string>>()), json::type_error,
"[json.exception.type_error.304] cannot use at() with object");
}
TEST(JsonConstructInitializerPairErrorTest, WrongJsonType)
{
json j(42);
EXPECT_THROW_MSG((j.get<std::pair<std::string, std::string>>()), json::type_error,
"[json.exception.type_error.302] type must be object, but is number");
"[json.exception.type_error.304] cannot use at() with number");
}
TEST(JsonConstructInitializerTest, EmptyArray)

120
wpiutil/src/test/native/cpp/json/unit-convenience.cpp
View File

@@ -1,120 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Modifications Copyright (c) FIRST 2017. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
| | |__ | | | | | | version 2.1.1
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
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 "gtest/gtest.h"
#include "wpi/SmallString.h"
#include "unit-json.h"
#include "json_serializer.h"
using wpi::json;
class JsonTypeNameTest
: public ::testing::TestWithParam<std::pair<json::value_t, const char*>> {};
TEST_P(JsonTypeNameTest, Case)
{
EXPECT_EQ(json(GetParam().first).type_name(), GetParam().second);
}
static const std::pair<json::value_t, const char*> type_name_cases[] = {
{json::value_t::null, "null"},
{json::value_t::object, "object"},
{json::value_t::array, "array"},
{json::value_t::number_integer, "number"},
{json::value_t::number_unsigned, "number"},
{json::value_t::number_float, "number"},
{json::value_t::boolean, "boolean"},
{json::value_t::string, "string"},
{json::value_t::discarded, "discarded"},
};
INSTANTIATE_TEST_CASE_P(JsonTypeNameTests, JsonTypeNameTest,
::testing::ValuesIn(type_name_cases), );
class JsonStringEscapeTest
: public ::testing::TestWithParam<std::pair<const char*, const char*>> {};
TEST_P(JsonStringEscapeTest, Case)
{
wpi::SmallString<32> buf;
wpi::raw_svector_ostream ss(buf);
json::serializer s(ss);
s.dump_escaped(GetParam().first);
EXPECT_EQ(ss.str(), wpi::StringRef(GetParam().second));
}
static const std::pair<const char*, const char*> string_escape_cases[] = {
{"\"", "\\\""},
{"\\", "\\\\"},
{"\b", "\\b"},
{"\f", "\\f"},
{"\n", "\\n"},
{"\r", "\\r"},
{"\t", "\\t"},
{"\x01", "\\u0001"},
{"\x02", "\\u0002"},
{"\x03", "\\u0003"},
{"\x04", "\\u0004"},
{"\x05", "\\u0005"},
{"\x06", "\\u0006"},
{"\x07", "\\u0007"},
{"\x08", "\\b"},
{"\x09", "\\t"},
{"\x0a", "\\n"},
{"\x0b", "\\u000b"},
{"\x0c", "\\f"},
{"\x0d", "\\r"},
{"\x0e", "\\u000e"},
{"\x0f", "\\u000f"},
{"\x10", "\\u0010"},
{"\x11", "\\u0011"},
{"\x12", "\\u0012"},
{"\x13", "\\u0013"},
{"\x14", "\\u0014"},
{"\x15", "\\u0015"},
{"\x16", "\\u0016"},
{"\x17", "\\u0017"},
{"\x18", "\\u0018"},
{"\x19", "\\u0019"},
{"\x1a", "\\u001a"},
{"\x1b", "\\u001b"},
{"\x1c", "\\u001c"},
{"\x1d", "\\u001d"},
{"\x1e", "\\u001e"},
{"\x1f", "\\u001f"},
};
INSTANTIATE_TEST_CASE_P(JsonStringEscapeTests, JsonStringEscapeTest,
::testing::ValuesIn(string_escape_cases), );

80
wpiutil/src/test/native/cpp/json/unit-conversions.cpp
View File

@@ -57,10 +57,10 @@ class JsonGetObjectTest : public ::testing::Test {
typedef ::testing::Types<
json::object_t
, std::map<json::string_t, json>
, std::multimap<json::string_t, json>
, std::unordered_map<json::string_t, json>
, std::unordered_multimap<json::string_t, json>
, std::map<std::string, json>
, std::multimap<std::string, json>
, std::unordered_map<std::string, json>
, std::unordered_multimap<std::string, json>
> JsonGetObjectTestTypes;
TYPED_TEST_CASE(JsonGetObjectTest, JsonGetObjectTestTypes);
@@ -195,11 +195,11 @@ class JsonGetStringTest : public ::testing::Test {
JsonGetStringTest() : j(s_reference) {}
protected:
json::string_t s_reference {"Hello world"};
std::string s_reference {"Hello world"};
json j;
};
typedef ::testing::Types<json::string_t, std::string> JsonGetStringTestTypes;
typedef ::testing::Types<std::string, std::string> JsonGetStringTestTypes;
TYPED_TEST_CASE(JsonGetStringTest, JsonGetStringTestTypes);
TYPED_TEST(JsonGetStringTest, Explicit)
@@ -217,19 +217,19 @@ TYPED_TEST(JsonGetStringTest, Implicit)
// exception in case of a non-string type
TEST(JsonGetStringExceptionTest, TypeError)
{
EXPECT_THROW_MSG(json(json::value_t::null).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::null).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is null");
EXPECT_THROW_MSG(json(json::value_t::object).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::object).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is object");
EXPECT_THROW_MSG(json(json::value_t::array).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::array).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is array");
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::boolean).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is boolean");
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is number");
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is number");
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::string_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_float).get<std::string>(), json::type_error,
"[json.exception.type_error.302] type must be string, but is number");
}
@@ -239,11 +239,11 @@ class JsonGetBooleanTest : public ::testing::Test {
JsonGetBooleanTest() : j(b_reference) {}
protected:
json::boolean_t b_reference {true};
bool b_reference {true};
json j;
};
typedef ::testing::Types<json::boolean_t, bool> JsonGetBooleanTestTypes;
typedef ::testing::Types<bool, bool> JsonGetBooleanTestTypes;
TYPED_TEST_CASE(JsonGetBooleanTest, JsonGetBooleanTestTypes);
TYPED_TEST(JsonGetBooleanTest, Explicit)
@@ -261,19 +261,19 @@ TYPED_TEST(JsonGetBooleanTest, Implicit)
// exception in case of a non-string type
TEST(JsonGetBooleanExceptionTest, TypeError)
{
EXPECT_THROW_MSG(json(json::value_t::null).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::null).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is null");
EXPECT_THROW_MSG(json(json::value_t::object).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::object).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is object");
EXPECT_THROW_MSG(json(json::value_t::array).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::array).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is array");
EXPECT_THROW_MSG(json(json::value_t::string).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::string).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is string");
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_integer).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is number");
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_unsigned).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is number");
EXPECT_THROW_MSG(json(json::value_t::number_float).get<json::boolean_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::number_float).get<bool>(), json::type_error,
"[json.exception.type_error.302] type must be boolean, but is number");
}
@@ -283,9 +283,9 @@ class JsonGetIntegerTest : public ::testing::Test {
JsonGetIntegerTest() : j(n_reference), j_unsigned(n_unsigned_reference) {}
protected:
json::number_integer_t n_reference {42};
int64_t n_reference {42};
json j;
json::number_unsigned_t n_unsigned_reference {42u};
uint64_t n_unsigned_reference {42u};
json j_unsigned;
};
@@ -353,19 +353,19 @@ TYPED_TEST(JsonGetIntegerTest, Implicit)
// exception in case of a non-number type
TEST(JsonGetIntegerExceptionTest, TypeError)
{
EXPECT_THROW_MSG(json(json::value_t::null).get<json::number_integer_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::null).get<int64_t>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is null");
EXPECT_THROW_MSG(json(json::value_t::object).get<json::number_integer_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::object).get<int64_t>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is object");
EXPECT_THROW_MSG(json(json::value_t::array).get<json::number_integer_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::array).get<int64_t>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is array");
EXPECT_THROW_MSG(json(json::value_t::string).get<json::number_integer_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::string).get<int64_t>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is string");
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::number_integer_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::boolean).get<int64_t>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is boolean");
EXPECT_NO_THROW(json(json::value_t::number_float).get<json::number_integer_t>());
EXPECT_NO_THROW(json(json::value_t::number_float).get<json::number_unsigned_t>());
EXPECT_NO_THROW(json(json::value_t::number_float).get<int64_t>());
EXPECT_NO_THROW(json(json::value_t::number_float).get<uint64_t>());
}
template <typename T>
@@ -374,11 +374,11 @@ class JsonGetFloatTest : public ::testing::Test {
JsonGetFloatTest() : j(n_reference) {}
protected:
json::number_float_t n_reference {42.23};
double n_reference {42.23};
json j;
};
typedef ::testing::Types<json::number_float_t, float, double>
typedef ::testing::Types<double, float, double>
JsonGetFloatTestTypes;
TYPED_TEST_CASE(JsonGetFloatTest, JsonGetFloatTestTypes);
@@ -400,19 +400,19 @@ TYPED_TEST(JsonGetFloatTest, Implicit)
// exception in case of a non-string type
TEST(JsonGetFloatExceptionTest, TypeError)
{
EXPECT_THROW_MSG(json(json::value_t::null).get<json::number_float_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::null).get<double>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is null");
EXPECT_THROW_MSG(json(json::value_t::object).get<json::number_float_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::object).get<double>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is object");
EXPECT_THROW_MSG(json(json::value_t::array).get<json::number_float_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::array).get<double>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is array");
EXPECT_THROW_MSG(json(json::value_t::string).get<json::number_float_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::string).get<double>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is string");
EXPECT_THROW_MSG(json(json::value_t::boolean).get<json::number_float_t>(), json::type_error,
EXPECT_THROW_MSG(json(json::value_t::boolean).get<double>(), json::type_error,
"[json.exception.type_error.302] type must be number, but is boolean");
EXPECT_NO_THROW(json(json::value_t::number_integer).get<json::number_float_t>());
EXPECT_NO_THROW(json(json::value_t::number_unsigned).get<json::number_float_t>());
EXPECT_NO_THROW(json(json::value_t::number_integer).get<double>());
EXPECT_NO_THROW(json(json::value_t::number_unsigned).get<double>());
}
TEST(JsonGetEnumTest, Case)

745
wpiutil/src/test/native/cpp/json/unit-iterator_wrapper.cpp
View File

@@ -1,745 +0,0 @@
/*----------------------------------------------------------------------------*/
/* Modifications Copyright (c) FIRST 2017. All Rights Reserved. */
/* Open Source Software - may be modified and shared by FRC teams. The code */
/* must be accompanied by the FIRST BSD license file in the root directory of */
/* the project. */
/*----------------------------------------------------------------------------*/
/*
__ _____ _____ _____
__| | __| | | | JSON for Modern C++ (test suite)
| | |__ | | | | | | version 2.1.1
|_____|_____|_____|_|___| https://github.com/nlohmann/json
Licensed under the MIT License <http://opensource.org/licenses/MIT>.
Copyright (c) 2013-2017 Niels Lohmann <http://nlohmann.me>.
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 "gtest/gtest.h"
#include "unit-json.h"
using wpi::json;
class JsonIteratorWrapperObjectTest : public ::testing::Test {
protected:
json j = {{"A", 1}, {"B", 2}};
};
TEST_F(JsonIteratorWrapperObjectTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperObjectTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
// change the value
i.value() = json(11);
EXPECT_EQ(i.value(), json(11));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
// change the value
i.value() = json(22);
EXPECT_EQ(i.value(), json(22));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
// check if values where changed
EXPECT_EQ(j, json({{"A", 11}, {"B", 22}}));
}
TEST_F(JsonIteratorWrapperObjectTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperObjectTest, ConstReference)
{
json j = {{"A", 1}, {"B", 2}};
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
class JsonIteratorWrapperConstObjectTest : public ::testing::Test {
protected:
const json j = {{"A", 1}, {"B", 2}};
};
TEST_F(JsonIteratorWrapperConstObjectTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstObjectTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstObjectTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstObjectTest, ConstReference)
{
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "A");
EXPECT_EQ(i.value(), json(1));
break;
}
case 2:
{
EXPECT_EQ(i.key(), "B");
EXPECT_EQ(i.value(), json(2));
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
class JsonIteratorWrapperArrayTest : public ::testing::Test {
protected:
json j = {"A", "B"};
};
TEST_F(JsonIteratorWrapperArrayTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperArrayTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
// change the value
i.value() = "AA";
EXPECT_EQ(i.value(), "AA");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
// change the value
i.value() = "BB";
EXPECT_EQ(i.value(), "BB");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
// check if values where changed
EXPECT_EQ(j, json({"AA", "BB"}));
}
TEST_F(JsonIteratorWrapperArrayTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperArrayTest, ConstReference)
{
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
class JsonIteratorWrapperConstArrayTest : public ::testing::Test {
protected:
const json j = {"A", "B"};
};
TEST_F(JsonIteratorWrapperConstArrayTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstArrayTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstArrayTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
TEST_F(JsonIteratorWrapperConstArrayTest, ConstReference)
{
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
switch (counter++)
{
case 1:
{
EXPECT_EQ(i.key(), "0");
EXPECT_EQ(i.value(), "A");
break;
}
case 2:
{
EXPECT_EQ(i.key(), "1");
EXPECT_EQ(i.value(), "B");
break;
}
default:
{
break;
}
}
}
EXPECT_EQ(counter, 3);
}
class JsonIteratorWrapperPrimitiveTest : public ::testing::Test {
protected:
json j = 1;
};
TEST_F(JsonIteratorWrapperPrimitiveTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
TEST_F(JsonIteratorWrapperPrimitiveTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
// change value
i.value() = json(2);
}
EXPECT_EQ(counter, 2);
// check if value has changed
EXPECT_EQ(j, json(2));
}
TEST_F(JsonIteratorWrapperPrimitiveTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
TEST_F(JsonIteratorWrapperPrimitiveTest, ConstReference)
{
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
class JsonIteratorWrapperConstPrimitiveTest : public ::testing::Test {
protected:
const json j = 1;
};
TEST_F(JsonIteratorWrapperConstPrimitiveTest, Value)
{
int counter = 1;
for (auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
TEST_F(JsonIteratorWrapperConstPrimitiveTest, Reference)
{
int counter = 1;
for (auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
TEST_F(JsonIteratorWrapperConstPrimitiveTest, ConstValue)
{
int counter = 1;
for (const auto i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}
TEST_F(JsonIteratorWrapperConstPrimitiveTest, ConstReference)
{
int counter = 1;
for (const auto& i : json::iterator_wrapper(j))
{
SCOPED_TRACE(counter);
++counter;
EXPECT_EQ(i.key(), "");
EXPECT_EQ(i.value(), json(1));
}
EXPECT_EQ(counter, 2);
}

10
wpiutil/src/test/native/cpp/json/unit-meta.cpp
View File

@@ -42,13 +42,13 @@ TEST(JsonVersionTest, Meta)
json j = json::meta();
EXPECT_EQ(j["name"], "WPI version of JSON for Modern C++");
EXPECT_EQ(j["copyright"], "(C) 2013-2017 Niels Lohmann, (C) 2017 FIRST");
EXPECT_EQ(j["url"], "https://github.com/wpilibsuite/wpiutil");
EXPECT_EQ(j["copyright"], "(C) 2013-2017 Niels Lohmann, (C) 2017-2018 FIRST");
EXPECT_EQ(j["url"], "https://github.com/wpilibsuite/allwpilib");
EXPECT_EQ(j["version"], json(
{
{"string", "2.1.1"},
{"major", 2},
{"string", "3.1.2"},
{"major", 3},
{"minor", 1},
{"patch", 1}
{"patch", 2}
}));
}

4
wpiutil/src/test/native/cpp/json/unit-modifiers.cpp
View File

@@ -718,7 +718,7 @@ TEST(JsonSwapTest, NonObjectT)
TEST(JsonSwapTest, StringT)
{
json j = "Hello world";
json::string_t s = "Hallo Welt";
std::string s = "Hallo Welt";
j.swap(s);
@@ -732,7 +732,7 @@ TEST(JsonSwapTest, StringT)
TEST(JsonSwapTest, NonStringT)
{
json j = 17;
json::string_t s = "Hallo Welt";
std::string s = "Hallo Welt";
EXPECT_THROW_MSG(j.swap(s), json::type_error,
"[json.exception.type_error.310] cannot use swap() with number");

312
wpiutil/src/test/native/cpp/json/unit-msgpack.cpp
View File

@@ -50,7 +50,7 @@ TEST(MessagePackDiscardedTest, Case)
TEST(MessagePackNullTest, Case)
{
json j = nullptr;
std::string expected = "\xc0";
std::vector<uint8_t> expected = {0xc0};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -61,7 +61,7 @@ TEST(MessagePackNullTest, Case)
TEST(MessagePackBooleanTest, True)
{
json j = true;
std::string expected = "\xc3";
std::vector<uint8_t> expected = {0xc3};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -72,7 +72,7 @@ TEST(MessagePackBooleanTest, True)
TEST(MessagePackBooleanTest, False)
{
json j = false;
std::string expected = "\xc2";
std::vector<uint8_t> expected = {0xc2};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -94,8 +94,8 @@ TEST(MessagePackSignedTest, Neg0)
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -119,14 +119,14 @@ TEST(MessagePackSignedTest, Pos0)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -134,7 +134,7 @@ TEST(MessagePackSignedTest, Pos0)
EXPECT_EQ(result.size(), 1u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(i));
EXPECT_EQ(result[0], static_cast<uint8_t>(i));
// roundtrip
EXPECT_EQ(json::from_msgpack(result), j);
@@ -150,15 +150,15 @@ TEST(MessagePackSignedTest, Pos1)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcc));
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcc));
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -166,7 +166,7 @@ TEST(MessagePackSignedTest, Pos1)
EXPECT_EQ(result.size(), 2u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcc));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcc));
uint8_t restored = static_cast<uint8_t>(result[1]);
EXPECT_EQ(restored, i);
@@ -184,16 +184,16 @@ TEST(MessagePackSignedTest, Pos2)
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(i);
j.get_ref<int64_t&>() = static_cast<int64_t>(i);
// check type
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcd));
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcd));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -201,7 +201,7 @@ TEST(MessagePackSignedTest, Pos2)
EXPECT_EQ(result.size(), 3u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcd));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcd));
uint16_t restored = static_cast<uint16_t>(static_cast<uint8_t>(result[1]) * 256 + static_cast<uint8_t>(result[2]));
EXPECT_EQ(restored, i);
@@ -216,18 +216,18 @@ TEST_P(MessagePackSignedPos4Test, Case)
{
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() = static_cast<json::number_integer_t>(GetParam());
j.get_ref<int64_t&>() = static_cast<int64_t>(GetParam());
// check type
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xce));
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xce));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -235,7 +235,7 @@ TEST_P(MessagePackSignedPos4Test, Case)
EXPECT_EQ(result.size(), 5u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xce));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xce));
uint32_t restored = (static_cast<uint32_t>(static_cast<uint8_t>(result[1])) << 030) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[2])) << 020) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[3])) << 010) +
@@ -262,22 +262,22 @@ TEST_P(MessagePackSignedPos8Test, Case)
{
// create JSON value with integer number
json j = -1;
j.get_ref<json::number_integer_t&>() =
static_cast<json::number_integer_t>(GetParam());
j.get_ref<int64_t&>() =
static_cast<int64_t>(GetParam());
// check type
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcf));
expected.push_back(static_cast<char>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 010) & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcf));
expected.push_back(static_cast<uint8_t>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
// compare result + size
@@ -286,7 +286,7 @@ TEST_P(MessagePackSignedPos8Test, Case)
EXPECT_EQ(result.size(), 9u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcf));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcf));
uint64_t restored = (static_cast<uint64_t>(static_cast<uint8_t>(result[1])) << 070) +
(static_cast<uint64_t>(static_cast<uint8_t>(result[2])) << 060) +
(static_cast<uint64_t>(static_cast<uint8_t>(result[3])) << 050) +
@@ -323,9 +323,9 @@ TEST(MessagePackSignedTest, Neg1)
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xd0));
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xd0));
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -333,7 +333,7 @@ TEST(MessagePackSignedTest, Neg1)
EXPECT_EQ(result.size(), 2u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xd0));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xd0));
EXPECT_EQ(static_cast<int8_t>(result[1]), i);
// roundtrip
@@ -355,10 +355,10 @@ TEST(MessagePackSignedTest, Neg2)
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xd1));
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xd1));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -366,7 +366,7 @@ TEST(MessagePackSignedTest, Neg2)
EXPECT_EQ(result.size(), 3u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xd1));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xd1));
int16_t restored = static_cast<int16_t>((static_cast<uint8_t>(result[1]) << 8) +
static_cast<uint8_t>(result[2]));
EXPECT_EQ(restored, i);
@@ -387,12 +387,12 @@ TEST_P(MessagePackSignedNeg4Test, Case)
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xd2));
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xd2));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -400,7 +400,7 @@ TEST_P(MessagePackSignedNeg4Test, Case)
EXPECT_EQ(result.size(), 5u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xd2));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xd2));
uint32_t restored = (static_cast<uint32_t>(static_cast<uint8_t>(result[1])) << 030) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[2])) << 020) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[3])) << 010) +
@@ -433,16 +433,16 @@ TEST_P(MessagePackSignedNeg8Test, Case)
EXPECT_TRUE(j.is_number_integer());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xd3));
expected.push_back(static_cast<char>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xd3));
expected.push_back(static_cast<uint8_t>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -450,7 +450,7 @@ TEST_P(MessagePackSignedNeg8Test, Case)
EXPECT_EQ(result.size(), 9u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xd3));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xd3));
int64_t restored = (static_cast<int64_t>(static_cast<uint8_t>(result[1])) << 070) +
(static_cast<int64_t>(static_cast<uint8_t>(result[2])) << 060) +
(static_cast<int64_t>(static_cast<uint8_t>(result[3])) << 050) +
@@ -487,8 +487,8 @@ TEST(MessagePackUnsignedTest, Pos0)
EXPECT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -496,7 +496,7 @@ TEST(MessagePackUnsignedTest, Pos0)
EXPECT_EQ(result.size(), 1u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(i));
EXPECT_EQ(result[0], static_cast<uint8_t>(i));
// roundtrip
EXPECT_EQ(json::from_msgpack(result), j);
@@ -517,9 +517,9 @@ TEST(MessagePackUnsignedTest, Pos1)
EXPECT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcc));
expected.push_back(static_cast<char>(i));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcc));
expected.push_back(static_cast<uint8_t>(i));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -527,7 +527,7 @@ TEST(MessagePackUnsignedTest, Pos1)
EXPECT_EQ(result.size(), 2u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcc));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcc));
uint8_t restored = static_cast<uint8_t>(result[1]);
EXPECT_EQ(restored, i);
@@ -550,10 +550,10 @@ TEST(MessagePackUnsignedTest, Pos2)
EXPECT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcd));
expected.push_back(static_cast<char>((i >> 8) & 0xff));
expected.push_back(static_cast<char>(i & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcd));
expected.push_back(static_cast<uint8_t>((i >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(i & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -561,7 +561,7 @@ TEST(MessagePackUnsignedTest, Pos2)
EXPECT_EQ(result.size(), 3u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcd));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcd));
uint16_t restored = static_cast<uint16_t>(static_cast<uint8_t>(result[1]) * 256 + static_cast<uint8_t>(result[2]));
EXPECT_EQ(restored, i);
@@ -581,12 +581,12 @@ TEST_P(MessagePackUnsignedPos4Test, Case)
EXPECT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xce));
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xce));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -594,7 +594,7 @@ TEST_P(MessagePackUnsignedPos4Test, Case)
EXPECT_EQ(result.size(), 5u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xce));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xce));
uint32_t restored = (static_cast<uint32_t>(static_cast<uint8_t>(result[1])) << 030) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[2])) << 020) +
(static_cast<uint32_t>(static_cast<uint8_t>(result[3])) << 010) +
@@ -620,16 +620,16 @@ TEST_P(MessagePackUnsignedPos8Test, Case)
EXPECT_TRUE(j.is_number_unsigned());
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xcf));
expected.push_back(static_cast<char>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xcf));
expected.push_back(static_cast<uint8_t>((GetParam() >> 070) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 060) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 050) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 040) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 030) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 020) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 010) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -637,7 +637,7 @@ TEST_P(MessagePackUnsignedPos8Test, Case)
EXPECT_EQ(result.size(), 9u);
// check individual bytes
EXPECT_EQ(result[0], static_cast<char>(0xcf));
EXPECT_EQ(result[0], static_cast<uint8_t>(0xcf));
uint64_t restored = (static_cast<uint64_t>(static_cast<uint8_t>(result[1])) << 070) +
(static_cast<uint64_t>(static_cast<uint8_t>(result[2])) << 060) +
(static_cast<uint64_t>(static_cast<uint8_t>(result[3])) << 050) +
@@ -661,7 +661,7 @@ TEST(MessagePackFloatTest, Number)
{
double v = 3.1415925;
json j = v;
std::string expected = "\xcb\x40\x09\x21\xfb\x3f\xa6\xde\xfc";
std::vector<uint8_t> expected = {0xcb,0x40,0x09,0x21,0xfb,0x3f,0xa6,0xde,0xfc};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -691,12 +691,15 @@ TEST(MessagePackStringTest, String1)
json j = s;
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(first_bytes[N]));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(first_bytes[N]));
for (size_t i = 0; i < N; ++i)
{
expected.push_back('x');
}
// check first byte
EXPECT_EQ((first_bytes[N] & 0x1f), static_cast<char>(N));
EXPECT_EQ((first_bytes[N] & 0x1f), static_cast<uint8_t>(N));
// compare result + size
const auto result = json::to_msgpack(j);
@@ -725,10 +728,13 @@ TEST(MessagePackStringTest, String2)
json j = s;
// create expected byte vector
std::string expected;
expected.push_back(static_cast<char>(0xd9));
expected.push_back(static_cast<char>(N));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xd9));
expected.push_back(static_cast<uint8_t>(N));
for (size_t i = 0; i < N; ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_msgpack(j);
@@ -751,11 +757,14 @@ TEST_P(MessagePackString3Test, Case)
json j = s;
// create expected byte vector (hack: create string first)
std::string expected;
expected.push_back(static_cast<char>(0xda));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xda));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
for (size_t i = 0; i < GetParam(); ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_msgpack(j);
@@ -790,13 +799,16 @@ TEST_P(MessagePackString5Test, Case)
json j = s;
// create expected byte vector (hack: create string first)
std::string expected;
expected.push_back(static_cast<char>(0xdb));
expected.push_back(static_cast<char>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<char>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<char>(GetParam() & 0xff));
expected.append(s);
std::vector<uint8_t> expected;
expected.push_back(static_cast<uint8_t>(0xdb));
expected.push_back(static_cast<uint8_t>((GetParam() >> 24) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 16) & 0xff));
expected.push_back(static_cast<uint8_t>((GetParam() >> 8) & 0xff));
expected.push_back(static_cast<uint8_t>(GetParam() & 0xff));
for (size_t i = 0; i < GetParam(); ++i)
{
expected.push_back('x');
}
// compare result + size
const auto result = json::to_msgpack(j);
@@ -821,7 +833,7 @@ INSTANTIATE_TEST_CASE_P(MessagePackString5Tests, MessagePackString5Test,
TEST(MessagePackArrayTest, Empty)
{
json j = json::array();
std::string expected = "\x90";
std::vector<uint8_t> expected = {0x90};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -833,7 +845,7 @@ TEST(MessagePackArrayTest, Empty)
TEST(MessagePackArrayTest, Null)
{
json j = {nullptr};
std::string expected = "\x91\xc0";
std::vector<uint8_t> expected = {0x91,0xc0};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -845,7 +857,7 @@ TEST(MessagePackArrayTest, Null)
TEST(MessagePackArrayTest, Simple)
{
json j = json::parse("[1,2,3,4,5]");
std::string expected = "\x95\x01\x02\x03\x04\x05";
std::vector<uint8_t> expected = {0x95,0x01,0x02,0x03,0x04,0x05};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -857,7 +869,7 @@ TEST(MessagePackArrayTest, Simple)
TEST(MessagePackArrayTest, NestEmpty)
{
json j = json::parse("[[[[]]]]");
std::string expected = "\x91\x91\x91\x90";
std::vector<uint8_t> expected = {0x91,0x91,0x91,0x90};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -869,8 +881,8 @@ TEST(MessagePackArrayTest, NestEmpty)
TEST(MessagePackArrayTest, UInt16)
{
json j(16, nullptr);
std::string expected(j.size() + 3, static_cast<char>(0xc0)); // all null
expected[0] = static_cast<char>(0xdc); // array 16
std::vector<uint8_t> expected(j.size() + 3, static_cast<uint8_t>(0xc0)); // all null
expected[0] = static_cast<uint8_t>(0xdc); // array 16
expected[1] = 0x00; // size (0x0010), byte 0
expected[2] = 0x10; // size (0x0010), byte 1
const auto result = json::to_msgpack(j);
@@ -884,8 +896,8 @@ TEST(MessagePackArrayTest, UInt16)
TEST(MessagePackArrayTest, UInt32)
{
json j(65536, nullptr);
std::string expected(j.size() + 5, static_cast<char>(0xc0)); // all null
expected[0] = static_cast<char>(0xdd); // array 32
std::vector<uint8_t> expected(j.size() + 5, static_cast<uint8_t>(0xc0)); // all null
expected[0] = static_cast<uint8_t>(0xdd); // array 32
expected[1] = 0x00; // size (0x00100000), byte 0
expected[2] = 0x01; // size (0x00100000), byte 1
expected[3] = 0x00; // size (0x00100000), byte 2
@@ -907,7 +919,7 @@ TEST(MessagePackArrayTest, UInt32)
TEST(MessagePackObjectTest, Empty)
{
json j = json::object();
std::string expected = "\x80";
std::vector<uint8_t> expected = {0x80};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -919,7 +931,7 @@ TEST(MessagePackObjectTest, Empty)
TEST(MessagePackObjectTest, EmptyKey)
{
json j = {{"", nullptr}};
std::string expected = "\x81\xa0\xc0";
std::vector<uint8_t> expected = {0x81,0xa0,0xc0};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -931,7 +943,7 @@ TEST(MessagePackObjectTest, EmptyKey)
TEST(MessagePackObjectTest, NestedEmpty)
{
json j = json::parse("{\"a\": {\"b\": {\"c\": {}}}}");
std::string expected = "\x81\xa1\x61\x81\xa1\x62\x81\xa1\x63\x80";
std::vector<uint8_t> expected = {0x81,0xa1,0x61,0x81,0xa1,0x62,0x81,0xa1,0x63,0x80};
const auto result = json::to_msgpack(j);
EXPECT_EQ(result, expected);
@@ -955,7 +967,7 @@ TEST(MessagePackObjectTest, UInt16)
// size and the overall size. The rest is then handled in the
// roundtrip check.
EXPECT_EQ(result.size(), 67u); // 1 type, 2 size, 16*4 content
EXPECT_EQ(result[0], static_cast<char>(0xde)); // map 16
EXPECT_EQ(result[0], static_cast<uint8_t>(0xde)); // map 16
EXPECT_EQ(result[1], 0x00); // byte 0 of size (0x0010)
EXPECT_EQ(result[2], 0x10); // byte 1 of size (0x0010)
@@ -984,7 +996,7 @@ TEST(MessagePackObjectTest, UInt32)
// size and the overall size. The rest is then handled in the
// roundtrip check.
EXPECT_EQ(result.size(), 458757u); // 1 type, 4 size, 65536*7 content
EXPECT_EQ(result[0], static_cast<char>(0xdf)); // map 32
EXPECT_EQ(result[0], static_cast<uint8_t>(0xdf)); // map 32
EXPECT_EQ(result[1], 0x00); // byte 0 of size (0x00010000)
EXPECT_EQ(result[2], 0x01); // byte 1 of size (0x00010000)
EXPECT_EQ(result[3], 0x00); // byte 2 of size (0x00010000)
@@ -997,50 +1009,50 @@ TEST(MessagePackObjectTest, UInt32)
// from float32
TEST(MessagePackFloat32Test, Case)
{
auto given = std::string("\xca\x41\xc8\x00\x01", 5);
auto given = std::vector<uint8_t>({0xca,0x41,0xc8,0x00,0x01});
json j = json::from_msgpack(given);
EXPECT_LT(std::fabs(j.get<double>() - 25), 0.001);
}
TEST(MessagePackErrorTest, TooShortByteVector)
{
EXPECT_THROW_MSG(json::from_msgpack("\xcc"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcc})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack("\xcd"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcd})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcd\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcd,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack("\xce"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xce})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xce\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xce,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xce\x00\x00", 3)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xce,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 4: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xce\x00\x00\x00", 4)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xce,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 5: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack("\xcf"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf})), json::parse_error,
"[json.exception.parse_error.110] parse error at 2: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00", 2)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 3: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00", 3)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 4: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00\x00", 4)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 5: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00\x00\x00", 5)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 6: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00\x00\x00\x00", 6)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 7: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00\x00\x00\x00\x00", 7)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 8: unexpected end of input");
EXPECT_THROW_MSG(json::from_msgpack(wpi::StringRef("\xcf\x00\x00\x00\x00\x00\x00\x00", 8)), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xcf,0x00,0x00,0x00,0x00,0x00,0x00,0x00})), json::parse_error,
"[json.exception.parse_error.110] parse error at 9: unexpected end of input");
}
TEST(MessagePackErrorTest, UnsupportedBytesConcrete)
{
EXPECT_THROW_MSG(json::from_msgpack("\xc1"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xc1})), json::parse_error,
"[json.exception.parse_error.112] parse error at 1: error reading MessagePack; last byte: 0xc1");
EXPECT_THROW_MSG(json::from_msgpack("\xc6"), json::parse_error,
EXPECT_THROW_MSG(json::from_msgpack(std::vector<uint8_t>({0xc6})), json::parse_error,
"[json.exception.parse_error.112] parse error at 1: error reading MessagePack; last byte: 0xc6");
}
@@ -1058,7 +1070,7 @@ TEST(MessagePackErrorTest, UnsupportedBytesAll)
0xd4, 0xd5, 0xd6, 0xd7, 0xd8
})
{
EXPECT_THROW(json::from_msgpack(std::string(1, static_cast<char>(byte))), json::parse_error);
EXPECT_THROW(json::from_msgpack(std::vector<uint8_t>({static_cast<uint8_t>(byte)})), json::parse_error);
}
}
#if 0

160
wpiutil/src/test/native/cpp/json/unit-pointer_access.cpp
View File

@@ -78,11 +78,11 @@ TEST(JsonPointerTest, ObjectT)
// check if null pointers are returned correctly
EXPECT_NE(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const object_t
@@ -107,11 +107,11 @@ TEST(JsonPointerTest, ConstObjectT)
// check if null pointers are returned correctly
EXPECT_NE(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to array_t
@@ -136,11 +136,11 @@ TEST(JsonPointerTest, ArrayT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const array_t
@@ -165,17 +165,17 @@ TEST(JsonPointerTest, ConstArrayT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to string_t
TEST(JsonPointerTest, StringT)
{
using test_type = json::string_t;
using test_type = std::string;
json value = "hello";
// check if pointers are returned correctly
@@ -194,17 +194,17 @@ TEST(JsonPointerTest, StringT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_NE(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const string_t
TEST(JsonPointerTest, ConstStringT)
{
using test_type = const json::string_t;
using test_type = const std::string;
const json value = "hello";
// check if pointers are returned correctly
@@ -223,17 +223,17 @@ TEST(JsonPointerTest, ConstStringT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to boolean_t
TEST(JsonPointerTest, BooleanT)
{
using test_type = json::boolean_t;
using test_type = bool;
json value = false;
// check if pointers are returned correctly
@@ -252,17 +252,17 @@ TEST(JsonPointerTest, BooleanT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_NE(value.get_ptr<bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const boolean_t
TEST(JsonPointerTest, ConstBooleanT)
{
using test_type = const json::boolean_t;
using test_type = const bool;
const json value = false;
// check if pointers are returned correctly
@@ -281,17 +281,17 @@ TEST(JsonPointerTest, ConstBooleanT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_NE(value.get_ptr<const bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to number_integer_t
TEST(JsonPointerTest, IntegerT)
{
using test_type = json::number_integer_t;
using test_type = int64_t;
json value = 23;
// check if pointers are returned correctly
@@ -310,17 +310,17 @@ TEST(JsonPointerTest, IntegerT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_NE(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const number_integer_t
TEST(JsonPointerTest, ConstIntegerT)
{
using test_type = const json::number_integer_t;
using test_type = const int64_t;
const json value = 23;
// check if pointers are returned correctly
@@ -339,17 +339,17 @@ TEST(JsonPointerTest, ConstIntegerT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_NE(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to number_unsigned_t
TEST(JsonPointerTest, UnsignedT)
{
using test_type = json::number_unsigned_t;
using test_type = uint64_t;
json value = 23u;
// check if pointers are returned correctly
@@ -368,17 +368,17 @@ TEST(JsonPointerTest, UnsignedT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_NE(value.get_ptr<int64_t*>(), nullptr);
EXPECT_NE(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<double*>(), nullptr);
}
// pointer access to const number_unsigned_t
TEST(JsonPointerTest, ConstUnsignedT)
{
using test_type = const json::number_unsigned_t;
using test_type = const uint64_t;
const json value = 23u;
// check if pointers are returned correctly
@@ -397,17 +397,17 @@ TEST(JsonPointerTest, ConstUnsignedT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_NE(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const double*>(), nullptr);
}
// pointer access to number_float_t
TEST(JsonPointerTest, FloatT)
{
using test_type = json::number_float_t;
using test_type = double;
json value = 42.23;
// check if pointers are returned correctly
@@ -426,17 +426,17 @@ TEST(JsonPointerTest, FloatT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<json::number_unsigned_t*>(), nullptr);
EXPECT_NE(value.get_ptr<json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<uint64_t*>(), nullptr);
EXPECT_NE(value.get_ptr<double*>(), nullptr);
}
// pointer access to const number_float_t
TEST(JsonPointerTest, ConstFloatT)
{
using test_type = const json::number_float_t;
using test_type = const double;
const json value = 42.23;
// check if pointers are returned correctly
@@ -455,9 +455,9 @@ TEST(JsonPointerTest, ConstFloatT)
// check if null pointers are returned correctly
EXPECT_EQ(value.get_ptr<const json::object_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::array_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::string_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::boolean_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_integer_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const json::number_unsigned_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const json::number_float_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const std::string*>(), nullptr);
EXPECT_EQ(value.get_ptr<const bool*>(), nullptr);
EXPECT_EQ(value.get_ptr<const int64_t*>(), nullptr);
EXPECT_EQ(value.get_ptr<const uint64_t*>(), nullptr);
EXPECT_NE(value.get_ptr<const double*>(), nullptr);
}

2
wpiutil/src/test/native/cpp/json/unit-readme.cpp
View File

@@ -45,6 +45,8 @@ using wpi::json;
#include <unordered_map>
#include <unordered_set>
#include "wpi/raw_ostream.h"
TEST(JsonReadmeTest, Basic)
{
// create an empty structure (null)

56
wpiutil/src/test/native/cpp/json/unit-reference_access.cpp
View File

@@ -55,10 +55,10 @@ TEST(JsonReferenceTest, ObjectT)
// check if mismatching references throw correctly
EXPECT_NO_THROW(value.get_ref<json::object_t&>());
EXPECT_ANY_THROW(value.get_ref<json::array_t&>());
EXPECT_ANY_THROW(value.get_ref<json::string_t&>());
EXPECT_ANY_THROW(value.get_ref<json::boolean_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_float_t&>());
EXPECT_ANY_THROW(value.get_ref<std::string&>());
EXPECT_ANY_THROW(value.get_ref<bool&>());
EXPECT_ANY_THROW(value.get_ref<int64_t&>());
EXPECT_ANY_THROW(value.get_ref<double&>());
}
// const reference access to const object_t
@@ -94,16 +94,16 @@ TEST(JsonReferenceTest, ArrayT)
// check if mismatching references throw correctly
EXPECT_ANY_THROW(value.get_ref<json::object_t&>());
EXPECT_NO_THROW(value.get_ref<json::array_t&>());
EXPECT_ANY_THROW(value.get_ref<json::string_t&>());
EXPECT_ANY_THROW(value.get_ref<json::boolean_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_float_t&>());
EXPECT_ANY_THROW(value.get_ref<std::string&>());
EXPECT_ANY_THROW(value.get_ref<bool&>());
EXPECT_ANY_THROW(value.get_ref<int64_t&>());
EXPECT_ANY_THROW(value.get_ref<double&>());
}
// reference access to string_t
TEST(JsonReferenceTest, StringT)
{
using test_type = json::string_t;
using test_type = std::string;
json value = "hello";
// check if references are returned correctly
@@ -118,16 +118,16 @@ TEST(JsonReferenceTest, StringT)
// check if mismatching references throw correctly
EXPECT_ANY_THROW(value.get_ref<json::object_t&>());
EXPECT_ANY_THROW(value.get_ref<json::array_t&>());
EXPECT_NO_THROW(value.get_ref<json::string_t&>());
EXPECT_ANY_THROW(value.get_ref<json::boolean_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_float_t&>());
EXPECT_NO_THROW(value.get_ref<std::string&>());
EXPECT_ANY_THROW(value.get_ref<bool&>());
EXPECT_ANY_THROW(value.get_ref<int64_t&>());
EXPECT_ANY_THROW(value.get_ref<double&>());
}
// reference access to boolean_t
TEST(JsonReferenceTest, BooleanT)
{
using test_type = json::boolean_t;
using test_type = bool;
json value = false;
// check if references are returned correctly
@@ -142,16 +142,16 @@ TEST(JsonReferenceTest, BooleanT)
// check if mismatching references throw correctly
EXPECT_ANY_THROW(value.get_ref<json::object_t&>());
EXPECT_ANY_THROW(value.get_ref<json::array_t&>());
EXPECT_ANY_THROW(value.get_ref<json::string_t&>());
EXPECT_NO_THROW(value.get_ref<json::boolean_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_float_t&>());
EXPECT_ANY_THROW(value.get_ref<std::string&>());
EXPECT_NO_THROW(value.get_ref<bool&>());
EXPECT_ANY_THROW(value.get_ref<int64_t&>());
EXPECT_ANY_THROW(value.get_ref<double&>());
}
// reference access to number_integer_t
TEST(JsonReferenceTest, IntegerT)
{
using test_type = json::number_integer_t;
using test_type = int64_t;
json value = 23;
// check if references are returned correctly
@@ -166,16 +166,16 @@ TEST(JsonReferenceTest, IntegerT)
// check if mismatching references throw correctly
EXPECT_ANY_THROW(value.get_ref<json::object_t&>());
EXPECT_ANY_THROW(value.get_ref<json::array_t&>());
EXPECT_ANY_THROW(value.get_ref<json::string_t&>());
EXPECT_ANY_THROW(value.get_ref<json::boolean_t&>());
EXPECT_NO_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_float_t&>());
EXPECT_ANY_THROW(value.get_ref<std::string&>());
EXPECT_ANY_THROW(value.get_ref<bool&>());
EXPECT_NO_THROW(value.get_ref<int64_t&>());
EXPECT_ANY_THROW(value.get_ref<double&>());
}
// reference access to number_float_t
TEST(JsonReferenceTest, FloatT)
{
using test_type = json::number_float_t;
using test_type = double;
json value = 42.23;
// check if references are returned correctly
@@ -190,8 +190,8 @@ TEST(JsonReferenceTest, FloatT)
// check if mismatching references throw correctly
EXPECT_ANY_THROW(value.get_ref<json::object_t&>());
EXPECT_ANY_THROW(value.get_ref<json::array_t&>());
EXPECT_ANY_THROW(value.get_ref<json::string_t&>());
EXPECT_ANY_THROW(value.get_ref<json::boolean_t&>());
EXPECT_ANY_THROW(value.get_ref<json::number_integer_t&>());
EXPECT_NO_THROW(value.get_ref<json::number_float_t&>());
EXPECT_ANY_THROW(value.get_ref<std::string&>());
EXPECT_ANY_THROW(value.get_ref<bool&>());
EXPECT_ANY_THROW(value.get_ref<int64_t&>());
EXPECT_NO_THROW(value.get_ref<double&>());
}

1
wpiutil/src/test/native/cpp/json/unit-unicode.cpp
View File

@@ -39,6 +39,7 @@ using wpi::json;
#include "wpi/Format.h"
#include "wpi/StringExtras.h"
#include "wpi/raw_ostream.h"
#include <fstream>