Initial commit of Arduino libraries

ArduinoJson/extras/tests/JsonArray/CMakeLists.txt

@@ -0,0 +1,25 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2025, Benoit BLANCHON
+# MIT License
+
+add_executable(JsonArrayTests
+	add.cpp
+	clear.cpp
+	compare.cpp
+	copyArray.cpp
+	equals.cpp
+	isNull.cpp
+	iterator.cpp
+	nesting.cpp
+	remove.cpp
+	size.cpp
+	subscript.cpp
+	unbound.cpp
+)
+
+add_test(JsonArray JsonArrayTests)
+
+set_tests_properties(JsonArray
+	PROPERTIES
+		LABELS "Catch"
+)

ArduinoJson/extras/tests/JsonArray/add.cpp

@@ -0,0 +1,262 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+#include "Literals.hpp"
+
+using ArduinoJson::detail::sizeofArray;
+
+TEST_CASE("JsonArray::add(T)") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+  JsonArray array = doc.to<JsonArray>();
+
+  SECTION("int") {
+    array.add(123);
+
+    REQUIRE(123 == array[0].as<int>());
+    REQUIRE(array[0].is<int>());
+    REQUIRE(array[0].is<double>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+
+  SECTION("double") {
+    array.add(123.45);
+
+    REQUIRE(123.45 == array[0].as<double>());
+    REQUIRE(array[0].is<double>());
+    REQUIRE_FALSE(array[0].is<bool>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+
+  SECTION("bool") {
+    array.add(true);
+
+    REQUIRE(array[0].as<bool>() == true);
+    REQUIRE(array[0].is<bool>());
+    REQUIRE_FALSE(array[0].is<int>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+
+  SECTION("string literal") {
+    array.add("hello");
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(array[0].is<const char*>());
+    REQUIRE(array[0].is<int>() == false);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+
+  SECTION("std::string") {
+    array.add("hello"_s);
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(array[0].is<const char*>() == true);
+    REQUIRE(array[0].is<int>() == false);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
+                         });
+  }
+
+  SECTION("const char*") {
+    const char* str = "hello";
+    array.add(str);
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(array[0].as<const char*>() != str);
+    REQUIRE(array[0].is<const char*>() == true);
+    REQUIRE(array[0].is<int>() == false);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
+                         });
+  }
+
+  SECTION("serialized(const char*)") {
+    array.add(serialized("{}"));
+
+    REQUIRE(doc.as<std::string>() == "[{}]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("{}")),
+                         });
+  }
+
+  SECTION("serialized(char*)") {
+    array.add(serialized(const_cast<char*>("{}")));
+
+    REQUIRE(doc.as<std::string>() == "[{}]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("{}")),
+                         });
+  }
+
+  SECTION("serialized(std::string)") {
+    array.add(serialized("{}"_s));
+
+    REQUIRE(doc.as<std::string>() == "[{}]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("{}")),
+                         });
+  }
+
+  SECTION("serialized(std::string)") {
+    array.add(serialized("\0XX"_s));
+
+    REQUIRE(doc.as<std::string>() == "[\0XX]"_s);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString(" XX")),
+                         });
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("vla") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    array.add(vla);
+
+    strcpy(vla, "hello");
+    REQUIRE(array[0] == "world"_s);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("hello")),
+                         });
+  }
+#endif
+
+  SECTION("nested array") {
+    JsonDocument doc2;
+    JsonArray arr = doc2.to<JsonArray>();
+
+    array.add(arr);
+
+    REQUIRE(arr == array[0].as<JsonArray>());
+    REQUIRE(array[0].is<JsonArray>());
+    REQUIRE_FALSE(array[0].is<int>());
+  }
+
+  SECTION("nested object") {
+    JsonDocument doc2;
+    JsonObject obj = doc2.to<JsonObject>();
+
+    array.add(obj);
+
+    REQUIRE(obj == array[0].as<JsonObject>());
+    REQUIRE(array[0].is<JsonObject>());
+    REQUIRE_FALSE(array[0].is<int>());
+  }
+
+  SECTION("array subscript") {
+    const char* str = "hello";
+    JsonDocument doc2;
+    JsonArray arr = doc2.to<JsonArray>();
+    arr.add(str);
+
+    array.add(arr[0]);
+
+    REQUIRE(str == array[0]);
+  }
+
+  SECTION("object subscript") {
+    const char* str = "hello";
+    JsonDocument doc2;
+    JsonObject obj = doc2.to<JsonObject>();
+    obj["x"] = str;
+
+    array.add(obj["x"]);
+
+    REQUIRE(str == array[0]);
+  }
+}
+
+TEST_CASE("JsonArray::add<T>()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+
+  SECTION("add<JsonArray>()") {
+    JsonArray nestedArray = array.add<JsonArray>();
+    nestedArray.add(1);
+    nestedArray.add(2);
+    REQUIRE(doc.as<std::string>() == "[[1,2]]");
+  }
+
+  SECTION("add<JsonObject>()") {
+    JsonObject nestedObject = array.add<JsonObject>();
+    nestedObject["a"] = 1;
+    nestedObject["b"] = 2;
+    REQUIRE(doc.as<std::string>() == "[{\"a\":1,\"b\":2}]");
+  }
+
+  SECTION("add<JsonVariant>()") {
+    JsonVariant nestedVariant = array.add<JsonVariant>();
+    nestedVariant.set(42);
+    REQUIRE(doc.as<std::string>() == "[42]");
+  }
+}
+
+TEST_CASE("JsonObject::add(JsonObject) ") {
+  JsonDocument doc1;
+  doc1["key1"_s] = "value1"_s;
+
+  TimebombAllocator allocator(10);
+  SpyingAllocator spy(&allocator);
+  JsonDocument doc2(&spy);
+  JsonArray array = doc2.to<JsonArray>();
+
+  SECTION("success") {
+    bool result = array.add(doc1.as<JsonObject>());
+
+    REQUIRE(result == true);
+    REQUIRE(doc2.as<std::string>() == "[{\"key1\":\"value1\"}]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("key1")),
+                             Allocate(sizeofString("value1")),
+                         });
+  }
+
+  SECTION("partial failure") {  // issue #2081
+    allocator.setCountdown(2);
+
+    bool result = array.add(doc1.as<JsonObject>());
+
+    REQUIRE(result == false);
+    REQUIRE(doc2.as<std::string>() == "[]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("key1")),
+                             AllocateFail(sizeofString("value1")),
+                             Deallocate(sizeofString("key1")),
+                         });
+  }
+
+  SECTION("complete failure") {
+    allocator.setCountdown(0);
+
+    bool result = array.add(doc1.as<JsonObject>());
+
+    REQUIRE(result == false);
+    REQUIRE(doc2.as<std::string>() == "[]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             AllocateFail(sizeofPool()),
+                         });
+  }
+}

