#include "doctest_compatibility.h"

DOCTEST_GCC_SUPPRESS_WARNING_PUSH

DOCTEST_GCC_SUPPRESS_WARNING("-Wnoexcept")

#if defined(JSON_DISABLE_ENUM_SERIALIZATION) && (JSON_DISABLE_ENUM_SERIALIZATION == 1)

#define SKIP_TESTS_FOR_ENUM_SERIALIZATION

#endif

#include <nlohmann/json.hpp>

using nlohmann::json;

#ifdef JSON_TEST_NO_GLOBAL_UDLS

using namespace nlohmann::literals; // NOLINT(google-build-using-namespace)

#endif

#include <map>

#include <memory>

#include <string>

#include <utility>

namespace udt

{

enum class country

};

struct age

};

struct name

};

struct address

};

struct person

};

struct contact

};

enum class book_id : std::uint64_t;

struct contact_book

};

} // namespace udt

namespace udt

{

template <typename BasicJsonType>

static void to_json(BasicJsonType& j, age a)

{

j = a.m_val;

}

template <typename BasicJsonType>

static void to_json(BasicJsonType& j, const name& n)

{

j = n.m_val;

}

template <typename BasicJsonType>

static void to_json(BasicJsonType& j, country c)

}

template <typename BasicJsonType>

static void to_json(BasicJsonType& j, const person& p)

{

j = BasicJsonType{{"age", p.m_age}, {"name", p.m_name}, {"country", p.m_country}};

}

static void to_json(nlohmann::json& j, const address& a)

{

j = a.m_val;

}

static void to_json(nlohmann::json& j, const contact& c)

{

j = json{{"person", c.m_person}, {"address", c.m_address}};

}

static void to_json(nlohmann::json& j, const contact_book& cb)

}

static bool operator==(age lhs, age rhs)

{

return lhs.m_val == rhs.m_val;

}

static bool operator==(const address& lhs, const address& rhs)

{

return lhs.m_val == rhs.m_val;

}

static bool operator==(const name& lhs, const name& rhs)

{

return lhs.m_val == rhs.m_val;

}

static bool operator==(const person& lhs, const person& rhs)

{

return std::tie(lhs.m_name, lhs.m_age) == std::tie(rhs.m_name, rhs.m_age);

}

static bool operator==(const contact& lhs, const contact& rhs)

{

return std::tie(lhs.m_person, lhs.m_address) ==

std::tie(rhs.m_person, rhs.m_address);

}

static bool operator==(const contact_book& lhs, const contact_book& rhs)

{

return std::tie(lhs.m_book_name, lhs.m_book_id, lhs.m_contacts) ==

std::tie(rhs.m_book_name, rhs.m_book_id, rhs.m_contacts);

}

} // namespace udt

namespace udt

{

template <typename BasicJsonType>

static void from_json(const BasicJsonType& j, age& a)

{

a.m_val = j.template get<int>();

}

template <typename BasicJsonType>

static void from_json(const BasicJsonType& j, name& n)

{

n.m_val = j.template get<std::string>();

}

template <typename BasicJsonType>

static void from_json(const BasicJsonType& j, country& c)

}

template <typename BasicJsonType>

static void from_json(const BasicJsonType& j, person& p)

}

static void from_json(const nlohmann::json& j, address& a)

{

a.m_val = j.get<std::string>();

}

static void from_json(const nlohmann::json& j, contact& c)

}

static void from_json(const nlohmann::json& j, contact_book& cb)

}

} // namespace udt

TEST_CASE("basic usage" * doctest::test_suite("udt"))

