added library json

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

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

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

@@ -0,0 +1,24 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <sstream>
+
+class CustomReader {
+  std::stringstream stream_;
+
+ public:
+  CustomReader(const char* input) : stream_(input) {}
+  CustomReader(const CustomReader&) = delete;
+
+  int read() {
+    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());
+  }
+};

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

@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+  virtual size_t write(const uint8_t *buffer, size_t size) = 0;
+
+  size_t write(const char *str) {
+    if (!str)
+      return 0;
+    return write(reinterpret_cast<const uint8_t *>(str), strlen(str));
+  }
+
+  size_t write(const char *buffer, size_t size) {
+    return write(reinterpret_cast<const uint8_t *>(buffer), size);
+  }
+};
+
+class Printable {
+ public:
+  virtual ~Printable() {}
+  virtual size_t printTo(Print &p) const = 0;
+};

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

@@ -0,0 +1,14 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+// Reproduces Arduino's Stream class
+class Stream  // : public Print
+{
+ public:
+  virtual ~Stream() {}
+  virtual int read() = 0;
+  virtual size_t readBytes(char *buffer, size_t length) = 0;
+};

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

@@ -0,0 +1,69 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <string>
+
+// Reproduces Arduino's String class
+class String {
+ public:
+  String() : _maxCapacity(1024) {}
+  explicit String(const char* s) : _str(s), _maxCapacity(1024) {}
+
+  void limitCapacityTo(size_t maxCapacity) {
+    _maxCapacity = maxCapacity;
+  }
+
+  unsigned char concat(const char* s) {
+    return concat(s, strlen(s));
+  }
+
+  size_t length() const {
+    return _str.size();
+  }
+
+  const char* c_str() const {
+    return _str.c_str();
+  }
+
+  bool operator==(const char* s) const {
+    return _str == s;
+  }
+
+  String& operator=(const char* s) {
+    _str.assign(s);
+    return *this;
+  }
+
+  char operator[](unsigned int index) const {
+    if (index >= _str.size())
+      return 0;
+    return _str[index];
+  }
+
+  friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
+    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)
+      return 0;
+    _str.append(s, n);
+    return 1;
+  }
+
+ private:
+  std::string _str;
+  size_t _maxCapacity;
+};
+
+class StringSumHelper : public ::String {};
+
+inline bool operator==(const std::string& lhs, const ::String& rhs) {
+  return lhs == rhs.c_str();
+}

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

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2023, Benoit BLANCHON
+// MIT License
+
+#pragma once
+
+#include <stdint.h>  // uint8_t
+
+#define PROGMEM
+
+class __FlashStringHelper;
+
+inline const void* convertPtrToFlash(const void* s) {
+  return reinterpret_cast<const char*>(s) + 42;
+}
+
+inline const void* convertFlashToPtr(const void* s) {
+  return reinterpret_cast<const char*>(s) - 42;
+}
+
+#define PSTR(X) reinterpret_cast<const char*>(convertPtrToFlash(X))
+#define F(X) reinterpret_cast<const __FlashStringHelper*>(PSTR(X))
+
+inline uint8_t pgm_read_byte(const void* p) {
+  return *reinterpret_cast<const uint8_t*>(convertFlashToPtr(p));
+}
+
+#define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...)                \
+  static type const ARDUINOJSON_CONCAT2(name, _progmem)[] = __VA_ARGS__; \
+  static type const* name = reinterpret_cast<type const*>(               \
+      convertPtrToFlash(ARDUINOJSON_CONCAT2(name, _progmem)));