fix: treat single-element brace-init as copy/move

ssam18 · ssam18 · commit bc6bfc32c125 · 2026-03-02T20:49:29.000-06:00
When passing a json value using brace initialization with a single element (e.g., `json j{someObj}` or `foo({someJson})`), C++ always prefers the initializer_list constructor over the copy/move constructor. This caused the value to be unexpectedly wrapped in a single-element array. This bug was previously compiler-dependent (GCC wrapped, Clang did not), but Clang 20 started matching GCC behavior, making it a universal issue. Fix: In the initializer_list constructor, when type deduction is enabled and the list has exactly one element, copy/move it directly instead of creating a single-element array. Before: json obj = {{"key", 1}}; json j{obj}; // -> [{"key":1}] (wrong: array) foo({obj}); // -> [{"key":1}] (wrong: array) After: json j{obj}; // -> {"key":1} (correct: copy) foo({obj}); // -> {"key":1} (correct: copy) To explicitly create a single-element array, use json::array({value}). Fixes the issue #5074
diff --git a/docs/mkdocs/docs/home/faq.md b/docs/mkdocs/docs/home/faq.md
@@ -20,7 +20,16 @@
 
     yield different results (`#!json [true]` vs. `#!json true`)?
 
-This is a known issue, and -- even worse -- the behavior differs between GCC and Clang. The "culprit" for this is the library's constructor overloads for initializer lists to allow syntax like
+Starting from this version, single-value brace initialization is treated as copy/move instead of wrapping in a single-element array:
+
+```cpp
+json j_orig = {{"key", "value"}};
+
+json j{j_orig};
+j_orig.method();
+```
+
+The root cause was the library's constructor overloads for initializer lists, which allow syntax like
 
 ```cpp
 json array = {1, 2, 3, 4};
@@ -32,11 +41,13 @@ for arrays and
 json object = {{"one", 1}, {"two", 2}}; 
 ```
 
-for objects.
+for objects. Because C++ always prefers `initializer_list` constructors for brace initialization, a single-element brace-init `json j{someValue}` previously wrapped the value in an array instead of copying it.
 
-!!! tip
+After the fix, a single-element brace-init behaves like copy/move initialization. To explicitly create a single-element array, use `json::array({value})`.
+
+!!! note
 
-    To avoid any confusion and ensure portable code, **do not** use brace initialization with the types `basic_json`, `json`, or `ordered_json` unless you want to create an object or array as shown in the examples above.
+The fix changes the behavior of single-element brace initialization: `json j{x}` is now equivalent to `json j(x)` (copy/move) rather than `json j = json::array({x})` (single-element array). Code relying on the old behavior should be updated to use `json::array({x})` explicitly.
 
 ## Limitations
 
diff --git a/include/nlohmann/json.hpp b/include/nlohmann/json.hpp
@@ -955,6 +955,18 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
         else
         {
+            // if there is exactly one element and type deduction is enabled,
+            // treat it as copy/move to avoid unintentionally wrapping a single
+            // json value in a single-element array
+            // (see https://github.com/nlohmann/json/issues/5074)
+            if (type_deduction && init.size() == 1)
+            {
+                *this = init.begin()->moved_or_copied();
+                set_parents();
+                assert_invariant();
+                return;
+            }
+
             // the initializer list describes an array -> create an array
             m_data.m_type = value_t::array;
             m_data.m_value.array = create<array_t>(init.begin(), init.end());
diff --git a/single_include/nlohmann/json.hpp b/single_include/nlohmann/json.hpp
@@ -21074,6 +21074,14 @@ class basic_json // NOLINT(cppcoreguidelines-special-member-functions,hicpp-spec
         }
         else
         {
+            if (type_deduction && init.size() == 1)
+            {
+                *this = init.begin()->moved_or_copied();
+                set_parents();
+                assert_invariant();
+                return;
+            }
+
             // the initializer list describes an array -> create an array
             m_data.m_type = value_t::array;
             m_data.m_value.array = create<array_t>(init.begin(), init.end());
diff --git a/tests/src/unit-class_parser.cpp b/tests/src/unit-class_parser.cpp
@@ -1506,7 +1506,7 @@ TEST_CASE("parser class")
 
             // removed all objects in array.
             CHECK (j_filtered2.size() == 1);
-            CHECK (j_filtered2 == json({1}));
+            CHECK (j_filtered2 == json::array({1}));
         }
 
         SECTION("filter specific events")
diff --git a/tests/src/unit-class_parser_diagnostic_positions.cpp b/tests/src/unit-class_parser_diagnostic_positions.cpp
@@ -1517,7 +1517,7 @@ TEST_CASE("parser class")
 
             // removed all objects in array.
             CHECK (j_filtered2.size() == 1);
