Set version to 5.13.5

.clang-format

@@ -3,6 +3,3 @@
 BasedOnStyle: Google
 Standard: Cpp03
 AllowShortFunctionsOnASingleLine: Empty
-
-# Always break after if to get accurate coverage
-AllowShortIfStatementsOnASingleLine: false

.github/FUNDING.yml

@@ -1 +0,0 @@
-custom: https://arduinojson.org/book/

.github/lock.yml

@@ -1,7 +0,0 @@
-# Configuration for Lock Threads - https://github.com/dessant/lock-threads
-
-# Number of days of inactivity before a closed issue or pull request is locked
-daysUntilLock: 30
-
-# Comment to post before locking. Set to `false` to disable
-lockComment: false

.gitignore

@@ -6,7 +6,6 @@
 /sftp-config.json
 .tags
 .tags_sorted_by_file
-/extras/fuzzing/*_fuzzer
-/extras/fuzzing/*_fuzzer.options
-/extras/fuzzing/*_fuzzer_seed_corpus.zip
-.vs/
+/fuzzing/*_fuzzer
+/fuzzing/*_fuzzer.options
+/fuzzing/*_fuzzer_seed_corpus.zip

.travis.yml

@@ -2,135 +2,133 @@ sudo: false
 language: cpp
 matrix:
   include:
-    - addons:
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.4']
-      env: SCRIPT=test _CC=gcc-4.4 _CXX=g++-4.4
-    - addons:
+      env: SCRIPT=cmake GCC=4.4
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.6']
-      env: SCRIPT=test _CC=gcc-4.6 _CXX=g++-4.6
-    - addons:
+      env: SCRIPT=cmake GCC=4.6
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.7']
-      env: SCRIPT=test _CC=gcc-4.7 _CXX=g++-4.7
-    - addons:
+      env: SCRIPT=cmake GCC=4.7
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.8']
-      env: SCRIPT=test _CC=gcc-4.8 _CXX=g++-4.8 
-    - addons:
+      env: SCRIPT=cmake GCC=4.8 SANITIZE=address
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-4.9']
-      env: SCRIPT=test _CC=gcc-4.9 _CXX=g++-4.9
-    - addons:
+      env: SCRIPT=cmake GCC=4.9 SANITIZE=leak
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-5']
-      env: SCRIPT=test _CC=gcc-5 _CXX=g++-5
-    - addons:
+      env: SCRIPT=cmake GCC=5
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-6']
-      env: SCRIPT=test _CC=gcc-6 _CXX=g++-6
-    - addons:
+      env: SCRIPT=cmake GCC=6
+    - compiler: gcc
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test']
           packages: ['g++-7']
-      env: SCRIPT=test _CC=gcc-7 _CXX=g++-7 CXXFLAGS="-fsanitize=leak"
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-8']
-      env: SCRIPT=test _CC=gcc-8 _CXX=g++-8 CXXFLAGS="-fsanitize=undefined" LDFLAGS="-fuse-ld=gold"
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-9']
-      env: SCRIPT=test _CC=gcc-9 _CXX=g++-9 CXXFLAGS="-fsanitize=address"
-    - addons:
-        apt:
-          packages: ['g++-arm-linux-gnueabihf']
-      env: SCRIPT=build _CC=arm-linux-gnueabihf-gcc _CXX=arm-linux-gnueabihf-g++
-    - env: SCRIPT=test _CC=clang _CXX=clang++
-    - addons:
+      env: SCRIPT=cmake GCC=7
+    - compiler: clang
+      env: SCRIPT=cmake
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
           packages: ['clang-3.5']
-      env: SCRIPT=test _CC=clang-3.5 _CXX=clang++-3.5 CXXFLAGS="-fsanitize=address"
-    - addons:
+      env: SCRIPT=cmake CLANG=3.5 SANITIZE=address
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
           packages: ['clang-3.6']
-      env: SCRIPT=test _CC=clang-3.6 _CXX=clang++-3.6 CXXFLAGS="-fsanitize=leak"
-    - addons:
+      env: SCRIPT=cmake CLANG=3.6 SANITIZE=leak
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
           packages: ['clang-3.7']
-      env: SCRIPT=test _CC=clang-3.7 _CXX=clang++-3.7
-    - addons:
+      env: SCRIPT=cmake CLANG=3.7
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
           packages: ['clang-3.8']
-      env: SCRIPT=test _CC=clang-3.8 _CXX=clang++-3.8 CXXFLAGS="-fsanitize=undefined"
-    - addons:
+      env: SCRIPT=cmake CLANG=3.8 SANITIZE=undefined
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-3.9']
           packages: ['clang-3.9']
-      env: SCRIPT=test _CC=clang-3.9 _CXX=clang++-3.9
-    - addons:
+      env: SCRIPT=cmake CLANG=3.9
+    - compiler: clang
+      addons:
         apt:
           sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-4.0']
           packages: ['clang-4.0']
-      env: SCRIPT=test _CC=clang-4.0 _CXX=clang++-4.0
-    - addons:
+      env: SCRIPT=cmake CLANG=4.0
+    - compiler: clang
+      addons:
         apt:
-          sources: ['ubuntu-toolchain-r-test']
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-5.0']
           packages: ['clang-5.0']
-      env: SCRIPT=test _CC=clang-5.0 _CXX=clang++-5.0
-    - addons:
+      env: SCRIPT=cmake CLANG=5.0
+    - compiler: clang
+      addons:
         apt:
-          sources: ['ubuntu-toolchain-r-test']
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-6.0']
           packages: ['clang-6.0']
-      env: SCRIPT=test _CC=clang-6.0 _CXX=clang++-6.0
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-7']
-          packages: ['clang-7']
-      env: SCRIPT=test _CC=clang-7 _CXX=clang++-7
-    - addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-8']
-          packages: ['clang-8']
-      env: SCRIPT=test _CC=clang-8 _CXX=clang++-8
-    - addons:
-        apt:
-          sources:
-            - sourceline: 'deb https://apt.llvm.org/xenial/ llvm-toolchain-xenial-9 main'
-              key_url: 'https://apt.llvm.org/llvm-snapshot.gpg.key'
-          packages: ['clang-9']
-      env: SCRIPT=test _CC=clang-9 _CXX=clang++-9
-    - env: SCRIPT=coverage
+      env: SCRIPT=cmake CLANG=6.0
+    - compiler: gcc
+      env: SCRIPT=coverage
+    - os: osx
+      osx_image: xcode7.3
+      compiler: clang
+      env: SCRIPT=cmake
     - os: osx
       osx_image: xcode8.3
-      env: SCRIPT=test
+      compiler: clang
+      env: SCRIPT=cmake
     - os: osx
       osx_image: xcode9.4
-      env: SCRIPT=test
+      compiler: clang
+      env: SCRIPT=cmake
     - os: osx
       osx_image: xcode10
-      env: SCRIPT=test CXXFLAGS="-fsanitize=address"
+      compiler: clang
+      env: SCRIPT=cmake SANITIZE=address
     - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:samd:mkr1000
+    - env: SCRIPT=arduino VERSION=1.8.2 BOARD=arduino:avr:uno
     - env: SCRIPT=platformio BOARD=uno
     - env: SCRIPT=platformio BOARD=esp01
+    - compiler: clang
+      addons:
+        apt:
+          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-trusty-6.0']
+          packages: ['clang-6.0','llvm-6.0']
+      env: SCRIPT=fuzz CLANG=6.0
 cache:
   directories:
     - "~/.platformio"
-    - "extras/fuzzing/json_corpus"
-    - "extras/fuzzing/msgpack_corpus"
-script: extras/ci/$SCRIPT.sh
+script: scripts/travis/$SCRIPT.sh

ArduinoJson.h

@@ -1,5 +1,5 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 
 #include "src/ArduinoJson.h"

CHANGELOG.md

@@ -1,595 +1,24 @@
 ArduinoJson: change log
 =======================
 
-v6.17.0 (2020-10-19)
+v5.13.5
 -------
 
-* Added a build failure when nullptr is defined as a macro (issue #1355)
-* Added `JsonDocument::overflowed()` which tells if the memory pool was too small (issue #1358)
-* Added `DeserializationError::EmptyInput` which tells if the input was empty
-* Added `DeserializationError::f_str()` which returns a `const __FlashStringHelper*` (issue #846)
-* Added `operator|(JsonVariantConst, JsonVariantConst)`
-* Added filtering for MessagePack (issue #1298, PR #1394 by Luca Passarella)
-* Moved float convertion tables to PROGMEM
-* Fixed `JsonVariant::set((char*)0)` which returned false instead of true (issue #1368)
-* Fixed error `No such file or directory #include <WString.h>` (issue #1381)
-
-v6.16.1 (2020-08-04)
--------
-
-* Fixed `deserializeJson()` that stopped reading after `{}` (issue #1335)
-
-v6.16.0 (2020-08-01)
--------
-
-* Added comparisons (`>`, `>=`, `==`, `!=`, `<`, and `<=`) between `JsonVariant`s
-* Added string deduplication (issue #1303)
-* Added `JsonString::operator!=`
-* Added wildcard key (`*`) for filters (issue #1309)
-* Set `ARDUINOJSON_DECODE_UNICODE` to `1` by default
-* Fixed `copyArray()` not working with `String`, `ElementProxy`, and `MemberProxy`
-* Fixed error `getOrAddElement is not a member of ElementProxy` (issue #1311)
-* Fixed excessive stack usage when compiled with `-Og` (issues #1210 and #1314)
-* Fixed `Warning[Pa093]: implicit conversion from floating point to integer` on IAR compiler (PR #1328 by @stawiski)
-
-v6.15.2 (2020-05-15)
--------
-
-* CMake: don't build tests when imported in another project
-* CMake: made project arch-independent
-* Visual Studio: fixed error C2766 with flag `/Zc:__cplusplus` (issue #1250)
-* Added support for `JsonDocument` to `copyArray()` (issue #1255)
-* Added support for `enum`s in `as<T>()` and `is<T>()`  (issue #1256)
-* Added `JsonVariant` as an input type for `deserializeXxx()`  
-  For example, you can do: `deserializeJson(doc2, doc1["payload"])`
-* Break the build if using 64-bit integers with ARDUINOJSON_USE_LONG_LONG==0
-
-v6.15.1 (2020-04-08)
--------
-
-* Fixed "maybe-uninitialized" warning (issue #1217)
-* Fixed "statement is unreachable" warning on IAR (issue #1233)
-* Fixed "pointless integer comparison" warning on IAR (issue #1233)
-* Added CMake "install" target (issue #1209)
-* Disabled alignment on AVR (issue #1231)
-
-v6.15.0 (2020-03-22)
--------
-
-* Added `DeserializationOption::Filter` (issue #959)
-* Added example `JsonFilterExample.ino`
-* Changed the array subscript operator to automatically add missing elements
-* Fixed "deprecated-copy" warning on GCC 9 (fixes #1184)
-* Fixed `MemberProxy::set(char[])` not duplicating the string (issue #1191)
-* Fixed enums serialized as booleans (issue #1197)
-* Fixed incorrect string comparison on some platforms (issue #1198)
-* Added move-constructor and move-assignment to `BasicJsonDocument`
-* Added `BasicJsonDocument::garbageCollect()` (issue #1195)
-* Added `StaticJsonDocument::garbageCollect()`
-* Changed copy-constructor of `BasicJsonDocument` to preserve the capacity of the source.
-* Removed copy-constructor of `JsonDocument` (issue #1189)
-
-> ### BREAKING CHANGES
-> 
-> #### Copy-constructor of `BasicJsonDocument`
->
-> In previous versions, the copy constructor of `BasicJsonDocument` looked at the source's `memoryUsage()` to choose its capacity.
-> Now, the copy constructor of `BasicJsonDocument` uses the same capacity as the source.
->
-> Example:
->
-> ```c++
-> DynamicJsonDocument doc1(64);
-> doc1.set(String("example"));
->
-> DynamicJsonDocument doc2 = doc1;
-> Serial.print(doc2.capacity());  // 8 with ArduinoJson 6.14
->                                 // 64 with ArduinoJson 6.15
-> ```
->
-> I made this change to get consistent results between copy-constructor and move-constructor, and whether RVO applies or not.
->
-> If you use the copy-constructor to optimize your documents, you can use `garbageCollect()` or `shrinkToFit()` instead.
->
-> #### Copy-constructor of `JsonDocument`
->
-> In previous versions, it was possible to create a function that take a `JsonDocument` by value.
->
-> ```c++
-> void myFunction(JsonDocument doc) {}
-> ```
->
-> This function gives the wrong clues because it doesn't receive a copy of the `JsonDocument`, only a sliced version.
-> It worked because the copy constructor copied the internal pointers, but it was an accident.
->
-> From now, if you need to pass a `JsonDocument` to a function, you must use a reference:
->
-> ```c++
-> void myFunction(JsonDocument& doc) {}
-> ```
-
-v6.14.1 (2020-01-27)
--------
-
-* Fixed regression in UTF16 decoding (issue #1173)
-* Fixed `containsKey()` on `JsonVariantConst`
-* Added `getElement()` and `getMember()` to `JsonVariantConst`
-
-v6.14.0 (2020-01-16)
--------
-
-* Added `BasicJsonDocument::shrinkToFit()`
-* Added support of `uint8_t` for `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` (issue #1142)
-* Added `ARDUINOJSON_ENABLE_COMMENTS` to enable support for comments (defaults to 0)
-* Auto enable support for `std::string` and `std::stream` on modern compilers (issue #1156)
-  (No need to define `ARDUINOJSON_ENABLE_STD_STRING` and `ARDUINOJSON_ENABLE_STD_STREAM` anymore)
-* Improved decoding of UTF-16 surrogate pairs (PR #1157 by @kaysievers)
-  (ArduinoJson now produces standard UTF-8 instead of CESU-8)
-* Added `measureJson`, `measureJsonPretty`, and `measureMsgPack` to `keywords.txt`
-  (This file is used for syntax highlighting in the Arduino IDE) 
-* Fixed `variant.is<nullptr_t>()`
-* Fixed value returned by `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` when writing to a `String`
-* Improved speed of `serializeJson()`, `serializeJsonPretty()`, and `serializeMsgPack()` when writing to a `String`
-
-> ### BREAKING CHANGES
-> 
-> #### Comments
-> 
-> Support for comments in input is now optional and disabled by default.
->
-> If you need support for comments, you must defined `ARDUINOJSON_ENABLE_COMMENTS` to `1`; otherwise, you'll receive `InvalidInput` errors.
->
-> ```c++
-> #define ARDUINOJSON_ENABLE_COMMENTS 1
-> #include <ArduinoJson.h>
-> ```
-
-v6.13.0 (2019-11-01)
--------
-
-* Added support for custom writer/reader classes (issue #1088)
-* Added conversion from `JsonArray` and `JsonObject` to `bool`, to be consistent with `JsonVariant`
-* Fixed `deserializeJson()` when input contains duplicate keys (issue #1095)
-* Improved `deserializeMsgPack()` speed by reading several bytes at once
-* Added detection of Atmel AVR8/GNU C Compiler (issue #1112)
-* Fixed deserializer that stopped reading at the first `0xFF` (PR #1118 by @mikee47)
-* Fixed dangling reference in copies of `MemberProxy` and `ElementProxy` (issue #1120)
-
-v6.12.0 (2019-09-05)
--------
-
-* Use absolute instead of relative includes (issue #1072)
-* Changed `JsonVariant::as<bool>()` to return `true` for any non-null value (issue #1005)
-* Moved ancillary files to `extras/` (issue #1011)
-
-v6.11.5 (2019-08-23)
--------
-
-* Added fallback implementations of `strlen_P()`, `strncmp_P()`, `strcmp_P()`, and `memcpy_P()` (issue #1073)
-
-v6.11.4 (2019-08-12)
--------
-
-* Added `measureJson()` to the `ArduinoJson` namespace (PR #1069 by @nomis)
-* Added support for `basic_string<char, traits, allocator>` (issue #1045)
-* Fixed example `JsonConfigFile.ino` for ESP8266
-* Include `Arduino.h` if `ARDUINO` is defined (PR #1071 by @nomis)
-
-v6.11.3 (2019-07-22)
--------
-
-* Added operators `==` and `!=` for `JsonDocument`, `ElementProxy`, and `MemberProxy`
-* Fixed comparison of `JsonVariant` when one contains a linked string and the other contains an owned string (issue #1051)
-
-v6.11.2 (2019-07-08)
--------
-
-* Fixed assignment of `JsonDocument` to `JsonVariant` (issue #1023)
-* Fix invalid conversion error on Particle Argon (issue #1035)
-
-v6.11.1 (2019-06-21)
--------
-
-* Fixed `serialized()` not working with Flash strings (issue #1030)
-
-v6.11.0 (2019-05-26)
--------
-
-* Fixed `deserializeJson()` silently accepting a `Stream*` (issue #978)
-* Fixed invalid result from `operator|` (issue #981)
-* Made `deserializeJson()` more picky about trailing characters (issue #980)
-* Added `ARDUINOJSON_ENABLE_NAN` (default=0) to enable NaN in JSON (issue #973)
-* Added `ARDUINOJSON_ENABLE_INFINITY` (default=0) to enable Infinity in JSON
-* Removed implicit conversion in comparison operators (issue #998)
-* Added lexicographical comparison for `JsonVariant`
-* Added support for `nullptr` (issue #998)
-
-> ### BREAKING CHANGES
-> 
-> #### NaN and Infinity
-> 
-> The JSON specification allows neither NaN not Infinity, but previous
-> versions of ArduinoJson supported it. Now, ArduinoJson behaves like most
-> other libraries: a NaN or and Infinity in the `JsonDocument`, becomes
-> a `null` in the output JSON. Also, `deserializeJson()` returns
-> `InvalidInput` if the JSON document contains NaN or Infinity.
-> 
-> This version still supports NaN and Infinity in JSON documents, but
-> it's disabled by default to be compatible with other JSON parsers.
-> If you need the old behavior back, define `ARDUINOJSON_ENABLE_NAN` and
-> `ARDUINOJSON_ENABLE_INFINITY` to `1`;:
-> 
-> ```c++
-> #define ARDUINOJSON_ENABLE_NAN 1
-> #define ARDUINOJSON_ENABLE_INFINITY 1
-> #include <ArduinoJson.h>
-> ```
-> 
-> #### The "or" operator
-> 
-> This version slightly changes the behavior of the | operator when the 
-> variant contains a float and the user requests an integer.
->
-> Older versions returned the floating point value truncated.
-> Now, it returns the default value.
-> 
-> ```c++
-> // suppose variant contains 1.2
-> int value = variant | 3;
-> 
-> // old behavior:
-> value == 1
-> 
-> // new behavior
-> value == 3
-> ```
-> 
-> If you need the old behavior, you must add `if (variant.is<float>())`.
-
-v6.10.1 (2019-04-23)
--------
-
-* Fixed error "attributes are not allowed on a function-definition"
-* Fixed `deserializeJson()` not being picky enough (issue #969)
-* Fixed error "no matching function for call to write(uint8_t)" (issue #972)
-
-v6.10.0 (2019-03-22)
--------
-
-* Fixed an integer overflow in the JSON deserializer
-* Added overflow handling in `JsonVariant::as<T>()` and `JsonVariant::is<T>()`.
-   - `as<T>()` returns `0` if the integer `T` overflows
-   - `is<T>()` returns `false` if the integer `T` overflows
-* Added `BasicJsonDocument` to support custom allocator (issue #876)
-* Added `JsonDocument::containsKey()` (issue #938)
-* Added `JsonVariant::containsKey()`
-
-v6.9.1 (2019-03-01)
-------
-
 * Fixed warning "unused variable" with GCC 4.4 (issue #912)
-* Fixed warning "cast  increases required alignment" (issue #914)
-* Fixed warning "conversion may alter value" (issue #914)
-* Fixed naming conflict with "CAPACITY" (issue #839)
-* Muted warning "will change in GCC 7.1" (issue #914)
-* Added a clear error message for `StaticJsonBuffer` and `DynamicJsonBuffer`
-* Marked ArduinoJson.h  as a "system header"
+* Fixed warning "maybe uninitialized" (issue #909)
+* Added an clear message for `StaticJsonDocument`, `DynamicJsonDocument`...
 
-v6.9.0 (2019-02-26)
-------
+v5.13.4
+-------
 
-* Decode escaped Unicode characters like \u00DE (issue #304, PR #791)
-  Many thanks to Daniel Schulte (aka @trilader) who implemented this feature.
-* Added option ARDUINOJSON_DECODE_UNICODE to enable it
-* Converted `JsonArray::copyFrom()/copyTo()` to free functions `copyArray()`
-* Renamed `JsonArray::copyFrom()` and `JsonObject::copyFrom()` to `set()`
-* Renamed `JsonArray::get()` to `getElement()`
-* Renamed `JsonArray::add()` (without arg) to `addElement()`
-* Renamed `JsonObject::get()` to `getMember()`
-* Renamed `JsonObject::getOrCreate()` to `getOrAddMember()`
-* Fixed `JsonVariant::isNull()` not returning `true` after `set((char*)0)`
-* Fixed segfault after `variant.set(serialized((char*)0))`
-* Detect `IncompleteInput` in `false`, `true`, and `null`
-* Added `JsonDocument::size()`
-* Added `JsonDocument::remove()`
-* Added `JsonVariant::clear()`
-* Added `JsonVariant::remove()`
-
-v6.8.0-beta (2019-01-30)
------------
-
-* Import functions in the ArduinoJson namespace to get clearer errors
-* Improved syntax highlighting in Arduino IDE
-* Removed default capacity of `DynamicJsonDocument`
-* `JsonArray::copyFrom()` accepts `JsonArrayConst`
-* `JsonVariant::set()` accepts `JsonArrayConst` and `JsonObjectConst`
-* `JsonDocument` was missing in the ArduinoJson namespace
-* Added `memoryUsage()` to `JsonArray`, `JsonObject`, and `JsonVariant`
-* Added `nesting()` to `JsonArray`, `JsonDocument`, `JsonObject`, and `JsonVariant`
-* Replaced `JsonDocument::nestingLimit` with an additional parameter
-  to `deserializeJson()` and `deserializeMsgPack()`
-* Fixed uninitialized variant in `JsonDocument`
-* Fixed `StaticJsonDocument` copy constructor and copy assignment
-* The copy constructor of `DynamicJsonDocument` chooses the capacity according to the memory usage of the source, not from the capacity of the source.
-* Added the ability to create/assign a `StaticJsonDocument`/`DynamicJsonDocument` from a `JsonArray`/`JsonObject`/`JsonVariant`
-* Added `JsonDocument::isNull()`
-* Added `JsonDocument::operator[]`
-* Added `ARDUINOJSON_TAB` to configure the indentation character
-* Reduced the size of the pretty JSON serializer
-* Added `add()`, `createNestedArray()` and `createNestedObject()` to `JsonVariant`
-* `JsonVariant` automatically promotes to `JsonObject` or `JsonArray` on write.
-  Calling `JsonVariant::to<T>()` is not required anymore.
-* `JsonDocument` now support the same operations as `JsonVariant`.
-  Calling `JsonDocument::as<T>()` is not required anymore.
-* Fixed example `JsonHttpClient.ino`
-* User can now use a `JsonString` as a key or a value
-
-> ### BREAKING CHANGES
-> 
-> #### `DynamicJsonDocument`'s constructor
-> 
-> The parameter to the constructor of `DynamicJsonDocument` is now mandatory
->
-> Old code:
->
-> ```c++
-> DynamicJsonDocument doc;
-> ```
->
-> New code:
->
-> ```c++
-> DynamicJsonDocument doc(1024);
-> ```
-> 
-> #### Nesting limit
-> 
-> `JsonDocument::nestingLimit` was replaced with a new parameter to `deserializeJson()` and `deserializeMsgPack()`.
-> 
-> Old code:
-> 
-> ```c++
-> doc.nestingLimit = 15;
-> deserializeJson(doc, input);
-> ```
-> 
-> New code: 
-> 
-> ```c++
-> deserializeJson(doc, input, DeserializationOption::NestingLimit(15));
-> ```
-
-v6.7.0-beta (2018-12-07)
------------
-
-* Removed the automatic expansion of `DynamicJsonDocument`, it now has a fixed capacity.
-* Restored the monotonic allocator because the code was getting too big
-* Reduced the memory usage
-* Reduced the code size
-* Renamed `JsonKey` to `JsonString`
 * Removed spurious files in the Particle library
 
-v6.6.0-beta (2018-11-13)
------------
+v5.13.3
+-------
 
-* Removed `JsonArray::is<T>(i)` and `JsonArray::set(i,v)`
-* Removed `JsonObject::is<T>(k)` and `JsonObject::set(k,v)`
-* Replaced `T JsonArray::get<T>(i)` with `JsonVariant JsonArray::get(i)`
-* Replaced `T JsonObject::get<T>(k)` with `JsonVariant JsonObject::get(k)`
-* Added `JSON_STRING_SIZE()`
-* ~~Replacing or removing a value now releases the memory~~
-* Added `DeserializationError::code()` to be used in switch statements (issue #846)
-
-v6.5.0-beta (2018-10-13)
------------
-
-* Added implicit conversion from `JsonArray` and `JsonObject` to `JsonVariant`
-* Allow mixed configuration in compilation units (issue #809)
-* Fixed object keys not being duplicated
-* `JsonPair::key()` now returns a `JsonKey`
-* Increased the default capacity of `DynamicJsonDocument`
-* Fixed `JsonVariant::is<String>()` (closes #763)
-* Added `JsonArrayConst`, `JsonObjectConst`, and `JsonVariantConst`
-* Added copy-constructor and copy-assignment-operator for `JsonDocument` (issue #827)
-
-v6.4.0-beta (2018-09-11)
------------
-
-* Copy `JsonArray` and `JsonObject`, instead of storing pointers (issue #780)
-* Added `JsonVariant::to<JsonArray>()` and `JsonVariant::to<JsonObject>()`
-
-v6.3.0-beta (2018-08-31)
------------
-
-* Implemented reference semantics for `JsonVariant`
-* Replaced `JsonPair`'s `key` and `value` with `key()` and `value()`
-* Fixed `serializeJson(obj[key], dst)` (issue #794)
-
-> ### BREAKING CHANGES
->
-> #### JsonVariant
-> 
-> `JsonVariant` now has a semantic similar to `JsonObject` and `JsonArray`.
-> It's a reference to a value stored in the `JsonDocument`.
-> As a consequence, a `JsonVariant` cannot be used as a standalone variable anymore.
->
-> Old code:
->
-> ```c++
-> JsonVariant myValue = 42;
-> ```
->
-> New code:
->
-> ```c++
-> DynamicJsonDocument doc;
-> JsonVariant myValue = doc.to<JsonVariant>();
-> myValue.set(42);
-> ```
->
-> #### JsonPair
->
-> Old code:
->
-> ```c++
-> for(JsonPair p : myObject) {
->   Serial.println(p.key);
->   Serial.println(p.value.as<int>());
-> }
-> ```
->
-> New code:
->
-> ```c++
-> for(JsonPair p : myObject) {
->   Serial.println(p.key());
->   Serial.println(p.value().as<int>());
-> }
-> ```
->
-> CAUTION: the key is now read only!
-
-v6.2.3-beta (2018-07-19)
------------
-
-* Fixed exception when using Flash strings as object keys (issue #784)
-
-v6.2.2-beta (2018-07-18)
------------
-
-* Fixed `invalid application of 'sizeof' to incomplete type '__FlashStringHelper'` (issue #783)
-* Fixed `char[]` not duplicated when passed to `JsonVariant::operator[]`
-
-v6.2.1-beta (2018-07-17)
------------
-
-* Fixed `JsonObject` not inserting keys of type `String` (issue #782)
-
-v6.2.0-beta (2018-07-12)
------------
-
-* Disabled lazy number deserialization (issue #772)
-* Fixed `JsonVariant::is<int>()` that returned true for empty strings
 * Improved float serialization when `-fsingle-precision-constant` is used
-* Renamed function `RawJson()` to `serialized()`
-* `serializeMsgPack()` now supports values marked with `serialized()`
-
-> ### BREAKING CHANGES
->
-> #### Non quoted strings
->
-> Non quoted strings are now forbidden in values, but they are still allowed in keys.
-> For example, `{key:"value"}` is accepted, but `{key:value}` is not.
->
-> #### Preformatted values
->
-> Old code:
->
-> ```c++
-> object["values"] = RawJson("[1,2,3,4]");
-> ```
-> 
-> New code:
-> 
-> ```c++
-> object["values"] = serialized("[1,2,3,4]");
-> ```
-
-v6.1.0-beta (2018-07-02)
------------
-
-* Return `JsonArray` and `JsonObject` by value instead of reference (issue #309)
-* Replaced `success()` with `isNull()`
-
-> ### BREAKING CHANGES
-> 
-> Old code:
->
-> ```c++
-> JsonObject& obj = doc.to<JsonObject>();
-> JsonArray& arr = obj.createNestedArray("key");
-> if (!arr.success()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> JsonObject obj = doc.to<JsonObject>();
-> JsonArray arr = obj.createNestedArray("key");
-> if (arr.isNull()) {
->   Serial.println("Not enough memory");
->   return;
-> }
-> ```
-
-v6.0.1-beta (2018-06-11)
------------
-
-* Fixed conflicts with `isnan()` and `isinf()` macros (issue #752)
-
-v6.0.0-beta (2018-06-07)
------------
-
-* Added `DynamicJsonDocument` and `StaticJsonDocument`
-* Added `deserializeJson()`
-* Added `serializeJson()` and `serializeJsonPretty()`
-* Added `measureJson()` and `measureJsonPretty()`
-* Added `serializeMsgPack()`, `deserializeMsgPack()` and `measureMsgPack()` (issue #358)
-* Added example `MsgPackParser.ino` (issue #358)
-* Added support for non zero-terminated strings (issue #704)
-* Removed `JsonBuffer::parseArray()`, `parseObject()` and `parse()`
-* Removed `JsonBuffer::createArray()` and `createObject()`
-* Removed `printTo()` and `prettyPrintTo()`
-* Removed `measureLength()` and `measurePrettyLength()`
-* Removed all deprecated features
-
-> ### BREAKING CHANGES
-> 
-> #### Deserialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.parseObject(json);
-> if (obj.success()) {
-> 
-> }
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument doc;
-> DeserializationError error = deserializeJson(doc, json);
-> if (error) {
-> 
-> }
-> JsonObject& obj = doc.as<JsonObject>();
-> ```
-> 
-> #### Serialization
-> 
-> Old code:
-> 
-> ```c++
-> DynamicJsonBuffer jb;
-> JsonObject& obj = jb.createObject();
-> obj["key"] = "value";
-> obj.printTo(Serial);
-> ```
-> 
-> New code:
-> 
-> ```c++
-> DynamicJsonDocument obj;
-> JsonObject& obj = doc.to<JsonObject>();
-> obj["key"] = "value";
-> serializeJson(doc, Serial);
-> ```
+* Fixed `JsonVariant::is<int>()` that returned true for empty strings
+* Fixed `JsonVariant::is<String>()` (closes #763)
 
 v5.13.2
 -------
@@ -1010,3 +439,52 @@ However, you should not see this as an invitation to use the `String` class.
 The `String` class is **bad** because it uses dynamic memory allocation.
 Compared to static allocation, it compiles to a bigger, slower program, and is less predictable.
 You certainly don't want that in an embedded environment!
+
+v4.6
+----
+
+* Fixed segmentation fault in `DynamicJsonBuffer` when memory allocation fails (issue #92)
+
+v4.5
+----
+
+* Fixed buffer overflow when input contains a backslash followed by a terminator (issue #81)
+
+**Upgrading is recommended** since previous versions contain a potential security risk.
+
+Special thanks to [Giancarlo Canales Barreto](https://github.com/gcanalesb) for finding this nasty bug.
+
+v4.4
+----
+
+* Added `JsonArray::measureLength()` and `JsonObject::measureLength()` (issue #75)
+
+v4.3
+----
+
+* Added `JsonArray::removeAt()` to remove an element of an array (issue #58)
+* Fixed stack-overflow in `DynamicJsonBuffer` when parsing huge JSON files (issue #65)
+* Fixed wrong return value of `parseArray()` and `parseObject()` when allocation fails (issue #68)
+
+v4.2
+----
+
+* Switched back to old library layout (issues #39, #43 and #45)
+* Removed global new operator overload (issue #40, #45 and #46)
+* Added an example with EthernetServer
+
+v4.1
+----
+
+* Added DynamicJsonBuffer (issue #19)
+
+v4.0
+----
+
+* Unified parser and generator API (issue #23)
+* Updated library layout, now requires Arduino 1.0.6 or newer
+
+> ### BREAKING CHANGES :warning:
+>
+> API changed significantly since v3, see [Migrating code to the new API](https://arduinojson.org/doc/migration/).
+

CMakeLists.txt

@@ -1,19 +1,16 @@
 # ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
+# Copyright Benoit Blanchon 2014-2019
 # MIT License
 
 cmake_minimum_required(VERSION 3.0)
+project(ArduinoJson)
 
-project(ArduinoJson VERSION 6.17.0)
+enable_testing()
 
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)
-    include(CTest)
+if(${COVERAGE})
+	set(CMAKE_CXX_FLAGS "-g -O0 -fprofile-arcs -ftest-coverage")
 endif()
 
-add_subdirectory(src)
-
-if(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)
-	include(extras/CompileOptions.cmake)
-	add_subdirectory(extras/tests)
-	add_subdirectory(extras/fuzzing)
-endif()
+include_directories(${CMAKE_CURRENT_LIST_DIR}/src)
+add_subdirectory(third-party/catch)
+add_subdirectory(test)

LICENSE.md

@@ -1,7 +1,7 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014-2020 Benoit BLANCHON
+Copyright © 2014-2019 Benoit BLANCHON
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

README.md

@@ -2,93 +2,57 @@
 
 ---
 
-[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=6.17.0)](https://www.ardu-badge.com/ArduinoJson/6.17.0)
-[![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/6.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=6.x)](https://travis-ci.org/bblanchon/ArduinoJson)
-[![Fuzzing Status](https://oss-fuzz-build-logs.storage.googleapis.com/badges/arduinojson.svg)](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
-[![Coverage Status](https://coveralls.io/repos/github/bblanchon/ArduinoJson/badge.svg?branch=6.x)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
-[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat)](https://github.com/bblanchon/ArduinoJson/stargazers)
+[![arduino-library-badge](https://www.ardu-badge.com/badge/ArduinoJson.svg?version=5.13.5)](https://www.ardu-badge.com/ArduinoJson/5.13.5)
+[![Build Status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master)
+[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson)
+[![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master)
+[![Star this project](http://githubbadges.com/star.svg?user=bblanchon&repo=ArduinoJson&style=flat&color=fff&background=007ec6)](https://github.com/bblanchon/ArduinoJson)
 
 ArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).
 
 ## Features
 
-* [JSON deserialization](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally decodes UTF-16 escape sequences to UTF-8](https://arduinojson.org/v6/api/config/decode_unicode/?utm_source=github&utm_medium=readme)
-    * [Optionally stores links to the input buffer (zero-copy)](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally supports comments in the input](https://arduinojson.org/v6/api/config/enable_comments/?utm_source=github&utm_medium=readme)
-    * [Optionally filters the input to keep only desired values](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#filtering)
-    * Supports single quotes as a string delimiter
-    * Compatible with NDJSON and JSON Lines
-* [JSON serialization](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
-    * [Can write to a buffer or a stream](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme)
-    * [Optionally indents the document (prettified JSON)](https://arduinojson.org/v6/api/json/serializejsonpretty/?utm_source=github&utm_medium=readme)
-* [MessagePack serialization](https://arduinojson.org/v6/api/msgpack/serializemsgpack/?utm_source=github&utm_medium=readme)
-* [MessagePack deserialization](https://arduinojson.org/v6/api/msgpack/deserializemsgpack/?utm_source=github&utm_medium=readme)
-* Efficient
-    * [Twice smaller than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Almost 10% faster than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Consumes roughly 10% less RAM than the "official" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/?utm_source=github&utm_medium=readme)
-    * [Fixed memory allocation, no heap fragmentation](https://arduinojson.org/v6/api/jsondocument/?utm_source=github&utm_medium=readme)
-    * [Optionally works without heap memory (zero malloc)](https://arduinojson.org/v6/api/staticjsondocument/?utm_source=github&utm_medium=readme)
-    * Deduplicates strings
-* Versatile
-    * [Supports custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v6/how-to/use-external-ram-on-esp32/?utm_source=github&utm_medium=readme)
-    * Supports [Arduino's `String`](https://arduinojson.org/v6/api/config/enable_arduino_string/) and [STL's `std::string`](https://arduinojson.org/v6/api/config/enable_std_string/?utm_source=github&utm_medium=readme)
-    * Supports Arduino's `Stream` and [STL's `std::istream`/`std::ostream`](https://arduinojson.org/v6/api/config/enable_std_stream/?utm_source=github&utm_medium=readme)
-    * [Supports Flash strings](https://arduinojson.org/v6/api/config/enable_progmem/?utm_source=github&utm_medium=readme)
-    * Supports [custom readers](https://arduinojson.org/v6/api/json/deserializejson/?utm_source=github&utm_medium=readme#custom-reader) and [custom writers](https://arduinojson.org/v6/api/json/serializejson/?utm_source=github&utm_medium=readme#custom-writer)
-* Portable
-    * Usable on any C++ project (not limited to Arduino)
-    * Compatible with C++98
-    * Zero warnings with `-Wall -Wextra -pedantic` and `/W4`
-    * [Header-only library](https://en.wikipedia.org/wiki/Header-only)
-    * Works with virtually any board
-        * Arduino boards: [Uno](https://amzn.to/38aL2ik), [Due](https://amzn.to/36YkWi2), [Micro](https://amzn.to/35WkdwG), [Nano](https://amzn.to/2QTvwRX), [Mega](https://amzn.to/36XWhuf), [Yun](https://amzn.to/30odURc), [Leonardo](https://amzn.to/36XWjlR)...
-        * Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB)
-        * Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)...
-        * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj) 
-        * Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)...
-        * Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)...
-    * Tested on all major development environments
-        * [Arduino IDE](https://www.arduino.cc/en/Main/Software)
-        * [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
-        * [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
-        * [Energia](http://energia.nu/)
-        * [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
-        * [Keil uVision](http://www.keil.com/)
-        * [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
-        * [PlatformIO](http://platformio.org/)
-        * [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/)
-        * [Visual Micro](http://www.visualmicro.com/)
-        * [Visual Studio](https://www.visualstudio.com/)
-    * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/t7KP7I6dVuLhqzDl)
-    * [CMake friendly](https://arduinojson.org/v6/how-to/use-arduinojson-with-cmake/?utm_source=github&utm_medium=readme)
-* Well designed
-    * [Elegant API](http://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)
-    * Self-contained (no external dependency)
-    * `const` friendly
-    * [`for` friendly](https://arduinojson.org/v6/api/jsonobject/begin_end/?utm_source=github&utm_medium=readme)
-    * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)
-    * Handles [integer overflows](https://arduinojson.org/v6/api/jsonvariant/as/?utm_source=github&utm_medium=readme#integer-overflows)
-* Well tested
-    * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=6.x)
-    * Continuously tested on
-        * [Visual Studio 2010, 2012, 2013, 2015, 2017, 2019](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/6.x)
-        * [GCC 4.4, 4.6, 4.7, 4.8, 4.9, 5, 6, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
-        * [Clang 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 5.0, 6.0, 7, 8](https://travis-ci.org/bblanchon/ArduinoJson)
-    * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)
-* Well documented
-    * [Tutorials](https://arduinojson.org/v6/doc/deserialization/?utm_source=github&utm_medium=readme)
-    * [Examples](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [How-tos](https://arduinojson.org/v6/example/?utm_source=github&utm_medium=readme)
-    * [FAQ](https://arduinojson.org/v6/faq/?utm_source=github&utm_medium=readme)
-    * [Book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme)
-* Vibrant user community
-    * Most popular of all Arduino libraries on [GitHub](https://github.com/search?o=desc&q=arduino+library&s=stars&type=Repositories) and [PlatformIO](https://platformio.org/lib/search)
-    * [Used in hundreds of projects](https://www.hackster.io/search?i=projects&q=arduinojson)
-    * [Responsive support](https://github.com/bblanchon/ArduinoJson/issues?q=is%3Aissue+is%3Aclosed)
+* JSON decoding (comments are supported)
+* JSON encoding (with optional indentation)
+* Elegant API, easy to use
+* Fixed memory allocation (zero malloc)
+* No data duplication (zero copy)
+* Portable (written in C++98, can be used in any C++ project)
+* Self-contained (no external dependency)
+* Small footprint
+* Input and output streams
+* [100% code coverage](https://coveralls.io/github/bblanchon/ArduinoJson)
+* [Header-only library](https://en.wikipedia.org/wiki/Header-only)
+* [MIT License](https://en.wikipedia.org/wiki/MIT_License)
+* [Comprehensive documentation](https://arduinojson.org?utm_source=github&utm_medium=readme)
+
+## Compatibility
+
+ArduinoJson works on the following hardware:
+
+* <img src="https://www.arduino.cc/favicon.ico" height="16" width="16"> Arduino boards: [Uno](https://www.arduino.cc/en/Main/ArduinoBoardUno), [Due](https://www.arduino.cc/en/Main/ArduinoBoardDue), [Mini](https://www.arduino.cc/en/Main/ArduinoBoardMini), [Micro](https://www.arduino.cc/en/Main/ArduinoBoardMicro), [Yun](https://www.arduino.cc/en/Main/ArduinoBoardYun)...
+* <img src="http://espressif.com/sites/all/themes/espressif/favicon.ico" height="16" width="16"> Espressif chips: [ESP8266](https://en.wikipedia.org/wiki/ESP8266), [ESP32](https://en.wikipedia.org/wiki/ESP32)
+* <img src="https://www.wemos.cc/themes/martin-materialize-parallax/assets/favicon.ico" height="16" width="16"> WeMos boards: [D1](https://wiki.wemos.cc/products:d1:d1), [D1 mini](https://wiki.wemos.cc/products:d1:d1_mini),  ...
+* <img src="http://redbearlab.com/favicon.ico" height="16" width="16"> RedBearLab boards: [BLE Nano](http://redbearlab.com/blenano/), [BLE Mini](http://redbearlab.com/blemini/), [WiFi Micro](https://redbear.cc/product/wifi/wifi-micro.html), [LOLIN32](https://wiki.wemos.cc/products:lolin32:lolin32)...
+* <img src="https://www.pjrc.com/favicon.ico" height="16" width="16"> [Teensy](https://www.pjrc.com/teensy/) boards
+* <img src="https://software.intel.com/sites/all/themes/zero/favicon.ico" height="16" width="16"> Intel boards: Edison, Galileo...
+* <img src="https://www-assets.particle.io/images/favicon.png"  height="16" width="16"> Particle boards: [Photon](https://www.particle.io/products/hardware/photon-wifi-dev-kit), [Electron](https://www.particle.io/products/hardware/electron-cellular-dev-kit)...
+* <img src="http://www.ti.com/favicon.ico" height="16" width="16"> Texas Instruments boards: [MSP430](http://www.ti.com/microcontrollers/msp430-ultra-low-power-mcus/overview/overview.html)...
+
+ArduinoJson compiles with zero warning on the following compilers, IDEs, and platforms:
+
+* <img src="https://www.arduino.cc/favicon.ico" height="16" width="16"> [Arduino IDE](https://www.arduino.cc/en/Main/Software)
+* <img src="http://cdn.platformio.org/favicon.ico" height="16" width="16"> [PlatformIO](http://platformio.org/)
+* <img src="http://energia.nu/img/favicon.ico" height="16" width="16"> [Energia](http://energia.nu/)
+* <img src="http://www.visualmicro.com/pics/arduino-visual-studio-ld.png" height="16" width="16"> [Visual Micro](http://www.visualmicro.com/)
+* <img src="http://www.atmel.com/Images/favicon.ico" height="16" width="16"> [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)
+* <img src="https://www.iar.com/favicon.ico" height="16" width="16"> [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)
+* <img src="http://www.st.com/etc/clientlibs/st-site/media/app/images/favicon.png" height="16" width="16"> [Atollic TrueSTUDIO](https://atollic.com/truestudio/)
+* <img src="http://www.keil.com/favicon.ico" height="16" width="16"> [Keil uVision](http://www.keil.com/)
+* <img src="http://www.microchip.com/favicon.ico" height="16" width="16"> [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)
+* <img src="https://gcc.gnu.org/favicon.ico" height="16" width="16"> [GCC](https://gcc.gnu.org/)
+* <img src="https://clang.llvm.org/favicon.ico" height="16" width="16"> [Clang](https://clang.llvm.org/)
+* <img src="https://www.visualstudio.com/favicon.ico" height="16" width="16"> [Visual Studio](https://www.visualstudio.com/)
 
 ## Quickstart
 
@@ -99,13 +63,14 @@ Here is a program that parses a JSON document with ArduinoJson.
 ```c++
 char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-DynamicJsonDocument doc(1024);
-deserializeJson(doc, json);
+StaticJsonBuffer<200> jsonBuffer;
 
-const char* sensor = doc["sensor"];
-long time          = doc["time"];
-double latitude    = doc["data"][0];
-double longitude   = doc["data"][1];
+JsonObject& root = jsonBuffer.parseObject(json);
+
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
 ```
 
 See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_source=github&utm_medium=readme)
@@ -115,23 +80,35 @@ See the [tutorial on arduinojson.org](https://arduinojson.org/doc/decoding/?utm_
 Here is a program that generates a JSON document with ArduinoJson:
 
 ```c++
-DynamicJsonDocument doc(1024);
+StaticJsonBuffer<200> jsonBuffer;
 
-doc["sensor"] = "gps";
-doc["time"]   = 1351824120;
-doc["data"][0] = 48.756080;
-doc["data"][1] = 2.302038;
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-serializeJson(doc, Serial);
+JsonArray& data = root.createNestedArray("data");
+data.add(48.756080);
+data.add(2.302038);
+
+root.printTo(Serial);
 // This prints:
 // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 ```
 
 See the [tutorial on arduinojson.org](https://arduinojson.org/doc/encoding/?utm_source=github&utm_medium=readme)
 
-## Support the project
+## Documentation
+
+The documentation is available on [arduinojson.org](https://arduinojson.org/?utm_source=github&utm_medium=readme), here are some shortcuts:
+
+* The [Examples](https://arduinojson.org/example/?utm_source=github&utm_medium=readme) show how to use the library in various situations.
+* The [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=readme) contains the description of each class and function.
+* The [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=readme) has the answer to virtually every question.
+* The [ArduinoJson Assistant](https://arduinojson.org/assistant/?utm_source=github&utm_medium=readme) writes programs for you!
+
+---
 
 Do you like this library? Please [star this project on GitHub](https://github.com/bblanchon/ArduinoJson/stargazers)!
 
-What? You don't like it but you *love* it?  
-We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time.
+What? You don't like it but you *love* it?
+We don't take donations anymore, but [we sell a book](https://arduinojson.org/book/?utm_source=github&utm_medium=readme), so you can help and learn at the same time!

appveyor.yml

@@ -1,8 +1,6 @@
-version: 6.17.0.{build}
+version: 5.13.5.{build}
 environment:
   matrix:
-  - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
-    CMAKE_GENERATOR: Visual Studio 16 2019
   - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
     CMAKE_GENERATOR: Visual Studio 15 2017
   - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2015
@@ -19,4 +17,4 @@ before_build:
 build_script:
 - cmake --build . --config %CONFIGURATION%
 test_script:
-- ctest -C %CONFIGURATION% --output-on-failure .
+- ctest --output-on-failure .

component.mk

@@ -1 +0,0 @@
-COMPONENT_ADD_INCLUDEDIRS := src

examples/JsonConfigFile/JsonConfigFile.ino

@@ -1,5 +1,5 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows how to store your project configuration in a file.
@@ -10,25 +10,12 @@
 //   "hostname": "examples.com",
 //   "port": 2731
 // }
-//
-// To run this program, you need an SD card connected to the SPI bus as follows:
-// * MOSI <-> pin 11
-// * MISO <-> pin 12
-// * CLK  <-> pin 13
-// * CS   <-> pin 4
-//
-// https://arduinojson.org/v6/example/config/
 
 #include <ArduinoJson.h>
 #include <SD.h>
 #include <SPI.h>
 
-// Our configuration structure.
-//
-// Never use a JsonDocument to store the configuration!
-// A JsonDocument is *not* a permanent storage; it's only a temporary storage
-// used during the serialization phase. See:
-// https://arduinojson.org/v6/faq/why-must-i-create-a-separate-config-object/
+// Configuration that we'll store on disk
 struct Config {
   char hostname[64];
   int port;
@@ -42,23 +29,24 @@ void loadConfiguration(const char *filename, Config &config) {
   // Open file for reading
   File file = SD.open(filename);
 
-  // Allocate a temporary JsonDocument
-  // Don't forget to change the capacity to match your requirements.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<512> doc;
+  // Allocate the memory pool on the stack.
+  // Don't forget to change the capacity to match your JSON document.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonBuffer<512> jsonBuffer;
 
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, file);
-  if (error)
+  // Parse the root object
+  JsonObject &root = jsonBuffer.parseObject(file);
+
+  if (!root.success())
     Serial.println(F("Failed to read file, using default configuration"));
 
-  // Copy values from the JsonDocument to the Config
-  config.port = doc["port"] | 2731;
-  strlcpy(config.hostname,                  // <- destination
-          doc["hostname"] | "example.com",  // <- source
-          sizeof(config.hostname));         // <- destination's capacity
+  // Copy values from the JsonObject to the Config
+  config.port = root["port"] | 2731;
+  strlcpy(config.hostname,                   // <- destination
+          root["hostname"] | "example.com",  // <- source
+          sizeof(config.hostname));          // <- destination's capacity
 
-  // Close the file (Curiously, File's destructor doesn't close the file)
+  // Close the file (File's destructor doesn't close the file)
   file.close();
 }
 
@@ -74,21 +62,24 @@ void saveConfiguration(const char *filename, const Config &config) {
     return;
   }
 
-  // Allocate a temporary JsonDocument
-  // Don't forget to change the capacity to match your requirements.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<256> doc;
+  // Allocate the memory pool on the stack
+  // Don't forget to change the capacity to match your JSON document.
+  // Use https://arduinojson.org/assistant/ to compute the capacity.
+  StaticJsonBuffer<256> jsonBuffer;
 
-  // Set the values in the document
-  doc["hostname"] = config.hostname;
-  doc["port"] = config.port;
+  // Parse the root object
+  JsonObject &root = jsonBuffer.createObject();
+
+  // Set the values
+  root["hostname"] = config.hostname;
+  root["port"] = config.port;
 
   // Serialize JSON to file
-  if (serializeJson(doc, file) == 0) {
+  if (root.printTo(file) == 0) {
     Serial.println(F("Failed to write to file"));
   }
 
-  // Close the file
+  // Close the file (File's destructor doesn't close the file)
   file.close();
 }
 
@@ -107,7 +98,7 @@ void printFile(const char *filename) {
   }
   Serial.println();
 
-  // Close the file
+  // Close the file (File's destructor doesn't close the file)
   file.close();
 }
 
@@ -117,8 +108,7 @@ void setup() {
   while (!Serial) continue;
 
   // Initialize SD library
-  const int chipSelect = 4;
-  while (!SD.begin(chipSelect)) {
+  while (!SD.begin()) {
     Serial.println(F("Failed to initialize SD library"));
     delay(1000);
   }

examples/JsonFilterExample/JsonFilterExample.ino

@@ -1,63 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-//
-// This example shows how to use DeserializationOpion::Filter
-//
-// https://arduinojson.org/v6/example/filter/
-
-#include <ArduinoJson.h>
-
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // The huge input: an extract from OpenWeatherMap response
-  const __FlashStringHelper* input_json = F(
-      "{\"cod\":\"200\",\"message\":0,\"list\":[{\"dt\":1581498000,\"main\":{"
-      "\"temp\":3.23,\"feels_like\":-3.63,\"temp_min\":3.23,\"temp_max\":4.62,"
-      "\"pressure\":1014,\"sea_level\":1014,\"grnd_level\":1010,\"humidity\":"
-      "58,\"temp_kf\":-1.39},\"weather\":[{\"id\":800,\"main\":\"Clear\","
-      "\"description\":\"clear "
-      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":0},\"wind\":{\"speed\":6."
-      "19,\"deg\":266},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
-      "09:00:00\"},{\"dt\":1581508800,\"main\":{\"temp\":6.09,\"feels_like\":-"
-      "1.07,\"temp_min\":6.09,\"temp_max\":7.13,\"pressure\":1015,\"sea_"
-      "level\":1015,\"grnd_level\":1011,\"humidity\":48,\"temp_kf\":-1.04},"
-      "\"weather\":[{\"id\":800,\"main\":\"Clear\",\"description\":\"clear "
-      "sky\",\"icon\":\"01d\"}],\"clouds\":{\"all\":9},\"wind\":{\"speed\":6."
-      "64,\"deg\":268},\"sys\":{\"pod\":\"d\"},\"dt_txt\":\"2020-02-12 "
-      "12:00:00\"}],\"city\":{\"id\":2643743,\"name\":\"London\",\"coord\":{"
-      "\"lat\":51.5085,\"lon\":-0.1257},\"country\":\"GB\",\"population\":"
-      "1000000,\"timezone\":0,\"sunrise\":1581492085,\"sunset\":1581527294}}");
-
-  // The filter: it contains "true" for each value we want to keep
-  StaticJsonDocument<200> filter;
-  filter["list"][0]["dt"] = true;
-  filter["list"][0]["main"]["temp"] = true;
-
-  // Deserialize the document
-  StaticJsonDocument<400> doc;
-  deserializeJson(doc, input_json, DeserializationOption::Filter(filter));
-
-  // Print the result
-  serializeJsonPretty(doc, Serial);
-}
-
-void loop() {
-  // not used in this example
-}
-
-// See also
-// --------
-//
-// https://arduinojson.org/ contains the documentation for all the functions
-// used above. It also includes an FAQ that will help you solve any
-// deserialization problem.
-//
-// The book "Mastering ArduinoJson" contains a tutorial on deserialization.
-// It begins with a simple example, like the one above, and then adds more
-// features like deserializing directly from a file or an HTTP request.
-// Learn more at https://arduinojson.org/book/
-// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,10 +1,8 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows how to generate a JSON document with ArduinoJson.
-//
-// https://arduinojson.org/v6/example/generator/
 
 #include <ArduinoJson.h>
 
@@ -13,42 +11,48 @@ void setup() {
   Serial.begin(9600);
   while (!Serial) continue;
 
-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
   //
-  // Inside the brackets, 200 is the RAM allocated to this document.
-  // Don't forget to change this value to match your requirement.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  // Inside the brackets, 200 is the size of the pool in bytes.
+  // Don't forget to change this value to match your JSON document.
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonBuffer<200> jsonBuffer;
 
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
   //
-  // DynamicJsonDocument  doc(200);
+  // DynamicJsonBuffer  jsonBuffer(200);
 
-  // Add values in the document
+  // Create the root of the object tree.
   //
-  doc["sensor"] = "gps";
-  doc["time"] = 1351824120;
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.createObject();
 
-  // Add an array.
+  // Add values in the object
   //
-  JsonArray data = doc.createNestedArray("data");
+  // Most of the time, you can rely on the implicit casts.
+  // In other case, you can do root.set<long>("time", 1351824120);
+  root["sensor"] = "gps";
+  root["time"] = 1351824120;
+
+  // Add a nested array.
+  //
+  // It's also possible to create the array separately and add it to the
+  // JsonObject but it's less efficient.
+  JsonArray& data = root.createNestedArray("data");
   data.add(48.756080);
   data.add(2.302038);
 
-  // Generate the minified JSON and send it to the Serial port.
-  //
-  serializeJson(doc, Serial);
-  // The above line prints:
+  root.printTo(Serial);
+  // This prints:
   // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
-  // Start a new line
   Serial.println();
 
-  // Generate the prettified JSON and send it to the Serial port.
-  //
-  serializeJsonPretty(doc, Serial);
-  // The above line prints:
+  root.prettyPrintTo(Serial);
+  // This prints:
   // {
   //   "sensor": "gps",
   //   "time": 1351824120,

examples/JsonHttpClient/JsonHttpClient.ino

@@ -1,5 +1,5 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows how to parse a JSON document in an HTTP response.
@@ -15,8 +15,6 @@
 //     2.302038
 //   ]
 // }
-//
-// https://arduinojson.org/v6/example/http-client/
 
 #include <ArduinoJson.h>
 #include <Ethernet.h>
@@ -59,8 +57,7 @@ void setup() {
   // Check HTTP status
   char status[32] = {0};
   client.readBytesUntil('\r', status, sizeof(status));
-  // It should be "HTTP/1.0 200 OK" or "HTTP/1.1 200 OK"
-  if (strcmp(status + 9, "200 OK") != 0) {
+  if (strcmp(status, "HTTP/1.1 200 OK") != 0) {
     Serial.print(F("Unexpected response: "));
     Serial.println(status);
     return;
@@ -73,25 +70,24 @@ void setup() {
     return;
   }
 
-  // Allocate the JSON document
-  // Use arduinojson.org/v6/assistant to compute the capacity.
+  // Allocate JsonBuffer
+  // Use arduinojson.org/assistant to compute the capacity.
   const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60;
-  DynamicJsonDocument doc(capacity);
+  DynamicJsonBuffer jsonBuffer(capacity);
 
   // Parse JSON object
-  DeserializationError error = deserializeJson(doc, client);
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.f_str());
+  JsonObject& root = jsonBuffer.parseObject(client);
+  if (!root.success()) {
+    Serial.println(F("Parsing failed!"));
     return;
   }
 
   // Extract values
   Serial.println(F("Response:"));
-  Serial.println(doc["sensor"].as<char*>());
-  Serial.println(doc["time"].as<long>());
-  Serial.println(doc["data"][0].as<float>(), 6);
-  Serial.println(doc["data"][1].as<float>(), 6);
+  Serial.println(root["sensor"].as<char*>());
+  Serial.println(root["time"].as<char*>());
+  Serial.println(root["data"][0].as<char*>());
+  Serial.println(root["data"][1].as<char*>());
 
   // Disconnect
   client.stop();
@@ -109,8 +105,8 @@ void loop() {
 // serialization  problem.
 //
 // The book "Mastering ArduinoJson" contains a tutorial on deserialization
-// showing how to parse the response from GitHub's API. In the last chapter,
+// showing how to parse the response from Yahoo Weather. In the last chapter,
 // it shows how to parse the huge documents from OpenWeatherMap
-// and Reddit.
+// and Weather Underground.
 // Learn more at https://arduinojson.org/book/
 // Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤

examples/JsonParserExample/JsonParserExample.ino

@@ -1,10 +1,8 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows how to deserialize a JSON document with ArduinoJson.
-//
-// https://arduinojson.org/v6/example/parser/
 
 #include <ArduinoJson.h>
 
@@ -13,47 +11,47 @@ void setup() {
   Serial.begin(9600);
   while (!Serial) continue;
 
-  // Allocate the JSON document
+  // Memory pool for JSON object tree.
   //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
+  // Inside the brackets, 200 is the size of the pool in bytes.
   // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonBuffer<200> jsonBuffer;
 
-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
+  // StaticJsonBuffer allocates memory on the stack, it can be
+  // replaced by DynamicJsonBuffer which allocates in the heap.
   //
-  // DynamicJsonDocument doc(200);
+  // DynamicJsonBuffer  jsonBuffer(200);
 
   // JSON input string.
   //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
+  // It's better to use a char[] as shown here.
+  // If you use a const char* or a String, ArduinoJson will
+  // have to make a copy of the input in the JsonBuffer.
   char json[] =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, json);
+  // Root of the object tree.
+  //
+  // It's a reference to the JsonObject, the actual bytes are inside the
+  // JsonBuffer with all the other nodes of the object tree.
+  // Memory is freed when jsonBuffer goes out of scope.
+  JsonObject& root = jsonBuffer.parseObject(json);
 
   // Test if parsing succeeds.
-  if (error) {
-    Serial.print(F("deserializeJson() failed: "));
-    Serial.println(error.f_str());
+  if (!root.success()) {
+    Serial.println("parseObject() failed");
     return;
   }
 
   // Fetch values.
   //
   // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
+  // In other case, you can do root["time"].as<long>();
+  const char* sensor = root["sensor"];
+  long time = root["time"];
+  double latitude = root["data"][0];
+  double longitude = root["data"][1];
 
   // Print values.
   Serial.println(sensor);

examples/JsonServer/JsonServer.ino

@@ -1,19 +1,17 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
-// This example shows how to implement an HTTP server that sends a JSON document
-// in the response.
+// This example shows how to implement an HTTP server that sends JSON document
+// in the responses.
 // It uses the Ethernet library but can be easily adapted for Wifi.
 //
-// The JSON document contains the values of the analog and digital pins.
-// It looks like that:
+// It sends the value of the analog and digital pins.
+// The JSON document looks like the following:
 // {
-//   "analog": [0, 76, 123, 158, 192, 205],
-//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+//   "analog": [ 0, 1, 2, 3, 4, 5 ],
+//   "digital": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]
 // }
-//
-// https://arduinojson.org/v6/example/http-server/
 
 #include <ArduinoJson.h>
 #include <Ethernet.h>
@@ -53,12 +51,15 @@ void loop() {
   // Read the request (we ignore the content in this example)
   while (client.available()) client.read();
 
-  // Allocate a temporary JsonDocument
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  // Allocate JsonBuffer
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonBuffer<500> jsonBuffer;
+
+  // Create the root object
+  JsonObject& root = jsonBuffer.createObject();
 
   // Create the "analog" array
-  JsonArray analogValues = doc.createNestedArray("analog");
+  JsonArray& analogValues = root.createNestedArray("analog");
   for (int pin = 0; pin < 6; pin++) {
     // Read the analog input
     int value = analogRead(pin);
@@ -68,7 +69,7 @@ void loop() {
   }
 
   // Create the "digital" array
-  JsonArray digitalValues = doc.createNestedArray("digital");
+  JsonArray& digitalValues = root.createNestedArray("digital");
   for (int pin = 0; pin < 14; pin++) {
     // Read the digital input
     int value = digitalRead(pin);
@@ -78,19 +79,17 @@ void loop() {
   }
 
   Serial.print(F("Sending: "));
-  serializeJson(doc, Serial);
+  root.printTo(Serial);
   Serial.println();
 
   // Write response headers
-  client.println(F("HTTP/1.0 200 OK"));
-  client.println(F("Content-Type: application/json"));
-  client.println(F("Connection: close"));
-  client.print(F("Content-Length: "));
-  client.println(measureJsonPretty(doc));
+  client.println("HTTP/1.0 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
   client.println();
 
   // Write JSON document
-  serializeJsonPretty(doc, client);
+  root.prettyPrintTo(client);
 
   // Disconnect
   client.stop();

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -1,14 +1,14 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows how to send a JSON document to a UDP socket.
 // At regular interval, it sends a UDP packet that contains the status of
 // analog and digital pins.
-// It looks like that:
+// The JSON document looks like the following:
 // {
-//   "analog": [0, 76, 123, 158, 192, 205],
-//   "digital": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]
+//   "analog": [ 0, 1, 2, 3, 4, 5 ],
+//   "digital": [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13 ]
 // }
 //
 // If you want to test this program, you need to be able to receive the UDP
@@ -16,8 +16,6 @@
 // For example, you can run netcat on your computer
 // $ ncat -ulp 8888
 // See https://nmap.org/ncat/
-//
-// https://arduinojson.org/v6/example/udp-beacon/
 
 #include <ArduinoJson.h>
 #include <Ethernet.h>
@@ -45,12 +43,15 @@ void setup() {
 }
 
 void loop() {
-  // Allocate a temporary JsonDocument
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<500> doc;
+  // Allocate JsonBuffer
+  // Use arduinojson.org/assistant to compute the capacity.
+  StaticJsonBuffer<500> jsonBuffer;
+
+  // Create the root object
+  JsonObject& root = jsonBuffer.createObject();
 
   // Create the "analog" array
-  JsonArray analogValues = doc.createNestedArray("analog");
+  JsonArray& analogValues = root.createNestedArray("analog");
   for (int pin = 0; pin < 6; pin++) {
     // Read the analog input
     int value = analogRead(pin);
@@ -60,7 +61,7 @@ void loop() {
   }
 
   // Create the "digital" array
-  JsonArray digitalValues = doc.createNestedArray("digital");
+  JsonArray& digitalValues = root.createNestedArray("digital");
   for (int pin = 0; pin < 14; pin++) {
     // Read the digital input
     int value = digitalRead(pin);
@@ -74,11 +75,11 @@ void loop() {
   Serial.print(remoteIp);
   Serial.print(F(" on port "));
   Serial.println(remotePort);
-  serializeJson(doc, Serial);
+  root.printTo(Serial);
 
   // Send UDP packet
   udp.beginPacket(remoteIp, remotePort);
-  serializeJson(doc, udp);
+  root.printTo(udp);
   udp.println();
   udp.endPacket();
 

examples/MsgPackParser/MsgPackParser.ino

@@ -1,75 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-//
-// This example shows how to deserialize a MessagePack document with
-// ArduinoJson.
-//
-// https://arduinojson.org/v6/example/msgpack-parser/
-
-#include <ArduinoJson.h>
-
-void setup() {
-  // Initialize serial port
-  Serial.begin(9600);
-  while (!Serial) continue;
-
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
-  //
-  // DynamicJsonObject doc(200);
-
-  // MessagePack input string.
-  //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
-  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
-                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
-                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
-                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
-  // This MessagePack document contains:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [48.75608, 2.302038]
-  // }
-
-  DeserializationError error = deserializeMsgPack(doc, input);
-
-  // Test if parsing succeeded.
-  if (error) {
-    Serial.print("deserializeMsgPack() failed: ");
-    Serial.println(error.f_str());
-    return;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  Serial.println(sensor);
-  Serial.println(time);
-  Serial.println(latitude, 6);
-  Serial.println(longitude, 6);
-}
-
-void loop() {
-  // not used in this example
-}

examples/ProgmemExample/ProgmemExample.ino

@@ -1,49 +1,47 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows the different ways you can use Flash strings with
 // ArduinoJson.
 //
 // Use Flash strings sparingly, because ArduinoJson duplicates them in the
-// JsonDocument. Prefer plain old char*, as they are more efficient in term of
+// JsonBuffer. Prefer plain old char*, as they are more efficient in term of
 // code size, speed, and memory usage.
-//
-// https://arduinojson.org/v6/example/progmem/
 
 #include <ArduinoJson.h>
 
 void setup() {
 #ifdef PROGMEM  // <- check that Flash strings are supported
 
-  DynamicJsonDocument doc(1024);
+  DynamicJsonBuffer jsonBuffer;
 
   // You can use a Flash String as your JSON input.
-  // WARNING: the strings in the input will be duplicated in the JsonDocument.
-  deserializeJson(doc, F("{\"sensor\":\"gps\",\"time\":1351824120,"
-                         "\"data\":[48.756080,2.302038]}"));
-  JsonObject obj = doc.as<JsonObject>();
+  // WARNING: the content of the Flash String will be duplicated in the
+  // JsonBuffer.
+  JsonObject& root =
+      jsonBuffer.parseObject(F("{\"sensor\":\"gps\",\"time\":1351824120,"
+                               "\"data\":[48.756080,2.302038]}"));
 
   // You can use a Flash String to get an element of a JsonObject
   // No duplication is done.
-  long time = obj[F("time")];
+  long time = root[F("time")];
 
   // You can use a Flash String to set an element of a JsonObject
   // WARNING: the content of the Flash String will be duplicated in the
-  // JsonDocument.
-  obj[F("time")] = time;
+  // JsonBuffer.
+  root[F("time")] = time;
 
   // You can set a Flash String to a JsonObject or JsonArray:
   // WARNING: the content of the Flash String will be duplicated in the
-  // JsonDocument.
-  obj["sensor"] = F("gps");
+  // JsonBuffer.
+  root["sensor"] = F("gps");
 
-  // It works with serialized() too:
-  obj["sensor"] = serialized(F("\"gps\""));
-  obj["sensor"] = serialized(F("\xA3gps"), 3);
+  // It works with RawJson too:
+  root["sensor"] = RawJson(F("\"gps\""));
 
   // You can compare the content of a JsonVariant to a Flash String
-  if (obj["sensor"] == F("gps")) {
+  if (root["sensor"] == F("gps")) {
     // ...
   }
 

examples/StringExample/StringExample.ino

@@ -1,63 +1,60 @@
 // ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
+// Copyright Benoit Blanchon 2014-2019
 // MIT License
 //
 // This example shows the different ways you can use String with ArduinoJson.
 //
 // Use String objects sparingly, because ArduinoJson duplicates them in the
-// JsonDocument. Prefer plain old char[], as they are more efficient in term of
+// JsonBuffer. Prefer plain old char[], as they are more efficient in term of
 // code size, speed, and memory usage.
-//
-// https://arduinojson.org/v6/example/string/
 
 #include <ArduinoJson.h>
 
 void setup() {
-  DynamicJsonDocument doc(1024);
+  DynamicJsonBuffer jsonBuffer;
 
   // You can use a String as your JSON input.
-  // WARNING: the string in the input  will be duplicated in the JsonDocument.
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
   String input =
       "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-  deserializeJson(doc, input);
-  JsonObject obj = doc.as<JsonObject>();
+  JsonObject& root = jsonBuffer.parseObject(input);
 
   // You can use a String to get an element of a JsonObject
   // No duplication is done.
-  long time = obj[String("time")];
+  long time = root[String("time")];
 
   // You can use a String to set an element of a JsonObject
-  // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj[String("time")] = time;
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root[String("time")] = time;
 
   // You can get a String from a JsonObject or JsonArray:
-  // No duplication is done, at least not in the JsonDocument.
-  String sensor = obj["sensor"];
+  // No duplication is done, at least not in the JsonBuffer.
+  String sensor = root["sensor"];
 
   // Unfortunately, the following doesn't work (issue #118):
-  // sensor = obj["sensor"]; // <-  error "ambiguous overload for 'operator='"
+  // sensor = root["sensor"]; // <-  error "ambiguous overload for 'operator='"
   // As a workaround, you need to replace by:
-  sensor = obj["sensor"].as<String>();
+  sensor = root["sensor"].as<String>();
 
   // You can set a String to a JsonObject or JsonArray:
-  // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj["sensor"] = sensor;
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root["sensor"] = sensor;
 
-  // It works with serialized() too:
-  obj["sensor"] = serialized(sensor);
+  // It works with RawJson too:
+  root["sensor"] = RawJson(sensor);
 
   // You can also concatenate strings
-  // WARNING: the content of the String will be duplicated in the JsonDocument.
-  obj[String("sen") + "sor"] = String("gp") + "s";
+  // WARNING: the content of the String will be duplicated in the JsonBuffer.
+  root[String("sen") + "sor"] = String("gp") + "s";
 
   // You can compare the content of a JsonObject with a String
-  if (obj["sensor"] == sensor) {
+  if (root["sensor"] == sensor) {
     // ...
   }
 
   // Lastly, you can print the resulting JSON to a String
   String output;
-  serializeJson(doc, output);
+  root.printTo(output);
 }
 
 void loop() {

extras/ArduinoJsonConfig.cmake.in

@@ -1,4 +0,0 @@
-@PACKAGE_INIT@
-
-include("${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake")
-check_required_components("@PROJECT_NAME@")

extras/ci/build.sh

@@ -1,7 +0,0 @@
-#!/bin/sh -ex
-
-export CC="$_CC"
-export CXX="$_CXX"
-
-cmake -DCMAKE_BUILD_TYPE=Release .
-cmake --build .

extras/ci/coverage.sh

@@ -1,9 +0,0 @@
-#!/bin/sh -eux
-
-cmake -DCOVERAGE=true .
-make 
-make test
-
-pip install --user cpp-coveralls 'requests[security]'
-pwd
-coveralls --include 'src' --gcov-options '\-lp'

extras/ci/fuzz.sh

@@ -1,22 +0,0 @@
-#!/bin/bash -eux
-
-ROOT_DIR=$(dirname $0)/../../
-FUZZING_DIR=${ROOT_DIR}/extras/fuzzing/
-
-export CC="clang-${CLANG}"
-export CXX="clang++-${CLANG}"
-cmake -DCMAKE_BUILD_TYPE=Debug .
-
-FUZZER_TARGET="${FUZZER}_fuzzer"
-FUZZER_PATH="extras/fuzzing/${FUZZER_TARGET}"
-CORPUS_DIR="${FUZZING_DIR}/${FUZZER}_corpus"
-SEED_CORPUS_DIR="${FUZZING_DIR}/${FUZZER}_seed_corpus"
-
-cmake --build . --target $FUZZER_TARGET
-
-export ASAN_OPTIONS="detect_leaks=0"
-export LLVM_PROFILE_FILE="${FUZZER_TARGET}.profraw"
-${FUZZER_PATH} "$CORPUS_DIR" "$SEED_CORPUS_DIR" -max_total_time=60 -timeout=1
-
-llvm-profdata-${CLANG} merge -sparse ${LLVM_PROFILE_FILE} -o ${FUZZER_TARGET}.profdata
-llvm-cov-${CLANG} report ./${FUZZER_PATH} -instr-profile=${FUZZER_TARGET}.profdata

extras/ci/platformio.sh

@@ -1,20 +0,0 @@
-#!/bin/sh -eux
-
-pip install --user platformio
-
-case $BOARD in
-uno)
-  platformio lib install 868 # SD library
-  platformio lib install 872 # Ethernet library
-  ;;
-esp01)
-  platformio lib uninstall 161 || true
-  platformio lib uninstall 868 || true
-  platformio lib uninstall 872 || true
-  ;;
-esac
-
-for EXAMPLE in $PWD/examples/*/*.ino; 
-do
-	platformio ci $EXAMPLE -l '.' -b $BOARD
-done

