Initial commit of Arduino libraries

ArduinoJson/extras/tests/Deprecated/BasicJsonDocument.cpp

@@ -0,0 +1,69 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include <string>
+
+using ArduinoJson::detail::is_base_of;
+
+static std::string allocatorLog;
+
+struct CustomAllocator {
+  CustomAllocator() {
+    allocatorLog = "";
+  }
+
+  void* allocate(size_t n) {
+    allocatorLog += "A";
+    return malloc(n);
+  }
+
+  void deallocate(void* p) {
+    free(p);
+    allocatorLog += "D";
+  }
+
+  void* reallocate(void* p, size_t n) {
+    allocatorLog += "R";
+    return realloc(p, n);
+  }
+};
+
+TEST_CASE("BasicJsonDocument") {
+  allocatorLog.clear();
+
+  SECTION("is a JsonDocument") {
+    REQUIRE(
+        is_base_of<JsonDocument, BasicJsonDocument<CustomAllocator>>::value ==
+        true);
+  }
+
+  SECTION("deserialize / serialize") {
+    BasicJsonDocument<CustomAllocator> doc(256);
+    deserializeJson(doc, "{\"hello\":\"world\"}");
+    REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\"}");
+    doc.clear();
+    REQUIRE(allocatorLog == "AARARDDD");
+  }
+
+  SECTION("copy") {
+    BasicJsonDocument<CustomAllocator> doc(256);
+    doc["hello"] = "world";
+    auto copy = doc;
+    REQUIRE(copy.as<std::string>() == "{\"hello\":\"world\"}");
+    REQUIRE(allocatorLog == "AA");
+  }
+
+  SECTION("capacity") {
+    BasicJsonDocument<CustomAllocator> doc(256);
+    REQUIRE(doc.capacity() == 256);
+  }
+
+  SECTION("garbageCollect()") {
+    BasicJsonDocument<CustomAllocator> doc(256);
+    doc.garbageCollect();
+  }
+}

ArduinoJson/extras/tests/Deprecated/CMakeLists.txt

@@ -0,0 +1,35 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2025, Benoit BLANCHON
+# MIT License
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_compile_options(
+		-w
+	)
+endif()
+
+if(MSVC)
+	add_compile_options(
+		/wd4996
+	)
+endif()
+
+add_executable(DeprecatedTests
+	add.cpp
+	BasicJsonDocument.cpp
+	containsKey.cpp
+	createNestedArray.cpp
+	createNestedObject.cpp
+	DynamicJsonDocument.cpp
+	macros.cpp
+	memoryUsage.cpp
+	shallowCopy.cpp
+	StaticJsonDocument.cpp
+)
+
+add_test(Deprecated DeprecatedTests)
+
+set_tests_properties(Deprecated
+	PROPERTIES
+	LABELS "Catch"
+)

ArduinoJson/extras/tests/Deprecated/DynamicJsonDocument.cpp

