// __ _____ _____ _____

// __| | __| | | | JSON for Modern C++ (supporting code)

// | | |__ | | | | | | version 3.12.0

// |_____|_____|_____|_|___| https://github.com/nlohmann/json

//

// SPDX-FileCopyrightText: 2013-2026 Niels Lohmann <https://nlohmann.me>

// SPDX-License-Identifier: MIT

#include "doctest_compatibility.h"

#define JSON_TESTS_PRIVATE

#include <nlohmann/json.hpp>

using nlohmann::json;

#include <deque>

#include <forward_list>

#include <fstream>

#include <list>

#include <set>

#include <unordered_map>

#include <unordered_set>

#include <valarray>

TEST_CASE("constructors")

{

SECTION("create an empty value with a given type")

{

SECTION("null")

{

auto const t = json::value_t::null;

json const j(t);

CHECK(j.type() == t);

}

SECTION("discarded")

{

auto const t = json::value_t::discarded;

json const j(t);

CHECK(j.type() == t);

}

SECTION("object")

{

auto const t = json::value_t::object;

json const j(t);

CHECK(j.type() == t);

}

SECTION("array")

{

auto const t = json::value_t::array;

json const j(t);

CHECK(j.type() == t);

}

SECTION("boolean")

{

auto const t = json::value_t::boolean;

json const j(t);

CHECK(j.type() == t);

CHECK(j == false);

}

SECTION("string")

{

auto const t = json::value_t::string;

json const j(t);

CHECK(j.type() == t);

CHECK(j == "");

}

SECTION("number_integer")

{

auto const t = json::value_t::number_integer;

json const j(t);

CHECK(j.type() == t);

CHECK(j == 0);

}

SECTION("number_unsigned")

{

auto const t = json::value_t::number_unsigned;

json const j(t);

CHECK(j.type() == t);

CHECK(j == 0);

}

SECTION("number_float")

{

auto const t = json::value_t::number_float;

json const j(t);

CHECK(j.type() == t);

CHECK(j == 0.0);

}

SECTION("binary")

{

auto const t = json::value_t::binary;

json const j(t);

CHECK(j.type() == t);

CHECK(j == json::binary({}));

}

}

SECTION("create a null object (implicitly)")

{

SECTION("no parameter")

{

json const j{};

CHECK(j.type() == json::value_t::null);

}

}

SECTION("create a null object (explicitly)")

{

SECTION("parameter")

{

json const j(nullptr);

CHECK(j.type() == json::value_t::null);

}

}

SECTION("create an object (explicit)")

{

SECTION("empty object")

{

json::object_t const o{};

json const j(o);

CHECK(j.type() == json::value_t::object);

}

SECTION("filled object")

{

json::object_t const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

}

}

SECTION("create an object (implicit)")

{

// reference object

json::object_t const o_reference {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j_reference(o_reference);

SECTION("std::map<json::string_t, json>")

{

std::map<json::string_t, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

SECTION("std::map<std::string, std::string> #600")

{

const std::map<std::string, std::string> m

{

{"a", "b"},

{"c", "d"},

{"e", "f"},

};

json const j(m);

CHECK((j.get<decltype(m)>() == m));

}

SECTION("std::map<const char*, json>")

{

std::map<const char*, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

SECTION("std::multimap<json::string_t, json>")

{

std::multimap<json::string_t, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

SECTION("std::unordered_map<json::string_t, json>")

{

std::unordered_map<json::string_t, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

SECTION("std::unordered_multimap<json::string_t, json>")

{

std::unordered_multimap<json::string_t, json> const o {{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}};

json const j(o);

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

SECTION("associative container literal")

{

json const j({{"a", json(1)}, {"b", json(1u)}, {"c", json(2.2)}, {"d", json(false)}, {"e", json("string")}, {"f", json()}});

CHECK(j.type() == json::value_t::object);

CHECK(j == j_reference);

}

}

SECTION("create an array (explicit)")

{

SECTION("empty array")

{

json::array_t const a{};

json const j(a);

CHECK(j.type() == json::value_t::array);

}

SECTION("filled array")

{

json::array_t const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

}

}

SECTION("create an array (implicit)")

{

// reference array

json::array_t const a_reference {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j_reference(a_reference);

SECTION("std::list<json>")

{

std::list<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

}

SECTION("std::pair")

{

std::pair<float, std::string> const p{1.0f, "string"};

json const j(p);

CHECK(j.type() == json::value_t::array);

CHECK(j.get<decltype(p)>() == p);

REQUIRE(j.size() == 2);

CHECK(j[0] == std::get<0>(p));

CHECK(j[1] == std::get<1>(p));

}

SECTION("std::pair with discarded values")

{

json const j{1, 2.0, "string"};

const auto p = j.get<std::pair<int, float>>();

CHECK(p.first == j[0]);

CHECK(p.second == j[1]);

}

SECTION("std::tuple")

{

const auto t = std::make_tuple(1.0, std::string{"string"}, 42, std::vector<int> {0, 1});

json const j(t);

CHECK(j.type() == json::value_t::array);

REQUIRE(j.size() == 4);

CHECK(j.get<decltype(t)>() == t);

CHECK(j[0] == std::get<0>(t));

CHECK(j[1] == std::get<1>(t));

CHECK(j[2] == std::get<2>(t));

CHECK(j[3][0] == 0);

CHECK(j[3][1] == 1);

}

SECTION("std::tuple with discarded values")

{

json const j{1, 2.0, "string", 42};

const auto t = j.get<std::tuple<int, float, std::string>>();

CHECK(std::get<0>(t) == j[0]);

CHECK(std::get<1>(t) == j[1]);

// CHECK(std::get<2>(t) == j[2]); // commented out due to CI issue, see https://github.com/nlohmann/json/pull/3985 and https://github.com/nlohmann/json/issues/4025

}

SECTION("std::tuple tie")

{

const auto a = 1.0;

const auto* const b = "string";

const auto c = 42;

const auto d = std::vector<int> {0, 2};

const size_t e = 1234;

auto t = std::tie(a, b, c, d, e);

json const j(t);

double a_out = 0;

std::string b_out;

int c_out = 0;

std::vector<int> d_out;

int64_t e_out = 0;

auto t_out = std::tie(a_out, b_out, c_out, d_out, e_out);

j.get_to(t_out);

CHECK(a_out == a);

CHECK(b_out == b);

CHECK(c_out == c);

CHECK(d_out == d);

CHECK(e_out == e);

}

SECTION("std::tuple of references to elements")

{

const auto a = 1.0;

const auto* const b = "string";

const auto c = 42;

const size_t d = 1234;

const auto t = std::tie(a, b, c, d);

json const j(t);

auto t_out = j.get<std::tuple<const json::number_float_t&,

const json::string_t&,

const json::number_integer_t&,

const json::number_unsigned_t&>>();

CHECK(&std::get<0>(t_out) == j[0].get_ptr<const json::number_float_t*>());

CHECK(&std::get<1>(t_out) == j[1].get_ptr<const json::string_t*>());

CHECK(&std::get<2>(t_out) == j[2].get_ptr<const json::number_integer_t*>());

CHECK(&std::get<3>(t_out) == j[3].get_ptr<const json::number_unsigned_t*>());

CHECK(std::get<0>(t_out) == a);

CHECK(std::get<1>(t_out) == b);

CHECK(std::get<2>(t_out) == c);

CHECK(std::get<3>(t_out) == d);

}

SECTION("std::tuple mixed arithmetic types")

{

using j_float_t = json::number_float_t;

using j_int_t = json::number_integer_t;

using j_uint_t = json::number_unsigned_t;

const j_float_t a = 1.0;

const j_int_t b = 1234;

const j_uint_t c = 42;

json const j(std::tie(a, b, c, c));

auto t1 = j.get<std::tuple<j_int_t, j_uint_t, j_float_t, const j_uint_t&>>();

j_uint_t a2 = 0;

j_float_t b2 = 0;

j_int_t c2 = 0;

auto t2 = std::tie(a2, b2, c2);

j.get_to(t2);

CHECK(std::get<0>(t1) == static_cast<j_int_t>(a));

CHECK(std::get<1>(t1) == static_cast<j_uint_t>(b));

CHECK(std::get<2>(t1) == static_cast<j_float_t>(c));

// t1[3] exists only to force usage of the no-default-constructor version

CHECK(a2 == static_cast<j_uint_t>(a));

CHECK(b2 == static_cast<j_float_t>(b));

CHECK(c2 == static_cast<j_int_t>(c));

}

SECTION("std::pair/tuple/array failures")

{

json const j{1};

CHECK_THROWS_WITH_AS((j.get<std::pair<int, int>>()), "[json.exception.out_of_range.401] array index 1 is out of range", json::out_of_range&);

CHECK_THROWS_WITH_AS((j.get<std::tuple<int, int>>()), "[json.exception.out_of_range.401] array index 1 is out of range", json::out_of_range&);

CHECK_THROWS_WITH_AS((j.get<std::array<int, 3>>()), "[json.exception.out_of_range.401] array index 1 is out of range", json::out_of_range&);

}

SECTION("std::forward_list<json>")

{

std::forward_list<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

}

SECTION("std::array<json, 6>")

{

std::array<json, 6> const a {{json(1), json(1u), json(2.2), json(false), json("string"), json()}};

json const j(a);

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

const auto a2 = j.get<std::array<json, 6>>();

CHECK(a2 == a);

}

SECTION("std::valarray<int>")

{

std::valarray<int> const va = {1, 2, 3, 4, 5};

json const j(va);

CHECK(j.type() == json::value_t::array);

CHECK(j == json({1, 2, 3, 4, 5}));

auto jva = j.get<std::valarray<int>>();

CHECK(jva.size() == va.size());

for (size_t i = 0; i < jva.size(); ++i)

{

CHECK(va[i] == jva[i]);

}

}

SECTION("std::valarray<double>")

{

std::valarray<double> const va = {1.2, 2.3, 3.4, 4.5, 5.6};

json const j(va);

CHECK(j.type() == json::value_t::array);

CHECK(j == json({1.2, 2.3, 3.4, 4.5, 5.6}));

auto jva = j.get<std::valarray<double>>();

CHECK(jva.size() == va.size());

for (size_t i = 0; i < jva.size(); ++i)

{

CHECK(va[i] == jva[i]);

}

}

SECTION("std::vector<json>")

{

std::vector<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

}

SECTION("std::deque<json>")

{

std::deque<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

}

SECTION("std::set<json>")

{

std::set<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

// we cannot really check for equality here

}

SECTION("std::unordered_set<json>")

{

std::unordered_set<json> const a {json(1), json(1u), json(2.2), json(false), json("string"), json()};

json const j(a);

CHECK(j.type() == json::value_t::array);

// we cannot really check for equality here

}

SECTION("sequence container literal")

{

json const j({json(1), json(1u), json(2.2), json(false), json("string"), json()});

CHECK(j.type() == json::value_t::array);

CHECK(j == j_reference);

}

}

SECTION("create a string (explicit)")

{

SECTION("empty string")

{

json::string_t const s{};

json const j(s);

CHECK(j.type() == json::value_t::string);

}

SECTION("filled string")

{

json::string_t const s {"Hello world"};

json const j(s);

CHECK(j.type() == json::value_t::string);

}

}

SECTION("create a string (implicit)")

{

// reference string

json::string_t const s_reference {"Hello world"};

json const j_reference(s_reference);

SECTION("std::string")

{

std::string const s {"Hello world"};

json const j(s);

CHECK(j.type() == json::value_t::string);

CHECK(j == j_reference);

}

SECTION("char[]")

{

const char s[] {"Hello world"}; // NOLINT(misc-const-correctness,cppcoreguidelines-avoid-c-arrays,hicpp-avoid-c-arrays,modernize-avoid-c-arrays)

json const j(s);

CHECK(j.type() == json::value_t::string);

CHECK(j == j_reference);

}

SECTION("const char*")

{

const char* s {"Hello world"};

json const j(s);

CHECK(j.type() == json::value_t::string);

CHECK(j == j_reference);

}

SECTION("string literal")

{

json const j("Hello world");

CHECK(j.type() == json::value_t::string);

CHECK(j == j_reference);

}

}

SECTION("create a boolean (explicit)")

{

SECTION("empty boolean")

{

json::boolean_t const b{};

json const j(b);

CHECK(j.type() == json::value_t::boolean);

}

SECTION("filled boolean (true)")

{

json const j(true);

CHECK(j.type() == json::value_t::boolean);

}

SECTION("filled boolean (false)")

{

json const j(false);

CHECK(j.type() == json::value_t::boolean);

}

SECTION("from std::vector<bool>::reference")

{

std::vector<bool> v{true};

json const j(v[0]);

CHECK(std::is_same<decltype(v[0]), std::vector<bool>::reference>::value);

CHECK(j.type() == json::value_t::boolean);

}

SECTION("from std::vector<bool>::const_reference")

{

const std::vector<bool> v{true};

json const j(v[0]);

CHECK(std::is_same<decltype(v[0]), std::vector<bool>::const_reference>::value);

CHECK(j.type() == json::value_t::boolean);

}

}

SECTION("create a binary (explicit)")

{

SECTION("empty binary")

{

json::binary_t const b{};

json const j(b);

CHECK(j.type() == json::value_t::binary);

}

SECTION("filled binary")

{

json::binary_t const b({1, 2, 3});

json const j(b);

CHECK(j.type() == json::value_t::binary);

}

}

SECTION("create an integer number (explicit)")

{

SECTION("uninitialized value")

{

json::number_integer_t const n{};

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

}

SECTION("initialized value")

{

json::number_integer_t const n(42);

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

}

}

SECTION("create an integer number (implicit)")

{

// reference objects

json::number_integer_t const n_reference = 42;

json const j_reference(n_reference);

json::number_unsigned_t const n_unsigned_reference = 42;

json const j_unsigned_reference(n_unsigned_reference);

SECTION("short")

{

short const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("unsigned short")

{

unsigned short const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("int")

{

int const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("unsigned int")

{

unsigned int const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("long")

{

long const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("unsigned long")

{

unsigned long const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("long long")

{

long long const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("unsigned long long")

{

unsigned long long const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("int8_t")

{

int8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int16_t")

{

int16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int32_t")

{

int32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int64_t")

{

int64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_fast8_t")

{

int_fast8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_fast16_t")

{

int_fast16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_fast32_t")

{

int_fast32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_fast64_t")

{

int_fast64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_least8_t")

{

int_least8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_least16_t")

{

int_least16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_least32_t")

{

int_least32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("int_least64_t")

{

int_least64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("uint8_t")

{

uint8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint16_t")

{

uint16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint32_t")

{

uint32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint64_t")

{

uint64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_fast8_t")

{

uint_fast8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_fast16_t")

{

uint_fast16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_fast32_t")

{

uint_fast32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_fast64_t")

{

uint_fast64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_least8_t")

{

uint_least8_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_least16_t")

{

uint_least16_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_least32_t")

{

uint_least32_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("uint_least64_t")

{

uint_least64_t const n = 42;

json const j(n);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("integer literal without suffix")

{

json const j(42);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("integer literal with u suffix")

{

const json j(42u);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("integer literal with l suffix")

{

json const j(42L);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("integer literal with ul suffix")

{

const json j(42ul);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

SECTION("integer literal with ll suffix")

{

json const j(42LL);

CHECK(j.type() == json::value_t::number_integer);

CHECK(j == j_reference);

}

SECTION("integer literal with ull suffix")

{

const json j(42ull);

CHECK(j.type() == json::value_t::number_unsigned);

CHECK(j == j_unsigned_reference);

}

}

SECTION("create a floating-point number (explicit)")

{

SECTION("uninitialized value")

{

json::number_float_t const n{};

json const j(n);

CHECK(j.type() == json::value_t::number_float);

}

SECTION("initialized value")

{

json::number_float_t const n(42.23);

json const j(n);

CHECK(j.type() == json::value_t::number_float);

}

SECTION("NaN")

{

// NaN is stored properly, but serialized to null

json::number_float_t const n(std::numeric_limits<json::number_float_t>::quiet_NaN());

json const j(n);

CHECK(j.type() == json::value_t::number_float);

// check round trip of NaN

json::number_float_t const d{j};

CHECK((std::isnan(d) && std::isnan(n)) == true);

// check that NaN is serialized to null

CHECK(j.dump() == "null");

}

SECTION("infinity")

{

// infinity is stored properly, but serialized to null

json::number_float_t const n(std::numeric_limits<json::number_float_t>::infinity());

json const j(n);

CHECK(j.type() == json::value_t::number_float);

// check round trip of infinity

json::number_float_t const d{j};

CHECK(d == n);

// check that inf is serialized to null

CHECK(j.dump() == "null");

}

}

SECTION("create a floating-point number (implicit)")

{

// reference object

json::number_float_t const n_reference = 42.23;

json const j_reference(n_reference);

SECTION("float")

{

float const n = 42.23f;

json const j(n);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

SECTION("double")

{

double const n = 42.23;

json const j(n);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

SECTION("long double")

{

long double const n = 42.23L;

json const j(n);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

SECTION("floating-point literal without suffix")

{

json const j(42.23);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

SECTION("integer literal with f suffix")

{

json const j(42.23f);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

SECTION("integer literal with l suffix")

{

json const j(42.23L);

CHECK(j.type() == json::value_t::number_float);

CHECK(j.m_data.m_value.number_float == Approx(j_reference.m_data.m_value.number_float));

}

}

SECTION("create a container (array or object) from an initializer list")

{

SECTION("empty initializer list")

{

SECTION("explicit")

{

json const j(json::initializer_list_t {});

CHECK(j.type() == json::value_t::object);

}

SECTION("implicit")

{

json const j {};