-            CHECK (j_filtered2 == json({1}));
+            CHECK (j_filtered2 == json::array({1}));
         }
 
         SECTION("filter specific events")
diff --git a/tests/src/unit-constructor1.cpp b/tests/src/unit-constructor1.cpp
@@ -283,7 +283,8 @@ TEST_CASE("constructors")
 
         SECTION("std::pair/tuple/array failures")
         {
-            json const j{1};
+            // Use json::array() to explicitly create a single-element array
+            json const j = json::array({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&);
@@ -935,14 +936,18 @@ TEST_CASE("constructors")
             {
                 SECTION("explicit")
                 {
+                    // j is a copy of the empty array element, not [[]]
                     json const j(json::initializer_list_t {json(json::array_t())});
                     CHECK(j.type() == json::value_t::array);
+                    CHECK(j.empty());
                 }
 
                 SECTION("implicit")
                 {
+                    // j is a copy of the empty array element, not [[]]
                     json const j {json::array_t()};
                     CHECK(j.type() == json::value_t::array);
+                    CHECK(j.empty());
                 }
             }
 
@@ -951,13 +956,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json(json::object_t())});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::object);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {json::object_t()};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::object);
                 }
             }
 
@@ -966,13 +971,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json("Hello world")});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::string);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {"Hello world"};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::string);
                 }
             }
 
@@ -981,13 +986,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json(true)});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::boolean);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {true};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::boolean);
                 }
             }
 
@@ -996,13 +1001,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json(1)});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_integer);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {1};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_integer);
                 }
             }
 
@@ -1011,13 +1016,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json(1u)});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_unsigned);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {1u};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_unsigned);
                 }
             }
 
@@ -1026,13 +1031,13 @@ TEST_CASE("constructors")
                 SECTION("explicit")
                 {
                     json const j(json::initializer_list_t {json(42.23)});
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_float);
                 }
 
                 SECTION("implicit")
                 {
                     json const j {42.23};
-                    CHECK(j.type() == json::value_t::array);
+                    CHECK(j.type() == json::value_t::number_float);
                 }
             }
         }
@@ -1110,7 +1115,7 @@ TEST_CASE("constructors")
                     std::string source(1024, '!');
                     const auto* source_addr = source.data();
                     json j = {std::move(source)};
-                    const auto* target_addr = j[0].get_ref<std::string const&>().data();
+                    const auto* target_addr = j.get_ref<std::string const&>().data();
                     const bool success = (target_addr == source_addr);
                     CHECK(success);
                 }
@@ -1145,7 +1150,7 @@ TEST_CASE("constructors")
                     json::array_t source = {1, 2, 3};
                     const auto* source_addr = source.data();
                     json j {std::move(source)};
-                    const auto* target_addr = j[0].get_ref<json::array_t const&>().data();
+                    const auto* target_addr = j.get_ref<json::array_t const&>().data();
                     const bool success = (target_addr == source_addr);
                     CHECK(success);
                 }
@@ -1165,7 +1170,7 @@ TEST_CASE("constructors")
                     json::array_t source = {1, 2, 3};
                     const auto* source_addr = source.data();
                     json j = {std::move(source)};
-                    const auto* target_addr = j[0].get_ref<json::array_t const&>().data();
+                    const auto* target_addr = j.get_ref<json::array_t const&>().data();
                     const bool success = (target_addr == source_addr);
                     CHECK(success);
                 }
@@ -1188,7 +1193,7 @@ TEST_CASE("constructors")
                     json::object_t source = {{"hello", "world"}};
                     const json* source_addr = &source.at("hello");
                     json j {std::move(source)};
-                    CHECK(&(j[0].get_ref<json::object_t const&>().at("hello")) == source_addr);
+                    CHECK(&(j.get_ref<json::object_t const&>().at("hello")) == source_addr);
                 }
 
                 SECTION("constructor with implicit types (object)")
@@ -1204,7 +1209,7 @@ TEST_CASE("constructors")
                     json::object_t source = {{"hello", "world"}};
                     const json* source_addr = &source.at("hello");
                     json j = {std::move(source)};
-                    CHECK(&(j[0].get_ref<json::object_t const&>().at("hello")) == source_addr);
+                    CHECK(&(j.get_ref<json::object_t const&>().at("hello")) == source_addr);
                 }
 
                 SECTION("assignment with implicit types (object)")