extras/ci/test.sh

@@ -1,8 +0,0 @@
-#!/bin/sh -ex
-
-export CC="$_CC"
-export CXX="$_CXX"
-
-cmake -DCMAKE_BUILD_TYPE=Debug .
-cmake --build .
-ctest --output-on-failure .

extras/fuzzing/CMakeLists.txt

@@ -1,77 +0,0 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
-# MIT License
-
-if(MSVC)
-	add_compile_options(-D_CRT_SECURE_NO_WARNINGS)
-endif()
-
-add_executable(msgpack_reproducer
-	msgpack_fuzzer.cpp
-	reproducer.cpp
-)
-target_link_libraries(msgpack_reproducer
-	ArduinoJson
-)
-
-add_executable(json_reproducer
-	json_fuzzer.cpp
-	reproducer.cpp
-)
-target_link_libraries(json_reproducer
-	ArduinoJson
-)
-
-# Infer path of llvm-symbolizer from the path of clang
-string(REPLACE "clang++" "llvm-symbolizer" LLVM_SYMBOLIZER ${CMAKE_CXX_COMPILER})
-
-macro(add_fuzzer name mode)	
-	set(FUZZER "${name}_${mode}_fuzzer")
-	set(CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_corpus")
-	set(SEED_CORPUS_DIR "${CMAKE_CURRENT_SOURCE_DIR}/${name}_seed_corpus")
-	add_executable("${FUZZER}"
-		"${name}_fuzzer.cpp"
-	)
-	target_link_libraries("${FUZZER}"
-		ArduinoJson
-	)
-	set_target_properties("${FUZZER}"
-		PROPERTIES 
-			COMPILE_FLAGS  
-				"-fprofile-instr-generate -fcoverage-mapping -fsanitize=${mode},fuzzer -fno-sanitize-recover=all"
-			LINK_FLAGS
-				"-fprofile-instr-generate -fcoverage-mapping -fsanitize=${mode},fuzzer -fno-sanitize-recover=all"
-	)
-
-	add_test(
-		NAME
-			"${FUZZER}"
-		COMMAND
-			"${FUZZER}" "${CORPUS_DIR}" "${SEED_CORPUS_DIR}" -max_total_time=5 -timeout=1
-	)
-
-	set_tests_properties("${FUZZER}"
-		PROPERTIES
-			ENVIRONMENT
-				ASAN_SYMBOLIZER_PATH=${LLVM_SYMBOLIZER}
-			ENVIRONMENT
-				LLVM_SYMBOLIZER_PATH=${LLVM_SYMBOLIZER}
-			ENVIRONMENT
-				MSAN_SYMBOLIZER_PATH=${LLVM_SYMBOLIZER}
-			ENVIRONMENT
-				UBSAN_SYMBOLIZER_PATH=${LLVM_SYMBOLIZER}
-	)
-endmacro()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 6)
-	add_fuzzer(json address)
-	add_fuzzer(json undefined)
-	add_fuzzer(msgpack address)
-	add_fuzzer(msgpack undefined)
-endif()
-
-if (CMAKE_CXX_COMPILER_ID STREQUAL "Clang" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 7)
-	# We're getting false positive with Clang 6
-	add_fuzzer(json memory)
-	add_fuzzer(msgpack memory)
-endif()