{

// a bit narcissistic maybe :) ?

const udt::age a

{

23

};

const udt::name n{"theo"};

const udt::country c{udt::country::france};

const udt::person sfinae_addict{a, n, c};

const udt::person senior_programmer{{42}, {"王芳"}, udt::country::china};

const udt::address addr{"Paris"};

const udt::contact cpp_programmer{sfinae_addict, addr};

const udt::book_id large_id{static_cast<udt::book_id>(static_cast<std::uint64_t>(1) << 63)}; // verify large unsigned enums are handled correctly

const udt::contact_book book{{"C++"}, static_cast<udt::book_id>(42u), {cpp_programmer, {senior_programmer, addr}}};

SECTION("conversion to json via free-functions")

{

CHECK(json(a) == json(23));

CHECK(json(n) == json("theo"));

CHECK(json(c) == json("France"));

CHECK(json(sfinae_addict) == R"({"name":"theo", "age":23, "country":"France"})"_json);

CHECK(json("Paris") == json(addr));

CHECK(json(cpp_programmer) ==

R"({"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"})"_json);

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

CHECK(json(large_id) == json(static_cast<std::uint64_t>(1) << 63));

CHECK(json(large_id) > 0u);

CHECK(to_string(json(large_id)) == "9223372036854775808");

CHECK(json(large_id).is_number_unsigned());

#endif

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

CHECK(

json(book) ==

R"({"name":"C++", "id":42, "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json);

#else

CHECK(

json(book) ==

R"({"name":"C++", "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json);

#endif

}

SECTION("conversion from json via free-functions")

{

const auto big_json =

R"({"name":"C++", "id":42, "contacts" : [{"person" : {"age":23, "name":"theo", "country":"France"}, "address":"Paris"}, {"person" : {"age":42, "country":"中华人民共和国", "name":"王芳"}, "address":"Paris"}]})"_json;

SECTION("via explicit calls to get")

{

const auto parsed_book = big_json.get<udt::contact_book>();

const auto book_name = big_json["name"].get<udt::name>();

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

const auto book_id = big_json["id"].get<udt::book_id>();

#endif

const auto contacts =

big_json["contacts"].get<std::vector<udt::contact>>();

const auto contact_json = big_json["contacts"].at(0);

const auto contact = contact_json.get<udt::contact>();

const auto person = contact_json["person"].get<udt::person>();

const auto address = contact_json["address"].get<udt::address>();

const auto age = contact_json["person"]["age"].get<udt::age>();

const auto country =

contact_json["person"]["country"].get<udt::country>();

const auto name = contact_json["person"]["name"].get<udt::name>();

CHECK(age == a);

CHECK(name == n);

CHECK(country == c);

CHECK(address == addr);

CHECK(person == sfinae_addict);

CHECK(contact == cpp_programmer);

CHECK(contacts == book.m_contacts);

CHECK(book_name == udt::name{"C++"});

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

CHECK(book_id == book.m_book_id);

CHECK(book == parsed_book);

#endif

}

SECTION("via explicit calls to get_to")

{

udt::person person;

udt::name name;

json person_json = big_json["contacts"][0]["person"];

CHECK(person_json.get_to(person) == sfinae_addict);

// correct reference gets returned

person_json["name"].get_to(name).m_val = "new name";

CHECK(name.m_val == "new name");

}

#if JSON_USE_IMPLICIT_CONVERSIONS

SECTION("implicit conversions")

{

const udt::contact_book parsed_book = big_json;

const udt::name book_name = big_json["name"];

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

const udt::book_id book_id = big_json["id"];

#endif

const std::vector<udt::contact> contacts = big_json["contacts"];

const auto contact_json = big_json["contacts"].at(0);

const udt::contact contact = contact_json;

const udt::person person = contact_json["person"];

const udt::address address = contact_json["address"];

const udt::age age = contact_json["person"]["age"];

const udt::country country = contact_json["person"]["country"];

const udt::name name = contact_json["person"]["name"];

CHECK(age == a);

CHECK(name == n);

CHECK(country == c);

CHECK(address == addr);

CHECK(person == sfinae_addict);

CHECK(contact == cpp_programmer);

CHECK(contacts == book.m_contacts);

CHECK(book_name == udt::name{"C++"});

#ifndef SKIP_TESTS_FOR_ENUM_SERIALIZATION

CHECK(book_id == static_cast<udt::book_id>(42u));

CHECK(book == parsed_book);

#endif

}

#endif

}

}

namespace udt

{

struct legacy_type

};

} // namespace udt

namespace nlohmann

{

template <typename T>

struct adl_serializer<std::shared_ptr<T>>

{

static void to_json(json& j, const std::shared_ptr<T>& opt)

}

static void from_json(const json& j, std::shared_ptr<T>& opt)

}

};

template <>

struct adl_serializer<udt::legacy_type>

{

static void to_json(json& j, const udt::legacy_type& l)

{

j = std::stoi(l.number);

}

static void from_json(const json& j, udt::legacy_type& l)

{

l.number = std::to_string(j.get<int>());

}

};

} // namespace nlohmann