diff --git a/tests/src/unit-modifiers.cpp b/tests/src/unit-modifiers.cpp
@@ -310,7 +310,7 @@ TEST_CASE("modifiers")
                 auto& x = j.emplace_back(3, "foo");
                 CHECK(x == json({"foo", "foo", "foo"}));
                 CHECK(j.type() == json::value_t::array);
-                CHECK(j == json({{"foo", "foo", "foo"}}));
+                CHECK(j == json::array({json({"foo", "foo", "foo"})}));
             }
         }
 
diff --git a/tests/src/unit-regression2.cpp b/tests/src/unit-regression2.cpp
@@ -844,7 +844,7 @@ TEST_CASE("regression tests 2")
         SECTION("std::tuple")
         {
             {
-                const json j = {9};
+                const json j = json::array({9});
                 auto t = j.get<std::tuple<NonDefaultConstructible>>();
                 CHECK(std::get<0>(t).x == 9);
             }
@@ -1119,6 +1119,57 @@ TEST_CASE("regression tests 2")
         CHECK((decoded == json_4804::array()));
     }
 #endif
+
+    SECTION("copy constructor changes semantics with brace initialization")
+    {
+        // object
+        {
+            json const j_obj = {{"key", "value"}, {"num", 42}};
+            json const j{j_obj};
+            CHECK(j.is_object());
+            CHECK(j == j_obj);
+        }
+
+        // array
+        {
+            json const j_arr = {1, 2, 3};
+            json const j{j_arr};
+            CHECK(j.is_array());
+            CHECK(j == j_arr);
+        }
+
+        // primitives
+        {
+            json const j_bool{true};
+            CHECK(j_bool.is_boolean());
+
+            json const j_num{42};
+            CHECK(j_num.is_number_integer());
+
+            json const j_float{3.14};
+            CHECK(j_float.is_number_float());
+
+            json const j_str{"hello"};
+            CHECK(j_str.is_string());
+        }
+
+        // passing by-value should still work correctly
+        {
+            auto receive_by_value = [](json j) { return j; };
+            json const j_obj = {{"key", "value"}};
+            json const result = receive_by_value(j_obj);
+            CHECK(result.is_object());
+            CHECK(result == j_obj);
+        }
+
+        // explicitly creating a single-element array still works via json::array()
+        {
+            json const j_arr = json::array({42});
+            CHECK(j_arr.is_array());
+            CHECK(j_arr.size() == 1);
+            CHECK(j_arr[0] == 42);
+        }
+    }
 }
 
 TEST_CASE_TEMPLATE("issue #4798 - nlohmann::json::to_msgpack() encode float NaN as double", T, double, float) // NOLINT(readability-math-missing-parentheses, bugprone-throwing-static-initialization)

Original file line number	Diff line number	Diff line change
`@@ -1506,7 +1506,7 @@ TEST_CASE("parser class")`
`1506`	`1506`
`1507`	`1507`	`// removed all objects in array.`
`1508`	`1508`	`CHECK (j_filtered2.size() == 1);`
`1509`		`- CHECK (j_filtered2 == json({1}));`
	`1509`	`+ CHECK (j_filtered2 == json::array({1}));`
`1510`	`1510`	`}`
`1511`	`1511`
`1512`	`1512`	`SECTION("filter specific events")`
Original file line number	Diff line number	Diff line change
`@@ -1517,7 +1517,7 @@ TEST_CASE("parser class")`
`1517`	`1517`
`1518`	`1518`	`// removed all objects in array.`
`1519`	`1519`	`CHECK (j_filtered2.size() == 1);`
`1520`		`- CHECK (j_filtered2 == json({1}));`
	`1520`	`+ CHECK (j_filtered2 == json::array({1}));`
`1521`	`1521`	`}`
`1522`	`1522`
`1523`	`1523`	`SECTION("filter specific events")`
Original file line number	Diff line number	Diff line change
`@@ -283,7 +283,8 @@ TEST_CASE("constructors")`
`283`	`283`
`284`	`284`	`SECTION("std::pair/tuple/array failures")`
`285`	`285`	`{`
`286`		`- json const j{1};`
	`286`	`+ // Use json::array() to explicitly create a single-element array`
	`287`	`+ json const j = json::array({1});`
`287`	`288`
`288`	`289`	`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&);`
`289`	`290`	`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&);`
`@@ -935,14 +936,18 @@ TEST_CASE("constructors")`
`935`	`936`	`{`
`936`	`937`	`SECTION("explicit")`
`937`	`938`	`{`
	`939`	`+ // j is a copy of the empty array element, not [[]]`
`938`	`940`	`json const j(json::initializer_list_t {json(json::array_t())});`
`939`	`941`	`CHECK(j.type() == json::value_t::array);`
	`942`	`+ CHECK(j.empty());`