extras/fuzzing/Makefile

@@ -1,22 +0,0 @@
-# CAUTION: this file is invoked by https://github.com/google/oss-fuzz
-
-CXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1
-
-all: \
-	$(OUT)/json_fuzzer \
-	$(OUT)/json_fuzzer_seed_corpus.zip \
-	$(OUT)/json_fuzzer.options \
-	$(OUT)/msgpack_fuzzer \
-	$(OUT)/msgpack_fuzzer_seed_corpus.zip \
-	$(OUT)/msgpack_fuzzer.options
-
-$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../../src -type f)
-	$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)
-
-$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*
-	zip -j $@ $?
-
-$(OUT)/%_fuzzer.options:
-	@echo "[libfuzzer]" > $@
-	@echo "max_len = 256" >> $@
-	@echo "timeout = 10" >> $@

extras/fuzzing/json_fuzzer.cpp

@@ -1,11 +0,0 @@
-#include <ArduinoJson.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc(4096);
-  DeserializationError error = deserializeJson(doc, data, size);
-  if (!error) {
-    std::string json;
-    serializeJson(doc, json);
-  }
-  return 0;
-}

extras/fuzzing/json_seed_corpus/IntegerOverflow.json

@@ -1 +0,0 @@
-9720730739393920739

extras/fuzzing/msgpack_corpus/.gitignore