ArduinoJson/extras/tests/JsonArray/clear.cpp

@@ -0,0 +1,46 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+
+TEST_CASE("JsonArray::clear()") {
+  SECTION("No-op on null JsonArray") {
+    JsonArray array;
+    array.clear();
+    REQUIRE(array.isNull() == true);
+    REQUIRE(array.size() == 0);
+  }
+
+  SECTION("Removes all elements") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add(2);
+    array.clear();
+    REQUIRE(array.size() == 0);
+    REQUIRE(array.isNull() == false);
+  }
+
+  SECTION("Removed elements are recycled") {
+    SpyingAllocator spy;
+    JsonDocument doc(&spy);
+    JsonArray array = doc.to<JsonArray>();
+
+    // fill the pool entirely
+    for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)
+      array.add(i);
+
+    // clear and fill again
+    array.clear();
+    for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)
+      array.add(i);
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+}

ArduinoJson/extras/tests/JsonArray/compare.cpp

@@ -0,0 +1,512 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("Compare JsonArray with JsonArray") {
+  JsonDocument doc;
+
+  SECTION("Compare with unbound") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonArray unbound;
+
+    CHECK(array != unbound);
+    CHECK_FALSE(array == unbound);
+    CHECK_FALSE(array <= unbound);
+    CHECK_FALSE(array >= unbound);
+    CHECK_FALSE(array > unbound);
+    CHECK_FALSE(array < unbound);
+
+    CHECK(unbound != array);
+    CHECK_FALSE(unbound == array);
+    CHECK_FALSE(unbound <= array);
+    CHECK_FALSE(unbound >= array);
+    CHECK_FALSE(unbound > array);
+    CHECK_FALSE(unbound < array);
+  }
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+
+    CHECK(array == array);
+    CHECK(array <= array);
+    CHECK(array >= array);
+    CHECK_FALSE(array != array);
+    CHECK_FALSE(array > array);
+    CHECK_FALSE(array < array);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello");
+    array1.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello");
+    array2.add<JsonObject>();
+
+    CHECK(array1 == array2);
+    CHECK(array1 <= array2);
+    CHECK(array1 >= array2);
+    CHECK_FALSE(array1 != array2);
+    CHECK_FALSE(array1 > array2);
+    CHECK_FALSE(array1 < array2);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello1");
+    array1.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello2");
+    array2.add<JsonObject>();
+
+    CHECK(array1 != array2);
+    CHECK_FALSE(array1 == array2);
+    CHECK_FALSE(array1 > array2);
+    CHECK_FALSE(array1 < array2);
+    CHECK_FALSE(array1 <= array2);
+    CHECK_FALSE(array1 >= array2);
+  }
+}
+
+TEST_CASE("Compare JsonArray with JsonVariant") {
+  JsonDocument doc;
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+
+    JsonVariant variant = array;
+
+    CHECK(array == variant);
+    CHECK(array <= variant);
+    CHECK(array >= variant);
+    CHECK_FALSE(array != variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+
+    CHECK(variant == array);
+    CHECK(variant <= array);
+    CHECK(variant >= array);
+    CHECK_FALSE(variant != array);
+    CHECK_FALSE(variant > array);
+    CHECK_FALSE(variant < array);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array = doc.add<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    array.add<JsonObject>();
+
+    JsonVariant variant = doc.add<JsonArray>();
+    variant.add(1);
+    variant.add("hello");
+    variant.add<JsonObject>();
+
+    CHECK(array == variant);
+    CHECK(array <= variant);
+    CHECK(array >= variant);
+    CHECK_FALSE(array != variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+
+    CHECK(variant == array);
+    CHECK(variant <= array);
+    CHECK(variant >= array);
+    CHECK_FALSE(variant != array);
+    CHECK_FALSE(variant > array);
+    CHECK_FALSE(variant < array);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array = doc.add<JsonArray>();
+    array.add(1);
+    array.add("hello1");
+    array.add<JsonObject>();
+
+    JsonVariant variant = doc.add<JsonArray>();
+    variant.add(1);
+    variant.add("hello2");
+    variant.add<JsonObject>();
+
+    CHECK(array != variant);
+    CHECK_FALSE(array == variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+    CHECK_FALSE(array <= variant);
+    CHECK_FALSE(array >= variant);
+  }
+}
+
+TEST_CASE("Compare JsonArray with JsonVariantConst") {
+  JsonDocument doc;
+
+  SECTION("Compare with unbound") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonVariantConst unbound;
+
+    CHECK(array != unbound);
+    CHECK_FALSE(array == unbound);
+    CHECK_FALSE(array <= unbound);
+    CHECK_FALSE(array >= unbound);
+    CHECK_FALSE(array > unbound);
+    CHECK_FALSE(array < unbound);
+
+    CHECK(unbound != array);
+    CHECK_FALSE(unbound == array);
+    CHECK_FALSE(unbound <= array);
+    CHECK_FALSE(unbound >= array);
+    CHECK_FALSE(unbound > array);
+    CHECK_FALSE(unbound < array);
+  }
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+
+    JsonVariantConst variant = array;
+
+    CHECK(array == variant);
+    CHECK(array <= variant);
+    CHECK(array >= variant);
+    CHECK_FALSE(array != variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+
+    CHECK(variant == array);
+    CHECK(variant <= array);
+    CHECK(variant >= array);
+    CHECK_FALSE(variant != array);
+    CHECK_FALSE(variant > array);
+    CHECK_FALSE(variant < array);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array = doc.add<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    array.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello");
+    array2.add<JsonObject>();
+    JsonVariantConst variant = array2;
+
+    CHECK(array == variant);
+    CHECK(array <= variant);
+    CHECK(array >= variant);
+    CHECK_FALSE(array != variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+
+    CHECK(variant == array);
+    CHECK(variant <= array);
+    CHECK(variant >= array);
+    CHECK_FALSE(variant != array);
+    CHECK_FALSE(variant > array);
+    CHECK_FALSE(variant < array);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array = doc.add<JsonArray>();
+    array.add(1);
+    array.add("hello1");
+    array.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello2");
+    array2.add<JsonObject>();
+    JsonVariantConst variant = array2;
+
+    CHECK(array != variant);
+    CHECK_FALSE(array == variant);
+    CHECK_FALSE(array > variant);
+    CHECK_FALSE(array < variant);
+    CHECK_FALSE(array <= variant);
+    CHECK_FALSE(array >= variant);
+  }
+}
+
+TEST_CASE("Compare JsonArray with JsonArrayConst") {
+  JsonDocument doc;
+
+  SECTION("Compare with unbound") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonArrayConst unbound;
+
+    CHECK(array != unbound);
+    CHECK_FALSE(array == unbound);
+    CHECK_FALSE(array <= unbound);
+    CHECK_FALSE(array >= unbound);
+    CHECK_FALSE(array > unbound);
+    CHECK_FALSE(array < unbound);
+
+    CHECK(unbound != array);
+    CHECK_FALSE(unbound == array);
+    CHECK_FALSE(unbound <= array);
+    CHECK_FALSE(unbound >= array);
+    CHECK_FALSE(unbound > array);
+    CHECK_FALSE(unbound < array);
+  }
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonArrayConst carray = array;
+
+    CHECK(array == carray);
+    CHECK(array <= carray);
+    CHECK(array >= carray);
+    CHECK_FALSE(array != carray);
+    CHECK_FALSE(array > carray);
+    CHECK_FALSE(array < carray);
+
+    CHECK(carray == array);
+    CHECK(carray <= array);
+    CHECK(carray >= array);
+    CHECK_FALSE(carray != array);
+    CHECK_FALSE(carray > array);
+    CHECK_FALSE(carray < array);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello");
+    array1.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello");
+    array2.add<JsonObject>();
+    JsonArrayConst carray2 = array2;
+
+    CHECK(array1 == carray2);
+    CHECK(array1 <= carray2);
+    CHECK(array1 >= carray2);
+    CHECK_FALSE(array1 != carray2);
+    CHECK_FALSE(array1 > carray2);
+    CHECK_FALSE(array1 < carray2);
+
+    CHECK(carray2 == array1);
+    CHECK(carray2 <= array1);
+    CHECK(carray2 >= array1);
+    CHECK_FALSE(carray2 != array1);
+    CHECK_FALSE(carray2 > array1);
+    CHECK_FALSE(carray2 < array1);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello1");
+    array1.add<JsonObject>();
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello2");
+    array2.add<JsonObject>();
+    JsonArrayConst carray2 = array2;
+
+    CHECK(array1 != carray2);
+    CHECK_FALSE(array1 == carray2);
+    CHECK_FALSE(array1 > carray2);
+    CHECK_FALSE(array1 < carray2);
+    CHECK_FALSE(array1 <= carray2);
+    CHECK_FALSE(array1 >= carray2);
+
+    CHECK(carray2 != array1);
+    CHECK_FALSE(carray2 == array1);
+    CHECK_FALSE(carray2 > array1);
+    CHECK_FALSE(carray2 < array1);
+    CHECK_FALSE(carray2 <= array1);
+    CHECK_FALSE(carray2 >= array1);
+  }
+}
+
+TEST_CASE("Compare JsonArrayConst with JsonArrayConst") {
+  JsonDocument doc;
+
+  SECTION("Compare with unbound") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+
+    JsonArrayConst carray = array;
+    JsonArrayConst unbound;
+
+    CHECK(carray != unbound);
+    CHECK_FALSE(carray == unbound);
+    CHECK_FALSE(carray <= unbound);
+    CHECK_FALSE(carray >= unbound);
+    CHECK_FALSE(carray > unbound);
+    CHECK_FALSE(carray < unbound);
+
+    CHECK(unbound != carray);
+    CHECK_FALSE(unbound == carray);
+    CHECK_FALSE(unbound <= carray);
+    CHECK_FALSE(unbound >= carray);
+    CHECK_FALSE(unbound > carray);
+    CHECK_FALSE(unbound < carray);
+  }
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonArrayConst carray = array;
+
+    CHECK(carray == carray);
+    CHECK(carray <= carray);
+    CHECK(carray >= carray);
+    CHECK_FALSE(carray != carray);
+    CHECK_FALSE(carray > carray);
+    CHECK_FALSE(carray < carray);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello");
+    array1.add<JsonObject>();
+    JsonArrayConst carray1 = array1;
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello");
+    array2.add<JsonObject>();
+    JsonArrayConst carray2 = array2;
+
+    CHECK(carray1 == carray2);
+    CHECK(carray1 <= carray2);
+    CHECK(carray1 >= carray2);
+    CHECK_FALSE(carray1 != carray2);
+    CHECK_FALSE(carray1 > carray2);
+    CHECK_FALSE(carray1 < carray2);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello1");
+    array1.add<JsonObject>();
+    JsonArrayConst carray1 = array1;
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello2");
+    array2.add<JsonObject>();
+    JsonArrayConst carray2 = array2;
+
+    CHECK(carray1 != carray2);
+    CHECK_FALSE(carray1 == carray2);
+    CHECK_FALSE(carray1 > carray2);
+    CHECK_FALSE(carray1 < carray2);
+    CHECK_FALSE(carray1 <= carray2);
+    CHECK_FALSE(carray1 >= carray2);
+  }
+}
+
+TEST_CASE("Compare JsonArrayConst with JsonVariant") {
+  JsonDocument doc;
+
+  SECTION("Compare with self") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add(1);
+    array.add("hello");
+    JsonArrayConst carray = array;
+    JsonVariant variant = array;
+
+    CHECK(carray == variant);
+    CHECK(carray <= variant);
+    CHECK(carray >= variant);
+    CHECK_FALSE(carray != variant);
+    CHECK_FALSE(carray > variant);
+    CHECK_FALSE(carray < variant);
+
+    CHECK(variant == carray);
+    CHECK(variant <= carray);
+    CHECK(variant >= carray);
+    CHECK_FALSE(variant != carray);
+    CHECK_FALSE(variant > carray);
+    CHECK_FALSE(variant < carray);
+  }
+
+  SECTION("Compare with identical array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello");
+    array1.add<JsonObject>();
+    JsonArrayConst carray1 = array1;
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello");
+    array2.add<JsonObject>();
+    JsonVariant variant2 = array2;
+
+    CHECK(carray1 == variant2);
+    CHECK(carray1 <= variant2);
+    CHECK(carray1 >= variant2);
+    CHECK_FALSE(carray1 != variant2);
+    CHECK_FALSE(carray1 > variant2);
+    CHECK_FALSE(carray1 < variant2);
+
+    CHECK(variant2 == carray1);
+    CHECK(variant2 <= carray1);
+    CHECK(variant2 >= carray1);
+    CHECK_FALSE(variant2 != carray1);
+    CHECK_FALSE(variant2 > carray1);
+    CHECK_FALSE(variant2 < carray1);
+  }
+
+  SECTION("Compare with different array") {
+    JsonArray array1 = doc.add<JsonArray>();
+    array1.add(1);
+    array1.add("hello1");
+    array1.add<JsonObject>();
+    JsonArrayConst carray1 = array1;
+
+    JsonArray array2 = doc.add<JsonArray>();
+    array2.add(1);
+    array2.add("hello2");
+    array2.add<JsonObject>();
+    JsonVariant variant2 = array2;
+
+    CHECK(carray1 != variant2);
+    CHECK_FALSE(carray1 == variant2);
+    CHECK_FALSE(carray1 > variant2);
+    CHECK_FALSE(carray1 < variant2);
+    CHECK_FALSE(carray1 <= variant2);
+    CHECK_FALSE(carray1 >= variant2);
+
+    CHECK(variant2 != carray1);
+    CHECK_FALSE(variant2 == carray1);
+    CHECK_FALSE(variant2 > carray1);
+    CHECK_FALSE(variant2 < carray1);
+    CHECK_FALSE(variant2 <= carray1);
+    CHECK_FALSE(variant2 >= carray1);
+  }
+}

