CI: upgrade Windows runner

Replacing `true` with `1` changes `JsonString("ABC", true)` into `JsonString("ABC", 1)`, so all static strings had a length of 1.

This is a workaround for arduino/ArduinoCore-sam#50
Fixes #2181

.github/workflows/ci.yml

@@ -179,19 +179,19 @@ jobs:
 
   conf_test_windows:
     name: Test configuration on Windows
-    runs-on: windows-2019
+    runs-on: windows-2022
     needs: [gcc, clang]
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: 32-bit
         run: |
-          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars32.bat"
           cl /Isrc extras/conf_test/x86.cpp
         shell: cmd
       - name: 64-bit
         run: |
-          call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+          call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
           cl /Isrc extras/conf_test/x64.cpp
         shell: cmd
 

CHANGELOG.md

@@ -1,42 +1,10 @@
 ArduinoJson: change log
 =======================
 
-HEAD
+v7.4.2 (2025-06-20)
-----
+------
 
-* Optimize storage of static strings
+* Fix truncated strings on Arduino Due (issue #2181)
-
-> ### BREAKING CHANGES
->
-> Static string cannot contain NUL characters anymore (they could since 7.3.0).
-> This is an extremely rare case, so you probably won't be affected.
->
-> For example, the following code produces different output in 7.3 and 7.4:
->
-> ```cpp
-> JsonDocument doc;
-> doc["a\0b"] = "c\0d";
-> serializeJson(doc, Serial);
-> // With Arduino 7.3 -> {"a\u0000b":"c\u0000d"}
-> // With Arduino 7.4 -> {"a":"c"}
-> ```
->
-> `JsonString` contructor now only accepts two arguments, not three.
-> If your code uses `JsonString` to store a string as a pointer, you must remove the size argument.
->
-> For example, if you have something like this:
->
-> ```cpp
-> doc["key"] = JsonString(str.c_str(), str.size(), true);
-> ```
->
-> You must replace with either:
->
-> ```cpp
-> doc["key"] = JsonString(str.c_str(), true);  // store as pointer, cannot contain NUL characters
-> doc["key"] = JsonString(str.c_str(), str.size()); // store by copy, NUL characters allowed
-> doc["key"] = str; // same as previous line for supported string classes (`String`, `std::string`, etc.)
-> ```
 
 v7.4.1 (2025-04-11)
 ------

CMakeLists.txt

@@ -10,7 +10,7 @@ if(ESP_PLATFORM)
 	return()
 endif()
 
-project(ArduinoJson VERSION 7.4.1)
+project(ArduinoJson VERSION 7.4.2)
 
 if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
 	include(CTest)

README.md

@@ -139,11 +139,6 @@ See the [tutorial on arduinojson.org](https://arduinojson.org/v7/doc/serializati
 
 ArduinoJson is thankful to its sponsors. Please give them a visit; they deserve it!
 
-<p>
-  <a href="https://www.programmingelectronics.com/" rel="sponsored">
-    <img src="https://arduinojson.org/images/2021/10/programmingeleactronicsacademy.png" alt="Programming Electronics Academy" width="200">
-  </a>
-</p>
 <p>
   <a href="https://github.com/1technophile" rel="sponsored">
     <img alt="1technophile" src="https://avatars.githubusercontent.com/u/12672732?s=40&v=4">

appveyor.yml

@@ -1,4 +1,4 @@
-version: 7.4.1.{build}
+version: 7.4.2.{build}
 environment:
   matrix:
     - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022

extras/conf_test/avr.cpp

@@ -12,7 +12,7 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 0, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(sizeof(ArduinoJson::detail::VariantData) == 6, "slot size");
+static_assert(ArduinoJson::detail::ResourceManager::slotSize == 6, "slot size");
 
 void setup() {}
 void loop() {}

extras/conf_test/esp8266.cpp

@@ -10,7 +10,7 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(sizeof(VariantData) == 8, "slot size");
+static_assert(ArduinoJson::detail::ResourceManager::slotSize == 8, "slot size");
 
 void setup() {}
 void loop() {}

extras/conf_test/x64.cpp

@@ -10,6 +10,7 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(sizeof(ArduinoJson::detail::VariantData) == 16, "slot size");
+static_assert(ArduinoJson::detail::ResourceManager::slotSize == 16,
+              "slot size");
 
 int main() {}

extras/conf_test/x86.cpp

@@ -10,6 +10,6 @@ static_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, "ARDUINOJSON_LITTLE_ENDIAN");
 
 static_assert(ARDUINOJSON_USE_DOUBLE == 1, "ARDUINOJSON_USE_DOUBLE");
 
-static_assert(sizeof(ArduinoJson::detail::VariantData) == 8, "slot size");
+static_assert(ArduinoJson::detail::ResourceManager::slotSize == 8, "slot size");
 
 int main() {}

extras/tests/Deprecated/BasicJsonDocument.cpp

@@ -54,7 +54,7 @@ TEST_CASE("BasicJsonDocument") {
     doc["hello"] = "world";
     auto copy = doc;
     REQUIRE(copy.as<std::string>() == "{\"hello\":\"world\"}");
-    REQUIRE(allocatorLog == "AAAA");
+    REQUIRE(allocatorLog == "AA");
   }
 
   SECTION("capacity") {

extras/tests/Helpers/Allocators.hpp

@@ -269,16 +269,10 @@ inline size_t sizeofPoolList(size_t n = ARDUINOJSON_INITIAL_POOL_COUNT) {
   return sizeof(MemoryPool<VariantData>) * n;
 }
 
-template <typename T = ArduinoJson::detail::VariantData>
 inline size_t sizeofPool(
     ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {
-  return ArduinoJson::detail::MemoryPool<T>::slotsToBytes(n);
-}
-
-inline size_t sizeofStaticStringPool(
-    ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {
   using namespace ArduinoJson::detail;
-  return MemoryPool<const char*>::slotsToBytes(n);
+  return MemoryPool<VariantData>::slotsToBytes(n);
 }
 
 inline size_t sizeofStringBuffer(size_t iteration = 1) {

extras/tests/JsonArray/add.cpp

@@ -8,7 +8,7 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
-using namespace ArduinoJson::detail;
+using ArduinoJson::detail::sizeofArray;
 
 TEST_CASE("JsonArray::add(T)") {
   SpyingAllocator spy;
@@ -33,8 +33,7 @@ TEST_CASE("JsonArray::add(T)") {
     REQUIRE(array[0].is<double>());
     REQUIRE_FALSE(array[0].is<bool>());
     REQUIRE(spy.log() == AllocatorLog{
-                             Allocate(sizeofPool<VariantData>()),
+                             Allocate(sizeofPool()),
-                             Allocate(sizeofPool<EightByteValue>()),
                          });
   }
 
@@ -57,7 +56,6 @@ TEST_CASE("JsonArray::add(T)") {
     REQUIRE(array[0].is<int>() == false);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonDeserializer/array.cpp

@@ -7,7 +7,7 @@
 
 #include "Allocators.hpp"
 
-using namespace ArduinoJson::detail;
+using ArduinoJson::detail::sizeofArray;
 
 TEST_CASE("deserialize JSON array") {
   SpyingAllocator spy;
@@ -92,12 +92,8 @@ TEST_CASE("deserialize JSON array") {
       REQUIRE(arr[0].as<double>() == Approx(4.2123456));
       REQUIRE(arr[1] == -7E89);
       REQUIRE(spy.log() == AllocatorLog{
-                               Allocate(sizeofPool<VariantData>()),
+                               Allocate(sizeofPool()),
-                               Allocate(sizeofPool<EightByteValue>()),
+                               Reallocate(sizeofPool(), sizeofPool(4)),
-                               Reallocate(sizeofPool<VariantData>(),
-                                          sizeofPool<VariantData>(2)),
-                               Reallocate(sizeofPool<EightByteValue>(),
-                                          sizeofPool<EightByteValue>(2)),
                            });
     }
 

extras/tests/JsonDeserializer/destination_types.cpp

@@ -104,8 +104,6 @@ TEST_CASE("deserializeJson(MemberProxy)") {
 
     REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\",\"value\":[42]}");
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() == AllocatorLog{});
-                             Allocate(sizeofStaticStringPool()),
-                         });
   }
 }

extras/tests/JsonDeserializer/errors.cpp

@@ -121,7 +121,7 @@ TEST_CASE("deserializeJson() returns NoMemory if string length overflows") {
   }
 }
 
-TEST_CASE("deserializeJson() returns NoMemory if 8-bit slot allocation fails") {
+TEST_CASE("deserializeJson() returns NoMemory if extension allocation fails") {
   JsonDocument doc(FailingAllocator::instance());
 
   SECTION("uint32_t should pass") {

extras/tests/JsonDeserializer/filter.cpp

@@ -825,9 +825,7 @@ TEST_CASE("shrink filter") {
 
   deserializeJson(doc, "{}", DeserializationOption::Filter(filter));
 
-  REQUIRE(spy.log() ==
+  REQUIRE(spy.log() == AllocatorLog{
-          AllocatorLog{
+                           Reallocate(sizeofPool(), sizeofObject(1)),
-              Reallocate(sizeofPool(), sizeofObject(1)),
+                       });
-              Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
-          });
 }

extras/tests/JsonDocument/ElementProxy.cpp

@@ -31,7 +31,6 @@ TEST_CASE("ElementProxy::add()") {
     REQUIRE(doc.as<std::string>() == "[[\"world\"]]");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonDocument/MemberProxy.cpp

@@ -25,7 +25,6 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[42]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 
@@ -35,7 +34,6 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 
@@ -46,7 +44,6 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
@@ -58,8 +55,8 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
+
                          });
   }
 
@@ -74,7 +71,6 @@ TEST_CASE("MemberProxy::add()") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":[\"world\"]}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
@@ -403,7 +399,7 @@ TEST_CASE("MemberProxy under memory constraints") {
   }
 
   SECTION("value slot allocation fails") {
-    timebomb.setCountdown(2);
+    timebomb.setCountdown(1);
 
     // fill the pool entirely, but leave one slot for the key
     doc["foo"][ARDUINOJSON_POOL_CAPACITY - 4] = 1;
@@ -416,7 +412,6 @@ TEST_CASE("MemberProxy under memory constraints") {
     REQUIRE(doc.overflowed() == true);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              AllocateFail(sizeofPool()),
                          });
   }

extras/tests/JsonDocument/add.cpp

@@ -32,7 +32,6 @@ TEST_CASE("JsonDocument::add(T)") {
     REQUIRE(doc.as<std::string>() == "[\"hello\"]");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonDocument/constructor.cpp

@@ -64,7 +64,6 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "{\"hello\":\"world\"}");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
-                                         Allocate(sizeofStaticStringPool()),
                                      });
   }
 