`940`	`943`	`}`
`941`	`944`
`942`	`945`	`SECTION("implicit")`
`943`	`946`	`{`
	`947`	`+ // j is a copy of the empty array element, not [[]]`
`944`	`948`	`json const j {json::array_t()};`
`945`	`949`	`CHECK(j.type() == json::value_t::array);`
	`950`	`+ CHECK(j.empty());`
`946`	`951`	`}`
`947`	`952`	`}`
`948`	`953`
`@@ -951,13 +956,13 @@ TEST_CASE("constructors")`
`951`	`956`	`SECTION("explicit")`
`952`	`957`	`{`
`953`	`958`	`json const j(json::initializer_list_t {json(json::object_t())});`
`954`		`- CHECK(j.type() == json::value_t::array);`
	`959`	`+ CHECK(j.type() == json::value_t::object);`
`955`	`960`	`}`
`956`	`961`
`957`	`962`	`SECTION("implicit")`
`958`	`963`	`{`
`959`	`964`	`json const j {json::object_t()};`
`960`		`- CHECK(j.type() == json::value_t::array);`
	`965`	`+ CHECK(j.type() == json::value_t::object);`
`961`	`966`	`}`
`962`	`967`	`}`
`963`	`968`
`@@ -966,13 +971,13 @@ TEST_CASE("constructors")`
`966`	`971`	`SECTION("explicit")`
`967`	`972`	`{`
`968`	`973`	`json const j(json::initializer_list_t {json("Hello world")});`
`969`		`- CHECK(j.type() == json::value_t::array);`
	`974`	`+ CHECK(j.type() == json::value_t::string);`
`970`	`975`	`}`
`971`	`976`
`972`	`977`	`SECTION("implicit")`
`973`	`978`	`{`
`974`	`979`	`json const j {"Hello world"};`
`975`		`- CHECK(j.type() == json::value_t::array);`
	`980`	`+ CHECK(j.type() == json::value_t::string);`
`976`	`981`	`}`
`977`	`982`	`}`
`978`	`983`
`@@ -981,13 +986,13 @@ TEST_CASE("constructors")`
`981`	`986`	`SECTION("explicit")`
`982`	`987`	`{`
`983`	`988`	`json const j(json::initializer_list_t {json(true)});`
`984`		`- CHECK(j.type() == json::value_t::array);`
	`989`	`+ CHECK(j.type() == json::value_t::boolean);`
`985`	`990`	`}`
`986`	`991`
`987`	`992`	`SECTION("implicit")`
`988`	`993`	`{`
`989`	`994`	`json const j {true};`
`990`		`- CHECK(j.type() == json::value_t::array);`
	`995`	`+ CHECK(j.type() == json::value_t::boolean);`
`991`	`996`	`}`
`992`	`997`	`}`
`993`	`998`
`@@ -996,13 +1001,13 @@ TEST_CASE("constructors")`
`996`	`1001`	`SECTION("explicit")`
`997`	`1002`	`{`
`998`	`1003`	`json const j(json::initializer_list_t {json(1)});`
`999`		`- CHECK(j.type() == json::value_t::array);`
	`1004`	`+ CHECK(j.type() == json::value_t::number_integer);`
`1000`	`1005`	`}`
`1001`	`1006`
`1002`	`1007`	`SECTION("implicit")`
`1003`	`1008`	`{`
`1004`	`1009`	`json const j {1};`
`1005`		`- CHECK(j.type() == json::value_t::array);`
	`1010`	`+ CHECK(j.type() == json::value_t::number_integer);`
`1006`	`1011`	`}`
`1007`	`1012`	`}`
`1008`	`1013`
`@@ -1011,13 +1016,13 @@ TEST_CASE("constructors")`
`1011`	`1016`	`SECTION("explicit")`
`1012`	`1017`	`{`
`1013`	`1018`	`json const j(json::initializer_list_t {json(1u)});`
`1014`		`- CHECK(j.type() == json::value_t::array);`
	`1019`	`+ CHECK(j.type() == json::value_t::number_unsigned);`
`1015`	`1020`	`}`
`1016`	`1021`
`1017`	`1022`	`SECTION("implicit")`
`1018`	`1023`	`{`
`1019`	`1024`	`json const j {1u};`
`1020`		`- CHECK(j.type() == json::value_t::array);`
	`1025`	`+ CHECK(j.type() == json::value_t::number_unsigned);`