@@ -1,2 +0,0 @@
-*
-!.gitignore

extras/fuzzing/msgpack_fuzzer.cpp

@@ -1,11 +0,0 @@
-#include <ArduinoJson.h>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
-  DynamicJsonDocument doc(4096);
-  DeserializationError error = deserializeMsgPack(doc, data, size);
-  if (!error) {
-    std::string json;
-    serializeMsgPack(doc, json);
-  }
-  return 0;
-}

extras/fuzzing/msgpack_seed_corpus/false

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixarray

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>hello<EFBFBD>world

extras/fuzzing/msgpack_seed_corpus/fixint_negative

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/fixint_positive

@@ -1 +0,0 @@
-

extras/fuzzing/msgpack_seed_corpus/fixmap

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>one
<01>two

extras/fuzzing/msgpack_seed_corpus/fixstr

@@ -1 +0,0 @@
-<EFBFBD>hello world

extras/fuzzing/msgpack_seed_corpus/float32

@@ -1 +0,0 @@
-<EFBFBD>@H<><48>

extras/fuzzing/msgpack_seed_corpus/float64

@@ -1 +0,0 @@
-<EFBFBD>@	!<21><><EFBFBD>o

extras/fuzzing/msgpack_seed_corpus/int16

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int32

@@ -1 +0,0 @@
-Ҷi<EFBFBD>.