@@ -88,7 +87,6 @@ TEST_CASE("JsonDocument constructor") {
     REQUIRE(doc2.as<std::string>() == "[\"hello\"]");
     REQUIRE(spyingAllocator.log() == AllocatorLog{
                                          Allocate(sizeofPool()),
-                                         Allocate(sizeofStaticStringPool()),
                                      });
   }
 

extras/tests/JsonDocument/remove.cpp

@@ -22,10 +22,10 @@ TEST_CASE("JsonDocument::remove()") {
 
   SECTION("string literal") {
     doc["a"] = 1;
-    doc["x"] = 2;
+    doc["a\0b"_s] = 2;
     doc["b"] = 3;
 
-    doc.remove("x");
+    doc.remove("a\0b");
 
     REQUIRE(doc.as<std::string>() == "{\"a\":1,\"b\":3}");
   }

extras/tests/JsonDocument/set.cpp

@@ -37,9 +37,7 @@ TEST_CASE("JsonDocument::set()") {
     doc.set("example");
 
     REQUIRE(doc.as<const char*>() == "example"_s);
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() == AllocatorLog{});
-                             Allocate(sizeofStaticStringPool()),
-                         });
   }
 
   SECTION("const char*") {

extras/tests/JsonDocument/shrinkToFit.cpp

@@ -75,11 +75,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     doc.shrinkToFit();
 
     REQUIRE(doc.as<std::string>() == "hello");
-    REQUIRE(spyingAllocator.log() ==
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
-            AllocatorLog{
-                Allocate(sizeofStaticStringPool()),
-                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
-            });
   }
 
   SECTION("owned string") {
@@ -114,9 +110,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     REQUIRE(spyingAllocator.log() ==
             AllocatorLog{
                 Allocate(sizeofPool()),
-                Allocate(sizeofStaticStringPool()),
                 Reallocate(sizeofPool(), sizeofObject(1)),
-                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
             });
   }
 
@@ -143,9 +137,7 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     REQUIRE(spyingAllocator.log() ==
             AllocatorLog{
                 Allocate(sizeofPool()),
-                Allocate(sizeofStaticStringPool()),
                 Reallocate(sizeofPool(), sizeofArray(1)),
-                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(1)),
             });
   }
 
@@ -172,23 +164,20 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
     REQUIRE(spyingAllocator.log() ==
             AllocatorLog{
                 Allocate(sizeofPool()),
-                Allocate(sizeofStaticStringPool()),
                 Reallocate(sizeofPool(), sizeofObject(1)),
-                Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(2)),
             });
   }
 
   SECTION("owned string in object") {
-    doc["key1"_s] = "value"_s;
+    doc["key"] = "abcdefg"_s;
 
     doc.shrinkToFit();
 
-    REQUIRE(doc.as<std::string>() == "{\"key1\":\"value\"}");
+    REQUIRE(doc.as<std::string>() == "{\"key\":\"abcdefg\"}");
     REQUIRE(spyingAllocator.log() ==
             AllocatorLog{
                 Allocate(sizeofPool()),
-                Allocate(sizeofString("key1")),
+                Allocate(sizeofString("abcdefg")),
-                Allocate(sizeofString("value")),
                 Reallocate(sizeofPool(), sizeofPool(2)),
             });
   }

extras/tests/JsonDocument/subscript.cpp