ArduinoJson/extras/tests/JsonArray/copyArray.cpp

@@ -0,0 +1,335 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+#include "Literals.hpp"
+
+TEST_CASE("copyArray()") {
+  SECTION("int[] -> JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    char json[32];
+    int source[] = {1, 2, 3};
+
+    bool ok = copyArray(source, array);
+    CHECK(ok);
+
+    serializeJson(array, json);
+    CHECK("[1,2,3]"_s == json);
+  }
+
+  SECTION("std::string[] -> JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    char json[32];
+    std::string source[] = {"a", "b", "c"};
+
+    bool ok = copyArray(source, array);
+    CHECK(ok);
+
+    serializeJson(array, json);
+    CHECK("[\"a\",\"b\",\"c\"]"_s == json);
+  }
+
+  SECTION("const char*[] -> JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    char json[32];
+    const char* source[] = {"a", "b", "c"};
+
+    bool ok = copyArray(source, array);
+    CHECK(ok);
+
+    serializeJson(array, json);
+    CHECK("[\"a\",\"b\",\"c\"]"_s == json);
+  }
+
+  SECTION("const char[][] -> JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    char json[32];
+    char source[][2] = {"a", "b", "c"};
+
+    bool ok = copyArray(source, array);
+    CHECK(ok);
+
+    serializeJson(array, json);
+    CHECK("[\"a\",\"b\",\"c\"]"_s == json);
+  }
+
+  SECTION("const char[][] -> JsonDocument") {
+    JsonDocument doc;
+    char json[32];
+    char source[][2] = {"a", "b", "c"};
+
+    bool ok = copyArray(source, doc);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("[\"a\",\"b\",\"c\"]"_s == json);
+  }
+
+  SECTION("const char[][] -> MemberProxy") {
+    JsonDocument doc;
+    char json[32];
+    char source[][2] = {"a", "b", "c"};
+
+    bool ok = copyArray(source, doc["data"]);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("{\"data\":[\"a\",\"b\",\"c\"]}"_s == json);
+  }
+
+  SECTION("int[] -> JsonDocument") {
+    JsonDocument doc;
+    char json[32];
+    int source[] = {1, 2, 3};
+
+    bool ok = copyArray(source, doc);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("[1,2,3]"_s == json);
+  }
+
+  SECTION("int[] -> MemberProxy") {
+    JsonDocument doc;
+    char json[32];
+    int source[] = {1, 2, 3};
+
+    bool ok = copyArray(source, doc["data"]);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("{\"data\":[1,2,3]}"_s == json);
+  }
+
+  SECTION("int[] -> JsonArray, but not enough memory") {
+    JsonDocument doc(FailingAllocator::instance());
+    JsonArray array = doc.to<JsonArray>();
+    int source[] = {1, 2, 3};
+
+    bool ok = copyArray(source, array);
+    REQUIRE_FALSE(ok);
+  }
+
+  SECTION("int[][] -> JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    char json[32];
+    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+    bool ok = copyArray(source, array);
+    CHECK(ok);
+
+    serializeJson(array, json);
+    CHECK("[[1,2,3],[4,5,6]]"_s == json);
+  }
+
+  SECTION("int[][] -> MemberProxy") {
+    JsonDocument doc;
+    char json[32];
+    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+    bool ok = copyArray(source, doc["data"]);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("{\"data\":[[1,2,3],[4,5,6]]}"_s == json);
+  }
+
+  SECTION("int[][] -> JsonDocument") {
+    JsonDocument doc;
+    char json[32];
+    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+    bool ok = copyArray(source, doc);
+    CHECK(ok);
+
+    serializeJson(doc, json);
+    CHECK("[[1,2,3],[4,5,6]]"_s == json);
+  }
+
+  SECTION("int[][] -> JsonArray, but not enough memory") {
+    JsonDocument doc(FailingAllocator::instance());
+    JsonArray array = doc.to<JsonArray>();
+    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
+
+    bool ok = copyArray(source, array);
+    REQUIRE(ok == false);
+  }
+
+  SECTION("JsonArray -> int[], with more space than needed") {
+    JsonDocument doc;
+    char json[] = "[1,2,3]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+    JsonArray array = doc.as<JsonArray>();
+
+    int destination[4] = {0};
+    size_t result = copyArray(array, destination);
+
+    CHECK(3 == result);
+    CHECK(1 == destination[0]);
+    CHECK(2 == destination[1]);
+    CHECK(3 == destination[2]);
+    CHECK(0 == destination[3]);
+  }
+
+  SECTION("JsonArray -> int[], without enough space") {
+    JsonDocument doc;
+    char json[] = "[1,2,3]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+    JsonArray array = doc.as<JsonArray>();
+
+    int destination[2] = {0};
+    size_t result = copyArray(array, destination);
+
+    CHECK(2 == result);
+    CHECK(1 == destination[0]);
+    CHECK(2 == destination[1]);
+  }
+
+  SECTION("JsonArray -> std::string[]") {
+    JsonDocument doc;
+    char json[] = "[\"a\",\"b\",\"c\"]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+    JsonArray array = doc.as<JsonArray>();
+
+    std::string destination[4];
+    size_t result = copyArray(array, destination);
+
+    CHECK(3 == result);
+    CHECK("a" == destination[0]);
+    CHECK("b" == destination[1]);
+    CHECK("c" == destination[2]);
+    CHECK("" == destination[3]);
+  }
+
+  SECTION("JsonArray -> char[N][]") {
+    JsonDocument doc;
+    char json[] = "[\"a12345\",\"b123456\",\"c1234567\"]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+    JsonArray array = doc.as<JsonArray>();
+
+    char destination[4][8] = {{0}};
+    size_t result = copyArray(array, destination);
+
+    CHECK(3 == result);
+    CHECK("a12345"_s == destination[0]);
+    CHECK("b123456"_s == destination[1]);
+    CHECK("c123456"_s == destination[2]);  // truncated
+    CHECK(std::string("") == destination[3]);
+  }
+
+  SECTION("JsonDocument -> int[]") {
+    JsonDocument doc;
+    char json[] = "[1,2,3]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+
+    int destination[4] = {0};
+    size_t result = copyArray(doc, destination);
+
+    CHECK(3 == result);
+    CHECK(1 == destination[0]);
+    CHECK(2 == destination[1]);
+    CHECK(3 == destination[2]);
+    CHECK(0 == destination[3]);
+  }
+
+  SECTION("MemberProxy -> int[]") {
+    JsonDocument doc;
+    char json[] = "{\"data\":[1,2,3]}";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+
+    int destination[4] = {0};
+    size_t result = copyArray(doc["data"], destination);
+
+    CHECK(3 == result);
+    CHECK(1 == destination[0]);
+    CHECK(2 == destination[1]);
+    CHECK(3 == destination[2]);
+    CHECK(0 == destination[3]);
+  }
+
+  SECTION("ElementProxy -> int[]") {
+    JsonDocument doc;
+    char json[] = "[[1,2,3]]";
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+
+    int destination[4] = {0};
+    size_t result = copyArray(doc[0], destination);
+
+    CHECK(3 == result);
+    CHECK(1 == destination[0]);
+    CHECK(2 == destination[1]);
+    CHECK(3 == destination[2]);
+    CHECK(0 == destination[3]);
+  }
+
+  SECTION("JsonArray -> int[][]") {
+    JsonDocument doc;
+    char json[] = "[[1,2],[3],[4]]";
+
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+    JsonArray array = doc.as<JsonArray>();
+
+    int destination[3][2] = {{0}};
+    copyArray(array, destination);
+
+    CHECK(1 == destination[0][0]);
+    CHECK(2 == destination[0][1]);
+    CHECK(3 == destination[1][0]);
+    CHECK(0 == destination[1][1]);
+    CHECK(4 == destination[2][0]);
+    CHECK(0 == destination[2][1]);
+  }
+
+  SECTION("JsonDocument -> int[][]") {
+    JsonDocument doc;
+    char json[] = "[[1,2],[3],[4]]";
+
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+
+    int destination[3][2] = {{0}};
+    copyArray(doc, destination);
+
+    CHECK(1 == destination[0][0]);
+    CHECK(2 == destination[0][1]);
+    CHECK(3 == destination[1][0]);
+    CHECK(0 == destination[1][1]);
+    CHECK(4 == destination[2][0]);
+    CHECK(0 == destination[2][1]);
+  }
+
+  SECTION("MemberProxy -> int[][]") {
+    JsonDocument doc;
+    char json[] = "{\"data\":[[1,2],[3],[4]]}";
+
+    DeserializationError err = deserializeJson(doc, json);
+    CHECK(err == DeserializationError::Ok);
+
+    int destination[3][2] = {{0}};
+    copyArray(doc["data"], destination);
+
+    CHECK(1 == destination[0][0]);
+    CHECK(2 == destination[0][1]);
+    CHECK(3 == destination[1][0]);
+    CHECK(0 == destination[1][1]);
+    CHECK(4 == destination[2][0]);
+    CHECK(0 == destination[2][1]);
+  }
+}