extras/fuzzing/msgpack_seed_corpus/int64

@@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/int8

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/nil

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/str8

@@ -1 +0,0 @@
-<EFBFBD>hello

extras/fuzzing/msgpack_seed_corpus/true

@@ -1 +0,0 @@
-<EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint16

@@ -1 +0,0 @@
-<EFBFBD>09

extras/fuzzing/msgpack_seed_corpus/uint32

@@ -1 +0,0 @@
-<EFBFBD>4Vx

extras/fuzzing/msgpack_seed_corpus/uint64

@@ -1 +0,0 @@
-<EFBFBD>4Vx<56><78><EFBFBD><EFBFBD>

extras/fuzzing/msgpack_seed_corpus/uint8

@@ -1 +0,0 @@
-<EFBFBD><EFBFBD>

extras/fuzzing/reproducer.cpp

@@ -1,50 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-// This file is NOT use by Google's OSS fuzz
-// I only use it to reproduce the bugs found
-
-#include <stdint.h>  // size_t
-#include <stdio.h>   // fopen et al.
-#include <stdlib.h>  // exit
-#include <iostream>
-#include <vector>
-
-extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);
-
-std::vector<uint8_t> read(const char* path) {
-  FILE* f = fopen(path, "rb");
-  if (!f) {
-    std::cerr << "Failed to open " << path << std::endl;
-    exit(1);
-  }
-
-  fseek(f, 0, SEEK_END);
-  size_t size = static_cast<size_t>(ftell(f));
-  fseek(f, 0, SEEK_SET);
-
-  std::vector<uint8_t> buffer(size);
-  if (fread(buffer.data(), 1, size, f) != size) {
-    fclose(f);
-    std::cerr << "Failed to read " << path << std::endl;
-    exit(1);
-  }
-
-  fclose(f);
-  return buffer;
-}
-
-int main(int argc, const char* argv[]) {
-  if (argc < 2) {
-    std::cerr << "Usage: msgpack_fuzzer files" << std::endl;
-    return 1;
-  }
-
-  for (int i = 1; i < argc; i++) {
-    std::cout << "Loading " << argv[i] << std::endl;
-    std::vector<uint8_t> buffer = read(argv[i]);
-    LLVMFuzzerTestOneInput(buffer.data(), buffer.size());
-  }
-  return 0;
-}