TEST_CASE("adl_serializer specialization" * doctest::test_suite("udt"))

{

SECTION("partial specialization")

{

SECTION("to_json")

{

std::shared_ptr<udt::person> optPerson;

json j = optPerson;

CHECK(j.is_null());

optPerson.reset(new udt::person{{42}, {"John Doe"}, udt::country::russia}); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-shared)

j = optPerson;

CHECK_FALSE(j.is_null());

CHECK(j.get<udt::person>() == *optPerson);

}

SECTION("from_json")

{

auto person = udt::person{{42}, {"John Doe"}, udt::country::russia};

json j = person;

auto optPerson = j.get<std::shared_ptr<udt::person>>();

REQUIRE(optPerson);

CHECK(*optPerson == person);

j = nullptr;

optPerson = j.get<std::shared_ptr<udt::person>>();

CHECK(!optPerson);

}

}

SECTION("total specialization")

{

SECTION("to_json")

{

udt::legacy_type const lt{"4242"};

json const j = lt;

CHECK(j.get<int>() == 4242);

}

SECTION("from_json")

{

json const j = 4242;

auto lt = j.get<udt::legacy_type>();

CHECK(lt.number == "4242");

}

}

}

namespace nlohmann

{

template <>

struct adl_serializer<std::vector<float>>

{

using type = std::vector<float>;

static void to_json(json& j, const type& /*type*/)

{

j = "hijacked!";

}

static void from_json(const json& /*unnamed*/, type& opt)

{

opt = {42.0, 42.0, 42.0};

}

// preferred version

static type from_json(const json& /*unnamed*/)

{

return {4.0, 5.0, 6.0};

}

};

} // namespace nlohmann

TEST_CASE("even supported types can be specialized" * doctest::test_suite("udt"))

{

json const j = std::vector<float> {1.0, 2.0, 3.0};

CHECK(j.dump() == R"("hijacked!")");

auto f = j.get<std::vector<float>>();

// the single argument from_json method is preferred

CHECK((f == std::vector<float> {4.0, 5.0, 6.0}));

}

namespace nlohmann

{

template <typename T>

struct adl_serializer<std::unique_ptr<T>>

{

static void to_json(json& j, const std::unique_ptr<T>& opt)

}

// this is the overload needed for non-copyable types,

static std::unique_ptr<T> from_json(const json& j)

}

};

} // namespace nlohmann

TEST_CASE("Non-copyable types" * doctest::test_suite("udt"))

{

SECTION("to_json")

{

std::unique_ptr<udt::person> optPerson;

json j = optPerson;

CHECK(j.is_null());

optPerson.reset(new udt::person{{42}, {"John Doe"}, udt::country::russia}); // NOLINT(cppcoreguidelines-owning-memory,modernize-make-unique)

j = optPerson;

CHECK_FALSE(j.is_null());

CHECK(j.get<udt::person>() == *optPerson);

}

SECTION("from_json")

{

auto person = udt::person{{42}, {"John Doe"}, udt::country::russia};

json j = person;

auto optPerson = j.get<std::unique_ptr<udt::person>>();

REQUIRE(optPerson);

CHECK(*optPerson == person);

j = nullptr;

optPerson = j.get<std::unique_ptr<udt::person>>();

CHECK(!optPerson);

}

}

template <typename T, typename = void>

struct pod_serializer

};

namespace udt

{

struct small_pod

};

struct non_pod

};

template <typename BasicJsonType>

static void to_json(BasicJsonType& j, const non_pod& np)

{

j = np.s;

}

template <typename BasicJsonType>

static void from_json(const BasicJsonType& j, non_pod& np)

{

np.s = j.template get<std::string>();

}

static bool operator==(small_pod lhs, small_pod rhs) noexcept

{

return std::tie(lhs.begin, lhs.middle, lhs.end) ==

std::tie(rhs.begin, rhs.middle, rhs.end);

}

static bool operator==(const non_pod& lhs, const non_pod& rhs) noexcept

{

return lhs.s == rhs.s;

}

static std::ostream& operator<<(std::ostream& os, small_pod l)

{

return os << "begin: " << l.begin << ", middle: " << l.middle << ", end: " << l.end;

}

} // namespace udt

TEST_CASE("custom serializer for pods" * doctest::test_suite("udt"))

