Update to ArduinoJson 7.0.4

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

@@ -1,5 +1,5 @@
 # ArduinoJson - https://arduinojson.org
-# Copyright © 2014-2023, Benoit BLANCHON
+# Copyright © 2014-2024, Benoit BLANCHON
 # MIT License
 
 add_executable(JsonVariantTests
@@ -10,10 +10,8 @@ add_executable(JsonVariantTests
 	containsKey.cpp
 	converters.cpp
 	copy.cpp
-	createNested.cpp
 	is.cpp
 	isnull.cpp
-	memoryUsage.cpp
 	misc.cpp
 	nesting.cpp
 	nullptr.cpp
@@ -21,7 +19,6 @@ add_executable(JsonVariantTests
 	overflow.cpp
 	remove.cpp
 	set.cpp
-	shallowCopy.cpp
 	size.cpp
 	stl_containers.cpp
 	subscript.cpp

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

@@ -1,13 +1,13 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <stdint.h>
 #include <catch.hpp>
 
-TEST_CASE("JsonVariant::add()") {
-  DynamicJsonDocument doc(4096);
+TEST_CASE("JsonVariant::add(T)") {
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
 
   SECTION("add integer to new variant") {
@@ -44,3 +44,27 @@ TEST_CASE("JsonVariant::add()") {
     REQUIRE(var.as<std::string>() == "{\"val\":123}");
   }
 }
+
+TEST_CASE("JsonVariant::add<T>()") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  SECTION("JsonArray") {
+    JsonArray array = var.add<JsonArray>();
+    array.add(1);
+    array.add(2);
+    REQUIRE(doc.as<std::string>() == "[[1,2]]");
+  }
+
+  SECTION("JsonObject") {
+    JsonObject object = var.add<JsonObject>();
+    object["hello"] = "world";
+    REQUIRE(doc.as<std::string>() == "[{\"hello\":\"world\"}]");
+  }
+
+  SECTION("JsonVariant") {
+    JsonVariant variant = var.add<JsonVariant>();
+    variant.set(42);
+    REQUIRE(doc.as<std::string>() == "[42]");
+  }
+}

lib/ArduinoJson/extras/tests/JsonVariant/as.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -15,7 +15,7 @@ enum MY_ENUM { ONE = 1, TWO = 2 };
 TEST_CASE("JsonVariant::as()") {
   static const char* null = 0;
 
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("not set") {
@@ -251,17 +251,6 @@ TEST_CASE("JsonVariant::as()") {
   }
 #endif
 
-  SECTION("should work on JsonVariantConst") {
-    variant.set("hello");
-
-    JsonVariantConst cvar = variant;
-
-    REQUIRE(cvar.as<bool>() == true);
-    REQUIRE(cvar.as<long>() == 0L);
-    REQUIRE(cvar.as<const char*>() == std::string("hello"));
-    REQUIRE(cvar.as<std::string>() == std::string("hello"));
-  }
-
   SECTION("as<enum>()") {
     variant.set(1);
 

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

@@ -1,13 +1,16 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <stdint.h>
 #include <catch.hpp>
 
+#include "Allocators.hpp"
+
 TEST_CASE("JsonVariant::clear()") {
-  DynamicJsonDocument doc(4096);
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
   JsonVariant var = doc.to<JsonVariant>();
 
   SECTION("size goes back to zero") {
@@ -23,4 +26,14 @@ TEST_CASE("JsonVariant::clear()") {
 
     REQUIRE(var.isNull() == true);
   }
+
+  SECTION("releases owned string") {
+    var.set(std::string("hello"));
+    var.clear();
+
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofString("hello")),
+                             Deallocate(sizeofString("hello")),
+                         });
+  }
 }

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

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -9,8 +9,8 @@
 // Here, we're just filling the holes
 
 TEST_CASE("Compare JsonVariant with value") {
-  StaticJsonDocument<256> doc;
-  JsonVariant a = doc.add();
+  JsonDocument doc;
+  JsonVariant a = doc.add<JsonVariant>();
 
   SECTION("null vs (char*)0") {
     char* b = 0;
@@ -37,9 +37,9 @@ TEST_CASE("Compare JsonVariant with value") {
 }
 
 TEST_CASE("Compare JsonVariant with JsonVariant") {
-  StaticJsonDocument<256> doc;
-  JsonVariant a = doc.add();
-  JsonVariant b = doc.add();
+  JsonDocument doc;
+  JsonVariant a = doc.add<JsonVariant>();
+  JsonVariant b = doc.add<JsonVariant>();
 
   SECTION("'abc' vs 'abc'") {
     a.set("abc");

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

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -7,7 +7,7 @@
 #include <catch.hpp>
 
 TEST_CASE("JsonVariant::containsKey()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
 
   SECTION("containsKey(const char*)") {
@@ -24,19 +24,3 @@ TEST_CASE("JsonVariant::containsKey()") {
     REQUIRE(var.containsKey(std::string("world")) == false);
   }
 }
-
-TEST_CASE("JsonVariantConst::containsKey()") {
-  DynamicJsonDocument doc(4096);
-  doc["hello"] = "world";
-  JsonVariantConst cvar = doc.as<JsonVariant>();
-
-  SECTION("containsKey(const char*) returns true") {
-    REQUIRE(cvar.containsKey("hello") == true);
-    REQUIRE(cvar.containsKey("world") == false);
-  }
-
-  SECTION("containsKey(std::string) returns true") {
-    REQUIRE(cvar.containsKey(std::string("hello")) == true);
-    REQUIRE(cvar.containsKey(std::string("world")) == false);
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/converters.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -32,7 +32,7 @@ bool canConvertFromJson(JsonVariantConst src, const Date&) {
 }  // namespace
 
 TEST_CASE("Custom converter with overloading") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("convert JSON to Date") {
     doc["date"]["day"] = 2;
@@ -74,18 +74,18 @@ TEST_CASE("Custom converter with overloading") {
 
 class Complex {
  public:
-  explicit Complex(double r, double i) : _real(r), _imag(i) {}
+  explicit Complex(double r, double i) : real_(r), imag_(i) {}
 
   double real() const {
-    return _real;
+    return real_;
   }
 
   double imag() const {
-    return _imag;
+    return imag_;
   }
 
  private:
-  double _real, _imag;
+  double real_, imag_;
 };
 
 namespace ArduinoJson {
@@ -107,7 +107,7 @@ struct Converter<Complex> {
 }  // namespace ArduinoJson
 
 TEST_CASE("Custom converter with specialization") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
 
   SECTION("convert JSON to Complex") {
     doc["value"]["real"] = 2;

lib/ArduinoJson/extras/tests/JsonVariant/copy.cpp

@@ -1,19 +1,22 @@
 // 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("JsonVariant::set(JsonVariant)") {
-  DynamicJsonDocument doc1(4096);
-  DynamicJsonDocument doc2(4096);
+  KillswitchAllocator killswitch;
+  SpyingAllocator spyingAllocator(&killswitch);
+  JsonDocument doc1(&spyingAllocator);
+  JsonDocument doc2(&spyingAllocator);
   JsonVariant var1 = doc1.to<JsonVariant>();
   JsonVariant var2 = doc2.to<JsonVariant>();
 
   SECTION("stores JsonArray by copy") {
     JsonArray arr = doc2.to<JsonArray>();
-    JsonObject obj = arr.createNestedObject();
+    JsonObject obj = arr.add<JsonObject>();
     obj["hello"] = "world";
 
     var1.set(arr);
@@ -24,7 +27,7 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
 
   SECTION("stores JsonObject by copy") {
     JsonObject obj = doc2.to<JsonObject>();
-    JsonArray arr = obj.createNestedArray("value");
+    JsonArray arr = obj["value"].to<JsonArray>();
     arr.add(42);
 
     var1.set(obj);
@@ -35,53 +38,95 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
 
   SECTION("stores const char* by reference") {
     var1.set("hello!!");
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == 0);
-    REQUIRE(doc2.memoryUsage() == 0);
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
   }
 
   SECTION("stores char* by copy") {
     char str[] = "hello!!";
-
     var1.set(str);
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
+  }
+
+  SECTION("fails gracefully if string allocation fails") {
+    char str[] = "hello!!";
+    var1.set(str);
+    killswitch.on();
+    spyingAllocator.clearLog();
+
+    var2.set(var1);
+
+    REQUIRE(doc2.overflowed() == true);
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         AllocateFail(sizeofString("hello!!")),
+                                     });
   }
 
   SECTION("stores std::string by copy") {
     var1.set(std::string("hello!!"));
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
   }
 
-  SECTION("stores Serialized<const char*> by reference") {
-    var1.set(serialized("hello!!", 8));
+  SECTION("stores Serialized<const char*> by copy") {
+    var1.set(serialized("hello!!", 7));
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == 0);
-    REQUIRE(doc2.memoryUsage() == 0);
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
   }
 
   SECTION("stores Serialized<char*> by copy") {
     char str[] = "hello!!";
     var1.set(serialized(str, 7));
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
   }
 
   SECTION("stores Serialized<std::string> by copy") {
     var1.set(serialized(std::string("hello!!")));
+    spyingAllocator.clearLog();
+
     var2.set(var1);
 
-    REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7));
-    REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         Allocate(sizeofString("hello!!")),
+                                     });
+  }
+
+  SECTION("fails gracefully if raw string allocation fails") {
+    var1.set(serialized(std::string("hello!!")));
+    killswitch.on();
+    spyingAllocator.clearLog();
+
+    var2.set(var1);
+
+    REQUIRE(doc2.overflowed() == true);
+    REQUIRE(spyingAllocator.log() == AllocatorLog{
+                                         AllocateFail(sizeofString("hello!!")),
+                                     });
   }
 
   SECTION("destination is unbound") {

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

@@ -1,58 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <stdint.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonVariant::createNestedObject()") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
-
-  SECTION("promotes to array") {
-    JsonObject obj = variant.createNestedObject();
-    obj["value"] = 42;
-
-    REQUIRE(variant.is<JsonArray>() == true);
-    REQUIRE(variant[0]["value"] == 42);
-    REQUIRE(obj.isNull() == false);
-  }
-}
-
-TEST_CASE("JsonVariant::createNestedArray()") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
-
-  SECTION("promotes to array") {
-    JsonArray arr = variant.createNestedArray();
-
-    REQUIRE(variant.is<JsonArray>() == true);
-    REQUIRE(arr.isNull() == false);
-  }
-}
-
-TEST_CASE("JsonVariant::createNestedObject(key)") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
-
-  SECTION("promotes to object") {
-    JsonObject obj = variant.createNestedObject("weather");
-    obj["temp"] = 42;
-
-    REQUIRE(variant.is<JsonObject>() == true);
-    REQUIRE(variant["weather"]["temp"] == 42);
-  }
-}
-
-TEST_CASE("JsonVariant::createNestedArray(key)") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
-
-  SECTION("promotes to object") {
-    JsonArray arr = variant.createNestedArray("items");
-
-    REQUIRE(variant.is<JsonObject>() == true);
-    REQUIRE(arr.isNull() == false);
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/is.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 @@
 enum MYENUM2 { ONE = 1, TWO = 2 };
 
 TEST_CASE("JsonVariant::is<T>()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("unbound") {
@@ -162,158 +162,3 @@ TEST_CASE("JsonVariant::is<T>()") {
     CHECK(variant.is<JsonVariantConst>() == true);
   }
 }
-
-TEST_CASE("JsonVariantConst::is<T>()") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
-  JsonVariantConst cvariant = variant;
-
-  SECTION("unbound") {
-    cvariant = JsonVariantConst();
-
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonArrayConst>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonObjectConst>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonVariantConst>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("null") {
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("true") {
-    variant.set(true);
-
-    CHECK(cvariant.is<bool>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("false") {
-    variant.set(false);
-
-    CHECK(cvariant.is<bool>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("int") {
-    variant.set(42);
-
-    CHECK(cvariant.is<int>() == true);
-    CHECK(cvariant.is<short>() == true);
-    CHECK(cvariant.is<long>() == true);
-    CHECK(cvariant.is<double>() == true);
-    CHECK(cvariant.is<float>() == true);
-    CHECK(cvariant.is<MYENUM2>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-  }
-
-  SECTION("double") {
-    variant.set(4.2);
-
-    CHECK(cvariant.is<double>() == true);
-    CHECK(cvariant.is<float>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("const char*") {
-    variant.set("4.2");
-
-    CHECK(cvariant.is<const char*>() == true);
-    CHECK(cvariant.is<const char*>() == true);
-    CHECK(cvariant.is<std::string>() == true);
-    CHECK(cvariant.is<JsonString>() == true);
-    CHECK(cvariant.is<double>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("JsonArray") {
-    variant.to<JsonArray>();
-
-    CHECK(cvariant.is<JsonArrayConst>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonObjectConst>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("JsonObject") {
-    variant.to<JsonObject>();
-
-    CHECK(cvariant.is<JsonObjectConst>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonArrayConst>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/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("JsonVariant::isNull()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("returns true when Undefined") {
@@ -20,7 +20,7 @@ TEST_CASE("JsonVariant::isNull()") {
   }
 
   SECTION("returns false when EmptyArray") {
-    DynamicJsonDocument doc2(4096);
+    JsonDocument doc2;
     JsonArray array = doc2.to<JsonArray>();
 
     variant.set(array);
@@ -28,7 +28,7 @@ TEST_CASE("JsonVariant::isNull()") {
   }
 
   SECTION("returns false when EmptyObject") {
-    DynamicJsonDocument doc2(4096);
+    JsonDocument doc2;
     JsonObject obj = doc2.to<JsonObject>();
 
     variant.set(obj);
@@ -69,25 +69,4 @@ TEST_CASE("JsonVariant::isNull()") {
     variant.set(serialized(static_cast<const char*>(0)));
     REQUIRE(variant.isNull() == true);
   }
-
-  SECTION("returns true for a shallow null copy") {
-    StaticJsonDocument<128> doc2;
-    variant.shallowCopy(doc2);
-    CHECK(variant.isNull() == true);
-  }
-
-  SECTION("returns false for a shallow array copy") {
-    StaticJsonDocument<128> doc2;
-    doc2[0] = 42;
-    variant.shallowCopy(doc2);
-    CHECK(variant.isNull() == false);
-  }
-
-  SECTION("works with JsonVariantConst") {
-    variant.set(42);
-
-    JsonVariantConst cvar = variant;
-
-    REQUIRE(cvar.isNull() == false);
-  }
 }

lib/ArduinoJson/extras/tests/JsonVariant/memoryUsage.cpp

@@ -1,41 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-#include <string>
-
-TEST_CASE("JsonVariant::memoryUsage()") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant var = doc.to<JsonVariant>();
-
-  SECTION("returns 0 if uninitialized") {
-    JsonVariant unitialized;
-    REQUIRE(unitialized.memoryUsage() == 0);
-  }
-
-  SECTION("returns size of object") {
-    JsonObject obj = var.to<JsonObject>();
-    obj["hello"] = 42;
-    REQUIRE(var.memoryUsage() == JSON_OBJECT_SIZE(1));
-  }
-
-  SECTION("returns size of array") {
-    JsonArray arr = var.to<JsonArray>();
-    arr.add(42);
-    REQUIRE(var.memoryUsage() == JSON_ARRAY_SIZE(1));
-  }
-
-  SECTION("returns size of owned string") {
-    var.set(std::string("hello"));
-    REQUIRE(var.memoryUsage() == 6);
-    REQUIRE(var.memoryUsage() == doc.memoryUsage());
-  }
-
-  SECTION("returns size of owned raw") {
-    var.set(serialized(std::string("hello")));
-    REQUIRE(var.memoryUsage() == 6);
-    REQUIRE(var.memoryUsage() == doc.memoryUsage());
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/misc.cpp

@@ -1,10 +1,20 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+TEST_CASE("VariantData") {
+  REQUIRE(std::is_standard_layout<ArduinoJson::detail::VariantData>::value ==
+          true);
+}
+
+TEST_CASE("StringNode") {
+  REQUIRE(std::is_standard_layout<ArduinoJson::detail::StringNode>::value ==
+          true);
+}
+
 TEST_CASE("JsonVariant from JsonArray") {
   SECTION("JsonArray is null") {
     JsonArray arr;
@@ -13,7 +23,7 @@ TEST_CASE("JsonVariant from JsonArray") {
   }
 
   SECTION("JsonArray is not null") {
-    DynamicJsonDocument doc(4096);
+    JsonDocument doc;
     JsonArray arr = doc.to<JsonArray>();
     arr.add(12);
     arr.add(34);
@@ -35,7 +45,7 @@ TEST_CASE("JsonVariant from JsonObject") {
   }
 
   SECTION("JsonObject is not null") {
-    DynamicJsonDocument doc(4096);
+    JsonDocument doc;
     JsonObject obj = doc.to<JsonObject>();
     obj["a"] = 12;
     obj["b"] = 34;

lib/ArduinoJson/extras/tests/JsonVariant/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("JsonVariant::nesting()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
 
   SECTION("return 0 if uninitialized") {

lib/ArduinoJson/extras/tests/JsonVariant/nullptr.cpp

@@ -3,7 +3,7 @@
 #include <catch.hpp>
 
 TEST_CASE("nullptr") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("JsonVariant == nullptr") {

lib/ArduinoJson/extras/tests/JsonVariant/or.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("JsonVariant::operator|()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc["value"].to<JsonVariant>();
 
   SECTION("null") {

lib/ArduinoJson/extras/tests/JsonVariant/overflow.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -7,7 +7,7 @@
 
 template <typename TOut, typename TIn>
 void shouldBeOk(TIn value) {
-  StaticJsonDocument<1> doc;
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
   var.set(value);
   REQUIRE(var.as<TOut>() == TOut(value));
@@ -15,7 +15,7 @@ void shouldBeOk(TIn value) {
 
 template <typename TOut, typename TIn>
 void shouldOverflow(TIn value) {
-  StaticJsonDocument<1> doc;
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
   var.set(value);
   REQUIRE(var.as<TOut>() == 0);

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

@@ -1,40 +1,83 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
 #include <stdint.h>
 #include <catch.hpp>
 
-TEST_CASE("JsonVariant::remove()") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant var = doc.to<JsonVariant>();
+#include "Allocators.hpp"
 
-  SECTION("remove(int)") {
-    var.add(1);
-    var.add(2);
-    var.add(3);
+using ArduinoJson::detail::sizeofArray;
 
+TEST_CASE("JsonVariant::remove(int)") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+
+  SECTION("release top level strings") {
+    doc.add(std::string("hello"));
+    doc.add(std::string("hello"));
+    doc.add(std::string("world"));
+
+    JsonVariant var = doc.as<JsonVariant>();
+    REQUIRE(var.as<std::string>() == "[\"hello\",\"hello\",\"world\"]");
+
+    spy.clearLog();
     var.remove(1);
+    REQUIRE(var.as<std::string>() == "[\"hello\",\"world\"]");
+    REQUIRE(spy.log() == AllocatorLog{});
 
-    REQUIRE(var.as<std::string>() == "[1,3]");
+    spy.clearLog();
+    var.remove(1);
+    REQUIRE(var.as<std::string>() == "[\"hello\"]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                         });
+
+    spy.clearLog();
+    var.remove(0);
+    REQUIRE(var.as<std::string>() == "[]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("hello")),
+                         });
   }
 
-  SECTION("remove(const char *)") {
-    var["a"] = 1;
-    var["b"] = 2;
+  SECTION("release strings in nested array") {
+    doc[0][0] = std::string("hello");
 
-    var.remove("a");
+    JsonVariant var = doc.as<JsonVariant>();
+    REQUIRE(var.as<std::string>() == "[[\"hello\"]]");
 
-    REQUIRE(var.as<std::string>() == "{\"b\":2}");
-  }
+    spy.clearLog();
+    var.remove(0);
 
-  SECTION("remove(std::string)") {
-    var["a"] = 1;
-    var["b"] = 2;
-
-    var.remove(std::string("b"));
-
-    REQUIRE(var.as<std::string>() == "{\"a\":1}");
+    REQUIRE(var.as<std::string>() == "[]");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("hello")),
+                         });
   }
 }
+
+TEST_CASE("JsonVariant::remove(const char *)") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  var["a"] = 1;
+  var["b"] = 2;
+
+  var.remove("a");
+
+  REQUIRE(var.as<std::string>() == "{\"b\":2}");
+}
+
+TEST_CASE("JsonVariant::remove(std::string)") {
+  JsonDocument doc;
+  JsonVariant var = doc.to<JsonVariant>();
+
+  var["a"] = 1;
+  var["b"] = 2;
+
+  var.remove(std::string("b"));
+
+  REQUIRE(var.as<std::string>() == "{\"a\":1}");
+}

lib/ArduinoJson/extras/tests/JsonVariant/set.cpp

@@ -1,14 +1,18 @@
 // 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"
+
+using ArduinoJson::detail::sizeofObject;
+
 enum ErrorCode { ERROR_01 = 1, ERROR_10 = 10 };
 
 TEST_CASE("JsonVariant::set() when there is enough memory") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("const char*") {
@@ -128,7 +132,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
 }
 
 TEST_CASE("JsonVariant::set() with not enough memory") {
-  StaticJsonDocument<1> doc;
+  JsonDocument doc(FailingAllocator::instance());
 
   JsonVariant v = doc.to<JsonVariant>();
 
@@ -155,11 +159,11 @@ TEST_CASE("JsonVariant::set() with not enough memory") {
   }
 }
 
-TEST_CASE("JsonVariant::set(DynamicJsonDocument)") {
-  DynamicJsonDocument doc1(1024);
+TEST_CASE("JsonVariant::set(JsonDocument)") {
+  JsonDocument doc1;
   doc1["hello"] = "world";
 
-  DynamicJsonDocument doc2(1024);
+  JsonDocument doc2;
   JsonVariant v = doc2.to<JsonVariant>();
 
   // Should copy the doc
@@ -170,3 +174,48 @@ TEST_CASE("JsonVariant::set(DynamicJsonDocument)") {
   serializeJson(doc2, json);
   REQUIRE(json == "{\"hello\":\"world\"}");
 }
+
+TEST_CASE("JsonVariant::set() releases the previous value") {
+  SpyingAllocator spy;
+  JsonDocument doc(&spy);
+  doc["hello"] = std::string("world");
+  spy.clearLog();
+
+  JsonVariant v = doc["hello"];
+
+  SECTION("int") {
+    v.set(42);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("bool") {
+    v.set(false);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("const char*") {
+    v.set("hello");
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("float") {
+    v.set(1.2);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("Serialized<const char*>") {
+    v.set(serialized("[]"));
+    REQUIRE(spy.log() == AllocatorLog{
+                             Deallocate(sizeofString("world")),
+                             Allocate(sizeofString("[]")),
+                         });
+  }
+}

lib/ArduinoJson/extras/tests/JsonVariant/shallowCopy.cpp

@@ -1,87 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonVariant::shallowCopy()") {
-  StaticJsonDocument<1024> doc1, doc2;
-  JsonVariant variant = doc1.to<JsonVariant>();
-
-  SECTION("JsonVariant::shallowCopy(JsonDocument&)") {
-    doc2["hello"] = "world";
-
-    variant.shallowCopy(doc2);
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
-
-    // altering the linked document should change the result
-    doc2["hello"] = "WORLD!";
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}");
-  }
-
-  SECTION("JsonVariant::shallowCopy(MemberProxy)") {
-    doc2["obj"]["hello"] = "world";
-
-    variant.shallowCopy(doc2["obj"]);
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
-
-    // altering the linked document should change the result
-    doc2["obj"]["hello"] = "WORLD!";
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}");
-  }
-
-  SECTION("JsonVariant::shallowCopy(ElementProxy)") {
-    doc2[0]["hello"] = "world";
-
-    variant.shallowCopy(doc2[0]);
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
-
-    // altering the linked document should change the result
-    doc2[0]["hello"] = "WORLD!";
-
-    CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}");
-  }
-
-  SECTION("target is unbound") {
-    JsonVariant unbound;
-    variant["hello"] = "world";
-
-    variant.shallowCopy(unbound);
-
-    CHECK(variant.isUnbound() == false);
-    CHECK(variant.isNull() == true);
-    CHECK(variant.memoryUsage() == 0);
-    CHECK(variant.size() == 0);
-  }
-
-  SECTION("variant is unbound") {
-    JsonVariant unbound;
-    doc2["hello"] = "world";
-
-    unbound.shallowCopy(doc2);
-
-    CHECK(unbound.isUnbound() == true);
-    CHECK(unbound.isNull() == true);
-    CHECK(unbound.memoryUsage() == 0);
-    CHECK(unbound.size() == 0);
-  }
-
-  SECTION("preserves owned key bit") {
-    doc2.set(42);
-
-    doc1["a"].shallowCopy(doc2);
-    doc1[std::string("b")].shallowCopy(doc2);
-
-    JsonObject::iterator it = doc1.as<JsonObject>().begin();
-
-    CHECK(it->key().isLinked() == true);
-    ++it;
-    CHECK(it->key().isLinked() == false);
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/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("JsonVariant::size()") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   SECTION("unbound reference") {

lib/ArduinoJson/extras/tests/JsonVariant/stl_containers.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -69,13 +69,13 @@ TEST_CASE("vector<int>") {
   SECTION("toJson") {
     std::vector<int> v = {1, 2};
 
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     doc.set(v);
     REQUIRE(doc.as<std::string>() == "[1,2]");
   }
 
   SECTION("fromJson") {
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     doc.add(1);
     doc.add(2);
 
@@ -86,7 +86,7 @@ TEST_CASE("vector<int>") {
   }
 
   SECTION("checkJson") {
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     CHECK(doc.is<std::vector<int>>() == false);
 
     doc.add(1);
@@ -106,13 +106,13 @@ TEST_CASE("array<int, 2>") {
     v[0] = 1;
     v[1] = 2;
 
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     doc.set(v);
     REQUIRE(doc.as<std::string>() == "[1,2]");
   }
 
   SECTION("fromJson") {
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     doc.add(1);
     doc.add(2);
 
@@ -123,7 +123,7 @@ TEST_CASE("array<int, 2>") {
   }
 
   SECTION("checkJson") {
-    StaticJsonDocument<128> doc;
+    JsonDocument doc;
     CHECK(doc.is<array_type>() == false);
 
     doc.add(1);

lib/ArduinoJson/extras/tests/JsonVariant/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("JsonVariant::operator[]") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant var = doc.to<JsonVariant>();
 
   SECTION("The JsonVariant is null") {
@@ -50,7 +50,7 @@ TEST_CASE("JsonVariant::operator[]") {
     }
 
     SECTION("set value in a nested object") {
-      array.createNestedObject();
+      array.add<JsonObject>();
 
       var[0]["hello"] = "world";
 
@@ -130,75 +130,3 @@ TEST_CASE("JsonVariant::operator[]") {
   }
 #endif
 }
-
-TEST_CASE("JsonVariantConst::operator[]") {
-  DynamicJsonDocument doc(4096);
-  JsonVariant var = doc.to<JsonVariant>();
-  JsonVariantConst cvar = var;
-
-  SECTION("The JsonVariant is null") {
-    REQUIRE(0 == cvar.size());
-    REQUIRE(cvar["0"].isNull());
-    REQUIRE(cvar[0].isNull());
-  }
-
-  SECTION("The JsonVariant is a string") {
-    var.set("hello world");
-    REQUIRE(0 == cvar.size());
-    REQUIRE(cvar["0"].isNull());
-    REQUIRE(cvar[0].isNull());
-  }
-
-  SECTION("The JsonVariant is a JsonArray") {
-    JsonArray array = var.to<JsonArray>();
-
-    SECTION("get value") {
-      array.add("element at index 0");
-      array.add("element at index 1");
-
-      REQUIRE(2 == cvar.size());
-      REQUIRE(std::string("element at index 0") == cvar[0]);
-      REQUIRE(std::string("element at index 1") == cvar[1]);
-      REQUIRE(std::string("element at index 0") ==
-              var[static_cast<unsigned char>(0)]);  // issue #381
-      REQUIRE(cvar[666].isNull());
-      REQUIRE(cvar[3].isNull());
-      REQUIRE(cvar["0"].isNull());
-    }
-  }
-
-  SECTION("The JsonVariant is a JsonObject") {
-    JsonObject object = var.to<JsonObject>();
-
-    SECTION("get value") {
-      object["a"] = "element at key \"a\"";
-      object["b"] = "element at key \"b\"";
-
-      REQUIRE(2 == cvar.size());
-      REQUIRE(std::string("element at key \"a\"") == cvar["a"]);
-      REQUIRE(std::string("element at key \"b\"") == cvar["b"]);
-      REQUIRE(cvar["c"].isNull());
-      REQUIRE(cvar[0].isNull());
-    }
-  }
-
-  SECTION("Auto promote null JsonVariant to JsonObject") {
-    var["hello"] = "world";
-
-    REQUIRE(var.is<JsonObject>() == true);
-  }
-
-  SECTION("Don't auto promote non-null JsonVariant to JsonObject") {
-    var.set(42);
-    var["hello"] = "world";
-
-    REQUIRE(var.is<JsonObject>() == false);
-  }
-
-  SECTION("Don't auto promote null JsonVariant to JsonObject when reading") {
-    const char* value = var["hello"];
-
-    REQUIRE(var.is<JsonObject>() == false);
-    REQUIRE(value == 0);
-  }
-}

lib/ArduinoJson/extras/tests/JsonVariant/types.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -9,7 +9,7 @@
 
 template <typename T>
 void checkValue(T expected) {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
   variant.set(expected);
@@ -24,7 +24,7 @@ void checkReference(T& expected) {
 
 template <typename T>
 void checkNumericType() {
-  DynamicJsonDocument docMin(4096), docMax(4096);
+  JsonDocument docMin, docMax;
   JsonVariant variantMin = docMin.to<JsonVariant>();
   JsonVariant variantMax = docMax.to<JsonVariant>();
 
@@ -129,7 +129,7 @@ TEST_CASE("JsonVariant set()/get()") {
 #endif
 
   SECTION("CanStoreObject") {
-    DynamicJsonDocument doc(4096);
+    JsonDocument doc;
     JsonObject object = doc.to<JsonObject>();
 
     checkValue<JsonObject>(object);
@@ -137,9 +137,16 @@ TEST_CASE("JsonVariant set()/get()") {
 }
 
 TEST_CASE("volatile") {
-  DynamicJsonDocument doc(4096);
+  JsonDocument doc;
   JsonVariant variant = doc.to<JsonVariant>();
 
+  SECTION("volatile bool") {  // issue #2029
+    volatile bool f = true;
+    variant.set(f);
+    CHECK(variant.is<bool>() == true);
+    CHECK(variant.as<bool>() == true);
+  }
+
   SECTION("volatile int") {
     volatile int f = 42;
     variant.set(f);

lib/ArduinoJson/extras/tests/JsonVariant/unbound.cpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #include <ArduinoJson.h>
@@ -44,6 +44,7 @@ TEST_CASE("Unbound JsonVariant") {
     CHECK_FALSE(variant.set(42L));
     CHECK_FALSE(variant.set(42U));
     CHECK_FALSE(variant.set(serialized("42")));
+    CHECK_FALSE(variant.set(serialized(std::string("42"))));
     CHECK_FALSE(variant.set(true));
   }
 
@@ -63,4 +64,13 @@ TEST_CASE("Unbound JsonVariant") {
     CHECK_FALSE(variant["key"].set(1));
     CHECK_FALSE(variant[std::string("key")].set(1));
   }
+
+  SECTION("containsKey()") {
+    CHECK_FALSE(variant.containsKey("hello"));
+  }
+
+  SECTION("remove()") {
+    variant.remove(0);
+    variant.remove("hello");
+  }
 }