extras/scripts/build-single-header.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-
-set -e
-
-TAG=$(git describe)
-RE_RELATIVE_INCLUDE='^#include[[:space:]]*"(.*)"'
-RE_ABSOLUTE_INCLUDE='^#include[[:space:]]*<(ArduinoJson/.*)>'
-RE_SYSTEM_INCLUDE='^#include[[:space:]]*<(.*)>'
-RE_EMPTY='^(#pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'
-SRC_DIRECTORY="$(realpath "$(dirname $0)/../../src")"
-
-
-declare -A INCLUDED
-
-process()
-{
-	local PARENT=$1
-	local FOLDER=$(dirname $1)
-	local SHOW_COMMENT=$2
-	while IFS= read -r LINE; do
-		if [[ $LINE =~ $RE_ABSOLUTE_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			local CHILD_PATH
-			CHILD_PATH=$(realpath "$SRC_DIRECTORY/$CHILD")
-			echo "$PARENT -> $CHILD" >&2
-			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
-				INCLUDED[$CHILD_PATH]=true
-				process "$CHILD" false
-			fi
-		elif [[ $LINE =~ $RE_RELATIVE_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			pushd "$FOLDER" > /dev/null
-			local CHILD_PATH
-			CHILD_PATH=$(realpath "$CHILD")
-			echo "$PARENT -> $CHILD" >&2
-			if [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then
-				INCLUDED[$CHILD_PATH]=true
-				process "$CHILD" false
-			fi
-			popd > /dev/null
-		elif [[ $LINE =~ $RE_SYSTEM_INCLUDE ]]; then
-			local CHILD=${BASH_REMATCH[1]}
-			echo "$PARENT -> <$CHILD>" >&2
-			if [[ ! ${INCLUDED[$CHILD]} ]]; then
-				echo "#include <$CHILD>"
-				INCLUDED[$CHILD]=true
-			fi
-		elif [[ "${SHOW_COMMENT}" = "true" ]] ; then
-			echo "$LINE"
-		elif [[ ! $LINE =~ $RE_EMPTY ]]; then
-			echo "$LINE"
-		fi
-	done < $PARENT
-}
-
-simplify_namespaces() {
-	perl -p0i -e 's|\}  // namespace ARDUINOJSON_NAMESPACE\r?\nnamespace ARDUINOJSON_NAMESPACE \{\r?\n||igs' "$1"
-	rm -f "$1.bak"
-}
-
-cd $(dirname $0)/../..
-INCLUDED=()
-process src/ArduinoJson.h true > ../ArduinoJson-$TAG.h
-simplify_namespaces ../ArduinoJson-$TAG.h
-g++ -x c++ -c -o ../smoketest.o - <<END
-#include "../ArduinoJson-$TAG.h"
-int main() {
-	StaticJsonDocument<300> doc;
-	deserializeJson(doc, "{}");
-}
-END
-
-INCLUDED=()
-process src/ArduinoJson.hpp true > ../ArduinoJson-$TAG.hpp
-simplify_namespaces ../ArduinoJson-$TAG.hpp
-g++ -x c++ -c -o ../smoketest.o - <<END
-#include "../ArduinoJson-$TAG.hpp"
-int main() {
-	ArduinoJson::StaticJsonDocument<300> doc;
-	ArduinoJson::deserializeJson(doc, "{}");
-}
-END

extras/scripts/publish.sh

@@ -1,64 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-cd "$(dirname "$0")/../.."
-
-VERSION="$1"
-DATE=$(date +%F)
-TAG="v$VERSION"
-VERSION_REGEX="[0-9a-z\\.\\-]+"
-
-update_version_in_source () {
-	IFS=".-" read MAJOR MINOR REVISION EXTRA < <(echo "$VERSION")
-	UNDERLINE=$(printf -- '-%.0s' $(seq 1 ${#TAG}))
-
-	sed -i~ -bE "s/version=$VERSION_REGEX/version=$VERSION/; s|ardu-badge.com/ArduinoJson/$VERSION_REGEX|ardu-badge.com/ArduinoJson/$VERSION|; " README.md
-	rm README.md~
-
-	sed -i~ -bE "4s/HEAD/$TAG ($DATE)/; 5s/-+/$UNDERLINE/" CHANGELOG.md
-	rm CHANGELOG.md~
-
-	sed -i~ -bE "s/(project\\s*\\(ArduinoJson\\s+VERSION\\s+).*?\\)/\\1$MAJOR.$MINOR.$REVISION)/" CMakeLists.txt
-	rm CMakeLists.txt~
-
-	sed -i~ -bE "s/\"version\":.*$/\"version\": \"$VERSION\",/" library.json
-	rm library.json~
-
-	sed -i~ -bE "s/version=.*$/version=$VERSION/" library.properties
-	rm library.properties~
-
-	sed -i~ -bE "s/version: .*$/version: $VERSION.{build}/" appveyor.yml
-	rm appveyor.yml~
-
-	sed -i~ -bE \
-		-e "s/ARDUINOJSON_VERSION .*$/ARDUINOJSON_VERSION \"$VERSION\"/" \
-		-e "s/ARDUINOJSON_VERSION_MAJOR .*$/ARDUINOJSON_VERSION_MAJOR $MAJOR/" \
-		-e "s/ARDUINOJSON_VERSION_MINOR .*$/ARDUINOJSON_VERSION_MINOR $MINOR/" \
-		-e "s/ARDUINOJSON_VERSION_REVISION .*$/ARDUINOJSON_VERSION_REVISION $REVISION/" \
-		src/ArduinoJson/version.hpp
-	rm src/ArduinoJson/version.hpp*~
-}
-
-commit_new_version () {
-	git add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml CMakeLists.txt
-	git commit -m "Set version to $VERSION"
-}
-
-add_tag () {
-	CHANGES=$(awk '/\* /{ FOUND=1; print; next } { if (FOUND) exit}' CHANGELOG.md)
-	git tag -m "ArduinoJson $VERSION"$'\n'"$CHANGES" "$TAG"
-}
-
-push () {
-	git push --follow-tags
-}
-
-update_version_in_source
-commit_new_version
-add_tag
-push
-
-extras/scripts/build-arduino-package.sh
-extras/scripts/build-single-header.sh
-extras/scripts/wandbox/publish.sh "../ArduinoJson-$TAG.h"

extras/scripts/wandbox/JsonGeneratorExample.cpp

@@ -1,60 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-//
-// This example shows how to generate a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the RAM allocated to this document.
-  // Don't forget to change this value to match your requirement.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<200> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument  doc(200);
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument  doc(200);
-
-  // Add values in the document
-  //
-  doc["sensor"] = "gps";
-  doc["time"] = 1351824120;
-
-  // Add an array.
-  //
-  JsonArray data = doc.createNestedArray("data");
-  data.add(48.756080);
-  data.add(2.302038);
-
-  // Generate the minified JSON and send it to STDOUT
-  //
-  serializeJson(doc, std::cout);
-  // The above line prints:
-  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
-
-  // Start a new line
-  std::cout << std::endl;
-
-  // Generate the prettified JSON and send it to STDOUT
-  //
-  serializeJsonPretty(doc, std::cout);
-  // The above line prints:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [
-  //     48.756080,
-  //     2.302038
-  //   ]
-  // }
-}

extras/scripts/wandbox/JsonParserExample.cpp

@@ -1,59 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-//
-// This example shows how to deserialize a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 200 is the capacity of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/v6/assistant to compute the capacity.
-  StaticJsonDocument<300> doc;
-
-  // StaticJsonDocument<N> allocates memory on the stack, it can be
-  // replaced by DynamicJsonDocument which allocates in the heap.
-  //
-  // DynamicJsonDocument doc(200);
-
-  // JSON input string.
-  //
-  // Using a char[], as shown here, enables the "zero-copy" mode. This mode uses
-  // the minimal amount of memory because the JsonDocument stores pointers to
-  // the input buffer.
-  // If you use another type of input, ArduinoJson must copy the strings from
-  // the input to the JsonDocument, so you need to increase the capacity of the
-  // JsonDocument.
-  char json[] =
-      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
-
-  // Deserialize the JSON document
-  DeserializationError error = deserializeJson(doc, json);
-
-  // Test if parsing succeeds.
-  if (error) {
-    std::cerr << "deserializeJson() failed: " << error.c_str() << std::endl;
-    return 1;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  std::cout << sensor << std::endl;
-  std::cout << time << std::endl;
-  std::cout << latitude << std::endl;
-  std::cout << longitude << std::endl;
-
-  return 0;
-}

extras/scripts/wandbox/MsgPackParserExample.cpp

@@ -1,68 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-//
-// This example shows how to generate a JSON document with ArduinoJson.
-
-#include <iostream>
-#include "ArduinoJson.h"
-
-int main() {
-  // Allocate the JSON document
-  //
-  // Inside the brackets, 300 is the size of the memory pool in bytes.
-  // Don't forget to change this value to match your JSON document.
-  // Use arduinojson.org/assistant to compute the capacity.
-  StaticJsonDocument<300> doc;
-
-  // StaticJsonObject allocates memory on the stack, it can be
-  // replaced by DynamicJsonObject which allocates in the heap.
-  //
-  // DynamicJsonObject doc(200);
-
-  // MessagePack input string.
-  //
-  // It's better to use a char[] as shown here.
-  // If you use a const char* or a String, ArduinoJson will
-  // have to make a copy of the input in the JsonBuffer.
-  uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,
-                     164, 116, 105, 109, 101, 206, 80,  147, 50,  248, 164, 100,
-                     97,  116, 97,  146, 203, 64,  72,  96,  199, 58,  188, 148,
-                     112, 203, 64,  2,   106, 146, 230, 33,  49,  169};
-  // This MessagePack document contains:
-  // {
-  //   "sensor": "gps",
-  //   "time": 1351824120,
-  //   "data": [48.75608, 2.302038]
-  // }
-
-  // doc of the object tree.
-  //
-  // It's a reference to the JsonObject, the actual bytes are inside the
-  // JsonBuffer with all the other nodes of the object tree.
-  // Memory is freed when jsonBuffer goes out of scope.
-  DeserializationError error = deserializeMsgPack(doc, input);
-
-  // Test if parsing succeeds.
-  if (error) {
-    std::cerr << "deserializeMsgPack() failed: " << error.c_str() << std::endl;
-    return 1;
-  }
-
-  // Fetch values.
-  //
-  // Most of the time, you can rely on the implicit casts.
-  // In other case, you can do doc["time"].as<long>();
-  const char* sensor = doc["sensor"];
-  long time = doc["time"];
-  double latitude = doc["data"][0];
-  double longitude = doc["data"][1];
-
-  // Print values.
-  std::cout << sensor << std::endl;
-  std::cout << time << std::endl;
-  std::cout << latitude << std::endl;
-  std::cout << longitude << std::endl;
-
-  return 0;
-}

extras/scripts/wandbox/publish.sh

@@ -1,29 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-ARDUINOJSON_H="$1"
-
-read_string() {
-	jq --slurp --raw-input '.' "$1"
-}
-
-compile() {
-	FILE_PATH="$(dirname $0)/$1.cpp"
-	cat >parameters.json <<END
-{
-  "code":$(read_string "$FILE_PATH"),
-  "codes": [{"file":"ArduinoJson.h","code":$(read_string "$ARDUINOJSON_H")}],
-  "options": "warning",
-  "compiler": "gcc-4.9.3",
-  "save": true
-}
-END
-	URL=$(curl -sS -H "Content-type: application/json" -d @parameters.json  https://wandbox.org/api/compile.json | jq --raw-output .url)
-	rm parameters.json
-	echo "  $1: $URL"
-}
-
-compile "JsonGeneratorExample"
-compile "JsonParserExample"
-compile "MsgPackParserExample"

extras/tests/CMakeLists.txt

@@ -1,26 +0,0 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
-# MIT License
-
-add_subdirectory(catch)
-
-link_libraries(ArduinoJson catch)
-
-include_directories(Helpers)
-add_subdirectory(ElementProxy)
-add_subdirectory(FailingBuilds)
-add_subdirectory(IntegrationTests)
-add_subdirectory(JsonArray)
-add_subdirectory(JsonDeserializer)
-add_subdirectory(JsonDocument)
-add_subdirectory(JsonObject)
-add_subdirectory(JsonSerializer)
-add_subdirectory(JsonVariant)
-add_subdirectory(MemberProxy)
-add_subdirectory(MemoryPool)
-add_subdirectory(Misc)
-add_subdirectory(MixedConfiguration)
-add_subdirectory(MsgPackDeserializer)
-add_subdirectory(MsgPackSerializer)
-add_subdirectory(Numbers)
-add_subdirectory(TextFormatter)

extras/tests/ElementProxy/CMakeLists.txt

@@ -1,15 +0,0 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
-# MIT License
-
-add_executable(ElementProxyTests
-	add.cpp
-	clear.cpp
-	compare.cpp
-	remove.cpp
-	set.cpp
-	size.cpp
-	subscript.cpp
-)
-
-add_test(ElementProxy ElementProxyTests)

extras/tests/ElementProxy/add.cpp

@@ -1,34 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::add()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("add(int)") {
-    ep.add(42);
-
-    REQUIRE(doc.as<std::string>() == "[[42]]");
-  }
-
-  SECTION("add(const char*)") {
-    ep.add("world");
-
-    REQUIRE(doc.as<std::string>() == "[[\"world\"]]");
-  }
-
-  SECTION("set(char[])") {
-    char s[] = "world";
-    ep.add(s);
-    strcpy(s, "!!!!!");
-
-    REQUIRE(doc.as<std::string>() == "[[\"world\"]]");
-  }
-}

extras/tests/ElementProxy/clear.cpp

@@ -1,28 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::clear()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("size goes back to zero") {
-    ep.add(42);
-    ep.clear();
-
-    REQUIRE(ep.size() == 0);
-  }
-
-  SECTION("isNull() return true") {
-    ep.add("hello");
-    ep.clear();
-
-    REQUIRE(ep.isNull() == true);
-  }
-}

extras/tests/ElementProxy/compare.cpp

@@ -1,48 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::operator==()") {
-  DynamicJsonDocument doc(4096);
-
-  SECTION("1 vs 1") {
-    doc.add(1);
-    doc.add(1);
-
-    REQUIRE(doc[0] <= doc[1]);
-    REQUIRE(doc[0] == doc[1]);
-    REQUIRE(doc[0] >= doc[1]);
-    REQUIRE_FALSE(doc[0] != doc[1]);
-    REQUIRE_FALSE(doc[0] < doc[1]);
-    REQUIRE_FALSE(doc[0] > doc[1]);
-  }
-
-  SECTION("1 vs 2") {
-    doc.add(1);
-    doc.add(2);
-
-    REQUIRE(doc[0] != doc[1]);
-    REQUIRE(doc[0] < doc[1]);
-    REQUIRE(doc[0] <= doc[1]);
-    REQUIRE_FALSE(doc[0] == doc[1]);
-    REQUIRE_FALSE(doc[0] > doc[1]);
-    REQUIRE_FALSE(doc[0] >= doc[1]);
-  }
-
-  SECTION("'abc' vs 'bcd'") {
-    doc.add("abc");
-    doc.add("bcd");
-
-    REQUIRE(doc[0] != doc[1]);
-    REQUIRE(doc[0] < doc[1]);
-    REQUIRE(doc[0] <= doc[1]);
-    REQUIRE_FALSE(doc[0] == doc[1]);
-    REQUIRE_FALSE(doc[0] > doc[1]);
-    REQUIRE_FALSE(doc[0] >= doc[1]);
-  }
-}

extras/tests/ElementProxy/remove.cpp

@@ -1,56 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::remove()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("remove(int)") {
-    ep.add(1);
-    ep.add(2);
-    ep.add(3);
-
-    ep.remove(1);
-
-    REQUIRE(ep.as<std::string>() == "[1,3]");
-  }
-
-  SECTION("remove(const char *)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    ep.remove("a");
-
-    REQUIRE(ep.as<std::string>() == "{\"b\":2}");
-  }
-
-  SECTION("remove(std::string)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    ep.remove(std::string("b"));
-
-    REQUIRE(ep.as<std::string>() == "{\"a\":1}");
-  }
-
-#ifdef HAS_VARIABLE_LENGTH_ARRAY
-  SECTION("remove(vla)") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-
-    int i = 4;
-    char vla[i];
-    strcpy(vla, "b");
-    ep.remove(vla);
-
-    REQUIRE(ep.as<std::string>() == "{\"a\":1}");
-  }
-#endif
-}

extras/tests/ElementProxy/set.cpp

@@ -1,33 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::set()") {
-  DynamicJsonDocument doc(4096);
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("set(int)") {
-    ep.set(42);
-
-    REQUIRE(doc.as<std::string>() == "[42]");
-  }
-
-  SECTION("set(const char*)") {
-    ep.set("world");
-
-    REQUIRE(doc.as<std::string>() == "[\"world\"]");
-  }
-
-  SECTION("set(char[])") {
-    char s[] = "world";
-    ep.set(s);
-    strcpy(s, "!!!!!");
-
-    REQUIRE(doc.as<std::string>() == "[\"world\"]");
-  }
-}

extras/tests/ElementProxy/size.cpp

@@ -1,30 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::size()") {
-  DynamicJsonDocument doc(4096);
-  doc.addElement();
-  ElementProxy<JsonDocument&> ep = doc[0];
-
-  SECTION("returns 0") {
-    REQUIRE(ep.size() == 0);
-  }
-
-  SECTION("as an array, returns 2") {
-    ep.add(1);
-    ep.add(2);
-    REQUIRE(ep.size() == 2);
-  }
-
-  SECTION("as an object, returns 2") {
-    ep["a"] = 1;
-    ep["b"] = 2;
-    REQUIRE(ep.size() == 2);
-  }
-}

