Update to ArduinoJson 7.0.4

lib/ArduinoJson/extras/tests/JsonDocument/BasicJsonDocument.cpp

@@ -1,180 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <stdlib.h>  // malloc, free
-#include <catch.hpp>
-#include <sstream>
-#include <utility>
-
-class SpyingAllocator {
- public:
-  SpyingAllocator(const SpyingAllocator& src) : _log(src._log) {}
-  SpyingAllocator(std::ostream& log) : _log(log) {}
-  SpyingAllocator& operator=(const SpyingAllocator& src) = delete;
-
-  void* allocate(size_t n) {
-    _log << "A" << n;
-    return malloc(n);
-  }
-  void deallocate(void* p) {
-    _log << "F";
-    free(p);
-  }
-
- private:
-  std::ostream& _log;
-};
-
-class ControllableAllocator {
- public:
-  ControllableAllocator() : _enabled(true) {}
-
-  void* allocate(size_t n) {
-    return _enabled ? malloc(n) : 0;
-  }
-
-  void deallocate(void* p) {
-    free(p);
-  }
-
-  void disable() {
-    _enabled = false;
-  }
-
- private:
-  bool _enabled;
-};
-
-TEST_CASE("BasicJsonDocument") {
-  std::stringstream log;
-
-  SECTION("Construct/Destruct") {
-    { BasicJsonDocument<SpyingAllocator> doc(4096, log); }
-    REQUIRE(log.str() == "A4096F");
-  }
-
-  SECTION("Copy construct") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(4096, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-
-      BasicJsonDocument<SpyingAllocator> doc2(doc1);
-
-      REQUIRE(doc1.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.capacity() == 4096);
-    }
-    REQUIRE(log.str() == "A4096A4096FF");
-  }
-
-  SECTION("Move construct") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(4096, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-
-      BasicJsonDocument<SpyingAllocator> doc2(std::move(doc1));
-
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc1.as<std::string>() == "null");
-      REQUIRE(doc1.capacity() == 0);
-      REQUIRE(doc2.capacity() == 4096);
-    }
-    REQUIRE(log.str() == "A4096F");
-  }
-
-  SECTION("Copy assign larger") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(4096, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-      BasicJsonDocument<SpyingAllocator> doc2(8, log);
-
-      doc2 = doc1;
-
-      REQUIRE(doc1.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.capacity() == 4096);
-    }
-    REQUIRE(log.str() == "A4096A8FA4096FF");
-  }
-
-  SECTION("Copy assign smaller") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(1024, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-      BasicJsonDocument<SpyingAllocator> doc2(4096, log);
-
-      doc2 = doc1;
-
-      REQUIRE(doc1.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.capacity() == 1024);
-    }
-    REQUIRE(log.str() == "A1024A4096FA1024FF");
-  }
-
-  SECTION("Copy assign same size") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(1024, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-      BasicJsonDocument<SpyingAllocator> doc2(1024, log);
-
-      doc2 = doc1;
-
-      REQUIRE(doc1.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc2.capacity() == 1024);
-    }
-    REQUIRE(log.str() == "A1024A1024FF");
-  }
-
-  SECTION("Move assign") {
-    {
-      BasicJsonDocument<SpyingAllocator> doc1(4096, log);
-      doc1.set(std::string("The size of this string is 32!!"));
-      BasicJsonDocument<SpyingAllocator> doc2(8, log);
-
-      doc2 = std::move(doc1);
-
-      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
-      REQUIRE(doc1.as<std::string>() == "null");
-      REQUIRE(doc1.capacity() == 0);
-      REQUIRE(doc2.capacity() == 4096);
-    }
-    REQUIRE(log.str() == "A4096A8FF");
-  }
-
-  SECTION("garbageCollect()") {
-    BasicJsonDocument<ControllableAllocator> doc(4096);
-
-    SECTION("when allocation succeeds") {
-      deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
-      REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
-      doc.remove("blanket");
-
-      bool result = doc.garbageCollect();
-
-      REQUIRE(result == true);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8);
-      REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
-    }
-
-    SECTION("when allocation fails") {
-      deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
-      REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
-      doc.remove("blanket");
-      doc.allocator().disable();
-
-      bool result = doc.garbageCollect();
-
-      REQUIRE(result == false);
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16);
-      REQUIRE(doc.capacity() == 4096);
-      REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
-    }
-  }
-}

lib/ArduinoJson/extras/tests/JsonDocument/CMakeLists.txt

@@ -1,15 +1,15 @@
 # ArduinoJson - https://arduinojson.org
