Update to ArduinoJson 7.0.4

lib/ArduinoJson/extras/tests/Helpers/Allocators.hpp

@@ -0,0 +1,283 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <ArduinoJson/Memory/Allocator.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
+#include <ArduinoJson/Memory/VariantPool.hpp>
+
+#include <sstream>
+
+struct FailingAllocator : ArduinoJson::Allocator {
+  static FailingAllocator* instance() {
+    static FailingAllocator allocator;
+    return &allocator;
+  }
+
+ private:
+  FailingAllocator() = default;
+  ~FailingAllocator() = default;
+
+  void* allocate(size_t) override {
+    return nullptr;
+  }
+
+  void deallocate(void*) override {}
+
+  void* reallocate(void*, size_t) override {
+    return nullptr;
+  }
+};
+
+class AllocatorLogEntry {
+ public:
+  AllocatorLogEntry(std::string s, size_t n = 1) : str_(s), count_(n) {}
+
+  const std::string& str() const {
+    return str_;
+  }
+
+  size_t count() const {
+    return count_;
+  }
+
+  AllocatorLogEntry operator*(size_t n) const {
+    return AllocatorLogEntry(str_, n);
+  }
+
+ private:
+  std::string str_;
+  size_t count_;
+};
+
+inline AllocatorLogEntry Allocate(size_t s) {
+  char buffer[32];
+  sprintf(buffer, "allocate(%zu)", s);
+  return AllocatorLogEntry(buffer);
+}
+
+inline AllocatorLogEntry AllocateFail(size_t s) {
+  char buffer[32];
+  sprintf(buffer, "allocate(%zu) -> nullptr", s);
+  return AllocatorLogEntry(buffer);
+}
+
+inline AllocatorLogEntry Reallocate(size_t s1, size_t s2) {
+  char buffer[32];
+  sprintf(buffer, "reallocate(%zu, %zu)", s1, s2);
+  return AllocatorLogEntry(buffer);
+}
+
+inline AllocatorLogEntry ReallocateFail(size_t s1, size_t s2) {
+  char buffer[32];
+  sprintf(buffer, "reallocate(%zu, %zu) -> nullptr", s1, s2);
+  return AllocatorLogEntry(buffer);
+}
+
+inline AllocatorLogEntry Deallocate(size_t s) {
+  char buffer[32];
+  sprintf(buffer, "deallocate(%zu)", s);
+  return AllocatorLogEntry(buffer);
+}
+
+class AllocatorLog {
+ public:
+  AllocatorLog() = default;
+  AllocatorLog(std::initializer_list<AllocatorLogEntry> list) {
+    for (auto& entry : list)
+      append(entry);
+  }
+
+  void clear() {
+    log_.str("");
+  }
+
+  void append(const AllocatorLogEntry& entry) {
+    for (size_t i = 0; i < entry.count(); i++)
+      log_ << entry.str() << "\n";
+  }
+
+  std::string str() const {
+    auto s = log_.str();
+    if (s.empty())
+      return "(empty)";
+    s.pop_back();  // remove the trailing '\n'
+    return s;
+  }
+
+  bool operator==(const AllocatorLog& other) const {
+    return str() == other.str();
+  }
+
+  friend std::ostream& operator<<(std::ostream& os, const AllocatorLog& log) {
+    os << log.str();
+    return os;
+  }
+
+ private:
+  std::ostringstream log_;
+};
+
+class SpyingAllocator : public ArduinoJson::Allocator {
+ public:
+  SpyingAllocator(
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : upstream_(upstream) {}
+  virtual ~SpyingAllocator() {}
+
+  size_t allocatedBytes() const {
+    return allocatedBytes_;
+  }
+
+  void* allocate(size_t n) override {
+    auto block = reinterpret_cast<AllocatedBlock*>(
+        upstream_->allocate(sizeof(AllocatedBlock) + n - 1));
+    if (block) {
+      log_.append(Allocate(n));
+      allocatedBytes_ += n;
+      block->size = n;
+      return block->payload;
+    } else {
+      log_.append(AllocateFail(n));
+      return nullptr;
+    }
+  }
+
+  void deallocate(void* p) override {
+    auto block = AllocatedBlock::fromPayload(p);
+    allocatedBytes_ -= block->size;
+    log_.append(Deallocate(block ? block->size : 0));
+    upstream_->deallocate(block);
+  }
+
+  void* reallocate(void* p, size_t n) override {
+    auto block = AllocatedBlock::fromPayload(p);
+    auto oldSize = block ? block->size : 0;
+    block = reinterpret_cast<AllocatedBlock*>(
+        upstream_->reallocate(block, sizeof(AllocatedBlock) + n - 1));
+    if (block) {
+      log_.append(Reallocate(oldSize, n));
+      block->size = n;
+      allocatedBytes_ += n - oldSize;
+      return block->payload;
+    } else {
+      log_.append(ReallocateFail(oldSize, n));
+      return nullptr;
+    }
+  }
+
+  void clearLog() {
+    log_.clear();
+  }
+
+  const AllocatorLog& log() const {
+    return log_;
+  }
+
+ private:
+  struct AllocatedBlock {
+    size_t size;
+    char payload[1];
+
+    static AllocatedBlock* fromPayload(void* p) {
+      if (!p)
+        return nullptr;
+      return reinterpret_cast<AllocatedBlock*>(
+          // Cast to void* to silence "cast increases required alignment of
+          // target type [-Werror=cast-align]"
+          reinterpret_cast<void*>(reinterpret_cast<char*>(p) -
+                                  offsetof(AllocatedBlock, payload)));
+    }
+  };
+
+  AllocatorLog log_;
+  Allocator* upstream_;
+  size_t allocatedBytes_ = 0;
+};
+
+class KillswitchAllocator : public ArduinoJson::Allocator {
+ public:
+  KillswitchAllocator(
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : working_(true), upstream_(upstream) {}
+  virtual ~KillswitchAllocator() {}
+
+  void* allocate(size_t n) override {
+    return working_ ? upstream_->allocate(n) : 0;
+  }
+
+  void deallocate(void* p) override {
+    upstream_->deallocate(p);
+  }
+
+  void* reallocate(void* ptr, size_t n) override {
+    return working_ ? upstream_->reallocate(ptr, n) : 0;
+  }
+
+  // Turn the killswitch on, so all allocation fail
+  void on() {
+    working_ = false;
+  }
+
+ private:
+  bool working_;
+  Allocator* upstream_;
+};
+
+class TimebombAllocator : public ArduinoJson::Allocator {
+ public:
+  TimebombAllocator(
+      size_t initialCountdown,
+      Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())
+      : countdown_(initialCountdown), upstream_(upstream) {}
+  virtual ~TimebombAllocator() {}
+
+  void* allocate(size_t n) override {
+    if (!countdown_)
+      return nullptr;
+    countdown_--;
+    return upstream_->allocate(n);
+  }
+
+  void deallocate(void* p) override {
+    upstream_->deallocate(p);
+  }
+
+  void* reallocate(void* ptr, size_t n) override {
+    if (!countdown_)
+      return nullptr;
+    countdown_--;
+    return upstream_->reallocate(ptr, n);
+  }
+
+  void setCountdown(size_t value) {
+    countdown_ = value;
+  }
+
+ private:
+  size_t countdown_ = 0;
+  Allocator* upstream_;
+};
+
+inline size_t sizeofPoolList(size_t n = ARDUINOJSON_INITIAL_POOL_COUNT) {
+  return sizeof(ArduinoJson::detail::VariantPool) * n;
+}
+
+inline size_t sizeofPool(
+    ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {
+  return ArduinoJson::detail::VariantPool::slotsToBytes(n);
+}
+
+inline size_t sizeofStringBuffer(size_t iteration = 1) {
+  // returns 31, 63, 127, 255, etc.
+  auto capacity = ArduinoJson::detail::StringBuilder::initialCapacity;
+  for (size_t i = 1; i < iteration; i++)
+    capacity = capacity * 2 + 1;
+  return ArduinoJson::detail::sizeofString(capacity);
+}
+
+inline size_t sizeofString(const char* s) {
+  return ArduinoJson::detail::sizeofString(strlen(s));
+}

lib/ArduinoJson/extras/tests/Helpers/Arduino.h

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #pragma once
@@ -7,5 +7,7 @@
 #include "api/Print.h"
 #include "api/Stream.h"
 #include "api/String.h"
+#include "avr/pgmspace.h"
 
+#define ARDUINO
 #define ARDUINO_H_INCLUDED 1

lib/ArduinoJson/extras/tests/Helpers/CustomReader.hpp

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #pragma once
@@ -7,18 +7,18 @@
 #include <sstream>
 
 class CustomReader {
-  std::stringstream _stream;
+  std::stringstream stream_;
 
  public:
-  CustomReader(const char* input) : _stream(input) {}
+  CustomReader(const char* input) : stream_(input) {}
   CustomReader(const CustomReader&) = delete;
 
   int read() {
-    return _stream.get();
+    return stream_.get();
   }
 
   size_t readBytes(char* buffer, size_t length) {
-    _stream.read(buffer, static_cast<std::streamsize>(length));
-    return static_cast<size_t>(_stream.gcount());
+    stream_.read(buffer, static_cast<std::streamsize>(length));
+    return static_cast<size_t>(stream_.gcount());
   }
 };

lib/ArduinoJson/extras/tests/Helpers/api/Print.h

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #pragma once

lib/ArduinoJson/extras/tests/Helpers/api/Stream.h

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #pragma once

lib/ArduinoJson/extras/tests/Helpers/api/String.h

@@ -1,5 +1,5 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
 #pragma once
@@ -9,11 +9,14 @@
 // Reproduces Arduino's String class
 class String {
  public:
-  String() : _maxCapacity(1024) {}
-  explicit String(const char* s) : _str(s), _maxCapacity(1024) {}
+  String() = default;
+  String(const char* s) {
+    if (s)
+      str_.assign(s);
+  }
 
   void limitCapacityTo(size_t maxCapacity) {
-    _maxCapacity = maxCapacity;
+    maxCapacity_ = maxCapacity;
   }
 
   unsigned char concat(const char* s) {
@@ -21,45 +24,48 @@ class String {
   }
 
   size_t length() const {
-    return _str.size();
+    return str_.size();
   }
 
   const char* c_str() const {
-    return _str.c_str();
+    return str_.c_str();
   }
 
   bool operator==(const char* s) const {
-    return _str == s;
+    return str_ == s;
   }
 
   String& operator=(const char* s) {
-    _str.assign(s);
+    if (s)
+      str_.assign(s);
+    else
+      str_.clear();
     return *this;
   }
 
   char operator[](unsigned int index) const {
-    if (index >= _str.size())
+    if (index >= str_.size())
       return 0;
-    return _str[index];
+    return str_[index];
   }
 
   friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
-    lhs << rhs._str;
+    lhs << rhs.str_;
     return lhs;
   }
 
  protected:
   // This function is protected in most Arduino cores
   unsigned char concat(const char* s, size_t n) {
-    if (_str.size() + n > _maxCapacity)
+    if (str_.size() + n > maxCapacity_)
       return 0;
-    _str.append(s, n);
+    str_.append(s, n);
     return 1;
   }
 
  private:
-  std::string _str;
-  size_t _maxCapacity;
+  std::string str_;
+  size_t maxCapacity_ = 1024;
 };
 
 class StringSumHelper : public ::String {};

lib/ArduinoJson/extras/tests/Helpers/avr/pgmspace.h

@@ -1,7 +1,9 @@
 // ArduinoJson - https://arduinojson.org
-// Copyright © 2014-2023, Benoit BLANCHON
+// Copyright © 2014-2024, Benoit BLANCHON
 // MIT License
 
+#pragma once
+
 #include <stdint.h>  // uint8_t
 
 #define PROGMEM