extras/tests/ElementProxy/subscript.cpp

@@ -1,25 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("ElementProxy::operator[]") {
-  DynamicJsonDocument doc(4096);
-  ElementProxy<JsonDocument&> ep = doc[1];
-
-  SECTION("set member") {
-    ep["world"] = 42;
-
-    REQUIRE(doc.as<std::string>() == "[null,{\"world\":42}]");
-  }
-
-  SECTION("set element") {
-    ep[2] = 42;
-
-    REQUIRE(doc.as<std::string>() == "[null,[null,null,42]]");
-  }
-}

extras/tests/FailingBuilds/CMakeLists.txt

@@ -1,38 +0,0 @@
-# ArduinoJson - arduinojson.org
-# Copyright Benoit Blanchon 2014-2020
-# MIT License
-
-macro(build_should_fail target)
-	set_target_properties(${target}
-		PROPERTIES
-	    	EXCLUDE_FROM_ALL TRUE
-	        EXCLUDE_FROM_DEFAULT_BUILD TRUE
-	)
-	add_test(
-		NAME
-			${target}
-	    COMMAND
-	    	${CMAKE_COMMAND} --build . --target ${target} --config $<CONFIGURATION>
-	    WORKING_DIRECTORY
-	    	${CMAKE_BINARY_DIR}
-	)
-	set_tests_properties(${target} 
-		PROPERTIES
-			WILL_FAIL TRUE
-	)
-endmacro()
-
-
-add_executable(Issue978 Issue978.cpp)
-build_should_fail(Issue978)
-
-add_executable(Issue1189 Issue1189.cpp)
-build_should_fail(Issue1189)
-
-add_executable(read_long_long read_long_long.cpp)
-set_property(TARGET read_long_long PROPERTY CXX_STANDARD 11)
-build_should_fail(read_long_long)
-
-add_executable(write_long_long write_long_long.cpp)
-set_property(TARGET write_long_long PROPERTY CXX_STANDARD 11)
-build_should_fail(write_long_long)

extras/tests/FailingBuilds/Issue1189.cpp

@@ -1,13 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-
-// a function should not be able to get a JsonDocument by value
-void f(JsonDocument) {}
-
-int main() {
-  DynamicJsonDocument doc(1024);
-  f(doc);
-}

extras/tests/FailingBuilds/Issue978.cpp

@@ -1,13 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-
-struct Stream {};
-
-int main() {
-  Stream* stream = 0;
-  DynamicJsonDocument doc(1024);
-  deserializeJson(doc, stream);
-}

extras/tests/FailingBuilds/read_long_long.cpp

@@ -1,20 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#define ARDUINOJSON_USE_LONG_LONG 0
-#include <ArduinoJson.h>
-
-#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8
-#error This test requires sizeof(long) < 8
-#endif
-
-#if !ARDUINOJSON_HAS_LONG_LONG
-#error This test requires C++11
-#endif
-
-ARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(long long)
-int main() {
-  DynamicJsonDocument doc(1024);
-  doc["dummy"].as<long long>();
-}

extras/tests/FailingBuilds/write_long_long.cpp

@@ -1,19 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#define ARDUINOJSON_USE_LONG_LONG 0
-#include <ArduinoJson.h>
-
-#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8
-#error This test requires sizeof(long) < 8
-#endif
-
-#if !ARDUINOJSON_HAS_LONG_LONG
-#error This test requires C++11
-#endif
-
-int main() {
-  DynamicJsonDocument doc(1024);
-  doc["dummy"] = static_cast<long long>(42);
-}

extras/tests/Helpers/Arduino.h

@@ -1,8 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#pragma once
-
-#include "api/Stream.h"
-#include "api/String.h"

extras/tests/Helpers/CustomReader.hpp

@@ -1,26 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#pragma once
-
-#include <sstream>
-
-class CustomReader {
-  std::stringstream _stream;
-
- public:
-  CustomReader(const char* input) : _stream(input) {}
-
-  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());
-  }
-
- private:
-  CustomReader(const CustomReader&);
-};

extras/tests/Helpers/api/Stream.h

@@ -1,14 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// 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;
-};

extras/tests/Helpers/api/String.h

@@ -1,45 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#pragma once
-
-#include <string>
-
-// Reproduces Arduino's String class
-class String {
- public:
-  String() {}
-  explicit String(const char* s) : _str(s) {}
-
-  String& operator+=(const char* rhs) {
-    _str += rhs;
-    return *this;
-  }
-
-  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;
-  }
-
-  friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {
-    lhs << rhs._str;
-    return lhs;
-  }
-
- private:
-  std::string _str;
-};
-
-class StringSumHelper;
-
-inline bool operator==(const std::string& lhs, const ::String& rhs) {
-  return lhs == rhs.c_str();
-}

extras/tests/Helpers/progmem_emulation.hpp

@@ -1,42 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <stdint.h>  // uint8_t
-#include <string.h>  // strcmp, strlen...
-
-#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));
-}
-
-inline void* pgm_read_ptr(const void* p) {
-  return *reinterpret_cast<void* const*>(convertFlashToPtr(p));
-}
-
-inline float pgm_read_float(const void* p) {
-  return *reinterpret_cast<const float*>(convertFlashToPtr(p));
-}
-
-inline uint32_t pgm_read_dword(const void* p) {
-  return *reinterpret_cast<const uint32_t*>(convertFlashToPtr(p));
-}
-
-#define ARDUINOJSON_DEFINE_STATIC_ARRAY(type, name, value)         \
-  static type const ARDUINOJSON_CONCAT2(name, _progmem)[] = value; \
-  static type const* name = reinterpret_cast<type const*>(         \
-      convertPtrToFlash(ARDUINOJSON_CONCAT2(name, _progmem)));

extras/tests/IntegrationTests/issue772.cpp

@@ -1,28 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-// https://github.com/bblanchon/ArduinoJson/issues/772
-
-TEST_CASE("Issue772") {
-  DynamicJsonDocument doc1(4096);
-  DynamicJsonDocument doc2(4096);
-  DeserializationError err;
-  std::string data =
-      "{\"state\":{\"reported\":{\"timestamp\":\"2018-07-02T09:40:12Z\","
-      "\"mac\":\"2C3AE84FC076\",\"firmwareVersion\":\"v0.2.7-5-gf4d4d78\","
-      "\"visibleLight\":261,\"infraRed\":255,\"ultraViolet\":0.02,"
-      "\"Temperature\":26.63,\"Pressure\":101145.7,\"Humidity\":54.79883,"
-      "\"Vbat\":4.171261,\"soilMoisture\":0,\"ActB\":0}}}";
-  err = deserializeJson(doc1, data);
-  REQUIRE(err == DeserializationError::Ok);
-
-  data = "";
-  serializeMsgPack(doc1, data);
-  err = deserializeMsgPack(doc2, data);
-
-  REQUIRE(err == DeserializationError::Ok);
-}

extras/tests/JsonArray/add.cpp

@@ -1,138 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::add()") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-
-  SECTION("int") {
-    array.add(123);
-    REQUIRE(123 == array[0].as<int>());
-    REQUIRE(array[0].is<int>());
-    REQUIRE(array[0].is<double>());
-  }
-
-  SECTION("double") {
-    array.add(123.45);
-    REQUIRE(123.45 == array[0].as<double>());
-    REQUIRE(array[0].is<double>());
-    REQUIRE_FALSE(array[0].is<bool>());
-  }
-
-  SECTION("bool") {
-    array.add(true);
-    REQUIRE(true == array[0].as<bool>());
-    REQUIRE(array[0].is<bool>());
-    REQUIRE_FALSE(array[0].is<int>());
-  }
-
-  SECTION("const char*") {
-    const char* str = "hello";
-    array.add(str);
-    REQUIRE(str == array[0].as<std::string>());
-    REQUIRE(array[0].is<const char*>());
-    REQUIRE_FALSE(array[0].is<int>());
-  }
-
-#ifdef HAS_VARIABLE_LENGTH_ARRAY
-  SECTION("vla") {
-    int i = 16;
-    char vla[i];
-    strcpy(vla, "world");
-
-    array.add(vla);
-
-    REQUIRE(std::string("world") == array[0]);
-  }
-#endif
-
-  SECTION("nested array") {
-    DynamicJsonDocument doc2(4096);
-    JsonArray arr = doc2.to<JsonArray>();
-
-    array.add(arr);
-
-    REQUIRE(arr == array[0].as<JsonArray>());
-    REQUIRE(array[0].is<JsonArray>());
-    REQUIRE_FALSE(array[0].is<int>());
-  }
-
-  SECTION("nested object") {
-    DynamicJsonDocument doc2(4096);
-    JsonObject obj = doc2.to<JsonObject>();
-
-    array.add(obj);
-
-    REQUIRE(obj == array[0].as<JsonObject>());
-    REQUIRE(array[0].is<JsonObject>());
-    REQUIRE_FALSE(array[0].is<int>());
-  }
-
-  SECTION("array subscript") {
-    const char* str = "hello";
-    DynamicJsonDocument doc2(4096);
-    JsonArray arr = doc2.to<JsonArray>();
-    arr.add(str);
-
-    array.add(arr[0]);
-
-    REQUIRE(str == array[0]);
-  }
-
-  SECTION("object subscript") {
-    const char* str = "hello";
-    DynamicJsonDocument doc2(4096);
-    JsonObject obj = doc2.to<JsonObject>();
-    obj["x"] = str;
-
-    array.add(obj["x"]);
-
-    REQUIRE(str == array[0]);
-  }
-
-  SECTION("should not duplicate const char*") {
-    array.add("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate char*") {
-    array.add(const_cast<char*>("world"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate std::string") {
-    array.add(std::string("world"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should not duplicate serialized(const char*)") {
-    array.add(serialized("{}"));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate serialized(char*)") {
-    array.add(serialized(const_cast<char*>("{}")));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate serialized(std::string)") {
-    array.add(serialized(std::string("{}")));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate serialized(std::string)") {
-    array.add(serialized(std::string("\0XX", 3)));
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(3);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-}

extras/tests/JsonArray/copyArray.cpp

@@ -1,279 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("copyArray()") {
-  SECTION("int[] -> JsonArray") {
-    DynamicJsonDocument doc(4096);
-    JsonArray array = doc.to<JsonArray>();
-    char json[32];
-    int source[] = {1, 2, 3};
-
-    bool ok = copyArray(source, array);
-    CHECK(ok);
-
-    serializeJson(array, json);
-    CHECK(std::string("[1,2,3]") == json);
-  }
-
-  SECTION("std::string[] -> JsonArray") {
-    DynamicJsonDocument doc(4096);
-    JsonArray array = doc.to<JsonArray>();
-    char json[32];
-    std::string source[] = {"a", "b", "c"};
-
-    bool ok = copyArray(source, array);
-    CHECK(ok);
-
-    serializeJson(array, json);
-    CHECK(std::string("[\"a\",\"b\",\"c\"]") == json);
-  }
-
-  SECTION("int[] -> JsonDocument") {
-    DynamicJsonDocument doc(4096);
-    char json[32];
-    int source[] = {1, 2, 3};
-
-    bool ok = copyArray(source, doc);
-    CHECK(ok);
-
-    serializeJson(doc, json);
-    CHECK(std::string("[1,2,3]") == json);
-  }
-
-  SECTION("int[] -> MemberProxy") {
-    DynamicJsonDocument doc(4096);
-    char json[32];
-    int source[] = {1, 2, 3};
-
-    bool ok = copyArray(source, doc["data"]);
-    CHECK(ok);
-
-    serializeJson(doc, json);
-    CHECK(std::string("{\"data\":[1,2,3]}") == json);
-  }
-
-  SECTION("int[] -> JsonArray, but not enough memory") {
-    const size_t SIZE = JSON_ARRAY_SIZE(2);
-    StaticJsonDocument<SIZE> doc;
-    JsonArray array = doc.to<JsonArray>();
-    char json[32];
-    int source[] = {1, 2, 3};
-
-    bool ok = copyArray(source, array);
-    REQUIRE_FALSE(ok);
-
-    serializeJson(array, json);
-    CHECK(std::string("[1,2]") == json);
-  }
-
-  SECTION("int[][] -> JsonArray") {
-    DynamicJsonDocument doc(4096);
-    JsonArray array = doc.to<JsonArray>();
-    char json[32];
-    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-    bool ok = copyArray(source, array);
-    CHECK(ok);
-
-    serializeJson(array, json);
-    CHECK(std::string("[[1,2,3],[4,5,6]]") == json);
-  }
-
-  SECTION("int[][] -> MemberProxy") {
-    DynamicJsonDocument doc(4096);
-    char json[32];
-    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-    bool ok = copyArray(source, doc["data"]);
-    CHECK(ok);
-
-    serializeJson(doc, json);
-    CHECK(std::string("{\"data\":[[1,2,3],[4,5,6]]}") == json);
-  }
-
-  SECTION("int[][] -> JsonDocument") {
-    DynamicJsonDocument doc(4096);
-    char json[32];
-    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-    bool ok = copyArray(source, doc);
-    CHECK(ok);
-
-    serializeJson(doc, json);
-    CHECK(std::string("[[1,2,3],[4,5,6]]") == json);
-  }
-
-  SECTION("int[][] -> JsonArray, but not enough memory") {
-    const size_t SIZE =
-        JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
-    StaticJsonDocument<SIZE> doc;
-    JsonArray array = doc.to<JsonArray>();
-    char json[32] = "";
-    int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-    CAPTURE(SIZE)
-
-    bool ok = copyArray(source, array);
-    CAPTURE(doc.memoryUsage());
-    CHECK_FALSE(ok);
-
-    serializeJson(array, json);
-    CHECK(std::string("[[1,2,3],[4,5]]") == json);
-  }
-
-  SECTION("JsonArray -> int[], with more space than needed") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[1,2,3]";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-    JsonArray array = doc.as<JsonArray>();
-
-    int destination[4] = {0};
-    size_t result = copyArray(array, destination);
-
-    CHECK(3 == result);
-    CHECK(1 == destination[0]);
-    CHECK(2 == destination[1]);
-    CHECK(3 == destination[2]);
-    CHECK(0 == destination[3]);
-  }
-
-  SECTION("JsonArray -> int[], without enough space") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[1,2,3]";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-    JsonArray array = doc.as<JsonArray>();
-
-    int destination[2] = {0};
-    size_t result = copyArray(array, destination);
-
-    CHECK(2 == result);
-    CHECK(1 == destination[0]);
-    CHECK(2 == destination[1]);
-  }
-
-  SECTION("JsonArray -> std::string[]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[\"a\",\"b\",\"c\"]";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-    JsonArray array = doc.as<JsonArray>();
-
-    std::string destination[4];
-    size_t result = copyArray(array, destination);
-
-    CHECK(3 == result);
-    CHECK("a" == destination[0]);
-    CHECK("b" == destination[1]);
-    CHECK("c" == destination[2]);
-    CHECK("" == destination[3]);
-  }
-
-  SECTION("JsonDocument -> int[]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[1,2,3]";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-
-    int destination[4] = {0};
-    size_t result = copyArray(doc, destination);
-
-    CHECK(3 == result);
-    CHECK(1 == destination[0]);
-    CHECK(2 == destination[1]);
-    CHECK(3 == destination[2]);
-    CHECK(0 == destination[3]);
-  }
-
-  SECTION("MemberProxy -> int[]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "{\"data\":[1,2,3]}";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-
-    int destination[4] = {0};
-    size_t result = copyArray(doc["data"], destination);
-
-    CHECK(3 == result);
-    CHECK(1 == destination[0]);
-    CHECK(2 == destination[1]);
-    CHECK(3 == destination[2]);
-    CHECK(0 == destination[3]);
-  }
-
-  SECTION("ElementProxy -> int[]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[[1,2,3]]";
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-
-    int destination[4] = {0};
-    size_t result = copyArray(doc[0], destination);
-
-    CHECK(3 == result);
-    CHECK(1 == destination[0]);
-    CHECK(2 == destination[1]);
-    CHECK(3 == destination[2]);
-    CHECK(0 == destination[3]);
-  }
-
-  SECTION("JsonArray -> int[][]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[[1,2],[3],[4]]";
-
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-    JsonArray array = doc.as<JsonArray>();
-
-    int destination[3][2] = {{0}};
-    copyArray(array, destination);
-
-    CHECK(1 == destination[0][0]);
-    CHECK(2 == destination[0][1]);
-    CHECK(3 == destination[1][0]);
-    CHECK(0 == destination[1][1]);
-    CHECK(4 == destination[2][0]);
-    CHECK(0 == destination[2][1]);
-  }
-
-  SECTION("JsonDocument -> int[][]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "[[1,2],[3],[4]]";
-
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-
-    int destination[3][2] = {{0}};
-    copyArray(doc, destination);
-
-    CHECK(1 == destination[0][0]);
-    CHECK(2 == destination[0][1]);
-    CHECK(3 == destination[1][0]);
-    CHECK(0 == destination[1][1]);
-    CHECK(4 == destination[2][0]);
-    CHECK(0 == destination[2][1]);
-  }
-
-  SECTION("MemberProxy -> int[][]") {
-    DynamicJsonDocument doc(4096);
-    char json[] = "{\"data\":[[1,2],[3],[4]]}";
-
-    DeserializationError err = deserializeJson(doc, json);
-    CHECK(err == DeserializationError::Ok);
-
-    int destination[3][2] = {{0}};
-    copyArray(doc["data"], destination);
-
-    CHECK(1 == destination[0][0]);
-    CHECK(2 == destination[0][1]);
-    CHECK(3 == destination[1][0]);
-    CHECK(0 == destination[1][1]);
-    CHECK(4 == destination[2][0]);
-    CHECK(0 == destination[2][1]);
-  }
-}

extras/tests/JsonArray/createNested.cpp

@@ -1,21 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray basics") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-
-  SECTION("CreateNestedArray") {
-    JsonArray arr = array.createNestedArray();
-    REQUIRE(arr == array[0].as<JsonArray>());
-  }
-
-  SECTION("CreateNestedObject") {
-    JsonObject obj = array.createNestedObject();
-    REQUIRE(obj == array[0].as<JsonObject>());
-  }
-}

extras/tests/JsonArray/equals.cpp

@@ -1,69 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::operator==()") {
-  DynamicJsonDocument doc1(4096);
-  JsonArray array1 = doc1.to<JsonArray>();
-  JsonArrayConst array1c = array1;
-
-  DynamicJsonDocument doc2(4096);
-  JsonArray array2 = doc2.to<JsonArray>();
-  JsonArrayConst array2c = array2;
-
-  SECTION("should return false when arrays differ") {
-    array1.add("coucou");
-    array2.add(1);
-
-    REQUIRE_FALSE(array1 == array2);
-    REQUIRE_FALSE(array1c == array2c);
-  }
-
-  SECTION("should return false when LHS has more elements") {
-    array1.add(1);
-    array1.add(2);
-    array2.add(1);
-
-    REQUIRE_FALSE(array1 == array2);
-    REQUIRE_FALSE(array1c == array2c);
-  }
-
-  SECTION("should return false when RHS has more elements") {
-    array1.add(1);
-    array2.add(1);
-    array2.add(2);
-
-    REQUIRE_FALSE(array1 == array2);
-    REQUIRE_FALSE(array1c == array2c);
-  }
-
-  SECTION("should return true when arrays equal") {
-    array1.add("coucou");
-    array2.add("coucou");
-
-    REQUIRE(array1 == array2);
-    REQUIRE(array1c == array2c);
-  }
-
-  SECTION("should return false when RHS is null") {
-    JsonArray null;
-
-    REQUIRE_FALSE(array1 == null);
-  }
-
-  SECTION("should return false when LHS is null") {
-    JsonArray null;
-
-    REQUIRE_FALSE(null == array1);
-  }
-
-  SECTION("should return true when both are null") {
-    JsonArray null1;
-    JsonArray null2;
-
-    REQUIRE(null1 == null2);
-  }
-}

extras/tests/JsonArray/get.cpp

@@ -1,16 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::get()") {
-  DynamicJsonDocument doc(4096);
-  deserializeJson(doc, "[1,2,3]");
-  JsonArray array = doc.as<JsonArray>();
-
-  SECTION("Overflow") {
-    REQUIRE(array.getElement(3).isNull());
-  }
-}

extras/tests/JsonArray/isNull.cpp

@@ -1,58 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::isNull()") {
-  SECTION("returns true") {
-    JsonArray arr;
-    REQUIRE(arr.isNull() == true);
-  }
-
-  SECTION("returns false") {
-    DynamicJsonDocument doc(4096);
-    JsonArray arr = doc.to<JsonArray>();
-    REQUIRE(arr.isNull() == false);
-  }
-}
-
-TEST_CASE("JsonArrayConst::isNull()") {
-  SECTION("returns true") {
-    JsonArrayConst arr;
-    REQUIRE(arr.isNull() == true);
-  }
-
-  SECTION("returns false") {
-    DynamicJsonDocument doc(4096);
-    JsonArrayConst arr = doc.to<JsonArray>();
-    REQUIRE(arr.isNull() == false);
-  }
-}
-
-TEST_CASE("JsonArray::operator bool()") {
-  SECTION("returns false") {
-    JsonArray arr;
-    REQUIRE(static_cast<bool>(arr) == false);
-  }
-
-  SECTION("returns true") {
-    DynamicJsonDocument doc(4096);
-    JsonArray arr = doc.to<JsonArray>();
-    REQUIRE(static_cast<bool>(arr) == true);
-  }
-}
-
-TEST_CASE("JsonArrayConst::operator bool()") {
-  SECTION("returns false") {
-    JsonArrayConst arr;
-    REQUIRE(static_cast<bool>(arr) == false);
-  }
-
-  SECTION("returns true") {
-    DynamicJsonDocument doc(4096);
-    JsonArrayConst arr = doc.to<JsonArray>();
-    REQUIRE(static_cast<bool>(arr) == true);
-  }
-}