-# Copyright © 2014-2023, Benoit BLANCHON
+# Copyright © 2014-2024, Benoit BLANCHON
 # MIT License
 
 add_executable(JsonDocumentTests
 	add.cpp
-	BasicJsonDocument.cpp
+	assignment.cpp
 	cast.cpp
+	clear.cpp
 	compare.cpp
+	constructor.cpp
 	containsKey.cpp
-	createNested.cpp
-	DynamicJsonDocument.cpp
 	ElementProxy.cpp
 	isNull.cpp
 	issue1120.cpp
@@ -19,7 +19,6 @@ add_executable(JsonDocumentTests
 	remove.cpp
 	shrinkToFit.cpp
 	size.cpp
-	StaticJsonDocument.cpp
 	subscript.cpp
 	swap.cpp
 )

lib/ArduinoJson/extras/tests/JsonDocument/DynamicJsonDocument.cpp

@@ -1,230 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using ArduinoJson::detail::addPadding;
-
-static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) {
-  std::string json;
-  serializeJson(doc, json);
-  REQUIRE(json == expected);
-}
-
-TEST_CASE("DynamicJsonDocument") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("serializeJson()") {
-    JsonObject obj = doc.to<JsonObject>();
-    obj["hello"] = "world";
-
-    std::string json;
-    serializeJson(doc, json);
-
-    REQUIRE(json == "{\"hello\":\"world\"}");
-  }
-
-  SECTION("memoryUsage()") {
-    SECTION("starts at zero") {
-      REQUIRE(doc.memoryUsage() == 0);
-    }
-
-    SECTION("JSON_ARRAY_SIZE(0)") {
-      doc.to<JsonArray>();
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
-    }
-
-    SECTION("JSON_ARRAY_SIZE(1)") {
-      doc.to<JsonArray>().add(42);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1));
-    }
-
-    SECTION("JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0)") {
-      doc.to<JsonArray>().createNestedArray();
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0));
-    }
-  }
-
-  SECTION("capacity()") {
-    SECTION("matches constructor argument") {
-      DynamicJsonDocument doc2(256);
-      REQUIRE(doc2.capacity() == 256);
-    }
-
-    SECTION("rounds up constructor argument") {
-      DynamicJsonDocument doc2(253);
-      REQUIRE(doc2.capacity() == 256);
-    }
-  }
-
-  SECTION("memoryUsage()") {
-    SECTION("Increases after adding value to array") {
-      JsonArray arr = doc.to<JsonArray>();
-
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
-      arr.add(42);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1));
-      arr.add(43);
-      REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
-    }
-
-    SECTION("Increases after adding value to object") {
-      JsonObject obj = doc.to<JsonObject>();
-
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
-      obj["a"] = 1;
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
-      obj["b"] = 2;
-      REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
-    }
-  }
-}
-
-TEST_CASE("DynamicJsonDocument constructor") {
-  SECTION("Copy constructor") {
-    DynamicJsonDocument doc1(1234);
-    deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-    DynamicJsonDocument doc2 = doc1;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-
-    REQUIRE(doc2.capacity() == doc1.capacity());
-  }
-
-  SECTION("Construct from StaticJsonDocument") {
-    StaticJsonDocument<200> doc1;
-    deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-    DynamicJsonDocument doc2 = doc1;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    REQUIRE(doc2.capacity() == doc1.capacity());
-  }
-
-  SECTION("Construct from JsonObject") {
-    StaticJsonDocument<200> doc1;
-    JsonObject obj = doc1.to<JsonObject>();
-    obj["hello"] = "world";
-
-    DynamicJsonDocument doc2 = obj;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    REQUIRE(doc2.capacity() == addPadding(doc1.memoryUsage()));
-  }
-
-  SECTION("Construct from JsonArray") {
-    StaticJsonDocument<200> doc1;
-    JsonArray arr = doc1.to<JsonArray>();
-    arr.add("hello");
-
-    DynamicJsonDocument doc2 = arr;
-
-    REQUIRE_JSON(doc2, "[\"hello\"]");
-    REQUIRE(doc2.capacity() == addPadding(doc1.memoryUsage()));
-  }
-
-  SECTION("Construct from JsonVariant") {
-    StaticJsonDocument<200> doc1;
-    deserializeJson(doc1, "42");
-
-    DynamicJsonDocument doc2 = doc1.as<JsonVariant>();
-
-    REQUIRE_JSON(doc2, "42");
-    REQUIRE(doc2.capacity() == addPadding(doc1.memoryUsage()));
-  }
-}
-
-TEST_CASE("DynamicJsonDocument assignment") {
-  SECTION("Copy assignment reallocates when capacity is smaller") {
-    DynamicJsonDocument doc1(1234);
-    deserializeJson(doc1, "{\"hello\":\"world\"}");
-    DynamicJsonDocument doc2(8);
-
-    doc2 = doc1;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    REQUIRE(doc2.capacity() == doc1.capacity());
-  }
-
-  SECTION("Copy assignment reallocates when capacity is larger") {
-    DynamicJsonDocument doc1(100);
-    deserializeJson(doc1, "{\"hello\":\"world\"}");
-    DynamicJsonDocument doc2(1234);
-
-    doc2 = doc1;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    REQUIRE(doc2.capacity() == doc1.capacity());
-  }
-
-  SECTION("Assign from StaticJsonDocument") {
-    StaticJsonDocument<200> doc1;
-    deserializeJson(doc1, "{\"hello\":\"world\"}");
-    DynamicJsonDocument doc2(4096);
-    doc2.to<JsonVariant>().set(666);
-
-    doc2 = doc1;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-  }
-
-  SECTION("Assign from JsonObject") {
-    StaticJsonDocument<200> doc1;
-    JsonObject obj = doc1.to<JsonObject>();
-    obj["hello"] = "world";
-
-    DynamicJsonDocument doc2(4096);
-    doc2 = obj;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    REQUIRE(doc2.capacity() == 4096);
-  }
-
-  SECTION("Assign from JsonArray") {
-    StaticJsonDocument<200> doc1;
-    JsonArray arr = doc1.to<JsonArray>();
-    arr.add("hello");
-
-    DynamicJsonDocument doc2(4096);
-    doc2 = arr;
-
-    REQUIRE_JSON(doc2, "[\"hello\"]");
-    REQUIRE(doc2.capacity() == 4096);
-  }
-
-  SECTION("Assign from JsonVariant") {
-    StaticJsonDocument<200> doc1;
-    deserializeJson(doc1, "42");
-
-    DynamicJsonDocument doc2(4096);
-    doc2 = doc1.as<JsonVariant>();
-
-    REQUIRE_JSON(doc2, "42");
-    REQUIRE(doc2.capacity() == 4096);
-  }
-
-  SECTION("Assign from MemberProxy") {
-    StaticJsonDocument<200> doc1;
-    doc1["value"] = 42;
-
-    DynamicJsonDocument doc2(4096);
-    doc2 = doc1["value"];
-
-    REQUIRE_JSON(doc2, "42");
-    REQUIRE(doc2.capacity() == 4096);
-  }
-
-  SECTION("Assign from ElementProxy") {
-    StaticJsonDocument<200> doc1;
-    doc1[0] = 42;
-
-    DynamicJsonDocument doc2(4096);
-    doc2 = doc1[0];
-
-    REQUIRE_JSON(doc2, "42");
-    REQUIRE(doc2.capacity() == 4096);
-  }
-}