@@ -0,0 +1,37 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using ArduinoJson::detail::is_base_of;
+
+TEST_CASE("DynamicJsonDocument") {
+  SECTION("is a JsonDocument") {
+    REQUIRE(is_base_of<JsonDocument, DynamicJsonDocument>::value == true);
+  }
+
+  SECTION("deserialize / serialize") {
+    DynamicJsonDocument doc(256);
+    deserializeJson(doc, "{\"hello\":\"world\"}");
+    REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("copy") {
+    DynamicJsonDocument doc(256);
+    doc["hello"] = "world";
+    auto copy = doc;
+    REQUIRE(copy.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("capacity") {
+    DynamicJsonDocument doc(256);
+    REQUIRE(doc.capacity() == 256);
+  }
+
+  SECTION("garbageCollect()") {
+    DynamicJsonDocument doc(256);
+    doc.garbageCollect();
+  }
+}

ArduinoJson/extras/tests/Deprecated/StaticJsonDocument.cpp

@@ -0,0 +1,32 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using ArduinoJson::detail::is_base_of;
+
+TEST_CASE("StaticJsonDocument") {
+  SECTION("is a JsonDocument") {
+    REQUIRE(is_base_of<JsonDocument, StaticJsonDocument<256>>::value == true);
+  }
+
+  SECTION("deserialize / serialize") {
+    StaticJsonDocument<256> doc;
+    deserializeJson(doc, "{\"hello\":\"world\"}");
+    REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("copy") {
+    StaticJsonDocument<256> doc;
+    doc["hello"] = "world";
+    auto copy = doc;
+    REQUIRE(copy.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("capacity") {
+    StaticJsonDocument<256> doc;
+    REQUIRE(doc.capacity() == 256);
+  }
+}

ArduinoJson/extras/tests/Deprecated/add.cpp

@@ -0,0 +1,38 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::add()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+  array.add().set(42);
+  REQUIRE(doc.as<std::string>() == "[42]");
+}
+
+TEST_CASE("JsonDocument::add()") {
+  JsonDocument doc;
+  doc.add().set(42);
+  REQUIRE(doc.as<std::string>() == "[42]");
+}
+
+TEST_CASE("ElementProxy::add()") {
+  JsonDocument doc;
+  doc[0].add().set(42);
+  REQUIRE(doc.as<std::string>() == "[[42]]");
+}
+
+TEST_CASE("MemberProxy::add()") {
+  JsonDocument doc;
+  doc["x"].add().set(42);
+  REQUIRE(doc.as<std::string>() == "{\"x\":[42]}");
+}
+
+TEST_CASE("JsonVariant::add()") {
+  JsonDocument doc;
+  JsonVariant v = doc.add();
+  v.add().set(42);
+  REQUIRE(doc.as<std::string>() == "[[42]]");
+}

ArduinoJson/extras/tests/Deprecated/containsKey.cpp

@@ -0,0 +1,246 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Literals.hpp"
+
+TEST_CASE("JsonDocument::containsKey()") {
+  JsonDocument doc;
+
+  SECTION("returns true on object") {
+    doc["hello"] = "world";
+
+    REQUIRE(doc.containsKey("hello") == true);
+  }
+
+  SECTION("returns true when value is null") {
+    doc["hello"] = static_cast<const char*>(0);
+
+    REQUIRE(doc.containsKey("hello") == true);
+  }
+
+  SECTION("returns true when key is a std::string") {
+    doc["hello"] = "world";
+
+    REQUIRE(doc.containsKey("hello"_s) == true);
+  }
+
+  SECTION("returns false  on object") {
+    doc["world"] = "hello";
+
+    REQUIRE(doc.containsKey("hello") == false);
+  }
+
+  SECTION("returns false on array") {
+    doc.add("hello");
+
+    REQUIRE(doc.containsKey("hello") == false);
+  }
+
+  SECTION("returns false on null") {
+    REQUIRE(doc.containsKey("hello") == false);
+  }
+
+  SECTION("supports JsonVariant") {
+    doc["hello"] = "world";
+    doc["key"] = "hello";
+
+    REQUIRE(doc.containsKey(doc["key"]) == true);
+    REQUIRE(doc.containsKey(doc["foo"]) == false);
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLAs") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    doc["hello"] = "world";
+
+    REQUIRE(doc.containsKey(vla) == true);
+  }
+#endif
+}
+
+TEST_CASE("MemberProxy::containsKey()") {
+  JsonDocument doc;
+  const auto& mp = doc["hello"];
+
+  SECTION("containsKey(const char*)") {
+    mp["key"] = "value";
+
+    REQUIRE(mp.containsKey("key") == true);
+    REQUIRE(mp.containsKey("key") == true);
+  }
+
+  SECTION("containsKey(std::string)") {
+    mp["key"] = "value";
+
+    REQUIRE(mp.containsKey("key"_s) == true);
+    REQUIRE(mp.containsKey("key"_s) == true);
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLAs") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    mp["hello"] = "world";
+
+    REQUIRE(mp.containsKey(vla) == true);
+  }
+#endif
+}
+
+TEST_CASE("JsonObject::containsKey()") {
+  JsonDocument doc;
+  JsonObject obj = doc.to<JsonObject>();
+  obj["hello"] = 42;
+
+  SECTION("returns true only if key is present") {
+    REQUIRE(false == obj.containsKey("world"));
+    REQUIRE(true == obj.containsKey("hello"));
+  }
+
+  SECTION("returns false after remove()") {
+    obj.remove("hello");
+
+    REQUIRE(false == obj.containsKey("hello"));
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("key is a VLA") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    REQUIRE(true == obj.containsKey(vla));
+  }
+#endif
+
+  SECTION("key is a JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(true == obj.containsKey(obj["key"]));
+    REQUIRE(false == obj.containsKey(obj["hello"]));
+  }
+
+  SECTION("std::string") {
+    REQUIRE(true == obj.containsKey("hello"_s));
+  }
+
+  SECTION("unsigned char[]") {
+    unsigned char key[] = "hello";
+    REQUIRE(true == obj.containsKey(key));
+  }
+}
+
+TEST_CASE("JsonObjectConst::containsKey()") {
+  JsonDocument doc;
+  doc["hello"] = 42;
+  auto obj = doc.as<JsonObjectConst>();
+
+  SECTION("supports const char*") {
+    REQUIRE(false == obj.containsKey("world"));
+    REQUIRE(true == obj.containsKey("hello"));
+  }
+
+  SECTION("supports std::string") {
+    REQUIRE(false == obj.containsKey("world"_s));
+    REQUIRE(true == obj.containsKey("hello"_s));
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLA") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    REQUIRE(true == obj.containsKey(vla));
+  }
+#endif
+
+  SECTION("supports JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(true == obj.containsKey(obj["key"]));
+    REQUIRE(false == obj.containsKey(obj["hello"]));
+  }
+}
+
+TEST_CASE("JsonVariant::containsKey()") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  SECTION("returns false is unbound") {
+    CHECK_FALSE(JsonVariant().containsKey("hello"));
+  }
+
+  SECTION("containsKey(const char*)") {
+    var["hello"] = "world";
+
+    REQUIRE(var.containsKey("hello") == true);
+    REQUIRE(var.containsKey("world") == false);
+  }
+
+  SECTION("containsKey(std::string)") {
+    var["hello"] = "world";
+
+    REQUIRE(var.containsKey("hello"_s) == true);
+    REQUIRE(var.containsKey("world"_s) == false);
+  }
+
+  SECTION("containsKey(JsonVariant)") {
+    var["hello"] = "world";
+    var["key"] = "hello";
+
+    REQUIRE(var.containsKey(doc["key"]) == true);
+    REQUIRE(var.containsKey(doc["foo"]) == false);
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLAs") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    var["hello"] = "world";
+
+    REQUIRE(var.containsKey(vla) == true);
+  }
+#endif
+}
+
+TEST_CASE("JsonVariantConst::containsKey()") {
+  JsonDocument doc;
+  doc["hello"] = "world";
+  JsonVariantConst var = doc.as<JsonVariant>();
+
+  SECTION("support const char*") {
+    REQUIRE(var.containsKey("hello") == true);
+    REQUIRE(var.containsKey("world") == false);
+  }
+
+  SECTION("support std::string") {
+    REQUIRE(var.containsKey("hello"_s) == true);
+    REQUIRE(var.containsKey("world"_s) == false);
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLA") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    REQUIRE(true == var.containsKey(vla));
+  }
+#endif
+
+  SECTION("support JsonVariant") {
+    doc["key"] = "hello";
+    REQUIRE(var.containsKey(var["key"]) == true);
+    REQUIRE(var.containsKey(var["foo"]) == false);
+  }
+}

ArduinoJson/extras/tests/Deprecated/createNestedArray.cpp

@@ -0,0 +1,113 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include <string>
+
+#include "Literals.hpp"
+
+TEST_CASE("JsonDocument::createNestedArray()") {
+  JsonDocument doc;
+
+  SECTION("createNestedArray()") {
+    JsonArray array = doc.createNestedArray();
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "[[42]]");
+  }
+
+  SECTION("createNestedArray(const char*)") {
+    JsonArray array = doc.createNestedArray("key");
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+  SECTION("createNestedArray(std::string)") {
+    JsonArray array = doc.createNestedArray("key"_s);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedArray(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonArray array = doc.createNestedArray(vla);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+#endif
+}
+
+TEST_CASE("JsonArray::createNestedArray()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+  JsonArray nestedArray = array.createNestedArray();
+  nestedArray.add(42);
+  REQUIRE(doc.as<std::string>() == "[[42]]");
+}
+
+TEST_CASE("JsonObject::createNestedArray()") {
+  JsonDocument doc;
+  JsonObject object = doc.to<JsonObject>();
+
+  SECTION("createNestedArray(const char*)") {
+    JsonArray array = object.createNestedArray("key");
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+  SECTION("createNestedArray(std::string)") {
+    JsonArray array = object.createNestedArray("key"_s);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedArray(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonArray array = object.createNestedArray(vla);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+#endif
+}
+
+TEST_CASE("JsonVariant::createNestedArray()") {
+  JsonDocument doc;
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("createNestedArray()") {
+    JsonArray array = variant.createNestedArray();
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "[[42]]");
+  }
+
+  SECTION("createNestedArray(const char*)") {
+    JsonArray array = variant.createNestedArray("key");
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+  SECTION("createNestedArray(std::string)") {
+    JsonArray array = variant.createNestedArray("key"_s);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedArray(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonArray array = variant.createNestedArray(vla);
+    array.add(42);
+    REQUIRE(doc.as<std::string>() == "{\"key\":[42]}");
+  }
+#endif
+}

ArduinoJson/extras/tests/Deprecated/createNestedObject.cpp

@@ -0,0 +1,113 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include <string>
+
+#include "Literals.hpp"
+
+TEST_CASE("JsonDocument::createNestedObject()") {
+  JsonDocument doc;
+
+  SECTION("createNestedObject()") {
+    JsonObject object = doc.createNestedObject();
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "[{\"hello\":\"world\"}]");
+  }
+
+  SECTION("createNestedObject(const char*)") {
+    JsonObject object = doc.createNestedObject("key");
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+  SECTION("createNestedObject(std::string)") {
+    JsonObject object = doc.createNestedObject("key"_s);
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedObject(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonObject object = doc.createNestedObject(vla);
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+#endif
+}
+
+TEST_CASE("JsonArray::createNestedObject()") {
+  JsonDocument doc;
+  JsonArray array = doc.to<JsonArray>();
+  JsonObject object = array.createNestedObject();
+  object["hello"] = "world";
+  REQUIRE(doc.as<std::string>() == "[{\"hello\":\"world\"}]");
+}
+
+TEST_CASE("JsonObject::createNestedObject()") {
+  JsonDocument doc;
+  JsonObject object = doc.to<JsonObject>();
+
+  SECTION("createNestedObject(const char*)") {
+    JsonObject nestedObject = object.createNestedObject("key");
+    nestedObject["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+  SECTION("createNestedObject(std::string)") {
+    JsonObject nestedObject = object.createNestedObject("key"_s);
+    nestedObject["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedObject(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonObject nestedObject = object.createNestedObject(vla);
+    nestedObject["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+#endif
+}
+
+TEST_CASE("JsonVariant::createNestedObject()") {
+  JsonDocument doc;
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("createNestedObject()") {
+    JsonObject object = variant.createNestedObject();
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "[{\"hello\":\"world\"}]");
+  }
+
+  SECTION("createNestedObject(const char*)") {
+    JsonObject object = variant.createNestedObject("key");
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+  SECTION("createNestedObject(std::string)") {
+    JsonObject object = variant.createNestedObject("key"_s);
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("createNestedObject(VLA)") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "key");
+    JsonObject object = variant.createNestedObject(vla);
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "{\"key\":{\"hello\":\"world\"}}");
+  }
+#endif
+}

ArduinoJson/extras/tests/Deprecated/macros.cpp

@@ -0,0 +1,18 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JSON_ARRAY_SIZE") {
+  REQUIRE(JSON_ARRAY_SIZE(10) == ArduinoJson::detail::sizeofArray(10));
+}
+
+TEST_CASE("JSON_OBJECT_SIZE") {
+  REQUIRE(JSON_OBJECT_SIZE(10) == ArduinoJson::detail::sizeofObject(10));
+}
+
+TEST_CASE("JSON_STRING_SIZE") {
+  REQUIRE(JSON_STRING_SIZE(10) == 11);  // issue #2054
+}

ArduinoJson/extras/tests/Deprecated/memoryUsage.cpp

@@ -0,0 +1,51 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonArray::memoryUsage()") {
+  JsonArray array;
+  REQUIRE(array.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonArrayConst::memoryUsage()") {
+  JsonArrayConst array;
+  REQUIRE(array.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonDocument::memoryUsage()") {
+  JsonDocument doc;
+  REQUIRE(doc.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonObject::memoryUsage()") {
+  JsonObject array;
+  REQUIRE(array.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonObjectConst::memoryUsage()") {
+  JsonObjectConst array;
+  REQUIRE(array.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonVariant::memoryUsage()") {
+  JsonVariant doc;
+  REQUIRE(doc.memoryUsage() == 0);
+}
+
+TEST_CASE("JsonVariantConst::memoryUsage()") {
+  JsonVariantConst doc;
+  REQUIRE(doc.memoryUsage() == 0);
+}
+
+TEST_CASE("ElementProxy::memoryUsage()") {
+  JsonDocument doc;
+  REQUIRE(doc[0].memoryUsage() == 0);
+}
+
+TEST_CASE("MemberProxy::memoryUsage()") {
+  JsonDocument doc;
+  REQUIRE(doc["hello"].memoryUsage() == 0);
+}

ArduinoJson/extras/tests/Deprecated/shallowCopy.cpp

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("shallowCopy()") {
+  JsonDocument doc1, doc2;
+  doc1["b"] = "c";
+  doc2["a"].shallowCopy(doc1);
+
+  REQUIRE(doc2.as<std::string>() == "{\"a\":{\"b\":\"c\"}}");
+}