ArduinoJson/extras/tests/JsonArray/equals.cpp

@@ -0,0 +1,63 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::operator==()") {
+  JsonDocument doc1;
+  JsonArray array1 = doc1.to<JsonArray>();
+
+  JsonDocument doc2;
+  JsonArray array2 = doc2.to<JsonArray>();
+
+  SECTION("should return false when arrays differ") {
+    array1.add("coucou");
+    array2.add(1);
+
+    REQUIRE_FALSE(array1 == array2);
+  }
+
+  SECTION("should return false when LHS has more elements") {
+    array1.add(1);
+    array1.add(2);
+    array2.add(1);
+
+    REQUIRE_FALSE(array1 == array2);
+  }
+
+  SECTION("should return false when RHS has more elements") {
+    array1.add(1);
+    array2.add(1);
+    array2.add(2);
+
+    REQUIRE_FALSE(array1 == array2);
+  }
+
+  SECTION("should return true when arrays equal") {
+    array1.add("coucou");
+    array2.add("coucou");
+
+    REQUIRE(array1 == array2);
+  }
+
+  SECTION("should return false when RHS is null") {
+    JsonArray null;
+
+    REQUIRE_FALSE(array1 == null);
+  }
+
+  SECTION("should return false when LHS is null") {
+    JsonArray null;
+
+    REQUIRE_FALSE(null == array1);
+  }
+
+  SECTION("should return true when both are null") {
+    JsonArray null1;
+    JsonArray null2;
+
+    REQUIRE(null1 == null2);
+  }
+}