@@ -25,6 +25,8 @@ TEST_CASE("JsonDocument::operator[]") {
     SECTION("string literal") {
       REQUIRE(doc["abc"] == "ABC");
       REQUIRE(cdoc["abc"] == "ABC");
+      REQUIRE(doc["abc\0d"] == "ABCD");
+      REQUIRE(cdoc["abc\0d"] == "ABCD");
     }
 
     SECTION("std::string") {
@@ -112,7 +114,6 @@ TEST_CASE("JsonDocument::operator[] key storage") {
     REQUIRE(doc.as<std::string>() == "{\"hello\":0}");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonObject/set.cpp

@@ -26,12 +26,25 @@ TEST_CASE("JsonObject::set()") {
     REQUIRE(obj2["hello"] == "world"_s);
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 
-  SECTION("copy local string key and value") {
+  SECTION("copy local string value") {
-    obj1["hello"_s] = "world"_s;
+    obj1["hello"] = "world"_s;
+    spy.clearLog();
+
+    bool success = obj2.set(obj1);
+
+    REQUIRE(success == true);
+    REQUIRE(obj2["hello"] == "world"_s);
+    REQUIRE(spy.log() == AllocatorLog{
+                             Allocate(sizeofPool()),
+                             Allocate(sizeofString("world")),
+                         });
+  }
+
+  SECTION("copy local key") {
+    obj1["hello"_s] = "world";
     spy.clearLog();
 
     bool success = obj2.set(obj1);
@@ -41,7 +54,6 @@ TEST_CASE("JsonObject::set()") {
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
-                             Allocate(sizeofString("world")),
                          });
   }
 
@@ -98,7 +110,7 @@ TEST_CASE("JsonObject::set()") {
   }
 
   SECTION("copy fails in the middle of an array") {
-    TimebombAllocator timebomb(2);
+    TimebombAllocator timebomb(1);
     JsonDocument doc3(&timebomb);
     JsonObject obj3 = doc3.to<JsonObject>();
 

extras/tests/JsonObject/subscript.cpp

@@ -102,25 +102,21 @@ TEST_CASE("JsonObject::operator[]") {
     REQUIRE(42 == obj[key]);
   }
 
-  SECTION("string literals") {
+  SECTION("should not duplicate const char*") {
     obj["hello"] = "world";
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() == AllocatorLog{Allocate(sizeofPool())});
-                             Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
-                         });
   }
 
   SECTION("should duplicate char* value") {
     obj["hello"] = const_cast<char*>("world");
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
 
   SECTION("should duplicate char* key") {
-    obj[const_cast<char*>("hello")] = 42;
+    obj[const_cast<char*>("hello")] = "world";
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
@@ -140,13 +136,12 @@ TEST_CASE("JsonObject::operator[]") {
     obj["hello"] = "world"_s;
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                              Allocate(sizeofString("world")),
                          });
   }
 
   SECTION("should duplicate std::string key") {
-    obj["hello"_s] = 42;
+    obj["hello"_s] = "world";
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
@@ -163,7 +158,7 @@ TEST_CASE("JsonObject::operator[]") {
   }
 
   SECTION("should duplicate a non-static JsonString key") {
-    obj[JsonString("hello", false)] = 42;
+    obj[JsonString("hello", false)] = "world";
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
                              Allocate(sizeofString("hello")),
@@ -171,10 +166,9 @@ TEST_CASE("JsonObject::operator[]") {
   }
 
   SECTION("should not duplicate a static JsonString key") {
-    obj[JsonString("hello", true)] = 42;
+    obj[JsonString("hello", true)] = "world";
     REQUIRE(spy.log() == AllocatorLog{
                              Allocate(sizeofPool()),
-                             Allocate(sizeofStaticStringPool()),
                          });
   }
 

extras/tests/JsonVariant/copy.cpp

@@ -38,15 +38,13 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
     REQUIRE(var1.as<std::string>() == "{\"value\":[42]}");
   }
 
-  SECTION("stores string literals by pointer") {
+  SECTION("stores const char* by reference") {
     var1.set("hello!!");
     spyingAllocator.clearLog();
 
     var2.set(var1);
 
-    REQUIRE(spyingAllocator.log() == AllocatorLog{
+    REQUIRE(spyingAllocator.log() == AllocatorLog{});
-                                         Allocate(sizeofStaticStringPool()),
-                                     });
   }
 
   SECTION("stores char* by copy") {

extras/tests/JsonVariant/set.cpp

@@ -8,7 +8,7 @@
 #include "Allocators.hpp"
 #include "Literals.hpp"
 
-using namespace ArduinoJson::detail;
+using ArduinoJson::detail::sizeofObject;
 
 enum ErrorCode { ERROR_01 = 1, ERROR_10 = 10 };
 
@@ -23,9 +23,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     CHECK(variant ==
           "hello"_s);  // linked string cannot contain '\0' at the moment
-    CHECK(spy.log() == AllocatorLog{
+    CHECK(spy.log() == AllocatorLog{});
-                           Allocate(sizeofStaticStringPool()),
-                       });
   }
 
   SECTION("const char*") {
@@ -151,9 +149,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
 
     REQUIRE(result == true);
     REQUIRE(variant == "world");  // stores by pointer
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() == AllocatorLog{});
-                             Allocate(sizeofStaticStringPool()),
-                         });
   }
 
   SECTION("non-static JsonString") {
@@ -197,11 +193,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<double>() == true);
     REQUIRE(variant.as<double>() == 1.2);
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() ==
-                             Allocate(sizeofPool<EightByteValue>()),
+            AllocatorLog{
-                             Reallocate(sizeofPool<EightByteValue>(),
+                Allocate(sizeofPool()),
-                                        sizeofPool<EightByteValue>(1)),
+                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-                         });
+            });
   }
 
   SECTION("int32_t") {
@@ -220,11 +216,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<int64_t>() == true);
     REQUIRE(variant.as<int64_t>() == -2147483649LL);
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() ==
-                             Allocate(sizeofPool<EightByteValue>()),
+            AllocatorLog{
-                             Reallocate(sizeofPool<EightByteValue>(),
+                Allocate(sizeofPool()),
-                                        sizeofPool<EightByteValue>(1)),
+                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-                         });
+            });
   }
 
   SECTION("uint32_t") {
@@ -243,11 +239,11 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
     REQUIRE(result == true);
     REQUIRE(variant.is<uint64_t>() == true);
     REQUIRE(variant.as<uint64_t>() == 4294967296);
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() ==
-                             Allocate(sizeofPool<EightByteValue>()),
+            AllocatorLog{
-                             Reallocate(sizeofPool<EightByteValue>(),
+                Allocate(sizeofPool()),
-                                        sizeofPool<EightByteValue>(1)),
+                Reallocate(sizeofPool(), sizeofPool(1)),  // one extension slot
-                         });
+            });
   }
 
   SECTION("JsonDocument") {
@@ -269,20 +265,6 @@ TEST_CASE("JsonVariant::set() with not enough memory") {
 
   JsonVariant v = doc.to<JsonVariant>();
 
-  SECTION("string literal") {
-    bool result = v.set("hello world");
-
-    REQUIRE(result == false);
-    REQUIRE(v.isNull());
-  }
-
-  SECTION("static JsonString") {
-    bool result = v.set(JsonString("hello world", true));
-
-    REQUIRE(result == false);
-    REQUIRE(v.isNull());
-  }
-
   SECTION("std::string") {
     bool result = v.set("hello world!!"_s);
 
@@ -378,7 +360,7 @@ TEST_CASE("JsonVariant::set() releases the previous value") {
   }
 
   SECTION("float") {
-    v.set(1.2f);
+    v.set(1.2);
     REQUIRE(spy.log() == AllocatorLog{
                              Deallocate(sizeofString("world")),
                          });
@@ -393,7 +375,7 @@ TEST_CASE("JsonVariant::set() releases the previous value") {
   }
 }
 
-TEST_CASE("JsonVariant::set() reuses 8-bit slot") {
+TEST_CASE("JsonVariant::set() reuses extension slot") {
   SpyingAllocator spy;
   JsonDocument doc(&spy);
   JsonVariant variant = doc.to<JsonVariant>();

extras/tests/JsonVariantConst/subscript.cpp

@@ -57,7 +57,7 @@ TEST_CASE("JsonVariantConst::operator[]") {
     SECTION("string literal") {
       REQUIRE(var["ab"] == "AB"_s);
       REQUIRE(var["abc"] == "ABC"_s);
-      REQUIRE(var["abc\0d"] == "ABC"_s);
+      REQUIRE(var["abc\0d"] == "ABCD"_s);
       REQUIRE(var["def"].isNull());
       REQUIRE(var[0].isNull());
     }

extras/tests/Misc/CMakeLists.txt

@@ -29,3 +29,23 @@ set_tests_properties(Misc
 	PROPERTIES
 		LABELS "Catch"
 )
+
+add_executable(Issue2181
+	issue2181.cpp # Cannot be linked with other tests
+)
+
+set_target_properties(Issue2181 PROPERTIES UNITY_BUILD OFF)
+
+add_test(Issue2181 Issue2181)
+
+set_tests_properties(Issue2181
+	PROPERTIES
+		LABELS "Catch"
+)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	target_compile_options(Issue2181
+		PRIVATE
+			-Wno-keyword-macro # keyword is hidden by macro definition
+	)
+endif()

extras/tests/Misc/StringAdapters.cpp

@@ -21,7 +21,7 @@ TEST_CASE("adaptString()") {
     auto s = adaptString("bravo\0alpha");
 
     CHECK(s.isNull() == false);
-    CHECK(s.size() == 5);
+    CHECK(s.size() == 11);
     CHECK(s.isStatic() == true);
   }
 

extras/tests/Misc/issue2181.cpp

@@ -0,0 +1,15 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#define true 0x1
+#define false 0x0
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("Issue #2181") {
+  JsonDocument doc;
+  doc["hello"] = "world";
+  REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\"}");
+}

extras/tests/MsgPackDeserializer/destination_types.cpp

@@ -104,8 +104,6 @@ TEST_CASE("deserializeMsgPack(MemberProxy)") {
 
     REQUIRE(err == DeserializationError::Ok);
     REQUIRE(doc.as<std::string>() == "{\"hello\":\"world\",\"value\":[42]}");
-    REQUIRE(spy.log() == AllocatorLog{
+    REQUIRE(spy.log() == AllocatorLog{});
-                             Allocate(sizeofStaticStringPool()),
-                         });
   }
 }

extras/tests/ResourceManager/CMakeLists.txt

@@ -5,7 +5,6 @@
 add_executable(ResourceManagerTests
 	allocVariant.cpp
 	clear.cpp
-	saveStaticString.cpp
 	saveString.cpp
 	shrinkToFit.cpp
 	size.cpp

extras/tests/ResourceManager/StringBuffer.cpp

@@ -2,7 +2,7 @@
 // Copyright © 2014-2025, Benoit BLANCHON
 // MIT License
 
-#include <ArduinoJson.hpp>
+#include <ArduinoJson/Memory/StringBuffer.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -22,7 +22,7 @@ TEST_CASE("StringBuffer") {
     sb.save(&variant);
 
     REQUIRE(variant.type() == VariantType::TinyString);
-    REQUIRE(variant.asString(&resources) == "hi!");
+    REQUIRE(variant.asString() == "hi!");
   }
 
   SECTION("Tiny string can't contain NUL") {
@@ -32,7 +32,7 @@ TEST_CASE("StringBuffer") {
 
     REQUIRE(variant.type() == VariantType::OwnedString);
 
-    auto str = variant.asString(&resources);
+    auto str = variant.asString();
     REQUIRE(str.size() == 3);
     REQUIRE(str.c_str()[0] == 'a');
     REQUIRE(str.c_str()[1] == 0);
@@ -45,6 +45,6 @@ TEST_CASE("StringBuffer") {
     sb.save(&variant);
 
     REQUIRE(variant.type() == VariantType::OwnedString);
-    REQUIRE(variant.asString(&resources) == "alfa");
+    REQUIRE(variant.asString() == "alfa");
   }
 }

extras/tests/ResourceManager/StringBuilder.cpp

@@ -2,7 +2,7 @@
 // Copyright © 2014-2025, Benoit BLANCHON
 // MIT License
 
-#include <ArduinoJson.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
 #include <catch.hpp>
 
 #include "Allocators.hpp"
@@ -46,7 +46,7 @@ TEST_CASE("StringBuilder") {
 
     REQUIRE(resources.overflowed() == false);
     REQUIRE(data.type() == VariantType::TinyString);
-    REQUIRE(data.asString(&resources) == "url");
+    REQUIRE(data.asString() == "url");
   }
 
   SECTION("Short string fits in first allocation") {
@@ -134,10 +134,9 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s2 = saveString(builder, "world");
     auto s3 = saveString(builder, "hello");
 
-    REQUIRE(s1.asString(&resources) == "hello");
+    REQUIRE(s1.asString() == "hello");
-    REQUIRE(s2.asString(&resources) == "world");
+    REQUIRE(s2.asString() == "world");
-    REQUIRE(+s1.asString(&resources).c_str() ==
+    REQUIRE(+s1.asString().c_str() == +s3.asString().c_str());  // same address
-            +s3.asString(&resources).c_str());  // same address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -153,10 +152,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "hello");
 
-    REQUIRE(s1.asString(&resources) == "hello world");
+    REQUIRE(s1.asString() == "hello world");
-    REQUIRE(s2.asString(&resources) == "hello");
+    REQUIRE(s2.asString() == "hello");
-    REQUIRE(+s2.asString(&resources).c_str() !=
+    REQUIRE(+s2.asString().c_str() !=
-            +s1.asString(&resources).c_str());  // different address
+            +s1.asString().c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{
@@ -171,10 +170,10 @@ TEST_CASE("StringBuilder::save() deduplicates strings") {
     auto s1 = saveString(builder, "hello world");
     auto s2 = saveString(builder, "worl");
 
-    REQUIRE(s1.asString(&resources) == "hello world");
+    REQUIRE(s1.asString() == "hello world");
-    REQUIRE(s2.asString(&resources) == "worl");
+    REQUIRE(s2.asString() == "worl");
-    REQUIRE(s2.asString(&resources).c_str() !=
+    REQUIRE(s2.asString().c_str() !=
-            s1.asString(&resources).c_str());  // different address
+            s1.asString().c_str());  // different address
 
     REQUIRE(spy.log() ==
             AllocatorLog{

extras/tests/ResourceManager/saveStaticString.cpp

@@ -1,47 +0,0 @@
-// ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2025, Benoit BLANCHON
-// MIT License
-
-#include <ArduinoJson/Memory/ResourceManager.hpp>
-#include <ArduinoJson/Strings/StringAdapters.hpp>
-#include <catch.hpp>
-
-#include "Allocators.hpp"
-
-using namespace ArduinoJson::detail;
-
-TEST_CASE("ResourceManager::saveStaticString() deduplicates strings") {
-  SpyingAllocator spy;
-  ResourceManager resources(&spy);
-
-  auto str1 = "hello";
-  auto str2 = "world";
-
-  auto id1 = resources.saveStaticString(str1);
-  auto id2 = resources.saveStaticString(str2);
-  REQUIRE(id1 != id2);
-
-  auto id3 = resources.saveStaticString(str1);
-  REQUIRE(id1 == id3);
-
-  resources.shrinkToFit();
-  REQUIRE(spy.log() ==
-          AllocatorLog{
-              Allocate(sizeofStaticStringPool()),
-              Reallocate(sizeofStaticStringPool(), sizeofStaticStringPool(2)),
-          });
-  REQUIRE(resources.overflowed() == false);
-}
-
-TEST_CASE("ResourceManager::saveStaticString() when allocation fails") {
-  SpyingAllocator spy(FailingAllocator::instance());
-  ResourceManager resources(&spy);
-
-  auto slotId = resources.saveStaticString("hello");
-
-  REQUIRE(slotId == NULL_SLOT);
-  REQUIRE(resources.overflowed() == true);
-  REQUIRE(spy.log() == AllocatorLog{
-                           AllocateFail(sizeofStaticStringPool()),
-                       });
-}

idf_component.yml

@@ -1,7 +1,7 @@
-version: "7.4.1"
+version: "7.4.2"
 description: >-
   A simple and efficient JSON library for embedded C++.
-  ★ 6898 stars on GitHub!
+  ★ 6953 stars on GitHub!
   Supports serialization, deserialization, MessagePack, streams, filtering, and more.
   Fully tested and documented.
 url: https://arduinojson.org/

library.json

@@ -1,13 +1,13 @@
 {
   "name": "ArduinoJson",
   "keywords": "json, rest, http, web",
-  "description": "A simple and efficient JSON library for embedded C++. ⭐ 6898 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.",
+  "description": "A simple and efficient JSON library for embedded C++. ⭐ 6953 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.",
   "homepage": "https://arduinojson.org/?utm_source=meta&utm_medium=library.json",
   "repository": {
     "type": "git",
     "url": "https://github.com/bblanchon/ArduinoJson.git"
   },
-  "version": "7.4.1",
+  "version": "7.4.2",
   "authors": {
     "name": "Benoit Blanchon",
     "url": "https://blog.benoitblanchon.fr"

library.properties

@@ -1,9 +1,9 @@
 name=ArduinoJson
-version=7.4.1
+version=7.4.2
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=A simple and efficient JSON library for embedded C++.
-paragraph=⭐ 6898 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.
+paragraph=⭐ 6953 stars on GitHub! Supports serialization, deserialization, MessagePack, streams, filtering, and more. Fully tested and documented.
 category=Data Processing
 url=https://arduinojson.org/?utm_source=meta&utm_medium=library.properties
 architectures=*

src/ArduinoJson.hpp

@@ -26,6 +26,15 @@
 #  endif
 #endif
 
+// Remove true and false macros defined by some cores, such as Arduino Due's
+// See issues #2181 and arduino/ArduinoCore-sam#50
+#ifdef true
+#  undef true
+#endif
+#ifdef false
+#  undef false
+#endif
+
 #include "ArduinoJson/Array/JsonArray.hpp"
 #include "ArduinoJson/Object/JsonObject.hpp"
 #include "ArduinoJson/Variant/JsonVariantConst.hpp"

src/ArduinoJson/Array/ArrayImpl.hpp

@@ -73,7 +73,7 @@ inline bool ArrayData::addValue(const T& value, ResourceManager* resources) {
 
 // Returns the size (in bytes) of an array with n elements.
 constexpr size_t sizeofArray(size_t n) {
-  return n * sizeof(VariantData);
+  return n * ResourceManager::slotSize;
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Configuration.hpp

@@ -274,9 +274,9 @@
 #endif
 
 #if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_DOUBLE
-#  define ARDUINOJSON_USE_8_BYTE_POOL 1
+#  define ARDUINOJSON_USE_EXTENSIONS 1
 #else
-#  define ARDUINOJSON_USE_8_BYTE_POOL 0
+#  define ARDUINOJSON_USE_EXTENSIONS 0
 #endif
 
 #if defined(nullptr)

src/ArduinoJson/Memory/MemoryPool.hpp

@@ -34,11 +34,6 @@ class Slot {
     return ptr_;
   }
 
-  T& operator*() const {
-    ARDUINOJSON_ASSERT(ptr_ != nullptr);
-    return *ptr_;
-  }
-
   T* operator->() const {
     ARDUINOJSON_ASSERT(ptr_ != nullptr);
     return ptr_;
@@ -81,14 +76,6 @@ class MemoryPool {
     return slots_ + id;
   }
 
-  SlotId find(const T& value) const {
-    for (SlotId i = 0; i < usage_; i++) {
-      if (slots_[i] == value)
-        return i;
-    }
-    return NULL_SLOT;
-  }
-
   void clear() {
     usage_ = 0;
   }

src/ArduinoJson/Memory/MemoryPoolList.hpp

@@ -114,15 +114,6 @@ class MemoryPoolList {
     return pools_[poolIndex].getSlot(indexInPool);
   }
 
-  SlotId find(const T& value) const {
-    for (PoolCount i = 0; i < count_; i++) {
-      SlotId id = pools_[i].find(value);
-      if (id != NULL_SLOT)
-        return SlotId(i * ARDUINOJSON_POOL_CAPACITY + id);
-    }
-    return NULL_SLOT;
-  }
-
   void clear(Allocator* allocator) {
     for (PoolCount i = 0; i < count_; i++)
       pools_[i].destroy(allocator);

src/ArduinoJson/Memory/ResourceManager.hpp

@@ -18,17 +18,22 @@ class VariantData;
 class VariantWithId;
 
 class ResourceManager {
+  union SlotData {
+    VariantData variant;
+#if ARDUINOJSON_USE_EXTENSIONS
+    VariantExtension extension;
+#endif
+  };
+
  public:
+  constexpr static size_t slotSize = sizeof(SlotData);
+
   ResourceManager(Allocator* allocator = DefaultAllocator::instance())
       : allocator_(allocator), overflowed_(false) {}
 
   ~ResourceManager() {
     stringPool_.clear(allocator_);
     variantPools_.clear(allocator_);
-    staticStringsPools_.clear(allocator_);
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    eightBytePools_.clear(allocator_);
-#endif
   }
 
   ResourceManager(const ResourceManager&) = delete;
@@ -37,10 +42,6 @@ class ResourceManager {
   friend void swap(ResourceManager& a, ResourceManager& b) {
     swap(a.stringPool_, b.stringPool_);
     swap(a.variantPools_, b.variantPools_);
-    swap(a.staticStringsPools_, b.staticStringsPools_);
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    swap(a.eightBytePools_, b.eightBytePools_);
-#endif
     swap_(a.allocator_, b.allocator_);
     swap_(a.overflowed_, b.overflowed_);
   }
@@ -61,10 +62,10 @@ class ResourceManager {
   void freeVariant(Slot<VariantData> slot);
   VariantData* getVariant(SlotId id) const;
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-  Slot<EightByteValue> allocEightByte();
+  Slot<VariantExtension> allocExtension();
-  void freeEightByte(SlotId slot);
+  void freeExtension(SlotId slot);
-  EightByteValue* getEightByte(SlotId id) const;
+  VariantExtension* getExtension(SlotId id) const;
 #endif
 
   template <typename TAdaptedString>
@@ -110,51 +111,21 @@ class ResourceManager {
     stringPool_.dereference(s, allocator_);
   }
 
-  SlotId saveStaticString(const char* s) {
-    auto existingSlotId = staticStringsPools_.find(s);
-    if (existingSlotId != NULL_SLOT)
-      return existingSlotId;
-
-    auto slot = staticStringsPools_.allocSlot(allocator_);
-    if (slot)
-      *slot = s;
-    else
-      overflowed_ = true;
-
-    return slot.id();
-  }
-
-  const char* getStaticString(SlotId id) const {
-    return *staticStringsPools_.getSlot(id);
-  }
-
   void clear() {
-    overflowed_ = false;
     variantPools_.clear(allocator_);
+    overflowed_ = false;
     stringPool_.clear(allocator_);
-    staticStringsPools_.clear(allocator_);
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    eightBytePools_.clear(allocator_);
-#endif
   }
 
   void shrinkToFit() {
     variantPools_.shrinkToFit(allocator_);
-    staticStringsPools_.shrinkToFit(allocator_);
-#if ARDUINOJSON_USE_8_BYTE_POOL
-    eightBytePools_.shrinkToFit(allocator_);
-#endif
   }
 
  private:
   Allocator* allocator_;
   bool overflowed_;
   StringPool stringPool_;
-  MemoryPoolList<VariantData> variantPools_;
+  MemoryPoolList<SlotData> variantPools_;
-  MemoryPoolList<const char*> staticStringsPools_;
-#if ARDUINOJSON_USE_8_BYTE_POOL
-  MemoryPoolList<EightByteValue> eightBytePools_;
-#endif
 };
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Memory/ResourceManagerImpl.hpp

@@ -12,41 +12,40 @@
 ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 
 inline Slot<VariantData> ResourceManager::allocVariant() {
-  auto slot = variantPools_.allocSlot(allocator_);
+  auto p = variantPools_.allocSlot(allocator_);
-  if (!slot) {
+  if (!p) {
     overflowed_ = true;
     return {};
   }
-  new (slot.ptr()) VariantData();
+  return {new (&p->variant) VariantData, p.id()};
-  return slot;
 }
 
-inline void ResourceManager::freeVariant(Slot<VariantData> slot) {
+inline void ResourceManager::freeVariant(Slot<VariantData> variant) {
-  slot->clear(this);
+  variant->clear(this);
-  variantPools_.freeSlot(slot);
+  variantPools_.freeSlot({alias_cast<SlotData*>(variant.ptr()), variant.id()});
 }
 
 inline VariantData* ResourceManager::getVariant(SlotId id) const {
   return reinterpret_cast<VariantData*>(variantPools_.getSlot(id));
 }
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-inline Slot<EightByteValue> ResourceManager::allocEightByte() {
+inline Slot<VariantExtension> ResourceManager::allocExtension() {
-  auto slot = eightBytePools_.allocSlot(allocator_);
+  auto p = variantPools_.allocSlot(allocator_);
-  if (!slot) {
+  if (!p) {
     overflowed_ = true;
     return {};
   }
-  return slot;
+  return {&p->extension, p.id()};
 }
 
-inline void ResourceManager::freeEightByte(SlotId id) {
+inline void ResourceManager::freeExtension(SlotId id) {
-  auto p = getEightByte(id);
+  auto p = getExtension(id);
-  eightBytePools_.freeSlot({p, id});
+  variantPools_.freeSlot({reinterpret_cast<SlotData*>(p), id});
 }
 
-inline EightByteValue* ResourceManager::getEightByte(SlotId id) const {
+inline VariantExtension* ResourceManager::getExtension(SlotId id) const {
-  return eightBytePools_.getSlot(id);
+  return &variantPools_.getSlot(id)->extension;
 }
 #endif
 

src/ArduinoJson/Object/JsonPair.hpp

@@ -18,7 +18,7 @@ class JsonPair {
   JsonPair(detail::ObjectData::iterator iterator,
            detail::ResourceManager* resources) {
     if (!iterator.done()) {
-      key_ = iterator->asString(resources);
+      key_ = iterator->asString();
       iterator.next(resources);
       value_ = JsonVariant(iterator.data(), resources);
     }
@@ -46,7 +46,7 @@ class JsonPairConst {
   JsonPairConst(detail::ObjectData::iterator iterator,
                 const detail::ResourceManager* resources) {
     if (!iterator.done()) {
-      key_ = iterator->asString(resources);
+      key_ = iterator->asString();
       iterator.next(resources);
       value_ = JsonVariantConst(iterator.data(), resources);
     }

src/ArduinoJson/Object/ObjectImpl.hpp

@@ -36,7 +36,7 @@ inline ObjectData::iterator ObjectData::findKey(
     return iterator();
   bool isKey = true;
   for (auto it = createIterator(resources); !it.done(); it.next(resources)) {
-    if (isKey && stringEquals(key, adaptString(it->asString(resources))))
+    if (isKey && stringEquals(key, adaptString(it->asString())))
       return it;
     isKey = !isKey;
   }
@@ -86,7 +86,7 @@ inline VariantData* ObjectData::addPair(VariantData** value,
 
 // Returns the size (in bytes) of an object with n members.
 constexpr size_t sizeofObject(size_t n) {
-  return 2 * n * sizeof(VariantData);
+  return 2 * n * ResourceManager::slotSize;
 }
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Strings/Adapters/RamString.hpp

@@ -90,9 +90,8 @@ template <size_t N>
 struct StringAdapter<const char (&)[N]> {
   using AdaptedString = RamString;
 
-  static AdaptedString adapt(const char* p) {
+  static AdaptedString adapt(const char (&p)[N]) {
-    ARDUINOJSON_ASSERT(p);
+    return RamString(p, N - 1, true);
-    return RamString(p, ::strlen(p), true);
   }
 };
 

src/ArduinoJson/Strings/JsonString.hpp

@@ -28,7 +28,8 @@ class JsonString {
             detail::enable_if_t<detail::is_integral<TSize>::value &&
                                     !detail::is_same<TSize, bool>::value,
                                 int> = 0>
-  JsonString(const char* data, TSize sz) : str_(data, size_t(sz), false) {}
+  JsonString(const char* data, TSize sz, bool isStatic = false)
+      : str_(data, size_t(sz), isStatic) {}
 
   // Returns a pointer to the characters.
   const char* c_str() const {

src/ArduinoJson/Variant/ConverterImpl.hpp

@@ -160,7 +160,7 @@ struct Converter<const char*> : private detail::VariantAttorney {
 
   static const char* fromJson(JsonVariantConst src) {
     auto data = getData(src);
-    return data ? data->asString(getResourceManager(src)).c_str() : 0;
+    return data ? data->asString().c_str() : 0;
   }
 
   static bool checkJson(JsonVariantConst src) {
@@ -178,7 +178,7 @@ struct Converter<JsonString> : private detail::VariantAttorney {
 
   static JsonString fromJson(JsonVariantConst src) {
     auto data = getData(src);
-    return data ? data->asString(getResourceManager(src)) : JsonString();
+    return data ? data->asString() : JsonString();
   }
 
   static bool checkJson(JsonVariantConst src) {

src/ArduinoJson/Variant/VariantContent.hpp

@@ -16,7 +16,9 @@ ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
 enum class VariantTypeBits : uint8_t {
   OwnedStringBit = 0x01,  // 0000 0001
   NumberBit = 0x08,       // 0000 1000
-  EightByteBit = 0x10,    // 0001 0000
+#if ARDUINOJSON_USE_EXTENSIONS
+  ExtensionBit = 0x10,  // 0001 0000
+#endif
   CollectionMask = 0x60,
 };
 
@@ -54,16 +56,19 @@ union VariantContent {
   bool asBoolean;
   uint32_t asUint32;
   int32_t asInt32;
+#if ARDUINOJSON_USE_EXTENSIONS
   SlotId asSlotId;
+#endif
   ArrayData asArray;
   ObjectData asObject;
   CollectionData asCollection;
+  const char* asLinkedString;
   struct StringNode* asOwnedString;
   char asTinyString[tinyStringMaxLength + 1];
 };
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-union EightByteValue {
+union VariantExtension {
 #  if ARDUINOJSON_USE_LONG_LONG
   uint64_t asUint64;
   int64_t asInt64;
@@ -72,9 +77,6 @@ union EightByteValue {
   double asDouble;
 #  endif
 };
-
-static_assert(sizeof(EightByteValue) == 8,
-              "sizeof(EightByteValue) must be 8 bytes");
 #endif
 
 ARDUINOJSON_END_PRIVATE_NAMESPACE

src/ArduinoJson/Variant/VariantData.hpp

@@ -53,8 +53,8 @@ class VariantData {
   template <typename TVisitor>
   typename TVisitor::result_type accept(
       TVisitor& visit, const ResourceManager* resources) const {
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-    auto eightByteValue = getEightByte(resources);
+    auto extension = getExtension(resources);
 #else
     (void)resources;  // silence warning
 #endif
@@ -64,7 +64,7 @@ class VariantData {
 
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
-        return visit.visit(eightByteValue->asDouble);
+        return visit.visit(extension->asDouble);
 #endif
 
       case VariantType::Array:
@@ -77,7 +77,7 @@ class VariantData {
         return visit.visit(JsonString(content_.asTinyString));
 
       case VariantType::LinkedString:
-        return visit.visit(JsonString(asLinkedString(resources), true));
+        return visit.visit(JsonString(content_.asLinkedString, true));
 
       case VariantType::OwnedString:
         return visit.visit(JsonString(content_.asOwnedString->data,
@@ -95,10 +95,10 @@ class VariantData {
 
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Int64:
-        return visit.visit(eightByteValue->asInt64);
+        return visit.visit(extension->asInt64);
 
       case VariantType::Uint64:
-        return visit.visit(eightByteValue->asUint64);
+        return visit.visit(extension->asUint64);
 #endif
 
       case VariantType::Boolean:
@@ -145,8 +145,8 @@ class VariantData {
   }
 
   bool asBoolean(const ResourceManager* resources) const {
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-    auto eightByteValue = getEightByte(resources);
+    auto extension = getExtension(resources);
 #else
     (void)resources;  // silence warning
 #endif
@@ -160,14 +160,14 @@ class VariantData {
         return content_.asFloat != 0;
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
-        return eightByteValue->asDouble != 0;
+        return extension->asDouble != 0;
 #endif
       case VariantType::Null:
         return false;
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
       case VariantType::Int64:
-        return eightByteValue->asUint64 != 0;
+        return extension->asUint64 != 0;
 #endif
       default:
         return true;
@@ -193,8 +193,8 @@ class VariantData {
   template <typename T>
   T asFloat(const ResourceManager* resources) const {
     static_assert(is_floating_point<T>::value, "T must be a floating point");
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-    auto eightByteValue = getEightByte(resources);
+    auto extension = getExtension(resources);
 #else
     (void)resources;  // silence warning
 #endif
@@ -208,15 +208,15 @@ class VariantData {
         return static_cast<T>(content_.asInt32);
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
-        return static_cast<T>(eightByteValue->asUint64);
+        return static_cast<T>(extension->asUint64);
       case VariantType::Int64:
-        return static_cast<T>(eightByteValue->asInt64);
+        return static_cast<T>(extension->asInt64);
 #endif
       case VariantType::TinyString:
         str = content_.asTinyString;
         break;
       case VariantType::LinkedString:
-        str = asLinkedString(resources);
+        str = content_.asLinkedString;
         break;
       case VariantType::OwnedString:
         str = content_.asOwnedString->data;
@@ -225,7 +225,7 @@ class VariantData {
         return static_cast<T>(content_.asFloat);
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
-        return static_cast<T>(eightByteValue->asDouble);
+        return static_cast<T>(extension->asDouble);
 #endif
       default:
         return 0.0;
@@ -238,8 +238,8 @@ class VariantData {
   template <typename T>
   T asIntegral(const ResourceManager* resources) const {
     static_assert(is_integral<T>::value, "T must be an integral type");
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-    auto eightByteValue = getEightByte(resources);
+    auto extension = getExtension(resources);
 #else
     (void)resources;  // silence warning
 #endif
@@ -253,15 +253,15 @@ class VariantData {
         return convertNumber<T>(content_.asInt32);
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
-        return convertNumber<T>(eightByteValue->asUint64);
+        return convertNumber<T>(extension->asUint64);
       case VariantType::Int64:
-        return convertNumber<T>(eightByteValue->asInt64);
+        return convertNumber<T>(extension->asInt64);
 #endif
       case VariantType::TinyString:
         str = content_.asTinyString;
         break;
       case VariantType::LinkedString:
-        str = asLinkedString(resources);
+        str = content_.asLinkedString;
         break;
       case VariantType::OwnedString:
         str = content_.asOwnedString->data;
@@ -270,7 +270,7 @@ class VariantData {
         return convertNumber<T>(content_.asFloat);
 #if ARDUINOJSON_USE_DOUBLE
       case VariantType::Double:
-        return convertNumber<T>(eightByteValue->asDouble);
+        return convertNumber<T>(extension->asDouble);
 #endif
       default:
         return 0;
@@ -298,14 +298,12 @@ class VariantData {
     }
   }
 
-  const char* asLinkedString(const ResourceManager* resources) const;
+  JsonString asString() const {
-
-  JsonString asString(const ResourceManager* resources) const {
     switch (type_) {
       case VariantType::TinyString:
         return JsonString(content_.asTinyString);
       case VariantType::LinkedString:
-        return JsonString(asLinkedString(resources), true);
+        return JsonString(content_.asLinkedString, true);
       case VariantType::OwnedString:
         return JsonString(content_.asOwnedString->data,
                           content_.asOwnedString->length);
@@ -314,8 +312,8 @@ class VariantData {
     }
   }
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-  const EightByteValue* getEightByte(const ResourceManager* resources) const;
+  const VariantExtension* getExtension(const ResourceManager* resources) const;
 #endif
 
   VariantData* getElement(size_t index,
@@ -378,7 +376,7 @@ class VariantData {
   template <typename T>
   bool isInteger(const ResourceManager* resources) const {
 #if ARDUINOJSON_USE_LONG_LONG
-    auto eightByteValue = getEightByte(resources);
+    auto extension = getExtension(resources);
 #else
     (void)resources;  // silence warning
 #endif
@@ -391,10 +389,10 @@ class VariantData {
 
 #if ARDUINOJSON_USE_LONG_LONG
       case VariantType::Uint64:
-        return canConvertNumber<T>(eightByteValue->asUint64);
+        return canConvertNumber<T>(extension->asUint64);
 
       case VariantType::Int64:
-        return canConvertNumber<T>(eightByteValue->asInt64);
+        return canConvertNumber<T>(extension->asInt64);
 #endif
 
       default:
@@ -521,7 +519,12 @@ class VariantData {
     var->setString(value, resources);
   }
 
-  bool setLinkedString(const char* s, ResourceManager* resources);
+  void setLinkedString(const char* s) {
+    ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
+    ARDUINOJSON_ASSERT(s);
+    type_ = VariantType::LinkedString;
+    content_.asLinkedString = s;
+  }
 
   template <typename TAdaptedString>
   void setTinyString(const TAdaptedString& s) {

src/ArduinoJson/Variant/VariantImpl.hpp

@@ -18,20 +18,6 @@ inline void VariantData::setRawString(SerializedValue<T> value,
     setRawString(dup);
 }
 
-inline bool VariantData::setLinkedString(const char* s,
-                                         ResourceManager* resources) {
-  ARDUINOJSON_ASSERT(type_ == VariantType::Null);  // must call clear() first
-  ARDUINOJSON_ASSERT(s);
-
-  auto slotId = resources->saveStaticString(s);
-  if (slotId == NULL_SLOT)
-    return false;
-
-  type_ = VariantType::LinkedString;
-  content_.asSlotId = slotId;
-  return true;
-}
-
 template <typename TAdaptedString>
 inline bool VariantData::setString(TAdaptedString value,
                                    ResourceManager* resources) {
@@ -40,8 +26,10 @@ inline bool VariantData::setString(TAdaptedString value,
   if (value.isNull())
     return false;
 
-  if (value.isStatic())
+  if (value.isStatic()) {
-    return setLinkedString(value.data(), resources);
+    setLinkedString(value.data());
+    return true;
+  }
 
   if (isTinyString(value, value.size())) {
     setTinyString(value);
@@ -61,9 +49,9 @@ inline void VariantData::clear(ResourceManager* resources) {
   if (type_ & VariantTypeBits::OwnedStringBit)
     resources->dereferenceString(content_.asOwnedString->data);
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-  if (type_ & VariantTypeBits::EightByteBit)
+  if (type_ & VariantTypeBits::ExtensionBit)
-    resources->freeEightByte(content_.asSlotId);
+    resources->freeExtension(content_.asSlotId);
 #endif
 
   auto collection = asCollection();
@@ -73,21 +61,15 @@ inline void VariantData::clear(ResourceManager* resources) {
   type_ = VariantType::Null;
 }
 
-#if ARDUINOJSON_USE_8_BYTE_POOL
+#if ARDUINOJSON_USE_EXTENSIONS
-inline const EightByteValue* VariantData::getEightByte(
+inline const VariantExtension* VariantData::getExtension(
     const ResourceManager* resources) const {
-  return type_ & VariantTypeBits::EightByteBit
+  return type_ & VariantTypeBits::ExtensionBit
-             ? resources->getEightByte(content_.asSlotId)
+             ? resources->getExtension(content_.asSlotId)
-             : 0;
+             : nullptr;
 }
 #endif
 
-inline const char* VariantData::asLinkedString(
-    const ResourceManager* resources) const {
-  ARDUINOJSON_ASSERT(type_ == VariantType::LinkedString);
-  return resources->getStaticString(content_.asSlotId);
-}
-
 template <typename T>
 enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
     T value, ResourceManager* resources) {
@@ -101,12 +83,12 @@ enable_if_t<sizeof(T) == 8, bool> VariantData::setFloat(
     type_ = VariantType::Float;
     content_.asFloat = valueAsFloat;
   } else {
-    auto slot = resources->allocEightByte();
+    auto extension = resources->allocExtension();
-    if (!slot)
+    if (!extension)
       return false;
     type_ = VariantType::Double;
-    content_.asSlotId = slot.id();
+    content_.asSlotId = extension.id();
-    slot->asDouble = value;
+    extension->asDouble = value;
   }
 #else
   type_ = VariantType::Float;
@@ -127,12 +109,12 @@ enable_if_t<is_signed<T>::value, bool> VariantData::setInteger(
   }
 #if ARDUINOJSON_USE_LONG_LONG
   else {
-    auto slot = resources->allocEightByte();
+    auto extension = resources->allocExtension();
-    if (!slot)
+    if (!extension)
       return false;
     type_ = VariantType::Int64;
-    content_.asSlotId = slot.id();
+    content_.asSlotId = extension.id();
-    slot->asInt64 = value;
+    extension->asInt64 = value;
   }
 #endif
   return true;
@@ -150,12 +132,12 @@ enable_if_t<is_unsigned<T>::value, bool> VariantData::setInteger(
   }
 #if ARDUINOJSON_USE_LONG_LONG
   else {
-    auto slot = resources->allocEightByte();
+    auto extension = resources->allocExtension();
-    if (!slot)
+    if (!extension)
       return false;
     type_ = VariantType::Uint64;
-    content_.asSlotId = slot.id();
+    content_.asSlotId = extension.id();
-    slot->asUint64 = value;
+    extension->asUint64 = value;
   }
 #endif
   return true;

src/ArduinoJson/version.hpp

@@ -4,8 +4,8 @@
 
 #pragma once
 
-#define ARDUINOJSON_VERSION "7.4.1"
+#define ARDUINOJSON_VERSION "7.4.2"
 #define ARDUINOJSON_VERSION_MAJOR 7
 #define ARDUINOJSON_VERSION_MINOR 4
-#define ARDUINOJSON_VERSION_REVISION 1
+#define ARDUINOJSON_VERSION_REVISION 2
-#define ARDUINOJSON_VERSION_MACRO V741
+#define ARDUINOJSON_VERSION_MACRO V742