lib/ArduinoJson/extras/tests/JsonDocument/ElementProxy.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -8,8 +8,8 @@
 typedef ArduinoJson::detail::ElementProxy<JsonDocument&> ElementProxy;
 
 TEST_CASE("ElementProxy::add()") {
-  DynamicJsonDocument doc(4096);
-  doc.add();
+  JsonDocument doc;
+  doc.add<JsonVariant>();
   ElementProxy ep = doc[0];
 
   SECTION("add(int)") {
@@ -34,8 +34,8 @@ TEST_CASE("ElementProxy::add()") {
 }
 
 TEST_CASE("ElementProxy::clear()") {
-  DynamicJsonDocument doc(4096);
-  doc.add();
+  JsonDocument doc;
+  doc.add<JsonVariant>();
   ElementProxy ep = doc[0];
 
   SECTION("size goes back to zero") {
@@ -54,7 +54,7 @@ TEST_CASE("ElementProxy::clear()") {
 }
 
 TEST_CASE("ElementProxy::operator==()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("1 vs 1") {
     doc.add(1);
@@ -94,8 +94,8 @@ TEST_CASE("ElementProxy::operator==()") {
 }
 
 TEST_CASE("ElementProxy::remove()") {
-  DynamicJsonDocument doc(4096);
-  doc.add();
+  JsonDocument doc;
+  doc.add<JsonVariant>();
   ElementProxy ep = doc[0];
 
   SECTION("remove(int)") {
@@ -142,7 +142,7 @@ TEST_CASE("ElementProxy::remove()") {
 }
 
 TEST_CASE("ElementProxy::set()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   ElementProxy ep = doc[0];
 
   SECTION("set(int)") {
@@ -167,8 +167,8 @@ TEST_CASE("ElementProxy::set()") {
 }
 
 TEST_CASE("ElementProxy::size()") {
-  DynamicJsonDocument doc(4096);
-  doc.add();
+  JsonDocument doc;
+  doc.add<JsonVariant>();
   ElementProxy ep = doc[0];
 
   SECTION("returns 0") {
@@ -188,23 +188,8 @@ TEST_CASE("ElementProxy::size()") {
   }
 }
 
-TEST_CASE("ElementProxy::memoryUsage()") {
-  DynamicJsonDocument doc(4096);
-  doc.add();
-  ElementProxy ep = doc[0];
-
-  SECTION("returns 0 for null") {
-    REQUIRE(ep.memoryUsage() == 0);
-  }
-
-  SECTION("returns size for string") {
-    ep.set(std::string("hello"));
-    REQUIRE(ep.memoryUsage() == 6);
-  }
-}
-
 TEST_CASE("ElementProxy::operator[]") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   ElementProxy ep = doc[1];
 
   SECTION("set member") {
@@ -221,7 +206,7 @@ TEST_CASE("ElementProxy::operator[]") {
 }
 
 TEST_CASE("ElementProxy cast to JsonVariantConst") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   doc[0] = "world";
 
   const ElementProxy ep = doc[0];
@@ -232,7 +217,7 @@ TEST_CASE("ElementProxy cast to JsonVariantConst") {
 }
 
 TEST_CASE("ElementProxy cast to JsonVariant") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   doc[0] = "world";
 
   ElementProxy ep = doc[0];
@@ -245,11 +230,3 @@ TEST_CASE("ElementProxy cast to JsonVariant") {
 
   CHECK(doc.as<std::string>() == "[\"toto\"]");
 }
-
-TEST_CASE("ElementProxy::shallowCopy()") {
-  StaticJsonDocument<1024> doc1, doc2;
-  doc2["hello"] = "world";
-  doc1[0].shallowCopy(doc2);
-
-  CHECK(doc1.as<std::string>() == "[{\"hello\":\"world\"}]");
-}

lib/ArduinoJson/extras/tests/JsonDocument/MemberProxy.cpp

@@ -1,15 +1,23 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#define ARDUINOJSON_ENABLE_PROGMEM 1
 #include <ArduinoJson.h>
+
 #include <catch.hpp>
 
+#include "Allocators.hpp"
+
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
 typedef ArduinoJson::detail::MemberProxy<JsonDocument&, const char*>
     MemberProxy;
 
 TEST_CASE("MemberProxy::add()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("add(int)") {
@@ -26,7 +34,7 @@ TEST_CASE("MemberProxy::add()") {
 }
 
 TEST_CASE("MemberProxy::clear()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("size goes back to zero") {
@@ -45,7 +53,7 @@ TEST_CASE("MemberProxy::clear()") {
 }
 
 TEST_CASE("MemberProxy::operator==()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("1 vs 1") {
     doc["a"] = 1;
@@ -85,7 +93,7 @@ TEST_CASE("MemberProxy::operator==()") {
 }
 
 TEST_CASE("MemberProxy::containsKey()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("containsKey(const char*)") {
@@ -104,7 +112,7 @@ TEST_CASE("MemberProxy::containsKey()") {
 }
 
 TEST_CASE("MemberProxy::operator|()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("const char*") {
     doc["a"] = "hello";
@@ -127,7 +135,7 @@ TEST_CASE("MemberProxy::operator|()") {
     JsonObject object = doc.to<JsonObject>();
     object["hello"] = "world";
 
-    StaticJsonDocument<0> emptyDoc;
+    JsonDocument emptyDoc;
     JsonObject anotherObject = object["hello"] | emptyDoc.to<JsonObject>();
 
     REQUIRE(anotherObject.isNull() == false);
@@ -136,7 +144,7 @@ TEST_CASE("MemberProxy::operator|()") {
 }
 
 TEST_CASE("MemberProxy::remove()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("remove(int)") {
@@ -183,7 +191,7 @@ TEST_CASE("MemberProxy::remove()") {
 }
 
 TEST_CASE("MemberProxy::set()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("set(int)") {
@@ -208,7 +216,7 @@ TEST_CASE("MemberProxy::set()") {
 }
 
 TEST_CASE("MemberProxy::size()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("returns 0") {
@@ -230,22 +238,8 @@ TEST_CASE("MemberProxy::size()") {
   }
 }
 
-TEST_CASE("MemberProxy::memoryUsage()") {
-  DynamicJsonDocument doc(4096);
-  MemberProxy mp = doc["hello"];
-
-  SECTION("returns 0 when null") {
-    REQUIRE(mp.memoryUsage() == 0);
-  }
-
-  SECTION("return the size for a string") {
-    mp.set(std::string("hello"));
-    REQUIRE(mp.memoryUsage() == 6);
-  }
-}
-
 TEST_CASE("MemberProxy::operator[]") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   MemberProxy mp = doc["hello"];
 
   SECTION("set member") {
@@ -262,7 +256,7 @@ TEST_CASE("MemberProxy::operator[]") {
 }
 
 TEST_CASE("MemberProxy cast to JsonVariantConst") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   doc["hello"] = "world";
 
   const MemberProxy mp = doc["hello"];
@@ -273,7 +267,7 @@ TEST_CASE("MemberProxy cast to JsonVariantConst") {
 }
 
 TEST_CASE("MemberProxy cast to JsonVariant") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   doc["hello"] = "world";
 
   MemberProxy mp = doc["hello"];
@@ -287,42 +281,83 @@ TEST_CASE("MemberProxy cast to JsonVariant") {
   CHECK(doc.as<std::string>() == "{\"hello\":\"toto\"}");
 }
 
-TEST_CASE("MemberProxy::createNestedArray()") {
-  StaticJsonDocument<1024> doc;
-  JsonArray arr = doc["items"].createNestedArray();
-  arr.add(42);
+TEST_CASE("Deduplicate keys") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
 
-  CHECK(doc["items"][0][0] == 42);
+  SECTION("std::string") {
+    doc[0][std::string("example")] = 1;
+    doc[1][std::string("example")] = 2;
+
+    const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
+    const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
+    CHECK(key1 == key2);
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("char*") {
+    char key[] = "example";
+    doc[0][key] = 1;
+    doc[1][key] = 2;
+
+    const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
+    const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
+    CHECK(key1 == key2);
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("Arduino String") {
+    doc[0][String("example")] = 1;
+    doc[1][String("example")] = 2;
+
+    const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
+    const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
+    CHECK(key1 == key2);
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("Flash string") {
+    doc[0][F("example")] = 1;
+    doc[1][F("example")] = 2;
+
+    const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
+    const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
+    CHECK(key1 == key2);
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
 }
 
-TEST_CASE("MemberProxy::createNestedArray(key)") {
-  StaticJsonDocument<1024> doc;
-  JsonArray arr = doc["weather"].createNestedArray("temp");
-  arr.add(42);
+TEST_CASE("MemberProxy under memory constraints") {
+  KillswitchAllocator killswitch;
+  SpyingAllocator spy(&killswitch);
+  JsonDocument doc(&spy);
 
-  CHECK(doc["weather"]["temp"][0] == 42);
-}
-
-TEST_CASE("MemberProxy::createNestedObject()") {
-  StaticJsonDocument<1024> doc;
-  JsonObject obj = doc["items"].createNestedObject();
-  obj["value"] = 42;
-
-  CHECK(doc["items"][0]["value"] == 42);
-}
-
-TEST_CASE("MemberProxy::createNestedObject(key)") {
-  StaticJsonDocument<1024> doc;
-  JsonObject obj = doc["status"].createNestedObject("weather");
-  obj["temp"] = 42;
-
-  CHECK(doc["status"]["weather"]["temp"] == 42);
-}
-
-TEST_CASE("MemberProxy::shallowCopy()") {
-  StaticJsonDocument<1024> doc1, doc2;
-  doc2["hello"] = "world";
-  doc1["obj"].shallowCopy(doc2);
-
-  CHECK(doc1.as<std::string>() == "{\"obj\":{\"hello\":\"world\"}}");
+  SECTION("key allocation fails") {
+    killswitch.on();
+
+    doc[std::string("hello")] = "world";
+
+    REQUIRE(doc.is<JsonObject>());
+    REQUIRE(doc.size() == 0);
+    REQUIRE(doc.overflowed() == true);
+    REQUIRE(spy.log() == AllocatorLog{
+                             AllocateFail(sizeofString("hello")),
+                         });
+  }
 }

lib/ArduinoJson/extras/tests/JsonDocument/StaticJsonDocument.cpp

@@ -1,224 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) {
-  std::string json;
-  serializeJson(doc, json);
-  REQUIRE(json == expected);
-}
-
-TEST_CASE("StaticJsonDocument") {
-  SECTION("capacity()") {
-    SECTION("matches template argument") {
-      StaticJsonDocument<256> doc;
-      REQUIRE(doc.capacity() == 256);
-    }
-
-    SECTION("rounds up template argument") {
-      StaticJsonDocument<253> doc;
-      REQUIRE(doc.capacity() == 256);
-    }
-  }
-
-  SECTION("serializeJson()") {
-    StaticJsonDocument<200> doc;
-    JsonObject obj = doc.to<JsonObject>();
-    obj["hello"] = "world";
-
-    std::string json;
-    serializeJson(doc, json);
-
-    REQUIRE(json == "{\"hello\":\"world\"}");
-  }
-
-  SECTION("Copy assignment") {
-    StaticJsonDocument<200> doc1, doc2;
-    doc1.to<JsonVariant>().set(666);
-    deserializeJson(doc2, "{\"hello\":\"world\"}");
-
-    doc1 = doc2;
-
-    REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-  }
-
-  SECTION("Contructor") {
-    SECTION("Copy constructor") {
-      StaticJsonDocument<200> doc1;
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      StaticJsonDocument<200> doc2 = doc1;
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Construct from StaticJsonDocument of different size") {
-      StaticJsonDocument<300> doc1;
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      StaticJsonDocument<200> doc2 = doc1;
-
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Construct from DynamicJsonDocument") {
-      DynamicJsonDocument doc1(4096);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      StaticJsonDocument<200> doc2 = doc1;
-
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Construct from JsonObject") {
-      DynamicJsonDocument doc1(4096);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      StaticJsonDocument<200> doc2 = doc1.as<JsonObject>();
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Construct from JsonArray") {
-      DynamicJsonDocument doc1(4096);
-      deserializeJson(doc1, "[\"hello\",\"world\"]");
-
-      StaticJsonDocument<200> doc2 = doc1.as<JsonArray>();
-
-      deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
-      REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
-    }
-
-    SECTION("Construct from JsonVariant") {
-      DynamicJsonDocument doc1(4096);
-      deserializeJson(doc1, "42");
-
-      StaticJsonDocument<200> doc2 = doc1.as<JsonVariant>();
-
-      REQUIRE_JSON(doc2, "42");
-    }
-  }
-
-  SECTION("Assignment") {
-    SECTION("Copy assignment") {
-      StaticJsonDocument<200> doc1, doc2;
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      doc2 = doc1;
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Assign from StaticJsonDocument of different capacity") {
-      StaticJsonDocument<200> doc1;
-      StaticJsonDocument<300> doc2;
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      doc2 = doc1;
-
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Assign from DynamicJsonDocument") {
-      StaticJsonDocument<200> doc1;
-      DynamicJsonDocument doc2(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      doc2 = doc1;
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Assign from JsonArray") {
-      StaticJsonDocument<200> doc1;
-      DynamicJsonDocument doc2(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "[\"hello\",\"world\"]");
-
-      doc2 = doc1.as<JsonArray>();
-
-      deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
-      REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
-    }
-
-    SECTION("Assign from JsonArrayConst") {
-      StaticJsonDocument<200> doc1;
-      DynamicJsonDocument doc2(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "[\"hello\",\"world\"]");
-
-      doc2 = doc1.as<JsonArrayConst>();
-
-      deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
-      REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
-    }
-
-    SECTION("Assign from JsonObject") {
-      StaticJsonDocument<200> doc1;
-      DynamicJsonDocument doc2(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      doc2 = doc1.as<JsonObject>();
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Assign from JsonObjectConst") {
-      StaticJsonDocument<200> doc1;
-      DynamicJsonDocument doc2(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "{\"hello\":\"world\"}");
-
-      doc2 = doc1.as<JsonObjectConst>();
-
-      deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
-      REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
-    }
-
-    SECTION("Assign from JsonVariant") {
-      DynamicJsonDocument doc1(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "42");
-
-      StaticJsonDocument<200> doc2;
-      doc2 = doc1.as<JsonVariant>();
-
-      REQUIRE_JSON(doc2, "42");
-    }
-
-    SECTION("Assign from JsonVariantConst") {
-      DynamicJsonDocument doc1(4096);
-      doc1.to<JsonVariant>().set(666);
-      deserializeJson(doc1, "42");
-
-      StaticJsonDocument<200> doc2;
-      doc2 = doc1.as<JsonVariantConst>();
-
-      REQUIRE_JSON(doc2, "42");
-    }
-  }
-
-  SECTION("garbageCollect()") {
-    StaticJsonDocument<256> doc;
-    doc[std::string("example")] = std::string("jukebox");
-    doc.remove("example");
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 16);
-
-    doc.garbageCollect();
-
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
-    REQUIRE_JSON(doc, "{}");
-  }
-}

lib/ArduinoJson/extras/tests/JsonDocument/add.cpp

@@ -1,22 +1,104 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
+#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1
+#define ARDUINOJSON_ENABLE_PROGMEM 1
 #include <ArduinoJson.h>
+
 #include <catch.hpp>
 
-TEST_CASE("JsonDocument::add()") {
-  DynamicJsonDocument doc(4096);
+#include "Allocators.hpp"
+
+using ArduinoJson::detail::sizeofArray;
+
+TEST_CASE("JsonDocument::add(T)") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
 
   SECTION("integer") {
     doc.add(42);
 
     REQUIRE(doc.as<std::string>() == "[42]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
   }
 
   SECTION("const char*") {
     doc.add("hello");
 
     REQUIRE(doc.as<std::string>() == "[\"hello\"]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                         });
+  }
+
+  SECTION("std::string") {
+    doc.add(std::string("example"));
+    doc.add(std::string("example"));
+
+    CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("char*") {
+    char value[] = "example";
+    doc.add(value);
+    doc.add(value);
+
+    CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("Arduino String") {
+    doc.add(String("example"));
+    doc.add(String("example"));
+
+    CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+
+  SECTION("Flash string") {
+    doc.add(F("example"));
+    doc.add(F("example"));
+
+    CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("example")),
+                         });
+  }
+}
+
+TEST_CASE("JsonDocument::add<T>()") {
+  JsonDocument doc;
+
+  SECTION("JsonArray") {
+    JsonArray array = doc.add<JsonArray>();
+    array.add(1);
+    array.add(2);
+    REQUIRE(doc.as<std::string>() == "[[1,2]]");
+  }
+
+  SECTION("JsonObject") {
+    JsonObject object = doc.add<JsonObject>();
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "[{\"hello\":\"world\"}]");
+  }
+
+  SECTION("JsonVariant") {
+    JsonVariant variant = doc.add<JsonVariant>();
+    variant.set(42);
+    REQUIRE(doc.as<std::string>() == "[42]");
   }
 }

lib/ArduinoJson/extras/tests/JsonDocument/assignment.cpp

@@ -0,0 +1,134 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+
+TEST_CASE("JsonDocument assignment") {
+  SpyingAllocator spyingAllocator;
+
+  SECTION("Copy assignment same capacity") {
+    JsonDocument doc1(&spyingAllocator);
+    deserializeJson(doc1, "{\"hello\":\"world\"}");
+    JsonDocument doc2(&spyingAllocator);
+    spyingAllocator.clearLog();
+
+    doc2 = doc1;
+
+    REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofPool()),
+                                         Allocate(sizeofString("world")),
+                                     });
+  }
+
+  SECTION("Copy assignment reallocates when capacity is smaller") {
+    JsonDocument doc1(&spyingAllocator);
+    deserializeJson(doc1, "[{\"hello\":\"world\"}]");
+    JsonDocument doc2(&spyingAllocator);
+    spyingAllocator.clearLog();
+
+    doc2 = doc1;
+
+    REQUIRE(doc2.as<std::string>() == "[{\"hello\":\"world\"}]");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofPool()),
+                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofString("world")),
+                                     });
+  }
+
+  SECTION("Copy assignment reallocates when capacity is larger") {
+    JsonDocument doc1(&spyingAllocator);
+    deserializeJson(doc1, "{\"hello\":\"world\"}");
+    JsonDocument doc2(&spyingAllocator);
+    spyingAllocator.clearLog();
+
+    doc2 = doc1;
+
+    REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofPool()),
+                                         Allocate(sizeofString("world")),
+                                     });
+  }
+
+  SECTION("Move assign") {
+    {
+      JsonDocument doc1(&spyingAllocator);
+      doc1[std::string("hello")] = std::string("world");
+      JsonDocument doc2(&spyingAllocator);
+
+      doc2 = std::move(doc1);
+
+      REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+      REQUIRE(doc1.as<std::string>() == "null");
+    }
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello")),
+                                         Allocate(sizeofPool()),
+                                         Allocate(sizeofString("world")),
+                                         Deallocate(sizeofString("hello")),
+                                         Deallocate(sizeofString("world")),
+                                         Deallocate(sizeofPool()),
+                                     });
+  }
+
+  SECTION("Assign from JsonObject") {
+    JsonDocument doc1;
+    JsonObject obj = doc1.to<JsonObject>();
+    obj["hello"] = "world";
+
+    JsonDocument doc2;
+    doc2 = obj;
+
+    REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("Assign from JsonArray") {
+    JsonDocument doc1;
+    JsonArray arr = doc1.to<JsonArray>();
+    arr.add("hello");
+
+    JsonDocument doc2;
+    doc2 = arr;
+
+    REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
+  }
+
+  SECTION("Assign from JsonVariant") {
+    JsonDocument doc1;
+    deserializeJson(doc1, "42");
+
+    JsonDocument doc2;
+    doc2 = doc1.as<JsonVariant>();
+
+    REQUIRE(doc2.as<std::string>() == "42");
+  }
+
+  SECTION("Assign from MemberProxy") {
+    JsonDocument doc1;
+    doc1["value"] = 42;
+
+    JsonDocument doc2;
+    doc2 = doc1["value"];
+
+    REQUIRE(doc2.as<std::string>() == "42");
+  }
+
+  SECTION("Assign from ElementProxy") {
+    JsonDocument doc1;
+    doc1[0] = 42;
+
+    JsonDocument doc2;
+    doc2 = doc1[0];
+
+    REQUIRE(doc2.as<std::string>() == "42");
+  }
+}

lib/ArduinoJson/extras/tests/JsonDocument/cast.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -8,7 +8,7 @@
 #include <string>
 
 TEST_CASE("Implicit cast to JsonVariant") {
-  StaticJsonDocument<128> doc;
+  JsonDocument doc;
 
   doc["hello"] = "world";
 

lib/ArduinoJson/extras/tests/JsonDocument/clear.cpp

@@ -0,0 +1,47 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include <stdlib.h>  // malloc, free
+#include <string>
+
+#include "Allocators.hpp"
+
+TEST_CASE("JsonDocument::clear()") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+
+  SECTION("null") {
+    doc.clear();
+
+    REQUIRE(doc.isNull());
+    REQUIRE(spy.log() == AllocatorLog{});
+  }
+
+  SECTION("releases resources") {
+    doc[std::string("hello")] = std::string("world");
+    spy.clearLog();
+
+    doc.clear();
+
+    REQUIRE(doc.isNull());
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofPool()),
+                             Deallocate(sizeofString("hello")),
+                             Deallocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("clear free list") {  // issue #2034
+    JsonObject obj = doc.to<JsonObject>();
+    obj["a"] = 1;
+    obj.clear();  // puts the slot in the free list
+
+    doc.clear();
+
+    doc["b"] = 2;  // will it pick from the free list?
+  }
+}

lib/ArduinoJson/extras/tests/JsonDocument/compare.cpp

@@ -1,103 +1,29 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
-TEST_CASE("DynamicJsonDocument::operator==(const DynamicJsonDocument&)") {
-  DynamicJsonDocument doc1(4096);
-  DynamicJsonDocument doc2(4096);
-
-  SECTION("Empty") {
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-
-  SECTION("With same object") {
-    doc1["hello"] = "world";
-    doc2["hello"] = "world";
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-  SECTION("With different object") {
-    doc1["hello"] = "world";
-    doc2["world"] = "hello";
-    REQUIRE_FALSE(doc1 == doc2);
-    REQUIRE(doc1 != doc2);
-  }
-}
-
-TEST_CASE("DynamicJsonDocument::operator==(const StaticJsonDocument&)") {
-  DynamicJsonDocument doc1(4096);
-  StaticJsonDocument<256> doc2;
-
-  SECTION("Empty") {
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-
-  SECTION("With same object") {
-    doc1["hello"] = "world";
-    doc2["hello"] = "world";
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-
-  SECTION("With different object") {
-    doc1["hello"] = "world";
-    doc2["world"] = "hello";
-    REQUIRE_FALSE(doc1 == doc2);
-    REQUIRE(doc1 != doc2);
-  }
-}
-
-TEST_CASE("StaticJsonDocument::operator==(const DynamicJsonDocument&)") {
-  StaticJsonDocument<256> doc1;
-  DynamicJsonDocument doc2(4096);
-
-  SECTION("Empty") {
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-
-  SECTION("With same object") {
-    doc1["hello"] = "world";
-    doc2["hello"] = "world";
-    REQUIRE(doc1 == doc2);
-    REQUIRE_FALSE(doc1 != doc2);
-  }
-
-  SECTION("With different object") {
-    doc1["hello"] = "world";
-    doc2["world"] = "hello";
-    REQUIRE_FALSE(doc1 == doc2);
-    REQUIRE(doc1 != doc2);
-  }
-}
-
 TEST_CASE("JsonDocument::operator==(const JsonDocument&)") {
-  StaticJsonDocument<256> doc1;
-  StaticJsonDocument<256> doc2;
-  const JsonDocument& ref1 = doc1;
-  const JsonDocument& ref2 = doc2;
+  JsonDocument doc1;
+  JsonDocument doc2;
 
   SECTION("Empty") {
-    REQUIRE(ref1 == ref2);
-    REQUIRE_FALSE(ref1 != ref2);
+    REQUIRE(doc1 == doc2);
+    REQUIRE_FALSE(doc1 != doc2);
   }
 
   SECTION("With same object") {
     doc1["hello"] = "world";
     doc2["hello"] = "world";
-    REQUIRE(ref1 == ref2);
-    REQUIRE_FALSE(ref1 != ref2);
+    REQUIRE(doc1 == doc2);
+    REQUIRE_FALSE(doc1 != doc2);
   }
-
   SECTION("With different object") {
     doc1["hello"] = "world";
     doc2["world"] = "hello";
-    REQUIRE_FALSE(ref1 == ref2);
-    REQUIRE(ref1 != ref2);
+    REQUIRE_FALSE(doc1 == doc2);
+    REQUIRE(doc1 != doc2);
   }
 }

lib/ArduinoJson/extras/tests/JsonDocument/constructor.cpp

@@ -0,0 +1,120 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Allocators.hpp"
+
+using ArduinoJson::detail::addPadding;
+
+TEST_CASE("JsonDocument constructor") {
+  SpyingAllocator spyingAllocator;
+
+  SECTION("JsonDocument(size_t)") {
+    { JsonDocument doc(&spyingAllocator); }
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
+  }
+
+  SECTION("JsonDocument(const JsonDocument&)") {
+    {
+      JsonDocument doc1(&spyingAllocator);
+      doc1.set(std::string("The size of this string is 32!!"));
+
+      JsonDocument doc2(doc1);
+
+      REQUIRE(doc1.as<std::string>() == "The size of this string is 32!!");
+      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
+    }
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofStringBuffer()),
+                                         Allocate(sizeofStringBuffer()),
+                                         Deallocate(sizeofStringBuffer()),
+                                         Deallocate(sizeofStringBuffer()),
+                                     });
+  }
+
+  SECTION("JsonDocument(JsonDocument&&)") {
+    {
+      JsonDocument doc1(&spyingAllocator);
+      doc1.set(std::string("The size of this string is 32!!"));
+
+      JsonDocument doc2(std::move(doc1));
+
+      REQUIRE(doc2.as<std::string>() == "The size of this string is 32!!");
+      REQUIRE(doc1.as<std::string>() == "null");
+    }
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofStringBuffer()),
+                                         Deallocate(sizeofStringBuffer()),
+                                     });
+  }
+
+  SECTION("JsonDocument(JsonObject, Allocator*)") {
+    JsonDocument doc1;
+    JsonObject obj = doc1.to<JsonObject>();
+    obj["hello"] = "world";
+
+    JsonDocument doc2(obj, &spyingAllocator);
+
+    REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofPool()),
+                                     });
+  }
+
+  SECTION("JsonDocument(JsonObject)") {
+    JsonDocument doc1;
+    JsonObject obj = doc1.to<JsonObject>();
+    obj["hello"] = "world";
+
+    JsonDocument doc2(obj);
+
+    REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
+  }
+
+  SECTION("JsonDocument(JsonArray, Allocator*)") {
+    JsonDocument doc1;
+    JsonArray arr = doc1.to<JsonArray>();
+    arr.add("hello");
+
+    JsonDocument doc2(arr, &spyingAllocator);
+
+    REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofPool()),
+                                     });
+  }
+
+  SECTION("JsonDocument(JsonArray)") {
+    JsonDocument doc1;
+    JsonArray arr = doc1.to<JsonArray>();
+    arr.add("hello");
+
+    JsonDocument doc2(arr);
+
+    REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
+  }
+
+  SECTION("JsonDocument(JsonVariant, Allocator*)") {
+    JsonDocument doc1;
+    deserializeJson(doc1, "\"hello\"");
+
+    JsonDocument doc2(doc1.as<JsonVariant>(), &spyingAllocator);
+
+    REQUIRE(doc2.as<std::string>() == "hello");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello")),
+                                     });
+  }
+
+  SECTION("JsonDocument(JsonVariant)") {
+    JsonDocument doc1;
+    deserializeJson(doc1, "\"hello\"");
+
+    JsonDocument doc2(doc1.as<JsonVariant>());
+
+    REQUIRE(doc2.as<std::string>() == "hello");
+  }
+}

lib/ArduinoJson/extras/tests/JsonDocument/containsKey.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::containsKey()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("returns true on object") {
     doc["hello"] = "world";

lib/ArduinoJson/extras/tests/JsonDocument/createNested.cpp

@@ -1,66 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonDocument::createNestedArray()") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("promotes to array") {
-    doc.createNestedArray();
-
-    REQUIRE(doc.is<JsonArray>());
-  }
-}
-
-TEST_CASE("JsonDocument::createNestedArray(key)") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("key is const char*") {
-    SECTION("promotes to object") {
-      doc.createNestedArray("hello");
-
-      REQUIRE(doc.is<JsonObject>());
-    }
-  }
-
-  SECTION("key is std::string") {
-    SECTION("promotes to object") {
-      doc.createNestedArray(std::string("hello"));
-
-      REQUIRE(doc.is<JsonObject>());
-    }
-  }
-}
-
-TEST_CASE("JsonDocument::createNestedObject()") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("promotes to array") {
-    doc.createNestedObject();
-
-    REQUIRE(doc.is<JsonArray>());
-  }
-}
-
-TEST_CASE("JsonDocument::createNestedObject(key)") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("key is const char*") {
-    SECTION("promotes to object") {
-      doc.createNestedObject("hello");
-
-      REQUIRE(doc.is<JsonObject>());
-    }
-  }
-
-  SECTION("key is std::string") {
-    SECTION("promotes to object") {
-      doc.createNestedObject(std::string("hello"));
-
-      REQUIRE(doc.is<JsonObject>());
-    }
-  }
-}

lib/ArduinoJson/extras/tests/JsonDocument/isNull.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::isNull()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("returns true if uninitialized") {
     REQUIRE(doc.isNull() == true);

lib/ArduinoJson/extras/tests/JsonDocument/issue1120.cpp

@@ -3,7 +3,7 @@
 #include <catch.hpp>
 
 TEST_CASE("Issue #1120") {
-  StaticJsonDocument<500> doc;
+  JsonDocument doc;
   constexpr char str[] =
       "{\"contents\":[{\"module\":\"Packet\"},{\"module\":\"Analog\"}]}";
   deserializeJson(doc, str);

lib/ArduinoJson/extras/tests/JsonDocument/nesting.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::nesting()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("return 0 if uninitialized") {
     REQUIRE(doc.nesting() == 0);

lib/ArduinoJson/extras/tests/JsonDocument/overflowed.cpp

@@ -1,85 +1,95 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+#include "Allocators.hpp"
+
 TEST_CASE("JsonDocument::overflowed()") {
+  TimebombAllocator timebomb(10);
+  JsonDocument doc(&timebomb);
+
   SECTION("returns false on a fresh object") {
-    StaticJsonDocument<0> doc;
+    timebomb.setCountdown(0);
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("returns true after a failed insertion") {
-    StaticJsonDocument<0> doc;
+    timebomb.setCountdown(0);
     doc.add(0);
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns false after successful insertion") {
-    StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
+    timebomb.setCountdown(2);
     doc.add(0);
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("returns true after a failed string copy") {
-    StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
+    timebomb.setCountdown(0);
     doc.add(std::string("example"));
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns false after a successful string copy") {
-    StaticJsonDocument<JSON_ARRAY_SIZE(1) + 8> doc;
+    timebomb.setCountdown(3);
     doc.add(std::string("example"));
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("returns true after a failed member add") {
-    StaticJsonDocument<1> doc;
+    timebomb.setCountdown(0);
     doc["example"] = true;
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns true after a failed deserialization") {
-    StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
-    deserializeJson(doc, "[\"example\"]");
+    timebomb.setCountdown(0);
+    deserializeJson(doc, "[1, 2]");
     CHECK(doc.overflowed() == true);
   }
 
   SECTION("returns false after a successful deserialization") {
-    StaticJsonDocument<JSON_ARRAY_SIZE(1) + 8> doc;
+    timebomb.setCountdown(3);
     deserializeJson(doc, "[\"example\"]");
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("returns false after clear()") {
-    StaticJsonDocument<0> doc;
+    timebomb.setCountdown(0);
     doc.add(0);
     doc.clear();
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("remains false after shrinkToFit()") {
-    DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
+    timebomb.setCountdown(2);
     doc.add(0);
+    timebomb.setCountdown(2);
     doc.shrinkToFit();
     CHECK(doc.overflowed() == false);
   }
 
   SECTION("remains true after shrinkToFit()") {
-    DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
-    doc.add(0);
+    timebomb.setCountdown(0);
     doc.add(0);
+    timebomb.setCountdown(2);
     doc.shrinkToFit();
     CHECK(doc.overflowed() == true);
   }
 
-  SECTION("return false after garbageCollect()") {
-    DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
-    doc.add(0);
-    doc.add(0);
-    doc.garbageCollect();
+  SECTION("returns false when string length doesn't overflow") {
+    auto maxLength = ArduinoJson::detail::StringNode::maxLength;
+    CHECK(doc.set(std::string(maxLength, 'a')) == true);
     CHECK(doc.overflowed() == false);
   }
+
+  SECTION("returns true when string length overflows") {
+    auto maxLength = ArduinoJson::detail::StringNode::maxLength;
+    CHECK(doc.set(std::string(maxLength + 1, 'a')) == false);
+    CHECK(doc.overflowed() == true);
+  }
 }

lib/ArduinoJson/extras/tests/JsonDocument/remove.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::remove()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("remove(int)") {
     doc.add(1);

lib/ArduinoJson/extras/tests/JsonDocument/shrinkToFit.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -8,145 +8,176 @@
 #include <stdlib.h>  // malloc, free
 #include <string>
 
-class ArmoredAllocator {
+#include "Allocators.hpp"
+
+using ArduinoJson::detail::sizeofArray;
+using ArduinoJson::detail::sizeofObject;
+
+class ArmoredAllocator : public Allocator {
  public:
-  ArmoredAllocator() : _ptr(0), _size(0) {}
+  virtual ~ArmoredAllocator() {}
 
-  void* allocate(size_t size) {
-    _ptr = malloc(size);
-    _size = size;
-    return _ptr;
+  void* allocate(size_t size) override {
+    return malloc(size);
   }
 
-  void deallocate(void* ptr) {
-    REQUIRE(ptr == _ptr);
+  void deallocate(void* ptr) override {
     free(ptr);
-    _ptr = 0;
-    _size = 0;
   }
 
-  void* reallocate(void* ptr, size_t new_size) {
-    REQUIRE(ptr == _ptr);
+  void* reallocate(void* ptr, size_t new_size) override {
     // don't call realloc, instead alloc a new buffer and erase the old one
     // this way we make sure we support relocation
     void* new_ptr = malloc(new_size);
-    memcpy(new_ptr, _ptr, std::min(new_size, _size));
-    memset(_ptr, '#', _size);  // erase
-    free(_ptr);
-    _ptr = new_ptr;
+    memset(new_ptr, '#', new_size);  // erase
+    if (ptr) {
+      memcpy(new_ptr, ptr, std::min(new_size, new_size));
+      free(ptr);
+    }
     return new_ptr;
   }
-
- private:
-  void* _ptr;
-  size_t _size;
 };
 
-typedef BasicJsonDocument<ArmoredAllocator> ShrinkToFitTestDocument;
-
-void testShrinkToFit(ShrinkToFitTestDocument& doc, std::string expected_json,
-                     size_t expected_size) {
-  // test twice: shrinkToFit() should be idempotent
-  for (int i = 0; i < 2; i++) {
-    doc.shrinkToFit();
-
-    REQUIRE(doc.capacity() == expected_size);
-    REQUIRE(doc.memoryUsage() == expected_size);
-
-    std::string json;
-    serializeJson(doc, json);
-    REQUIRE(json == expected_json);
-  }
-}
-
-TEST_CASE("BasicJsonDocument::shrinkToFit()") {
-  ShrinkToFitTestDocument doc(4096);
+TEST_CASE("JsonDocument::shrinkToFit()") {
+  ArmoredAllocator armoredAllocator;
+  SpyingAllocator spyingAllocator(&armoredAllocator);
+  JsonDocument doc(&spyingAllocator);
 
   SECTION("null") {
-    testShrinkToFit(doc, "null", 0);
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "null");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
   SECTION("empty object") {
     deserializeJson(doc, "{}");
-    testShrinkToFit(doc, "{}", JSON_OBJECT_SIZE(0));
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{}");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
   SECTION("empty array") {
     deserializeJson(doc, "[]");
-    testShrinkToFit(doc, "[]", JSON_ARRAY_SIZE(0));
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "[]");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
   SECTION("linked string") {
     doc.set("hello");
-    testShrinkToFit(doc, "\"hello\"", 0);
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "hello");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
   SECTION("owned string") {
     doc.set(std::string("abcdefg"));
-    testShrinkToFit(doc, "\"abcdefg\"", 8);
+    REQUIRE(doc.as<std::string>() == "abcdefg");
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "abcdefg");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("abcdefg")),
+                                     });
   }
 
-  SECTION("linked raw") {
-    doc.set(serialized("[{},123]"));
-    testShrinkToFit(doc, "[{},123]", 0);
-  }
+  SECTION("raw string") {
+    doc.set(serialized("[{},12]"));
 
-  SECTION("owned raw") {
-    doc.set(serialized(std::string("[{},12]")));
-    testShrinkToFit(doc, "[{},12]", 8);
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "[{},12]");
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("[{},12]")),
+                                     });
   }
 
   SECTION("linked key") {
     doc["key"] = 42;
-    testShrinkToFit(doc, "{\"key\":42}", JSON_OBJECT_SIZE(1));
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{\"key\":42}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Reallocate(sizeofPool(), sizeofObject(1)),
+            });
   }
 
   SECTION("owned key") {
     doc[std::string("abcdefg")] = 42;
-    testShrinkToFit(doc, "{\"abcdefg\":42}", JSON_OBJECT_SIZE(1) + 8);
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{\"abcdefg\":42}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofString("abcdefg")),
+                Allocate(sizeofPool()),
+                Reallocate(sizeofPool(), sizeofObject(1)),
+            });
   }
 
   SECTION("linked string in array") {
     doc.add("hello");
-    testShrinkToFit(doc, "[\"hello\"]", JSON_ARRAY_SIZE(1));
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "[\"hello\"]");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Reallocate(sizeofPool(), sizeofArray(1)),
+            });
   }
 
   SECTION("owned string in array") {
     doc.add(std::string("abcdefg"));
-    testShrinkToFit(doc, "[\"abcdefg\"]", JSON_ARRAY_SIZE(1) + 8);
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "[\"abcdefg\"]");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Allocate(sizeofString("abcdefg")),
+                Reallocate(sizeofPool(), sizeofArray(1)),
+            });
   }
 
   SECTION("linked string in object") {
     doc["key"] = "hello";
-    testShrinkToFit(doc, "{\"key\":\"hello\"}", JSON_OBJECT_SIZE(1));
+
+    doc.shrinkToFit();
+
+    REQUIRE(doc.as<std::string>() == "{\"key\":\"hello\"}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Reallocate(sizeofPool(), sizeofObject(1)),
+            });
   }
 
   SECTION("owned string in object") {
     doc["key"] = std::string("abcdefg");
-    testShrinkToFit(doc, "{\"key\":\"abcdefg\"}", JSON_ARRAY_SIZE(1) + 8);
-  }
-
-  SECTION("unaligned") {
-    doc.add(std::string("?"));  // two bytes in the string pool
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2);
 
     doc.shrinkToFit();
 
-    // the new capacity should be padded to align the pointers
-    REQUIRE(doc.capacity() == JSON_OBJECT_SIZE(1) + sizeof(void*));
-    REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2);
-    REQUIRE(doc[0] == "?");
+    REQUIRE(doc.as<std::string>() == "{\"key\":\"abcdefg\"}");
+    REQUIRE(spyingAllocator.log() ==
+            AllocatorLog{
+                Allocate(sizeofPool()),
+                Allocate(sizeofString("abcdefg")),
+                Reallocate(sizeofPool(), sizeofPool(1)),
+            });
   }
 }