ArduinoJson/extras/tests/JsonArray/isNull.cpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::isNull()") {
+  SECTION("returns true") {
+    JsonArray arr;
+    REQUIRE(arr.isNull() == true);
+  }
+
+  SECTION("returns false") {
+    JsonDocument doc;
+    JsonArray arr = doc.to<JsonArray>();
+    REQUIRE(arr.isNull() == false);
+  }
+}
+
+TEST_CASE("JsonArray::operator bool()") {
+  SECTION("returns false") {
+    JsonArray arr;
+    REQUIRE(static_cast<bool>(arr) == false);
+  }
+
+  SECTION("returns true") {
+    JsonDocument doc;
+    JsonArray arr = doc.to<JsonArray>();
+    REQUIRE(static_cast<bool>(arr) == true);
+  }
+}

ArduinoJson/extras/tests/JsonArray/iterator.cpp

@@ -0,0 +1,34 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::begin()/end()") {
+  SECTION("Non null JsonArray") {
+    JsonDocument doc;
+    JsonArray array = doc.to<JsonArray>();
+    array.add(12);
+    array.add(34);
+
+    auto it = array.begin();
+    auto end = array.end();
+
+    REQUIRE(end != it);
+    REQUIRE(12 == it->as<int>());
+    REQUIRE(12 == static_cast<int>(*it));
+    ++it;
+    REQUIRE(end != it);
+    REQUIRE(34 == it->as<int>());
+    REQUIRE(34 == static_cast<int>(*it));
+    ++it;
+    REQUIRE(end == it);
+  }
+
+  SECTION("Null JsonArray") {
+    JsonArray array;
+
+    REQUIRE(array.begin() == array.end());
+  }
+}