`1021`	`1026`	`}`
`1022`	`1027`	`}`
`1023`	`1028`
`@@ -1026,13 +1031,13 @@ TEST_CASE("constructors")`
`1026`	`1031`	`SECTION("explicit")`
`1027`	`1032`	`{`
`1028`	`1033`	`json const j(json::initializer_list_t {json(42.23)});`
`1029`		`- CHECK(j.type() == json::value_t::array);`
	`1034`	`+ CHECK(j.type() == json::value_t::number_float);`
`1030`	`1035`	`}`
`1031`	`1036`
`1032`	`1037`	`SECTION("implicit")`
`1033`	`1038`	`{`
`1034`	`1039`	`json const j {42.23};`
`1035`		`- CHECK(j.type() == json::value_t::array);`
	`1040`	`+ CHECK(j.type() == json::value_t::number_float);`
`1036`	`1041`	`}`
`1037`	`1042`	`}`
`1038`	`1043`	`}`
`@@ -1110,7 +1115,7 @@ TEST_CASE("constructors")`
`1110`	`1115`	`std::string source(1024, '!');`
`1111`	`1116`	`const auto* source_addr = source.data();`
`1112`	`1117`	`json j = {std::move(source)};`
`1113`		`- const auto* target_addr = j[0].get_ref<std::string const&>().data();`
	`1118`	`+ const auto* target_addr = j.get_ref<std::string const&>().data();`
`1114`	`1119`	`const bool success = (target_addr == source_addr);`
`1115`	`1120`	`CHECK(success);`
`1116`	`1121`	`}`
`@@ -1145,7 +1150,7 @@ TEST_CASE("constructors")`
`1145`	`1150`	`json::array_t source = {1, 2, 3};`
`1146`	`1151`	`const auto* source_addr = source.data();`
`1147`	`1152`	`json j {std::move(source)};`
`1148`		`- const auto* target_addr = j[0].get_ref<json::array_t const&>().data();`
	`1153`	`+ const auto* target_addr = j.get_ref<json::array_t const&>().data();`
`1149`	`1154`	`const bool success = (target_addr == source_addr);`
`1150`	`1155`	`CHECK(success);`
`1151`	`1156`	`}`
`@@ -1165,7 +1170,7 @@ TEST_CASE("constructors")`
`1165`	`1170`	`json::array_t source = {1, 2, 3};`
`1166`	`1171`	`const auto* source_addr = source.data();`
`1167`	`1172`	`json j = {std::move(source)};`
`1168`		`- const auto* target_addr = j[0].get_ref<json::array_t const&>().data();`
	`1173`	`+ const auto* target_addr = j.get_ref<json::array_t const&>().data();`
`1169`	`1174`	`const bool success = (target_addr == source_addr);`
`1170`	`1175`	`CHECK(success);`
`1171`	`1176`	`}`
`@@ -1188,7 +1193,7 @@ TEST_CASE("constructors")`
`1188`	`1193`	`json::object_t source = {{"hello", "world"}};`
`1189`	`1194`	`const json* source_addr = &source.at("hello");`
`1190`	`1195`	`json j {std::move(source)};`
`1191`		`- CHECK(&(j[0].get_ref<json::object_t const&>().at("hello")) == source_addr);`
	`1196`	`+ CHECK(&(j.get_ref<json::object_t const&>().at("hello")) == source_addr);`
`1192`	`1197`	`}`
`1193`	`1198`
`1194`	`1199`	`SECTION("constructor with implicit types (object)")`
`@@ -1204,7 +1209,7 @@ TEST_CASE("constructors")`
`1204`	`1209`	`json::object_t source = {{"hello", "world"}};`
`1205`	`1210`	`const json* source_addr = &source.at("hello");`
`1206`	`1211`	`json j = {std::move(source)};`
`1207`		`- CHECK(&(j[0].get_ref<json::object_t const&>().at("hello")) == source_addr);`
	`1212`	`+ CHECK(&(j.get_ref<json::object_t const&>().at("hello")) == source_addr);`
`1208`	`1213`	`}`
`1209`	`1214`
`1210`	`1215`	`SECTION("assignment with implicit types (object)")`
Original file line number	Diff line number	Diff line change
`@@ -310,7 +310,7 @@ TEST_CASE("modifiers")`
`310`	`310`	`auto& x = j.emplace_back(3, "foo");`
`311`	`311`	`CHECK(x == json({"foo", "foo", "foo"}));`
`312`	`312`	`CHECK(j.type() == json::value_t::array);`
`313`		`- CHECK(j == json({{"foo", "foo", "foo"}}));`
	`313`	`+ CHECK(j == json::array({json({"foo", "foo", "foo"})}));`
`314`	`314`	`}`
`315`	`315`	`}`
`316`	`316`