{

using custom_json =

nlohmann::basic_json<std::map, std::vector, std::string, bool,

std::int64_t, std::uint64_t, double, std::allocator, pod_serializer>;

auto p = udt::small_pod{42, '/', 42};

custom_json const j = p;

auto p2 = j.get<udt::small_pod>();

CHECK(p == p2);

auto np = udt::non_pod{{"non-pod"}};

custom_json const j2 = np;

auto np2 = j2.get<udt::non_pod>();

CHECK(np == np2);

}

template <typename T, typename>

struct another_adl_serializer;

using custom_json = nlohmann::basic_json<std::map, std::vector, std::string, bool, std::int64_t, std::uint64_t, double, std::allocator, another_adl_serializer>;

template <typename T, typename>

struct another_adl_serializer

};

TEST_CASE("custom serializer that does adl by default" * doctest::test_suite("udt"))

{

auto me = udt::person{{23}, {"theo"}, udt::country::france};

json const j = me;

custom_json const cj = me;

CHECK(j.dump() == cj.dump());

CHECK(me == j.get<udt::person>());

CHECK(me == cj.get<udt::person>());

}

TEST_CASE("different basic_json types conversions")

{

SECTION("null")

{

json const j;

const custom_json cj = j;

CHECK(cj == nullptr);

}

SECTION("boolean")

{

json const j = true;

const custom_json cj = j;

CHECK(cj == true);

}

SECTION("discarded")

{

json const j(json::value_t::discarded);

custom_json cj;

CHECK_NOTHROW(cj = j);

CHECK(cj.type() == custom_json::value_t::discarded);

}

SECTION("array")

{

json const j = {1, 2, 3};

custom_json const cj = j;

CHECK((cj == std::vector<int> {1, 2, 3}));

}

SECTION("integer")

{

json const j = 42;

const custom_json cj = j;

CHECK(cj == 42);

}

SECTION("float")

{

json const j = 42.0;

const custom_json cj = j;

CHECK(cj == 42.0);

}

SECTION("unsigned")

{

json const j = 42u;

const custom_json cj = j;

CHECK(cj == 42u);

}

SECTION("string")

{

json const j = "forty-two";

const custom_json cj = j;

CHECK(cj == "forty-two");

}

SECTION("binary")

{

json j = json::binary({1, 2, 3}, 42);

custom_json cj = j;

CHECK(cj.get_binary().subtype() == 42);

const std::vector<std::uint8_t>& cv = cj.get_binary();

std::vector<std::uint8_t> v = j.get_binary();

CHECK(cv == v);

}

SECTION("object")

{

json const j = {{"forty", "two"}};

const custom_json cj = j;

auto m = j.get<std::map<std::string, std::string>>();

CHECK(cj == m);

}

SECTION("get<custom_json>")

{

json const j = 42;

const custom_json cj = j.get<custom_json>();

CHECK(cj == 42);

}

}

{

struct incomplete;

template <typename T, typename = void>

struct is_constructible_patched : std::false_type {};

template <typename T>

struct is_constructible_patched<T, decltype(void(json(std::declval<T>())))> : std::true_type {};

} // namespace

TEST_CASE("an incomplete type does not trigger a compiler error in non-evaluated context" * doctest::test_suite("udt"))

{

static_assert(!is_constructible_patched<json, incomplete>::value, "");

}

{

class Evil

};

void from_json(const json& /*unused*/, Evil& /*unused*/) {}

} // namespace

TEST_CASE("Issue #924")

{

// Prevent get<std::vector<Evil>>() to throw

auto j = json::array();

CHECK_NOTHROW(j.get<Evil>());

CHECK_NOTHROW(j.get<std::vector<Evil>>());

// silence Wunused-template warnings

const Evil e(1);

CHECK(e.m_i >= 0);

// suppress warning: function "<unnamed>::Evil::Evil(T) [with T=std::string]" was declared but never referenced [declared_but_not_referenced]

const Evil e2(std::string("foo"));

CHECK(e2.m_i >= 0);

}

TEST_CASE("Issue #1237")

{

struct non_convertible_type {};

static_assert(!std::is_convertible<json, non_convertible_type>::value, "");

}

{

class no_iterator_type

};

} // namespace

TEST_CASE("compatible array type, without iterator type alias")

{

no_iterator_type const vec{1, 2, 3};

json const j = vec;

}

DOCTEST_GCC_SUPPRESS_WARNING_POP