ArduinoJson/extras/tests/JsonArray/nesting.cpp

@@ -0,0 +1,35 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::nesting()") {
+  JsonDocument doc;
+  JsonArray arr = doc.to<JsonArray>();
+
+  SECTION("return 0 if uninitialized") {
+    JsonArray unitialized;
+    REQUIRE(unitialized.nesting() == 0);
+  }
+
+  SECTION("returns 1 for empty array") {
+    REQUIRE(arr.nesting() == 1);
+  }
+
+  SECTION("returns 1 for flat array") {
+    arr.add("hello");
+    REQUIRE(arr.nesting() == 1);
+  }
+
+  SECTION("returns 2 with nested array") {
+    arr.add<JsonArray>();
+    REQUIRE(arr.nesting() == 2);
+  }
+
+  SECTION("returns 2 with nested object") {
+    arr.add<JsonObject>();
+    REQUIRE(arr.nesting() == 2);
+  }
+}

ArduinoJson/extras/tests/JsonArray/remove.cpp

@@ -0,0 +1,126 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+
+TEST_CASE("JsonArray::remove()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+  array.add(1);
+  array.add(2);
+  array.add(3);
+
+  SECTION("remove first by index") {
+    array.remove(0);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 2);
+    REQUIRE(array[1] == 3);
+  }
+
+  SECTION("remove middle by index") {
+    array.remove(1);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 3);
+  }
+
+  SECTION("remove last by index") {
+    array.remove(2);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 2);
+  }
+
+  SECTION("remove first by iterator") {
+    JsonArray::iterator it = array.begin();
+    array.remove(it);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 2);
+    REQUIRE(array[1] == 3);
+  }
+
+  SECTION("remove middle by iterator") {
+    JsonArray::iterator it = array.begin();
+    ++it;
+    array.remove(it);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 3);
+  }
+
+  SECTION("remove last bty iterator") {
+    JsonArray::iterator it = array.begin();
+    ++it;
+    ++it;
+    array.remove(it);
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 2);
+  }
+
+  SECTION("remove end()") {
+    array.remove(array.end());
+
+    REQUIRE(3 == array.size());
+  }
+
+  SECTION("In a loop") {
+    for (JsonArray::iterator it = array.begin(); it != array.end(); ++it) {
+      if (*it == 2)
+        array.remove(it);
+    }
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 3);
+  }
+
+  SECTION("remove by index on unbound reference") {
+    JsonArray unboundArray;
+    unboundArray.remove(20);
+  }
+
+  SECTION("remove by iterator on unbound reference") {
+    JsonArray unboundArray;
+    unboundArray.remove(unboundArray.begin());
+  }
+
+  SECTION("use JsonVariant as index") {
+    array.remove(array[3]);  // no effect with null variant
+    array.remove(array[0]);  // remove element at index 1
+
+    REQUIRE(2 == array.size());
+    REQUIRE(array[0] == 1);
+    REQUIRE(array[1] == 3);
+  }
+}
+
+TEST_CASE("Removed elements are recycled") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+  JsonArray array = doc.to<JsonArray>();
+
+  // fill the pool entirely
+  for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)
+    array.add(i);
+
+  // free one slot in the pool
+  array.remove(0);
+
+  // add one element; it should use the free slot
+  array.add(42);
+
+  REQUIRE(spy.log() == AllocatorLog{
+                           Allocate(sizeofPool()),  // only one pool
+                       });
+}