extras/tests/JsonArray/iterator.cpp

@@ -1,52 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-template <typename TArray>
-static void run_iterator_test() {
-  StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
-  JsonArray tmp = doc.to<JsonArray>();
-  tmp.add(12);
-  tmp.add(34);
-
-  TArray array = tmp;
-  typename TArray::iterator it = array.begin();
-  typename TArray::iterator end = array.end();
-
-  REQUIRE(end != it);
-  REQUIRE(12 == it->template as<int>());
-  REQUIRE(12 == static_cast<int>(*it));
-  ++it;
-  REQUIRE(end != it);
-  REQUIRE(34 == it->template as<int>());
-  REQUIRE(34 == static_cast<int>(*it));
-  ++it;
-  REQUIRE(end == it);
-}
-
-TEST_CASE("JsonArray::begin()/end()") {
-  SECTION("Non null JsonArray") {
-    run_iterator_test<JsonArray>();
-  }
-
-  SECTION("Null JsonArray") {
-    JsonArray array;
-
-    REQUIRE(array.begin() == array.end());
-  }
-}
-
-TEST_CASE("JsonArrayConst::begin()/end()") {
-  SECTION("Non null JsonArrayConst") {
-    run_iterator_test<JsonArrayConst>();
-  }
-
-  SECTION("Null JsonArrayConst") {
-    JsonArrayConst array;
-
-    REQUIRE(array.begin() == array.end());
-  }
-}

extras/tests/JsonArray/memoryUsage.cpp

@@ -1,42 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::memoryUsage()") {
-  DynamicJsonDocument doc(4096);
-  JsonArray arr = doc.to<JsonArray>();
-
-  SECTION("return 0 if uninitialized") {
-    JsonArray unitialized;
-    REQUIRE(unitialized.memoryUsage() == 0);
-  }
-
-  SECTION("JSON_ARRAY_SIZE(0) if empty") {
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0));
-  }
-
-  SECTION("JSON_ARRAY_SIZE(1) after add") {
-    arr.add("hello");
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1));
-  }
-
-  SECTION("includes the size of the string") {
-    arr.add(std::string("hello"));
-    REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1) + 6);
-  }
-
-  SECTION("includes the size of the nested array") {
-    JsonArray nested = arr.createNestedArray();
-    nested.add(42);
-    REQUIRE(arr.memoryUsage() == 2 * JSON_ARRAY_SIZE(1));
-  }
-
-  SECTION("includes the size of the nested arrect") {
-    JsonObject nested = arr.createNestedObject();
-    nested["hello"] = "world";
-    REQUIRE(arr.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1));
-  }
-}

extras/tests/JsonArray/nesting.cpp

@@ -1,35 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::nesting()") {
-  DynamicJsonDocument doc(4096);
-  JsonArray arr = doc.to<JsonArray>();
-
-  SECTION("return 0 if uninitialized") {
-    JsonArray unitialized;
-    REQUIRE(unitialized.nesting() == 0);
-  }
-
-  SECTION("returns 1 for empty array") {
-    REQUIRE(arr.nesting() == 1);
-  }
-
-  SECTION("returns 1 for flat array") {
-    arr.add("hello");
-    REQUIRE(arr.nesting() == 1);
-  }
-
-  SECTION("returns 2 with nested array") {
-    arr.createNestedArray();
-    REQUIRE(arr.nesting() == 2);
-  }
-
-  SECTION("returns 2 with nested object") {
-    arr.createNestedObject();
-    REQUIRE(arr.nesting() == 2);
-  }
-}

extras/tests/JsonArray/size.cpp

@@ -1,31 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::size()") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-
-  SECTION("returns 0 is empty") {
-    REQUIRE(0U == array.size());
-  }
-
-  SECTION("increases after add()") {
-    array.add("hello");
-    REQUIRE(1U == array.size());
-
-    array.add("world");
-    REQUIRE(2U == array.size());
-  }
-
-  SECTION("remains the same after replacing an element") {
-    array.add("hello");
-    REQUIRE(1U == array.size());
-
-    array[0] = "hello";
-    REQUIRE(1U == array.size());
-  }
-}

extras/tests/JsonArray/std_string.cpp

@@ -1,31 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-static void eraseString(std::string &str) {
-  char *p = const_cast<char *>(str.c_str());
-  while (*p) *p++ = '*';
-}
-
-TEST_CASE("std::string") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-
-  SECTION("add()") {
-    std::string value("hello");
-    array.add(value);
-    eraseString(value);
-    REQUIRE(std::string("hello") == array[0]);
-  }
-
-  SECTION("operator[]") {
-    std::string value("world");
-    array.add("hello");
-    array[0] = value;
-    eraseString(value);
-    REQUIRE(std::string("world") == array[0]);
-  }
-}

extras/tests/JsonArray/subscript.cpp

@@ -1,175 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <stdint.h>
-#include <catch.hpp>
-
-TEST_CASE("JsonArray::operator[]") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-
-  SECTION("Pad with null") {
-    array[2] = 2;
-    array[5] = 5;
-    REQUIRE(array.size() == 6);
-    REQUIRE(array[0].isNull() == true);
-    REQUIRE(array[1].isNull() == true);
-    REQUIRE(array[2].isNull() == false);
-    REQUIRE(array[3].isNull() == true);
-    REQUIRE(array[4].isNull() == true);
-    REQUIRE(array[5].isNull() == false);
-    REQUIRE(array[2] == 2);
-    REQUIRE(array[5] == 5);
-  }
-
-  SECTION("int") {
-    array[0] = 123;
-    REQUIRE(123 == array[0].as<int>());
-    REQUIRE(true == array[0].is<int>());
-    REQUIRE(false == array[0].is<bool>());
-  }
-
-#if ARDUINOJSON_USE_LONG_LONG
-  SECTION("long long") {
-    array[0] = 9223372036854775807;
-    REQUIRE(9223372036854775807 == array[0].as<int64_t>());
-    REQUIRE(true == array[0].is<int64_t>());
-    REQUIRE(false == array[0].is<int32_t>());
-    REQUIRE(false == array[0].is<bool>());
-  }
-#endif
-
-  SECTION("double") {
-    array[0] = 123.45;
-    REQUIRE(123.45 == array[0].as<double>());
-    REQUIRE(true == array[0].is<double>());
-    REQUIRE(false == array[0].is<int>());
-  }
-
-  SECTION("bool") {
-    array[0] = true;
-    REQUIRE(true == array[0].as<bool>());
-    REQUIRE(true == array[0].is<bool>());
-    REQUIRE(false == array[0].is<int>());
-  }
-
-  SECTION("const char*") {
-    const char* str = "hello";
-
-    array[0] = str;
-    REQUIRE(str == array[0].as<const char*>());
-    REQUIRE(str == array[0].as<char*>());  // <- short hand
-    REQUIRE(true == array[0].is<const char*>());
-    REQUIRE(false == array[0].is<int>());
-  }
-
-  SECTION("nested array") {
-    DynamicJsonDocument doc2(4096);
-    JsonArray arr2 = doc2.to<JsonArray>();
-
-    array[0] = arr2;
-
-    REQUIRE(arr2 == array[0].as<JsonArray>());
-    REQUIRE(true == array[0].is<JsonArray>());
-    REQUIRE(false == array[0].is<int>());
-  }
-
-  SECTION("nested object") {
-    DynamicJsonDocument doc2(4096);
-    JsonObject obj = doc2.to<JsonObject>();
-
-    array[0] = obj;
-
-    REQUIRE(obj == array[0].as<JsonObject>());
-    REQUIRE(true == array[0].is<JsonObject>());
-    REQUIRE(false == array[0].is<int>());
-  }
-
-  SECTION("array subscript") {
-    DynamicJsonDocument doc2(4096);
-    JsonArray arr2 = doc2.to<JsonArray>();
-    const char* str = "hello";
-
-    arr2.add(str);
-
-    array[0] = arr2[0];
-
-    REQUIRE(str == array[0]);
-  }
-
-  SECTION("object subscript") {
-    const char* str = "hello";
-    DynamicJsonDocument doc2(4096);
-    JsonObject obj = doc2.to<JsonObject>();
-
-    obj["x"] = str;
-
-    array[0] = obj["x"];
-
-    REQUIRE(str == array[0]);
-  }
-
-  SECTION("should not duplicate const char*") {
-    array[0] = "world";
-    const size_t expectedSize = JSON_ARRAY_SIZE(1);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate char*") {
-    array[0] = const_cast<char*>("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("should duplicate std::string") {
-    array[0] = std::string("world");
-    const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5);
-    REQUIRE(expectedSize == doc.memoryUsage());
-  }
-
-  SECTION("array[0].to<JsonObject>()") {
-    JsonObject obj = array[0].to<JsonObject>();
-    REQUIRE(obj.isNull() == false);
-  }
-
-#ifdef HAS_VARIABLE_LENGTH_ARRAY
-  SECTION("set(VLA)") {
-    int i = 16;
-    char vla[i];
-    strcpy(vla, "world");
-
-    array.add("hello");
-    array[0].set(vla);
-
-    REQUIRE(std::string("world") == array[0]);
-  }
-
-  SECTION("operator=(VLA)") {
-    int i = 16;
-    char vla[i];
-    strcpy(vla, "world");
-
-    array.add("hello");
-    array[0] = vla;
-
-    REQUIRE(std::string("world") == array[0]);
-  }
-#endif
-}
-
-TEST_CASE("JsonArrayConst::operator[]") {
-  DynamicJsonDocument doc(4096);
-  JsonArray array = doc.to<JsonArray>();
-  array.add(0);
-
-  SECTION("int") {
-    array[0] = 123;
-    JsonArrayConst carr = array;
-
-    REQUIRE(123 == carr[0].as<int>());
-    REQUIRE(true == carr[0].is<int>());
-    REQUIRE(false == carr[0].is<bool>());
-  }
-}

extras/tests/JsonArray/undefined.cpp

@@ -1,35 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2020
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-
-using namespace Catch::Matchers;
-
-TEST_CASE("Undefined JsonArray") {
-  JsonArray array;
-
-  SECTION("SubscriptFails") {
-    REQUIRE(array[0].isNull());
-  }
-
-  SECTION("AddFails") {
-    array.add(1);
-    REQUIRE(0 == array.size());
-  }
-
-  SECTION("CreateNestedArrayFails") {
-    REQUIRE(array.createNestedArray().isNull());
-  }
-
-  SECTION("CreateNestedObjectFails") {
-    REQUIRE(array.createNestedObject().isNull());
-  }
-
-  SECTION("PrintToWritesBrackets") {
-    char buffer[32];
-    serializeJson(array, buffer, sizeof(buffer));
-    REQUIRE_THAT(buffer, Equals("null"));
-  }
-}