-
-TEST_CASE("DynamicJsonDocument::shrinkToFit()") {
-  DynamicJsonDocument doc(4096);
-
-  deserializeJson(doc, "{\"hello\":[\"world\"]");
-
-  doc.shrinkToFit();
-
-  std::string json;
-  serializeJson(doc, json);
-  REQUIRE(json == "{\"hello\":[\"world\"]}");
-}

lib/ArduinoJson/extras/tests/JsonDocument/size.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::size()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("returns 0") {
     REQUIRE(doc.size() == 0);

lib/ArduinoJson/extras/tests/JsonDocument/subscript.cpp

@@ -1,12 +1,12 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
 TEST_CASE("JsonDocument::operator[]") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   const JsonDocument& cdoc = doc;
 
   SECTION("object") {
@@ -37,7 +37,7 @@ TEST_CASE("JsonDocument::operator[]") {
 }
 
 TEST_CASE("JsonDocument automatically promotes to object") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   doc["one"]["two"]["three"] = 4;
 
@@ -45,7 +45,7 @@ TEST_CASE("JsonDocument automatically promotes to object") {
 }
 
 TEST_CASE("JsonDocument automatically promotes to array") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   doc[2] = 2;
 

lib/ArduinoJson/extras/tests/JsonDocument/swap.cpp

@@ -7,21 +7,19 @@
 using namespace std;
 
 TEST_CASE("std::swap") {
-  SECTION("DynamicJsonDocument*") {
-    DynamicJsonDocument *p1, *p2;
+  SECTION("JsonDocument*") {
+    JsonDocument *p1, *p2;
     swap(p1, p2);  // issue #1678
   }
 
-  SECTION("DynamicJsonDocument") {
-    DynamicJsonDocument doc1(0x10), doc2(0x20);
+  SECTION("JsonDocument") {
+    JsonDocument doc1, doc2;
     doc1.set("hello");
     doc2.set("world");
 
     swap(doc1, doc2);
 
-    CHECK(doc1.capacity() == 0x20);
     CHECK(doc1.as<string>() == "world");
-    CHECK(doc2.capacity() == 0x10);
     CHECK(doc2.as<string>() == "hello");
   }
 }