ArduinoJson/extras/tests/JsonArray/size.cpp

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::size()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+
+  SECTION("returns 0 is empty") {
+    REQUIRE(0U == array.size());
+  }
+
+  SECTION("increases after add()") {
+    array.add("hello");
+    REQUIRE(1U == array.size());
+
+    array.add("world");
+    REQUIRE(2U == array.size());
+  }
+
+  SECTION("remains the same after replacing an element") {
+    array.add("hello");
+    REQUIRE(1U == array.size());
+
+    array[0] = "hello";
+    REQUIRE(1U == array.size());
+  }
+}

ArduinoJson/extras/tests/JsonArray/subscript.cpp

@@ -0,0 +1,171 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+#include "Literals.hpp"
+
+TEST_CASE("JsonArray::operator[]") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+  JsonArray array = doc.to<JsonArray>();
+
+  SECTION("Pad with null") {
+    array[2] = 2;
+    array[5] = 5;
+    REQUIRE(array.size() == 6);
+    REQUIRE(array[0].isNull() == true);
+    REQUIRE(array[1].isNull() == true);
+    REQUIRE(array[2].isNull() == false);
+    REQUIRE(array[3].isNull() == true);
+    REQUIRE(array[4].isNull() == true);
+    REQUIRE(array[5].isNull() == false);
+    REQUIRE(array[2] == 2);
+    REQUIRE(array[5] == 5);
+  }
+
+  SECTION("int") {
+    array[0] = 123;
+    REQUIRE(123 == array[0].as<int>());
+    REQUIRE(true == array[0].is<int>());
+    REQUIRE(false == array[0].is<bool>());
+  }
+
+#if ARDUINOJSON_USE_LONG_LONG
+  SECTION("long long") {
+    array[0] = 9223372036854775807;
+    REQUIRE(9223372036854775807 == array[0].as<int64_t>());
+    REQUIRE(true == array[0].is<int64_t>());
+    REQUIRE(false == array[0].is<int32_t>());
+    REQUIRE(false == array[0].is<bool>());
+  }
+#endif
+
+  SECTION("double") {
+    array[0] = 123.45;
+    REQUIRE(123.45 == array[0].as<double>());
+    REQUIRE(true == array[0].is<double>());
+    REQUIRE(false == array[0].is<int>());
+  }
+
+  SECTION("bool") {
+    array[0] = true;
+    REQUIRE(true == array[0].as<bool>());
+    REQUIRE(true == array[0].is<bool>());
+    REQUIRE(false == array[0].is<int>());
+  }
+
+  SECTION("string literal") {
+    array[0] = "hello";
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(true == array[0].is<const char*>());
+    REQUIRE(false == array[0].is<int>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("const char*") {
+    const char* str = "hello";
+    array[0] = str;
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(true == array[0].is<const char*>());
+    REQUIRE(false == array[0].is<int>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("std::string") {
+    array[0] = "hello"_s;
+
+    REQUIRE(array[0].as<std::string>() == "hello");
+    REQUIRE(true == array[0].is<const char*>());
+    REQUIRE(false == array[0].is<int>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("VLA") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    array.add("hello");
+    array[0] = vla;
+
+    REQUIRE(array[0] == "world"_s);
+  }
+#endif
+
+  SECTION("nested array") {
+    JsonDocument doc2;
+    JsonArray arr2 = doc2.to<JsonArray>();
+
+    array[0] = arr2;
+
+    REQUIRE(arr2 == array[0].as<JsonArray>());
+    REQUIRE(true == array[0].is<JsonArray>());
+    REQUIRE(false == array[0].is<int>());
+  }
+
+  SECTION("nested object") {
+    JsonDocument doc2;
+    JsonObject obj = doc2.to<JsonObject>();
+
+    array[0] = obj;
+
+    REQUIRE(obj == array[0].as<JsonObject>());
+    REQUIRE(true == array[0].is<JsonObject>());
+    REQUIRE(false == array[0].is<int>());
+  }
+
+  SECTION("array subscript") {
+    JsonDocument doc2;
+    JsonArray arr2 = doc2.to<JsonArray>();
+    const char* str = "hello";
+
+    arr2.add(str);
+
+    array[0] = arr2[0];
+
+    REQUIRE(str == array[0]);
+  }
+
+  SECTION("object subscript") {
+    const char* str = "hello";
+    JsonDocument doc2;
+    JsonObject obj = doc2.to<JsonObject>();
+
+    obj["x"] = str;
+
+    array[0] = obj["x"];
+
+    REQUIRE(str == array[0]);
+  }
+
+  SECTION("array[0].to<JsonObject>()") {
+    JsonObject obj = array[0].to<JsonObject>();
+    REQUIRE(obj.isNull() == false);
+  }
+
+  SECTION("Use a JsonVariant as index") {
+    array[0] = 1;
+    array[1] = 2;
+    array[2] = 3;
+
+    REQUIRE(array[array[1]] == 3);
+    REQUIRE(array[array[3]] == nullptr);
+  }
+}

ArduinoJson/extras/tests/JsonArray/unbound.cpp

@@ -0,0 +1,27 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace Catch::Matchers;
+
+TEST_CASE("Unbound JsonArray") {
+  JsonArray array;
+
+  SECTION("SubscriptFails") {
+    REQUIRE(array[0].isNull());
+  }
+
+  SECTION("AddFails") {
+    array.add(1);
+    REQUIRE(0 == array.size());
+  }
+
+  SECTION("PrintToWritesBrackets") {
+    char buffer[32];
+    serializeJson(array, buffer, sizeof(buffer));
+    REQUIRE_THAT(buffer, Equals("null"));
+  }
+}