[ { "path": ".clang-format", "content": "# http://clang.llvm.org/docs/ClangFormatStyleOptions.html\n\nBasedOnStyle: Google\nStandard: c++11\nAllowShortFunctionsOnASingleLine: Empty\nIncludeBlocks: Preserve\nIndentPPDirectives: AfterHash\nDerivePointerAlignment: false\n\n# Always break after if to get accurate coverage\nAllowShortIfStatementsOnASingleLine: false\nAllowShortLoopsOnASingleLine: false\n" }, { "path": ".devcontainer/clang10/devcontainer.json", "content": "{\n\t\"name\": \"Clang 10\",\n\t\"image\": \"conanio/clang10\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang10\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang11/devcontainer.json", "content": "{\n\t\"name\": \"Clang 11\",\n\t\"image\": \"conanio/clang11\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang11\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang13/Dockerfile", "content": "FROM ubuntu:22.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git clang-13 libc++-13-dev libc++abi-13-dev\nENV CC=clang-13 CXX=clang++-13\n" }, { "path": ".devcontainer/clang13/devcontainer.json", "content": "{\n\t\"name\": \"Clang 13\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\"\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang13\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang14/Dockerfile", "content": "FROM ubuntu:22.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git clang-14 libc++-14-dev libc++abi-14-dev\nENV CC=clang-14 CXX=clang++-14\n" }, { "path": ".devcontainer/clang14/devcontainer.json", "content": "{\n\t\"name\": \"Clang 14\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\"\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang14\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang15/Dockerfile", "content": "FROM ubuntu:22.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git clang-15 libc++-15-dev libc++abi-15-dev\nENV CC=clang-15 CXX=clang++-15\n" }, { "path": ".devcontainer/clang15/devcontainer.json", "content": "{\n\t\"name\": \"Clang 15\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\"\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang15\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang16/Dockerfile", "content": "FROM ubuntu:22.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git clang-16 libc++-16-dev libc++abi-16-dev\nENV CC=clang-16 CXX=clang++-16\n" }, { "path": ".devcontainer/clang16/devcontainer.json", "content": "{\n\t\"name\": \"Clang 16\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\"\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang16\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang17/Dockerfile", "content": "FROM ubuntu:24.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git clang-17 libc++-17-dev libc++abi-17-dev\nENV CC=clang-17 CXX=clang++-17\n" }, { "path": ".devcontainer/clang17/devcontainer.json", "content": "{\n\t\"name\": \"Clang 17\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\"\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang17\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang5/devcontainer.json", "content": "{\n\t\"name\": \"Clang 5\",\n\t\"image\": \"conanio/clang50\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang5\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang6/devcontainer.json", "content": "{\n\t\"name\": \"Clang 6\",\n\t\"image\": \"conanio/clang60\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang6\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang7/devcontainer.json", "content": "{\n\t\"name\": \"Clang 7\",\n\t\"image\": \"conanio/clang7\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang7\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang8/devcontainer.json", "content": "{\n\t\"name\": \"Clang 8\",\n\t\"image\": \"conanio/clang8\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang8\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/clang9/devcontainer.json", "content": "{\n\t\"name\": \"Clang 9\",\n\t\"image\": \"conanio/clang9\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-clang9\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc10/devcontainer.json", "content": "{\n\t\"name\": \"GCC 10\",\n\t\"image\": \"conanio/gcc10\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc10\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc11/devcontainer.json", "content": "{\n\t\"name\": \"GCC 11\",\n\t\"image\": \"conanio/gcc11\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc11\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc12/Dockerfile", "content": "FROM ubuntu:22.04\n\nRUN apt-get update\nRUN apt-get install -y cmake git g++-12\n" }, { "path": ".devcontainer/gcc12/devcontainer.json", "content": "{\n\t\"name\": \"GCC 12\",\n\t\"build\": {\n\t\t\"dockerfile\": \"Dockerfile\",\n\t},\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc12\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc48/devcontainer.json", "content": "{\n\t\"name\": \"GCC 4.8\",\n\t\"image\": \"conanio/gcc48\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc48\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\",\n\t\t\t\t\"josetr.cmake-language-support-vscode\",\n\t\t\t\t\"ms-vscode.cpptools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc5/devcontainer.json", "content": "{\n\t\"name\": \"GCC 5\",\n\t\"image\": \"conanio/gcc5\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc5\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc6/devcontainer.json", "content": "{\n\t\"name\": \"GCC 6\",\n\t\"image\": \"conanio/gcc6\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc6\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc7/devcontainer.json", "content": "{\n\t\"name\": \"GCC 7\",\n\t\"image\": \"conanio/gcc7\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc7\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc8/devcontainer.json", "content": "{\n\t\"name\": \"GCC 8\",\n\t\"image\": \"conanio/gcc8\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc8\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".devcontainer/gcc9/devcontainer.json", "content": "{\n\t\"name\": \"GCC 9\",\n\t\"image\": \"conanio/gcc9\",\n\t\"runArgs\": [\n\t\t\"--name=ArduinoJson-gcc9\"\n\t],\n\t\"customizations\": {\n\t\t\"vscode\": {\n\t\t\t\"extensions\": [\n\t\t\t\t\"ms-vscode.cmake-tools\"\n\t\t\t],\n\t\t\t\"settings\": {\n\t\t\t\t\"cmake.generator\": \"Unix Makefiles\",\n\t\t\t\t\"cmake.buildDirectory\": \"/tmp/build\"\n\t\t\t}\n\t\t}\n\t}\n}\n" }, { "path": ".gitattributes", "content": "* text=auto\n*.sh text eol=lf\n" }, { "path": ".github/FUNDING.yml", "content": "github: bblanchon\ncustom:\n - https://arduinojson.org/book/\n - https://donate.benoitblanchon.fr/\n" }, { "path": ".github/ISSUE_TEMPLATE/bug_report.md", "content": "---\nname: 🐛 Bug report\nabout: Report a bug in ArduinoJson\ntitle: ''\nlabels: 'bug'\nassignees: ''\n---\n\n\n\n**Describe the bug** \nA clear and concise description of what the bug is.\n\n**Troubleshooter report** \nHere is the report generated by the [ArduinoJson Troubleshooter](https://arduinojson.org/v7/troubleshooter/): \n[Paste the report here]\n\n**Environment** \nHere is the environment that I used:\n* Microcontroller: [e.g. ESP8266]\n* Core/runtime: [e.g. ESP8266 core for Arduino v3.0.2]\n* IDE: [e.g. Arduino IDE 1.8.16]\n\n**Reproduction** \nHere is a small snippet that reproduces the issue.\n\n```c++\nJsonDocument doc;\n\nDeserializationError error = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n\n[insert repro code here]\n```\n\n**Compiler output** \nIf relevant, include the complete compiler output (i.e. not just the line that contains the error.)\n\n\n**Program output** \nIf relevant, include the repro program output.\n\nExpected output:\n\n```\n[insert expected output here]\n```\n\nActual output:\n\n```\n[insert actual output here]\n```\n" }, { "path": ".github/ISSUE_TEMPLATE/config.yml", "content": "blank_issues_enabled: true\ncontact_links:\n - name: 👨‍🏫 ArduinoJson Assistant\n url: https://arduinojson.org/v7/assistant/\n about: An online tool that computes memory requirements and generates scaffolding code for your project.\n - name: 👨‍⚕️ ArduinoJson Troubleshooter\n url: https://arduinojson.org/v7/troubleshooter/\n about: An online tool that helps you diagnose the most common issues with ArduinoJson.\n" }, { "path": ".github/ISSUE_TEMPLATE/feature_request.md", "content": "---\nname: 💡 Feature request\nabout: Suggest an idea for ArduinoJson\ntitle: ''\nlabels: enhancement\nassignees: ''\n---\n\n**Is your feature request related to a problem? Please describe.** \nA clear and concise description of what the problem is. Ex. I'm always frustrated when [...]\n\n**Describe the solution you'd like** \nA clear and concise description of what you want to happen.\n\n**Describe alternatives you've considered** \nA clear and concise description of any alternative solutions or features you've considered.\n\n**Additional context** \nAdd any other context or screenshots about the feature request here.\n" }, { "path": ".github/ISSUE_TEMPLATE/help.md", "content": "---\nname: 😭 Help!\nabout: Ask for help\ntitle: ''\nlabels: 'question'\nassignees: ''\n---\n\n\n\n**Describe the issue** \nA clear and concise description of what you're trying to do.\nYou don't need to explain every aspect of your project: focus on the problem you're having.\n\n**Troubleshooter report** \nHere is the report generated by the [ArduinoJson Troubleshooter](https://arduinojson.org/v7/troubleshooter/): \n[Paste the report here]\n\n**Environment** \nHere is the environment that I'm using':\n* Microconroller: [e.g. ESP8266]\n* Core/runtime: [e.g. ESP8266 core for Arduino v3.0.2]\n* IDE: [e.g. Arduino IDE 1.8.16]\n\n**Reproduction** \nHere is a small snippet that demonstrate the problem.\n\n```c++\nJsonDocument doc;\n\nDeserializationError error = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n\n// insert code here\n```\n\n**Program output** \nIf relevant, include the program output.\n\nExpected output:\n\n```\n[insert expected output here]\n```\n\nActual output:\n\n```\n[insert actual output here]\n```\n" }, { "path": ".github/workflows/ci.yml", "content": "name: Continuous Integration\n\non: [push, pull_request]\n\nconcurrency:\n group: ${{ github.workflow }}-${{ github.ref }}\n cancel-in-progress: true\n\njobs:\n lint:\n name: Lint\n runs-on: ubuntu-22.04\n steps:\n - name: Install\n run: sudo apt-get install -y clang-format\n - name: Checkout\n uses: actions/checkout@v4\n - name: Symlinks\n run: find * -type l -printf \"::error::%p is a symlink. This is forbidden by the Arduino Library Specification.\" -exec false {} +\n - name: Clang-format\n run: |\n find src/ extras/ -name '*.[ch]pp' | xargs clang-format -i --verbose --style=file\n git diff --exit-code\n - name: Check URLs\n run: |\n grep -hREo \"(http|https)://[a-zA-Z0-9./?=_%:-]*\" src/ | sort -u | while read -r URL\n do\n STATUS=$(curl -s -o /dev/null -I -w \"%{http_code}\" \"$URL\")\n [ \"$STATUS\" -ge 400 ] && echo \"::warning title=HTTP $STATUS::$URL returned $STATUS\"\n done || true\n\n gcc:\n name: GCC\n needs: lint\n runs-on: ubuntu-22.04\n strategy:\n fail-fast: false\n matrix:\n include:\n - gcc: \"4.8\"\n - gcc: \"5\"\n - gcc: \"6\"\n - gcc: \"7\"\n cxxflags: -fsanitize=leak -fno-sanitize-recover=all\n - gcc: \"8\"\n cxxflags: -fsanitize=undefined -fno-sanitize-recover=all\n - gcc: \"9\"\n cxxflags: -fsanitize=address -fno-sanitize-recover=all\n - gcc: \"10\"\n cxxflags: -funsigned-char # Issue #1715\n - gcc: \"11\"\n - gcc: \"12\"\n steps:\n - name: Workaround for actions/runner-images#9491\n run: sudo sysctl vm.mmap_rnd_bits=28\n\n - name: Install\n run: |\n sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys 40976EAF437D05B5 3B4FE6ACC0B21F32\n sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ xenial main universe'\n sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ bionic main universe'\n sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ focal main universe'\n sudo apt-get update\n sudo apt-get install -y gcc-${{ matrix.gcc }} g++-${{ matrix.gcc }}\n timeout-minutes: 5\n\n - name: Checkout\n uses: actions/checkout@v4\n timeout-minutes: 1\n\n - name: Configure\n run: cmake -DCMAKE_BUILD_TYPE=Debug .\n env:\n CC: gcc-${{ matrix.gcc }}\n CXX: g++-${{ matrix.gcc }}\n CXXFLAGS: ${{ matrix.cxxflags }}\n timeout-minutes: 1\n\n - name: Build\n run: cmake --build .\n timeout-minutes: 10\n\n - name: Test\n run: ctest --output-on-failure -C Debug .\n env:\n UBSAN_OPTIONS: print_stacktrace=1\n timeout-minutes: 2\n\n clang:\n name: Clang\n needs: lint\n strategy:\n fail-fast: false\n matrix:\n include:\n - clang: \"7\"\n runner: ubuntu-22.04\n archive: focal\n - clang: \"8\"\n cxxflags: -fsanitize=leak -fno-sanitize-recover=all\n runner: ubuntu-22.04\n archive: focal\n - clang: \"9\"\n cxxflags: -fsanitize=undefined -fno-sanitize-recover=all\n runner: ubuntu-22.04\n archive: focal\n - clang: \"10\"\n cxxflags: -fsanitize=address -fno-sanitize-recover=all\n runner: ubuntu-22.04\n archive: focal\n - clang: \"11\"\n runner: ubuntu-22.04\n - clang: \"12\"\n runner: ubuntu-22.04\n - clang: \"13\"\n runner: ubuntu-22.04\n - clang: 14\n - clang: 15\n - clang: 16\n - clang: 17\n - clang: 18\n - clang: 19\n runs-on: ${{ matrix.runner || 'ubuntu-latest' }}\n steps:\n - name: Add archive repositories\n if: matrix.archive\n run: |\n sudo gpg --keyserver keyserver.ubuntu.com --recv-keys 3B4FE6ACC0B21F32\n sudo gpg --export 3B4FE6ACC0B21F32 | sudo tee /etc/apt/trusted.gpg.d/ubuntu-keyring.gpg > /dev/null\n sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ ${{ matrix.archive }} main'\n sudo add-apt-repository -yn 'deb http://archive.ubuntu.com/ubuntu/ ${{ matrix.archive }} universe'\n - name: Install Clang ${{ matrix.clang }}\n run: |\n sudo apt-get update\n sudo apt-get install -y clang-${{ matrix.clang }}\n - name: Install libc++ ${{ matrix.clang }}\n run: sudo apt-get install -y libc++-${{ matrix.clang }}-dev libc++abi-${{ matrix.clang }}-dev\n - name: Install libunwind ${{ matrix.clang }}\n if: matrix.clang == 12 # dependency is missing in Ubuntu 22.04\n run: sudo apt-get install -y libunwind-${{ matrix.clang }}-dev\n - name: Checkout\n uses: actions/checkout@v4\n - name: Configure\n run: cmake -DCMAKE_BUILD_TYPE=Debug .\n env:\n CC: clang-${{ matrix.clang }}\n CXX: clang++-${{ matrix.clang }}\n CXXFLAGS: >-\n ${{ matrix.cxxflags }}\n ${{ matrix.clang < 11 && '-I/usr/lib/llvm-10/include/c++/v1/' || '' }}\n - name: Build\n run: cmake --build .\n - name: Test\n run: ctest --output-on-failure -C Debug .\n env:\n UBSAN_OPTIONS: print_stacktrace=1\n\n conf_test:\n name: Test configuration on Linux\n needs: [gcc, clang]\n runs-on: ubuntu-22.04\n steps:\n - name: Install\n run: |\n sudo apt-get update\n sudo apt-get install -y g++-multilib gcc-avr avr-libc\n - name: Checkout\n uses: actions/checkout@v4\n - name: AVR\n run: avr-g++ -std=c++11 -Isrc extras/conf_test/avr.cpp\n - name: GCC 32-bit\n run: g++ -std=c++11 -m32 -Isrc extras/conf_test/x86.cpp\n - name: GCC 64-bit\n run: g++ -std=c++11 -m64 -Isrc extras/conf_test/x64.cpp\n - name: Clang 32-bit\n run: clang++ -std=c++11 -m32 -Isrc extras/conf_test/x86.cpp\n - name: Clang 64-bit\n run: clang++ -std=c++11 -m64 -Isrc extras/conf_test/x64.cpp\n\n conf_test_windows:\n name: Test configuration on Windows\n runs-on: windows-2022\n needs: [gcc, clang]\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: 32-bit\n run: |\n call \"C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars32.bat\"\n cl /Isrc extras/conf_test/x86.cpp\n shell: cmd\n - name: 64-bit\n run: |\n call \"C:\\Program Files\\Microsoft Visual Studio\\2022\\Enterprise\\VC\\Auxiliary\\Build\\vcvars64.bat\"\n cl /Isrc extras/conf_test/x64.cpp\n shell: cmd\n\n xcode:\n name: XCode\n needs: clang\n runs-on: macos-26\n strategy:\n fail-fast: false\n matrix:\n include:\n - xcode: \"26.0\"\n - xcode: \"26.1\"\n - xcode: \"26.2\"\n - xcode: \"26.3\"\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Select XCode version\n run: sudo xcode-select --switch /Applications/Xcode_${{ matrix.xcode }}.app\n - name: Configure\n run: cmake -DCMAKE_BUILD_TYPE=Debug .\n - name: Build\n run: cmake --build .\n - name: Test\n run: ctest --output-on-failure -C Debug .\n\n # DISABLED: Running on AppVeyor instead because it supports older versions of the compiler\n # msvc:\n # name: Visual Studio\n # strategy:\n # fail-fast: false\n # matrix:\n # include:\n # - os: windows-2016\n # - os: windows-2019\n # runs-on: ${{ matrix.os }}\n # steps:\n # - name: Checkout\n # uses: actions/checkout@v4\n # - name: Configure\n # run: cmake -DCMAKE_BUILD_TYPE=Debug .\n # - name: Build\n # run: cmake --build .\n # - name: Test\n # run: ctest --output-on-failure -C Debug .\n\n arduino:\n name: Arduino\n needs: gcc\n strategy:\n fail-fast: false\n matrix:\n include:\n - core: arduino:avr\n board: arduino:avr:uno\n - core: arduino:samd\n board: arduino:samd:mkr1000\n runs-on: ubuntu-22.04\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Install arduino-cli\n run: curl -fsSL https://raw.githubusercontent.com/arduino/arduino-cli/master/install.sh | BINDIR=/usr/local/bin sh\n - name: Install core\n run: arduino-cli core install ${{ matrix.core }}\n - name: Install libraries\n run: arduino-cli lib install SD Ethernet\n - name: Build JsonConfigFile\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonConfigFile/JsonConfigFile.ino\"\n - name: Build JsonFilterExample\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonFilterExample/JsonFilterExample.ino\"\n - name: Build JsonGeneratorExample\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonGeneratorExample/JsonGeneratorExample.ino\"\n - name: Build JsonHttpClient\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonHttpClient/JsonHttpClient.ino\"\n - name: Build JsonParserExample\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonParserExample/JsonParserExample.ino\"\n - name: Build JsonServer\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonServer/JsonServer.ino\"\n - name: Build JsonUdpBeacon\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/JsonUdpBeacon/JsonUdpBeacon.ino\"\n - name: Build MsgPackParser\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/MsgPackParser/MsgPackParser.ino\"\n - name: Build ProgmemExample\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/ProgmemExample/ProgmemExample.ino\"\n - name: Build StringExample\n run: arduino-cli compile --library . --warnings all -b ${{ matrix.board }} \"examples/StringExample/StringExample.ino\"\n\n platformio:\n name: PlatformIO\n needs: gcc\n runs-on: ubuntu-latest\n strategy:\n fail-fast: false\n matrix:\n include:\n - platform: atmelavr\n board: leonardo\n libraries:\n - SD\n - Ethernet\n conf_test: avr\n - platform: espressif8266\n board: huzzah\n conf_test: esp8266\n - platform: espressif32\n board: esp32dev\n libraries:\n - Ethernet\n conf_test: esp8266\n - platform: atmelsam\n board: mkr1000USB\n libraries:\n - SD\n - Ethernet\n conf_test: esp8266\n - platform: teensy\n board: teensy31\n conf_test: esp8266\n - platform: ststm32\n board: adafruit_feather_f405\n libraries:\n - SD\n - Ethernet\n conf_test: esp8266\n - platform: nordicnrf52\n board: adafruit_feather_nrf52840\n libraries:\n - SD\n - Ethernet\n conf_test: esp8266\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Set up cache for pip\n uses: actions/cache@v4\n with:\n path: ~/.cache/pip\n key: ${{ runner.os }}-pip\n - name: Set up Python 3.x\n uses: actions/setup-python@v5\n with:\n python-version: \"3.x\"\n - name: Install PlatformIO\n run: pip install platformio\n - name: Install adafruit-nrfutil\n if: ${{ matrix.platform == 'nordicnrf52' }}\n run: pip install adafruit-nrfutil\n - name: Include Adafruit_TinyUSB.h # https://github.com/adafruit/Adafruit_nRF52_Arduino/issues/653\n if: ${{ matrix.platform == 'nordicnrf52' }}\n run: find examples/ -name '*.ino' -exec sed -i 's/\\(#include \\)/\\1\\n#include /' {} +\n - name: Set up cache for platformio\n uses: actions/cache@v4\n with:\n path: ~/.platformio\n key: ${{ runner.os }}-platformio-${{ matrix.platform }}\n - name: Install platform \"${{ matrix.platform }}\"\n run: platformio platform install ${{ matrix.platform }}\n - name: Install libraries\n if: ${{ matrix.libraries }}\n run: platformio lib install arduino-libraries/${{ join(matrix.libraries, ' arduino-libraries/') }}\n - name: Test configuration\n run: platformio ci \"extras/conf_test/${{ matrix.conf_test }}.cpp\" -l '.' -b ${{ matrix.board }}\n if: ${{ matrix.conf_test }}\n - name: Build JsonConfigFile\n run: platformio ci \"examples/JsonConfigFile/JsonConfigFile.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonFilterExample\n run: platformio ci \"examples/JsonFilterExample/JsonFilterExample.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonGeneratorExample\n run: platformio ci \"examples/JsonGeneratorExample/JsonGeneratorExample.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonHttpClient\n run: platformio ci \"examples/JsonHttpClient/JsonHttpClient.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonParserExample\n run: platformio ci \"examples/JsonParserExample/JsonParserExample.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonServer\n if: ${{ matrix.platform != 'espressif32' }}\n run: platformio ci \"examples/JsonServer/JsonServer.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build JsonUdpBeacon\n run: platformio ci \"examples/JsonUdpBeacon/JsonUdpBeacon.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build MsgPackParser\n run: platformio ci \"examples/MsgPackParser/MsgPackParser.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build ProgmemExample\n run: platformio ci \"examples/ProgmemExample/ProgmemExample.ino\" -l '.' -b ${{ matrix.board }}\n - name: Build StringExample\n run: platformio ci \"examples/StringExample/StringExample.ino\" -l '.' -b ${{ matrix.board }}\n - name: PlatformIO prune\n if: ${{ always() }}\n run: platformio system prune -f\n\n particle:\n name: Particle\n needs: gcc\n runs-on: ubuntu-latest\n if: github.event_name == 'push'\n strategy:\n fail-fast: false\n matrix:\n include:\n - board: argon\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Install Particle CLI\n run: |\n bash <( curl -sL https://particle.io/install-cli )\n echo \"$HOME/bin\" >> $GITHUB_PATH\n - name: Login to Particle\n run: particle login -t \"${{ secrets.PARTICLE_TOKEN }}\"\n - name: Compile\n run: extras/ci/particle.sh ${{ matrix.board }}\n\n arm:\n name: GCC for ARM processor\n needs: gcc\n runs-on: ubuntu-22.04\n steps:\n - name: Install\n run: |\n sudo apt-get update\n sudo apt-get install -y g++-arm-linux-gnueabihf\n - name: Checkout\n uses: actions/checkout@v4\n - name: Configure\n run: cmake .\n env:\n CC: arm-linux-gnueabihf-gcc\n CXX: arm-linux-gnueabihf-g++\n - name: Build\n run: cmake --build .\n\n coverage:\n needs: gcc\n name: Coverage\n runs-on: ubuntu-22.04\n steps:\n - name: Install\n run: sudo apt-get install -y lcov ninja-build\n - name: Checkout\n uses: actions/checkout@v4\n - name: Configure\n run: cmake -G Ninja -DCOVERAGE=true .\n - name: Build\n run: ninja\n - name: Test\n run: ctest --output-on-failure -LE 'WillFail|Fuzzing' -T test\n - name: lcov --capture\n run: lcov --capture --no-external --directory . --output-file coverage.info\n - name: lcov --remove\n run: lcov --remove coverage.info \"$(pwd)/extras/*\" --output-file coverage_filtered.info\n - name: genhtml\n run: mkdir coverage && genhtml coverage_filtered.info -o coverage -t ArduinoJson\n - name: Upload HTML report\n uses: actions/upload-artifact@v4\n with:\n name: Coverage report\n path: coverage\n - name: Upload to Coveralls\n uses: coverallsapp/github-action@v2\n with:\n github-token: ${{ secrets.GITHUB_TOKEN }}\n path-to-lcov: coverage_filtered.info\n\n valgrind:\n needs: gcc\n name: Valgrind\n runs-on: ubuntu-22.04\n steps:\n - name: Install\n run: |\n sudo apt-get update\n sudo apt-get install -y valgrind ninja-build\n - name: Checkout\n uses: actions/checkout@v4\n - name: Configure\n run: cmake -G Ninja -D MEMORYCHECK_COMMAND_OPTIONS=\"--error-exitcode=1 --leak-check=full\" .\n - name: Build\n run: ninja\n - name: Memcheck\n run: ctest --output-on-failure -LE WillFail -T memcheck\n id: memcheck\n - name: MemoryChecker.*.log\n run: cat Testing/Temporary/MemoryChecker.*.log > $GITHUB_STEP_SUMMARY\n if: failure()\n\n clang-tidy:\n needs: clang\n name: Clang-Tidy\n runs-on: ubuntu-latest\n steps:\n - name: Install\n run: sudo apt-get install -y clang-tidy libc++-dev libc++abi-dev\n - name: Checkout\n uses: actions/checkout@v4\n - name: Configure\n run: cmake -G Ninja -DCMAKE_CXX_CLANG_TIDY=\"clang-tidy;--warnings-as-errors=*\" -DCMAKE_BUILD_TYPE=Debug .\n env:\n CC: clang\n CXX: clang++\n - name: Check\n run: cmake --build . -- -k 0\n\n amalgamate:\n needs: gcc\n name: Amalgamate ArduinoJson.h\n runs-on: ubuntu-22.04\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Setup\n run: |\n if [[ $GITHUB_REF == refs/tags/* ]]; then\n VERSION=${GITHUB_REF#refs/tags/}\n else\n VERSION=${GITHUB_SHA::7}\n fi\n echo \"ARDUINOJSON_H=ArduinoJson-$VERSION.h\" >> $GITHUB_ENV\n echo \"ARDUINOJSON_HPP=ArduinoJson-$VERSION.hpp\" >> $GITHUB_ENV\n - name: Amalgamate ArduinoJson.h\n run: extras/scripts/build-single-header.sh \"src/ArduinoJson.h\" \"$ARDUINOJSON_H\"\n - name: Amalgamate ArduinoJson.hpp\n run: extras/scripts/build-single-header.sh \"src/ArduinoJson.hpp\" \"$ARDUINOJSON_HPP\"\n - name: Upload artifact\n uses: actions/upload-artifact@v4\n with:\n name: Single headers\n path: |\n ${{ env.ARDUINOJSON_H }}\n ${{ env.ARDUINOJSON_HPP }}\n - name: Smoke test ArduinoJson.h\n run: |\n g++ -x c++ - <> $GITHUB_OUTPUT\n echo \"version=${GITHUB_REF#refs/tags/v}\" >> $GITHUB_OUTPUT\n - name: Checkout\n uses: actions/checkout@v4\n - name: Write release body\n id: body\n run: |\n FILENAME=RELEASE.md\n tee $FILENAME <> $GITHUB_OUTPUT\n - name: Amalgamate ArduinoJson.h\n id: amalgamate_h\n run: |\n FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.h\n extras/scripts/build-single-header.sh src/ArduinoJson.h \"$FILENAME\"\n echo \"filename=$FILENAME\" >> $GITHUB_OUTPUT\n - name: Amalgamate ArduinoJson.hpp\n id: amalgamate_hpp\n run: |\n FILENAME=ArduinoJson-${{ steps.init.outputs.tag }}.hpp\n extras/scripts/build-single-header.sh src/ArduinoJson.hpp \"$FILENAME\"\n echo \"filename=$FILENAME\" >> $GITHUB_OUTPUT\n - name: Create release\n uses: ncipollo/release-action@v1\n with:\n bodyFile: ${{ steps.body.outputs.filename }}\n name: ArduinoJson ${{ steps.init.outputs.version }}\n artifacts: ${{ steps.amalgamate_h.outputs.filename }},${{ steps.amalgamate_hpp.outputs.filename }}\n token: ${{ secrets.GITHUB_TOKEN }}\n\n idf:\n name: IDF Component Registry\n runs-on: ubuntu-latest\n steps:\n - name: Checkout\n uses: actions/checkout@v4\n - name: Upload component to the component registry\n uses: espressif/upload-components-ci-action@v1\n with:\n name: ArduinoJson\n namespace: bblanchon\n api_token: ${{ secrets.IDF_COMPONENT_API_TOKEN }}\n\n particle:\n name: Particle\n runs-on: ubuntu-latest\n steps:\n - name: Install\n run: npm install -g particle-cli\n - name: Checkout\n uses: actions/checkout@v4\n - name: Login\n run: particle login --token ${{ secrets.PARTICLE_TOKEN }}\n - name: Publish\n run: bash -eux extras/scripts/publish-particle-library.sh\n\n platformio:\n name: PlatformIO\n runs-on: ubuntu-latest\n steps:\n - name: Set up Python 3.x\n uses: actions/setup-python@v5\n with:\n python-version: \"3.x\"\n - name: Install PlatformIO\n run: pip install platformio\n - name: Checkout\n uses: actions/checkout@v4\n - name: Publish\n run: pio pkg publish --no-interactive --no-notify\n env:\n PLATFORMIO_AUTH_TOKEN: ${{ secrets.PLATFORMIO_AUTH_TOKEN }}\n" }, { "path": ".gitignore", "content": ".DS_Store\n/.idea\n/build\n/bin\n/lib\n/sftp-config.json\n.tags\n.tags_sorted_by_file\n/extras/fuzzing/*_fuzzer\n/extras/fuzzing/*_fuzzer.options\n/extras/fuzzing/*_fuzzer_seed_corpus.zip\n.vs/\n/out/\n\n# Used by CI for Particle\n/src/*.ino\n/project.properties\n\n# Used by IDF\n/dist/\n" }, { "path": ".mbedignore", "content": ".devcontainer/\n.github/\nexamples/\nextras/\n" }, { "path": ".prettierignore", "content": "*.md\n" }, { "path": ".vscode/settings.json", "content": "{\n \"C_Cpp.default.configurationProvider\": \"ms-vscode.cmake-tools\",\n \"git.inputValidationLength\": 80,\n \"git.inputValidationSubjectLength\": 72,\n \"files.insertFinalNewline\": true,\n \"files.trimFinalNewlines\": true,\n \"search.exclude\": {\n \"/extras/tests/catch/*\": true\n },\n \"C_Cpp.default.includePath\": [\n \"/src\"\n ],\n \"[cmake]\": {\n \"editor.detectIndentation\": false,\n \"editor.insertSpaces\": false,\n }\n}\n" }, { "path": "ArduinoJson.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \"src/ArduinoJson.h\"\n" }, { "path": "CHANGELOG.md", "content": "ArduinoJson: change log\r\n=======================\r\n\r\nHEAD\r\n----\r\n\r\n* Don't store string literals by pointer anymore (issue #2189)\r\n Version 7.3 introduced a new way to detect string literals, but it fails in some edge cases.\r\n I could not find a way to fix it, so I chose to remove the optimization rather than keep it broken.\r\n* Replace the \"extension slots\" mechanism with a memory pool dedicated to 8-byte values.\r\n\r\n> ### BREAKING CHANGES\r\n>\r\n> #### `JsonString` constructor's boolean parameter\r\n>\r\n> Since version 7.3, you could pass a boolean to `JsonString`'s constructor to force the string to be stored by pointer.\r\n> This optimization has been removed, and you'll get a deprecation warning if you use it.\r\n> To fix the issue, you must remove the boolean argument from the constructor, or better yet, remove `JsonString` altogether.\r\n>\r\n> ```diff\r\n> char name[] = \"ArduinoJson\";\r\n> - doc[\"name\"] = JsonString(name, true);\r\n> + doc[\"name\"] = name;\r\n> ```\r\n>\r\n> #### NUL characters in string literals\r\n> \r\n> Since version 7.3, ArduinoJson has supported NUL characters (`\\0`) in string literals.\r\n> This feature has been removed as part of the storage policy change.\r\n>\r\n> If you do need to include NULs in your string, you must use a `JsonString` instead:\r\n>\r\n> ```diff\r\n> - doc[\"strings\"] = \"hello\\0world\"\r\n> + doc[\"strings\"] = JsonString(\"hello\\0world\", 11)\r\n> ```\r\n\r\nv7.4.3 (2026-03-02)\r\n------\r\n\r\n* Fix a buffer overrun in `as()` when `T` is a numeric type and\r\n the variant contains a string representing a floating point number\r\n with a large number of digits (issue #2220)\r\n\r\nv7.4.2 (2025-06-20)\r\n------\r\n\r\n* Fix truncated strings on Arduino Due (issue #2181)\r\n\r\nv7.4.1 (2025-04-11)\r\n------\r\n\r\n* Fix crash with tiny Flash strings (issue #2170)\r\n\r\nv7.4.0 (2025-04-09)\r\n------\r\n\r\n* Optimize storage of tiny strings (up to 3 characters)\r\n* Fix support for `const char[]` (issue #2166)\r\n\r\nv7.3.1 (2025-02-27)\r\n------\r\n\r\n* Fix conversion from static string to number\r\n* Slightly reduce code size\r\n\r\nv7.3.0 (2024-12-29)\r\n------\r\n\r\n* Fix support for NUL characters in `deserializeJson()`\r\n* Make `ElementProxy` and `MemberProxy` non-copyable\r\n* Change string copy policy: only string literal are stored by pointer\r\n* `JsonString` is now stored by copy, unless specified otherwise\r\n* Replace undocumented `JsonString::Ownership` with `bool`\r\n* Rename undocumented `JsonString::isLinked()` to `isStatic()`\r\n* Move public facing SFINAEs to template declarations\r\n\r\n> ### BREAKING CHANGES\r\n>\r\n> In previous versions, `MemberProxy` (the class returned by `operator[]`) could lead to dangling pointers when used with a temporary string.\r\n> To prevent this issue, `MemberProxy` and `ElementProxy` are now non-copyable.\r\n>\r\n> Your code is likely to be affected if you use `auto` to store the result of `operator[]`. For example, the following line won't compile anymore:\r\n>\r\n> ```cpp\r\n> auto value = doc[\"key\"];\r\n> ```\r\n>\r\n> To fix the issue, you must append either `.as()` or `.to()`, depending on the situation.\r\n>\r\n> For example, if you are extracting values from a JSON document, you should update like this:\r\n>\r\n> ```diff\r\n> - auto config = doc[\"config\"];\r\n> + auto config = doc[\"config\"].as();\r\n> const char* name = config[\"name\"];\r\n> ```\r\n>\r\n> However, if you are building a JSON document, you should update like this:\r\n>\r\n> ```diff\r\n> - auto config = doc[\"config\"];\r\n> + auto config = doc[\"config\"].to();\r\n> config[\"name\"] = \"ArduinoJson\";\r\n> ```\r\n\r\nv7.2.1 (2024-11-15)\r\n------\r\n\r\n* Forbid `deserializeJson(JsonArray|JsonObject, ...)` (issue #2135)\r\n* Fix VLA support in `JsonDocument::set()`\r\n* Fix `operator[](variant)` ignoring NUL characters\r\n\r\nv7.2.0 (2024-09-18)\r\n------\r\n\r\n* Store object members with two slots: one for the key and one for the value\r\n* Store 64-bit numbers (`double` and `long long`) in an additional slot\r\n* Reduce the slot size (see table below)\r\n* Improve message when user forgets third arg of `serializeJson()` et al.\r\n* Set `ARDUINOJSON_USE_DOUBLE` to `0` by default on 8-bit architectures\r\n* Deprecate `containsKey()` in favor of `doc[\"key\"].is()`\r\n* Add support for escape sequence `\\'` (issue #2124)\r\n\r\n| Architecture | before | after |\r\n|--------------|----------|----------|\r\n| 8-bit | 8 bytes | 6 bytes |\r\n| 32-bit | 16 bytes | 8 bytes |\r\n| 64-bit | 24 bytes | 16 bytes |\r\n\r\n> ### BREAKING CHANGES\r\n>\r\n> After being on the death row for years, the `containsKey()` method has finally been deprecated.\r\n> You should replace `doc.containsKey(\"key\")` with `doc[\"key\"].is()`, which not only checks that the key exists but also that the value is of the expected type.\r\n>\r\n> ```cpp\r\n> // Before\r\n> if (doc.containsKey(\"value\")) {\r\n> int value = doc[\"value\"];\r\n> // ...\r\n> }\r\n>\r\n> // After\r\n> if (doc[\"value\"].is()) {\r\n> int value = doc[\"value\"];\r\n> // ...\r\n> }\r\n> ```\r\n\r\nv7.1.0 (2024-06-27)\r\n------\r\n\r\n* Add `ARDUINOJSON_STRING_LENGTH_SIZE` to the namespace name\r\n* Add support for MsgPack binary (PR #2078 by @Sanae6)\r\n* Add support for MsgPack extension\r\n* Make string support even more generic (PR #2084 by @d-a-v)\r\n* Optimize `deserializeMsgPack()`\r\n* Allow using a `JsonVariant` as a key or index (issue #2080)\r\n Note: works only for reading, not for writing\r\n* Support `ElementProxy` and `MemberProxy` in `JsonDocument`'s constructor\r\n* Don't add partial objects when allocation fails (issue #2081)\r\n* Read MsgPack's 64-bit integers even if `ARDUINOJSON_USE_LONG_LONG` is `0`\r\n (they are set to `null` if they don't fit in a `long`)\r\n\r\nv7.0.4 (2024-03-12)\r\n------\r\n\r\n* Make `JSON_STRING_SIZE(N)` return `N+1` to fix third-party code (issue #2054)\r\n\r\nv7.0.3 (2024-02-05)\r\n------\r\n\r\n* Improve error messages when using `char` or `char*` (issue #2043)\r\n* Reduce stack consumption (issue #2046)\r\n* Fix compatibility with GCC 4.8 (issue #2045)\r\n\r\nv7.0.2 (2024-01-19)\r\n------\r\n\r\n* Fix assertion `poolIndex < count_` after `JsonDocument::clear()` (issue #2034)\r\n\r\nv7.0.1 (2024-01-10)\r\n------\r\n\r\n* Fix \"no matching function\" with `JsonObjectConst::operator[]` (issue #2019)\r\n* Remove unused files in the PlatformIO package\r\n* Fix `volatile bool` serialized as `1` or `0` instead of `true` or `false` (issue #2029)\r\n\r\nv7.0.0 (2024-01-03)\r\n------\r\n\r\n* Remove `BasicJsonDocument`\r\n* Remove `StaticJsonDocument`\r\n* Add abstract `Allocator` class\r\n* Merge `DynamicJsonDocument` with `JsonDocument`\r\n* Remove `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()`\r\n* Remove `ARDUINOJSON_ENABLE_STRING_DEDUPLICATION` (string deduplication cannot be disabled anymore)\r\n* Remove `JsonDocument::capacity()`\r\n* Store the strings in the heap\r\n* Reference-count shared strings\r\n* Always store `serialized(\"string\")` by copy (#1915)\r\n* Remove the zero-copy mode of `deserializeJson()` and `deserializeMsgPack()`\r\n* Fix double lookup in `to()`\r\n* Fix double call to `size()` in `serializeMsgPack()`\r\n* Include `ARDUINOJSON_SLOT_OFFSET_SIZE` in the namespace name\r\n* Remove `JsonVariant::shallowCopy()`\r\n* `JsonDocument`'s capacity grows as needed, no need to pass it to the constructor anymore\r\n* `JsonDocument`'s allocator is not monotonic anymore, removed values get recycled\r\n* Show a link to the documentation when user passes an unsupported input type\r\n* Remove `JsonDocument::memoryUsage()`\r\n* Remove `JsonDocument::garbageCollect()`\r\n* Add `deserializeJson(JsonVariant, ...)` and `deserializeMsgPack(JsonVariant, ...)` (#1226)\r\n* Call `shrinkToFit()` in `deserializeJson()` and `deserializeMsgPack()`\r\n* `serializeJson()` and `serializeMsgPack()` replace the content of `std::string` and `String` instead of appending to it\r\n* Replace `add()` with `add()` (`add(T)` is still supported)\r\n* Remove `createNestedArray()` and `createNestedObject()` (use `to()` and `to()` instead)\r\n\r\n> ### BREAKING CHANGES\r\n>\r\n> As every major release, ArduinoJson 7 introduces several breaking changes.\r\n> I added some stubs so that most existing programs should compile, but I highty recommend you upgrade your code.\r\n>\r\n> #### `JsonDocument`\r\n> \r\n> In ArduinoJson 6, you could allocate the memory pool on the stack (with `StaticJsonDocument`) or in the heap (with `DynamicJsonDocument`). \r\n> In ArduinoJson 7, the memory pool is always allocated in the heap, so `StaticJsonDocument` and `DynamicJsonDocument` have been merged into `JsonDocument`.\r\n>\r\n> In ArduinoJson 6, `JsonDocument` had a fixed capacity; in ArduinoJson 7, it has an elastic capacity that grows as needed.\r\n> Therefore, you don't need to specify the capacity anymore, so the macros `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()` have been removed.\r\n>\r\n> ```c++\r\n> // ArduinoJson 6\r\n> StaticJsonDocument<256> doc;\r\n> // or\r\n> DynamicJsonDocument doc(256);\r\n> \r\n> // ArduinoJson 7\r\n> JsonDocument doc;\r\n> ```\r\n>\r\n> In ArduinoJson 7, `JsonDocument` reuses released memory, so `garbageCollect()` has been removed. \r\n> `shrinkToFit()` is still available and releases the over-allocated memory.\r\n>\r\n> Due to a change in the implementation, it's not possible to store a pointer to a variant from another `JsonDocument`, so `shallowCopy()` has been removed.\r\n> \r\n> In ArduinoJson 6, the meaning of `memoryUsage()` was clear: it returned the number of bytes used in the memory pool. \r\n> In ArduinoJson 7, the meaning of `memoryUsage()` would be ambiguous, so it has been removed.\r\n>\r\n> #### Custom allocators\r\n>\r\n> In ArduinoJson 6, you could specify a custom allocator class as a template parameter of `BasicJsonDocument`. \r\n> In ArduinoJson 7, you must inherit from `ArduinoJson::Allocator` and pass a pointer to an instance of your class to the constructor of `JsonDocument`.\r\n>\r\n> ```c++\r\n> // ArduinoJson 6\r\n> class MyAllocator {\r\n> // ...\r\n> };\r\n> BasicJsonDocument doc(256);\r\n>\r\n> // ArduinoJson 7\r\n> class MyAllocator : public ArduinoJson::Allocator {\r\n> // ...\r\n> };\r\n> MyAllocator myAllocator;\r\n> JsonDocument doc(&myAllocator);\r\n> ```\r\n>\r\n> #### `createNestedArray()` and `createNestedObject()`\r\n>\r\n> In ArduinoJson 6, you could create a nested array or object with `createNestedArray()` and `createNestedObject()`. \r\n> In ArduinoJson 7, you must use `add()` or `to()` instead.\r\n>\r\n> For example, to create `[[],{}]`, you would write:\r\n>\r\n> ```c++\r\n> // ArduinoJson 6\r\n> arr.createNestedArray();\r\n> arr.createNestedObject();\r\n>\r\n> // ArduinoJson 7\r\n> arr.add();\r\n> arr.add();\r\n> ```\r\n>\r\n> And to create `{\"array\":[],\"object\":{}}`, you would write:\r\n>\r\n> ```c++\r\n> // ArduinoJson 6\r\n> obj.createNestedArray(\"array\");\r\n> obj.createNestedObject(\"object\");\r\n>\r\n> // ArduinoJson 7\r\n> obj[\"array\"].to();\r\n> obj[\"object\"].to();\r\n> ```\r\n" }, { "path": "CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\ncmake_minimum_required(VERSION 3.15)\n\nif(ESP_PLATFORM)\n\t# Build ArduinoJson as an ESP-IDF component\n\tidf_component_register(INCLUDE_DIRS src)\n\treturn()\nendif()\n\nproject(ArduinoJson VERSION 7.4.2)\n\nif(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME)\n\tinclude(CTest)\nendif()\n\nadd_subdirectory(src)\n\nif(CMAKE_PROJECT_NAME STREQUAL PROJECT_NAME AND BUILD_TESTING)\n\tinclude(extras/CompileOptions.cmake)\n\tadd_subdirectory(extras/tests)\n\tadd_subdirectory(extras/fuzzing)\nendif()\n" }, { "path": "CONTRIBUTING.md", "content": "# Contribution to ArduinoJson\n\nFirst, thank you for taking the time to contribute to this project.\n\nYou can submit changes via GitHub Pull Requests.\n\nPlease:\n\n1. Update the test suite for any change of behavior\n2. Use clang-format in \"file\" mode to format the code\n" }, { "path": "LICENSE.txt", "content": "The MIT License (MIT)\n---------------------\n\nCopyright © 2014-2025, Benoit BLANCHON\n\nPermission 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:\n\nThe above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\n" }, { "path": "README.md", "content": "

\r\n \"ArduinoJson\"\r\n

\r\n\r\n---\r\n\r\n[![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/bblanchon/ArduinoJson/ci.yml?branch=7.x&logo=github)](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22+branch%3A7.x)\r\n[![Continuous Integration](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/7.x?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/7.x)\r\n[![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)\r\n[![Coveralls branch](https://img.shields.io/coveralls/github/bblanchon/ArduinoJson/7.x?logo=coveralls)](https://coveralls.io/github/bblanchon/ArduinoJson?branch=7.x) \r\n[![GitHub stars](https://img.shields.io/github/stars/bblanchon/ArduinoJson?style=flat&logo=github&color=orange)](https://github.com/bblanchon/ArduinoJson/stargazers)\r\n[![GitHub Sponsors](https://img.shields.io/github/sponsors/bblanchon?logo=github&color=orange)](https://github.com/sponsors/bblanchon)\r\n\r\nArduinoJson is a C++ JSON library for Arduino and IoT (Internet Of Things).\r\n\r\n## Features\r\n\r\n* [JSON deserialization](https://arduinojson.org/v7/api/json/deserializejson/)\r\n * [Optionally decodes UTF-16 escape sequences to UTF-8](https://arduinojson.org/v7/api/config/decode_unicode/)\r\n * [Optionally supports comments in the input](https://arduinojson.org/v7/api/config/enable_comments/)\r\n * [Optionally filters the input to keep only desired values](https://arduinojson.org/v7/api/json/deserializejson/#filtering)\r\n * Supports single quotes as a string delimiter\r\n * Compatible with [NDJSON](http://ndjson.org/) and [JSON Lines](https://jsonlines.org/)\r\n* [JSON serialization](https://arduinojson.org/v7/api/json/serializejson/)\r\n * [Can write to a buffer or a stream](https://arduinojson.org/v7/api/json/serializejson/)\r\n * [Optionally indents the document (prettified JSON)](https://arduinojson.org/v7/api/json/serializejsonpretty/)\r\n* [MessagePack serialization](https://arduinojson.org/v7/api/msgpack/serializemsgpack/)\r\n* [MessagePack deserialization](https://arduinojson.org/v7/api/msgpack/deserializemsgpack/)\r\n* Efficient\r\n * [Twice smaller than the \"official\" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)\r\n * [Almost 10% faster than the \"official\" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)\r\n * [Consumes roughly 10% less RAM than the \"official\" Arduino_JSON library](https://arduinojson.org/2019/11/19/arduinojson-vs-arduino_json/)\r\n * [Deduplicates strings](https://arduinojson.org/news/2020/08/01/version-6-16-0/)\r\n* Versatile\r\n * Supports [custom allocators (to use external RAM chip, for example)](https://arduinojson.org/v7/how-to/use-external-ram-on-esp32/)\r\n * Supports [`String`](https://arduinojson.org/v7/api/config/enable_arduino_string/), [`std::string`](https://arduinojson.org/v7/api/config/enable_std_string/), and [`std::string_view`](https://arduinojson.org/v7/api/config/enable_string_view/)\r\n * Supports [`Stream`](https://arduinojson.org/v7/api/config/enable_arduino_stream/) and [`std::istream`/`std::ostream`](https://arduinojson.org/v7/api/config/enable_std_stream/)\r\n * Supports [Flash strings](https://arduinojson.org/v7/api/config/enable_progmem/)\r\n * Supports [custom readers](https://arduinojson.org/v7/api/json/deserializejson/#custom-reader) and [custom writers](https://arduinojson.org/v7/api/json/serializejson/#custom-writer)\r\n * Supports [custom converters](https://arduinojson.org/news/2021/05/04/version-6-18-0/)\r\n* Portable\r\n * Usable on any C++ project (not limited to Arduino)\r\n * Compatible with C++11, C++14 and C++17\r\n * Support for C++98/C++03 available on [ArduinoJson 6.20.x](https://github.com/bblanchon/ArduinoJson/tree/6.20.x)\r\n * Zero warnings with `-Wall -Wextra -pedantic` and `/W4`\r\n * [Header-only library](https://en.wikipedia.org/wiki/Header-only)\r\n * Works with virtually any board\r\n * 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)...\r\n * Espressif chips: [ESP8266](https://amzn.to/36YluV8), [ESP32](https://amzn.to/2G4pRCB)\r\n * Lolin (WeMos) boards: [D1 mini](https://amzn.to/2QUpz7q), [D1 Mini Pro](https://amzn.to/36UsGSs)...\r\n * Teensy boards: [4.0](https://amzn.to/30ljXGq), [3.2](https://amzn.to/2FT0EuC), [2.0](https://amzn.to/2QXUMXj)\r\n * Particle boards: [Argon](https://amzn.to/2FQHa9X), [Boron](https://amzn.to/36WgLUd), [Electron](https://amzn.to/30vEc4k), [Photon](https://amzn.to/387F9Cd)...\r\n * Texas Instruments boards: [MSP430](https://amzn.to/30nJWgg)...\r\n * Soft cores: [Nios II](https://en.wikipedia.org/wiki/Nios_II)...\r\n * Tested on all major development environments\r\n * [Arduino IDE](https://www.arduino.cc/en/Main/Software)\r\n * [Atmel Studio](http://www.atmel.com/microsite/atmel-studio/)\r\n * [Atollic TrueSTUDIO](https://atollic.com/truestudio/)\r\n * [Energia](http://energia.nu/)\r\n * [IAR Embedded Workbench](https://www.iar.com/iar-embedded-workbench/)\r\n * [Keil uVision](http://www.keil.com/)\r\n * [MPLAB X IDE](http://www.microchip.com/mplab/mplab-x-ide)\r\n * [Particle](https://www.particle.io/)\r\n * [PlatformIO](http://platformio.org/)\r\n * [Sloeber plugin for Eclipse](https://eclipse.baeyens.it/)\r\n * [Visual Micro](http://www.visualmicro.com/)\r\n * [Visual Studio](https://www.visualstudio.com/)\r\n * [Even works with online compilers like wandbox.org](https://wandbox.org/permlink/RlZSKy17DjJ6HcdN)\r\n * [CMake friendly](https://arduinojson.org/v7/how-to/use-arduinojson-with-cmake/)\r\n* Well designed\r\n * [Elegant API](http://arduinojson.org/v7/example/)\r\n * [Thread-safe](https://en.wikipedia.org/wiki/Thread_safety)\r\n * Self-contained (no external dependency)\r\n * `const` friendly\r\n * [`for` friendly](https://arduinojson.org/v7/api/jsonobject/begin_end/)\r\n * [TMP friendly](https://en.wikipedia.org/wiki/Template_metaprogramming)\r\n * Handles [integer overflows](https://arduinojson.org/v7/api/jsonvariant/as/#integer-overflows)\r\n* Well tested\r\n * [Unit test coverage close to 100%](https://coveralls.io/github/bblanchon/ArduinoJson?branch=7.x)\r\n * Continuously tested on\r\n * [Visual Studio 2017, 2019, 2022](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/7.x)\r\n * [GCC 4.8, 5, 6, 7, 8, 9, 10, 11, 12](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)\r\n * [Clang 7 to 19](https://github.com/bblanchon/ArduinoJson/actions?query=workflow%3A%22Continuous+Integration%22)\r\n * [Continuously fuzzed with Google OSS Fuzz](https://bugs.chromium.org/p/oss-fuzz/issues/list?sort=-opened&can=1&q=proj:arduinojson)\r\n * Passes all default checks of [clang-tidy](https://releases.llvm.org/10.0.0/tools/clang/tools/extra/docs/clang-tidy/)\r\n* Well documented\r\n * [Tutorials](https://arduinojson.org/v7/doc/deserialization/)\r\n * [Examples](https://arduinojson.org/v7/example/)\r\n * [How-tos](https://arduinojson.org/v7/example/)\r\n * [FAQ](https://arduinojson.org/v7/faq/)\r\n * [Troubleshooter](https://arduinojson.org/v7/troubleshooter/)\r\n * [Book](https://arduinojson.org/book/)\r\n * [Changelog](CHANGELOG.md)\r\n\r\n## Quickstart\r\n\r\n### Deserialization\r\n\r\nHere is a program that parses a JSON document with ArduinoJson.\r\n\r\n```c++\r\nconst char* json = \"{\\\"sensor\\\":\\\"gps\\\",\\\"time\\\":1351824120,\\\"data\\\":[48.756080,2.302038]}\";\r\n\r\nJsonDocument doc;\r\ndeserializeJson(doc, json);\r\n\r\nconst char* sensor = doc[\"sensor\"];\r\nlong time = doc[\"time\"];\r\ndouble latitude = doc[\"data\"][0];\r\ndouble longitude = doc[\"data\"][1];\r\n```\r\n\r\nSee the [tutorial on arduinojson.org](https://arduinojson.org/v7/doc/deserialization/)\r\n\r\n### Serialization\r\n\r\nHere is a program that generates a JSON document with ArduinoJson:\r\n\r\n```c++\r\nJsonDocument doc;\r\n\r\ndoc[\"sensor\"] = \"gps\";\r\ndoc[\"time\"] = 1351824120;\r\ndoc[\"data\"][0] = 48.756080;\r\ndoc[\"data\"][1] = 2.302038;\r\n\r\nserializeJson(doc, Serial);\r\n// This prints:\r\n// {\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}\r\n```\r\n\r\nSee the [tutorial on arduinojson.org](https://arduinojson.org/v7/doc/serialization/)\r\n\r\n## Sponsors\r\n\r\nArduinoJson is thankful to its sponsors. Please give them a visit; they deserve it!\r\n\r\n

\r\n \r\n \"1technophile\"\r\n \r\n \r\n \"LArkema\"\r\n \r\n

\r\n\r\nIf you run a commercial project that embeds ArduinoJson, think about [sponsoring the library's development](https://github.com/sponsors/bblanchon): it ensures the code that your products rely on stays actively maintained. It can also give your project some exposure to the makers' community.\r\n\r\nIf you are an individual user and want to support the development (or give a sign of appreciation), consider purchasing the book [Mastering ArduinoJson](https://arduinojson.org/book/) ❤, or simply [cast a star](https://github.com/bblanchon/ArduinoJson/stargazers) ⭐.\r\n" }, { "path": "SUPPORT.md", "content": "# ArduinoJson Support\n\nFirst off, thank you very much for using ArduinoJson.\n\nWe'll be very happy to help you, but first please read the following.\n\n## Before asking for help\n\n1. Read the [FAQ](https://arduinojson.org/faq/?utm_source=github&utm_medium=support)\n2. Search in the [API Reference](https://arduinojson.org/api/?utm_source=github&utm_medium=support)\n\nIf you did not find the answer, please create a [new issue on GitHub](https://github.com/bblanchon/ArduinoJson/issues/new).\n\nIt is OK to add a comment to a currently opened issue, but please avoid adding comments to a closed issue.\n\n## Before hitting the Submit button\n\nPlease provide all the relevant information:\n\n* Good title\n* Short description of the problem\n* Target platform\n* Compiler model and version\n* [MVCE](https://stackoverflow.com/help/mcve)\n* Compiler output\n\nGood questions get fast answers!\n" }, { "path": "appveyor.yml", "content": "version: 7.4.2.{build}\nenvironment:\n matrix:\n - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2022\n CMAKE_GENERATOR: Visual Studio 17 2022\n - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019\n CMAKE_GENERATOR: Visual Studio 16 2019\n - APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017\n CMAKE_GENERATOR: Visual Studio 15 2017\n - CMAKE_GENERATOR: Ninja\n MINGW32: i686-6.3.0-posix-dwarf-rt_v5-rev1 # MinGW-w64 6.3.0 i686\n - CMAKE_GENERATOR: Ninja\n MINGW64: x86_64-6.3.0-posix-seh-rt_v5-rev1 # MinGW-w64 6.3.0 x86_64\n - CMAKE_GENERATOR: Ninja\n MINGW64: x86_64-7.3.0-posix-seh-rt_v5-rev0 # MinGW-w64 7.3.0 x86_64\n - CMAKE_GENERATOR: Ninja\n MINGW64: x86_64-8.1.0-posix-seh-rt_v6-rev0 # MinGW-w64 8.1.0 x86_64\nconfiguration: Debug\nbefore_build:\n - set PATH=%PATH:C:\\Program Files\\Git\\usr\\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW\n - if defined MINGW set PATH=C:\\%MINGW%\\bin;%PATH%\n - if defined MINGW32 set PATH=C:\\mingw-w64\\%MINGW32%\\mingw32\\bin;%PATH%\n - if defined MINGW64 set PATH=C:\\mingw-w64\\%MINGW64%\\mingw64\\bin;%PATH%\n - cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G \"%CMAKE_GENERATOR%\" .\nbuild_script:\n - cmake --build . --config %CONFIGURATION%\ntest_script:\n - ctest -C %CONFIGURATION% --output-on-failure .\n" }, { "path": "component.mk", "content": "COMPONENT_ADD_INCLUDEDIRS := src\n" }, { "path": "examples/JsonConfigFile/JsonConfigFile.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to store your project configuration in a file.\n// It uses the SD library but can be easily modified for any other file-system.\n//\n// The file contains a JSON document with the following content:\n// {\n// \"hostname\": \"examples.com\",\n// \"port\": 2731\n// }\n//\n// To run this program, you need an SD card connected to the SPI bus as follows:\n// * MOSI <-> pin 11\n// * MISO <-> pin 12\n// * CLK <-> pin 13\n// * CS <-> pin 4\n//\n// https://arduinojson.org/v7/example/config/\n\n#include \n#include \n#include \n\n// Our configuration structure.\nstruct Config {\n char hostname[64];\n int port;\n};\n\nconst char* filename = \"/config.txt\"; // <- SD library uses 8.3 filenames\nConfig config; // <- global configuration object\n\n// Loads the configuration from a file\nvoid loadConfiguration(const char* filename, Config& config) {\n // Open file for reading\n File file = SD.open(filename);\n\n // Allocate a temporary JsonDocument\n JsonDocument doc;\n\n // Deserialize the JSON document\n DeserializationError error = deserializeJson(doc, file);\n if (error)\n Serial.println(F(\"Failed to read file, using default configuration\"));\n\n // Copy values from the JsonDocument to the Config\n config.port = doc[\"port\"] | 2731;\n strlcpy(config.hostname, // <- destination\n doc[\"hostname\"] | \"example.com\", // <- source\n sizeof(config.hostname)); // <- destination's capacity\n\n // Close the file (Curiously, File's destructor doesn't close the file)\n file.close();\n}\n\n// Saves the configuration to a file\nvoid saveConfiguration(const char* filename, const Config& config) {\n // Delete existing file, otherwise the configuration is appended to the file\n SD.remove(filename);\n\n // Open file for writing\n File file = SD.open(filename, FILE_WRITE);\n if (!file) {\n Serial.println(F(\"Failed to create file\"));\n return;\n }\n\n // Allocate a temporary JsonDocument\n JsonDocument doc;\n\n // Set the values in the document\n doc[\"hostname\"] = config.hostname;\n doc[\"port\"] = config.port;\n\n // Serialize JSON to file\n if (serializeJson(doc, file) == 0) {\n Serial.println(F(\"Failed to write to file\"));\n }\n\n // Close the file\n file.close();\n}\n\n// Prints the content of a file to the Serial\nvoid printFile(const char* filename) {\n // Open file for reading\n File file = SD.open(filename);\n if (!file) {\n Serial.println(F(\"Failed to read file\"));\n return;\n }\n\n // Extract each characters by one by one\n while (file.available()) {\n Serial.print((char)file.read());\n }\n Serial.println();\n\n // Close the file\n file.close();\n}\n\nvoid setup() {\n // Initialize serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // Initialize SD library\n const int chipSelect = 4;\n while (!SD.begin(chipSelect)) {\n Serial.println(F(\"Failed to initialize SD library\"));\n delay(1000);\n }\n\n // Should load default config if run for the first time\n Serial.println(F(\"Loading configuration...\"));\n loadConfiguration(filename, config);\n\n // Create configuration file\n Serial.println(F(\"Saving configuration...\"));\n saveConfiguration(filename, config);\n\n // Dump config file\n Serial.println(F(\"Print config file...\"));\n printFile(filename);\n}\n\nvoid loop() {\n // not used in this example\n}\n\n// Performance issue?\n// ------------------\n//\n// File is an unbuffered stream, which is not optimal for ArduinoJson.\n// See: https://arduinojson.org/v7/how-to/improve-speed/\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any\n// serialization or deserialization problem.\n//\n// The book \"Mastering ArduinoJson\" contains a case study of a project that has\n// a complex configuration with nested members.\n// Contrary to this example, the project in the book uses the SPIFFS filesystem.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/JsonFilterExample/JsonFilterExample.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to use DeserializationOption::Filter\n//\n// https://arduinojson.org/v7/example/filter/\n\n#include \n\nvoid setup() {\n // Initialize serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // The huge input: an extract from OpenWeatherMap response\n auto input_json = F(\n \"{\\\"cod\\\":\\\"200\\\",\\\"message\\\":0,\\\"list\\\":[{\\\"dt\\\":1581498000,\\\"main\\\":{\"\n \"\\\"temp\\\":3.23,\\\"feels_like\\\":-3.63,\\\"temp_min\\\":3.23,\\\"temp_max\\\":4.62,\"\n \"\\\"pressure\\\":1014,\\\"sea_level\\\":1014,\\\"grnd_level\\\":1010,\\\"humidity\\\":\"\n \"58,\\\"temp_kf\\\":-1.39},\\\"weather\\\":[{\\\"id\\\":800,\\\"main\\\":\\\"Clear\\\",\"\n \"\\\"description\\\":\\\"clear \"\n \"sky\\\",\\\"icon\\\":\\\"01d\\\"}],\\\"clouds\\\":{\\\"all\\\":0},\\\"wind\\\":{\\\"speed\\\":6.\"\n \"19,\\\"deg\\\":266},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-12 \"\n \"09:00:00\\\"},{\\\"dt\\\":1581508800,\\\"main\\\":{\\\"temp\\\":6.09,\\\"feels_like\\\":-\"\n \"1.07,\\\"temp_min\\\":6.09,\\\"temp_max\\\":7.13,\\\"pressure\\\":1015,\\\"sea_\"\n \"level\\\":1015,\\\"grnd_level\\\":1011,\\\"humidity\\\":48,\\\"temp_kf\\\":-1.04},\"\n \"\\\"weather\\\":[{\\\"id\\\":800,\\\"main\\\":\\\"Clear\\\",\\\"description\\\":\\\"clear \"\n \"sky\\\",\\\"icon\\\":\\\"01d\\\"}],\\\"clouds\\\":{\\\"all\\\":9},\\\"wind\\\":{\\\"speed\\\":6.\"\n \"64,\\\"deg\\\":268},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-12 \"\n \"12:00:00\\\"}],\\\"city\\\":{\\\"id\\\":2643743,\\\"name\\\":\\\"London\\\",\\\"coord\\\":{\"\n \"\\\"lat\\\":51.5085,\\\"lon\\\":-0.1257},\\\"country\\\":\\\"GB\\\",\\\"population\\\":\"\n \"1000000,\\\"timezone\\\":0,\\\"sunrise\\\":1581492085,\\\"sunset\\\":1581527294}}\");\n\n // The filter: it contains \"true\" for each value we want to keep\n JsonDocument filter;\n filter[\"list\"][0][\"dt\"] = true;\n filter[\"list\"][0][\"main\"][\"temp\"] = true;\n\n // Deserialize the document\n JsonDocument doc;\n deserializeJson(doc, input_json, DeserializationOption::Filter(filter));\n\n // Print the result\n serializeJsonPretty(doc, Serial);\n}\n\nvoid loop() {\n // not used in this example\n}\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any\n// deserialization problem.\n//\n// The book \"Mastering ArduinoJson\" contains a tutorial on deserialization.\n// It begins with a simple example, like the one above, and then adds more\n// features like deserializing directly from a file or an HTTP request.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/JsonGeneratorExample/JsonGeneratorExample.ino", "content": "// ArduinoJson - https://arduinojson.org\r\n// Copyright © 2014-2025, Benoit BLANCHON\r\n// MIT License\r\n//\r\n// This example shows how to generate a JSON document with ArduinoJson.\r\n//\r\n// https://arduinojson.org/v7/example/generator/\r\n\r\n#include \r\n\r\nvoid setup() {\r\n // Initialize Serial port\r\n Serial.begin(9600);\r\n while (!Serial)\r\n continue;\r\n\r\n // Allocate the JSON document\r\n JsonDocument doc;\r\n\r\n // Add values in the document\r\n doc[\"sensor\"] = \"gps\";\r\n doc[\"time\"] = 1351824120;\r\n\r\n // Add an array\r\n JsonArray data = doc[\"data\"].to();\r\n data.add(48.756080);\r\n data.add(2.302038);\r\n\r\n // Generate the minified JSON and send it to the Serial port\r\n serializeJson(doc, Serial);\r\n // The above line prints:\r\n // {\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}\r\n\r\n // Start a new line\r\n Serial.println();\r\n\r\n // Generate the prettified JSON and send it to the Serial port\r\n serializeJsonPretty(doc, Serial);\r\n // The above line prints:\r\n // {\r\n // \"sensor\": \"gps\",\r\n // \"time\": 1351824120,\r\n // \"data\": [\r\n // 48.756080,\r\n // 2.302038\r\n // ]\r\n // }\r\n}\r\n\r\nvoid loop() {\r\n // not used in this example\r\n}\r\n\r\n// See also\r\n// --------\r\n//\r\n// https://arduinojson.org/ contains the documentation for all the functions\r\n// used above. It also includes an FAQ that will help you solve any\r\n// serialization problem.\r\n//\r\n// The book \"Mastering ArduinoJson\" contains a tutorial on serialization.\r\n// It begins with a simple example, like the one above, and then adds more\r\n// features like serializing directly to a file or an HTTP request.\r\n// Learn more at https://arduinojson.org/book/\r\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\r\n" }, { "path": "examples/JsonHttpClient/JsonHttpClient.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to parse a JSON document in an HTTP response.\n// It uses the Ethernet library, but can be easily adapted for Wifi.\n//\n// It performs a GET resquest on https://arduinojson.org/example.json\n// Here is the expected response:\n// {\n// \"sensor\": \"gps\",\n// \"time\": 1351824120,\n// \"data\": [\n// 48.756080,\n// 2.302038\n// ]\n// }\n//\n// https://arduinojson.org/v7/example/http-client/\n\n#include \n#include \n#include \n\nvoid setup() {\n // Initialize Serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // Initialize Ethernet library\n byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};\n if (!Ethernet.begin(mac)) {\n Serial.println(F(\"Failed to configure Ethernet\"));\n return;\n }\n delay(1000);\n\n Serial.println(F(\"Connecting...\"));\n\n // Connect to HTTP server\n EthernetClient client;\n client.setTimeout(10000);\n if (!client.connect(\"arduinojson.org\", 80)) {\n Serial.println(F(\"Connection failed\"));\n return;\n }\n\n Serial.println(F(\"Connected!\"));\n\n // Send HTTP request\n client.println(F(\"GET /example.json HTTP/1.0\"));\n client.println(F(\"Host: arduinojson.org\"));\n client.println(F(\"Connection: close\"));\n if (client.println() == 0) {\n Serial.println(F(\"Failed to send request\"));\n client.stop();\n return;\n }\n\n // Check HTTP status\n char status[32] = {0};\n client.readBytesUntil('\\r', status, sizeof(status));\n // It should be \"HTTP/1.0 200 OK\" or \"HTTP/1.1 200 OK\"\n if (strcmp(status + 9, \"200 OK\") != 0) {\n Serial.print(F(\"Unexpected response: \"));\n Serial.println(status);\n client.stop();\n return;\n }\n\n // Skip HTTP headers\n char endOfHeaders[] = \"\\r\\n\\r\\n\";\n if (!client.find(endOfHeaders)) {\n Serial.println(F(\"Invalid response\"));\n client.stop();\n return;\n }\n\n // Allocate the JSON document\n JsonDocument doc;\n\n // Parse JSON object\n DeserializationError error = deserializeJson(doc, client);\n if (error) {\n Serial.print(F(\"deserializeJson() failed: \"));\n Serial.println(error.f_str());\n client.stop();\n return;\n }\n\n // Extract values\n Serial.println(F(\"Response:\"));\n Serial.println(doc[\"sensor\"].as());\n Serial.println(doc[\"time\"].as());\n Serial.println(doc[\"data\"][0].as(), 6);\n Serial.println(doc[\"data\"][1].as(), 6);\n\n // Disconnect\n client.stop();\n}\n\nvoid loop() {\n // not used in this example\n}\n\n// Performance issue?\n// ------------------\n//\n// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.\n// See: https://arduinojson.org/v7/how-to/improve-speed/\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any\n// serialization problem.\n//\n// The book \"Mastering ArduinoJson\" contains a tutorial on deserialization\n// showing how to parse the response from GitHub's API. In the last chapter,\n// it shows how to parse the huge documents from OpenWeatherMap\n// and Reddit.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/JsonParserExample/JsonParserExample.ino", "content": "// ArduinoJson - https://arduinojson.org\r\n// Copyright © 2014-2025, Benoit BLANCHON\r\n// MIT License\r\n//\r\n// This example shows how to deserialize a JSON document with ArduinoJson.\r\n//\r\n// https://arduinojson.org/v7/example/parser/\r\n\r\n#include \r\n\r\nvoid setup() {\r\n // Initialize serial port\r\n Serial.begin(9600);\r\n while (!Serial)\r\n continue;\r\n\r\n // Allocate the JSON document\r\n JsonDocument doc;\r\n\r\n // JSON input string.\r\n const char* json =\r\n \"{\\\"sensor\\\":\\\"gps\\\",\\\"time\\\":1351824120,\\\"data\\\":[48.756080,2.302038]}\";\r\n\r\n // Deserialize the JSON document\r\n DeserializationError error = deserializeJson(doc, json);\r\n\r\n // Test if parsing succeeds\r\n if (error) {\r\n Serial.print(F(\"deserializeJson() failed: \"));\r\n Serial.println(error.f_str());\r\n return;\r\n }\r\n\r\n // Fetch the values\r\n //\r\n // Most of the time, you can rely on the implicit casts.\r\n // In other case, you can do doc[\"time\"].as();\r\n const char* sensor = doc[\"sensor\"];\r\n long time = doc[\"time\"];\r\n double latitude = doc[\"data\"][0];\r\n double longitude = doc[\"data\"][1];\r\n\r\n // Print the values\r\n Serial.println(sensor);\r\n Serial.println(time);\r\n Serial.println(latitude, 6);\r\n Serial.println(longitude, 6);\r\n}\r\n\r\nvoid loop() {\r\n // not used in this example\r\n}\r\n\r\n// See also\r\n// --------\r\n//\r\n// https://arduinojson.org/ contains the documentation for all the functions\r\n// used above. It also includes an FAQ that will help you solve any\r\n// deserialization problem.\r\n//\r\n// The book \"Mastering ArduinoJson\" contains a tutorial on deserialization.\r\n// It begins with a simple example, like the one above, and then adds more\r\n// features like deserializing directly from a file or an HTTP request.\r\n// Learn more at https://arduinojson.org/book/\r\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\r\n" }, { "path": "examples/JsonServer/JsonServer.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to implement an HTTP server that sends a JSON document\n// in the response.\n// It uses the Ethernet library but can be easily adapted for Wifi.\n//\n// The JSON document contains the values of the analog and digital pins.\n// It looks like that:\n// {\n// \"analog\": [0, 76, 123, 158, 192, 205],\n// \"digital\": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]\n// }\n//\n// https://arduinojson.org/v7/example/http-server/\n\n#include \n#include \n#include \n\nbyte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};\nEthernetServer server(80);\n\nvoid setup() {\n // Initialize serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // Initialize Ethernet libary\n if (!Ethernet.begin(mac)) {\n Serial.println(F(\"Failed to initialize Ethernet library\"));\n return;\n }\n\n // Start to listen\n server.begin();\n\n Serial.println(F(\"Server is ready.\"));\n Serial.print(F(\"Please connect to http://\"));\n Serial.println(Ethernet.localIP());\n}\n\nvoid loop() {\n // Wait for an incomming connection\n EthernetClient client = server.available();\n\n // Do we have a client?\n if (!client)\n return;\n\n Serial.println(F(\"New client\"));\n\n // Read the request (we ignore the content in this example)\n while (client.available())\n client.read();\n\n // Allocate a temporary JsonDocument\n JsonDocument doc;\n\n // Create the \"analog\" array\n JsonArray analogValues = doc[\"analog\"].to();\n for (int pin = 0; pin < 6; pin++) {\n // Read the analog input\n int value = analogRead(pin);\n\n // Add the value at the end of the array\n analogValues.add(value);\n }\n\n // Create the \"digital\" array\n JsonArray digitalValues = doc[\"digital\"].to();\n for (int pin = 0; pin < 14; pin++) {\n // Read the digital input\n int value = digitalRead(pin);\n\n // Add the value at the end of the array\n digitalValues.add(value);\n }\n\n Serial.print(F(\"Sending: \"));\n serializeJson(doc, Serial);\n Serial.println();\n\n // Write response headers\n client.println(F(\"HTTP/1.0 200 OK\"));\n client.println(F(\"Content-Type: application/json\"));\n client.println(F(\"Connection: close\"));\n client.print(F(\"Content-Length: \"));\n client.println(measureJsonPretty(doc));\n client.println();\n\n // Write JSON document\n serializeJsonPretty(doc, client);\n\n // Disconnect\n client.stop();\n}\n\n// Performance issue?\n// ------------------\n//\n// EthernetClient is an unbuffered stream, which is not optimal for ArduinoJson.\n// See: https://arduinojson.org/v7/how-to/improve-speed/\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any\n// serialization problem.\n//\n// The book \"Mastering ArduinoJson\" contains a tutorial on serialization.\n// It begins with a simple example, then adds more features like serializing\n// directly to a file or an HTTP client.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/JsonUdpBeacon/JsonUdpBeacon.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to send a JSON document to a UDP socket.\n// At regular interval, it sends a UDP packet that contains the status of\n// analog and digital pins.\n// It looks like that:\n// {\n// \"analog\": [0, 76, 123, 158, 192, 205],\n// \"digital\": [1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0]\n// }\n//\n// If you want to test this program, you need to be able to receive the UDP\n// packets.\n// For example, you can run netcat on your computer\n// $ ncat -ulp 8888\n// See https://nmap.org/ncat/\n//\n// https://arduinojson.org/v7/example/udp-beacon/\n\n#include \n#include \n#include \n\nbyte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};\nIPAddress remoteIp(192, 168, 0, 108); // <- EDIT!!!!\nunsigned short remotePort = 8888;\nunsigned short localPort = 8888;\nEthernetUDP udp;\n\nvoid setup() {\n // Initialize serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // Initialize Ethernet libary\n if (!Ethernet.begin(mac)) {\n Serial.println(F(\"Failed to initialize Ethernet library\"));\n return;\n }\n\n // Enable UDP\n udp.begin(localPort);\n}\n\nvoid loop() {\n // Allocate a temporary JsonDocument\n JsonDocument doc;\n\n // Create the \"analog\" array\n JsonArray analogValues = doc[\"analog\"].to();\n for (int pin = 0; pin < 6; pin++) {\n // Read the analog input\n int value = analogRead(pin);\n\n // Add the value at the end of the array\n analogValues.add(value);\n }\n\n // Create the \"digital\" array\n JsonArray digitalValues = doc[\"digital\"].to();\n for (int pin = 0; pin < 14; pin++) {\n // Read the digital input\n int value = digitalRead(pin);\n\n // Add the value at the end of the array\n digitalValues.add(value);\n }\n\n // Log\n Serial.print(F(\"Sending to \"));\n Serial.print(remoteIp);\n Serial.print(F(\" on port \"));\n Serial.println(remotePort);\n serializeJson(doc, Serial);\n\n // Send UDP packet\n udp.beginPacket(remoteIp, remotePort);\n serializeJson(doc, udp);\n udp.println();\n udp.endPacket();\n\n // Wait\n delay(10000);\n}\n\n// Performance issue?\n// ------------------\n//\n// EthernetUDP is an unbuffered stream, which is not optimal for ArduinoJson.\n// See: https://arduinojson.org/v7/how-to/improve-speed/\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any\n// serialization problem.\n//\n// The book \"Mastering ArduinoJson\" contains a tutorial on serialization.\n// It begins with a simple example, then adds more features like serializing\n// directly to a file or any stream.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/MsgPackParser/MsgPackParser.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to deserialize a MessagePack document with\n// ArduinoJson.\n//\n// https://arduinojson.org/v7/example/msgpack-parser/\n\n#include \n\nvoid setup() {\n // Initialize serial port\n Serial.begin(9600);\n while (!Serial)\n continue;\n\n // Allocate the JSON document\n JsonDocument doc;\n\n // The MessagePack input string\n uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,\n 164, 116, 105, 109, 101, 206, 80, 147, 50, 248, 164, 100,\n 97, 116, 97, 146, 203, 64, 72, 96, 199, 58, 188, 148,\n 112, 203, 64, 2, 106, 146, 230, 33, 49, 169};\n // This MessagePack document contains:\n // {\n // \"sensor\": \"gps\",\n // \"time\": 1351824120,\n // \"data\": [48.75608, 2.302038]\n // }\n\n // Parse the input\n DeserializationError error = deserializeMsgPack(doc, input);\n\n // Test if parsing succeeded\n if (error) {\n Serial.print(\"deserializeMsgPack() failed: \");\n Serial.println(error.f_str());\n return;\n }\n\n // Fetch the values\n //\n // Most of the time, you can rely on the implicit casts.\n // In other case, you can do doc[\"time\"].as();\n const char* sensor = doc[\"sensor\"];\n long time = doc[\"time\"];\n double latitude = doc[\"data\"][0];\n double longitude = doc[\"data\"][1];\n\n // Print the values\n Serial.println(sensor);\n Serial.println(time);\n Serial.println(latitude, 6);\n Serial.println(longitude, 6);\n}\n\nvoid loop() {\n // not used in this example\n}\n" }, { "path": "examples/ProgmemExample/ProgmemExample.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows the different ways you can use Flash strings with\n// ArduinoJson.\n//\n// Use Flash strings sparingly, because ArduinoJson duplicates them in the\n// JsonDocument. Prefer plain old char*, as they are more efficient in term of\n// code size, speed, and memory usage.\n//\n// https://arduinojson.org/v7/example/progmem/\n\n#include \n\nvoid setup() {\n JsonDocument doc;\n\n // You can use a Flash String as your JSON input.\n // WARNING: the strings in the input will be duplicated in the JsonDocument.\n deserializeJson(doc, F(\"{\\\"sensor\\\":\\\"gps\\\",\\\"time\\\":1351824120,\"\n \"\\\"data\\\":[48.756080,2.302038]}\"));\n\n // You can use a Flash String as a key to get a member from JsonDocument\n // No duplication is done.\n long time = doc[F(\"time\")];\n\n // You can use a Flash String as a key to set a member of a JsonDocument\n // WARNING: the content of the Flash String will be duplicated in the\n // JsonDocument.\n doc[F(\"time\")] = time;\n\n // You can set a Flash String as the content of a JsonVariant\n // WARNING: the content of the Flash String will be duplicated in the\n // JsonDocument.\n doc[\"sensor\"] = F(\"gps\");\n\n // It works with serialized() too:\n doc[\"sensor\"] = serialized(F(\"\\\"gps\\\"\"));\n doc[\"sensor\"] = serialized(F(\"\\xA3gps\"), 3);\n\n // You can compare the content of a JsonVariant to a Flash String\n if (doc[\"sensor\"] == F(\"gps\")) {\n // ...\n }\n}\n\nvoid loop() {\n // not used in this example\n}\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any memory\n// problem.\n//\n// The book \"Mastering ArduinoJson\" contains a quick C++ course that explains\n// how your microcontroller stores strings in memory. It also tells why you\n// should not abuse Flash strings with ArduinoJson.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "examples/StringExample/StringExample.ino", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows the different ways you can use String with ArduinoJson.\n//\n// Use String objects sparingly, because ArduinoJson duplicates them in the\n// JsonDocument. Prefer plain old char[], as they are more efficient in term of\n// code size, speed, and memory usage.\n//\n// https://arduinojson.org/v7/example/string/\n\n#include \n\nvoid setup() {\n JsonDocument doc;\n\n // You can use a String as your JSON input.\n // WARNING: the string in the input will be duplicated in the JsonDocument.\n String input =\n \"{\\\"sensor\\\":\\\"gps\\\",\\\"time\\\":1351824120,\\\"data\\\":[48.756080,2.302038]}\";\n deserializeJson(doc, input);\n\n // You can use a String as a key to get a member from JsonDocument\n // No duplication is done.\n long time = doc[String(\"time\")];\n\n // You can use a String as a key to set a member of a JsonDocument\n // WARNING: the content of the String will be duplicated in the JsonDocument.\n doc[String(\"time\")] = time;\n\n // You can get the content of a JsonVariant as a String\n // No duplication is done, at least not in the JsonDocument.\n String sensor = doc[\"sensor\"];\n\n // Unfortunately, the following doesn't work (issue #118):\n // sensor = doc[\"sensor\"]; // <- error \"ambiguous overload for 'operator='\"\n // As a workaround, you need to replace by:\n sensor = doc[\"sensor\"].as();\n\n // You can set a String as the content of a JsonVariant\n // WARNING: the content of the String will be duplicated in the JsonDocument.\n doc[\"sensor\"] = sensor;\n\n // It works with serialized() too:\n doc[\"sensor\"] = serialized(sensor);\n\n // You can also concatenate strings\n // WARNING: the content of the String will be duplicated in the JsonDocument.\n doc[String(\"sen\") + \"sor\"] = String(\"gp\") + \"s\";\n\n // You can compare the content of a JsonObject with a String\n if (doc[\"sensor\"] == sensor) {\n // ...\n }\n\n // Lastly, you can print the resulting JSON to a String\n String output;\n serializeJson(doc, output);\n}\n\nvoid loop() {\n // not used in this example\n}\n\n// See also\n// --------\n//\n// https://arduinojson.org/ contains the documentation for all the functions\n// used above. It also includes an FAQ that will help you solve any problem.\n//\n// The book \"Mastering ArduinoJson\" contains a quick C++ course that explains\n// how your microcontroller stores strings in memory. On several occasions, it\n// shows how you can avoid String in your program.\n// Learn more at https://arduinojson.org/book/\n// Use the coupon code TWENTY for a 20% discount ❤❤❤❤❤\n" }, { "path": "extras/ArduinoJsonConfig.cmake.in", "content": "@PACKAGE_INIT@\n\ninclude(\"${CMAKE_CURRENT_LIST_DIR}/@PROJECT_NAME@Targets.cmake\")\ncheck_required_components(\"@PROJECT_NAME@\")\n" }, { "path": "extras/CompileOptions.cmake", "content": "if(NOT DEFINED COVERAGE)\n\tset(COVERAGE OFF)\nendif()\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"(GNU|Clang)\")\n\tadd_compile_options(\n\t\t-pedantic\n\t\t-Wall\n\t\t-Wcast-align\n\t\t-Wcast-qual\n\t\t-Wconversion\n\t\t-Wctor-dtor-privacy\n\t\t-Wdisabled-optimization\n\t\t-Werror\n\t\t-Wextra\n\t\t-Wformat=2\n\t\t-Winit-self\n\t\t-Wmissing-include-dirs\n\t\t-Wnon-virtual-dtor\n\t\t-Wold-style-cast\n\t\t-Woverloaded-virtual\n\t\t-Wparentheses\n\t\t-Wredundant-decls\n\t\t-Wshadow\n\t\t-Wsign-conversion\n\t\t-Wsign-promo\n\t\t-Wstrict-aliasing\n\t\t-Wundef\n\t)\n\n\tif(${COVERAGE})\n\t\tset(CMAKE_CXX_FLAGS \"-fprofile-arcs -ftest-coverage\")\n\tendif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\")\n\tif((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.9) AND(NOT ${COVERAGE}))\n\t\tadd_compile_options(-g -Og)\n\telse() # GCC 4.8\n\t\tadd_compile_options(\n\t\t\t-g\n\t\t\t-O0 # GCC 4.8 doesn't support -Og\n\t\t\t-Wno-shadow # allow the same name for a function parameter and a member functions\n\t\t\t-Wp,-w # Disable preprocessing warnings (see below)\n\t\t)\n\t\t# GCC 4.8 doesn't support __has_include, so we need to help him\n\t\tadd_definitions(\n\t\t\t-DARDUINOJSON_ENABLE_STD_STRING=1\n\t\t\t-DARDUINOJSON_ENABLE_STD_STREAM=1\n\t\t)\n\tendif()\n\n\tadd_compile_options(\n\t\t-Wstrict-null-sentinel\n\t\t-Wno-vla # Allow VLA in tests\n\t)\n\tadd_definitions(-DHAS_VARIABLE_LENGTH_ARRAY)\n\n\tif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)\n\t\tadd_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy\n\tendif()\n\n\tif(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)\n\t\tadd_compile_options(-Wnoexcept)\n\tendif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n\tadd_compile_options(\n\t\t-Wc++11-compat\n\t\t-Wdeprecated-register\n\t\t-Wno-vla-extension # Allow VLA in tests\n\t)\n\tadd_definitions(\n\t\t-DHAS_VARIABLE_LENGTH_ARRAY\n\t\t-DSUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR\n\t)\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\")\n\tadd_compile_options(-stdlib=libc++)\n\tlink_libraries(c++ m)\n\n\tif((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.0) AND(NOT ${COVERAGE}))\n\t\tadd_compile_options(-g -Og)\n\telse()\n\t\tadd_compile_options(-g -O0)\n\tendif()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"AppleClang\")\n\tif((CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 9.0) AND(NOT ${COVERAGE}))\n\t\tadd_compile_options(-g -Og)\n\telse()\n\t\tadd_compile_options(-g -O0)\n\tendif()\nendif()\n\nif(MSVC)\n\tadd_definitions(-D_CRT_SECURE_NO_WARNINGS)\n\tadd_compile_options(\n\t\t/W4 # Set warning level\n\t\t/WX # Treats all compiler warnings as errors.\n\t\t/Zc:__cplusplus # Enable updated __cplusplus macro\n\t)\nendif()\n\nif(MINGW)\n\t# Static link on MinGW to avoid linking with the wrong DLLs when multiple\n\t# versions are installed.\n\tadd_link_options(-static)\nendif()\n" }, { "path": "extras/ci/espidf/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\ncmake_minimum_required(VERSION 3.5)\n\ninclude($ENV{IDF_PATH}/tools/cmake/project.cmake)\nproject(example)\n" }, { "path": "extras/ci/espidf/main/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nidf_component_register(\n\tSRCS \"main.cpp\"\n\tINCLUDE_DIRS \"\"\n)\n" }, { "path": "extras/ci/espidf/main/component.mk", "content": "#\n# \"main\" pseudo-component makefile.\n#\n# (Uses default behaviour of compiling all source files in directory, adding 'include' to include path.)\n" }, { "path": "extras/ci/espidf/main/main.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\nextern \"C\" void app_main() {\n char buffer[256];\n JsonDocument doc;\n\n doc[\"hello\"] = \"world\";\n serializeJson(doc, buffer);\n deserializeJson(doc, buffer);\n serializeMsgPack(doc, buffer);\n deserializeMsgPack(doc, buffer);\n}\n" }, { "path": "extras/ci/particle.sh", "content": "#!/bin/sh -ex\n\nBOARD=$1\n\ncd \"$(dirname \"$0\")/../../\"\n\ncp extras/particle/src/smocktest.ino src/\ncp extras/particle/project.properties ./\n\nparticle compile \"$BOARD\"\n" }, { "path": "extras/conf_test/avr.cpp", "content": "#include \n\nstatic_assert(ARDUINOJSON_ENABLE_PROGMEM == 1, \"ARDUINOJSON_ENABLE_PROGMEM\");\n\nstatic_assert(ARDUINOJSON_USE_LONG_LONG == 0, \"ARDUINOJSON_USE_LONG_LONG\");\n\nstatic_assert(ARDUINOJSON_SLOT_ID_SIZE == 1, \"ARDUINOJSON_SLOT_ID_SIZE\");\n\nstatic_assert(ARDUINOJSON_POOL_CAPACITY == 16, \"ARDUINOJSON_POOL_CAPACITY\");\n\nstatic_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, \"ARDUINOJSON_LITTLE_ENDIAN\");\n\nstatic_assert(ARDUINOJSON_USE_DOUBLE == 0, \"ARDUINOJSON_USE_DOUBLE\");\n\nstatic_assert(sizeof(ArduinoJson::detail::VariantData) == 6, \"slot size\");\n\nvoid setup() {}\nvoid loop() {}\n" }, { "path": "extras/conf_test/esp8266.cpp", "content": "#include \n\nstatic_assert(ARDUINOJSON_USE_LONG_LONG == 1, \"ARDUINOJSON_USE_LONG_LONG\");\n\nstatic_assert(ARDUINOJSON_SLOT_ID_SIZE == 2, \"ARDUINOJSON_SLOT_ID_SIZE\");\n\nstatic_assert(ARDUINOJSON_POOL_CAPACITY == 128, \"ARDUINOJSON_POOL_CAPACITY\");\n\nstatic_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, \"ARDUINOJSON_LITTLE_ENDIAN\");\n\nstatic_assert(ARDUINOJSON_USE_DOUBLE == 1, \"ARDUINOJSON_USE_DOUBLE\");\n\nstatic_assert(sizeof(ArduinoJson::detail::VariantData) == 8, \"slot size\");\n\nvoid setup() {}\nvoid loop() {}\n" }, { "path": "extras/conf_test/x64.cpp", "content": "#include \n\nstatic_assert(ARDUINOJSON_USE_LONG_LONG == 1, \"ARDUINOJSON_USE_LONG_LONG\");\n\nstatic_assert(ARDUINOJSON_SLOT_ID_SIZE == 4, \"ARDUINOJSON_SLOT_ID_SIZE\");\n\nstatic_assert(ARDUINOJSON_POOL_CAPACITY == 256, \"ARDUINOJSON_POOL_CAPACITY\");\n\nstatic_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, \"ARDUINOJSON_LITTLE_ENDIAN\");\n\nstatic_assert(ARDUINOJSON_USE_DOUBLE == 1, \"ARDUINOJSON_USE_DOUBLE\");\n\nstatic_assert(sizeof(ArduinoJson::detail::VariantData) == 16, \"slot size\");\n\nint main() {}\n" }, { "path": "extras/conf_test/x86.cpp", "content": "#include \n\nstatic_assert(ARDUINOJSON_USE_LONG_LONG == 1, \"ARDUINOJSON_USE_LONG_LONG\");\n\nstatic_assert(ARDUINOJSON_SLOT_ID_SIZE == 2, \"ARDUINOJSON_SLOT_ID_SIZE\");\n\nstatic_assert(ARDUINOJSON_POOL_CAPACITY == 128, \"ARDUINOJSON_POOL_CAPACITY\");\n\nstatic_assert(ARDUINOJSON_LITTLE_ENDIAN == 1, \"ARDUINOJSON_LITTLE_ENDIAN\");\n\nstatic_assert(ARDUINOJSON_USE_DOUBLE == 1, \"ARDUINOJSON_USE_DOUBLE\");\n\nstatic_assert(sizeof(ArduinoJson::detail::VariantData) == 8, \"slot size\");\n\nint main() {}\n" }, { "path": "extras/fuzzing/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nset(CMAKE_CXX_STANDARD 11)\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\nif(MSVC)\n\tadd_compile_options(-D_CRT_SECURE_NO_WARNINGS)\nendif()\n\nfunction(add_fuzzer name)\n\tset(FUZZER \"${name}_fuzzer\")\n\tset(REPRODUCER \"${FUZZER}_reproducer\")\n\tset(CORPUS_DIR \"${CMAKE_CURRENT_SOURCE_DIR}/${name}_corpus\")\n\tset(SEED_CORPUS_DIR \"${CMAKE_CURRENT_SOURCE_DIR}/${name}_seed_corpus\")\n\n\tadd_executable(\"${FUZZER}\"\n\t\t\"${name}_fuzzer.cpp\"\n\t)\n\ttarget_link_libraries(\"${FUZZER}\"\n\t\tArduinoJson\n\t)\n\tset_target_properties(\"${FUZZER}\"\n\t\tPROPERTIES\n\t\t\tCOMPILE_FLAGS \"-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all\"\n\t\t\tLINK_FLAGS \"-fprofile-instr-generate -fcoverage-mapping -fsanitize=fuzzer -fno-sanitize-recover=all\"\n\t)\n\n\tadd_test(\n\t\tNAME \"${FUZZER}\"\n\t\tCOMMAND \"${FUZZER}\" \"${CORPUS_DIR}\" \"${SEED_CORPUS_DIR}\" -max_total_time=5 -timeout=1\n\t)\n\tset_tests_properties(\"${FUZZER}\"\n\t\tPROPERTIES\n\t\tLABELS \"Fuzzing\"\n\t)\n\n\tadd_executable(\"${REPRODUCER}\"\n\t\t\"${name}_fuzzer.cpp\"\n\t\treproducer.cpp\n\t)\n\ttarget_link_libraries(\"${REPRODUCER}\"\n\t\tArduinoJson\n\t)\nendfunction()\n\n# Needs Clang 6+ to compile\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"Clang\" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6)\n\tif(DEFINED ENV{GITHUB_ACTIONS} AND CMAKE_CXX_COMPILER_VERSION MATCHES \"^11\\\\.\")\n\t\t# Clang 11 fails on GitHub Actions with the following error:\n\t\t# > ERROR: UndefinedBehaviorSanitizer failed to allocate 0x0 (0) bytes of SetAlternateSignalStack (error code: 22)\n\t\t# > Sanitizer CHECK failed: /build/llvm-toolchain-11-mnvtwk/llvm-toolchain-11-11.1.0/compiler-rt/lib/sanitizer_common/sanitizer_common.cpp:54 ((0 && \"unable to mmap\")) != (0) (0, 0)\n\t\tmessage(WARNING \"Fuzzing is disabled on GitHub Actions to workaround a bug in Clang 11\")\n\t\treturn()\n\tendif()\n\n\tadd_fuzzer(json)\n\tadd_fuzzer(msgpack)\n\tadd_fuzzer(number)\nendif()\n" }, { "path": "extras/fuzzing/Makefile", "content": "# CAUTION: this file is invoked by https://github.com/google/oss-fuzz\n\nCXXFLAGS += -I../../src -DARDUINOJSON_DEBUG=1 -std=c++11\n\nall: \\\n\t$(OUT)/json_fuzzer \\\n\t$(OUT)/json_fuzzer_seed_corpus.zip \\\n\t$(OUT)/json_fuzzer.options \\\n\t$(OUT)/msgpack_fuzzer \\\n\t$(OUT)/msgpack_fuzzer_seed_corpus.zip \\\n\t$(OUT)/msgpack_fuzzer.options \\\n\t$(OUT)/number_fuzzer \\\n\t$(OUT)/number_fuzzer_seed_corpus.zip \\\n\t$(OUT)/number_fuzzer.options\n\n$(OUT)/%_fuzzer: %_fuzzer.cpp $(shell find ../../src -type f)\n\t$(CXX) $(CXXFLAGS) $< -o$@ $(LIB_FUZZING_ENGINE)\n\n$(OUT)/%_fuzzer_seed_corpus.zip: %_seed_corpus/*\n\tzip -j $@ $?\n\n$(OUT)/%_fuzzer.options:\n\t@echo \"[libfuzzer]\" > $@\n\t@echo \"max_len = 4096\" >> $@\n\t@echo \"timeout = 10\" >> $@\n" }, { "path": "extras/fuzzing/json_corpus/.gitignore", "content": "*\n!.gitignore\n" }, { "path": "extras/fuzzing/json_fuzzer.cpp", "content": "#include \n\nextern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {\n JsonDocument doc;\n DeserializationError error = deserializeJson(doc, data, size);\n if (!error) {\n std::string json;\n serializeJson(doc, json);\n }\n return 0;\n}\n" }, { "path": "extras/fuzzing/json_seed_corpus/Comments.json", "content": "//comment\n/*comment*/\n[ //comment\n/*comment*/\"comment\"/*comment*/,//comment\n/*comment*/{//comment\n/* comment*/\"key\"//comment\n: //comment\n\"value\"//comment\n}/*comment*/\n]//comment" }, { "path": "extras/fuzzing/json_seed_corpus/EmptyArray.json", "content": "[]" }, { "path": "extras/fuzzing/json_seed_corpus/EmptyObject.json", "content": "{}" }, { "path": "extras/fuzzing/json_seed_corpus/ExcessiveNesting.json", "content": "[1,[2,[3,[4,[5,[6,[7,[8,[9,[10,[11,[12,[13,[14,[15,[16,[17,[18,[19,[20,[21,[22,[23,[24,[25,[26,[27,[28,[29,[30,[31,[32,[33,[34,[35,[36,[37,[38,[39,[40,[41,[42,[43,[44,[45,[46,[47,[48,[49,[50,[51,[52,[53,[54,[55,[56,[57,[58,[59,[60,[61,[62,[63,[64,[65,[66,[67,[68,[69,[70,[71,[72,[73,[74,[75,[76,[77,[78,[79,[80,[81,[82,[83,[84,[85,[86,[87,[88,[89,[90,[91,[92,[93,[94,[95,[96,[97,[98,[99,[100,[101,[102,[103,[104,[105,[106,[107,[108,[109,[110,[111,[112,[113,[114,[115,[116,[117,[118,[119,[120]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]]" }, { "path": "extras/fuzzing/json_seed_corpus/IntegerOverflow.json", "content": "9720730739393920739\n" }, { "path": "extras/fuzzing/json_seed_corpus/Numbers.json", "content": "[\n 123,\n -123,\n 123.456,\n -123.456,\n 12e34,\n 12e-34,\n 12e+34,\n 12E34,\n 12E-34,\n 12E+34,\n 12.34e56,\n 12.34e-56,\n 12.34e+56,\n 12.34E56,\n 12.34E-56,\n 12.34E+56,\n NaN,\n -NaN,\n +NaN,\n Infinity,\n +Infinity,\n -Infinity\n]" }, { "path": "extras/fuzzing/json_seed_corpus/OpenWeatherMap.json", "content": "{\n \"coord\": {\n \"lon\": -0.13,\n \"lat\": 51.51\n },\n \"weather\": [\n {\n \"id\": 301,\n \"main\": \"Drizzle\",\n \"description\": \"drizzle\",\n \"icon\": \"09n\"\n },\n {\n \"id\": 701,\n \"main\": \"Mist\",\n \"description\": \"mist\",\n \"icon\": \"50n\"\n },\n {\n \"id\": 741,\n \"main\": \"Fog\",\n \"description\": \"fog\",\n \"icon\": \"50n\"\n }\n ],\n \"base\": \"stations\",\n \"main\": {\n \"temp\": 281.87,\n \"pressure\": 1032,\n \"humidity\": 100,\n \"temp_min\": 281.15,\n \"temp_max\": 283.15\n },\n \"visibility\": 2900,\n \"wind\": {\n \"speed\": 1.5\n },\n \"clouds\": {\n \"all\": 90\n },\n \"dt\": 1483820400,\n \"sys\": {\n \"type\": 1,\n \"id\": 5091,\n \"message\": 0.0226,\n \"country\": \"GB\",\n \"sunrise\": 1483776245,\n \"sunset\": 1483805443\n },\n \"id\": 2643743,\n \"name\": \"London\",\n \"cod\": 200\n}\n" }, { "path": "extras/fuzzing/json_seed_corpus/Strings.json", "content": "[\n \"hello\",\n 'hello',\n hello,\n {\"hello\":\"world\"},\n {'hello':'world'},\n {hello:world}\n]" }, { "path": "extras/fuzzing/json_seed_corpus/WeatherUnderground.json", "content": "{\n \"response\": {\n \"version\": \"0.1\",\n \"termsofService\": \"http://www.wunderground.com/weather/api/d/terms.html\",\n \"features\": {\n \"conditions\": 1\n }\n },\n \"current_observation\": {\n \"image\": {\n \"url\": \"http://icons-ak.wxug.com/graphics/wu2/logo_130x80.png\",\n \"title\": \"Weather Underground\",\n \"link\": \"http://www.wunderground.com\"\n },\n \"display_location\": {\n \"full\": \"San Francisco, CA\",\n \"city\": \"San Francisco\",\n \"state\": \"CA\",\n \"state_name\": \"California\",\n \"country\": \"US\",\n \"country_iso3166\": \"US\",\n \"zip\": \"94101\",\n \"latitude\": \"37.77500916\",\n \"longitude\": \"-122.41825867\",\n \"elevation\": \"47.00000000\"\n },\n \"observation_location\": {\n \"full\": \"SOMA - Near Van Ness, San Francisco, California\",\n \"city\": \"SOMA - Near Van Ness, San Francisco\",\n \"state\": \"California\",\n \"country\": \"US\",\n \"country_iso3166\": \"US\",\n \"latitude\": \"37.773285\",\n \"longitude\": \"-122.417725\",\n \"elevation\": \"49 ft\"\n },\n \"estimated\": {},\n \"station_id\": \"KCASANFR58\",\n \"observation_time\": \"Last Updated on June 27, 5:27 PM PDT\",\n \"observation_time_rfc822\": \"Wed, 27 Jun 2012 17:27:13 -0700\",\n \"observation_epoch\": \"1340843233\",\n \"local_time_rfc822\": \"Wed, 27 Jun 2012 17:27:14 -0700\",\n \"local_epoch\": \"1340843234\",\n \"local_tz_short\": \"PDT\",\n \"local_tz_long\": \"America/Los_Angeles\",\n \"local_tz_offset\": \"-0700\",\n \"weather\": \"Partly Cloudy\",\n \"temperature_string\": \"66.3 F (19.1 C)\",\n \"temp_f\": 66.3,\n \"temp_c\": 19.1,\n \"relative_humidity\": \"65%\",\n \"wind_string\": \"From the NNW at 22.0 MPH Gusting to 28.0 MPH\",\n \"wind_dir\": \"NNW\",\n \"wind_degrees\": 346,\n \"wind_mph\": 22,\n \"wind_gust_mph\": \"28.0\",\n \"wind_kph\": 35.4,\n \"wind_gust_kph\": \"45.1\",\n \"pressure_mb\": \"1013\",\n \"pressure_in\": \"29.93\",\n \"pressure_trend\": \"+\",\n \"dewpoint_string\": \"54 F (12 C)\",\n \"dewpoint_f\": 54,\n \"dewpoint_c\": 12,\n \"heat_index_string\": \"NA\",\n \"heat_index_f\": \"NA\",\n \"heat_index_c\": \"NA\",\n \"windchill_string\": \"NA\",\n \"windchill_f\": \"NA\",\n \"windchill_c\": \"NA\",\n \"feelslike_string\": \"66.3 F (19.1 C)\",\n \"feelslike_f\": \"66.3\",\n \"feelslike_c\": \"19.1\",\n \"visibility_mi\": \"10.0\",\n \"visibility_km\": \"16.1\",\n \"solarradiation\": \"\",\n \"UV\": \"5\",\n \"precip_1hr_string\": \"0.00 in ( 0 mm)\",\n \"precip_1hr_in\": \"0.00\",\n \"precip_1hr_metric\": \" 0\",\n \"precip_today_string\": \"0.00 in (0 mm)\",\n \"precip_today_in\": \"0.00\",\n \"precip_today_metric\": \"0\",\n \"icon\": \"partlycloudy\",\n \"icon_url\": \"http://icons-ak.wxug.com/i/c/k/partlycloudy.gif\",\n \"forecast_url\": \"http://www.wunderground.com/US/CA/San_Francisco.html\",\n \"history_url\": \"http://www.wunderground.com/history/airport/KCASANFR58/2012/6/27/DailyHistory.html\",\n \"ob_url\": \"http://www.wunderground.com/cgi-bin/findweather/getForecast?query=37.773285,-122.417725\"\n }\n}\n" }, { "path": "extras/fuzzing/msgpack_corpus/.gitignore", "content": "*\n!.gitignore\n" }, { "path": "extras/fuzzing/msgpack_fuzzer.cpp", "content": "#include \n\nextern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {\n JsonDocument doc;\n DeserializationError error = deserializeMsgPack(doc, data, size);\n if (!error) {\n std::string json;\n serializeMsgPack(doc, json);\n }\n return 0;\n}\n" }, { "path": "extras/fuzzing/msgpack_seed_corpus/false", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/fixarray", "content": "helloworld" }, { "path": "extras/fuzzing/msgpack_seed_corpus/fixint_negative", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/fixint_positive", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/fixmap", "content": "one\u0001two\u0002" }, { "path": "extras/fuzzing/msgpack_seed_corpus/fixstr", "content": "hello world" }, { "path": "extras/fuzzing/msgpack_seed_corpus/float32", "content": "@H" }, { "path": "extras/fuzzing/msgpack_seed_corpus/float64", "content": "@\t!\u0012o" }, { "path": "extras/fuzzing/msgpack_seed_corpus/int16", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/int32", "content": "Ҷi." }, { "path": "extras/fuzzing/msgpack_seed_corpus/int64", "content": "\u00124Vx" }, { "path": "extras/fuzzing/msgpack_seed_corpus/int8", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/nil", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/str8", "content": "\u0005hello" }, { "path": "extras/fuzzing/msgpack_seed_corpus/true", "content": "" }, { "path": "extras/fuzzing/msgpack_seed_corpus/uint16", "content": "09" }, { "path": "extras/fuzzing/msgpack_seed_corpus/uint32", "content": "\u00124Vx" }, { "path": "extras/fuzzing/msgpack_seed_corpus/uint64", "content": "\u00124Vx" }, { "path": "extras/fuzzing/msgpack_seed_corpus/uint8", "content": "" }, { "path": "extras/fuzzing/number_corpus/.gitignore", "content": "*\n!.gitignore\n" }, { "path": "extras/fuzzing/number_fuzzer.cpp", "content": "#include \n\nextern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) {\n // Make a copy to ensure the input is null-terminated\n std::string str(reinterpret_cast(data), size);\n\n ArduinoJson::detail::parseNumber(str.c_str());\n\n return 0;\n}\n" }, { "path": "extras/fuzzing/number_seed_corpus/decimal_half", "content": "0.5\n" }, { "path": "extras/fuzzing/number_seed_corpus/decimal_one_and_half", "content": "1.5\n" }, { "path": "extras/fuzzing/number_seed_corpus/infinity", "content": "infinity\n" }, { "path": "extras/fuzzing/number_seed_corpus/issue2220-1", "content": "1000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000\n" }, { "path": "extras/fuzzing/number_seed_corpus/issue2220-2", "content": "0.00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000001\n" }, { "path": "extras/fuzzing/number_seed_corpus/large_decimal", "content": "999999.999999\n" }, { "path": "extras/fuzzing/number_seed_corpus/large_integer", "content": "9876543210\n" }, { "path": "extras/fuzzing/number_seed_corpus/leading_zeros", "content": "0.00001\n" }, { "path": "extras/fuzzing/number_seed_corpus/nan", "content": "nan\n" }, { "path": "extras/fuzzing/number_seed_corpus/negative_decimal", "content": "-123.456\n" }, { "path": "extras/fuzzing/number_seed_corpus/negative_one", "content": "-1\n" }, { "path": "extras/fuzzing/number_seed_corpus/negative_scientific", "content": "-2.5e-3\n" }, { "path": "extras/fuzzing/number_seed_corpus/negative_scientific_large_exp", "content": "-1.23456e+20\n" }, { "path": "extras/fuzzing/number_seed_corpus/negative_zero", "content": "-0\n" }, { "path": "extras/fuzzing/number_seed_corpus/one", "content": "1\n" }, { "path": "extras/fuzzing/number_seed_corpus/pi_approximation", "content": "3.14159265359\n" }, { "path": "extras/fuzzing/number_seed_corpus/scientific_e10", "content": "1e10\n" }, { "path": "extras/fuzzing/number_seed_corpus/scientific_e_minus", "content": "1.5e-10\n" }, { "path": "extras/fuzzing/number_seed_corpus/scientific_e_plus", "content": "1.23e+5\n" }, { "path": "extras/fuzzing/number_seed_corpus/small_decimal", "content": "0.001\n" }, { "path": "extras/fuzzing/number_seed_corpus/small_integer", "content": "42\n" }, { "path": "extras/fuzzing/number_seed_corpus/trailing_zeros", "content": "1000000\n" }, { "path": "extras/fuzzing/number_seed_corpus/very_small_positive", "content": "0.0000001\n" }, { "path": "extras/fuzzing/number_seed_corpus/zero", "content": "0\n" }, { "path": "extras/fuzzing/reproducer.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n// This file is NOT use by Google's OSS fuzz\n// I only use it to reproduce the bugs found\n\n#include // size_t\n#include // fopen et al.\n#include // exit\n#include \n#include \n\nextern \"C\" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size);\n\nstd::vector read(const char* path) {\n FILE* f = fopen(path, \"rb\");\n if (!f) {\n std::cerr << \"Failed to open \" << path << std::endl;\n exit(1);\n }\n\n fseek(f, 0, SEEK_END);\n size_t size = static_cast(ftell(f));\n fseek(f, 0, SEEK_SET);\n\n std::vector buffer(size);\n if (fread(buffer.data(), 1, size, f) != size) {\n fclose(f);\n std::cerr << \"Failed to read \" << path << std::endl;\n exit(1);\n }\n\n fclose(f);\n return buffer;\n}\n\nint main(int argc, const char* argv[]) {\n if (argc < 2) {\n std::cerr << \"Usage: msgpack_fuzzer files\" << std::endl;\n return 1;\n }\n\n for (int i = 1; i < argc; i++) {\n std::cout << \"Loading \" << argv[i] << std::endl;\n std::vector buffer = read(argv[i]);\n LLVMFuzzerTestOneInput(buffer.data(), buffer.size());\n }\n return 0;\n}\n" }, { "path": "extras/particle/project.properties", "content": "name=ArduinoJsonCI\n" }, { "path": "extras/particle/src/smocktest.ino", "content": "#include \"ArduinoJson.h\"\n\nvoid setup() {}\n\nvoid loop() {}\n" }, { "path": "extras/scripts/build-single-header.sh", "content": "#!/bin/bash\n\nset -e\n\nRE_RELATIVE_INCLUDE='^#[[:space:]]*include[[:space:]]*\"(.*)\"'\nRE_ABSOLUTE_INCLUDE='^#[[:space:]]*include[[:space:]]*<(ArduinoJson/.*)>'\nRE_SYSTEM_INCLUDE='^#[[:space:]]*include[[:space:]]*<(.*)>'\nRE_EMPTY='^(#[[:space:]]*pragma[[:space:]]+once)?[[:space:]]*(//.*)?$'\nSRC_DIRECTORY=\"$(realpath \"$(dirname $0)/../../src\")\"\n\n\ndeclare -A INCLUDED\n\nprocess()\n{\n\tlocal PARENT=$1\n\tlocal FOLDER=$(dirname $1)\n\tlocal SHOW_COMMENT=$2\n\twhile IFS= read -r LINE; do\n\t\tif [[ $LINE =~ $RE_ABSOLUTE_INCLUDE ]]; then\n\t\t\tlocal CHILD=${BASH_REMATCH[1]}\n\t\t\tlocal CHILD_PATH\n\t\t\tCHILD_PATH=$(realpath \"$SRC_DIRECTORY/$CHILD\")\n\t\t\techo \"$PARENT -> $CHILD\" >&2\n\t\t\tif [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then\n\t\t\t\tINCLUDED[$CHILD_PATH]=true\n\t\t\t\tprocess \"$CHILD\" false\n\t\t\tfi\n\t\telif [[ $LINE =~ $RE_RELATIVE_INCLUDE ]]; then\n\t\t\tlocal CHILD=${BASH_REMATCH[1]}\n\t\t\tpushd \"$FOLDER\" > /dev/null\n\t\t\tlocal CHILD_PATH\n\t\t\tCHILD_PATH=$(realpath \"$CHILD\")\n\t\t\techo \"$PARENT -> $CHILD\" >&2\n\t\t\tif [[ ! ${INCLUDED[$CHILD_PATH]} ]]; then\n\t\t\t\tINCLUDED[$CHILD_PATH]=true\n\t\t\t\tprocess \"$CHILD\" false\n\t\t\tfi\n\t\t\tpopd > /dev/null\n\t\telif [[ $LINE =~ $RE_SYSTEM_INCLUDE ]]; then\n\t\t\tlocal CHILD=${BASH_REMATCH[1]}\n\t\t\techo \"$PARENT -> <$CHILD>\" >&2\n\t\t\tif [[ ! ${INCLUDED[$CHILD]} ]]; then\n\t\t\t\techo \"#include <$CHILD>\"\n\t\t\t\tINCLUDED[$CHILD]=true\n\t\t\tfi\n\t\telif [[ \"${SHOW_COMMENT}\" = \"true\" ]] ; then\n\t\t\techo \"$LINE\"\n\t\telif [[ ! $LINE =~ $RE_EMPTY ]]; then\n\t\t\techo \"$LINE\"\n\t\tfi\n\tdone < $PARENT\n}\n\nsimplify_namespaces() {\n\tperl -p0i -e 's|ARDUINOJSON_END_PUBLIC_NAMESPACE\\r?\\nARDUINOJSON_BEGIN_PUBLIC_NAMESPACE\\r?\\n||igs' \"$1\"\n\tperl -p0i -e 's|ARDUINOJSON_END_PRIVATE_NAMESPACE\\r?\\nARDUINOJSON_BEGIN_PRIVATE_NAMESPACE\\r?\\n||igs' \"$1\"\n\trm -f \"$1.bak\"\n}\n\nINCLUDED=()\nINPUT=$1\nOUTPUT=$2\nprocess \"$INPUT\" true > \"$OUTPUT\"\nsimplify_namespaces \"$OUTPUT\"\n" }, { "path": "extras/scripts/extract_changes.awk", "content": "#!/usr/bin/awk -f\n\n# Start echoing after the first list item\n/\\* / {\n STARTED=1\n EMPTY_LINE=0\n}\n\n# Remember if we have seen an empty line\n/^[[:space:]]*$/ {\n EMPTY_LINE=1\n}\n\n# Exit when seeing a new version number\n/^v[[:digit:]]/ {\n if (STARTED) exit\n}\n\n# Print if the line is not empty\n# and restore the empty line we have skipped\n!/^[[:space:]]*$/ {\n if (STARTED) {\n if (EMPTY_LINE) {\n print \"\"\n EMPTY_LINE=0\n }\n print\n }\n}\n" }, { "path": "extras/scripts/get-release-page.sh", "content": "#!/bin/bash\n\nset -eu\n\nVERSION=\"$1\"\nCHANGELOG=\"$2\"\nARDUINOJSON_H=\"$3\"\n\ncat << END\n---\nbranch: v7\nversion: $VERSION\ndate: '$(date +'%Y-%m-%d')'\n$(extras/scripts/wandbox/publish.sh \"$ARDUINOJSON_H\")\n---\n\n$(extras/scripts/extract_changes.awk \"$CHANGELOG\")\nEND\n" }, { "path": "extras/scripts/publish-particle-library.sh", "content": "#!/usr/bin/env bash\n\nset -eu\n\nSOURCE_DIR=\"$(dirname \"$0\")/../..\"\nWORK_DIR=$(mktemp -d)\ntrap 'rm -rf \"$WORK_DIR\"' EXIT\n\ncp \"$SOURCE_DIR/README.md\" \"$WORK_DIR/README.md\"\ncp \"$SOURCE_DIR/CHANGELOG.md\" \"$WORK_DIR/CHANGELOG.md\"\ncp \"$SOURCE_DIR/library.properties\" \"$WORK_DIR/library.properties\"\ncp \"$SOURCE_DIR/LICENSE.txt\" \"$WORK_DIR/LICENSE.txt\"\ncp -r \"$SOURCE_DIR/src\" \"$WORK_DIR/\"\ncp -r \"$SOURCE_DIR/examples\" \"$WORK_DIR/\"\n\ncd \"$WORK_DIR\"\nparticle library upload\nparticle library publish\n" }, { "path": "extras/scripts/publish.sh", "content": "#!/usr/bin/env bash\n\nset -eu\n\nwhich awk sed jq curl perl >/dev/null\n\ncd \"$(dirname \"$0\")/../..\"\n\nif ! git diff --quiet --exit-code; then\n\techo \"Repository contains uncommitted changes\"\n\texit\nfi\n\nVERSION=\"$1\"\nDATE=$(date +%F)\nTAG=\"v$VERSION\"\nVERSION_REGEX='[0-9]+\\.[0-9]+\\.[0-9]+(-[a-z0-9]+)?'\nSTARS=$(curl -s https://api.github.com/repos/bblanchon/ArduinoJson | jq '.stargazers_count')\n\nupdate_version_in_source () {\n\tIFS=\".-\" read MAJOR MINOR REVISION EXTRA < <(echo \"$VERSION\")\n\tUNDERLINE=$(printf -- '-%.0s' $(seq 1 ${#TAG}))\n\n\tsed -i~ -bE \"1,20{s/$VERSION_REGEX/$VERSION/g}\" README.md\n\trm README.md~\n\n\tsed -i~ -bE \"4s/HEAD/$TAG ($DATE)/; 5s/-+/$UNDERLINE/\" CHANGELOG.md\n\trm CHANGELOG.md~\n\n\tsed -i~ -bE \"s/(project\\\\s*\\\\(ArduinoJson\\\\s+VERSION\\\\s+).*?\\\\)/\\\\1$MAJOR.$MINOR.$REVISION)/\" CMakeLists.txt\n\trm CMakeLists.txt~\n\n\tsed -i~ -bE \\\n\t\t-e \"s/\\\"version\\\":.*$/\\\"version\\\": \\\"$VERSION\\\",/\" \\\n\t\t-e \"s/[0-9]+ stars/$STARS stars/\" \\\n\t\tlibrary.json\n\trm library.json~\n\n\tsed -i~ -bE \\\n\t\t-e \"s/version=.*$/version=$VERSION/\" \\\n\t\t-e \"s/[0-9]+ stars/$STARS stars/\" \\\n\t\tlibrary.properties\n\trm library.properties~\n\n\tsed -i~ -bE \"s/version: .*$/version: $VERSION.{build}/\" appveyor.yml\n\trm appveyor.yml~\n\n\tsed -i~ -bE \\\n\t\t-e \"s/^version: .*$/version: \\\"$VERSION\\\"/\" \\\n\t\t-e \"s/[0-9]+ stars/$STARS stars/\" \\\n\t\tidf_component.yml\n\trm idf_component.yml~\n\n\tsed -i~ -bE \\\n\t\t-e \"s/ARDUINOJSON_VERSION .*$/ARDUINOJSON_VERSION \\\"$VERSION\\\"/\" \\\n\t\t-e \"s/ARDUINOJSON_VERSION_MAJOR .*$/ARDUINOJSON_VERSION_MAJOR $MAJOR/\" \\\n\t\t-e \"s/ARDUINOJSON_VERSION_MINOR .*$/ARDUINOJSON_VERSION_MINOR $MINOR/\" \\\n\t\t-e \"s/ARDUINOJSON_VERSION_REVISION .*$/ARDUINOJSON_VERSION_REVISION $REVISION/\" \\\n\t\t-e \"s/ARDUINOJSON_VERSION_MACRO .*$/ARDUINOJSON_VERSION_MACRO V$MAJOR$MINOR$REVISION/\" \\\n\t\tsrc/ArduinoJson/version.hpp\n\trm src/ArduinoJson/version.hpp*~\n}\n\ncommit_new_version () {\n\tgit add src/ArduinoJson/version.hpp README.md CHANGELOG.md library.json library.properties appveyor.yml CMakeLists.txt idf_component.yml\n\tgit commit -m \"Set version to $VERSION\"\n}\n\nadd_tag () {\n\tCHANGES=$(awk '/\\* /{ FOUND=1; print; next } { if (FOUND) exit}' CHANGELOG.md)\n\tgit tag -m \"ArduinoJson $VERSION\"$'\\n'\"$CHANGES\" \"$TAG\"\n}\n\npush () {\n\tgit push --follow-tags\n}\n\nupdate_version_in_source\ncommit_new_version\nadd_tag\npush\n\nextras/scripts/build-single-header.sh \"src/ArduinoJson.h\" \"../ArduinoJson-$TAG.h\"\nextras/scripts/build-single-header.sh \"src/ArduinoJson.hpp\" \"../ArduinoJson-$TAG.hpp\"\nextras/scripts/get-release-page.sh \"$VERSION\" \"CHANGELOG.md\" \"../ArduinoJson-$TAG.h\" > \"../ArduinoJson-$TAG.md\"\n\necho \"You can now copy ../ArduinoJson-$TAG.md into arduinojson.org/collections/_versions/$VERSION.md\"\n" }, { "path": "extras/scripts/wandbox/JsonGeneratorExample.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to generate a JSON document with ArduinoJson.\n\n#include \n#include \"ArduinoJson.h\"\n\nint main() {\n // Allocate the JSON document\n JsonDocument doc;\n\n // Add values in the document.\n doc[\"sensor\"] = \"gps\";\n doc[\"time\"] = 1351824120;\n\n // Add an array\n JsonArray data = doc[\"data\"].to();\n data.add(48.756080);\n data.add(2.302038);\n\n // Generate the minified JSON and send it to STDOUT\n serializeJson(doc, std::cout);\n // The above line prints:\n // {\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}\n\n // Start a new line\n std::cout << std::endl;\n\n // Generate the prettified JSON and send it to STDOUT\n serializeJsonPretty(doc, std::cout);\n // The above line prints:\n // {\n // \"sensor\": \"gps\",\n // \"time\": 1351824120,\n // \"data\": [\n // 48.756080,\n // 2.302038\n // ]\n // }\n}\n" }, { "path": "extras/scripts/wandbox/JsonParserExample.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to deserialize a JSON document with ArduinoJson.\n\n#include \n#include \"ArduinoJson.h\"\n\nint main() {\n // Allocate the JSON document\n JsonDocument doc;\n\n // JSON input string\n const char* json =\n \"{\\\"sensor\\\":\\\"gps\\\",\\\"time\\\":1351824120,\\\"data\\\":[48.756080,2.302038]}\";\n\n // Deserialize the JSON document\n DeserializationError error = deserializeJson(doc, json);\n\n // Test if parsing succeeds\n if (error) {\n std::cerr << \"deserializeJson() failed: \" << error.c_str() << std::endl;\n return 1;\n }\n\n // Fetch the values\n //\n // Most of the time, you can rely on the implicit casts.\n // In other case, you can do doc[\"time\"].as();\n const char* sensor = doc[\"sensor\"];\n long time = doc[\"time\"];\n double latitude = doc[\"data\"][0];\n double longitude = doc[\"data\"][1];\n\n // Print the values\n std::cout << sensor << std::endl;\n std::cout << time << std::endl;\n std::cout << latitude << std::endl;\n std::cout << longitude << std::endl;\n\n return 0;\n}\n" }, { "path": "extras/scripts/wandbox/MsgPackParserExample.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n//\n// This example shows how to generate a JSON document with ArduinoJson.\n\n#include \n#include \"ArduinoJson.h\"\n\nint main() {\n // Allocate the JSON document\n JsonDocument doc;\n\n // The MessagePack input string\n uint8_t input[] = {131, 166, 115, 101, 110, 115, 111, 114, 163, 103, 112, 115,\n 164, 116, 105, 109, 101, 206, 80, 147, 50, 248, 164, 100,\n 97, 116, 97, 146, 203, 64, 72, 96, 199, 58, 188, 148,\n 112, 203, 64, 2, 106, 146, 230, 33, 49, 169};\n // This MessagePack document contains:\n // {\n // \"sensor\": \"gps\",\n // \"time\": 1351824120,\n // \"data\": [48.75608, 2.302038]\n // }\n\n // Parse the input\n DeserializationError error = deserializeMsgPack(doc, input);\n\n // Test if parsing succeeds\n if (error) {\n std::cerr << \"deserializeMsgPack() failed: \" << error.c_str() << std::endl;\n return 1;\n }\n\n // Fetch the values\n //\n // Most of the time, you can rely on the implicit casts.\n // In other case, you can do doc[\"time\"].as();\n const char* sensor = doc[\"sensor\"];\n long time = doc[\"time\"];\n double latitude = doc[\"data\"][0];\n double longitude = doc[\"data\"][1];\n\n // Print the values\n std::cout << sensor << std::endl;\n std::cout << time << std::endl;\n std::cout << latitude << std::endl;\n std::cout << longitude << std::endl;\n\n return 0;\n}\n" }, { "path": "extras/scripts/wandbox/publish.sh", "content": "#!/usr/bin/env bash\n\nset -eu\n\nARDUINOJSON_H=\"$1\"\n\nread_string() {\n\tjq --slurp --raw-input '.' \"$1\"\n}\n\ncompile() {\n\tFILE_PATH=\"$(dirname $0)/$1.cpp\"\n\tcat >parameters.json <\n// but we don't want it to included accidentally\n#undef ARDUINO\n#define ARDUINOJSON_ENABLE_STD_STREAM 0\n#define ARDUINOJSON_ENABLE_STD_STRING 0\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\n#if !ARDUINOJSON_ENABLE_STRING_VIEW\n# error ARDUINOJSON_ENABLE_STRING_VIEW must be set to 1\n#endif\n\nusing ArduinoJson::detail::sizeofArray;\n\nTEST_CASE(\"string_view\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonVariant variant = doc.to();\n\n SECTION(\"deserializeJson()\") {\n auto err = deserializeJson(doc, std::string_view(\"123\", 2));\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == 12);\n }\n\n SECTION(\"JsonDocument::set()\") {\n doc.set(std::string_view(\"123\", 2));\n REQUIRE(doc.as() == \"12\");\n }\n\n SECTION(\"JsonDocument::operator[]() const\") {\n doc[\"ab\"] = \"Yes\";\n doc[\"abc\"] = \"No\";\n REQUIRE(doc[std::string_view(\"abc\", 2)] == \"Yes\");\n }\n\n SECTION(\"JsonDocument::operator[]()\") {\n doc[std::string_view(\"abc\", 2)] = \"Yes\";\n REQUIRE(doc[\"ab\"] == \"Yes\");\n }\n\n SECTION(\"JsonVariant::operator==()\") {\n variant.set(\"A\");\n REQUIRE(variant == std::string_view(\"AX\", 1));\n REQUIRE_FALSE(variant == std::string_view(\"BX\", 1));\n }\n\n SECTION(\"JsonVariant::operator>()\") {\n variant.set(\"B\");\n REQUIRE(variant > std::string_view(\"AX\", 1));\n REQUIRE_FALSE(variant > std::string_view(\"CX\", 1));\n }\n\n SECTION(\"JsonVariant::operator<()\") {\n variant.set(\"B\");\n REQUIRE(variant < std::string_view(\"CX\", 1));\n REQUIRE_FALSE(variant < std::string_view(\"AX\", 1));\n }\n\n SECTION(\"String deduplication\") {\n doc.add(std::string_view(\"example one\", 7));\n doc.add(std::string_view(\"example two\", 7));\n doc.add(std::string_view(\"example\\0tree\", 12));\n doc.add(std::string_view(\"example\\0tree and a half\", 12));\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n Allocate(sizeofString(\"example tree\")),\n });\n }\n\n SECTION(\"as()\") {\n doc[\"s\"] = \"Hello World\";\n doc[\"i\"] = 42;\n REQUIRE(doc[\"s\"].as() == std::string_view(\"Hello World\"));\n REQUIRE(doc[\"i\"].as() == std::string_view());\n }\n\n SECTION(\"is()\") {\n doc[\"s\"] = \"Hello World\";\n doc[\"i\"] = 42;\n REQUIRE(doc[\"s\"].is() == true);\n REQUIRE(doc[\"i\"].is() == false);\n }\n\n SECTION(\"String containing NUL\") {\n doc.set(\"hello\\0world\"_s);\n REQUIRE(doc.as().size() == 11);\n REQUIRE(doc.as() == std::string_view(\"hello\\0world\", 11));\n }\n}\n\nusing ArduinoJson::detail::adaptString;\n\nTEST_CASE(\"StringViewAdapter\") {\n std::string_view str(\"bravoXXX\", 5);\n auto adapter = adaptString(str);\n\n CHECK(stringCompare(adapter, adaptString(\"alpha\", 5)) > 0);\n CHECK(stringCompare(adapter, adaptString(\"bravo\", 5)) == 0);\n CHECK(stringCompare(adapter, adaptString(\"charlie\", 7)) < 0);\n\n CHECK(adapter.size() == 5);\n}\n" }, { "path": "extras/tests/Cpp20/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nif(MSVC_VERSION LESS 1910)\n\treturn()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10)\n\treturn()\nendif()\n\nif(CMAKE_CXX_COMPILER_ID STREQUAL \"GNU\" AND CMAKE_CXX_COMPILER_VERSION VERSION_LESS 10)\n\treturn()\nendif()\n\nset(CMAKE_CXX_STANDARD 20)\nset(CMAKE_CXX_STANDARD_REQUIRED ON)\n\nadd_executable(Cpp20Tests\n\tsmoke_test.cpp\n)\n\nadd_test(Cpp20 Cpp20Tests)\n\nset_tests_properties(Cpp20\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/Cpp20/smoke_test.cpp", "content": "#include \n\n#include \n#include \n\nTEST_CASE(\"C++20 smoke test\") {\n JsonDocument doc;\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(doc[\"hello\"] == \"world\");\n\n std::string json;\n serializeJson(doc, json);\n REQUIRE(json == \"{\\\"hello\\\":\\\"world\\\"}\");\n}\n" }, { "path": "extras/tests/Deprecated/BasicJsonDocument.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nusing ArduinoJson::detail::is_base_of;\n\nstatic std::string allocatorLog;\n\nstruct CustomAllocator {\n CustomAllocator() {\n allocatorLog = \"\";\n }\n\n void* allocate(size_t n) {\n allocatorLog += \"A\";\n return malloc(n);\n }\n\n void deallocate(void* p) {\n free(p);\n allocatorLog += \"D\";\n }\n\n void* reallocate(void* p, size_t n) {\n allocatorLog += \"R\";\n return realloc(p, n);\n }\n};\n\nTEST_CASE(\"BasicJsonDocument\") {\n allocatorLog.clear();\n\n SECTION(\"is a JsonDocument\") {\n REQUIRE(\n is_base_of>::value ==\n true);\n }\n\n SECTION(\"deserialize / serialize\") {\n BasicJsonDocument doc(256);\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n doc.clear();\n REQUIRE(allocatorLog == \"AARARDDD\");\n }\n\n SECTION(\"copy\") {\n BasicJsonDocument doc(256);\n doc[\"hello\"] = \"world\";\n auto copy = doc;\n REQUIRE(copy.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(allocatorLog == \"AAAAAA\");\n }\n\n SECTION(\"capacity\") {\n BasicJsonDocument doc(256);\n REQUIRE(doc.capacity() == 256);\n }\n\n SECTION(\"garbageCollect()\") {\n BasicJsonDocument doc(256);\n doc.garbageCollect();\n }\n}\n" }, { "path": "extras/tests/Deprecated/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"(GNU|Clang)\")\n\tadd_compile_options(\n\t\t-w\n\t)\nendif()\n\nif(MSVC)\n\tadd_compile_options(\n\t\t/wd4996\n\t)\nendif()\n\nadd_executable(DeprecatedTests\n\tadd.cpp\n\tBasicJsonDocument.cpp\n\tcontainsKey.cpp\n\tcreateNestedArray.cpp\n\tcreateNestedObject.cpp\n\tDynamicJsonDocument.cpp\n\tmacros.cpp\n\tmemoryUsage.cpp\n\tshallowCopy.cpp\n\tStaticJsonDocument.cpp\n)\n\nadd_test(Deprecated DeprecatedTests)\n\nset_tests_properties(Deprecated\n\tPROPERTIES\n\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/Deprecated/DynamicJsonDocument.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing ArduinoJson::detail::is_base_of;\n\nTEST_CASE(\"DynamicJsonDocument\") {\n SECTION(\"is a JsonDocument\") {\n REQUIRE(is_base_of::value == true);\n }\n\n SECTION(\"deserialize / serialize\") {\n DynamicJsonDocument doc(256);\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"copy\") {\n DynamicJsonDocument doc(256);\n doc[\"hello\"] = \"world\";\n auto copy = doc;\n REQUIRE(copy.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"capacity\") {\n DynamicJsonDocument doc(256);\n REQUIRE(doc.capacity() == 256);\n }\n\n SECTION(\"garbageCollect()\") {\n DynamicJsonDocument doc(256);\n doc.garbageCollect();\n }\n}\n" }, { "path": "extras/tests/Deprecated/StaticJsonDocument.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing ArduinoJson::detail::is_base_of;\n\nTEST_CASE(\"StaticJsonDocument\") {\n SECTION(\"is a JsonDocument\") {\n REQUIRE(is_base_of>::value == true);\n }\n\n SECTION(\"deserialize / serialize\") {\n StaticJsonDocument<256> doc;\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"copy\") {\n StaticJsonDocument<256> doc;\n doc[\"hello\"] = \"world\";\n auto copy = doc;\n REQUIRE(copy.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"capacity\") {\n StaticJsonDocument<256> doc;\n REQUIRE(doc.capacity() == 256);\n }\n}\n" }, { "path": "extras/tests/Deprecated/add.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::add()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add().set(42);\n REQUIRE(doc.as() == \"[42]\");\n}\n\nTEST_CASE(\"JsonDocument::add()\") {\n JsonDocument doc;\n doc.add().set(42);\n REQUIRE(doc.as() == \"[42]\");\n}\n\nTEST_CASE(\"ElementProxy::add()\") {\n JsonDocument doc;\n doc[0].add().set(42);\n REQUIRE(doc.as() == \"[[42]]\");\n}\n\nTEST_CASE(\"MemberProxy::add()\") {\n JsonDocument doc;\n doc[\"x\"].add().set(42);\n REQUIRE(doc.as() == \"{\\\"x\\\":[42]}\");\n}\n\nTEST_CASE(\"JsonVariant::add()\") {\n JsonDocument doc;\n JsonVariant v = doc.add();\n v.add().set(42);\n REQUIRE(doc.as() == \"[[42]]\");\n}\n" }, { "path": "extras/tests/Deprecated/containsKey.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::containsKey()\") {\n JsonDocument doc;\n\n SECTION(\"returns true on object\") {\n doc[\"hello\"] = \"world\";\n\n REQUIRE(doc.containsKey(\"hello\") == true);\n }\n\n SECTION(\"returns true when value is null\") {\n doc[\"hello\"] = static_cast(0);\n\n REQUIRE(doc.containsKey(\"hello\") == true);\n }\n\n SECTION(\"returns true when key is a std::string\") {\n doc[\"hello\"] = \"world\";\n\n REQUIRE(doc.containsKey(\"hello\"_s) == true);\n }\n\n SECTION(\"returns false on object\") {\n doc[\"world\"] = \"hello\";\n\n REQUIRE(doc.containsKey(\"hello\") == false);\n }\n\n SECTION(\"returns false on array\") {\n doc.add(\"hello\");\n\n REQUIRE(doc.containsKey(\"hello\") == false);\n }\n\n SECTION(\"returns false on null\") {\n REQUIRE(doc.containsKey(\"hello\") == false);\n }\n\n SECTION(\"supports JsonVariant\") {\n doc[\"hello\"] = \"world\";\n doc[\"key\"] = \"hello\";\n\n REQUIRE(doc.containsKey(doc[\"key\"]) == true);\n REQUIRE(doc.containsKey(doc[\"foo\"]) == false);\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLAs\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n doc[\"hello\"] = \"world\";\n\n REQUIRE(doc.containsKey(vla) == true);\n }\n#endif\n}\n\nTEST_CASE(\"MemberProxy::containsKey()\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"containsKey(const char*)\") {\n mp[\"key\"] = \"value\";\n\n REQUIRE(mp.containsKey(\"key\") == true);\n REQUIRE(mp.containsKey(\"key\") == true);\n }\n\n SECTION(\"containsKey(std::string)\") {\n mp[\"key\"] = \"value\";\n\n REQUIRE(mp.containsKey(\"key\"_s) == true);\n REQUIRE(mp.containsKey(\"key\"_s) == true);\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLAs\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n mp[\"hello\"] = \"world\";\n\n REQUIRE(mp.containsKey(vla) == true);\n }\n#endif\n}\n\nTEST_CASE(\"JsonObject::containsKey()\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"hello\"] = 42;\n\n SECTION(\"returns true only if key is present\") {\n REQUIRE(false == obj.containsKey(\"world\"));\n REQUIRE(true == obj.containsKey(\"hello\"));\n }\n\n SECTION(\"returns false after remove()\") {\n obj.remove(\"hello\");\n\n REQUIRE(false == obj.containsKey(\"hello\"));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"key is a VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n REQUIRE(true == obj.containsKey(vla));\n }\n#endif\n\n SECTION(\"key is a JsonVariant\") {\n doc[\"key\"] = \"hello\";\n REQUIRE(true == obj.containsKey(obj[\"key\"]));\n REQUIRE(false == obj.containsKey(obj[\"hello\"]));\n }\n\n SECTION(\"std::string\") {\n REQUIRE(true == obj.containsKey(\"hello\"_s));\n }\n\n SECTION(\"unsigned char[]\") {\n unsigned char key[] = \"hello\";\n REQUIRE(true == obj.containsKey(key));\n }\n}\n\nTEST_CASE(\"JsonObjectConst::containsKey()\") {\n JsonDocument doc;\n doc[\"hello\"] = 42;\n auto obj = doc.as();\n\n SECTION(\"supports const char*\") {\n REQUIRE(false == obj.containsKey(\"world\"));\n REQUIRE(true == obj.containsKey(\"hello\"));\n }\n\n SECTION(\"supports std::string\") {\n REQUIRE(false == obj.containsKey(\"world\"_s));\n REQUIRE(true == obj.containsKey(\"hello\"_s));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n REQUIRE(true == obj.containsKey(vla));\n }\n#endif\n\n SECTION(\"supports JsonVariant\") {\n doc[\"key\"] = \"hello\";\n REQUIRE(true == obj.containsKey(obj[\"key\"]));\n REQUIRE(false == obj.containsKey(obj[\"hello\"]));\n }\n}\n\nTEST_CASE(\"JsonVariant::containsKey()\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n SECTION(\"returns false is unbound\") {\n CHECK_FALSE(JsonVariant().containsKey(\"hello\"));\n }\n\n SECTION(\"containsKey(const char*)\") {\n var[\"hello\"] = \"world\";\n\n REQUIRE(var.containsKey(\"hello\") == true);\n REQUIRE(var.containsKey(\"world\") == false);\n }\n\n SECTION(\"containsKey(std::string)\") {\n var[\"hello\"] = \"world\";\n\n REQUIRE(var.containsKey(\"hello\"_s) == true);\n REQUIRE(var.containsKey(\"world\"_s) == false);\n }\n\n SECTION(\"containsKey(JsonVariant)\") {\n var[\"hello\"] = \"world\";\n var[\"key\"] = \"hello\";\n\n REQUIRE(var.containsKey(doc[\"key\"]) == true);\n REQUIRE(var.containsKey(doc[\"foo\"]) == false);\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLAs\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n var[\"hello\"] = \"world\";\n\n REQUIRE(var.containsKey(vla) == true);\n }\n#endif\n}\n\nTEST_CASE(\"JsonVariantConst::containsKey()\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n JsonVariantConst var = doc.as();\n\n SECTION(\"support const char*\") {\n REQUIRE(var.containsKey(\"hello\") == true);\n REQUIRE(var.containsKey(\"world\") == false);\n }\n\n SECTION(\"support std::string\") {\n REQUIRE(var.containsKey(\"hello\"_s) == true);\n REQUIRE(var.containsKey(\"world\"_s) == false);\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n REQUIRE(true == var.containsKey(vla));\n }\n#endif\n\n SECTION(\"support JsonVariant\") {\n doc[\"key\"] = \"hello\";\n REQUIRE(var.containsKey(var[\"key\"]) == true);\n REQUIRE(var.containsKey(var[\"foo\"]) == false);\n }\n}\n" }, { "path": "extras/tests/Deprecated/createNestedArray.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::createNestedArray()\") {\n JsonDocument doc;\n\n SECTION(\"createNestedArray()\") {\n JsonArray array = doc.createNestedArray();\n array.add(42);\n REQUIRE(doc.as() == \"[[42]]\");\n }\n\n SECTION(\"createNestedArray(const char*)\") {\n JsonArray array = doc.createNestedArray(\"key\");\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n SECTION(\"createNestedArray(std::string)\") {\n JsonArray array = doc.createNestedArray(\"key\"_s);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedArray(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonArray array = doc.createNestedArray(vla);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n#endif\n}\n\nTEST_CASE(\"JsonArray::createNestedArray()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n JsonArray nestedArray = array.createNestedArray();\n nestedArray.add(42);\n REQUIRE(doc.as() == \"[[42]]\");\n}\n\nTEST_CASE(\"JsonObject::createNestedArray()\") {\n JsonDocument doc;\n JsonObject object = doc.to();\n\n SECTION(\"createNestedArray(const char*)\") {\n JsonArray array = object.createNestedArray(\"key\");\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n SECTION(\"createNestedArray(std::string)\") {\n JsonArray array = object.createNestedArray(\"key\"_s);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedArray(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonArray array = object.createNestedArray(vla);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n#endif\n}\n\nTEST_CASE(\"JsonVariant::createNestedArray()\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"createNestedArray()\") {\n JsonArray array = variant.createNestedArray();\n array.add(42);\n REQUIRE(doc.as() == \"[[42]]\");\n }\n\n SECTION(\"createNestedArray(const char*)\") {\n JsonArray array = variant.createNestedArray(\"key\");\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n SECTION(\"createNestedArray(std::string)\") {\n JsonArray array = variant.createNestedArray(\"key\"_s);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedArray(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonArray array = variant.createNestedArray(vla);\n array.add(42);\n REQUIRE(doc.as() == \"{\\\"key\\\":[42]}\");\n }\n#endif\n}\n" }, { "path": "extras/tests/Deprecated/createNestedObject.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::createNestedObject()\") {\n JsonDocument doc;\n\n SECTION(\"createNestedObject()\") {\n JsonObject object = doc.createNestedObject();\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n }\n\n SECTION(\"createNestedObject(const char*)\") {\n JsonObject object = doc.createNestedObject(\"key\");\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n SECTION(\"createNestedObject(std::string)\") {\n JsonObject object = doc.createNestedObject(\"key\"_s);\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedObject(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonObject object = doc.createNestedObject(vla);\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n#endif\n}\n\nTEST_CASE(\"JsonArray::createNestedObject()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n JsonObject object = array.createNestedObject();\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n}\n\nTEST_CASE(\"JsonObject::createNestedObject()\") {\n JsonDocument doc;\n JsonObject object = doc.to();\n\n SECTION(\"createNestedObject(const char*)\") {\n JsonObject nestedObject = object.createNestedObject(\"key\");\n nestedObject[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n SECTION(\"createNestedObject(std::string)\") {\n JsonObject nestedObject = object.createNestedObject(\"key\"_s);\n nestedObject[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedObject(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonObject nestedObject = object.createNestedObject(vla);\n nestedObject[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n#endif\n}\n\nTEST_CASE(\"JsonVariant::createNestedObject()\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"createNestedObject()\") {\n JsonObject object = variant.createNestedObject();\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n }\n\n SECTION(\"createNestedObject(const char*)\") {\n JsonObject object = variant.createNestedObject(\"key\");\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n SECTION(\"createNestedObject(std::string)\") {\n JsonObject object = variant.createNestedObject(\"key\"_s);\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"createNestedObject(VLA)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"key\");\n JsonObject object = variant.createNestedObject(vla);\n object[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"key\\\":{\\\"hello\\\":\\\"world\\\"}}\");\n }\n#endif\n}\n" }, { "path": "extras/tests/Deprecated/macros.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JSON_ARRAY_SIZE\") {\n REQUIRE(JSON_ARRAY_SIZE(10) == ArduinoJson::detail::sizeofArray(10));\n}\n\nTEST_CASE(\"JSON_OBJECT_SIZE\") {\n REQUIRE(JSON_OBJECT_SIZE(10) == ArduinoJson::detail::sizeofObject(10));\n}\n\nTEST_CASE(\"JSON_STRING_SIZE\") {\n REQUIRE(JSON_STRING_SIZE(10) == 11); // issue #2054\n}\n" }, { "path": "extras/tests/Deprecated/memoryUsage.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::memoryUsage()\") {\n JsonArray array;\n REQUIRE(array.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonArrayConst::memoryUsage()\") {\n JsonArrayConst array;\n REQUIRE(array.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonDocument::memoryUsage()\") {\n JsonDocument doc;\n REQUIRE(doc.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonObject::memoryUsage()\") {\n JsonObject array;\n REQUIRE(array.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonObjectConst::memoryUsage()\") {\n JsonObjectConst array;\n REQUIRE(array.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonVariant::memoryUsage()\") {\n JsonVariant doc;\n REQUIRE(doc.memoryUsage() == 0);\n}\n\nTEST_CASE(\"JsonVariantConst::memoryUsage()\") {\n JsonVariantConst doc;\n REQUIRE(doc.memoryUsage() == 0);\n}\n\nTEST_CASE(\"ElementProxy::memoryUsage()\") {\n JsonDocument doc;\n REQUIRE(doc[0].memoryUsage() == 0);\n}\n\nTEST_CASE(\"MemberProxy::memoryUsage()\") {\n JsonDocument doc;\n REQUIRE(doc[\"hello\"].memoryUsage() == 0);\n}\n" }, { "path": "extras/tests/Deprecated/shallowCopy.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"shallowCopy()\") {\n JsonDocument doc1, doc2;\n doc1[\"b\"] = \"c\";\n doc2[\"a\"].shallowCopy(doc1);\n\n REQUIRE(doc2.as() == \"{\\\"a\\\":{\\\"b\\\":\\\"c\\\"}}\");\n}\n" }, { "path": "extras/tests/FailingBuilds/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nmacro(add_failing_build source_file)\n\tget_filename_component(target ${source_file} NAME_WE)\n\n\tadd_executable(${target} ${source_file})\n\n\tset_target_properties(${target}\n\t\tPROPERTIES\n\t\t\tEXCLUDE_FROM_ALL TRUE\n\t\t\tEXCLUDE_FROM_DEFAULT_BUILD TRUE\n\t)\n\tadd_test(\n\t\tNAME ${target}\n\t\t\tCOMMAND ${CMAKE_COMMAND} --build . --target ${target} --config $\n\t\t\tWORKING_DIRECTORY ${CMAKE_BINARY_DIR}\n\t)\n\tset_tests_properties(${target}\n\t\tPROPERTIES\n\t\t\tWILL_FAIL TRUE\n\t\t\tLABELS \"WillFail\"\n\t)\nendmacro()\n\nadd_failing_build(Issue978.cpp)\nadd_failing_build(read_long_long.cpp)\nadd_failing_build(write_long_long.cpp)\nadd_failing_build(variant_as_char.cpp)\nadd_failing_build(assign_char.cpp)\nadd_failing_build(deserialize_object.cpp)\n" }, { "path": "extras/tests/FailingBuilds/Issue978.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\nstruct Stream {};\n\nint main() {\n Stream* stream = 0;\n JsonDocument doc;\n deserializeJson(doc, stream);\n}\n" }, { "path": "extras/tests/FailingBuilds/assign_char.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n// See issue #1498\n\nint main() {\n JsonDocument doc;\n doc[\"dummy\"] = 'A';\n}\n" }, { "path": "extras/tests/FailingBuilds/deserialize_object.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n// See issue #2135\n\nint main() {\n JsonObject obj;\n deserializeJson(obj, \"\");\n}\n" }, { "path": "extras/tests/FailingBuilds/read_long_long.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_USE_LONG_LONG 0\n#include \n\n#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8\n# error This test requires sizeof(long) < 8\n#endif\n\nARDUINOJSON_ASSERT_INTEGER_TYPE_IS_SUPPORTED(long long)\nint main() {\n JsonDocument doc;\n doc[\"dummy\"].as();\n}\n" }, { "path": "extras/tests/FailingBuilds/variant_as_char.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n// See issue #1498\n\nint main() {\n JsonDocument doc;\n doc[\"dummy\"].as();\n}\n" }, { "path": "extras/tests/FailingBuilds/write_long_long.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_USE_LONG_LONG 0\n#include \n\n#if defined(__SIZEOF_LONG__) && __SIZEOF_LONG__ >= 8\n# error This test requires sizeof(long) < 8\n#endif\n\nint main() {\n JsonDocument doc;\n doc[\"dummy\"] = static_cast(42);\n}\n" }, { "path": "extras/tests/Helpers/Allocators.hpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n#include \n#include \n\n#include \n\nnamespace {\n\nstruct FailingAllocator : ArduinoJson::Allocator {\n static FailingAllocator* instance() {\n static FailingAllocator allocator;\n return &allocator;\n }\n\n private:\n FailingAllocator() = default;\n ~FailingAllocator() = default;\n\n void* allocate(size_t) override {\n return nullptr;\n }\n\n void deallocate(void*) override {}\n\n void* reallocate(void*, size_t) override {\n return nullptr;\n }\n};\n\nclass AllocatorLogEntry {\n public:\n AllocatorLogEntry(std::string s, size_t n = 1) : str_(s), count_(n) {}\n\n const std::string& str() const {\n return str_;\n }\n\n size_t count() const {\n return count_;\n }\n\n AllocatorLogEntry operator*(size_t n) const {\n return AllocatorLogEntry(str_, n);\n }\n\n private:\n std::string str_;\n size_t count_;\n};\n\ninline AllocatorLogEntry Allocate(size_t s) {\n char buffer[32];\n snprintf(buffer, sizeof(buffer), \"allocate(%zu)\", s);\n return AllocatorLogEntry(buffer);\n}\n\ninline AllocatorLogEntry AllocateFail(size_t s) {\n char buffer[32];\n snprintf(buffer, sizeof(buffer), \"allocate(%zu) -> nullptr\", s);\n return AllocatorLogEntry(buffer);\n}\n\ninline AllocatorLogEntry Reallocate(size_t s1, size_t s2) {\n char buffer[32];\n snprintf(buffer, sizeof(buffer), \"reallocate(%zu, %zu)\", s1, s2);\n return AllocatorLogEntry(buffer);\n}\n\ninline AllocatorLogEntry ReallocateFail(size_t s1, size_t s2) {\n char buffer[32];\n snprintf(buffer, sizeof(buffer), \"reallocate(%zu, %zu) -> nullptr\", s1, s2);\n return AllocatorLogEntry(buffer);\n}\n\ninline AllocatorLogEntry Deallocate(size_t s) {\n char buffer[32];\n snprintf(buffer, sizeof(buffer), \"deallocate(%zu)\", s);\n return AllocatorLogEntry(buffer);\n}\n\nclass AllocatorLog {\n public:\n AllocatorLog() = default;\n AllocatorLog(std::initializer_list list) {\n for (auto& entry : list)\n append(entry);\n }\n\n void clear() {\n log_.str(\"\");\n }\n\n void append(const AllocatorLogEntry& entry) {\n for (size_t i = 0; i < entry.count(); i++)\n log_ << entry.str() << \"\\n\";\n }\n\n std::string str() const {\n auto s = log_.str();\n if (s.empty())\n return \"(empty)\";\n s.pop_back(); // remove the trailing '\\n'\n return s;\n }\n\n bool operator==(const AllocatorLog& other) const {\n return str() == other.str();\n }\n\n friend std::ostream& operator<<(std::ostream& os, const AllocatorLog& log) {\n os << log.str();\n return os;\n }\n\n private:\n std::ostringstream log_;\n};\n\nclass SpyingAllocator : public ArduinoJson::Allocator {\n public:\n SpyingAllocator(\n Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())\n : upstream_(upstream) {}\n virtual ~SpyingAllocator() {}\n\n size_t allocatedBytes() const {\n return allocatedBytes_;\n }\n\n void* allocate(size_t n) override {\n auto block = reinterpret_cast(\n upstream_->allocate(sizeof(AllocatedBlock) + n - 1));\n if (block) {\n log_.append(Allocate(n));\n allocatedBytes_ += n;\n block->size = n;\n return block->payload;\n } else {\n log_.append(AllocateFail(n));\n return nullptr;\n }\n }\n\n void deallocate(void* p) override {\n auto block = AllocatedBlock::fromPayload(p);\n allocatedBytes_ -= block->size;\n log_.append(Deallocate(block ? block->size : 0));\n upstream_->deallocate(block);\n }\n\n void* reallocate(void* p, size_t n) override {\n auto block = AllocatedBlock::fromPayload(p);\n auto oldSize = block ? block->size : 0;\n block = reinterpret_cast(\n upstream_->reallocate(block, sizeof(AllocatedBlock) + n - 1));\n if (block) {\n log_.append(Reallocate(oldSize, n));\n block->size = n;\n allocatedBytes_ += n - oldSize;\n return block->payload;\n } else {\n log_.append(ReallocateFail(oldSize, n));\n return nullptr;\n }\n }\n\n void clearLog() {\n log_.clear();\n }\n\n const AllocatorLog& log() const {\n return log_;\n }\n\n private:\n struct AllocatedBlock {\n size_t size;\n char payload[1];\n\n static AllocatedBlock* fromPayload(void* p) {\n if (!p)\n return nullptr;\n return reinterpret_cast(\n // Cast to void* to silence \"cast increases required alignment of\n // target type [-Werror=cast-align]\"\n reinterpret_cast(reinterpret_cast(p) -\n offsetof(AllocatedBlock, payload)));\n }\n };\n\n AllocatorLog log_;\n Allocator* upstream_;\n size_t allocatedBytes_ = 0;\n};\n\nclass KillswitchAllocator : public ArduinoJson::Allocator {\n public:\n KillswitchAllocator(\n Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())\n : working_(true), upstream_(upstream) {}\n virtual ~KillswitchAllocator() {}\n\n void* allocate(size_t n) override {\n return working_ ? upstream_->allocate(n) : 0;\n }\n\n void deallocate(void* p) override {\n upstream_->deallocate(p);\n }\n\n void* reallocate(void* ptr, size_t n) override {\n return working_ ? upstream_->reallocate(ptr, n) : 0;\n }\n\n // Turn the killswitch on, so all allocation fail\n void on() {\n working_ = false;\n }\n\n private:\n bool working_;\n Allocator* upstream_;\n};\n\nclass TimebombAllocator : public ArduinoJson::Allocator {\n public:\n TimebombAllocator(\n size_t initialCountdown,\n Allocator* upstream = ArduinoJson::detail::DefaultAllocator::instance())\n : countdown_(initialCountdown), upstream_(upstream) {}\n virtual ~TimebombAllocator() {}\n\n void* allocate(size_t n) override {\n if (!countdown_)\n return nullptr;\n countdown_--;\n return upstream_->allocate(n);\n }\n\n void deallocate(void* p) override {\n upstream_->deallocate(p);\n }\n\n void* reallocate(void* ptr, size_t n) override {\n if (!countdown_)\n return nullptr;\n countdown_--;\n return upstream_->reallocate(ptr, n);\n }\n\n void setCountdown(size_t value) {\n countdown_ = value;\n }\n\n private:\n size_t countdown_ = 0;\n Allocator* upstream_;\n};\n} // namespace\n\ninline size_t sizeofPoolList(size_t n = ARDUINOJSON_INITIAL_POOL_COUNT) {\n using namespace ArduinoJson::detail;\n return sizeof(MemoryPool) * n;\n}\n\ntemplate \ninline size_t sizeofPool(\n ArduinoJson::detail::SlotCount n = ARDUINOJSON_POOL_CAPACITY) {\n return ArduinoJson::detail::MemoryPool::slotsToBytes(n);\n}\n\ninline size_t sizeofStringBuffer(size_t iteration = 1) {\n // returns 31, 63, 127, 255, etc.\n auto capacity = ArduinoJson::detail::StringBuilder::initialCapacity;\n for (size_t i = 1; i < iteration; i++)\n capacity = capacity * 2 + 1;\n return ArduinoJson::detail::sizeofString(capacity);\n}\n\ninline size_t sizeofString(const char* s) {\n return ArduinoJson::detail::sizeofString(strlen(s));\n}\n" }, { "path": "extras/tests/Helpers/Arduino.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \"api/Print.h\"\n#include \"api/Stream.h\"\n#include \"api/String.h\"\n#include \"avr/pgmspace.h\"\n\n#define ARDUINO\n#define ARDUINO_H_INCLUDED 1\n" }, { "path": "extras/tests/Helpers/CustomReader.hpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n\nclass CustomReader {\n std::stringstream stream_;\n\n public:\n CustomReader(const char* input) : stream_(input) {}\n CustomReader(const CustomReader&) = delete;\n\n int read() {\n return stream_.get();\n }\n\n size_t readBytes(char* buffer, size_t length) {\n stream_.read(buffer, static_cast(length));\n return static_cast(stream_.gcount());\n }\n};\n" }, { "path": "extras/tests/Helpers/Literals.hpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n\n// the space before _s is required by GCC 4.8\ninline std::string operator\"\" _s(const char* str, size_t len) {\n return std::string(str, len);\n}\n" }, { "path": "extras/tests/Helpers/api/Print.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n#include \n#include \n\nclass Print {\n public:\n virtual ~Print() {}\n\n virtual size_t write(uint8_t) = 0;\n virtual size_t write(const uint8_t* buffer, size_t size) = 0;\n\n size_t write(const char* str) {\n if (!str)\n return 0;\n return write(reinterpret_cast(str), strlen(str));\n }\n\n size_t write(const char* buffer, size_t size) {\n return write(reinterpret_cast(buffer), size);\n }\n};\n\nclass Printable {\n public:\n virtual ~Printable() {}\n virtual size_t printTo(Print& p) const = 0;\n};\n" }, { "path": "extras/tests/Helpers/api/Stream.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n// Reproduces Arduino's Stream class\nclass Stream // : public Print\n{\n public:\n virtual ~Stream() {}\n virtual int read() = 0;\n virtual size_t readBytes(char* buffer, size_t length) = 0;\n};\n" }, { "path": "extras/tests/Helpers/api/String.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n\n// Reproduces Arduino's String class\nclass String {\n public:\n String() = default;\n String(const char* s) {\n if (s)\n str_.assign(s);\n }\n\n void limitCapacityTo(size_t maxCapacity) {\n maxCapacity_ = maxCapacity;\n }\n\n unsigned char concat(const char* s) {\n return concat(s, strlen(s));\n }\n\n size_t length() const {\n return str_.size();\n }\n\n const char* c_str() const {\n return str_.c_str();\n }\n\n bool operator==(const char* s) const {\n return str_ == s;\n }\n\n String& operator=(const char* s) {\n if (s)\n str_.assign(s);\n else\n str_.clear();\n return *this;\n }\n\n char operator[](unsigned int index) const {\n if (index >= str_.size())\n return 0;\n return str_[index];\n }\n\n friend std::ostream& operator<<(std::ostream& lhs, const ::String& rhs) {\n lhs << rhs.str_;\n return lhs;\n }\n\n protected:\n // This function is protected in most Arduino cores\n unsigned char concat(const char* s, size_t n) {\n if (str_.size() + n > maxCapacity_)\n return 0;\n str_.append(s, n);\n return 1;\n }\n\n private:\n std::string str_;\n size_t maxCapacity_ = 1024;\n};\n\nclass StringSumHelper : public ::String {};\n\ninline bool operator==(const std::string& lhs, const ::String& rhs) {\n return lhs == rhs.c_str();\n}\n" }, { "path": "extras/tests/Helpers/avr/pgmspace.h", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include // uint8_t\n\n#define PROGMEM\n\nclass __FlashStringHelper;\n\ninline const void* convertPtrToFlash(const void* s) {\n return reinterpret_cast(s) + 42;\n}\n\ninline const void* convertFlashToPtr(const void* s) {\n return reinterpret_cast(s) - 42;\n}\n\n#define PSTR(X) reinterpret_cast(convertPtrToFlash(X))\n#define F(X) reinterpret_cast(PSTR(X))\n\ninline uint8_t pgm_read_byte(const void* p) {\n return *reinterpret_cast(convertFlashToPtr(p));\n}\n\n#define ARDUINOJSON_DEFINE_PROGMEM_ARRAY(type, name, ...) \\\n static type const ARDUINOJSON_CONCAT2(name, _progmem)[] = __VA_ARGS__; \\\n static type const* name = reinterpret_cast( \\\n convertPtrToFlash(ARDUINOJSON_CONCAT2(name, _progmem)));\n" }, { "path": "extras/tests/IntegrationTests/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(IntegrationTests\n\tgbathree.cpp\n\tissue772.cpp\n\tround_trip.cpp\n\topenweathermap.cpp\n)\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"GNU\" AND CMAKE_CXX_COMPILER_VERSION VERSION_GREATER_EQUAL 6)\n\ttarget_compile_options(IntegrationTests\n\t\tPUBLIC\n\t\t\t-fsingle-precision-constant # issue 544\n\t)\nendif()\n\nadd_test(IntegrationTests IntegrationTests)\n\nset_tests_properties(IntegrationTests\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/IntegrationTests/gbathree.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"Gbathree\") {\n JsonDocument doc;\n\n DeserializationError error = deserializeJson(\n doc,\n \"{\\\"protocol_name\\\":\\\"fluorescence\\\",\\\"repeats\\\":1,\\\"wait\\\":0,\"\n \"\\\"averages\\\":1,\\\"measurements\\\":3,\\\"meas2_light\\\":15,\\\"meas1_\"\n \"baseline\\\":0,\\\"act_light\\\":20,\\\"pulsesize\\\":25,\\\"pulsedistance\\\":\"\n \"10000,\\\"actintensity1\\\":50,\\\"actintensity2\\\":255,\\\"measintensity\\\":\"\n \"255,\\\"calintensity\\\":255,\\\"pulses\\\":[50,50,50],\\\"act\\\":[2,1,2,2],\"\n \"\\\"red\\\":[2,2,2,2],\\\"detectors\\\":[[34,34,34,34],[34,34,34,34],[34,\"\n \"34,34,34],[34,34,34,34]],\\\"alta\\\":[2,2,2,2],\\\"altb\\\":[2,2,2,2],\"\n \"\\\"measlights\\\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,\"\n \"15,15]],\\\"measlights2\\\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],\"\n \"[15,15,15,15]],\\\"altc\\\":[2,2,2,2],\\\"altd\\\":[2,2,2,2]}\");\n JsonObject root = doc.as();\n\n SECTION(\"Success\") {\n REQUIRE(error == DeserializationError::Ok);\n }\n\n SECTION(\"ProtocolName\") {\n REQUIRE(\"fluorescence\" == root[\"protocol_name\"]);\n }\n\n SECTION(\"Repeats\") {\n REQUIRE(1 == root[\"repeats\"]);\n }\n\n SECTION(\"Wait\") {\n REQUIRE(0 == root[\"wait\"]);\n }\n\n SECTION(\"Measurements\") {\n REQUIRE(3 == root[\"measurements\"]);\n }\n\n SECTION(\"Meas2_Light\") {\n REQUIRE(15 == root[\"meas2_light\"]);\n }\n\n SECTION(\"Meas1_Baseline\") {\n REQUIRE(0 == root[\"meas1_baseline\"]);\n }\n\n SECTION(\"Act_Light\") {\n REQUIRE(20 == root[\"act_light\"]);\n }\n\n SECTION(\"Pulsesize\") {\n REQUIRE(25 == root[\"pulsesize\"]);\n }\n\n SECTION(\"Pulsedistance\") {\n REQUIRE(10000 == root[\"pulsedistance\"]);\n }\n\n SECTION(\"Actintensity1\") {\n REQUIRE(50 == root[\"actintensity1\"]);\n }\n\n SECTION(\"Actintensity2\") {\n REQUIRE(255 == root[\"actintensity2\"]);\n }\n\n SECTION(\"Measintensity\") {\n REQUIRE(255 == root[\"measintensity\"]);\n }\n\n SECTION(\"Calintensity\") {\n REQUIRE(255 == root[\"calintensity\"]);\n }\n\n SECTION(\"Pulses\") {\n // \"pulses\":[50,50,50]\n\n JsonArray array = root[\"pulses\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(3 == array.size());\n\n for (size_t i = 0; i < 3; i++) {\n REQUIRE(50 == array[i]);\n }\n }\n\n SECTION(\"Act\") {\n // \"act\":[2,1,2,2]\n\n JsonArray array = root[\"act\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(4 == array.size());\n REQUIRE(2 == array[0]);\n REQUIRE(1 == array[1]);\n REQUIRE(2 == array[2]);\n REQUIRE(2 == array[3]);\n }\n\n SECTION(\"Detectors\") {\n // \"detectors\":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]]\n\n JsonArray array = root[\"detectors\"];\n REQUIRE(array.isNull() == false);\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n JsonArray nestedArray = array[i];\n REQUIRE(4 == nestedArray.size());\n\n for (size_t j = 0; j < 4; j++) {\n REQUIRE(34 == nestedArray[j]);\n }\n }\n }\n\n SECTION(\"Alta\") {\n // alta:[2,2,2,2]\n\n JsonArray array = root[\"alta\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n REQUIRE(2 == array[i]);\n }\n }\n\n SECTION(\"Altb\") {\n // altb:[2,2,2,2]\n\n JsonArray array = root[\"altb\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n REQUIRE(2 == array[i]);\n }\n }\n\n SECTION(\"Measlights\") {\n // \"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]\n\n JsonArray array = root[\"measlights\"];\n REQUIRE(array.isNull() == false);\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n JsonArray nestedArray = array[i];\n\n REQUIRE(4 == nestedArray.size());\n\n for (size_t j = 0; j < 4; j++) {\n REQUIRE(15 == nestedArray[j]);\n }\n }\n }\n\n SECTION(\"Measlights2\") {\n // \"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]\n\n JsonArray array = root[\"measlights2\"];\n REQUIRE(array.isNull() == false);\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n JsonArray nestedArray = array[i];\n REQUIRE(4 == nestedArray.size());\n\n for (size_t j = 0; j < 4; j++) {\n REQUIRE(15 == nestedArray[j]);\n }\n }\n }\n\n SECTION(\"Altc\") {\n // altc:[2,2,2,2]\n\n JsonArray array = root[\"altc\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n REQUIRE(2 == array[i]);\n }\n }\n\n SECTION(\"Altd\") {\n // altd:[2,2,2,2]\n\n JsonArray array = root[\"altd\"];\n REQUIRE(array.isNull() == false);\n\n REQUIRE(4 == array.size());\n\n for (size_t i = 0; i < 4; i++) {\n REQUIRE(2 == array[i]);\n }\n }\n}\n" }, { "path": "extras/tests/IntegrationTests/issue772.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n// https://github.com/bblanchon/ArduinoJson/issues/772\n\nTEST_CASE(\"Issue772\") {\n JsonDocument doc1;\n JsonDocument doc2;\n DeserializationError err;\n std::string data =\n \"{\\\"state\\\":{\\\"reported\\\":{\\\"timestamp\\\":\\\"2018-07-02T09:40:12Z\\\",\"\n \"\\\"mac\\\":\\\"2C3AE84FC076\\\",\\\"firmwareVersion\\\":\\\"v0.2.7-5-gf4d4d78\\\",\"\n \"\\\"visibleLight\\\":261,\\\"infraRed\\\":255,\\\"ultraViolet\\\":0.02,\"\n \"\\\"Temperature\\\":26.63,\\\"Pressure\\\":101145.7,\\\"Humidity\\\":54.79883,\"\n \"\\\"Vbat\\\":4.171261,\\\"soilMoisture\\\":0,\\\"ActB\\\":0}}}\";\n err = deserializeJson(doc1, data);\n REQUIRE(err == DeserializationError::Ok);\n\n data = \"\";\n serializeMsgPack(doc1, data);\n err = deserializeMsgPack(doc2, data);\n\n REQUIRE(err == DeserializationError::Ok);\n}\n" }, { "path": "extras/tests/IntegrationTests/openweathermap.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"OpenWeatherMap\") {\n // clang-format off\n const char* input_json = \"{\\\"cod\\\":\\\"200\\\",\\\"message\\\":0,\\\"cnt\\\":40,\\\"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\\\"},{\\\"dt\\\":1581519600,\\\"main\\\":{\\\"temp\\\":6.82,\\\"feels_like\\\":0.47,\\\"temp_min\\\":6.82,\\\"temp_max\\\":7.52,\\\"pressure\\\":1015,\\\"sea_level\\\":1015,\\\"grnd_level\\\":1011,\\\"humidity\\\":47,\\\"temp_kf\\\":-0.7},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04d\\\"}],\\\"clouds\\\":{\\\"all\\\":97},\\\"wind\\\":{\\\"speed\\\":5.55,\\\"deg\\\":267},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-12 15:00:00\\\"},{\\\"dt\\\":1581530400,\\\"main\\\":{\\\"temp\\\":5.76,\\\"feels_like\\\":1.84,\\\"temp_min\\\":5.76,\\\"temp_max\\\":6.11,\\\"pressure\\\":1015,\\\"sea_level\\\":1015,\\\"grnd_level\\\":1010,\\\"humidity\\\":57,\\\"temp_kf\\\":-0.35},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":99},\\\"wind\\\":{\\\"speed\\\":2.35,\\\"deg\\\":232},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-12 18:00:00\\\"},{\\\"dt\\\":1581541200,\\\"main\\\":{\\\"temp\\\":5.7,\\\"feels_like\\\":1.34,\\\"temp_min\\\":5.7,\\\"temp_max\\\":5.7,\\\"pressure\\\":1012,\\\"sea_level\\\":1012,\\\"grnd_level\\\":1008,\\\"humidity\\\":71,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":3.57,\\\"deg\\\":198},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-12 21:00:00\\\"},{\\\"dt\\\":1581552000,\\\"main\\\":{\\\"temp\\\":5.82,\\\"feels_like\\\":1.39,\\\"temp_min\\\":5.82,\\\"temp_max\\\":5.82,\\\"pressure\\\":1009,\\\"sea_level\\\":1009,\\\"grnd_level\\\":1004,\\\"humidity\\\":86,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":4.35,\\\"deg\\\":169},\\\"rain\\\":{\\\"3h\\\":0.5},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-13 00:00:00\\\"},{\\\"dt\\\":1581562800,\\\"main\\\":{\\\"temp\\\":5.9,\\\"feels_like\\\":-0.85,\\\"temp_min\\\":5.9,\\\"temp_max\\\":5.9,\\\"pressure\\\":1000,\\\"sea_level\\\":1000,\\\"grnd_level\\\":997,\\\"humidity\\\":86,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":7.69,\\\"deg\\\":178},\\\"rain\\\":{\\\"3h\\\":1.75},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-13 03:00:00\\\"},{\\\"dt\\\":1581573600,\\\"main\\\":{\\\"temp\\\":7.52,\\\"feels_like\\\":1.74,\\\"temp_min\\\":7.52,\\\"temp_max\\\":7.52,\\\"pressure\\\":993,\\\"sea_level\\\":993,\\\"grnd_level\\\":988,\\\"humidity\\\":88,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":6.84,\\\"deg\\\":184},\\\"rain\\\":{\\\"3h\\\":7.06},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-13 06:00:00\\\"},{\\\"dt\\\":1581584400,\\\"main\\\":{\\\"temp\\\":7.23,\\\"feels_like\\\":0.81,\\\"temp_min\\\":7.23,\\\"temp_max\\\":7.23,\\\"pressure\\\":992,\\\"sea_level\\\":992,\\\"grnd_level\\\":988,\\\"humidity\\\":69,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":49},\\\"wind\\\":{\\\"speed\\\":6.77,\\\"deg\\\":239},\\\"rain\\\":{\\\"3h\\\":0.25},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-13 09:00:00\\\"},{\\\"dt\\\":1581595200,\\\"main\\\":{\\\"temp\\\":7.67,\\\"feels_like\\\":2.81,\\\"temp_min\\\":7.67,\\\"temp_max\\\":7.67,\\\"pressure\\\":991,\\\"sea_level\\\":991,\\\"grnd_level\\\":987,\\\"humidity\\\":75,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":73},\\\"wind\\\":{\\\"speed\\\":4.93,\\\"deg\\\":235},\\\"rain\\\":{\\\"3h\\\":0.75},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-13 12:00:00\\\"},{\\\"dt\\\":1581606000,\\\"main\\\":{\\\"temp\\\":8.83,\\\"feels_like\\\":3.23,\\\"temp_min\\\":8.83,\\\"temp_max\\\":8.83,\\\"pressure\\\":993,\\\"sea_level\\\":993,\\\"grnd_level\\\":990,\\\"humidity\\\":64,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":83},\\\"wind\\\":{\\\"speed\\\":5.7,\\\"deg\\\":293},\\\"rain\\\":{\\\"3h\\\":0.38},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-13 15:00:00\\\"},{\\\"dt\\\":1581616800,\\\"main\\\":{\\\"temp\\\":7.42,\\\"feels_like\\\":1.77,\\\"temp_min\\\":7.42,\\\"temp_max\\\":7.42,\\\"pressure\\\":1000,\\\"sea_level\\\":1000,\\\"grnd_level\\\":996,\\\"humidity\\\":71,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":803,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"broken clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":54},\\\"wind\\\":{\\\"speed\\\":5.81,\\\"deg\\\":307},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-13 18:00:00\\\"},{\\\"dt\\\":1581627600,\\\"main\\\":{\\\"temp\\\":5.82,\\\"feels_like\\\":0.89,\\\"temp_min\\\":5.82,\\\"temp_max\\\":5.82,\\\"pressure\\\":1007,\\\"sea_level\\\":1007,\\\"grnd_level\\\":1003,\\\"humidity\\\":79,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":800,\\\"main\\\":\\\"Clear\\\",\\\"description\\\":\\\"clear sky\\\",\\\"icon\\\":\\\"01n\\\"}],\\\"clouds\\\":{\\\"all\\\":6},\\\"wind\\\":{\\\"speed\\\":4.76,\\\"deg\\\":300},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-13 21:00:00\\\"},{\\\"dt\\\":1581638400,\\\"main\\\":{\\\"temp\\\":5.58,\\\"feels_like\\\":2.09,\\\"temp_min\\\":5.58,\\\"temp_max\\\":5.58,\\\"pressure\\\":1011,\\\"sea_level\\\":1011,\\\"grnd_level\\\":1007,\\\"humidity\\\":81,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":802,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"scattered clouds\\\",\\\"icon\\\":\\\"03n\\\"}],\\\"clouds\\\":{\\\"all\\\":47},\\\"wind\\\":{\\\"speed\\\":2.73,\\\"deg\\\":326},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-14 00:00:00\\\"},{\\\"dt\\\":1581649200,\\\"main\\\":{\\\"temp\\\":4.27,\\\"feels_like\\\":1.72,\\\"temp_min\\\":4.27,\\\"temp_max\\\":4.27,\\\"pressure\\\":1014,\\\"sea_level\\\":1014,\\\"grnd_level\\\":1010,\\\"humidity\\\":85,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":803,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"broken clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":69},\\\"wind\\\":{\\\"speed\\\":1.24,\\\"deg\\\":295},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-14 03:00:00\\\"},{\\\"dt\\\":1581660000,\\\"main\\\":{\\\"temp\\\":3.91,\\\"feels_like\\\":1.54,\\\"temp_min\\\":3.91,\\\"temp_max\\\":3.91,\\\"pressure\\\":1016,\\\"sea_level\\\":1016,\\\"grnd_level\\\":1012,\\\"humidity\\\":87,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":85},\\\"wind\\\":{\\\"speed\\\":0.98,\\\"deg\\\":211},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-14 06:00:00\\\"},{\\\"dt\\\":1581670800,\\\"main\\\":{\\\"temp\\\":4.77,\\\"feels_like\\\":0.74,\\\"temp_min\\\":4.77,\\\"temp_max\\\":4.77,\\\"pressure\\\":1017,\\\"sea_level\\\":1017,\\\"grnd_level\\\":1013,\\\"humidity\\\":78,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":3.19,\\\"deg\\\":184},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-14 09:00:00\\\"},{\\\"dt\\\":1581681600,\\\"main\\\":{\\\"temp\\\":9.03,\\\"feels_like\\\":4,\\\"temp_min\\\":9.03,\\\"temp_max\\\":9.03,\\\"pressure\\\":1016,\\\"sea_level\\\":1016,\\\"grnd_level\\\":1012,\\\"humidity\\\":73,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":5.43,\\\"deg\\\":206},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-14 12:00:00\\\"},{\\\"dt\\\":1581692400,\\\"main\\\":{\\\"temp\\\":9.86,\\\"feels_like\\\":4.22,\\\"temp_min\\\":9.86,\\\"temp_max\\\":9.86,\\\"pressure\\\":1014,\\\"sea_level\\\":1014,\\\"grnd_level\\\":1010,\\\"humidity\\\":74,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":6.58,\\\"deg\\\":209},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-14 15:00:00\\\"},{\\\"dt\\\":1581703200,\\\"main\\\":{\\\"temp\\\":9.48,\\\"feels_like\\\":4.8,\\\"temp_min\\\":9.48,\\\"temp_max\\\":9.48,\\\"pressure\\\":1013,\\\"sea_level\\\":1013,\\\"grnd_level\\\":1009,\\\"humidity\\\":83,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":5.6,\\\"deg\\\":206},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-14 18:00:00\\\"},{\\\"dt\\\":1581714000,\\\"main\\\":{\\\"temp\\\":10.03,\\\"feels_like\\\":6.48,\\\"temp_min\\\":10.03,\\\"temp_max\\\":10.03,\\\"pressure\\\":1013,\\\"sea_level\\\":1013,\\\"grnd_level\\\":1009,\\\"humidity\\\":93,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":4.75,\\\"deg\\\":226},\\\"rain\\\":{\\\"3h\\\":3.13},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-14 21:00:00\\\"},{\\\"dt\\\":1581724800,\\\"main\\\":{\\\"temp\\\":9.48,\\\"feels_like\\\":6.25,\\\"temp_min\\\":9.48,\\\"temp_max\\\":9.48,\\\"pressure\\\":1013,\\\"sea_level\\\":1013,\\\"grnd_level\\\":1009,\\\"humidity\\\":89,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":3.87,\\\"deg\\\":214},\\\"rain\\\":{\\\"3h\\\":2.38},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-15 00:00:00\\\"},{\\\"dt\\\":1581735600,\\\"main\\\":{\\\"temp\\\":9.12,\\\"feels_like\\\":7.08,\\\"temp_min\\\":9.12,\\\"temp_max\\\":9.12,\\\"pressure\\\":1011,\\\"sea_level\\\":1011,\\\"grnd_level\\\":1007,\\\"humidity\\\":96,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":2.43,\\\"deg\\\":194},\\\"rain\\\":{\\\"3h\\\":1},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-15 03:00:00\\\"},{\\\"dt\\\":1581746400,\\\"main\\\":{\\\"temp\\\":10.32,\\\"feels_like\\\":6.71,\\\"temp_min\\\":10.32,\\\"temp_max\\\":10.32,\\\"pressure\\\":1009,\\\"sea_level\\\":1009,\\\"grnd_level\\\":1004,\\\"humidity\\\":95,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":5.05,\\\"deg\\\":196},\\\"rain\\\":{\\\"3h\\\":1.75},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-15 06:00:00\\\"},{\\\"dt\\\":1581757200,\\\"main\\\":{\\\"temp\\\":11.57,\\\"feels_like\\\":5.85,\\\"temp_min\\\":11.57,\\\"temp_max\\\":11.57,\\\"pressure\\\":1006,\\\"sea_level\\\":1006,\\\"grnd_level\\\":1002,\\\"humidity\\\":85,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":7.91,\\\"deg\\\":205},\\\"rain\\\":{\\\"3h\\\":1.44},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-15 09:00:00\\\"},{\\\"dt\\\":1581768000,\\\"main\\\":{\\\"temp\\\":12.25,\\\"feels_like\\\":4.46,\\\"temp_min\\\":12.25,\\\"temp_max\\\":12.25,\\\"pressure\\\":1003,\\\"sea_level\\\":1003,\\\"grnd_level\\\":998,\\\"humidity\\\":78,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":10.65,\\\"deg\\\":201},\\\"rain\\\":{\\\"3h\\\":1.81},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-15 12:00:00\\\"},{\\\"dt\\\":1581778800,\\\"main\\\":{\\\"temp\\\":12.19,\\\"feels_like\\\":3.17,\\\"temp_min\\\":12.19,\\\"temp_max\\\":12.19,\\\"pressure\\\":998,\\\"sea_level\\\":998,\\\"grnd_level\\\":994,\\\"humidity\\\":80,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":12.52,\\\"deg\\\":204},\\\"rain\\\":{\\\"3h\\\":3.5},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-15 15:00:00\\\"},{\\\"dt\\\":1581789600,\\\"main\\\":{\\\"temp\\\":12.25,\\\"feels_like\\\":4.15,\\\"temp_min\\\":12.25,\\\"temp_max\\\":12.25,\\\"pressure\\\":996,\\\"sea_level\\\":996,\\\"grnd_level\\\":992,\\\"humidity\\\":83,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":11.42,\\\"deg\\\":215},\\\"rain\\\":{\\\"3h\\\":4.88},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-15 18:00:00\\\"},{\\\"dt\\\":1581800400,\\\"main\\\":{\\\"temp\\\":12.64,\\\"feels_like\\\":5.85,\\\"temp_min\\\":12.64,\\\"temp_max\\\":12.64,\\\"pressure\\\":994,\\\"sea_level\\\":994,\\\"grnd_level\\\":990,\\\"humidity\\\":76,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":9.22,\\\"deg\\\":217},\\\"rain\\\":{\\\"3h\\\":6.88},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-15 21:00:00\\\"},{\\\"dt\\\":1581811200,\\\"main\\\":{\\\"temp\\\":12.96,\\\"feels_like\\\":4.03,\\\"temp_min\\\":12.96,\\\"temp_max\\\":12.96,\\\"pressure\\\":988,\\\"sea_level\\\":988,\\\"grnd_level\\\":984,\\\"humidity\\\":83,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":12.88,\\\"deg\\\":211},\\\"rain\\\":{\\\"3h\\\":5.63},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-16 00:00:00\\\"},{\\\"dt\\\":1581822000,\\\"main\\\":{\\\"temp\\\":13.13,\\\"feels_like\\\":5.17,\\\"temp_min\\\":13.13,\\\"temp_max\\\":13.13,\\\"pressure\\\":987,\\\"sea_level\\\":987,\\\"grnd_level\\\":982,\\\"humidity\\\":82,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":501,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"moderate rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":11.49,\\\"deg\\\":246},\\\"rain\\\":{\\\"3h\\\":7.25},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-16 03:00:00\\\"},{\\\"dt\\\":1581832800,\\\"main\\\":{\\\"temp\\\":9.07,\\\"feels_like\\\":0.79,\\\"temp_min\\\":9.07,\\\"temp_max\\\":9.07,\\\"pressure\\\":990,\\\"sea_level\\\":990,\\\"grnd_level\\\":986,\\\"humidity\\\":75,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10n\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":10.18,\\\"deg\\\":255},\\\"rain\\\":{\\\"3h\\\":2},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-16 06:00:00\\\"},{\\\"dt\\\":1581843600,\\\"main\\\":{\\\"temp\\\":8.05,\\\"feels_like\\\":-0.9,\\\"temp_min\\\":8.05,\\\"temp_max\\\":8.05,\\\"pressure\\\":994,\\\"sea_level\\\":994,\\\"grnd_level\\\":990,\\\"humidity\\\":51,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":100},\\\"wind\\\":{\\\"speed\\\":9.65,\\\"deg\\\":245},\\\"rain\\\":{\\\"3h\\\":1.19},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-16 09:00:00\\\"},{\\\"dt\\\":1581854400,\\\"main\\\":{\\\"temp\\\":9.54,\\\"feels_like\\\":0.13,\\\"temp_min\\\":9.54,\\\"temp_max\\\":9.54,\\\"pressure\\\":996,\\\"sea_level\\\":996,\\\"grnd_level\\\":991,\\\"humidity\\\":41,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04d\\\"}],\\\"clouds\\\":{\\\"all\\\":94},\\\"wind\\\":{\\\"speed\\\":10.03,\\\"deg\\\":243},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-16 12:00:00\\\"},{\\\"dt\\\":1581865200,\\\"main\\\":{\\\"temp\\\":9.08,\\\"feels_like\\\":-0.35,\\\"temp_min\\\":9.08,\\\"temp_max\\\":9.08,\\\"pressure\\\":996,\\\"sea_level\\\":996,\\\"grnd_level\\\":991,\\\"humidity\\\":44,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":500,\\\"main\\\":\\\"Rain\\\",\\\"description\\\":\\\"light rain\\\",\\\"icon\\\":\\\"10d\\\"}],\\\"clouds\\\":{\\\"all\\\":89},\\\"wind\\\":{\\\"speed\\\":10.15,\\\"deg\\\":246},\\\"rain\\\":{\\\"3h\\\":0.25},\\\"sys\\\":{\\\"pod\\\":\\\"d\\\"},\\\"dt_txt\\\":\\\"2020-02-16 15:00:00\\\"},{\\\"dt\\\":1581876000,\\\"main\\\":{\\\"temp\\\":7.41,\\\"feels_like\\\":-1.34,\\\"temp_min\\\":7.41,\\\"temp_max\\\":7.41,\\\"pressure\\\":996,\\\"sea_level\\\":996,\\\"grnd_level\\\":992,\\\"humidity\\\":50,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":804,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"overcast clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":94},\\\"wind\\\":{\\\"speed\\\":9.21,\\\"deg\\\":240},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-16 18:00:00\\\"},{\\\"dt\\\":1581886800,\\\"main\\\":{\\\"temp\\\":6.42,\\\"feels_like\\\":-1.7,\\\"temp_min\\\":6.42,\\\"temp_max\\\":6.42,\\\"pressure\\\":997,\\\"sea_level\\\":997,\\\"grnd_level\\\":993,\\\"humidity\\\":58,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":803,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"broken clouds\\\",\\\"icon\\\":\\\"04n\\\"}],\\\"clouds\\\":{\\\"all\\\":67},\\\"wind\\\":{\\\"speed\\\":8.52,\\\"deg\\\":236},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-16 21:00:00\\\"},{\\\"dt\\\":1581897600,\\\"main\\\":{\\\"temp\\\":6.03,\\\"feels_like\\\":-2.65,\\\"temp_min\\\":6.03,\\\"temp_max\\\":6.03,\\\"pressure\\\":996,\\\"sea_level\\\":996,\\\"grnd_level\\\":993,\\\"humidity\\\":51,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":802,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"scattered clouds\\\",\\\"icon\\\":\\\"03n\\\"}],\\\"clouds\\\":{\\\"all\\\":38},\\\"wind\\\":{\\\"speed\\\":8.94,\\\"deg\\\":240},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-17 00:00:00\\\"},{\\\"dt\\\":1581908400,\\\"main\\\":{\\\"temp\\\":5.62,\\\"feels_like\\\":-2.86,\\\"temp_min\\\":5.62,\\\"temp_max\\\":5.62,\\\"pressure\\\":995,\\\"sea_level\\\":995,\\\"grnd_level\\\":991,\\\"humidity\\\":53,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":800,\\\"main\\\":\\\"Clear\\\",\\\"description\\\":\\\"clear sky\\\",\\\"icon\\\":\\\"01n\\\"}],\\\"clouds\\\":{\\\"all\\\":0},\\\"wind\\\":{\\\"speed\\\":8.67,\\\"deg\\\":241},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-17 03:00:00\\\"},{\\\"dt\\\":1581919200,\\\"main\\\":{\\\"temp\\\":5.51,\\\"feels_like\\\":-2.41,\\\"temp_min\\\":5.51,\\\"temp_max\\\":5.51,\\\"pressure\\\":995,\\\"sea_level\\\":995,\\\"grnd_level\\\":991,\\\"humidity\\\":61,\\\"temp_kf\\\":0},\\\"weather\\\":[{\\\"id\\\":802,\\\"main\\\":\\\"Clouds\\\",\\\"description\\\":\\\"scattered clouds\\\",\\\"icon\\\":\\\"03n\\\"}],\\\"clouds\\\":{\\\"all\\\":35},\\\"wind\\\":{\\\"speed\\\":8.2,\\\"deg\\\":244},\\\"sys\\\":{\\\"pod\\\":\\\"n\\\"},\\\"dt_txt\\\":\\\"2020-02-17 06:00:00\\\"}],\\\"city\\\":{\\\"id\\\":2643743,\\\"name\\\":\\\"London\\\",\\\"coord\\\":{\\\"lat\\\":51.5085,\\\"lon\\\":-0.1257},\\\"country\\\":\\\"GB\\\",\\\"population\\\":1000000,\\\"timezone\\\":0,\\\"sunrise\\\":1581492085,\\\"sunset\\\":1581527294}}\";\n\n const char* expected_json = \"{\\\"list\\\":[\"\n \"{\\\"dt\\\":1581498000,\\\"main\\\":{\\\"temp\\\":3.23},\\\"weather\\\":[{\\\"description\\\":\\\"clear sky\\\"}]},\"\n \"{\\\"dt\\\":1581508800,\\\"main\\\":{\\\"temp\\\":6.09},\\\"weather\\\":[{\\\"description\\\":\\\"clear sky\\\"}]},\"\n \"{\\\"dt\\\":1581519600,\\\"main\\\":{\\\"temp\\\":6.82},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581530400,\\\"main\\\":{\\\"temp\\\":5.76},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581541200,\\\"main\\\":{\\\"temp\\\":5.7},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581552000,\\\"main\\\":{\\\"temp\\\":5.82},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581562800,\\\"main\\\":{\\\"temp\\\":5.9},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581573600,\\\"main\\\":{\\\"temp\\\":7.52},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581584400,\\\"main\\\":{\\\"temp\\\":7.23},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581595200,\\\"main\\\":{\\\"temp\\\":7.67},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581606000,\\\"main\\\":{\\\"temp\\\":8.83},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581616800,\\\"main\\\":{\\\"temp\\\":7.42},\\\"weather\\\":[{\\\"description\\\":\\\"broken clouds\\\"}]},\"\n \"{\\\"dt\\\":1581627600,\\\"main\\\":{\\\"temp\\\":5.82},\\\"weather\\\":[{\\\"description\\\":\\\"clear sky\\\"}]},\"\n \"{\\\"dt\\\":1581638400,\\\"main\\\":{\\\"temp\\\":5.58},\\\"weather\\\":[{\\\"description\\\":\\\"scattered clouds\\\"}]},\"\n \"{\\\"dt\\\":1581649200,\\\"main\\\":{\\\"temp\\\":4.27},\\\"weather\\\":[{\\\"description\\\":\\\"broken clouds\\\"}]},\"\n \"{\\\"dt\\\":1581660000,\\\"main\\\":{\\\"temp\\\":3.91},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581670800,\\\"main\\\":{\\\"temp\\\":4.77},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581681600,\\\"main\\\":{\\\"temp\\\":9.03},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581692400,\\\"main\\\":{\\\"temp\\\":9.86},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581703200,\\\"main\\\":{\\\"temp\\\":9.48},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581714000,\\\"main\\\":{\\\"temp\\\":10.03},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581724800,\\\"main\\\":{\\\"temp\\\":9.48},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581735600,\\\"main\\\":{\\\"temp\\\":9.12},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581746400,\\\"main\\\":{\\\"temp\\\":10.32},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581757200,\\\"main\\\":{\\\"temp\\\":11.57},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581768000,\\\"main\\\":{\\\"temp\\\":12.25},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581778800,\\\"main\\\":{\\\"temp\\\":12.19},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581789600,\\\"main\\\":{\\\"temp\\\":12.25},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581800400,\\\"main\\\":{\\\"temp\\\":12.64},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581811200,\\\"main\\\":{\\\"temp\\\":12.96},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581822000,\\\"main\\\":{\\\"temp\\\":13.13},\\\"weather\\\":[{\\\"description\\\":\\\"moderate rain\\\"}]},\"\n \"{\\\"dt\\\":1581832800,\\\"main\\\":{\\\"temp\\\":9.07},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581843600,\\\"main\\\":{\\\"temp\\\":8.05},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581854400,\\\"main\\\":{\\\"temp\\\":9.54},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581865200,\\\"main\\\":{\\\"temp\\\":9.08},\\\"weather\\\":[{\\\"description\\\":\\\"light rain\\\"}]},\"\n \"{\\\"dt\\\":1581876000,\\\"main\\\":{\\\"temp\\\":7.41},\\\"weather\\\":[{\\\"description\\\":\\\"overcast clouds\\\"}]},\"\n \"{\\\"dt\\\":1581886800,\\\"main\\\":{\\\"temp\\\":6.42},\\\"weather\\\":[{\\\"description\\\":\\\"broken clouds\\\"}]},\"\n \"{\\\"dt\\\":1581897600,\\\"main\\\":{\\\"temp\\\":6.03},\\\"weather\\\":[{\\\"description\\\":\\\"scattered clouds\\\"}]},\"\n \"{\\\"dt\\\":1581908400,\\\"main\\\":{\\\"temp\\\":5.62},\\\"weather\\\":[{\\\"description\\\":\\\"clear sky\\\"}]},\"\n \"{\\\"dt\\\":1581919200,\\\"main\\\":{\\\"temp\\\":5.51},\\\"weather\\\":[{\\\"description\\\":\\\"scattered clouds\\\"}]}\"\n \"]}\";\n // clang-format on\n\n JsonDocument filter;\n filter[\"list\"][0][\"dt\"] = true;\n filter[\"list\"][0][\"main\"][\"temp\"] = true;\n filter[\"list\"][0][\"weather\"][0][\"description\"] = true;\n\n JsonDocument doc;\n\n REQUIRE(\n deserializeJson(doc, input_json, DeserializationOption::Filter(filter)) ==\n DeserializationError::Ok);\n\n REQUIRE(doc.as() == expected_json);\n}\n" }, { "path": "extras/tests/IntegrationTests/round_trip.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nvoid check(std::string originalJson) {\n JsonDocument doc;\n\n std::string prettyJson;\n deserializeJson(doc, originalJson);\n serializeJsonPretty(doc, prettyJson);\n\n std::string finalJson;\n deserializeJson(doc, originalJson);\n serializeJson(doc, finalJson);\n\n REQUIRE(originalJson == finalJson);\n}\n\nTEST_CASE(\"Round Trip: parse -> prettyPrint -> parse -> print\") {\n SECTION(\"OpenWeatherMap\") {\n check(\n \"{\\\"coord\\\":{\\\"lon\\\":145.77,\\\"lat\\\":-16.92},\\\"sys\\\":{\\\"type\\\":1,\\\"id\\\":\"\n \"8166,\\\"message\\\":0.1222,\\\"country\\\":\\\"AU\\\",\\\"sunrise\\\":1414784325,\"\n \"\\\"sunset\\\":1414830137},\\\"weather\\\":[{\\\"id\\\":801,\\\"main\\\":\\\"Clouds\\\",\"\n \"\\\"description\\\":\\\"few clouds\\\",\\\"icon\\\":\\\"02n\\\"}],\\\"base\\\":\\\"cmc \"\n \"stations\\\",\\\"main\\\":{\\\"temp\\\":296.15,\\\"pressure\\\":1014,\\\"humidity\\\":\"\n \"83,\\\"temp_min\\\":296.15,\\\"temp_max\\\":296.15},\\\"wind\\\":{\\\"speed\\\":2.22,\"\n \"\\\"deg\\\":114.501},\\\"clouds\\\":{\\\"all\\\":20},\\\"dt\\\":1414846800,\\\"id\\\":\"\n \"2172797,\\\"name\\\":\\\"Cairns\\\",\\\"cod\\\":200}\");\n }\n\n SECTION(\"YahooQueryLanguage\") {\n check(\n \"{\\\"query\\\":{\\\"count\\\":40,\\\"created\\\":\\\"2014-11-01T14:16:49Z\\\",\"\n \"\\\"lang\\\":\\\"fr-FR\\\",\\\"results\\\":{\\\"item\\\":[{\\\"title\\\":\\\"Burkina army \"\n \"backs Zida as interim leader\\\"},{\\\"title\\\":\\\"British jets intercept \"\n \"Russian bombers\\\"},{\\\"title\\\":\\\"Doubts chip away at nation's most \"\n \"trusted agencies\\\"},{\\\"title\\\":\\\"Cruise ship stuck off Norway, no \"\n \"damage\\\"},{\\\"title\\\":\\\"U.S. military launches 10 air strikes in \"\n \"Syria, Iraq\\\"},{\\\"title\\\":\\\"Blackout hits Bangladesh as line from \"\n \"India fails\\\"},{\\\"title\\\":\\\"Burkina Faso president in Ivory Coast \"\n \"after ouster\\\"},{\\\"title\\\":\\\"Kurds in Turkey rally to back city \"\n \"besieged by IS\\\"},{\\\"title\\\":\\\"A majority of Scots would vote for \"\n \"independence now:poll\\\"},{\\\"title\\\":\\\"Tunisia elections possible \"\n \"model for region\\\"},{\\\"title\\\":\\\"Islamic State kills 85 more members \"\n \"of Iraqi tribe\\\"},{\\\"title\\\":\\\"Iraqi officials:IS extremists line \"\n \"up, kill 50\\\"},{\\\"title\\\":\\\"Burkina Faso army backs presidential \"\n \"guard official to lead transition\\\"},{\\\"title\\\":\\\"Kurdish peshmerga \"\n \"arrive with weapons in Syria's Kobani\\\"},{\\\"title\\\":\\\"Driver sought \"\n \"in crash that killed 3 on Halloween\\\"},{\\\"title\\\":\\\"Ex-Marine arrives \"\n \"in US after release from Mexico jail\\\"},{\\\"title\\\":\\\"UN panel \"\n \"scrambling to finish climate report\\\"},{\\\"title\\\":\\\"Investigators, \"\n \"Branson go to spacecraft crash site\\\"},{\\\"title\\\":\\\"Soldiers vie for \"\n \"power after Burkina Faso president quits\\\"},{\\\"title\\\":\\\"For a man \"\n \"without a party, turnout is big test\\\"},{\\\"title\\\":\\\"'We just had a \"\n \"hunch':US marshals nab Eric Frein\\\"},{\\\"title\\\":\\\"Boko Haram leader \"\n \"threatens to kill German hostage\\\"},{\\\"title\\\":\\\"Nurse free to move \"\n \"about as restrictions eased\\\"},{\\\"title\\\":\\\"Former Burkina president \"\n \"Compaore arrives in Ivory Coast:sources\\\"},{\\\"title\\\":\\\"Libyan port \"\n \"rebel leader refuses to hand over oil ports to rival \"\n \"group\\\"},{\\\"title\\\":\\\"Iraqi peshmerga fighters prepare for Syria \"\n \"battle\\\"},{\\\"title\\\":\\\"1 Dem Senate candidate welcoming Obama's \"\n \"help\\\"},{\\\"title\\\":\\\"Bikers cancel party after police recover \"\n \"bar\\\"},{\\\"title\\\":\\\"New question in Texas:Can Davis survive \"\n \"defeat?\\\"},{\\\"title\\\":\\\"Ukraine rebels to hold election, despite \"\n \"criticism\\\"},{\\\"title\\\":\\\"Iraqi officials say Islamic State group \"\n \"lines up, kills 50 tribesmen, women in Anbar \"\n \"province\\\"},{\\\"title\\\":\\\"James rebounds, leads Cavaliers past \"\n \"Bulls\\\"},{\\\"title\\\":\\\"UK warns travelers they could be terror \"\n \"targets\\\"},{\\\"title\\\":\\\"Hello Kitty celebrates 40th \"\n \"birthday\\\"},{\\\"title\\\":\\\"A look at people killed during space \"\n \"missions\\\"},{\\\"title\\\":\\\"Nigeria's purported Boko Haram leader says \"\n \"has 'married off' girls:AFP\\\"},{\\\"title\\\":\\\"Mexico orders immediate \"\n \"release of Marine veteran\\\"},{\\\"title\\\":\\\"As election closes in, \"\n \"Obama on center stage\\\"},{\\\"title\\\":\\\"Body of Zambian president \"\n \"arrives home\\\"},{\\\"title\\\":\\\"South Africa arrests 2 Vietnamese for \"\n \"poaching\\\"}]}}}\");\n }\n}\n" }, { "path": "extras/tests/JsonArray/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonArrayTests\n\tadd.cpp\n\tclear.cpp\n\tcompare.cpp\n\tcopyArray.cpp\n\tequals.cpp\n\tisNull.cpp\n\titerator.cpp\n\tnesting.cpp\n\tremove.cpp\n\tsize.cpp\n\tsubscript.cpp\n\tunbound.cpp\n)\n\nadd_test(JsonArray JsonArrayTests)\n\nset_tests_properties(JsonArray\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonArray/add.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"JsonArray::add(T)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonArray array = doc.to();\n\n SECTION(\"int\") {\n array.add(123);\n\n REQUIRE(123 == array[0].as());\n REQUIRE(array[0].is());\n REQUIRE(array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"double\") {\n array.add(123.45);\n\n REQUIRE(123.45 == array[0].as());\n REQUIRE(array[0].is());\n REQUIRE_FALSE(array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"bool\") {\n array.add(true);\n\n REQUIRE(array[0].as() == true);\n REQUIRE(array[0].is());\n REQUIRE_FALSE(array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"string literal\") {\n array.add(\"hello\");\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(array[0].is());\n REQUIRE(array[0].is() == false);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"std::string\") {\n array.add(\"hello\"_s);\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(array[0].is() == true);\n REQUIRE(array[0].is() == false);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* str = \"hello\";\n array.add(str);\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(array[0].as() != str);\n REQUIRE(array[0].is() == true);\n REQUIRE(array[0].is() == false);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"serialized(const char*)\") {\n array.add(serialized(\"{}\"));\n\n REQUIRE(doc.as() == \"[{}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"{}\")),\n });\n }\n\n SECTION(\"serialized(char*)\") {\n array.add(serialized(const_cast(\"{}\")));\n\n REQUIRE(doc.as() == \"[{}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"{}\")),\n });\n }\n\n SECTION(\"serialized(std::string)\") {\n array.add(serialized(\"{}\"_s));\n\n REQUIRE(doc.as() == \"[{}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"{}\")),\n });\n }\n\n SECTION(\"serialized(std::string)\") {\n array.add(serialized(\"\\0XX\"_s));\n\n REQUIRE(doc.as() == \"[\\0XX]\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\" XX\")),\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"vla\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"world\");\n\n array.add(vla);\n\n strcpy(vla, \"hello\");\n REQUIRE(array[0] == \"world\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n#endif\n\n SECTION(\"nested array\") {\n JsonDocument doc2;\n JsonArray arr = doc2.to();\n\n array.add(arr);\n\n REQUIRE(arr == array[0].as());\n REQUIRE(array[0].is());\n REQUIRE_FALSE(array[0].is());\n }\n\n SECTION(\"nested object\") {\n JsonDocument doc2;\n JsonObject obj = doc2.to();\n\n array.add(obj);\n\n REQUIRE(obj == array[0].as());\n REQUIRE(array[0].is());\n REQUIRE_FALSE(array[0].is());\n }\n\n SECTION(\"array subscript\") {\n const char* str = \"hello\";\n JsonDocument doc2;\n JsonArray arr = doc2.to();\n arr.add(str);\n\n array.add(arr[0]);\n\n REQUIRE(str == array[0]);\n }\n\n SECTION(\"object subscript\") {\n const char* str = \"hello\";\n JsonDocument doc2;\n JsonObject obj = doc2.to();\n obj[\"x\"] = str;\n\n array.add(obj[\"x\"]);\n\n REQUIRE(str == array[0]);\n }\n}\n\nTEST_CASE(\"JsonArray::add()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n\n SECTION(\"add()\") {\n JsonArray nestedArray = array.add();\n nestedArray.add(1);\n nestedArray.add(2);\n REQUIRE(doc.as() == \"[[1,2]]\");\n }\n\n SECTION(\"add()\") {\n JsonObject nestedObject = array.add();\n nestedObject[\"a\"] = 1;\n nestedObject[\"b\"] = 2;\n REQUIRE(doc.as() == \"[{\\\"a\\\":1,\\\"b\\\":2}]\");\n }\n\n SECTION(\"add()\") {\n JsonVariant nestedVariant = array.add();\n nestedVariant.set(42);\n REQUIRE(doc.as() == \"[42]\");\n }\n}\n\nTEST_CASE(\"JsonObject::add(JsonObject) \") {\n JsonDocument doc1;\n doc1[\"key1\"_s] = \"value1\"_s;\n\n TimebombAllocator allocator(10);\n SpyingAllocator spy(&allocator);\n JsonDocument doc2(&spy);\n JsonArray array = doc2.to();\n\n SECTION(\"success\") {\n bool result = array.add(doc1.as());\n\n REQUIRE(result == true);\n REQUIRE(doc2.as() == \"[{\\\"key1\\\":\\\"value1\\\"}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"key1\")),\n Allocate(sizeofString(\"value1\")),\n });\n }\n\n SECTION(\"partial failure\") { // issue #2081\n allocator.setCountdown(2);\n\n bool result = array.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"key1\")),\n AllocateFail(sizeofString(\"value1\")),\n Deallocate(sizeofString(\"key1\")),\n });\n }\n\n SECTION(\"complete failure\") {\n allocator.setCountdown(0);\n\n bool result = array.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofPool()),\n });\n }\n}\n" }, { "path": "extras/tests/JsonArray/clear.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nTEST_CASE(\"JsonArray::clear()\") {\n SECTION(\"No-op on null JsonArray\") {\n JsonArray array;\n array.clear();\n REQUIRE(array.isNull() == true);\n REQUIRE(array.size() == 0);\n }\n\n SECTION(\"Removes all elements\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add(1);\n array.add(2);\n array.clear();\n REQUIRE(array.size() == 0);\n REQUIRE(array.isNull() == false);\n }\n\n SECTION(\"Removed elements are recycled\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonArray array = doc.to();\n\n // fill the pool entirely\n for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)\n array.add(i);\n\n // clear and fill again\n array.clear();\n for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)\n array.add(i);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n });\n }\n}\n" }, { "path": "extras/tests/JsonArray/compare.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"Compare JsonArray with JsonArray\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonArray unbound;\n\n CHECK(array != unbound);\n CHECK_FALSE(array == unbound);\n CHECK_FALSE(array <= unbound);\n CHECK_FALSE(array >= unbound);\n CHECK_FALSE(array > unbound);\n CHECK_FALSE(array < unbound);\n\n CHECK(unbound != array);\n CHECK_FALSE(unbound == array);\n CHECK_FALSE(unbound <= array);\n CHECK_FALSE(unbound >= array);\n CHECK_FALSE(unbound > array);\n CHECK_FALSE(unbound < array);\n }\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n\n CHECK(array == array);\n CHECK(array <= array);\n CHECK(array >= array);\n CHECK_FALSE(array != array);\n CHECK_FALSE(array > array);\n CHECK_FALSE(array < array);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello\");\n array1.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello\");\n array2.add();\n\n CHECK(array1 == array2);\n CHECK(array1 <= array2);\n CHECK(array1 >= array2);\n CHECK_FALSE(array1 != array2);\n CHECK_FALSE(array1 > array2);\n CHECK_FALSE(array1 < array2);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello1\");\n array1.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello2\");\n array2.add();\n\n CHECK(array1 != array2);\n CHECK_FALSE(array1 == array2);\n CHECK_FALSE(array1 > array2);\n CHECK_FALSE(array1 < array2);\n CHECK_FALSE(array1 <= array2);\n CHECK_FALSE(array1 >= array2);\n }\n}\n\nTEST_CASE(\"Compare JsonArray with JsonVariant\") {\n JsonDocument doc;\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n\n JsonVariant variant = array;\n\n CHECK(array == variant);\n CHECK(array <= variant);\n CHECK(array >= variant);\n CHECK_FALSE(array != variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n\n CHECK(variant == array);\n CHECK(variant <= array);\n CHECK(variant >= array);\n CHECK_FALSE(variant != array);\n CHECK_FALSE(variant > array);\n CHECK_FALSE(variant < array);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array = doc.add();\n array.add(1);\n array.add(\"hello\");\n array.add();\n\n JsonVariant variant = doc.add();\n variant.add(1);\n variant.add(\"hello\");\n variant.add();\n\n CHECK(array == variant);\n CHECK(array <= variant);\n CHECK(array >= variant);\n CHECK_FALSE(array != variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n\n CHECK(variant == array);\n CHECK(variant <= array);\n CHECK(variant >= array);\n CHECK_FALSE(variant != array);\n CHECK_FALSE(variant > array);\n CHECK_FALSE(variant < array);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array = doc.add();\n array.add(1);\n array.add(\"hello1\");\n array.add();\n\n JsonVariant variant = doc.add();\n variant.add(1);\n variant.add(\"hello2\");\n variant.add();\n\n CHECK(array != variant);\n CHECK_FALSE(array == variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n CHECK_FALSE(array <= variant);\n CHECK_FALSE(array >= variant);\n }\n}\n\nTEST_CASE(\"Compare JsonArray with JsonVariantConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonVariantConst unbound;\n\n CHECK(array != unbound);\n CHECK_FALSE(array == unbound);\n CHECK_FALSE(array <= unbound);\n CHECK_FALSE(array >= unbound);\n CHECK_FALSE(array > unbound);\n CHECK_FALSE(array < unbound);\n\n CHECK(unbound != array);\n CHECK_FALSE(unbound == array);\n CHECK_FALSE(unbound <= array);\n CHECK_FALSE(unbound >= array);\n CHECK_FALSE(unbound > array);\n CHECK_FALSE(unbound < array);\n }\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n\n JsonVariantConst variant = array;\n\n CHECK(array == variant);\n CHECK(array <= variant);\n CHECK(array >= variant);\n CHECK_FALSE(array != variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n\n CHECK(variant == array);\n CHECK(variant <= array);\n CHECK(variant >= array);\n CHECK_FALSE(variant != array);\n CHECK_FALSE(variant > array);\n CHECK_FALSE(variant < array);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array = doc.add();\n array.add(1);\n array.add(\"hello\");\n array.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello\");\n array2.add();\n JsonVariantConst variant = array2;\n\n CHECK(array == variant);\n CHECK(array <= variant);\n CHECK(array >= variant);\n CHECK_FALSE(array != variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n\n CHECK(variant == array);\n CHECK(variant <= array);\n CHECK(variant >= array);\n CHECK_FALSE(variant != array);\n CHECK_FALSE(variant > array);\n CHECK_FALSE(variant < array);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array = doc.add();\n array.add(1);\n array.add(\"hello1\");\n array.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello2\");\n array2.add();\n JsonVariantConst variant = array2;\n\n CHECK(array != variant);\n CHECK_FALSE(array == variant);\n CHECK_FALSE(array > variant);\n CHECK_FALSE(array < variant);\n CHECK_FALSE(array <= variant);\n CHECK_FALSE(array >= variant);\n }\n}\n\nTEST_CASE(\"Compare JsonArray with JsonArrayConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonArrayConst unbound;\n\n CHECK(array != unbound);\n CHECK_FALSE(array == unbound);\n CHECK_FALSE(array <= unbound);\n CHECK_FALSE(array >= unbound);\n CHECK_FALSE(array > unbound);\n CHECK_FALSE(array < unbound);\n\n CHECK(unbound != array);\n CHECK_FALSE(unbound == array);\n CHECK_FALSE(unbound <= array);\n CHECK_FALSE(unbound >= array);\n CHECK_FALSE(unbound > array);\n CHECK_FALSE(unbound < array);\n }\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonArrayConst carray = array;\n\n CHECK(array == carray);\n CHECK(array <= carray);\n CHECK(array >= carray);\n CHECK_FALSE(array != carray);\n CHECK_FALSE(array > carray);\n CHECK_FALSE(array < carray);\n\n CHECK(carray == array);\n CHECK(carray <= array);\n CHECK(carray >= array);\n CHECK_FALSE(carray != array);\n CHECK_FALSE(carray > array);\n CHECK_FALSE(carray < array);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello\");\n array1.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello\");\n array2.add();\n JsonArrayConst carray2 = array2;\n\n CHECK(array1 == carray2);\n CHECK(array1 <= carray2);\n CHECK(array1 >= carray2);\n CHECK_FALSE(array1 != carray2);\n CHECK_FALSE(array1 > carray2);\n CHECK_FALSE(array1 < carray2);\n\n CHECK(carray2 == array1);\n CHECK(carray2 <= array1);\n CHECK(carray2 >= array1);\n CHECK_FALSE(carray2 != array1);\n CHECK_FALSE(carray2 > array1);\n CHECK_FALSE(carray2 < array1);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello1\");\n array1.add();\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello2\");\n array2.add();\n JsonArrayConst carray2 = array2;\n\n CHECK(array1 != carray2);\n CHECK_FALSE(array1 == carray2);\n CHECK_FALSE(array1 > carray2);\n CHECK_FALSE(array1 < carray2);\n CHECK_FALSE(array1 <= carray2);\n CHECK_FALSE(array1 >= carray2);\n\n CHECK(carray2 != array1);\n CHECK_FALSE(carray2 == array1);\n CHECK_FALSE(carray2 > array1);\n CHECK_FALSE(carray2 < array1);\n CHECK_FALSE(carray2 <= array1);\n CHECK_FALSE(carray2 >= array1);\n }\n}\n\nTEST_CASE(\"Compare JsonArrayConst with JsonArrayConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n\n JsonArrayConst carray = array;\n JsonArrayConst unbound;\n\n CHECK(carray != unbound);\n CHECK_FALSE(carray == unbound);\n CHECK_FALSE(carray <= unbound);\n CHECK_FALSE(carray >= unbound);\n CHECK_FALSE(carray > unbound);\n CHECK_FALSE(carray < unbound);\n\n CHECK(unbound != carray);\n CHECK_FALSE(unbound == carray);\n CHECK_FALSE(unbound <= carray);\n CHECK_FALSE(unbound >= carray);\n CHECK_FALSE(unbound > carray);\n CHECK_FALSE(unbound < carray);\n }\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonArrayConst carray = array;\n\n CHECK(carray == carray);\n CHECK(carray <= carray);\n CHECK(carray >= carray);\n CHECK_FALSE(carray != carray);\n CHECK_FALSE(carray > carray);\n CHECK_FALSE(carray < carray);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello\");\n array1.add();\n JsonArrayConst carray1 = array1;\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello\");\n array2.add();\n JsonArrayConst carray2 = array2;\n\n CHECK(carray1 == carray2);\n CHECK(carray1 <= carray2);\n CHECK(carray1 >= carray2);\n CHECK_FALSE(carray1 != carray2);\n CHECK_FALSE(carray1 > carray2);\n CHECK_FALSE(carray1 < carray2);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello1\");\n array1.add();\n JsonArrayConst carray1 = array1;\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello2\");\n array2.add();\n JsonArrayConst carray2 = array2;\n\n CHECK(carray1 != carray2);\n CHECK_FALSE(carray1 == carray2);\n CHECK_FALSE(carray1 > carray2);\n CHECK_FALSE(carray1 < carray2);\n CHECK_FALSE(carray1 <= carray2);\n CHECK_FALSE(carray1 >= carray2);\n }\n}\n\nTEST_CASE(\"Compare JsonArrayConst with JsonVariant\") {\n JsonDocument doc;\n\n SECTION(\"Compare with self\") {\n JsonArray array = doc.to();\n array.add(1);\n array.add(\"hello\");\n JsonArrayConst carray = array;\n JsonVariant variant = array;\n\n CHECK(carray == variant);\n CHECK(carray <= variant);\n CHECK(carray >= variant);\n CHECK_FALSE(carray != variant);\n CHECK_FALSE(carray > variant);\n CHECK_FALSE(carray < variant);\n\n CHECK(variant == carray);\n CHECK(variant <= carray);\n CHECK(variant >= carray);\n CHECK_FALSE(variant != carray);\n CHECK_FALSE(variant > carray);\n CHECK_FALSE(variant < carray);\n }\n\n SECTION(\"Compare with identical array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello\");\n array1.add();\n JsonArrayConst carray1 = array1;\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello\");\n array2.add();\n JsonVariant variant2 = array2;\n\n CHECK(carray1 == variant2);\n CHECK(carray1 <= variant2);\n CHECK(carray1 >= variant2);\n CHECK_FALSE(carray1 != variant2);\n CHECK_FALSE(carray1 > variant2);\n CHECK_FALSE(carray1 < variant2);\n\n CHECK(variant2 == carray1);\n CHECK(variant2 <= carray1);\n CHECK(variant2 >= carray1);\n CHECK_FALSE(variant2 != carray1);\n CHECK_FALSE(variant2 > carray1);\n CHECK_FALSE(variant2 < carray1);\n }\n\n SECTION(\"Compare with different array\") {\n JsonArray array1 = doc.add();\n array1.add(1);\n array1.add(\"hello1\");\n array1.add();\n JsonArrayConst carray1 = array1;\n\n JsonArray array2 = doc.add();\n array2.add(1);\n array2.add(\"hello2\");\n array2.add();\n JsonVariant variant2 = array2;\n\n CHECK(carray1 != variant2);\n CHECK_FALSE(carray1 == variant2);\n CHECK_FALSE(carray1 > variant2);\n CHECK_FALSE(carray1 < variant2);\n CHECK_FALSE(carray1 <= variant2);\n CHECK_FALSE(carray1 >= variant2);\n\n CHECK(variant2 != carray1);\n CHECK_FALSE(variant2 == carray1);\n CHECK_FALSE(variant2 > carray1);\n CHECK_FALSE(variant2 < carray1);\n CHECK_FALSE(variant2 <= carray1);\n CHECK_FALSE(variant2 >= carray1);\n }\n}\n" }, { "path": "extras/tests/JsonArray/copyArray.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"copyArray()\") {\n SECTION(\"int[] -> JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n char json[32];\n int source[] = {1, 2, 3};\n\n bool ok = copyArray(source, array);\n CHECK(ok);\n\n serializeJson(array, json);\n CHECK(\"[1,2,3]\"_s == json);\n }\n\n SECTION(\"std::string[] -> JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n char json[32];\n std::string source[] = {\"a\", \"b\", \"c\"};\n\n bool ok = copyArray(source, array);\n CHECK(ok);\n\n serializeJson(array, json);\n CHECK(\"[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\"_s == json);\n }\n\n SECTION(\"const char*[] -> JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n char json[32];\n const char* source[] = {\"a\", \"b\", \"c\"};\n\n bool ok = copyArray(source, array);\n CHECK(ok);\n\n serializeJson(array, json);\n CHECK(\"[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\"_s == json);\n }\n\n SECTION(\"const char[][] -> JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n char json[32];\n char source[][2] = {\"a\", \"b\", \"c\"};\n\n bool ok = copyArray(source, array);\n CHECK(ok);\n\n serializeJson(array, json);\n CHECK(\"[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\"_s == json);\n }\n\n SECTION(\"const char[][] -> JsonDocument\") {\n JsonDocument doc;\n char json[32];\n char source[][2] = {\"a\", \"b\", \"c\"};\n\n bool ok = copyArray(source, doc);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\"_s == json);\n }\n\n SECTION(\"const char[][] -> MemberProxy\") {\n JsonDocument doc;\n char json[32];\n char source[][2] = {\"a\", \"b\", \"c\"};\n\n bool ok = copyArray(source, doc[\"data\"]);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"{\\\"data\\\":[\\\"a\\\",\\\"b\\\",\\\"c\\\"]}\"_s == json);\n }\n\n SECTION(\"int[] -> JsonDocument\") {\n JsonDocument doc;\n char json[32];\n int source[] = {1, 2, 3};\n\n bool ok = copyArray(source, doc);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"[1,2,3]\"_s == json);\n }\n\n SECTION(\"int[] -> MemberProxy\") {\n JsonDocument doc;\n char json[32];\n int source[] = {1, 2, 3};\n\n bool ok = copyArray(source, doc[\"data\"]);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"{\\\"data\\\":[1,2,3]}\"_s == json);\n }\n\n SECTION(\"int[] -> JsonArray, but not enough memory\") {\n JsonDocument doc(FailingAllocator::instance());\n JsonArray array = doc.to();\n int source[] = {1, 2, 3};\n\n bool ok = copyArray(source, array);\n REQUIRE_FALSE(ok);\n }\n\n SECTION(\"int[][] -> JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n char json[32];\n int source[][3] = {{1, 2, 3}, {4, 5, 6}};\n\n bool ok = copyArray(source, array);\n CHECK(ok);\n\n serializeJson(array, json);\n CHECK(\"[[1,2,3],[4,5,6]]\"_s == json);\n }\n\n SECTION(\"int[][] -> MemberProxy\") {\n JsonDocument doc;\n char json[32];\n int source[][3] = {{1, 2, 3}, {4, 5, 6}};\n\n bool ok = copyArray(source, doc[\"data\"]);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"{\\\"data\\\":[[1,2,3],[4,5,6]]}\"_s == json);\n }\n\n SECTION(\"int[][] -> JsonDocument\") {\n JsonDocument doc;\n char json[32];\n int source[][3] = {{1, 2, 3}, {4, 5, 6}};\n\n bool ok = copyArray(source, doc);\n CHECK(ok);\n\n serializeJson(doc, json);\n CHECK(\"[[1,2,3],[4,5,6]]\"_s == json);\n }\n\n SECTION(\"int[][] -> JsonArray, but not enough memory\") {\n JsonDocument doc(FailingAllocator::instance());\n JsonArray array = doc.to();\n int source[][3] = {{1, 2, 3}, {4, 5, 6}};\n\n bool ok = copyArray(source, array);\n REQUIRE(ok == false);\n }\n\n SECTION(\"JsonArray -> int[], with more space than needed\") {\n JsonDocument doc;\n char json[] = \"[1,2,3]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n JsonArray array = doc.as();\n\n int destination[4] = {0};\n size_t result = copyArray(array, destination);\n\n CHECK(3 == result);\n CHECK(1 == destination[0]);\n CHECK(2 == destination[1]);\n CHECK(3 == destination[2]);\n CHECK(0 == destination[3]);\n }\n\n SECTION(\"JsonArray -> int[], without enough space\") {\n JsonDocument doc;\n char json[] = \"[1,2,3]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n JsonArray array = doc.as();\n\n int destination[2] = {0};\n size_t result = copyArray(array, destination);\n\n CHECK(2 == result);\n CHECK(1 == destination[0]);\n CHECK(2 == destination[1]);\n }\n\n SECTION(\"JsonArray -> std::string[]\") {\n JsonDocument doc;\n char json[] = \"[\\\"a\\\",\\\"b\\\",\\\"c\\\"]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n JsonArray array = doc.as();\n\n std::string destination[4];\n size_t result = copyArray(array, destination);\n\n CHECK(3 == result);\n CHECK(\"a\" == destination[0]);\n CHECK(\"b\" == destination[1]);\n CHECK(\"c\" == destination[2]);\n CHECK(\"\" == destination[3]);\n }\n\n SECTION(\"JsonArray -> char[N][]\") {\n JsonDocument doc;\n char json[] = \"[\\\"a12345\\\",\\\"b123456\\\",\\\"c1234567\\\"]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n JsonArray array = doc.as();\n\n char destination[4][8] = {{0}};\n size_t result = copyArray(array, destination);\n\n CHECK(3 == result);\n CHECK(\"a12345\"_s == destination[0]);\n CHECK(\"b123456\"_s == destination[1]);\n CHECK(\"c123456\"_s == destination[2]); // truncated\n CHECK(std::string(\"\") == destination[3]);\n }\n\n SECTION(\"JsonDocument -> int[]\") {\n JsonDocument doc;\n char json[] = \"[1,2,3]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n\n int destination[4] = {0};\n size_t result = copyArray(doc, destination);\n\n CHECK(3 == result);\n CHECK(1 == destination[0]);\n CHECK(2 == destination[1]);\n CHECK(3 == destination[2]);\n CHECK(0 == destination[3]);\n }\n\n SECTION(\"MemberProxy -> int[]\") {\n JsonDocument doc;\n char json[] = \"{\\\"data\\\":[1,2,3]}\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n\n int destination[4] = {0};\n size_t result = copyArray(doc[\"data\"], destination);\n\n CHECK(3 == result);\n CHECK(1 == destination[0]);\n CHECK(2 == destination[1]);\n CHECK(3 == destination[2]);\n CHECK(0 == destination[3]);\n }\n\n SECTION(\"ElementProxy -> int[]\") {\n JsonDocument doc;\n char json[] = \"[[1,2,3]]\";\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n\n int destination[4] = {0};\n size_t result = copyArray(doc[0], destination);\n\n CHECK(3 == result);\n CHECK(1 == destination[0]);\n CHECK(2 == destination[1]);\n CHECK(3 == destination[2]);\n CHECK(0 == destination[3]);\n }\n\n SECTION(\"JsonArray -> int[][]\") {\n JsonDocument doc;\n char json[] = \"[[1,2],[3],[4]]\";\n\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n JsonArray array = doc.as();\n\n int destination[3][2] = {{0}};\n copyArray(array, destination);\n\n CHECK(1 == destination[0][0]);\n CHECK(2 == destination[0][1]);\n CHECK(3 == destination[1][0]);\n CHECK(0 == destination[1][1]);\n CHECK(4 == destination[2][0]);\n CHECK(0 == destination[2][1]);\n }\n\n SECTION(\"JsonDocument -> int[][]\") {\n JsonDocument doc;\n char json[] = \"[[1,2],[3],[4]]\";\n\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n\n int destination[3][2] = {{0}};\n copyArray(doc, destination);\n\n CHECK(1 == destination[0][0]);\n CHECK(2 == destination[0][1]);\n CHECK(3 == destination[1][0]);\n CHECK(0 == destination[1][1]);\n CHECK(4 == destination[2][0]);\n CHECK(0 == destination[2][1]);\n }\n\n SECTION(\"MemberProxy -> int[][]\") {\n JsonDocument doc;\n char json[] = \"{\\\"data\\\":[[1,2],[3],[4]]}\";\n\n DeserializationError err = deserializeJson(doc, json);\n CHECK(err == DeserializationError::Ok);\n\n int destination[3][2] = {{0}};\n copyArray(doc[\"data\"], destination);\n\n CHECK(1 == destination[0][0]);\n CHECK(2 == destination[0][1]);\n CHECK(3 == destination[1][0]);\n CHECK(0 == destination[1][1]);\n CHECK(4 == destination[2][0]);\n CHECK(0 == destination[2][1]);\n }\n}\n" }, { "path": "extras/tests/JsonArray/equals.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::operator==()\") {\n JsonDocument doc1;\n JsonArray array1 = doc1.to();\n\n JsonDocument doc2;\n JsonArray array2 = doc2.to();\n\n SECTION(\"should return false when arrays differ\") {\n array1.add(\"coucou\");\n array2.add(1);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return false when LHS has more elements\") {\n array1.add(1);\n array1.add(2);\n array2.add(1);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return false when RHS has more elements\") {\n array1.add(1);\n array2.add(1);\n array2.add(2);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return true when arrays equal\") {\n array1.add(\"coucou\");\n array2.add(\"coucou\");\n\n REQUIRE(array1 == array2);\n }\n\n SECTION(\"should return false when RHS is null\") {\n JsonArray null;\n\n REQUIRE_FALSE(array1 == null);\n }\n\n SECTION(\"should return false when LHS is null\") {\n JsonArray null;\n\n REQUIRE_FALSE(null == array1);\n }\n\n SECTION(\"should return true when both are null\") {\n JsonArray null1;\n JsonArray null2;\n\n REQUIRE(null1 == null2);\n }\n}\n" }, { "path": "extras/tests/JsonArray/isNull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::isNull()\") {\n SECTION(\"returns true\") {\n JsonArray arr;\n REQUIRE(arr.isNull() == true);\n }\n\n SECTION(\"returns false\") {\n JsonDocument doc;\n JsonArray arr = doc.to();\n REQUIRE(arr.isNull() == false);\n }\n}\n\nTEST_CASE(\"JsonArray::operator bool()\") {\n SECTION(\"returns false\") {\n JsonArray arr;\n REQUIRE(static_cast(arr) == false);\n }\n\n SECTION(\"returns true\") {\n JsonDocument doc;\n JsonArray arr = doc.to();\n REQUIRE(static_cast(arr) == true);\n }\n}\n" }, { "path": "extras/tests/JsonArray/iterator.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::begin()/end()\") {\n SECTION(\"Non null JsonArray\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add(12);\n array.add(34);\n\n auto it = array.begin();\n auto end = array.end();\n\n REQUIRE(end != it);\n REQUIRE(12 == it->as());\n REQUIRE(12 == static_cast(*it));\n ++it;\n REQUIRE(end != it);\n REQUIRE(34 == it->as());\n REQUIRE(34 == static_cast(*it));\n ++it;\n REQUIRE(end == it);\n }\n\n SECTION(\"Null JsonArray\") {\n JsonArray array;\n\n REQUIRE(array.begin() == array.end());\n }\n}\n" }, { "path": "extras/tests/JsonArray/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::nesting()\") {\n JsonDocument doc;\n JsonArray arr = doc.to();\n\n SECTION(\"return 0 if uninitialized\") {\n JsonArray unitialized;\n REQUIRE(unitialized.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty array\") {\n REQUIRE(arr.nesting() == 1);\n }\n\n SECTION(\"returns 1 for flat array\") {\n arr.add(\"hello\");\n REQUIRE(arr.nesting() == 1);\n }\n\n SECTION(\"returns 2 with nested array\") {\n arr.add();\n REQUIRE(arr.nesting() == 2);\n }\n\n SECTION(\"returns 2 with nested object\") {\n arr.add();\n REQUIRE(arr.nesting() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonArray/remove.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nTEST_CASE(\"JsonArray::remove()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add(1);\n array.add(2);\n array.add(3);\n\n SECTION(\"remove first by index\") {\n array.remove(0);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 2);\n REQUIRE(array[1] == 3);\n }\n\n SECTION(\"remove middle by index\") {\n array.remove(1);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 3);\n }\n\n SECTION(\"remove last by index\") {\n array.remove(2);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 2);\n }\n\n SECTION(\"remove first by iterator\") {\n JsonArray::iterator it = array.begin();\n array.remove(it);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 2);\n REQUIRE(array[1] == 3);\n }\n\n SECTION(\"remove middle by iterator\") {\n JsonArray::iterator it = array.begin();\n ++it;\n array.remove(it);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 3);\n }\n\n SECTION(\"remove last bty iterator\") {\n JsonArray::iterator it = array.begin();\n ++it;\n ++it;\n array.remove(it);\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 2);\n }\n\n SECTION(\"remove end()\") {\n array.remove(array.end());\n\n REQUIRE(3 == array.size());\n }\n\n SECTION(\"In a loop\") {\n for (JsonArray::iterator it = array.begin(); it != array.end(); ++it) {\n if (*it == 2)\n array.remove(it);\n }\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 3);\n }\n\n SECTION(\"remove by index on unbound reference\") {\n JsonArray unboundArray;\n unboundArray.remove(20);\n }\n\n SECTION(\"remove by iterator on unbound reference\") {\n JsonArray unboundArray;\n unboundArray.remove(unboundArray.begin());\n }\n\n SECTION(\"use JsonVariant as index\") {\n array.remove(array[3]); // no effect with null variant\n array.remove(array[0]); // remove element at index 1\n\n REQUIRE(2 == array.size());\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 3);\n }\n}\n\nTEST_CASE(\"Removed elements are recycled\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonArray array = doc.to();\n\n // fill the pool entirely\n for (int i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)\n array.add(i);\n\n // free one slot in the pool\n array.remove(0);\n\n // add one element; it should use the free slot\n array.add(42);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()), // only one pool\n });\n}\n" }, { "path": "extras/tests/JsonArray/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArray::size()\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n\n SECTION(\"returns 0 is empty\") {\n REQUIRE(0U == array.size());\n }\n\n SECTION(\"increases after add()\") {\n array.add(\"hello\");\n REQUIRE(1U == array.size());\n\n array.add(\"world\");\n REQUIRE(2U == array.size());\n }\n\n SECTION(\"remains the same after replacing an element\") {\n array.add(\"hello\");\n REQUIRE(1U == array.size());\n\n array[0] = \"hello\";\n REQUIRE(1U == array.size());\n }\n}\n" }, { "path": "extras/tests/JsonArray/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonArray::operator[]\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonArray array = doc.to();\n\n SECTION(\"Pad with null\") {\n array[2] = 2;\n array[5] = 5;\n REQUIRE(array.size() == 6);\n REQUIRE(array[0].isNull() == true);\n REQUIRE(array[1].isNull() == true);\n REQUIRE(array[2].isNull() == false);\n REQUIRE(array[3].isNull() == true);\n REQUIRE(array[4].isNull() == true);\n REQUIRE(array[5].isNull() == false);\n REQUIRE(array[2] == 2);\n REQUIRE(array[5] == 5);\n }\n\n SECTION(\"int\") {\n array[0] = 123;\n REQUIRE(123 == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"long long\") {\n array[0] = 9223372036854775807;\n REQUIRE(9223372036854775807 == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n REQUIRE(false == array[0].is());\n }\n#endif\n\n SECTION(\"double\") {\n array[0] = 123.45;\n REQUIRE(123.45 == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n }\n\n SECTION(\"bool\") {\n array[0] = true;\n REQUIRE(true == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n }\n\n SECTION(\"string literal\") {\n array[0] = \"hello\";\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* str = \"hello\";\n array[0] = str;\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"std::string\") {\n array[0] = \"hello\"_s;\n\n REQUIRE(array[0].as() == \"hello\");\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"world\");\n\n array.add(\"hello\");\n array[0] = vla;\n\n REQUIRE(array[0] == \"world\"_s);\n }\n#endif\n\n SECTION(\"nested array\") {\n JsonDocument doc2;\n JsonArray arr2 = doc2.to();\n\n array[0] = arr2;\n\n REQUIRE(arr2 == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n }\n\n SECTION(\"nested object\") {\n JsonDocument doc2;\n JsonObject obj = doc2.to();\n\n array[0] = obj;\n\n REQUIRE(obj == array[0].as());\n REQUIRE(true == array[0].is());\n REQUIRE(false == array[0].is());\n }\n\n SECTION(\"array subscript\") {\n JsonDocument doc2;\n JsonArray arr2 = doc2.to();\n const char* str = \"hello\";\n\n arr2.add(str);\n\n array[0] = arr2[0];\n\n REQUIRE(str == array[0]);\n }\n\n SECTION(\"object subscript\") {\n const char* str = \"hello\";\n JsonDocument doc2;\n JsonObject obj = doc2.to();\n\n obj[\"x\"] = str;\n\n array[0] = obj[\"x\"];\n\n REQUIRE(str == array[0]);\n }\n\n SECTION(\"array[0].to()\") {\n JsonObject obj = array[0].to();\n REQUIRE(obj.isNull() == false);\n }\n\n SECTION(\"Use a JsonVariant as index\") {\n array[0] = 1;\n array[1] = 2;\n array[2] = 3;\n\n REQUIRE(array[array[1]] == 3);\n REQUIRE(array[array[3]] == nullptr);\n }\n}\n" }, { "path": "extras/tests/JsonArray/unbound.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace Catch::Matchers;\n\nTEST_CASE(\"Unbound JsonArray\") {\n JsonArray array;\n\n SECTION(\"SubscriptFails\") {\n REQUIRE(array[0].isNull());\n }\n\n SECTION(\"AddFails\") {\n array.add(1);\n REQUIRE(0 == array.size());\n }\n\n SECTION(\"PrintToWritesBrackets\") {\n char buffer[32];\n serializeJson(array, buffer, sizeof(buffer));\n REQUIRE_THAT(buffer, Equals(\"null\"));\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonArrayConstTests\n\tequals.cpp\n\tisNull.cpp\n\titerator.cpp\n\tnesting.cpp\n\tsize.cpp\n\tsubscript.cpp\n)\n\nadd_test(JsonArrayConst JsonArrayConstTests)\n\nset_tests_properties(JsonArrayConst\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonArrayConst/equals.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::operator==()\") {\n JsonDocument doc1;\n JsonArrayConst array1 = doc1.to();\n\n JsonDocument doc2;\n JsonArrayConst array2 = doc2.to();\n\n SECTION(\"should return false when arrays differ\") {\n doc1.add(\"coucou\");\n doc2.add(1);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return false when LHS has more elements\") {\n doc1.add(1);\n doc1.add(2);\n doc2.add(1);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return false when RHS has more elements\") {\n doc1.add(1);\n doc2.add(1);\n doc2.add(2);\n\n REQUIRE_FALSE(array1 == array2);\n }\n\n SECTION(\"should return true when arrays equal\") {\n doc1.add(\"coucou\");\n doc2.add(\"coucou\");\n\n REQUIRE(array1 == array2);\n }\n\n SECTION(\"should return false when RHS is null\") {\n JsonArrayConst null;\n\n REQUIRE_FALSE(array1 == null);\n }\n\n SECTION(\"should return false when LHS is null\") {\n JsonArrayConst null;\n\n REQUIRE_FALSE(null == array1);\n }\n\n SECTION(\"should return true when both are null\") {\n JsonArrayConst null1;\n JsonArrayConst null2;\n\n REQUIRE(null1 == null2);\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/isNull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::isNull()\") {\n SECTION(\"returns true\") {\n JsonArrayConst arr;\n REQUIRE(arr.isNull() == true);\n }\n\n SECTION(\"returns false\") {\n JsonDocument doc;\n JsonArrayConst arr = doc.to();\n REQUIRE(arr.isNull() == false);\n }\n}\n\nTEST_CASE(\"JsonArrayConst::operator bool()\") {\n SECTION(\"returns false\") {\n JsonArrayConst arr;\n REQUIRE(static_cast(arr) == false);\n }\n\n SECTION(\"returns true\") {\n JsonDocument doc;\n JsonArrayConst arr = doc.to();\n REQUIRE(static_cast(arr) == true);\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/iterator.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::begin()/end()\") {\n SECTION(\"Non null JsonArrayConst\") {\n JsonDocument doc;\n JsonArrayConst array = doc.to();\n doc.add(12);\n doc.add(34);\n\n auto it = array.begin();\n auto end = array.end();\n\n REQUIRE(end != it);\n REQUIRE(12 == it->as());\n REQUIRE(12 == static_cast(*it));\n ++it;\n REQUIRE(end != it);\n REQUIRE(34 == it->as());\n REQUIRE(34 == static_cast(*it));\n ++it;\n REQUIRE(end == it);\n }\n\n SECTION(\"Null JsonArrayConst\") {\n JsonArrayConst array;\n\n REQUIRE(array.begin() == array.end());\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::nesting()\") {\n JsonDocument doc;\n JsonArrayConst arr = doc.to();\n\n SECTION(\"return 0 if unbound\") {\n JsonArrayConst unbound;\n REQUIRE(unbound.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty array\") {\n REQUIRE(arr.nesting() == 1);\n }\n\n SECTION(\"returns 1 for flat array\") {\n doc.add(\"hello\");\n REQUIRE(arr.nesting() == 1);\n }\n\n SECTION(\"returns 2 with nested array\") {\n doc.add();\n REQUIRE(arr.nesting() == 2);\n }\n\n SECTION(\"returns 2 with nested object\") {\n doc.add();\n REQUIRE(arr.nesting() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::size()\") {\n JsonDocument doc;\n JsonArrayConst array = doc.to();\n\n SECTION(\"returns 0 if unbound\") {\n JsonArrayConst unbound;\n REQUIRE(0U == unbound.size());\n }\n\n SECTION(\"returns 0 is empty\") {\n REQUIRE(0U == array.size());\n }\n\n SECTION(\"return number of elements\") {\n doc.add(\"hello\");\n doc.add(\"world\");\n\n REQUIRE(2U == array.size());\n }\n}\n" }, { "path": "extras/tests/JsonArrayConst/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nTEST_CASE(\"JsonArrayConst::operator[]\") {\n JsonDocument doc;\n JsonArrayConst arr = doc.to();\n doc.add(1);\n doc.add(2);\n doc.add(3);\n\n SECTION(\"int\") {\n REQUIRE(1 == arr[0].as());\n REQUIRE(2 == arr[1].as());\n REQUIRE(3 == arr[2].as());\n REQUIRE(0 == arr[3].as());\n }\n\n SECTION(\"JsonVariant\") {\n REQUIRE(2 == arr[arr[0]].as());\n REQUIRE(0 == arr[arr[3]].as());\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonDeserializerTests\n\tarray.cpp\n\tDeserializationError.cpp\n\tdestination_types.cpp\n\terrors.cpp\n\tfilter.cpp\n\tinput_types.cpp\n\tmisc.cpp\n\tnestingLimit.cpp\n\tnumber.cpp\n\tobject.cpp\n\tstring.cpp\n)\n\nset_target_properties(JsonDeserializerTests PROPERTIES UNITY_BUILD OFF)\n\nadd_test(JsonDeserializer JsonDeserializerTests)\n\nset_tests_properties(JsonDeserializer\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonDeserializer/DeserializationError.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nvoid testStringification(DeserializationError error, std::string expected) {\n REQUIRE(error.c_str() == expected);\n}\n\nvoid testBoolification(DeserializationError error, bool expected) {\n // DeserializationError on left-hand side\n CHECK(bool(error) == expected);\n CHECK(bool(error) != !expected);\n CHECK(!bool(error) == !expected);\n\n // DeserializationError on right-hand side\n CHECK(expected == bool(error));\n CHECK(!expected != bool(error));\n CHECK(!expected == !bool(error));\n}\n\n#define TEST_STRINGIFICATION(symbol) \\\n testStringification(DeserializationError::symbol, #symbol)\n\n#define TEST_BOOLIFICATION(symbol, expected) \\\n testBoolification(DeserializationError::symbol, expected)\n\nTEST_CASE(\"DeserializationError\") {\n SECTION(\"c_str()\") {\n TEST_STRINGIFICATION(Ok);\n TEST_STRINGIFICATION(EmptyInput);\n TEST_STRINGIFICATION(IncompleteInput);\n TEST_STRINGIFICATION(InvalidInput);\n TEST_STRINGIFICATION(NoMemory);\n TEST_STRINGIFICATION(TooDeep);\n }\n\n SECTION(\"as boolean\") {\n TEST_BOOLIFICATION(Ok, false);\n TEST_BOOLIFICATION(EmptyInput, true);\n TEST_BOOLIFICATION(IncompleteInput, true);\n TEST_BOOLIFICATION(InvalidInput, true);\n TEST_BOOLIFICATION(NoMemory, true);\n TEST_BOOLIFICATION(TooDeep, true);\n }\n\n SECTION(\"ostream DeserializationError\") {\n std::stringstream s;\n s << DeserializationError(DeserializationError::InvalidInput);\n REQUIRE(s.str() == \"InvalidInput\");\n }\n\n SECTION(\"ostream DeserializationError::Code\") {\n std::stringstream s;\n s << DeserializationError::InvalidInput;\n REQUIRE(s.str() == \"InvalidInput\");\n }\n\n SECTION(\"switch\") {\n DeserializationError err = DeserializationError::InvalidInput;\n switch (err.code()) {\n case DeserializationError::InvalidInput:\n SUCCEED();\n break;\n default:\n FAIL();\n break;\n }\n }\n\n SECTION(\"Use in a condition\") {\n DeserializationError invalidInput(DeserializationError::InvalidInput);\n DeserializationError ok(DeserializationError::Ok);\n\n SECTION(\"if (!err)\") {\n if (!invalidInput)\n FAIL();\n }\n\n SECTION(\"if (err)\") {\n if (ok)\n FAIL();\n }\n }\n\n SECTION(\"Comparisons\") {\n DeserializationError invalidInput(DeserializationError::InvalidInput);\n DeserializationError ok(DeserializationError::Ok);\n\n SECTION(\"DeserializationError == Code\") {\n REQUIRE(invalidInput == DeserializationError::InvalidInput);\n REQUIRE(ok == DeserializationError::Ok);\n }\n\n SECTION(\"Code == DeserializationError\") {\n REQUIRE(DeserializationError::InvalidInput == invalidInput);\n REQUIRE(DeserializationError::Ok == ok);\n }\n\n SECTION(\"DeserializationError != Code\") {\n REQUIRE(invalidInput != DeserializationError::Ok);\n REQUIRE(ok != DeserializationError::InvalidInput);\n }\n\n SECTION(\"Code != DeserializationError\") {\n REQUIRE(DeserializationError::Ok != invalidInput);\n REQUIRE(DeserializationError::InvalidInput != ok);\n }\n\n SECTION(\"DeserializationError == DeserializationError\") {\n REQUIRE_FALSE(invalidInput == ok);\n }\n\n SECTION(\"DeserializationError != DeserializationError\") {\n REQUIRE(invalidInput != ok);\n }\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/array.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"deserialize JSON array\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"An empty array\") {\n DeserializationError err = deserializeJson(doc, \"[]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(0 == arr.size());\n }\n\n SECTION(\"Spaces\") {\n SECTION(\"Before the opening bracket\") {\n DeserializationError err = deserializeJson(doc, \" []\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(0 == arr.size());\n }\n\n SECTION(\"Before first value\") {\n DeserializationError err = deserializeJson(doc, \"[ \\t\\r\\n42]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == 42);\n }\n\n SECTION(\"After first value\") {\n DeserializationError err = deserializeJson(doc, \"[42 \\t\\r\\n]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == 42);\n }\n }\n\n SECTION(\"Values types\") {\n SECTION(\"On integer\") {\n DeserializationError err = deserializeJson(doc, \"[42]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == 42);\n }\n\n SECTION(\"Two integers\") {\n DeserializationError err = deserializeJson(doc, \"[42,84]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == 42);\n REQUIRE(arr[1] == 84);\n }\n\n SECTION(\"Float\") {\n DeserializationError err = deserializeJson(doc, \"[4.2,1e2]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0].as() == Approx(4.2f));\n REQUIRE(arr[1] == 1e2f);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofPool(2)),\n });\n }\n\n SECTION(\"Double\") {\n DeserializationError err = deserializeJson(doc, \"[4.2123456,-7E89]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0].as() == Approx(4.2123456));\n REQUIRE(arr[1] == -7E89);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(),\n sizeofPool(2)),\n Reallocate(sizeofPool(),\n sizeofPool(2)),\n });\n }\n\n SECTION(\"Unsigned long\") {\n DeserializationError err = deserializeJson(doc, \"[4294967295]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == 4294967295UL);\n }\n\n SECTION(\"Boolean\") {\n DeserializationError err = deserializeJson(doc, \"[true,false]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == true);\n REQUIRE(arr[1] == false);\n }\n\n SECTION(\"Null\") {\n DeserializationError err = deserializeJson(doc, \"[null,null]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0].as() == 0);\n REQUIRE(arr[1].as() == 0);\n }\n }\n\n SECTION(\"Quotes\") {\n SECTION(\"Double quotes\") {\n DeserializationError err =\n deserializeJson(doc, \"[ \\\"hello\\\" , \\\"world\\\" ]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"Single quotes\") {\n DeserializationError err = deserializeJson(doc, \"[ 'hello' , 'world' ]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"No quotes\") {\n DeserializationError err = deserializeJson(doc, \"[ hello , world ]\");\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"Double quotes (empty strings)\") {\n DeserializationError err = deserializeJson(doc, \"[\\\"\\\",\\\"\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"\");\n REQUIRE(arr[1] == \"\");\n }\n\n SECTION(\"Single quotes (empty strings)\") {\n DeserializationError err = deserializeJson(doc, \"[\\'\\',\\'\\']\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"\");\n REQUIRE(arr[1] == \"\");\n }\n\n SECTION(\"No quotes (empty strings)\") {\n DeserializationError err = deserializeJson(doc, \"[,]\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"Closing single quotes missing\") {\n DeserializationError err = deserializeJson(doc, \"[\\\"]\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"Closing double quotes missing\") {\n DeserializationError err = deserializeJson(doc, \"[\\']\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n\n SECTION(\"Premature null-terminator\") {\n SECTION(\"After opening bracket\") {\n DeserializationError err = deserializeJson(doc, \"[\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After value\") {\n DeserializationError err = deserializeJson(doc, \"[1\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err = deserializeJson(doc, \"[1,\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n\n SECTION(\"Premature end of input\") {\n const char* input = \"[1,2]\";\n\n SECTION(\"After opening bracket\") {\n DeserializationError err = deserializeJson(doc, input, 1);\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After value\") {\n DeserializationError err = deserializeJson(doc, input, 2);\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err = deserializeJson(doc, input, 3);\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n\n SECTION(\"Misc\") {\n SECTION(\"Nested objects\") {\n char jsonString[] =\n \" [ { \\\"a\\\" : 1 , \\\"b\\\" : 2 } , { \\\"c\\\" : 3 , \\\"d\\\" : 4 } ] \";\n\n DeserializationError err = deserializeJson(doc, jsonString);\n JsonArray arr = doc.as();\n\n JsonObject object1 = arr[0];\n const JsonObject object2 = arr[1];\n JsonObject object3 = arr[2];\n\n REQUIRE(err == DeserializationError::Ok);\n\n REQUIRE(object1.isNull() == false);\n REQUIRE(object2.isNull() == false);\n REQUIRE(object3.isNull() == true);\n\n REQUIRE(2 == object1.size());\n REQUIRE(2 == object2.size());\n REQUIRE(0 == object3.size());\n\n REQUIRE(1 == object1[\"a\"].as());\n REQUIRE(2 == object1[\"b\"].as());\n REQUIRE(3 == object2[\"c\"].as());\n REQUIRE(4 == object2[\"d\"].as());\n REQUIRE(0 == object3[\"e\"].as());\n }\n }\n\n SECTION(\"Should clear the JsonArray\") {\n deserializeJson(doc, \"[1,2,3,4]\");\n spy.clearLog();\n\n deserializeJson(doc, \"[]\");\n\n JsonArray arr = doc.as();\n REQUIRE(arr.size() == 0);\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofArray(4)),\n });\n }\n}\n\nTEST_CASE(\"deserialize JSON array under memory constraints\") {\n TimebombAllocator timebomb(100);\n SpyingAllocator spy(&timebomb);\n JsonDocument doc(&spy);\n\n SECTION(\"empty array requires no allocation\") {\n timebomb.setCountdown(0);\n char input[] = \"[]\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"allocation of pool list fails\") {\n timebomb.setCountdown(0);\n char input[] = \"[1]\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"[]\");\n }\n\n SECTION(\"allocation of pool fails\") {\n timebomb.setCountdown(0);\n char input[] = \"[1]\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"[]\");\n }\n\n SECTION(\"allocation of string fails in array\") {\n timebomb.setCountdown(1);\n char input[] = \"[0,\\\"hi!\\\"]\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"[0,null]\");\n }\n\n SECTION(\"don't store space characters\") {\n deserializeJson(doc, \" [ \\\"1234567\\\" ] \");\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"1234567\")),\n Reallocate(sizeofPool(), sizeofArray(1)),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/destination_types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"deserializeJson(JsonDocument&)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n auto err = deserializeJson(doc, \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[42]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofPool()),\n Deallocate(sizeofString(\"hello\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofArray(1)),\n });\n}\n\nTEST_CASE(\"deserializeJson(JsonVariant)\") {\n SECTION(\"variant is bound\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n JsonVariant variant = doc[0];\n\n auto err = deserializeJson(variant, \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[[42]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"variant is unbound\") {\n JsonVariant variant;\n\n auto err = deserializeJson(variant, \"[42]\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n\nTEST_CASE(\"deserializeJson(ElementProxy)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n SECTION(\"element already exists\") {\n auto err = deserializeJson(doc[0], \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[[42]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"element must be created\") {\n auto err = deserializeJson(doc[1], \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[\\\"hello\\\",[42]]\");\n REQUIRE(spy.log() == AllocatorLog{});\n }\n}\n\nTEST_CASE(\"deserializeJson(MemberProxy)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc[\"hello\"_s] = \"world\"_s;\n spy.clearLog();\n\n SECTION(\"member already exists\") {\n auto err = deserializeJson(doc[\"hello\"], \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{\\\"hello\\\":[42]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"member must be created exists\") {\n auto err = deserializeJson(doc[\"value\"], \"[42]\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\",\\\"value\\\":[42]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"value\")),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/errors.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_DECODE_UNICODE 1\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nTEST_CASE(\"deserializeJson() returns IncompleteInput\") {\n const char* testCases[] = {\n // strings\n \"\\\"\\\\\",\n \"\\\"hello\",\n \"\\'hello\",\n // unicode\n \"'\\\\u\",\n \"'\\\\u00\",\n \"'\\\\u000\",\n // false\n \"f\",\n \"fa\",\n \"fal\",\n \"fals\",\n // true\n \"t\",\n \"tr\",\n \"tru\",\n // null\n \"n\",\n \"nu\",\n \"nul\",\n // object\n \"{\",\n \"{a\",\n \"{a:\",\n \"{a:1\",\n \"{a:1,\",\n \"{a:1,b\",\n \"{a:1,b:\",\n };\n\n for (auto input : testCases) {\n SECTION(input) {\n JsonDocument doc;\n REQUIRE(deserializeJson(doc, input) ==\n DeserializationError::IncompleteInput);\n }\n }\n}\n\nTEST_CASE(\"deserializeJson() returns InvalidInput\") {\n const char* testCases[] = {\n // unicode\n \"'\\\\u'\", \"'\\\\u000g'\", \"'\\\\u000'\", \"'\\\\u000G'\", \"'\\\\u000/'\", \"\\\\x1234\",\n // numbers\n \"6a9\", \"1,\", \"2]\", \"3}\",\n // constants\n \"nulL\", \"tru3\", \"fals3\",\n // garbage\n \"%*$£¤\"};\n\n for (auto input : testCases) {\n SECTION(input) {\n JsonDocument doc;\n REQUIRE(deserializeJson(doc, input) ==\n DeserializationError::InvalidInput);\n }\n }\n}\n\nTEST_CASE(\"deserializeJson() oversees some edge cases\") {\n const char* testCases[] = {\n \"'\\\\ud83d'\", // leading surrogate without a trailing surrogate\n \"'\\\\udda4'\", // trailing surrogate without a leading surrogate\n \"'\\\\ud83d\\\\ud83d'\", // two leading surrogates\n };\n\n for (auto input : testCases) {\n SECTION(input) {\n JsonDocument doc;\n REQUIRE(deserializeJson(doc, input) == DeserializationError::Ok);\n }\n }\n}\n\nTEST_CASE(\"deserializeJson() returns EmptyInput\") {\n JsonDocument doc;\n\n SECTION(\"null\") {\n auto err = deserializeJson(doc, static_cast(0));\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n\n SECTION(\"Empty string\") {\n auto err = deserializeJson(doc, \"\");\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n\n SECTION(\"Only spaces\") {\n auto err = deserializeJson(doc, \" \\t\\n\\r\");\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n}\n\nTEST_CASE(\"deserializeJson() returns NoMemory if string length overflows\") {\n JsonDocument doc;\n auto maxLength = ArduinoJson::detail::StringNode::maxLength;\n\n SECTION(\"max length should succeed\") {\n auto err = deserializeJson(doc, \"\\\"\" + std::string(maxLength, 'a') + \"\\\"\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"one above max length should fail\") {\n auto err =\n deserializeJson(doc, \"\\\"\" + std::string(maxLength + 1, 'a') + \"\\\"\");\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n\nTEST_CASE(\"deserializeJson() returns NoMemory if 8-bit slot allocation fails\") {\n JsonDocument doc(FailingAllocator::instance());\n\n SECTION(\"uint32_t should pass\") {\n auto err = deserializeJson(doc, \"4294967295\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"uint64_t should fail\") {\n auto err = deserializeJson(doc, \"18446744073709551615\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"int32_t should pass\") {\n auto err = deserializeJson(doc, \"-2147483648\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"int64_t should fail\") {\n auto err = deserializeJson(doc, \"-9223372036854775808\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"float should pass\") {\n auto err = deserializeJson(doc, \"3.402823e38\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"double should fail\") {\n auto err = deserializeJson(doc, \"1.7976931348623157e308\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/filter.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_COMMENTS 1\n#include \n#include \n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"Filtering\") {\n struct TestCase {\n const char* description;\n const char* input;\n const char* filter;\n uint8_t nestingLimit;\n DeserializationError error;\n const char* output;\n size_t memoryUsage;\n };\n\n TestCase testCases[] = {\n {\n \"Input is object, filter is null\", // description\n \"{\\\"hello\\\":\\\"world\\\"}\", // input\n \"null\", // filter\n 10, // nestingLimit\n DeserializationError::Ok, // error\n \"null\", // output\n 0, // memoryUsage\n },\n {\n \"Input is object, filter is false\",\n \"{\\\"hello\\\":\\\"world\\\"}\",\n \"false\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Input is object, filter is true\",\n \"{\\\"abcdefg\\\":\\\"hijklmn\\\"}\",\n \"true\",\n 10,\n DeserializationError::Ok,\n \"{\\\"abcdefg\\\":\\\"hijklmn\\\"}\",\n sizeofObject(1) + sizeofString(\"abcdefg\") + sizeofString(\"hijklmn\"),\n },\n {\n \"Input is object, filter is empty object\",\n \"{\\\"hello\\\":\\\"world\\\"}\",\n \"{}\",\n 10,\n DeserializationError::Ok,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Input in an object, but filter wants an array\",\n \"{\\\"hello\\\":\\\"world\\\"}\",\n \"[]\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Member is a string, but filter wants an array\",\n \"{\\\"example\\\":\\\"example\\\"}\",\n \"{\\\"example\\\":[true]}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":null}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Member is a number, but filter wants an array\",\n \"{\\\"example\\\":42}\",\n \"{\\\"example\\\":[true]}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":null}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Input is an array, but filter wants an object\",\n \"[\\\"hello\\\",\\\"world\\\"]\",\n \"{}\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Input is a bool, but filter wants an object\",\n \"true\",\n \"{}\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Input is a string, but filter wants an object\",\n \"\\\"hello\\\"\",\n \"{}\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Skip an integer\",\n \"{\\\"an_integer\\\":666,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip a float\",\n \"{\\\"a_float\\\":12.34e-6,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip false\",\n \"{\\\"a_bool\\\":false,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip true\",\n \"{\\\"a_bool\\\":true,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip null\",\n \"{\\\"a_bool\\\":null,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip a double-quoted string\",\n \"{\\\"a_double_quoted_string\\\":\\\"hello\\\",example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip a single-quoted string\",\n \"{\\\"a_single_quoted_string\\\":'hello',example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an empty array\",\n \"{\\\"an_empty_array\\\":[],example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an empty array with spaces in it\",\n \"{\\\"an_empty_array\\\":[\\t],example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an array\",\n \"{\\\"an_array\\\":[1,2,3],example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an array with spaces in it\",\n \"{\\\"an_array\\\": [ 1 , 2 , 3 ] ,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an empty nested object\",\n \"{\\\"an_empty_object\\\":{},example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an empty nested object with spaces in it\",\n \"{\\\"an_empty_object\\\":{ },example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip a nested object\",\n \"{\\\"an_object\\\":{a:1,'b':2,\\\"c\\\":3},example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip an object with spaces in it\",\n \"{\\\"an_object\\\" : { a : 1 , 'b' : 2 , \\\"c\\\" : 3 } ,example:42}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":42}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Skip a string in a nested object\",\n \"{\\\"an_integer\\\": 0,\\\"example\\\":{\\\"type\\\":\\\"int\\\",\\\"outcome\\\":42}}\",\n \"{\\\"example\\\":{\\\"outcome\\\":true}}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":{\\\"outcome\\\":42}}\",\n 2 * sizeofObject(1) + 2 * sizeofString(\"example\"),\n },\n {\n \"wildcard\",\n \"{\\\"example\\\":{\\\"type\\\":\\\"int\\\",\\\"outcome\\\":42}}\",\n \"{\\\"*\\\":{\\\"outcome\\\":true}}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":{\\\"outcome\\\":42}}\",\n 2 * sizeofObject(1) + 2 * sizeofString(\"example\"),\n },\n {\n \"exclusion filter (issue #1628)\",\n \"{\\\"example\\\":1,\\\"ignored\\\":2}\",\n \"{\\\"*\\\":true,\\\"ignored\\\":false}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"example\\\":1}\",\n sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"only the first element of array counts\",\n \"[1,2,3]\",\n \"[true, false]\",\n 10,\n DeserializationError::Ok,\n \"[1,2,3]\",\n sizeofArray(3),\n },\n {\n \"only the first element of array counts\",\n \"[1,2,3]\",\n \"[false, true]\",\n 10,\n DeserializationError::Ok,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"filter members of object in array\",\n \"[{\\\"example\\\":1,\\\"ignore\\\":2},{\\\"example\\\":3,\\\"ignore\\\":4}]\",\n \"[{\\\"example\\\":true}]\",\n 10,\n DeserializationError::Ok,\n \"[{\\\"example\\\":1},{\\\"example\\\":3}]\",\n sizeofArray(2) + 2 * sizeofObject(1) + sizeofString(\"example\"),\n },\n {\n \"Unclosed single quote in skipped element\",\n \"[',2,3]\",\n \"[false,true]\",\n 10,\n DeserializationError::IncompleteInput,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Unclosed double quote in skipped element\",\n \"[\\\",2,3]\",\n \"[false,true]\",\n 10,\n DeserializationError::IncompleteInput,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Detect errors in skipped value\",\n \"[!,2,\\\\]\",\n \"[false]\",\n 10,\n DeserializationError::InvalidInput,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Detect incomplete string event if it's skipped\",\n \"\\\"ABC\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Detect incomplete string event if it's skipped\",\n \"'ABC\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Handle escaped quotes\",\n \"'A\\\\'BC'\",\n \"false\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Handle escaped quotes\",\n \"\\\"A\\\\\\\"BC\\\"\",\n \"false\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Detect incomplete string in presence of escaped quotes\",\n \"'A\\\\'BC\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Detect incomplete string in presence of escaped quotes\",\n \"\\\"A\\\\\\\"BC\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"skip empty array\",\n \"[]\",\n \"false\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Skip empty array with spaces\",\n \" [ ] \",\n \"false\",\n 10,\n DeserializationError::Ok,\n \"null\",\n 0,\n },\n {\n \"Bubble up element error even if array is skipped\",\n \"[1,'2,3]\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Bubble up member error even if object is skipped\",\n \"{'hello':'worl}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Bubble up colon error even if object is skipped\",\n \"{'hello','world'}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Bubble up key error even if object is skipped\",\n \"{'hello:1}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Detect invalid value in skipped object\",\n \"{'hello':!}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Ignore invalid value in skipped object\",\n \"{'hello':\\\\}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Check nesting limit even for ignored objects\",\n \"{}\",\n \"false\",\n 0,\n DeserializationError::TooDeep,\n \"null\",\n 0,\n },\n {\n \"Check nesting limit even for ignored objects\",\n \"{'hello':{}}\",\n \"false\",\n 1,\n DeserializationError::TooDeep,\n \"null\",\n 0,\n },\n {\n \"Check nesting limit even for ignored values in objects\",\n \"{'hello':{}}\",\n \"{}\",\n 1,\n DeserializationError::TooDeep,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Check nesting limit even for ignored arrays\",\n \"[]\",\n \"false\",\n 0,\n DeserializationError::TooDeep,\n \"null\",\n 0,\n },\n {\n \"Check nesting limit even for ignored arrays\",\n \"[[]]\",\n \"false\",\n 1,\n DeserializationError::TooDeep,\n \"null\",\n 0,\n },\n {\n \"Check nesting limit even for ignored values in arrays\",\n \"[[]]\",\n \"[]\",\n 1,\n DeserializationError::TooDeep,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Supports back-slash at the end of skipped string\",\n \"\\\"hell\\\\\",\n \"false\",\n 1,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Invalid comment at after an element in a skipped array\",\n \"[1/]\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Incomplete comment at after an element in a skipped array\",\n \"[1/*]\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Missing comma in a skipped array\",\n \"[1 2]\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Invalid comment at the beginning of array\",\n \"[/1]\",\n \"[false]\",\n 10,\n DeserializationError::InvalidInput,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Incomplete comment at the begining of an array\",\n \"[/*]\",\n \"[false]\",\n 10,\n DeserializationError::IncompleteInput,\n \"[]\",\n sizeofArray(0),\n },\n {\n \"Invalid comment before key\",\n \"{/1:2}\",\n \"{}\",\n 10,\n DeserializationError::InvalidInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Incomplete comment before key\",\n \"{/*:2}\",\n \"{}\",\n 10,\n DeserializationError::IncompleteInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Invalid comment after key\",\n \"{\\\"example\\\"/1:2}\",\n \"{}\",\n 10,\n DeserializationError::InvalidInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Incomplete comment after key\",\n \"{\\\"example\\\"/*:2}\",\n \"{}\",\n 10,\n DeserializationError::IncompleteInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Invalid comment after colon\",\n \"{\\\"example\\\":/12}\",\n \"{}\",\n 10,\n DeserializationError::InvalidInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Incomplete comment after colon\",\n \"{\\\"example\\\":/*2}\",\n \"{}\",\n 10,\n DeserializationError::IncompleteInput,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Comment next to an integer\",\n \"{\\\"ignore\\\":1//,\\\"example\\\":2\\n}\",\n \"{\\\"example\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{}\",\n sizeofObject(0),\n },\n {\n \"Invalid comment after opening brace of a skipped object\",\n \"{/1:2}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Incomplete after opening brace of a skipped object\",\n \"{/*:2}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Invalid comment after key of a skipped object\",\n \"{\\\"example\\\"/:2}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Incomplete comment after key of a skipped object\",\n \"{\\\"example\\\"/*:2}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Invalid comment after value in a skipped object\",\n \"{\\\"example\\\":2/}\",\n \"false\",\n 10,\n DeserializationError::InvalidInput,\n \"null\",\n 0,\n },\n {\n \"Incomplete comment after value of a skipped object\",\n \"{\\\"example\\\":2/*}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"Incomplete comment after comma in skipped object\",\n \"{\\\"example\\\":2,/*}\",\n \"false\",\n 10,\n DeserializationError::IncompleteInput,\n \"null\",\n 0,\n },\n {\n \"NUL character in key\",\n \"{\\\"x\\\":0,\\\"x\\\\u0000a\\\":1,\\\"x\\\\u0000b\\\":2}\",\n \"{\\\"x\\\\u0000a\\\":true}\",\n 10,\n DeserializationError::Ok,\n \"{\\\"x\\\\u0000a\\\":1}\",\n sizeofObject(1) + sizeofString(\"x?a\"),\n },\n };\n\n for (auto& tc : testCases) {\n SECTION(tc.description) {\n SpyingAllocator spy;\n JsonDocument filter;\n JsonDocument doc(&spy);\n\n REQUIRE(deserializeJson(filter, tc.filter) == DeserializationError::Ok);\n\n CHECK(deserializeJson(\n doc, tc.input, DeserializationOption::Filter(filter),\n DeserializationOption::NestingLimit(tc.nestingLimit)) ==\n tc.error);\n\n CHECK(doc.as() == tc.output);\n\n doc.shrinkToFit();\n CHECK(spy.allocatedBytes() == tc.memoryUsage);\n }\n }\n}\n\nTEST_CASE(\"Overloads\") {\n JsonDocument doc;\n JsonDocument filter;\n\n using namespace DeserializationOption;\n\n // deserializeJson(..., Filter)\n\n SECTION(\"const char*, Filter\") {\n deserializeJson(doc, \"{}\", Filter(filter));\n }\n\n SECTION(\"const char*, size_t, Filter\") {\n deserializeJson(doc, \"{}\", 2, Filter(filter));\n }\n\n SECTION(\"const std::string&, Filter\") {\n deserializeJson(doc, \"{}\"_s, Filter(filter));\n }\n\n SECTION(\"std::istream&, Filter\") {\n std::stringstream s(\"{}\");\n deserializeJson(doc, s, Filter(filter));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], Filter\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeJson(doc, vla, Filter(filter));\n }\n#endif\n\n // deserializeJson(..., Filter, NestingLimit)\n\n SECTION(\"const char*, Filter, NestingLimit\") {\n deserializeJson(doc, \"{}\", Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"const char*, size_t, Filter, NestingLimit\") {\n deserializeJson(doc, \"{}\", 2, Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"const std::string&, Filter, NestingLimit\") {\n deserializeJson(doc, \"{}\"_s, Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"std::istream&, Filter, NestingLimit\") {\n std::stringstream s(\"{}\");\n deserializeJson(doc, s, Filter(filter), NestingLimit(5));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], Filter, NestingLimit\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeJson(doc, vla, Filter(filter), NestingLimit(5));\n }\n#endif\n\n // deserializeJson(..., NestingLimit, Filter)\n\n SECTION(\"const char*, NestingLimit, Filter\") {\n deserializeJson(doc, \"{}\", NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"const char*, size_t, NestingLimit, Filter\") {\n deserializeJson(doc, \"{}\", 2, NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"const std::string&, NestingLimit, Filter\") {\n deserializeJson(doc, \"{}\"_s, NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"std::istream&, NestingLimit, Filter\") {\n std::stringstream s(\"{}\");\n deserializeJson(doc, s, NestingLimit(5), Filter(filter));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], NestingLimit, Filter\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeJson(doc, vla, NestingLimit(5), Filter(filter));\n }\n#endif\n}\n\nTEST_CASE(\"shrink filter\") {\n JsonDocument doc;\n SpyingAllocator spy;\n JsonDocument filter(&spy);\n filter[\"a\"] = true;\n spy.clearLog();\n\n deserializeJson(doc, \"{}\", DeserializationOption::Filter(filter));\n\n REQUIRE(spy.log() == AllocatorLog{\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n}\n" }, { "path": "extras/tests/JsonDeserializer/input_types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"CustomReader.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"deserializeJson(char*)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n char input[] = \"{\\\"hello\\\":\\\"world\\\"}\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Allocate(sizeofPool()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"world\")),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n}\n\nTEST_CASE(\"deserializeJson(unsigned char*, unsigned int)\") { // issue #1897\n JsonDocument doc;\n\n unsigned char input[] = \"{\\\"hello\\\":\\\"world\\\"}\";\n unsigned char* input_ptr = input;\n unsigned int size = sizeof(input);\n\n DeserializationError err = deserializeJson(doc, input_ptr, size);\n\n REQUIRE(err == DeserializationError::Ok);\n}\n\nTEST_CASE(\"deserializeJson(uint8_t*, size_t)\") { // issue #1898\n JsonDocument doc;\n\n uint8_t input[] = \"{\\\"hello\\\":\\\"world\\\"}\";\n uint8_t* input_ptr = input;\n size_t size = sizeof(input);\n\n DeserializationError err = deserializeJson(doc, input_ptr, size);\n\n REQUIRE(err == DeserializationError::Ok);\n}\n\nTEST_CASE(\"deserializeJson(const std::string&)\") {\n JsonDocument doc;\n\n SECTION(\"should accept const string\") {\n const std::string input(\"[42]\");\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"should accept temporary string\") {\n DeserializationError err = deserializeJson(doc, \"[42]\"_s);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"should duplicate content\") {\n std::string input(\"[\\\"hello\\\"]\");\n\n DeserializationError err = deserializeJson(doc, input);\n input[2] = 'X'; // alter the string tomake sure we made a copy\n\n JsonArray array = doc.as();\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(\"hello\"_s == array[0]);\n }\n}\n\nTEST_CASE(\"deserializeJson(std::istream&)\") {\n JsonDocument doc;\n\n SECTION(\"array\") {\n std::istringstream json(\" [ 42 ] \");\n\n DeserializationError err = deserializeJson(doc, json);\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(42 == arr[0]);\n }\n\n SECTION(\"object\") {\n std::istringstream json(\" { hello : 'world' }\");\n\n DeserializationError err = deserializeJson(doc, json);\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == obj.size());\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"Should not read after the closing brace of an empty object\") {\n std::istringstream json(\"{}123\");\n\n deserializeJson(doc, json);\n\n REQUIRE('1' == char(json.get()));\n }\n\n SECTION(\"Should not read after the closing brace\") {\n std::istringstream json(\"{\\\"hello\\\":\\\"world\\\"}123\");\n\n deserializeJson(doc, json);\n\n REQUIRE('1' == char(json.get()));\n }\n\n SECTION(\"Should not read after the closing bracket of an empty array\") {\n std::istringstream json(\"[]123\");\n\n deserializeJson(doc, json);\n\n REQUIRE('1' == char(json.get()));\n }\n\n SECTION(\"Should not read after the closing bracket\") {\n std::istringstream json(\"[\\\"hello\\\",\\\"world\\\"]123\");\n\n deserializeJson(doc, json);\n\n REQUIRE('1' == char(json.get()));\n }\n\n SECTION(\"Should not read after the closing quote\") {\n std::istringstream json(\"\\\"hello\\\"123\");\n\n deserializeJson(doc, json);\n\n REQUIRE('1' == char(json.get()));\n }\n}\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\nTEST_CASE(\"deserializeJson(VLA)\") {\n size_t i = 9;\n char vla[i];\n strcpy(vla, \"{\\\"a\\\":42}\");\n\n JsonDocument doc;\n DeserializationError err = deserializeJson(doc, vla);\n\n REQUIRE(err == DeserializationError::Ok);\n}\n#endif\n\nTEST_CASE(\"deserializeJson(CustomReader)\") {\n JsonDocument doc;\n CustomReader reader(\"[4,2]\");\n DeserializationError err = deserializeJson(doc, reader);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.size() == 2);\n REQUIRE(doc[0] == 4);\n REQUIRE(doc[1] == 2);\n}\n\nTEST_CASE(\"deserializeJson(JsonDocument&, MemberProxy)\") {\n JsonDocument doc1;\n doc1[\"payload\"] = \"[4,2]\";\n\n JsonDocument doc2;\n DeserializationError err = deserializeJson(doc2, doc1[\"payload\"]);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc2.size() == 2);\n REQUIRE(doc2[0] == 4);\n REQUIRE(doc2[1] == 2);\n}\n\nTEST_CASE(\"deserializeJson(JsonDocument&, JsonVariant)\") {\n JsonDocument doc1;\n doc1[\"payload\"] = \"[4,2]\";\n\n JsonDocument doc2;\n DeserializationError err =\n deserializeJson(doc2, doc1[\"payload\"].as());\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc2.size() == 2);\n REQUIRE(doc2[0] == 4);\n REQUIRE(doc2[1] == 2);\n}\n\nTEST_CASE(\"deserializeJson(JsonDocument&, JsonVariantConst)\") {\n JsonDocument doc1;\n doc1[\"payload\"] = \"[4,2]\";\n\n JsonDocument doc2;\n DeserializationError err =\n deserializeJson(doc2, doc1[\"payload\"].as());\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc2.size() == 2);\n REQUIRE(doc2[0] == 4);\n REQUIRE(doc2[1] == 2);\n}\n\nTEST_CASE(\"deserializeJson(JsonDocument&, ElementProxy)\") {\n JsonDocument doc1;\n doc1[0] = \"[4,2]\";\n\n JsonDocument doc2;\n DeserializationError err = deserializeJson(doc2, doc1[0]);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc2.size() == 2);\n REQUIRE(doc2[0] == 4);\n REQUIRE(doc2[1] == 2);\n}\n" }, { "path": "extras/tests/JsonDeserializer/misc.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\n\nTEST_CASE(\"deserializeJson() misc cases\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"null\") {\n DeserializationError err = deserializeJson(doc, \"null\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == false);\n }\n\n SECTION(\"true\") {\n DeserializationError err = deserializeJson(doc, \"true\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(doc.as() == true);\n }\n\n SECTION(\"false\") {\n DeserializationError err = deserializeJson(doc, \"false\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(doc.as() == false);\n }\n\n SECTION(\"Should clear the JsonVariant\") {\n deserializeJson(doc, \"[1,2,3]\");\n spy.clearLog();\n\n deserializeJson(doc, \"{}\");\n\n REQUIRE(doc.is());\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofArray(3)),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/nestingLimit.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Literals.hpp\"\n\n#define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression);\n#define SHOULD_FAIL(expression) \\\n REQUIRE(DeserializationError::TooDeep == expression);\n\nTEST_CASE(\"JsonDeserializer nesting\") {\n JsonDocument doc;\n\n SECTION(\"Input = const char*\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeJson(doc, \"\\\"toto\\\"\", nesting));\n SHOULD_WORK(deserializeJson(doc, \"123\", nesting));\n SHOULD_WORK(deserializeJson(doc, \"true\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[]\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{}\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[\\\"toto\\\"]\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":1}\", nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeJson(doc, \"[\\\"toto\\\"]\", nesting));\n SHOULD_WORK(deserializeJson(doc, \"{\\\"toto\\\":1}\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":{}}\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":[]}\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[[\\\"toto\\\"]]\", nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[{\\\"toto\\\":1}]\", nesting));\n }\n }\n\n SECTION(\"char* and size_t\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeJson(doc, \"\\\"toto\\\"\", 6, nesting));\n SHOULD_WORK(deserializeJson(doc, \"123\", 3, nesting));\n SHOULD_WORK(deserializeJson(doc, \"true\", 4, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[]\", 2, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{}\", 2, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[\\\"toto\\\"]\", 8, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":1}\", 10, nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeJson(doc, \"[\\\"toto\\\"]\", 8, nesting));\n SHOULD_WORK(deserializeJson(doc, \"{\\\"toto\\\":1}\", 10, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":{}}\", 11, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":[]}\", 11, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[[\\\"toto\\\"]]\", 10, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[{\\\"toto\\\":1}]\", 12, nesting));\n }\n }\n\n SECTION(\"Input = std::string\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeJson(doc, \"\\\"toto\\\"\"_s, nesting));\n SHOULD_WORK(deserializeJson(doc, \"123\"_s, nesting));\n SHOULD_WORK(deserializeJson(doc, \"true\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[]\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{}\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[\\\"toto\\\"]\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":1}\"_s, nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeJson(doc, \"[\\\"toto\\\"]\"_s, nesting));\n SHOULD_WORK(deserializeJson(doc, \"{\\\"toto\\\":1}\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":{}}\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"{\\\"toto\\\":[]}\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[[\\\"toto\\\"]]\"_s, nesting));\n SHOULD_FAIL(deserializeJson(doc, \"[{\\\"toto\\\":1}]\"_s, nesting));\n }\n }\n\n SECTION(\"Input = std::istream\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n std::istringstream good(\"true\");\n std::istringstream bad(\"[]\");\n SHOULD_WORK(deserializeJson(doc, good, nesting));\n SHOULD_FAIL(deserializeJson(doc, bad, nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n std::istringstream good(\"[\\\"toto\\\"]\");\n std::istringstream bad(\"{\\\"toto\\\":{}}\");\n SHOULD_WORK(deserializeJson(doc, good, nesting));\n SHOULD_FAIL(deserializeJson(doc, bad, nesting));\n }\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/number.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_USE_LONG_LONG 0\n#define ARDUINOJSON_ENABLE_NAN 1\n#define ARDUINOJSON_ENABLE_INFINITY 1\n\n#include \n#include \n#include \n\nnamespace my {\nusing ArduinoJson::detail::isinf;\nusing ArduinoJson::detail::isnan;\n} // namespace my\n\nTEST_CASE(\"deserialize an integer\") {\n JsonDocument doc;\n\n SECTION(\"Integer\") {\n SECTION(\"0\") {\n DeserializationError err = deserializeJson(doc, \"0\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(doc.as() == 0);\n REQUIRE(doc.as() == \"0\"); // issue #808\n }\n\n SECTION(\"Negative\") {\n DeserializationError err = deserializeJson(doc, \"-42\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE_FALSE(doc.is());\n REQUIRE(doc.as() == -42);\n }\n\n#if LONG_MAX == 2147483647\n SECTION(\"LONG_MAX\") {\n DeserializationError err = deserializeJson(doc, \"2147483647\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(doc.as() == LONG_MAX);\n }\n\n SECTION(\"LONG_MAX + 1\") {\n DeserializationError err = deserializeJson(doc, \"2147483648\");\n\n CAPTURE(LONG_MIN);\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == false);\n REQUIRE(doc.is() == true);\n }\n#endif\n\n#if LONG_MIN == -2147483648\n SECTION(\"LONG_MIN\") {\n DeserializationError err = deserializeJson(doc, \"-2147483648\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(doc.as() == LONG_MIN);\n }\n\n SECTION(\"LONG_MIN - 1\") {\n DeserializationError err = deserializeJson(doc, \"-2147483649\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == false);\n REQUIRE(doc.is() == true);\n }\n#endif\n\n#if ULONG_MAX == 4294967295\n SECTION(\"ULONG_MAX\") {\n DeserializationError err = deserializeJson(doc, \"4294967295\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(doc.as() == ULONG_MAX);\n REQUIRE(doc.is() == false);\n }\n\n SECTION(\"ULONG_MAX + 1\") {\n DeserializationError err = deserializeJson(doc, \"4294967296\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == false);\n REQUIRE(doc.is() == true);\n }\n#endif\n }\n\n SECTION(\"Floats\") {\n SECTION(\"Double\") {\n DeserializationError err = deserializeJson(doc, \"-1.23e+4\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE_FALSE(doc.is());\n REQUIRE(doc.is());\n REQUIRE(doc.as() == Approx(-1.23e+4));\n }\n\n SECTION(\"NaN\") {\n DeserializationError err = deserializeJson(doc, \"NaN\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(my::isnan(doc.as()));\n }\n\n SECTION(\"Infinity\") {\n DeserializationError err = deserializeJson(doc, \"Infinity\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(my::isinf(doc.as()));\n }\n\n SECTION(\"+Infinity\") {\n DeserializationError err = deserializeJson(doc, \"+Infinity\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(my::isinf(doc.as()));\n }\n\n SECTION(\"-Infinity\") {\n DeserializationError err = deserializeJson(doc, \"-Infinity\");\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is() == true);\n REQUIRE(my::isinf(doc.as()));\n }\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/object.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"deserialize JSON object\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"An empty object\") {\n DeserializationError err = deserializeJson(doc, \"{}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 0);\n }\n\n SECTION(\"Quotes\") {\n SECTION(\"Double quotes\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key\\\":\\\"value\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"Single quotes\") {\n DeserializationError err = deserializeJson(doc, \"{'key':'value'}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"No quotes\") {\n DeserializationError err = deserializeJson(doc, \"{key:'value'}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"No quotes, allow underscore in key\") {\n DeserializationError err = deserializeJson(doc, \"{_k_e_y_:42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"_k_e_y_\"] == 42);\n }\n }\n\n SECTION(\"Spaces\") {\n SECTION(\"Before the key\") {\n DeserializationError err = deserializeJson(doc, \"{ \\\"key\\\":\\\"value\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"After the key\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key\\\" :\\\"value\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"Before the value\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key\\\": \\\"value\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"After the value\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key\\\":\\\"value\\\" }\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[\"key\"] == \"value\");\n }\n\n SECTION(\"Before the comma\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":\\\"value1\\\" ,\\\"key2\\\":\\\"value2\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"] == \"value1\");\n REQUIRE(obj[\"key2\"] == \"value2\");\n }\n\n SECTION(\"After the comma\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":\\\"value1\\\", \\\"key2\\\":\\\"value2\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"] == \"value1\");\n REQUIRE(obj[\"key2\"] == \"value2\");\n }\n }\n\n SECTION(\"Values types\") {\n SECTION(\"String\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":\\\"value1\\\",\\\"key2\\\":\\\"value2\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"] == \"value1\");\n REQUIRE(obj[\"key2\"] == \"value2\");\n }\n\n SECTION(\"Integer\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":42,\\\"key2\\\":-42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"] == 42);\n REQUIRE(obj[\"key2\"] == -42);\n }\n\n SECTION(\"Float\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":12.345,\\\"key2\\\":-7E3}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"].as() == Approx(12.345f));\n REQUIRE(obj[\"key2\"] == -7E3f);\n }\n\n SECTION(\"Double\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":12.3456789,\\\"key2\\\":-7E89}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"].as() == Approx(12.3456789));\n REQUIRE(obj[\"key2\"] == -7E89);\n }\n\n SECTION(\"Booleans\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":true,\\\"key2\\\":false}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"] == true);\n REQUIRE(obj[\"key2\"] == false);\n }\n\n SECTION(\"Null\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"key1\\\":null,\\\"key2\\\":null}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"key1\"].as() == 0);\n REQUIRE(obj[\"key2\"].as() == 0);\n }\n\n SECTION(\"Array\") {\n char jsonString[] = \" { \\\"ab\\\" : [ 1 , 2 ] , \\\"cd\\\" : [ 3 , 4 ] } \";\n\n DeserializationError err = deserializeJson(doc, jsonString);\n JsonObject obj = doc.as();\n\n JsonArray array1 = obj[\"ab\"];\n const JsonArray array2 = obj[\"cd\"];\n JsonArray array3 = obj[\"ef\"];\n\n REQUIRE(err == DeserializationError::Ok);\n\n REQUIRE(array1.isNull() == false);\n REQUIRE(array2.isNull() == false);\n REQUIRE(array3.isNull() == true);\n\n REQUIRE(2 == array1.size());\n REQUIRE(2 == array2.size());\n REQUIRE(0 == array3.size());\n\n REQUIRE(1 == array1[0].as());\n REQUIRE(2 == array1[1].as());\n\n REQUIRE(3 == array2[0].as());\n REQUIRE(4 == array2[1].as());\n\n REQUIRE(0 == array3[0].as());\n }\n }\n\n SECTION(\"Premature null terminator\") {\n SECTION(\"After opening brace\") {\n DeserializationError err = deserializeJson(doc, \"{\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After key\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\"\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After colon\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After value\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\",\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n\n SECTION(\"Misc\") {\n SECTION(\"A quoted key without value\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key\\\"}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"A non-quoted key without value\") {\n DeserializationError err = deserializeJson(doc, \"{key}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"A dangling comma\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"key1\\\":\\\"value1\\\",}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"null as a key\") {\n DeserializationError err = deserializeJson(doc, \"{null:\\\"value\\\"}\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"Repeated key\") {\n DeserializationError err =\n deserializeJson(doc, \"{alfa:{bravo:{charlie:1}},alfa:2}\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{\\\"alfa\\\":2}\");\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Allocate(sizeofPool()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"alfa\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"bravo\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"charlie\")),\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofString(\"bravo\")),\n Deallocate(sizeofString(\"charlie\")),\n Deallocate(sizeofStringBuffer()),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofObject(1)),\n });\n }\n\n SECTION(\"Repeated key with zero copy mode\") { // issue #1697\n char input[] = \"{a:{b:{c:1}},a:2}\";\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc[\"a\"] == 2);\n }\n\n SECTION(\"NUL in keys\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"x\\\":0,\\\"x\\\\u0000a\\\":1,\\\"x\\\\u0000b\\\":2}\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() ==\n \"{\\\"x\\\":0,\\\"x\\\\u0000a\\\":1,\\\"x\\\\u0000b\\\":2}\");\n }\n }\n\n SECTION(\"Should clear the JsonObject\") {\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n spy.clearLog();\n\n deserializeJson(doc, \"{}\");\n\n REQUIRE(doc.is());\n REQUIRE(doc.size() == 0);\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofObject(1)),\n Deallocate(sizeofString(\"hello\")),\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"Issue #1335\") {\n std::string json(\"{\\\"a\\\":{},\\\"b\\\":{}}\");\n deserializeJson(doc, json);\n CHECK(doc.as() == json);\n }\n}\n\nTEST_CASE(\"deserialize JSON object under memory constraints\") {\n TimebombAllocator timebomb(1024);\n JsonDocument doc(&timebomb);\n\n SECTION(\"empty object requires no allocation\") {\n timebomb.setCountdown(0);\n char input[] = \"{}\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{}\");\n }\n\n SECTION(\"key allocation fails\") {\n timebomb.setCountdown(0);\n char input[] = \"{\\\"a\\\":1}\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"{}\");\n }\n\n SECTION(\"pool allocation fails\") {\n timebomb.setCountdown(1);\n char input[] = \"{\\\"a\\\":1}\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"{}\");\n }\n\n SECTION(\"string allocation fails\") {\n timebomb.setCountdown(3);\n char input[] = \"{\\\"alfa\\\":\\\"bravo\\\"}\";\n\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n REQUIRE(doc.as() == \"{\\\"alfa\\\":null}\");\n }\n}\n" }, { "path": "extras/tests/JsonDeserializer/string.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_DECODE_UNICODE 1\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"Valid JSON strings value\") {\n struct TestCase {\n const char* input;\n const char* expectedOutput;\n };\n\n TestCase testCases[] = {\n {\"\\\"hello world\\\"\", \"hello world\"},\n {\"\\'hello world\\'\", \"hello world\"},\n {\"'\\\"'\", \"\\\"\"},\n {\"'\\\\\\\\'\", \"\\\\\"},\n {\"'\\\\/'\", \"/\"},\n {\"'\\\\b'\", \"\\b\"},\n {\"'\\\\f'\", \"\\f\"},\n {\"'\\\\n'\", \"\\n\"},\n {\"'\\\\r'\", \"\\r\"},\n {\"'\\\\t'\", \"\\t\"},\n {\"\\\"1\\\\\\\"2\\\\\\\\3\\\\/4\\\\b5\\\\f6\\\\n7\\\\r8\\\\t9\\\"\", \"1\\\"2\\\\3/4\\b5\\f6\\n7\\r8\\t9\"},\n {\"'\\\\u0041'\", \"A\"},\n {\"'\\\\u00e4'\", \"\\xc3\\xa4\"}, // ä\n {\"'\\\\u00E4'\", \"\\xc3\\xa4\"}, // ä\n {\"'\\\\u3042'\", \"\\xe3\\x81\\x82\"}, // あ\n {\"'\\\\ud83d\\\\udda4'\", \"\\xf0\\x9f\\x96\\xa4\"}, // 🖤\n {\"'\\\\uF053'\", \"\\xef\\x81\\x93\"}, // issue #1173\n {\"'\\\\uF015'\", \"\\xef\\x80\\x95\"}, // issue #1173\n {\"'\\\\uF054'\", \"\\xef\\x81\\x94\"}, // issue #1173\n };\n const size_t testCount = sizeof(testCases) / sizeof(testCases[0]);\n\n JsonDocument doc;\n\n for (size_t i = 0; i < testCount; i++) {\n const TestCase& testCase = testCases[i];\n CAPTURE(testCase.input);\n DeserializationError err = deserializeJson(doc, testCase.input);\n CHECK(err == DeserializationError::Ok);\n CHECK(doc.as() == testCase.expectedOutput);\n }\n}\n\nTEST_CASE(\"\\\\u0000\") {\n JsonDocument doc;\n\n DeserializationError err = deserializeJson(doc, \"\\\"wx\\\\u0000yz\\\"\");\n REQUIRE(err == DeserializationError::Ok);\n\n const char* result = doc.as();\n CHECK(result[0] == 'w');\n CHECK(result[1] == 'x');\n CHECK(result[2] == 0);\n CHECK(result[3] == 'y');\n CHECK(result[4] == 'z');\n CHECK(result[5] == 0);\n\n CHECK(doc.as().size() == 5);\n CHECK(doc.as().size() == 5);\n}\n\nTEST_CASE(\"Truncated JSON string\") {\n const char* testCases[] = {\"\\\"hello\", \"\\'hello\", \"'\\\\u\", \"'\\\\u00\", \"'\\\\u000\"};\n const size_t testCount = sizeof(testCases) / sizeof(testCases[0]);\n\n JsonDocument doc;\n\n for (size_t i = 0; i < testCount; i++) {\n const char* input = testCases[i];\n CAPTURE(input);\n REQUIRE(deserializeJson(doc, input) ==\n DeserializationError::IncompleteInput);\n }\n}\n\nTEST_CASE(\"Escape single quote in single quoted string\") {\n JsonDocument doc;\n\n DeserializationError err = deserializeJson(doc, \"'ab\\\\\\'cd'\");\n REQUIRE(err == DeserializationError::Ok);\n CHECK(doc.as() == \"ab\\'cd\");\n}\n\nTEST_CASE(\"Escape double quote in double quoted string\") {\n JsonDocument doc;\n\n DeserializationError err = deserializeJson(doc, \"'ab\\\\\\\"cd'\");\n REQUIRE(err == DeserializationError::Ok);\n CHECK(doc.as() == \"ab\\\"cd\");\n}\n\nTEST_CASE(\"Invalid JSON string\") {\n const char* testCases[] = {\"'\\\\u'\", \"'\\\\u000g'\", \"'\\\\u000'\",\n \"'\\\\u000G'\", \"'\\\\u000/'\", \"'\\\\x1234'\"};\n const size_t testCount = sizeof(testCases) / sizeof(testCases[0]);\n\n JsonDocument doc;\n\n for (size_t i = 0; i < testCount; i++) {\n const char* input = testCases[i];\n CAPTURE(input);\n REQUIRE(deserializeJson(doc, input) == DeserializationError::InvalidInput);\n }\n}\n\nTEST_CASE(\"Allocation of the key fails\") {\n TimebombAllocator timebomb(0);\n SpyingAllocator spy(&timebomb);\n JsonDocument doc(&spy);\n\n SECTION(\"Quoted string, first member\") {\n REQUIRE(deserializeJson(doc, \"{\\\"example\\\":1}\") ==\n DeserializationError::NoMemory);\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Quoted string, second member\") {\n timebomb.setCountdown(3);\n REQUIRE(deserializeJson(doc, \"{\\\"hello\\\":1,\\\"world\\\"}\") ==\n DeserializationError::NoMemory);\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Allocate(sizeofPool()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello\")),\n AllocateFail(sizeofStringBuffer()),\n ReallocateFail(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"Non-Quoted string, first member\") {\n REQUIRE(deserializeJson(doc, \"{example:1}\") ==\n DeserializationError::NoMemory);\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Non-Quoted string, second member\") {\n timebomb.setCountdown(3);\n REQUIRE(deserializeJson(doc, \"{hello:1,world}\") ==\n DeserializationError::NoMemory);\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Allocate(sizeofPool()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello\")),\n AllocateFail(sizeofStringBuffer()),\n ReallocateFail(sizeofPool(), sizeofObject(1)),\n });\n }\n}\n\nTEST_CASE(\"String allocation fails\") {\n SpyingAllocator spy(FailingAllocator::instance());\n JsonDocument doc(&spy);\n\n SECTION(\"Input is const char*\") {\n REQUIRE(deserializeJson(doc, \"\\\"hello\\\"\") ==\n DeserializationError::NoMemory);\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n}\n\nTEST_CASE(\"Deduplicate values\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n deserializeJson(doc, \"[\\\"example\\\",\\\"example\\\"]\");\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"example\")),\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n Reallocate(sizeofPool(), sizeofArray(2)),\n });\n}\n\nTEST_CASE(\"Deduplicate keys\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n deserializeJson(doc, \"[{\\\"example\\\":1},{\\\"example\\\":2}]\");\n\n const char* key1 = doc[0].as().begin()->key().c_str();\n const char* key2 = doc[1].as().begin()->key().c_str();\n CHECK(key1 == key2);\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"example\")),\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n Reallocate(sizeofPool(), sizeofArray(2) + 2 * sizeofObject(1)),\n });\n}\n" }, { "path": "extras/tests/JsonDocument/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonDocumentTests\n\tadd.cpp\n\tassignment.cpp\n\tcast.cpp\n\tclear.cpp\n\tcompare.cpp\n\tconstructor.cpp\n\tElementProxy.cpp\n\tisNull.cpp\n\tissue1120.cpp\n\tMemberProxy.cpp\n\tnesting.cpp\n\toverflowed.cpp\n\tremove.cpp\n\tset.cpp\n\tshrinkToFit.cpp\n\tsize.cpp\n\tsubscript.cpp\n\tswap.cpp\n)\n\nadd_test(JsonDocument JsonDocumentTests)\n\nset_tests_properties(JsonDocument\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonDocument/ElementProxy.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ElementProxy = ArduinoJson::detail::ElementProxy;\n\nTEST_CASE(\"ElementProxy::add()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add();\n const ElementProxy& ep = doc[0];\n\n SECTION(\"integer\") {\n ep.add(42);\n\n REQUIRE(doc.as() == \"[[42]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"string literal\") {\n ep.add(\"world\");\n\n REQUIRE(doc.as() == \"[[\\\"world\\\"]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* s = \"world\";\n ep.add(s);\n\n REQUIRE(doc.as() == \"[[\\\"world\\\"]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"char[]\") {\n char s[] = \"world\";\n ep.add(s);\n strcpy(s, \"!!!!!\");\n\n REQUIRE(doc.as() == \"[[\\\"world\\\"]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t i = 8;\n char vla[i];\n strcpy(vla, \"world\");\n\n ep.add(vla);\n\n REQUIRE(doc.as() == \"[[\\\"world\\\"]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"world\")),\n });\n }\n#endif\n}\n\nTEST_CASE(\"ElementProxy::clear()\") {\n JsonDocument doc;\n doc.add();\n const ElementProxy& ep = doc[0];\n\n SECTION(\"size goes back to zero\") {\n ep.add(42);\n ep.clear();\n\n REQUIRE(ep.size() == 0);\n }\n\n SECTION(\"isNull() return true\") {\n ep.add(\"hello\");\n ep.clear();\n\n REQUIRE(ep.isNull() == true);\n }\n}\n\nTEST_CASE(\"ElementProxy::operator==()\") {\n JsonDocument doc;\n\n SECTION(\"1 vs 1\") {\n doc.add(1);\n doc.add(1);\n\n REQUIRE(doc[0] <= doc[1]);\n REQUIRE(doc[0] == doc[1]);\n REQUIRE(doc[0] >= doc[1]);\n REQUIRE_FALSE(doc[0] != doc[1]);\n REQUIRE_FALSE(doc[0] < doc[1]);\n REQUIRE_FALSE(doc[0] > doc[1]);\n }\n\n SECTION(\"1 vs 2\") {\n doc.add(1);\n doc.add(2);\n\n REQUIRE(doc[0] != doc[1]);\n REQUIRE(doc[0] < doc[1]);\n REQUIRE(doc[0] <= doc[1]);\n REQUIRE_FALSE(doc[0] == doc[1]);\n REQUIRE_FALSE(doc[0] > doc[1]);\n REQUIRE_FALSE(doc[0] >= doc[1]);\n }\n\n SECTION(\"'abc' vs 'bcd'\") {\n doc.add(\"abc\");\n doc.add(\"bcd\");\n\n REQUIRE(doc[0] != doc[1]);\n REQUIRE(doc[0] < doc[1]);\n REQUIRE(doc[0] <= doc[1]);\n REQUIRE_FALSE(doc[0] == doc[1]);\n REQUIRE_FALSE(doc[0] > doc[1]);\n REQUIRE_FALSE(doc[0] >= doc[1]);\n }\n}\n\nTEST_CASE(\"ElementProxy::remove()\") {\n JsonDocument doc;\n doc.add();\n const ElementProxy& ep = doc[0];\n\n SECTION(\"remove(int)\") {\n ep.add(1);\n ep.add(2);\n ep.add(3);\n\n ep.remove(1);\n\n REQUIRE(ep.as() == \"[1,3]\");\n }\n\n SECTION(\"remove(const char *)\") {\n ep[\"a\"] = 1;\n ep[\"b\"] = 2;\n\n ep.remove(\"a\");\n\n REQUIRE(ep.as() == \"{\\\"b\\\":2}\");\n }\n\n SECTION(\"remove(std::string)\") {\n ep[\"a\"] = 1;\n ep[\"b\"] = 2;\n\n ep.remove(\"b\"_s);\n\n REQUIRE(ep.as() == \"{\\\"a\\\":1}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"remove(vla)\") {\n ep[\"a\"] = 1;\n ep[\"b\"] = 2;\n\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"b\");\n ep.remove(vla);\n\n REQUIRE(ep.as() == \"{\\\"a\\\":1}\");\n }\n#endif\n}\n\nTEST_CASE(\"ElementProxy::set()\") {\n JsonDocument doc;\n const ElementProxy& ep = doc[0];\n\n SECTION(\"set(int)\") {\n ep.set(42);\n\n REQUIRE(doc.as() == \"[42]\");\n }\n\n SECTION(\"set(const char*)\") {\n ep.set(\"world\");\n\n REQUIRE(doc.as() == \"[\\\"world\\\"]\");\n }\n\n SECTION(\"set(char[])\") {\n char s[] = \"world\";\n ep.set(s);\n strcpy(s, \"!!!!!\");\n\n REQUIRE(doc.as() == \"[\\\"world\\\"]\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"set(VLA)\") {\n size_t i = 8;\n char vla[i];\n strcpy(vla, \"world\");\n\n ep.set(vla);\n\n REQUIRE(doc.as() == \"[\\\"world\\\"]\");\n }\n#endif\n}\n\nTEST_CASE(\"ElementProxy::size()\") {\n JsonDocument doc;\n doc.add();\n const ElementProxy& ep = doc[0];\n\n SECTION(\"returns 0\") {\n REQUIRE(ep.size() == 0);\n }\n\n SECTION(\"as an array, returns 2\") {\n ep.add(1);\n ep.add(2);\n REQUIRE(ep.size() == 2);\n }\n\n SECTION(\"as an object, returns 2\") {\n ep[\"a\"] = 1;\n ep[\"b\"] = 2;\n REQUIRE(ep.size() == 2);\n }\n}\n\nTEST_CASE(\"ElementProxy::operator[]\") {\n JsonDocument doc;\n const ElementProxy& ep = doc[1];\n\n SECTION(\"set member\") {\n ep[\"world\"] = 42;\n\n REQUIRE(doc.as() == \"[null,{\\\"world\\\":42}]\");\n }\n\n SECTION(\"set element\") {\n ep[2] = 42;\n\n REQUIRE(doc.as() == \"[null,[null,null,42]]\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"set VLA\") {\n size_t i = 8;\n char vla[i];\n strcpy(vla, \"world\");\n\n ep[0] = vla;\n\n REQUIRE(doc.as() == \"[null,[\\\"world\\\"]]\");\n }\n#endif\n}\n\nTEST_CASE(\"ElementProxy cast to JsonVariantConst\") {\n JsonDocument doc;\n doc[0] = \"world\";\n\n const ElementProxy& ep = doc[0];\n\n JsonVariantConst var = ep;\n\n CHECK(var.as() == \"world\");\n}\n\nTEST_CASE(\"ElementProxy cast to JsonVariant\") {\n JsonDocument doc;\n doc[0] = \"world\";\n\n const ElementProxy& ep = doc[0];\n\n JsonVariant var = ep;\n\n CHECK(var.as() == \"world\");\n\n var.set(\"toto\");\n\n CHECK(doc.as() == \"[\\\"toto\\\"]\");\n}\n" }, { "path": "extras/tests/JsonDocument/MemberProxy.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1\n#define ARDUINOJSON_ENABLE_PROGMEM 1\n#include \n\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"MemberProxy::add()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"integer\") {\n mp.add(42);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[42]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"string literal\") {\n mp.add(\"world\");\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[\\\"world\\\"]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* temp = \"world\";\n mp.add(temp);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[\\\"world\\\"]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"char[]\") {\n char temp[] = \"world\";\n mp.add(temp);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[\\\"world\\\"]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"world\");\n\n mp.add(vla);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[\\\"world\\\"]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n#endif\n}\n\nTEST_CASE(\"MemberProxy::clear()\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"size goes back to zero\") {\n mp.add(42);\n mp.clear();\n\n REQUIRE(mp.size() == 0);\n }\n\n SECTION(\"isNull() return true\") {\n mp.add(\"hello\");\n mp.clear();\n\n REQUIRE(mp.isNull() == true);\n }\n}\n\nTEST_CASE(\"MemberProxy::operator==()\") {\n JsonDocument doc;\n\n SECTION(\"1 vs 1\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 1;\n\n REQUIRE(doc[\"a\"] <= doc[\"b\"]);\n REQUIRE(doc[\"a\"] == doc[\"b\"]);\n REQUIRE(doc[\"a\"] >= doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] != doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] < doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] > doc[\"b\"]);\n }\n\n SECTION(\"1 vs 2\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n REQUIRE(doc[\"a\"] != doc[\"b\"]);\n REQUIRE(doc[\"a\"] < doc[\"b\"]);\n REQUIRE(doc[\"a\"] <= doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] == doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] > doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] >= doc[\"b\"]);\n }\n\n SECTION(\"'abc' vs 'bcd'\") {\n doc[\"a\"] = \"abc\";\n doc[\"b\"] = \"bcd\";\n\n REQUIRE(doc[\"a\"] != doc[\"b\"]);\n REQUIRE(doc[\"a\"] < doc[\"b\"]);\n REQUIRE(doc[\"a\"] <= doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] == doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] > doc[\"b\"]);\n REQUIRE_FALSE(doc[\"a\"] >= doc[\"b\"]);\n }\n}\n\nTEST_CASE(\"MemberProxy::operator|()\") {\n JsonDocument doc;\n\n SECTION(\"const char*\") {\n doc[\"a\"] = \"hello\";\n\n REQUIRE((doc[\"a\"] | \"world\") == \"hello\"_s);\n REQUIRE((doc[\"b\"] | \"world\") == \"world\"_s);\n }\n\n SECTION(\"Issue #1411\") {\n doc[\"sensor\"] = \"gps\";\n\n const char* test = \"test\"; // <- the literal must be captured in a variable\n // to trigger the bug\n const char* sensor = doc[\"sensor\"] | test; // \"gps\"\n\n REQUIRE(sensor == \"gps\"_s);\n }\n\n SECTION(\"Issue #1415\") {\n JsonObject object = doc.to();\n object[\"hello\"] = \"world\";\n\n JsonDocument emptyDoc;\n JsonObject anotherObject = object[\"hello\"] | emptyDoc.to();\n\n REQUIRE(anotherObject.isNull() == false);\n REQUIRE(anotherObject.size() == 0);\n }\n}\n\nTEST_CASE(\"MemberProxy::remove()\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"remove(int)\") {\n mp.add(1);\n mp.add(2);\n mp.add(3);\n\n mp.remove(1);\n\n REQUIRE(mp.as() == \"[1,3]\");\n }\n\n SECTION(\"remove(const char *)\") {\n mp[\"a\"] = 1;\n mp[\"b\"] = 2;\n\n mp.remove(\"a\");\n\n REQUIRE(mp.as() == \"{\\\"b\\\":2}\");\n }\n\n SECTION(\"remove(std::string)\") {\n mp[\"a\"] = 1;\n mp[\"b\"] = 2;\n\n mp.remove(\"b\"_s);\n\n REQUIRE(mp.as() == \"{\\\"a\\\":1}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"remove(vla)\") {\n mp[\"a\"] = 1;\n mp[\"b\"] = 2;\n\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"b\");\n mp.remove(vla);\n\n REQUIRE(mp.as() == \"{\\\"a\\\":1}\");\n }\n#endif\n}\n\nTEST_CASE(\"MemberProxy::set()\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"set(int)\") {\n mp.set(42);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":42}\");\n }\n\n SECTION(\"set(const char*)\") {\n mp.set(\"world\");\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"set(char[])\") { // issue #1191\n char s[] = \"world\";\n mp.set(s);\n strcpy(s, \"!!!!!\");\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"set(vla)\") {\n size_t i = 8;\n char vla[i];\n strcpy(vla, \"world\");\n\n mp.set(vla);\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n#endif\n}\n\nTEST_CASE(\"MemberProxy::size()\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"returns 0\") {\n REQUIRE(mp.size() == 0);\n }\n\n SECTION(\"as an array, return 2\") {\n mp.add(1);\n mp.add(2);\n\n REQUIRE(mp.size() == 2);\n }\n\n SECTION(\"as an object, return 2\") {\n mp[\"a\"] = 1;\n mp[\"b\"] = 2;\n\n REQUIRE(mp.size() == 2);\n }\n}\n\nTEST_CASE(\"MemberProxy::operator[]\") {\n JsonDocument doc;\n const auto& mp = doc[\"hello\"];\n\n SECTION(\"set member\") {\n mp[\"world\"] = 42;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":{\\\"world\\\":42}}\");\n }\n\n SECTION(\"set element\") {\n mp[2] = 42;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":[null,null,42]}\");\n }\n}\n\nTEST_CASE(\"MemberProxy cast to JsonVariantConst\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n const auto& mp = doc[\"hello\"];\n\n JsonVariantConst var = mp;\n\n CHECK(var.as() == \"world\");\n}\n\nTEST_CASE(\"MemberProxy cast to JsonVariant\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n const auto& mp = doc[\"hello\"];\n\n JsonVariant var = mp;\n\n CHECK(var.as() == \"world\");\n\n var.set(\"toto\");\n\n CHECK(doc.as() == \"{\\\"hello\\\":\\\"toto\\\"}\");\n}\n\nTEST_CASE(\"Deduplicate keys\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"std::string\") {\n doc[0][\"example\"_s] = 1;\n doc[1][\"example\"_s] = 2;\n\n const char* key1 = doc[0].as().begin()->key().c_str();\n const char* key2 = doc[1].as().begin()->key().c_str();\n CHECK(key1 == key2);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"char*\") {\n char key[] = \"example\";\n doc[0][key] = 1;\n doc[1][key] = 2;\n\n const char* key1 = doc[0].as().begin()->key().c_str();\n const char* key2 = doc[1].as().begin()->key().c_str();\n CHECK(key1 == key2);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Arduino String\") {\n doc[0][String(\"example\")] = 1;\n doc[1][String(\"example\")] = 2;\n\n const char* key1 = doc[0].as().begin()->key().c_str();\n const char* key2 = doc[1].as().begin()->key().c_str();\n CHECK(key1 == key2);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Flash string\") {\n doc[0][F(\"example\")] = 1;\n doc[1][F(\"example\")] = 2;\n\n const char* key1 = doc[0].as().begin()->key().c_str();\n const char* key2 = doc[1].as().begin()->key().c_str();\n CHECK(key1 == key2);\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n}\n\nTEST_CASE(\"MemberProxy under memory constraints\") {\n TimebombAllocator timebomb(1);\n SpyingAllocator spy(&timebomb);\n JsonDocument doc(&spy);\n\n SECTION(\"key slot allocation fails\") {\n timebomb.setCountdown(0);\n\n doc[\"hello\"_s] = \"world\";\n\n REQUIRE(doc.is());\n REQUIRE(doc.size() == 0);\n REQUIRE(doc.overflowed() == true);\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofPool()),\n });\n }\n\n SECTION(\"value slot allocation fails\") {\n timebomb.setCountdown(1);\n\n // fill the pool entirely, but leave one slot for the key\n doc[\"foo\"][ARDUINOJSON_POOL_CAPACITY - 4] = 1;\n REQUIRE(doc.overflowed() == false);\n\n doc[\"hello\"_s] = \"world\";\n\n REQUIRE(doc.is());\n REQUIRE(doc.size() == 1);\n REQUIRE(doc.overflowed() == true);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n AllocateFail(sizeofPool()),\n });\n }\n\n SECTION(\"key string allocation fails\") {\n timebomb.setCountdown(1);\n\n doc[\"hello\"_s] = \"world\";\n\n REQUIRE(doc.is());\n REQUIRE(doc.size() == 0);\n REQUIRE(doc.overflowed() == true);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n AllocateFail(sizeofString(\"hello\")),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDocument/add.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1\n#define ARDUINOJSON_ENABLE_PROGMEM 1\n#include \n\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\n\nTEST_CASE(\"JsonDocument::add(T)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"integer\") {\n doc.add(42);\n\n REQUIRE(doc.as() == \"[42]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"string literal\") {\n doc.add(\"hello\");\n\n REQUIRE(doc.as() == \"[\\\"hello\\\"]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* value = \"hello\";\n doc.add(value);\n\n REQUIRE(doc.as() == \"[\\\"hello\\\"]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"std::string\") {\n doc.add(\"example\"_s);\n doc.add(\"example\"_s);\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"char*\") {\n char value[] = \"example\";\n doc.add(value);\n doc.add(value);\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Arduino String\") {\n doc.add(String(\"example\"));\n doc.add(String(\"example\"));\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Flash string\") {\n doc.add(F(\"example\"));\n doc.add(F(\"example\"));\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"example\");\n\n doc.add(vla);\n doc.add(vla);\n\n CHECK(doc[0].as() == doc[1].as());\n REQUIRE(\"example\"_s == doc[0]);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"example\")),\n });\n }\n#endif\n}\n\nTEST_CASE(\"JsonDocument::add()\") {\n JsonDocument doc;\n\n SECTION(\"JsonArray\") {\n JsonArray array = doc.add();\n array.add(1);\n array.add(2);\n REQUIRE(doc.as() == \"[[1,2]]\");\n }\n\n SECTION(\"JsonVariant\") {\n JsonVariant variant = doc.add();\n variant.set(42);\n REQUIRE(doc.as() == \"[42]\");\n }\n}\n\nTEST_CASE(\"JsonObject::add(JsonObject) \") {\n JsonDocument doc1;\n doc1[\"hello\"_s] = \"world\"_s;\n\n TimebombAllocator allocator(10);\n SpyingAllocator spy(&allocator);\n JsonDocument doc2(&spy);\n\n SECTION(\"success\") {\n bool result = doc2.add(doc1.as());\n\n REQUIRE(result == true);\n REQUIRE(doc2.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"partial failure\") { // issue #2081\n allocator.setCountdown(2);\n\n bool result = doc2.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n AllocateFail(sizeofString(\"world\")),\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"complete failure\") {\n allocator.setCountdown(0);\n\n bool result = doc2.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofPool()),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDocument/assignment.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument assignment\") {\n SpyingAllocator spyingAllocator;\n\n SECTION(\"Copy assignment same capacity\") {\n JsonDocument doc1(&spyingAllocator);\n deserializeJson(doc1, \"{\\\"hello\\\":\\\"world\\\"}\");\n JsonDocument doc2(&spyingAllocator);\n spyingAllocator.clearLog();\n\n doc2 = doc1;\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"Copy assignment reallocates when capacity is smaller\") {\n JsonDocument doc1(&spyingAllocator);\n deserializeJson(doc1, \"[{\\\"hello\\\":\\\"world\\\"}]\");\n JsonDocument doc2(&spyingAllocator);\n spyingAllocator.clearLog();\n\n doc2 = doc1;\n\n REQUIRE(doc2.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"Copy assignment reallocates when capacity is larger\") {\n JsonDocument doc1(&spyingAllocator);\n deserializeJson(doc1, \"{\\\"hello\\\":\\\"world\\\"}\");\n JsonDocument doc2(&spyingAllocator);\n spyingAllocator.clearLog();\n\n doc2 = doc1;\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"Move assign\") {\n {\n JsonDocument doc1(&spyingAllocator);\n doc1[\"hello\"_s] = \"world\"_s;\n JsonDocument doc2(&spyingAllocator);\n\n doc2 = std::move(doc1);\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n\n // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)\n REQUIRE(doc1.as() == \"null\");\n }\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n Deallocate(sizeofString(\"hello\")),\n Deallocate(sizeofString(\"world\")),\n Deallocate(sizeofPool()),\n });\n }\n\n SECTION(\"Assign from JsonObject\") {\n JsonDocument doc1;\n JsonObject obj = doc1.to();\n obj[\"hello\"] = \"world\";\n\n JsonDocument doc2;\n doc2 = obj;\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"Assign from JsonArray\") {\n JsonDocument doc1;\n JsonArray arr = doc1.to();\n arr.add(\"hello\");\n\n JsonDocument doc2;\n doc2 = arr;\n\n REQUIRE(doc2.as() == \"[\\\"hello\\\"]\");\n }\n\n SECTION(\"Assign from JsonVariant\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"42\");\n\n JsonDocument doc2;\n doc2 = doc1.as();\n\n REQUIRE(doc2.as() == \"42\");\n }\n\n SECTION(\"Assign from MemberProxy\") {\n JsonDocument doc1;\n doc1[\"value\"] = 42;\n\n JsonDocument doc2;\n doc2 = doc1[\"value\"];\n\n REQUIRE(doc2.as() == \"42\");\n }\n\n SECTION(\"Assign from ElementProxy\") {\n JsonDocument doc1;\n doc1[0] = 42;\n\n JsonDocument doc2;\n doc2 = doc1[0];\n\n REQUIRE(doc2.as() == \"42\");\n }\n}\n" }, { "path": "extras/tests/JsonDocument/cast.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nTEST_CASE(\"Implicit cast to JsonVariant\") {\n JsonDocument doc;\n\n doc[\"hello\"] = \"world\";\n\n JsonVariant var = doc;\n\n CHECK(var.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n}\n" }, { "path": "extras/tests/JsonDocument/clear.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include // malloc, free\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::clear()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"null\") {\n doc.clear();\n\n REQUIRE(doc.isNull());\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"releases resources\") {\n doc[\"hello\"_s] = \"world\"_s;\n spy.clearLog();\n\n doc.clear();\n\n REQUIRE(doc.isNull());\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofPool()),\n Deallocate(sizeofString(\"hello\")),\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"clear free list\") { // issue #2034\n JsonObject obj = doc.to();\n obj[\"a\"] = 1;\n obj.clear(); // puts the slot in the free list\n\n doc.clear();\n\n doc[\"b\"] = 2; // will it pick from the free list?\n }\n}\n" }, { "path": "extras/tests/JsonDocument/compare.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonDocument::operator==(const JsonDocument&)\") {\n JsonDocument doc1;\n JsonDocument doc2;\n\n SECTION(\"Empty\") {\n REQUIRE(doc1 == doc2);\n REQUIRE_FALSE(doc1 != doc2);\n }\n\n SECTION(\"With same object\") {\n doc1[\"hello\"] = \"world\";\n doc2[\"hello\"] = \"world\";\n REQUIRE(doc1 == doc2);\n REQUIRE_FALSE(doc1 != doc2);\n }\n SECTION(\"With different object\") {\n doc1[\"hello\"] = \"world\";\n doc2[\"world\"] = \"hello\";\n REQUIRE_FALSE(doc1 == doc2);\n REQUIRE(doc1 != doc2);\n }\n}\n" }, { "path": "extras/tests/JsonDocument/constructor.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument constructor\") {\n SpyingAllocator spyingAllocator;\n\n SECTION(\"JsonDocument(size_t)\") {\n { JsonDocument doc(&spyingAllocator); }\n REQUIRE(spyingAllocator.log() == AllocatorLog{});\n }\n\n SECTION(\"JsonDocument(const JsonDocument&)\") {\n {\n JsonDocument doc1(&spyingAllocator);\n doc1.set(\"The size of this string is 32!!\"_s);\n\n JsonDocument doc2(doc1);\n\n REQUIRE(doc1.as() == \"The size of this string is 32!!\");\n REQUIRE(doc2.as() == \"The size of this string is 32!!\");\n }\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"JsonDocument(JsonDocument&&)\") {\n {\n JsonDocument doc1(&spyingAllocator);\n doc1.set(\"The size of this string is 32!!\"_s);\n\n JsonDocument doc2(std::move(doc1));\n\n REQUIRE(doc2.as() == \"The size of this string is 32!!\");\n\n // NOLINTNEXTLINE(clang-analyzer-cplusplus.Move)\n REQUIRE(doc1.as() == \"null\");\n }\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"JsonDocument(JsonObject, Allocator*)\") {\n JsonDocument doc1;\n JsonObject obj = doc1.to();\n obj[\"hello\"] = \"world\";\n\n JsonDocument doc2(obj, &spyingAllocator);\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"JsonDocument(JsonObject)\") {\n JsonDocument doc1;\n JsonObject obj = doc1.to();\n obj[\"hello\"] = \"world\";\n\n JsonDocument doc2(obj);\n\n REQUIRE(doc2.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"JsonDocument(JsonArray, Allocator*)\") {\n JsonDocument doc1;\n JsonArray arr = doc1.to();\n arr.add(\"hello\");\n\n JsonDocument doc2(arr, &spyingAllocator);\n\n REQUIRE(doc2.as() == \"[\\\"hello\\\"]\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"JsonDocument(JsonArray)\") {\n JsonDocument doc1;\n JsonArray arr = doc1.to();\n arr.add(\"hello\");\n\n JsonDocument doc2(arr);\n\n REQUIRE(doc2.as() == \"[\\\"hello\\\"]\");\n }\n\n SECTION(\"JsonDocument(JsonVariant, Allocator*)\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"\\\"hello\\\"\");\n\n JsonDocument doc2(doc1.as(), &spyingAllocator);\n\n REQUIRE(doc2.as() == \"hello\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"JsonDocument(JsonVariant)\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"\\\"hello\\\"\");\n\n JsonDocument doc2(doc1.as());\n\n REQUIRE(doc2.as() == \"hello\");\n }\n\n SECTION(\"JsonDocument(JsonVariantConst)\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"\\\"hello\\\"\");\n\n JsonDocument doc2(doc1.as());\n\n REQUIRE(doc2.as() == \"hello\");\n }\n\n SECTION(\"JsonDocument(ElementProxy)\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"[\\\"hello\\\",\\\"world\\\"]\");\n\n JsonDocument doc2(doc1[1]);\n\n REQUIRE(doc2.as() == \"world\");\n }\n\n SECTION(\"JsonDocument(MemberProxy)\") {\n JsonDocument doc1;\n deserializeJson(doc1, \"{\\\"hello\\\":\\\"world\\\"}\");\n\n JsonDocument doc2(doc1[\"hello\"]);\n\n REQUIRE(doc2.as() == \"world\");\n }\n}\n" }, { "path": "extras/tests/JsonDocument/isNull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonDocument::isNull()\") {\n JsonDocument doc;\n\n SECTION(\"returns true if uninitialized\") {\n REQUIRE(doc.isNull() == true);\n }\n\n SECTION(\"returns false after to()\") {\n doc.to();\n REQUIRE(doc.isNull() == false);\n }\n\n SECTION(\"returns false after to()\") {\n doc.to();\n REQUIRE(doc.isNull() == false);\n }\n\n SECTION(\"returns true after to()\") {\n REQUIRE(doc.isNull() == true);\n }\n\n SECTION(\"returns false after set()\") {\n doc.to().set(42);\n REQUIRE(doc.isNull() == false);\n }\n\n SECTION(\"returns true after clear()\") {\n doc.to();\n doc.clear();\n REQUIRE(doc.isNull() == true);\n }\n}\n" }, { "path": "extras/tests/JsonDocument/issue1120.cpp", "content": "#include \n\n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"Issue #1120\") {\n JsonDocument doc;\n constexpr char str[] =\n \"{\\\"contents\\\":[{\\\"module\\\":\\\"Packet\\\"},{\\\"module\\\":\\\"Analog\\\"}]}\";\n deserializeJson(doc, str);\n\n SECTION(\"MemberProxy::isNull()\") {\n SECTION(\"returns false\") {\n CHECK(doc[\"contents\"_s].isNull() == false);\n }\n\n SECTION(\"returns true\") {\n CHECK(doc[\"zontents\"_s].isNull() == true);\n }\n }\n\n SECTION(\"ElementProxy >::isNull()\") {\n SECTION(\"returns false\") { // Issue #1120\n CHECK(doc[\"contents\"][1].isNull() == false);\n }\n\n SECTION(\"returns true\") {\n CHECK(doc[\"contents\"][2].isNull() == true);\n }\n }\n\n SECTION(\"MemberProxy, const char*>::isNull()\") {\n SECTION(\"returns false\") {\n CHECK(doc[\"contents\"][1][\"module\"].isNull() == false);\n }\n\n SECTION(\"returns true\") {\n CHECK(doc[\"contents\"][1][\"zodule\"].isNull() == true);\n }\n }\n\n SECTION(\"MemberProxy, std::string>::isNull()\") {\n SECTION(\"returns false\") {\n CHECK(doc[\"contents\"][1][\"module\"_s].isNull() == false);\n }\n\n SECTION(\"returns true\") {\n CHECK(doc[\"contents\"][1][\"zodule\"_s].isNull() == true);\n }\n }\n}\n" }, { "path": "extras/tests/JsonDocument/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonDocument::nesting()\") {\n JsonDocument doc;\n\n SECTION(\"return 0 if uninitialized\") {\n REQUIRE(doc.nesting() == 0);\n }\n\n SECTION(\"returns 0 for string\") {\n JsonVariant var = doc.to();\n var.set(\"hello\");\n REQUIRE(doc.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty object\") {\n doc.to();\n REQUIRE(doc.nesting() == 1);\n }\n\n SECTION(\"returns 1 for empty array\") {\n doc.to();\n REQUIRE(doc.nesting() == 1);\n }\n}\n" }, { "path": "extras/tests/JsonDocument/overflowed.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::overflowed()\") {\n TimebombAllocator timebomb(10);\n JsonDocument doc(&timebomb);\n\n SECTION(\"returns false on a fresh object\") {\n timebomb.setCountdown(0);\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"returns true after a failed insertion\") {\n timebomb.setCountdown(0);\n doc.add(0);\n CHECK(doc.overflowed() == true);\n }\n\n SECTION(\"returns false after successful insertion\") {\n timebomb.setCountdown(2);\n doc.add(0);\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"returns true after a failed string copy\") {\n timebomb.setCountdown(0);\n doc.add(\"example\"_s);\n CHECK(doc.overflowed() == true);\n }\n\n SECTION(\"returns false after a successful string copy\") {\n timebomb.setCountdown(3);\n doc.add(\"example\"_s);\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"returns true after a failed member add\") {\n timebomb.setCountdown(0);\n doc[\"example\"] = true;\n CHECK(doc.overflowed() == true);\n }\n\n SECTION(\"returns true after a failed deserialization\") {\n timebomb.setCountdown(0);\n deserializeJson(doc, \"[1, 2]\");\n CHECK(doc.overflowed() == true);\n }\n\n SECTION(\"returns false after a successful deserialization\") {\n timebomb.setCountdown(3);\n deserializeJson(doc, \"[\\\"example\\\"]\");\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"returns false after clear()\") {\n timebomb.setCountdown(0);\n doc.add(0);\n doc.clear();\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"remains false after shrinkToFit()\") {\n timebomb.setCountdown(2);\n doc.add(0);\n timebomb.setCountdown(2);\n doc.shrinkToFit();\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"remains true after shrinkToFit()\") {\n timebomb.setCountdown(0);\n doc.add(0);\n timebomb.setCountdown(2);\n doc.shrinkToFit();\n CHECK(doc.overflowed() == true);\n }\n\n SECTION(\"returns false when string length doesn't overflow\") {\n auto maxLength = ArduinoJson::detail::StringNode::maxLength;\n CHECK(doc.set(std::string(maxLength, 'a')) == true);\n CHECK(doc.overflowed() == false);\n }\n\n SECTION(\"returns true when string length overflows\") {\n auto maxLength = ArduinoJson::detail::StringNode::maxLength;\n CHECK(doc.set(std::string(maxLength + 1, 'a')) == false);\n CHECK(doc.overflowed() == true);\n }\n}\n" }, { "path": "extras/tests/JsonDocument/remove.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::remove()\") {\n JsonDocument doc;\n\n SECTION(\"remove(int)\") {\n doc.add(1);\n doc.add(2);\n doc.add(3);\n\n doc.remove(1);\n\n REQUIRE(doc.as() == \"[1,3]\");\n }\n\n SECTION(\"string literal\") {\n doc[\"a\"] = 1;\n doc[\"ab\"_s] = 2;\n doc[\"b\"] = 3;\n\n doc.remove(\"ab\");\n\n REQUIRE(doc.as() == \"{\\\"a\\\":1,\\\"b\\\":3}\");\n }\n\n SECTION(\"remove(const char *)\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n doc.remove(static_cast(\"a\"));\n\n REQUIRE(doc.as() == \"{\\\"b\\\":2}\");\n }\n\n SECTION(\"remove(std::string)\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n doc.remove(\"b\"_s);\n\n REQUIRE(doc.as() == \"{\\\"a\\\":1}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"remove(vla)\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"b\");\n doc.remove(vla);\n\n REQUIRE(doc.as() == \"{\\\"a\\\":1}\");\n }\n#endif\n\n SECTION(\"remove(JsonVariant) from object\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n doc[\"c\"] = \"b\";\n\n doc.remove(doc[\"c\"]);\n\n REQUIRE(doc.as() == \"{\\\"a\\\":1,\\\"c\\\":\\\"b\\\"}\");\n }\n\n SECTION(\"remove(JsonVariant) from array\") {\n doc[0] = 3;\n doc[1] = 2;\n doc[2] = 1;\n\n doc.remove(doc[2]);\n doc.remove(doc[3]); // noop\n\n REQUIRE(doc.as() == \"[3,1]\");\n }\n}\n" }, { "path": "extras/tests/JsonDocument/set.cpp", "content": "#define ARDUINOJSON_ENABLE_ARDUINO_STRING 1\n#define ARDUINOJSON_ENABLE_PROGMEM 1\n#include \n\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::set()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"nullptr\") {\n doc.set(nullptr);\n\n REQUIRE(doc.isNull());\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"integer&\") {\n int toto = 42;\n doc.set(toto);\n\n REQUIRE(doc.as() == \"42\");\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"integer\") {\n doc.set(42);\n\n REQUIRE(doc.as() == \"42\");\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"string literal\") {\n doc.set(\"example\");\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* value = \"example\";\n doc.set(value);\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"std::string\") {\n doc.set(\"example\"_s);\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"char*\") {\n char value[] = \"example\";\n doc.set(value);\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Arduino String\") {\n doc.set(String(\"example\"));\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Flash string\") {\n doc.set(F(\"example\"));\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Flash tiny string\") { // issue #2170\n doc.set(F(\"abc\"));\n\n REQUIRE(doc.as() == \"abc\"_s);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"example\");\n\n doc.set(vla);\n\n REQUIRE(doc.as() == \"example\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"example\")),\n });\n }\n#endif\n}\n" }, { "path": "extras/tests/JsonDocument/shrinkToFit.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include // malloc, free\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nclass ArmoredAllocator : public Allocator {\n public:\n virtual ~ArmoredAllocator() {}\n\n void* allocate(size_t size) override {\n return malloc(size);\n }\n\n void deallocate(void* ptr) override {\n free(ptr);\n }\n\n void* reallocate(void* ptr, size_t new_size) override {\n // don't call realloc, instead alloc a new buffer and erase the old one\n // this way we make sure we support relocation\n void* new_ptr = malloc(new_size);\n memset(new_ptr, '#', new_size); // erase\n if (ptr) {\n memcpy(new_ptr, ptr, std::min(new_size, new_size));\n free(ptr);\n }\n return new_ptr;\n }\n};\n\nTEST_CASE(\"JsonDocument::shrinkToFit()\") {\n ArmoredAllocator armoredAllocator;\n SpyingAllocator spyingAllocator(&armoredAllocator);\n JsonDocument doc(&spyingAllocator);\n\n SECTION(\"null\") {\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"null\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{});\n }\n\n SECTION(\"empty object\") {\n deserializeJson(doc, \"{}\");\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"{}\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{});\n }\n\n SECTION(\"empty array\") {\n deserializeJson(doc, \"[]\");\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"[]\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{});\n }\n\n SECTION(\"string\") {\n doc.set(\"abcdefg\");\n REQUIRE(doc.as() == \"abcdefg\");\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"abcdefg\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"abcdefg\")),\n });\n }\n\n SECTION(\"raw string\") {\n doc.set(serialized(\"[{},12]\"));\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"[{},12]\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"[{},12]\")),\n });\n }\n\n SECTION(\"object key\") {\n doc[\"abcdefg\"_s] = 42;\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"{\\\"abcdefg\\\":42}\");\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"abcdefg\")),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"string in array\") {\n doc.add(\"abcdefg\"_s);\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"[\\\"abcdefg\\\"]\");\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"abcdefg\")),\n Reallocate(sizeofPool(), sizeofArray(1)),\n });\n }\n\n SECTION(\"string in object\") {\n doc[\"key\"] = \"abcdefg\"_s;\n\n doc.shrinkToFit();\n\n REQUIRE(doc.as() == \"{\\\"key\\\":\\\"abcdefg\\\"}\");\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"abcdefg\")),\n Reallocate(sizeofPool(), sizeofPool(2)),\n });\n }\n}\n" }, { "path": "extras/tests/JsonDocument/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonDocument::size()\") {\n JsonDocument doc;\n\n SECTION(\"returns 0\") {\n REQUIRE(doc.size() == 0);\n }\n\n SECTION(\"as an array, return 2\") {\n doc.add(1);\n doc.add(2);\n\n REQUIRE(doc.size() == 2);\n }\n\n SECTION(\"as an object, return 2\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n REQUIRE(doc.size() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonDocument/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonDocument::operator[]\") {\n JsonDocument doc;\n const JsonDocument& cdoc = doc;\n\n SECTION(\"object\") {\n doc[\"abc\"_s] = \"ABC\";\n doc[\"abcd\"_s] = \"ABCD\";\n\n SECTION(\"const char*\") {\n const char* key = \"abc\";\n REQUIRE(doc[key] == \"ABC\");\n REQUIRE(cdoc[key] == \"ABC\");\n }\n\n SECTION(\"string literal\") {\n REQUIRE(doc[\"abc\"] == \"ABC\");\n REQUIRE(cdoc[\"abc\"] == \"ABC\");\n REQUIRE(doc[\"abcd\"] == \"ABCD\");\n REQUIRE(cdoc[\"abcd\"] == \"ABCD\");\n }\n\n SECTION(\"std::string\") {\n REQUIRE(doc[\"abc\"_s] == \"ABC\");\n REQUIRE(cdoc[\"abc\"_s] == \"ABC\");\n REQUIRE(doc[\"abcd\"_s] == \"ABCD\");\n REQUIRE(cdoc[\"abcd\"_s] == \"ABCD\");\n }\n\n SECTION(\"JsonVariant\") {\n doc[\"key1\"] = \"abc\";\n doc[\"key2\"] = \"abcd\"_s;\n doc[\"key3\"] = \"foo\";\n\n CHECK(doc[doc[\"key1\"]] == \"ABC\");\n CHECK(doc[doc[\"key2\"]] == \"ABCD\");\n CHECK(doc[doc[\"key3\"]] == nullptr);\n CHECK(doc[doc[\"key4\"]] == nullptr);\n\n CHECK(cdoc[cdoc[\"key1\"]] == \"ABC\");\n CHECK(cdoc[cdoc[\"key2\"]] == \"ABCD\");\n CHECK(cdoc[cdoc[\"key3\"]] == nullptr);\n CHECK(cdoc[cdoc[\"key4\"]] == nullptr);\n }\n\n SECTION(\"supports operator|\") {\n REQUIRE((doc[\"abc\"] | \"nope\") == \"ABC\"_s);\n REQUIRE((doc[\"def\"] | \"nope\") == \"nope\"_s);\n }\n\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"supports VLAs\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n doc[vla] = \"world\";\n\n REQUIRE(doc[vla] == \"world\");\n REQUIRE(cdoc[vla] == \"world\");\n }\n#endif\n }\n\n SECTION(\"array\") {\n deserializeJson(doc, \"[\\\"hello\\\",\\\"world\\\"]\");\n\n SECTION(\"int\") {\n REQUIRE(doc[1] == \"world\");\n REQUIRE(cdoc[1] == \"world\");\n }\n\n SECTION(\"JsonVariant\") {\n doc[2] = 1;\n REQUIRE(doc[doc[2]] == \"world\");\n REQUIRE(cdoc[doc[2]] == \"world\");\n }\n }\n}\n\nTEST_CASE(\"JsonDocument automatically promotes to object\") {\n JsonDocument doc;\n\n doc[\"one\"][\"two\"][\"three\"] = 4;\n\n REQUIRE(doc[\"one\"][\"two\"][\"three\"] == 4);\n}\n\nTEST_CASE(\"JsonDocument automatically promotes to array\") {\n JsonDocument doc;\n\n doc[2] = 2;\n\n REQUIRE(doc.as() == \"[null,null,2]\");\n}\n\nTEST_CASE(\"JsonDocument::operator[] key storage\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"string literal\") {\n doc[\"hello\"] = 0;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":0}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"const char*\") {\n const char* key = \"hello\";\n doc[key] = 0;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":0}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"char[]\") {\n char key[] = \"hello\";\n doc[key] = 0;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":0}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"std::string\") {\n doc[\"hello\"_s] = 0;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":0}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n doc[vla] = 0;\n\n REQUIRE(doc.as() == \"{\\\"hello\\\":0}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n });\n }\n#endif\n}\n" }, { "path": "extras/tests/JsonDocument/swap.cpp", "content": "#include \n\n#include \n#include \n#include \n\nusing namespace std;\n\nTEST_CASE(\"std::swap\") {\n SECTION(\"JsonDocument*\") {\n JsonDocument *p1, *p2;\n swap(p1, p2); // issue #1678\n }\n\n SECTION(\"JsonDocument\") {\n JsonDocument doc1, doc2;\n doc1.set(\"hello\");\n doc2.set(\"world\");\n\n swap(doc1, doc2);\n\n CHECK(doc1.as() == \"world\");\n CHECK(doc2.as() == \"hello\");\n }\n}\n" }, { "path": "extras/tests/JsonObject/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonObjectTests\n\tclear.cpp\n\tcompare.cpp\n\tequals.cpp\n\tisNull.cpp\n\titerator.cpp\n\tnesting.cpp\n\tremove.cpp\n\tset.cpp\n\tsize.cpp\n\tstd_string.cpp\n\tsubscript.cpp\n\tunbound.cpp\n)\n\nadd_test(JsonObject JsonObjectTests)\n\nset_tests_properties(JsonObject\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonObject/clear.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObject::clear()\") {\n SECTION(\"No-op on null JsonObject\") {\n JsonObject obj;\n obj.clear();\n REQUIRE(obj.isNull() == true);\n REQUIRE(obj.size() == 0);\n }\n\n SECTION(\"Removes all elements\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"hello\"] = 1;\n obj[\"world\"] = 2;\n obj.clear();\n REQUIRE(obj.size() == 0);\n REQUIRE(obj.isNull() == false);\n }\n}\n" }, { "path": "extras/tests/JsonObject/compare.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"Compare JsonObject with JsonObject\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonObject unbound;\n\n CHECK(object != unbound);\n CHECK_FALSE(object == unbound);\n CHECK_FALSE(object <= unbound);\n CHECK_FALSE(object >= unbound);\n CHECK_FALSE(object > unbound);\n CHECK_FALSE(object < unbound);\n\n CHECK(unbound != object);\n CHECK_FALSE(unbound == object);\n CHECK_FALSE(unbound <= object);\n CHECK_FALSE(unbound >= object);\n CHECK_FALSE(unbound > object);\n CHECK_FALSE(unbound < object);\n }\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n\n CHECK(object == object);\n CHECK(object <= object);\n CHECK(object >= object);\n CHECK_FALSE(object != object);\n CHECK_FALSE(object > object);\n CHECK_FALSE(object < object);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello\";\n object1[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello\";\n object2[\"c\"][0] = false;\n\n CHECK(object1 == object2);\n CHECK(object1 <= object2);\n CHECK(object1 >= object2);\n CHECK_FALSE(object1 != object2);\n CHECK_FALSE(object1 > object2);\n CHECK_FALSE(object1 < object2);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello1\";\n object1[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello2\";\n object2[\"c\"][0] = false;\n\n CHECK(object1 != object2);\n CHECK_FALSE(object1 == object2);\n CHECK_FALSE(object1 > object2);\n CHECK_FALSE(object1 < object2);\n CHECK_FALSE(object1 <= object2);\n CHECK_FALSE(object1 >= object2);\n }\n}\n\nTEST_CASE(\"Compare JsonObject with JsonVariant\") {\n JsonDocument doc;\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n\n JsonVariant variant = object;\n\n CHECK(object == variant);\n CHECK(object <= variant);\n CHECK(object >= variant);\n CHECK_FALSE(object != variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n\n CHECK(variant == object);\n CHECK(variant <= object);\n CHECK(variant >= object);\n CHECK_FALSE(variant != object);\n CHECK_FALSE(variant > object);\n CHECK_FALSE(variant < object);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object = doc.add();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n object[\"c\"][0] = false;\n\n JsonVariant variant = doc.add();\n variant[\"a\"] = 1;\n variant[\"b\"] = \"hello\";\n variant[\"c\"][0] = false;\n\n CHECK(object == variant);\n CHECK(object <= variant);\n CHECK(object >= variant);\n CHECK_FALSE(object != variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n\n CHECK(variant == object);\n CHECK(variant <= object);\n CHECK(variant >= object);\n CHECK_FALSE(variant != object);\n CHECK_FALSE(variant > object);\n CHECK_FALSE(variant < object);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object = doc.add();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello1\";\n object[\"c\"][0] = false;\n\n JsonVariant variant = doc.add();\n variant[\"a\"] = 1;\n variant[\"b\"] = \"hello2\";\n variant[\"c\"][0] = false;\n\n CHECK(object != variant);\n CHECK_FALSE(object == variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n CHECK_FALSE(object <= variant);\n CHECK_FALSE(object >= variant);\n }\n}\n\nTEST_CASE(\"Compare JsonObject with JsonVariantConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonVariantConst unbound;\n\n CHECK(object != unbound);\n CHECK_FALSE(object == unbound);\n CHECK_FALSE(object <= unbound);\n CHECK_FALSE(object >= unbound);\n CHECK_FALSE(object > unbound);\n CHECK_FALSE(object < unbound);\n\n CHECK(unbound != object);\n CHECK_FALSE(unbound == object);\n CHECK_FALSE(unbound <= object);\n CHECK_FALSE(unbound >= object);\n CHECK_FALSE(unbound > object);\n CHECK_FALSE(unbound < object);\n }\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n\n JsonVariantConst variant = object;\n\n CHECK(object == variant);\n CHECK(object <= variant);\n CHECK(object >= variant);\n CHECK_FALSE(object != variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n\n CHECK(variant == object);\n CHECK(variant <= object);\n CHECK(variant >= object);\n CHECK_FALSE(variant != object);\n CHECK_FALSE(variant > object);\n CHECK_FALSE(variant < object);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object = doc.add();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n object[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello\";\n object2[\"c\"][0] = false;\n JsonVariantConst variant = object2;\n\n CHECK(object == variant);\n CHECK(object <= variant);\n CHECK(object >= variant);\n CHECK_FALSE(object != variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n\n CHECK(variant == object);\n CHECK(variant <= object);\n CHECK(variant >= object);\n CHECK_FALSE(variant != object);\n CHECK_FALSE(variant > object);\n CHECK_FALSE(variant < object);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object = doc.add();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello1\";\n object[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello2\";\n object2[\"c\"][0] = false;\n JsonVariantConst variant = object2;\n\n CHECK(object != variant);\n CHECK_FALSE(object == variant);\n CHECK_FALSE(object > variant);\n CHECK_FALSE(object < variant);\n CHECK_FALSE(object <= variant);\n CHECK_FALSE(object >= variant);\n }\n}\n\nTEST_CASE(\"Compare JsonObject with JsonObjectConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonObjectConst unbound;\n\n CHECK(object != unbound);\n CHECK_FALSE(object == unbound);\n CHECK_FALSE(object <= unbound);\n CHECK_FALSE(object >= unbound);\n CHECK_FALSE(object > unbound);\n CHECK_FALSE(object < unbound);\n\n CHECK(unbound != object);\n CHECK_FALSE(unbound == object);\n CHECK_FALSE(unbound <= object);\n CHECK_FALSE(unbound >= object);\n CHECK_FALSE(unbound > object);\n CHECK_FALSE(unbound < object);\n }\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonObjectConst cobject = object;\n\n CHECK(object == cobject);\n CHECK(object <= cobject);\n CHECK(object >= cobject);\n CHECK_FALSE(object != cobject);\n CHECK_FALSE(object > cobject);\n CHECK_FALSE(object < cobject);\n\n CHECK(cobject == object);\n CHECK(cobject <= object);\n CHECK(cobject >= object);\n CHECK_FALSE(cobject != object);\n CHECK_FALSE(cobject > object);\n CHECK_FALSE(cobject < object);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello\";\n object1[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello\";\n object2[\"c\"][0] = false;\n JsonObjectConst carray2 = object2;\n\n CHECK(object1 == carray2);\n CHECK(object1 <= carray2);\n CHECK(object1 >= carray2);\n CHECK_FALSE(object1 != carray2);\n CHECK_FALSE(object1 > carray2);\n CHECK_FALSE(object1 < carray2);\n\n CHECK(carray2 == object1);\n CHECK(carray2 <= object1);\n CHECK(carray2 >= object1);\n CHECK_FALSE(carray2 != object1);\n CHECK_FALSE(carray2 > object1);\n CHECK_FALSE(carray2 < object1);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello1\";\n object1[\"c\"][0] = false;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello2\";\n object2[\"c\"][0] = false;\n JsonObjectConst carray2 = object2;\n\n CHECK(object1 != carray2);\n CHECK_FALSE(object1 == carray2);\n CHECK_FALSE(object1 > carray2);\n CHECK_FALSE(object1 < carray2);\n CHECK_FALSE(object1 <= carray2);\n CHECK_FALSE(object1 >= carray2);\n\n CHECK(carray2 != object1);\n CHECK_FALSE(carray2 == object1);\n CHECK_FALSE(carray2 > object1);\n CHECK_FALSE(carray2 < object1);\n CHECK_FALSE(carray2 <= object1);\n CHECK_FALSE(carray2 >= object1);\n }\n}\n\nTEST_CASE(\"Compare JsonObjectConst with JsonObjectConst\") {\n JsonDocument doc;\n\n SECTION(\"Compare with unbound\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n\n JsonObjectConst cobject = object;\n JsonObjectConst unbound;\n\n CHECK(cobject != unbound);\n CHECK_FALSE(cobject == unbound);\n CHECK_FALSE(cobject <= unbound);\n CHECK_FALSE(cobject >= unbound);\n CHECK_FALSE(cobject > unbound);\n CHECK_FALSE(cobject < unbound);\n\n CHECK(unbound != cobject);\n CHECK_FALSE(unbound == cobject);\n CHECK_FALSE(unbound <= cobject);\n CHECK_FALSE(unbound >= cobject);\n CHECK_FALSE(unbound > cobject);\n CHECK_FALSE(unbound < cobject);\n }\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonObjectConst cobject = object;\n\n CHECK(cobject == cobject);\n CHECK(cobject <= cobject);\n CHECK(cobject >= cobject);\n CHECK_FALSE(cobject != cobject);\n CHECK_FALSE(cobject > cobject);\n CHECK_FALSE(cobject < cobject);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello\";\n object1[\"c\"][0] = false;\n JsonObjectConst carray1 = object1;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello\";\n object2[\"c\"][0] = false;\n JsonObjectConst carray2 = object2;\n\n CHECK(carray1 == carray2);\n CHECK(carray1 <= carray2);\n CHECK(carray1 >= carray2);\n CHECK_FALSE(carray1 != carray2);\n CHECK_FALSE(carray1 > carray2);\n CHECK_FALSE(carray1 < carray2);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello1\";\n object1[\"c\"][0] = false;\n JsonObjectConst carray1 = object1;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello2\";\n object2[\"c\"][0] = false;\n JsonObjectConst carray2 = object2;\n\n CHECK(carray1 != carray2);\n CHECK_FALSE(carray1 == carray2);\n CHECK_FALSE(carray1 > carray2);\n CHECK_FALSE(carray1 < carray2);\n CHECK_FALSE(carray1 <= carray2);\n CHECK_FALSE(carray1 >= carray2);\n }\n}\n\nTEST_CASE(\"Compare JsonObjectConst with JsonVariant\") {\n JsonDocument doc;\n\n SECTION(\"Compare with self\") {\n JsonObject object = doc.to();\n object[\"a\"] = 1;\n object[\"b\"] = \"hello\";\n JsonObjectConst cobject = object;\n JsonVariant variant = object;\n\n CHECK(cobject == variant);\n CHECK(cobject <= variant);\n CHECK(cobject >= variant);\n CHECK_FALSE(cobject != variant);\n CHECK_FALSE(cobject > variant);\n CHECK_FALSE(cobject < variant);\n\n CHECK(variant == cobject);\n CHECK(variant <= cobject);\n CHECK(variant >= cobject);\n CHECK_FALSE(variant != cobject);\n CHECK_FALSE(variant > cobject);\n CHECK_FALSE(variant < cobject);\n }\n\n SECTION(\"Compare with identical object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello\";\n object1[\"c\"][0] = false;\n JsonObjectConst carray1 = object1;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello\";\n object2[\"c\"][0] = false;\n JsonVariant variant2 = object2;\n\n CHECK(carray1 == variant2);\n CHECK(carray1 <= variant2);\n CHECK(carray1 >= variant2);\n CHECK_FALSE(carray1 != variant2);\n CHECK_FALSE(carray1 > variant2);\n CHECK_FALSE(carray1 < variant2);\n\n CHECK(variant2 == carray1);\n CHECK(variant2 <= carray1);\n CHECK(variant2 >= carray1);\n CHECK_FALSE(variant2 != carray1);\n CHECK_FALSE(variant2 > carray1);\n CHECK_FALSE(variant2 < carray1);\n }\n\n SECTION(\"Compare with different object\") {\n JsonObject object1 = doc.add();\n object1[\"a\"] = 1;\n object1[\"b\"] = \"hello1\";\n object1[\"c\"][0] = false;\n JsonObjectConst carray1 = object1;\n\n JsonObject object2 = doc.add();\n object2[\"a\"] = 1;\n object2[\"b\"] = \"hello2\";\n object2[\"c\"][0] = false;\n JsonVariant variant2 = object2;\n\n CHECK(carray1 != variant2);\n CHECK_FALSE(carray1 == variant2);\n CHECK_FALSE(carray1 > variant2);\n CHECK_FALSE(carray1 < variant2);\n CHECK_FALSE(carray1 <= variant2);\n CHECK_FALSE(carray1 >= variant2);\n\n CHECK(variant2 != carray1);\n CHECK_FALSE(variant2 == carray1);\n CHECK_FALSE(variant2 > carray1);\n CHECK_FALSE(variant2 < carray1);\n CHECK_FALSE(variant2 <= carray1);\n CHECK_FALSE(variant2 >= carray1);\n }\n}\n" }, { "path": "extras/tests/JsonObject/equals.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObject::operator==()\") {\n JsonDocument doc1;\n JsonObject obj1 = doc1.to();\n\n JsonDocument doc2;\n JsonObject obj2 = doc2.to();\n\n SECTION(\"should return false when objs differ\") {\n obj1[\"hello\"] = \"coucou\";\n obj2[\"world\"] = 1;\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return false when LHS has more elements\") {\n obj1[\"hello\"] = \"coucou\";\n obj1[\"world\"] = 666;\n obj2[\"hello\"] = \"coucou\";\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return false when RKS has more elements\") {\n obj1[\"hello\"] = \"coucou\";\n obj2[\"hello\"] = \"coucou\";\n obj2[\"world\"] = 666;\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return true when objs equal\") {\n obj1[\"hello\"] = \"world\";\n obj1[\"anwser\"] = 42;\n // insert in different order\n obj2[\"anwser\"] = 42;\n obj2[\"hello\"] = \"world\";\n\n REQUIRE(obj1 == obj2);\n }\n\n SECTION(\"should return false when RHS is null\") {\n JsonObject null;\n\n REQUIRE_FALSE(obj1 == null);\n }\n\n SECTION(\"should return false when LHS is null\") {\n JsonObject null;\n\n REQUIRE_FALSE(null == obj2);\n }\n}\n" }, { "path": "extras/tests/JsonObject/isNull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObject::isNull()\") {\n SECTION(\"returns true\") {\n JsonObject obj;\n REQUIRE(obj.isNull() == true);\n }\n\n SECTION(\"returns false\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n REQUIRE(obj.isNull() == false);\n }\n}\n\nTEST_CASE(\"JsonObject::operator bool()\") {\n SECTION(\"returns false\") {\n JsonObject obj;\n REQUIRE(static_cast(obj) == false);\n }\n\n SECTION(\"returns true\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n REQUIRE(static_cast(obj) == true);\n }\n}\n" }, { "path": "extras/tests/JsonObject/iterator.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObject::begin()/end()\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"ab\"] = 12;\n obj[\"cd\"] = 34;\n\n SECTION(\"NonConstIterator\") {\n JsonObject::iterator it = obj.begin();\n REQUIRE(obj.end() != it);\n REQUIRE(it->key() == \"ab\");\n REQUIRE(12 == it->value());\n ++it;\n REQUIRE(obj.end() != it);\n REQUIRE(it->key() == \"cd\");\n REQUIRE(34 == it->value());\n ++it;\n REQUIRE(obj.end() == it);\n }\n\n SECTION(\"Dereferencing end() is safe\") {\n REQUIRE(obj.end()->key().isNull());\n REQUIRE(obj.end()->value().isNull());\n }\n\n SECTION(\"null JsonObject\") {\n JsonObject null;\n REQUIRE(null.begin() == null.end());\n }\n}\n" }, { "path": "extras/tests/JsonObject/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObject::nesting()\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n\n SECTION(\"return 0 if uninitialized\") {\n JsonObject unitialized;\n REQUIRE(unitialized.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty object\") {\n REQUIRE(obj.nesting() == 1);\n }\n\n SECTION(\"returns 1 for flat object\") {\n obj[\"hello\"] = \"world\";\n REQUIRE(obj.nesting() == 1);\n }\n\n SECTION(\"returns 2 with nested array\") {\n obj[\"nested\"].to();\n REQUIRE(obj.nesting() == 2);\n }\n\n SECTION(\"returns 2 with nested object\") {\n obj[\"nested\"].to();\n REQUIRE(obj.nesting() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonObject/remove.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nTEST_CASE(\"JsonObject::remove()\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"a\"] = 0;\n obj[\"b\"] = 1;\n obj[\"c\"] = 2;\n std::string result;\n\n SECTION(\"remove(key)\") {\n SECTION(\"Remove first\") {\n obj.remove(\"a\");\n serializeJson(obj, result);\n REQUIRE(\"{\\\"b\\\":1,\\\"c\\\":2}\" == result);\n }\n\n SECTION(\"Remove middle\") {\n obj.remove(\"b\");\n serializeJson(obj, result);\n REQUIRE(\"{\\\"a\\\":0,\\\"c\\\":2}\" == result);\n }\n\n SECTION(\"Remove last\") {\n obj.remove(\"c\");\n serializeJson(obj, result);\n REQUIRE(\"{\\\"a\\\":0,\\\"b\\\":1}\" == result);\n }\n }\n\n SECTION(\"remove(iterator)\") {\n JsonObject::iterator it = obj.begin();\n\n SECTION(\"Remove first\") {\n obj.remove(it);\n serializeJson(obj, result);\n REQUIRE(\"{\\\"b\\\":1,\\\"c\\\":2}\" == result);\n }\n\n SECTION(\"Remove middle\") {\n ++it;\n obj.remove(it);\n serializeJson(obj, result);\n REQUIRE(\"{\\\"a\\\":0,\\\"c\\\":2}\" == result);\n }\n\n SECTION(\"Remove last\") {\n ++it;\n ++it;\n obj.remove(it);\n serializeJson(obj, result);\n REQUIRE(\"{\\\"a\\\":0,\\\"b\\\":1}\" == result);\n }\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"key is a vla\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"b\");\n obj.remove(vla);\n\n serializeJson(obj, result);\n REQUIRE(\"{\\\"a\\\":0,\\\"c\\\":2}\" == result);\n }\n#endif\n\n SECTION(\"remove by key on unbound reference\") {\n JsonObject unboundObject;\n unboundObject.remove(\"key\");\n }\n\n SECTION(\"remove by iterator on unbound reference\") {\n JsonObject unboundObject;\n unboundObject.remove(unboundObject.begin());\n }\n\n SECTION(\"remove(JsonVariant)\") {\n obj[\"key\"] = \"b\";\n obj.remove(obj[\"key\"]);\n REQUIRE(\"{\\\"a\\\":0,\\\"c\\\":2,\\\"key\\\":\\\"b\\\"}\" == doc.as());\n }\n}\n" }, { "path": "extras/tests/JsonObject/set.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonObject::set()\") {\n SpyingAllocator spy;\n JsonDocument doc1(&spy);\n JsonDocument doc2(&spy);\n\n JsonObject obj1 = doc1.to();\n JsonObject obj2 = doc2.to();\n\n SECTION(\"copy key and string value\") {\n obj1[\"hello\"] = \"world\";\n spy.clearLog();\n\n bool success = obj2.set(obj1);\n\n REQUIRE(success == true);\n REQUIRE(obj2[\"hello\"] == \"world\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"copy string from deserializeJson()\") {\n deserializeJson(doc1, \"{'hello':'world'}\");\n spy.clearLog();\n\n bool success = obj2.set(obj1);\n\n REQUIRE(success == true);\n REQUIRE(obj2[\"hello\"] == \"world\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"copy string from deserializeMsgPack()\") {\n deserializeMsgPack(doc1, \"\\x81\\xA5hello\\xA5world\");\n spy.clearLog();\n\n bool success = obj2.set(obj1);\n\n REQUIRE(success == true);\n REQUIRE(obj2[\"hello\"] == \"world\"_s);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"should work with JsonObjectConst\") {\n obj1[\"hello\"] = \"world\";\n\n obj2.set(static_cast(obj1));\n\n REQUIRE(obj2[\"hello\"] == \"world\"_s);\n }\n\n SECTION(\"copy fails in the middle of an object\") {\n TimebombAllocator timebomb(2);\n JsonDocument doc3(&timebomb);\n JsonObject obj3 = doc3.to();\n\n obj1[\"alpha\"_s] = 1;\n obj1[\"beta\"_s] = 2;\n\n bool success = obj3.set(obj1);\n\n REQUIRE(success == false);\n REQUIRE(doc3.as() == \"{\\\"alpha\\\":1}\");\n }\n\n SECTION(\"copy fails in the middle of an array\") {\n TimebombAllocator timebomb(2);\n JsonDocument doc3(&timebomb);\n JsonObject obj3 = doc3.to();\n\n obj1[\"hello\"][0] = \"world\"_s;\n\n bool success = obj3.set(obj1);\n\n REQUIRE(success == false);\n REQUIRE(doc3.as() == \"{\\\"hello\\\":[]}\");\n }\n\n SECTION(\"destination is null\") {\n JsonObject null;\n obj1[\"hello\"] = \"world\";\n\n bool success = null.set(obj1);\n\n REQUIRE(success == false);\n }\n\n SECTION(\"source is null\") {\n JsonObject null;\n obj1[\"hello\"] = \"world\";\n\n bool success = obj1.set(null);\n\n REQUIRE(success == false);\n }\n}\n" }, { "path": "extras/tests/JsonObject/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nTEST_CASE(\"JsonObject::size()\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n\n SECTION(\"initial size is zero\") {\n REQUIRE(0 == obj.size());\n }\n\n SECTION(\"increases when values are added\") {\n obj[\"hello\"] = 42;\n REQUIRE(1 == obj.size());\n }\n\n SECTION(\"decreases when values are removed\") {\n obj[\"hello\"] = 42;\n obj.remove(\"hello\");\n REQUIRE(0 == obj.size());\n }\n\n SECTION(\"doesn't increase when the same key is added twice\") {\n obj[\"hello\"] = 1;\n obj[\"hello\"] = 2;\n REQUIRE(1 == obj.size());\n }\n\n SECTION(\"doesn't decrease when another key is removed\") {\n obj[\"hello\"] = 1;\n obj.remove(\"world\");\n REQUIRE(1 == obj.size());\n }\n}\n" }, { "path": "extras/tests/JsonObject/std_string.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nstatic void eraseString(std::string& str) {\n char* p = const_cast(str.c_str());\n while (*p)\n *p++ = '*';\n}\n\nTEST_CASE(\"std::string\") {\n JsonDocument doc;\n\n SECTION(\"operator[]\") {\n char json[] = \"{\\\"key\\\":\\\"value\\\"}\";\n\n deserializeJson(doc, json);\n JsonObject obj = doc.as();\n\n REQUIRE(\"value\"_s == obj[\"key\"_s]);\n }\n\n SECTION(\"operator[] const\") {\n char json[] = \"{\\\"key\\\":\\\"value\\\"}\";\n\n deserializeJson(doc, json);\n JsonObject obj = doc.as();\n\n REQUIRE(\"value\"_s == obj[\"key\"_s]);\n }\n\n SECTION(\"remove()\") {\n JsonObject obj = doc.to();\n obj[\"key\"] = \"value\";\n\n obj.remove(\"key\"_s);\n\n REQUIRE(0 == obj.size());\n }\n\n SECTION(\"operator[], set key\") {\n std::string key(\"hello\");\n JsonObject obj = doc.to();\n obj[key] = \"world\";\n eraseString(key);\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"operator[], set value\") {\n std::string value(\"world\");\n JsonObject obj = doc.to();\n obj[\"hello\"] = value;\n eraseString(value);\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n}\n" }, { "path": "extras/tests/JsonObject/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonObject::operator[]\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonObject obj = doc.to();\n\n SECTION(\"int\") {\n obj[\"hello\"] = 123;\n\n REQUIRE(123 == obj[\"hello\"].as());\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n }\n\n SECTION(\"volatile int\") { // issue #415\n volatile int i = 123;\n obj[\"hello\"] = i;\n\n REQUIRE(123 == obj[\"hello\"].as());\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n }\n\n SECTION(\"double\") {\n obj[\"hello\"] = 123.45;\n\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n REQUIRE(123.45 == obj[\"hello\"].as());\n }\n\n SECTION(\"bool\") {\n obj[\"hello\"] = true;\n\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n REQUIRE(true == obj[\"hello\"].as());\n }\n\n SECTION(\"const char*\") {\n obj[\"hello\"] = \"h3110\";\n\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n REQUIRE(\"h3110\"_s == obj[\"hello\"].as());\n }\n\n SECTION(\"array\") {\n JsonDocument doc2;\n JsonArray arr = doc2.to();\n\n obj[\"hello\"] = arr;\n\n REQUIRE(arr == obj[\"hello\"].as());\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n }\n\n SECTION(\"object\") {\n JsonDocument doc2;\n JsonObject obj2 = doc2.to();\n\n obj[\"hello\"] = obj2;\n\n REQUIRE(obj2 == obj[\"hello\"].as());\n REQUIRE(true == obj[\"hello\"].is());\n REQUIRE(false == obj[\"hello\"].is());\n }\n\n SECTION(\"array subscript\") {\n JsonDocument doc2;\n JsonArray arr = doc2.to();\n arr.add(42);\n\n obj[\"a\"] = arr[0];\n\n REQUIRE(42 == obj[\"a\"]);\n }\n\n SECTION(\"object subscript\") {\n JsonDocument doc2;\n JsonObject obj2 = doc2.to();\n obj2[\"x\"] = 42;\n\n obj[\"a\"] = obj2[\"x\"];\n\n REQUIRE(42 == obj[\"a\"]);\n }\n\n SECTION(\"char key[]\") { // issue #423\n char key[] = \"hello\";\n obj[key] = 42;\n REQUIRE(42 == obj[key]);\n }\n SECTION(\"should duplicate key and value strings\") {\n obj[\"hello\"] = \"world\";\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"should ignore null key\") {\n // object must have a value to make a call to strcmp()\n obj[\"dummy\"] = 42;\n\n const char* null = 0;\n obj[null] = 666;\n\n REQUIRE(obj.size() == 1);\n REQUIRE(obj[null] == null);\n }\n\n SECTION(\"obj[key].to()\") {\n JsonArray arr = obj[\"hello\"].to();\n\n REQUIRE(arr.isNull() == false);\n }\n\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"obj[VLA] = str\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n obj[vla] = \"world\";\n\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"obj[str] = VLA\") { // issue #416\n size_t i = 32;\n char vla[i];\n strcpy(vla, \"world\");\n\n obj[\"hello\"] = vla;\n\n REQUIRE(\"world\"_s == obj[\"hello\"].as());\n }\n\n SECTION(\"obj.set(VLA, str)\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n obj[vla] = \"world\";\n\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"obj.set(str, VLA)\") {\n size_t i = 32;\n char vla[i];\n strcpy(vla, \"world\");\n\n obj[\"hello\"].set(vla);\n\n REQUIRE(\"world\"_s == obj[\"hello\"].as());\n }\n\n SECTION(\"obj[VLA]\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n\n obj = doc.as();\n REQUIRE(\"world\"_s == obj[vla]);\n }\n#endif\n\n SECTION(\"chain\") {\n obj[\"hello\"][\"world\"] = 123;\n\n REQUIRE(123 == obj[\"hello\"][\"world\"].as());\n REQUIRE(true == obj[\"hello\"][\"world\"].is());\n REQUIRE(false == obj[\"hello\"][\"world\"].is());\n }\n\n SECTION(\"JsonVariant\") {\n obj[\"hello\"] = \"world\";\n obj[\"a\\0b\"_s] = \"ABC\";\n\n doc[\"key1\"] = \"hello\";\n doc[\"key2\"] = \"a\\0b\"_s;\n doc[\"key3\"] = \"foo\";\n\n REQUIRE(obj[obj[\"key1\"]] == \"world\");\n REQUIRE(obj[obj[\"key2\"]] == \"ABC\");\n REQUIRE(obj[obj[\"key3\"]] == nullptr);\n REQUIRE(obj[obj[\"key4\"]] == nullptr);\n }\n}\n" }, { "path": "extras/tests/JsonObject/unbound.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace Catch::Matchers;\n\nTEST_CASE(\"Unbound JsonObject\") {\n JsonObject obj;\n\n SECTION(\"retrieve member\") {\n REQUIRE(obj[\"key\"].isNull());\n }\n\n SECTION(\"add member\") {\n obj[\"hello\"] = \"world\";\n REQUIRE(0 == obj.size());\n }\n\n SECTION(\"serialize\") {\n char buffer[32];\n serializeJson(obj, buffer, sizeof(buffer));\n REQUIRE_THAT(buffer, Equals(\"null\"));\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonObjectConstTests\n\tequals.cpp\n\tisNull.cpp\n\titerator.cpp\n\tnesting.cpp\n\tsize.cpp\n\tsubscript.cpp\n)\n\nadd_test(JsonObjectConst JsonObjectConstTests)\n\nset_tests_properties(JsonObjectConst\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonObjectConst/equals.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObjectConst::operator==()\") {\n JsonDocument doc1;\n JsonObjectConst obj1 = doc1.to();\n\n JsonDocument doc2;\n JsonObjectConst obj2 = doc2.to();\n\n SECTION(\"should return false when objs differ\") {\n doc1[\"hello\"] = \"coucou\";\n doc2[\"world\"] = 1;\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return false when LHS has more elements\") {\n doc1[\"hello\"] = \"coucou\";\n doc1[\"world\"] = 666;\n doc2[\"hello\"] = \"coucou\";\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return false when RKS has more elements\") {\n doc1[\"hello\"] = \"coucou\";\n doc2[\"hello\"] = \"coucou\";\n doc2[\"world\"] = 666;\n\n REQUIRE_FALSE(obj1 == obj2);\n }\n\n SECTION(\"should return true when objs equal\") {\n doc1[\"hello\"] = \"world\";\n doc1[\"anwser\"] = 42;\n // insert in different order\n doc2[\"anwser\"] = 42;\n doc2[\"hello\"] = \"world\";\n\n REQUIRE(obj1 == obj2);\n }\n\n SECTION(\"should return false when RHS is null\") {\n JsonObjectConst null;\n\n REQUIRE_FALSE(obj1 == null);\n }\n\n SECTION(\"should return false when LHS is null\") {\n JsonObjectConst null;\n\n REQUIRE_FALSE(null == obj2);\n }\n\n SECTION(\"should return true when both are null\") {\n JsonObjectConst null1, null2;\n\n REQUIRE(null1 == null2);\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/isNull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObjectConst::isNull()\") {\n SECTION(\"returns true\") {\n JsonObjectConst obj;\n REQUIRE(obj.isNull() == true);\n }\n\n SECTION(\"returns false\") {\n JsonDocument doc;\n JsonObjectConst obj = doc.to();\n REQUIRE(obj.isNull() == false);\n }\n}\n\nTEST_CASE(\"JsonObjectConst::operator bool()\") {\n SECTION(\"returns false\") {\n JsonObjectConst obj;\n REQUIRE(static_cast(obj) == false);\n }\n\n SECTION(\"returns true\") {\n JsonDocument doc;\n JsonObjectConst obj = doc.to();\n REQUIRE(static_cast(obj) == true);\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/iterator.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObjectConst::begin()/end()\") {\n JsonDocument doc;\n JsonObjectConst obj = doc.to();\n doc[\"ab\"] = 12;\n doc[\"cd\"] = 34;\n\n SECTION(\"Iteration\") {\n JsonObjectConst::iterator it = obj.begin();\n REQUIRE(obj.end() != it);\n REQUIRE(it->key() == \"ab\");\n REQUIRE(12 == it->value());\n\n ++it;\n REQUIRE(obj.end() != it);\n JsonPairConst pair = *it;\n REQUIRE(pair.key() == \"cd\");\n REQUIRE(34 == pair.value());\n\n ++it;\n REQUIRE(obj.end() == it);\n }\n\n SECTION(\"Dereferencing end() is safe\") {\n REQUIRE(obj.end()->key().isNull());\n REQUIRE(obj.end()->value().isNull());\n }\n\n SECTION(\"null JsonObjectConst\") {\n JsonObjectConst null;\n REQUIRE(null.begin() == null.end());\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonObjectConst::nesting()\") {\n JsonDocument doc;\n JsonObjectConst obj = doc.to();\n\n SECTION(\"return 0 if unbound\") {\n JsonObjectConst unbound;\n REQUIRE(unbound.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty object\") {\n REQUIRE(obj.nesting() == 1);\n }\n\n SECTION(\"returns 1 for flat object\") {\n doc[\"hello\"] = \"world\";\n REQUIRE(obj.nesting() == 1);\n }\n\n SECTION(\"returns 2 with nested array\") {\n doc[\"nested\"].to();\n REQUIRE(obj.nesting() == 2);\n }\n\n SECTION(\"returns 2 with nested object\") {\n doc[\"nested\"].to();\n REQUIRE(obj.nesting() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nTEST_CASE(\"JsonObjectConst::size()\") {\n JsonDocument doc;\n JsonObjectConst obj = doc.to();\n\n SECTION(\"returns 0 when empty\") {\n REQUIRE(0 == obj.size());\n }\n\n SECTION(\"returns the number of members\") {\n doc[\"hello\"] = 1;\n doc[\"world\"] = 2;\n REQUIRE(2 == obj.size());\n }\n}\n" }, { "path": "extras/tests/JsonObjectConst/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonObjectConst::operator[]\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n doc[\"a\\0b\"_s] = \"ABC\";\n JsonObjectConst obj = doc.as();\n\n SECTION(\"supports const char*\") {\n REQUIRE(obj[\"hello\"] == \"world\"); // issue #2019\n }\n\n SECTION(\"supports std::string\") {\n REQUIRE(obj[\"hello\"_s] == \"world\"); // issue #2019\n REQUIRE(obj[\"a\\0b\"_s] == \"ABC\");\n }\n\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"supports VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n REQUIRE(obj[vla] == \"world\"_s);\n }\n#endif\n\n SECTION(\"supports JsonVariant\") {\n doc[\"key1\"] = \"hello\";\n doc[\"key2\"] = \"a\\0b\"_s;\n doc[\"key3\"] = \"foo\";\n REQUIRE(obj[obj[\"key1\"]] == \"world\");\n REQUIRE(obj[obj[\"key2\"]] == \"ABC\");\n REQUIRE(obj[obj[\"key3\"]] == nullptr);\n REQUIRE(obj[obj[\"key4\"]] == nullptr);\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonSerializerTests\n\tCustomWriter.cpp\n\tJsonArray.cpp\n\tJsonArrayPretty.cpp\n\tJsonObject.cpp\n\tJsonObjectPretty.cpp\n\tJsonVariant.cpp\n\tmisc.cpp\n\tstd_stream.cpp\n\tstd_string.cpp\n)\n\nadd_test(JsonSerializer JsonSerializerTests)\n\nset_tests_properties(JsonSerializer\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonSerializer/CustomWriter.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nclass CustomWriter {\n public:\n CustomWriter() {}\n CustomWriter(const CustomWriter&) = delete;\n CustomWriter& operator=(const CustomWriter&) = delete;\n\n size_t write(uint8_t c) {\n str_.append(1, static_cast(c));\n return 1;\n }\n\n size_t write(const uint8_t* s, size_t n) {\n str_.append(reinterpret_cast(s), n);\n return n;\n }\n\n const std::string& str() const {\n return str_;\n }\n\n private:\n std::string str_;\n};\n\nTEST_CASE(\"CustomWriter\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add(4);\n array.add(2);\n\n SECTION(\"serializeJson()\") {\n CustomWriter writer;\n serializeJson(array, writer);\n\n REQUIRE(\"[4,2]\" == writer.str());\n }\n\n SECTION(\"serializeJsonPretty\") {\n CustomWriter writer;\n serializeJsonPretty(array, writer);\n\n REQUIRE(\"[\\r\\n 4,\\r\\n 2\\r\\n]\" == writer.str());\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/JsonArray.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nstatic void check(JsonArray array, std::string expected) {\n std::string actual;\n size_t actualLen = serializeJson(array, actual);\n REQUIRE(expected == actual);\n REQUIRE(actualLen == expected.size());\n size_t measuredLen = measureJson(array);\n REQUIRE(measuredLen == expected.size());\n}\n\nTEST_CASE(\"serializeJson(JsonArray)\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n\n SECTION(\"Empty\") {\n check(array, \"[]\");\n }\n\n SECTION(\"Null\") {\n array.add(static_cast(0));\n\n check(array, \"[null]\");\n }\n\n SECTION(\"OneString\") {\n array.add(\"hello\");\n\n check(array, \"[\\\"hello\\\"]\");\n }\n\n SECTION(\"TwoStrings\") {\n array.add(\"hello\");\n array.add(\"world\");\n\n check(array, \"[\\\"hello\\\",\\\"world\\\"]\");\n }\n\n SECTION(\"One double\") {\n array.add(3.1415927);\n check(array, \"[3.1415927]\");\n }\n\n SECTION(\"OneInteger\") {\n array.add(1);\n\n check(array, \"[1]\");\n }\n\n SECTION(\"TwoIntegers\") {\n array.add(1);\n array.add(2);\n\n check(array, \"[1,2]\");\n }\n\n SECTION(\"serialized(const char*)\") {\n array.add(serialized(\"{\\\"key\\\":\\\"value\\\"}\"));\n\n check(array, \"[{\\\"key\\\":\\\"value\\\"}]\");\n }\n\n SECTION(\"serialized(char*)\") {\n char tmp[] = \"{\\\"key\\\":\\\"value\\\"}\";\n array.add(serialized(tmp));\n\n check(array, \"[{\\\"key\\\":\\\"value\\\"}]\");\n }\n\n SECTION(\"OneTrue\") {\n array.add(true);\n\n check(array, \"[true]\");\n }\n\n SECTION(\"OneFalse\") {\n array.add(false);\n\n check(array, \"[false]\");\n }\n\n SECTION(\"TwoBooleans\") {\n array.add(false);\n array.add(true);\n\n check(array, \"[false,true]\");\n }\n\n SECTION(\"OneEmptyNestedArray\") {\n array.add();\n\n check(array, \"[[]]\");\n }\n\n SECTION(\"OneEmptyNestedHash\") {\n array.add();\n\n check(array, \"[{}]\");\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/JsonArrayPretty.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nstatic void checkArray(JsonArray array, std::string expected) {\n std::string actual;\n size_t actualLen = serializeJsonPretty(array, actual);\n size_t measuredLen = measureJsonPretty(array);\n CHECK(actualLen == expected.size());\n CHECK(measuredLen == expected.size());\n REQUIRE(expected == actual);\n}\n\nTEST_CASE(\"serializeJsonPretty(JsonArray)\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n\n SECTION(\"Empty\") {\n checkArray(array, \"[]\");\n }\n\n SECTION(\"OneElement\") {\n array.add(1);\n\n checkArray(array,\n \"[\\r\\n\"\n \" 1\\r\\n\"\n \"]\");\n }\n\n SECTION(\"TwoElements\") {\n array.add(1);\n array.add(2);\n\n checkArray(array,\n \"[\\r\\n\"\n \" 1,\\r\\n\"\n \" 2\\r\\n\"\n \"]\");\n }\n\n SECTION(\"EmptyNestedArrays\") {\n array.add();\n array.add();\n\n checkArray(array,\n \"[\\r\\n\"\n \" [],\\r\\n\"\n \" []\\r\\n\"\n \"]\");\n }\n\n SECTION(\"NestedArrays\") {\n JsonArray nested1 = array.add();\n nested1.add(1);\n nested1.add(2);\n\n JsonObject nested2 = array.add();\n nested2[\"key\"] = 3;\n\n checkArray(array,\n \"[\\r\\n\"\n \" [\\r\\n\"\n \" 1,\\r\\n\"\n \" 2\\r\\n\"\n \" ],\\r\\n\"\n \" {\\r\\n\"\n \" \\\"key\\\": 3\\r\\n\"\n \" }\\r\\n\"\n \"]\");\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/JsonObject.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nstatic void checkObject(const JsonObject obj, const std::string& expected) {\n char actual[256];\n memset(actual, '!', sizeof(actual));\n\n size_t actualLen = serializeJson(obj, actual);\n size_t measuredLen = measureJson(obj);\n\n REQUIRE(expected.size() == measuredLen);\n REQUIRE(expected.size() == actualLen);\n REQUIRE(actual[actualLen] == 0); // serializeJson() adds a null terminator\n REQUIRE(expected == actual);\n}\n\nTEST_CASE(\"serializeJson(JsonObject)\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n\n SECTION(\"EmptyObject\") {\n checkObject(obj, \"{}\");\n }\n\n SECTION(\"TwoStrings\") {\n obj[\"key1\"] = \"value1\";\n obj[\"key2\"] = \"value2\";\n\n checkObject(obj, \"{\\\"key1\\\":\\\"value1\\\",\\\"key2\\\":\\\"value2\\\"}\");\n }\n\n SECTION(\"RemoveFirst\") {\n obj[\"key1\"] = \"value1\";\n obj[\"key2\"] = \"value2\";\n obj.remove(\"key1\");\n\n checkObject(obj, \"{\\\"key2\\\":\\\"value2\\\"}\");\n }\n\n SECTION(\"RemoveLast\") {\n obj[\"key1\"] = \"value1\";\n obj[\"key2\"] = \"value2\";\n obj.remove(\"key2\");\n\n checkObject(obj, \"{\\\"key1\\\":\\\"value1\\\"}\");\n }\n\n SECTION(\"RemoveUnexistingKey\") {\n obj[\"key1\"] = \"value1\";\n obj[\"key2\"] = \"value2\";\n obj.remove(\"key3\");\n\n checkObject(obj, \"{\\\"key1\\\":\\\"value1\\\",\\\"key2\\\":\\\"value2\\\"}\");\n }\n\n SECTION(\"ReplaceExistingKey\") {\n obj[\"key\"] = \"value1\";\n obj[\"key\"] = \"value2\";\n\n checkObject(obj, \"{\\\"key\\\":\\\"value2\\\"}\");\n }\n\n SECTION(\"TwoIntegers\") {\n obj[\"a\"] = 1;\n obj[\"b\"] = 2;\n checkObject(obj, \"{\\\"a\\\":1,\\\"b\\\":2}\");\n }\n\n SECTION(\"serialized(const char*)\") {\n obj[\"a\"] = serialized(\"[1,2]\");\n obj[\"b\"] = serialized(\"[4,5]\");\n checkObject(obj, \"{\\\"a\\\":[1,2],\\\"b\\\":[4,5]}\");\n }\n\n SECTION(\"Two doubles\") {\n obj[\"a\"] = 12.34;\n obj[\"b\"] = 56.78;\n checkObject(obj, \"{\\\"a\\\":12.34,\\\"b\\\":56.78}\");\n }\n\n SECTION(\"TwoNull\") {\n obj[\"a\"] = static_cast(0);\n obj[\"b\"] = static_cast(0);\n checkObject(obj, \"{\\\"a\\\":null,\\\"b\\\":null}\");\n }\n\n SECTION(\"TwoBooleans\") {\n obj[\"a\"] = true;\n obj[\"b\"] = false;\n checkObject(obj, \"{\\\"a\\\":true,\\\"b\\\":false}\");\n }\n\n SECTION(\"ThreeNestedArrays\") {\n JsonDocument b;\n JsonDocument c;\n\n obj[\"a\"].to();\n obj[\"b\"] = b.to();\n obj[\"c\"] = c.to();\n\n checkObject(obj, \"{\\\"a\\\":[],\\\"b\\\":[],\\\"c\\\":[]}\");\n }\n\n SECTION(\"ThreeNestedObjects\") {\n JsonDocument b;\n JsonDocument c;\n\n obj[\"a\"].to();\n obj[\"b\"] = b.to();\n obj[\"c\"] = c.to();\n\n checkObject(obj, \"{\\\"a\\\":{},\\\"b\\\":{},\\\"c\\\":{}}\");\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/JsonObjectPretty.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nstatic void checkObjectPretty(const JsonObject obj,\n const std::string expected) {\n char json[256];\n\n size_t actualLen = serializeJsonPretty(obj, json);\n size_t measuredLen = measureJsonPretty(obj);\n\n REQUIRE(json == expected);\n REQUIRE(expected.size() == actualLen);\n REQUIRE(expected.size() == measuredLen);\n}\n\nTEST_CASE(\"serializeJsonPretty(JsonObject)\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n\n SECTION(\"EmptyObject\") {\n checkObjectPretty(obj, \"{}\");\n }\n\n SECTION(\"OneMember\") {\n obj[\"key\"] = \"value\";\n\n checkObjectPretty(obj,\n \"{\\r\\n\"\n \" \\\"key\\\": \\\"value\\\"\\r\\n\"\n \"}\");\n }\n\n SECTION(\"TwoMembers\") {\n obj[\"key1\"] = \"value1\";\n obj[\"key2\"] = \"value2\";\n\n checkObjectPretty(obj,\n \"{\\r\\n\"\n \" \\\"key1\\\": \\\"value1\\\",\\r\\n\"\n \" \\\"key2\\\": \\\"value2\\\"\\r\\n\"\n \"}\");\n }\n\n SECTION(\"EmptyNestedContainers\") {\n obj[\"key1\"].to();\n obj[\"key2\"].to();\n\n checkObjectPretty(obj,\n \"{\\r\\n\"\n \" \\\"key1\\\": {},\\r\\n\"\n \" \\\"key2\\\": []\\r\\n\"\n \"}\");\n }\n\n SECTION(\"NestedContainers\") {\n JsonObject nested1 = obj[\"key1\"].to();\n nested1[\"a\"] = 1;\n\n JsonArray nested2 = obj[\"key2\"].to();\n nested2.add(2);\n\n checkObjectPretty(obj,\n \"{\\r\\n\"\n \" \\\"key1\\\": {\\r\\n\"\n \" \\\"a\\\": 1\\r\\n\"\n \" },\\r\\n\"\n \" \\\"key2\\\": [\\r\\n\"\n \" 2\\r\\n\"\n \" ]\\r\\n\"\n \"}\");\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/JsonVariant.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Literals.hpp\"\n\ntemplate \nvoid check(T value, const std::string& expected) {\n JsonDocument doc;\n doc.to().set(value);\n char buffer[256] = \"\";\n size_t returnValue = serializeJson(doc, buffer, sizeof(buffer));\n REQUIRE(expected == buffer);\n REQUIRE(expected.size() == returnValue);\n}\n\nTEST_CASE(\"serializeJson(JsonVariant)\") {\n SECTION(\"Undefined\") {\n check(JsonVariant(), \"null\");\n }\n\n SECTION(\"Null string\") {\n check(static_cast(0), \"null\");\n }\n\n SECTION(\"const char*\") {\n check(\"hello\", \"\\\"hello\\\"\");\n }\n\n SECTION(\"string\") {\n check(\"hello\"_s, \"\\\"hello\\\"\");\n\n SECTION(\"Escape quotation mark\") {\n check(\"hello \\\"world\\\"\"_s, \"\\\"hello \\\\\\\"world\\\\\\\"\\\"\");\n }\n\n SECTION(\"Escape reverse solidus\") {\n check(\"hello\\\\world\"_s, \"\\\"hello\\\\\\\\world\\\"\");\n }\n\n SECTION(\"Don't escape solidus\") {\n check(\"fifty/fifty\"_s, \"\\\"fifty/fifty\\\"\");\n }\n\n SECTION(\"Don't escape single quote\") {\n check(\"hello'world\"_s, \"\\\"hello'world\\\"\");\n }\n\n SECTION(\"Escape backspace\") {\n check(\"hello\\bworld\"_s, \"\\\"hello\\\\bworld\\\"\");\n }\n\n SECTION(\"Escape formfeed\") {\n check(\"hello\\fworld\"_s, \"\\\"hello\\\\fworld\\\"\");\n }\n\n SECTION(\"Escape linefeed\") {\n check(\"hello\\nworld\"_s, \"\\\"hello\\\\nworld\\\"\");\n }\n\n SECTION(\"Escape carriage return\") {\n check(\"hello\\rworld\"_s, \"\\\"hello\\\\rworld\\\"\");\n }\n\n SECTION(\"Escape tab\") {\n check(\"hello\\tworld\"_s, \"\\\"hello\\\\tworld\\\"\");\n }\n\n SECTION(\"NUL char\") {\n check(\"hello\\0world\"_s, \"\\\"hello\\\\u0000world\\\"\");\n }\n }\n\n SECTION(\"SerializedValue\") {\n check(serialized(\"[1,2]\"), \"[1,2]\");\n }\n\n SECTION(\"SerializedValue\") {\n check(serialized(\"[1,2]\"_s), \"[1,2]\");\n }\n\n SECTION(\"Double\") {\n check(3.1415927, \"3.1415927\");\n }\n\n SECTION(\"Float\") {\n REQUIRE(sizeof(float) == 4);\n check(3.1415927f, \"3.141593\");\n }\n\n SECTION(\"Zero\") {\n check(0, \"0\");\n }\n\n SECTION(\"Integer\") {\n check(42, \"42\");\n }\n\n SECTION(\"NegativeLong\") {\n check(-42, \"-42\");\n }\n\n SECTION(\"UnsignedLong\") {\n check(4294967295UL, \"4294967295\");\n }\n\n SECTION(\"True\") {\n check(true, \"true\");\n }\n\n SECTION(\"OneFalse\") {\n check(false, \"false\");\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"NegativeInt64\") {\n check(-9223372036854775807 - 1, \"-9223372036854775808\");\n }\n\n SECTION(\"PositiveInt64\") {\n check(9223372036854775807, \"9223372036854775807\");\n }\n\n SECTION(\"UInt64\") {\n check(18446744073709551615U, \"18446744073709551615\");\n }\n#endif\n}\n" }, { "path": "extras/tests/JsonSerializer/misc.cpp", "content": "#include \n#include \n#include \n\nTEST_CASE(\"serializeJson(MemberProxy)\") {\n JsonDocument doc;\n deserializeJson(doc, \"{\\\"hello\\\":42}\");\n JsonObject obj = doc.as();\n std::string result;\n\n serializeJson(obj[\"hello\"], result);\n\n REQUIRE(result == \"42\");\n}\n\nTEST_CASE(\"serializeJson(ElementProxy)\") {\n JsonDocument doc;\n deserializeJson(doc, \"[42]\");\n JsonArray arr = doc.as();\n std::string result;\n\n serializeJson(arr[0], result);\n\n REQUIRE(result == \"42\");\n}\n\nTEST_CASE(\"serializeJson(JsonVariantSubscript)\") {\n JsonDocument doc;\n deserializeJson(doc, \"[42]\");\n JsonVariant var = doc.as();\n std::string result;\n\n serializeJson(var[0], result);\n\n REQUIRE(result == \"42\");\n}\n" }, { "path": "extras/tests/JsonSerializer/std_stream.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nTEST_CASE(\"operator<<(std::ostream)\") {\n JsonDocument doc;\n std::ostringstream os;\n\n SECTION(\"JsonVariant containing false\") {\n JsonVariant variant = doc.to();\n\n variant.set(false);\n os << variant;\n\n REQUIRE(\"false\" == os.str());\n }\n\n SECTION(\"JsonVariant containing string\") {\n JsonVariant variant = doc.to();\n\n variant.set(\"coucou\");\n os << variant;\n\n REQUIRE(\"\\\"coucou\\\"\" == os.str());\n }\n\n SECTION(\"JsonObject\") {\n JsonObject object = doc.to();\n object[\"key\"] = \"value\";\n\n os << object;\n\n REQUIRE(\"{\\\"key\\\":\\\"value\\\"}\" == os.str());\n }\n\n SECTION(\"MemberProxy\") {\n JsonObject object = doc.to();\n object[\"key\"] = \"value\";\n\n os << object[\"key\"];\n\n REQUIRE(\"\\\"value\\\"\" == os.str());\n }\n\n SECTION(\"JsonArray\") {\n JsonArray array = doc.to();\n array.add(\"value\");\n\n os << array;\n\n REQUIRE(\"[\\\"value\\\"]\" == os.str());\n }\n\n SECTION(\"ElementProxy\") {\n JsonArray array = doc.to();\n array.add(\"value\");\n\n os << array[0];\n\n REQUIRE(\"\\\"value\\\"\" == os.str());\n }\n}\n" }, { "path": "extras/tests/JsonSerializer/std_string.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"serialize JsonArray to std::string\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n array.add(4);\n array.add(2);\n\n SECTION(\"serializeJson()\") {\n std::string json = \"erase me\";\n serializeJson(array, json);\n\n REQUIRE(\"[4,2]\" == json);\n }\n\n SECTION(\"serializeJsonPretty\") {\n std::string json = \"erase me\";\n serializeJsonPretty(array, json);\n\n REQUIRE(\"[\\r\\n 4,\\r\\n 2\\r\\n]\" == json);\n }\n}\n\nTEST_CASE(\"serialize JsonObject to std::string\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"key\"] = \"value\";\n\n SECTION(\"object\") {\n std::string json = \"erase me\";\n serializeJson(doc, json);\n\n REQUIRE(\"{\\\"key\\\":\\\"value\\\"}\" == json);\n }\n\n SECTION(\"serializeJsonPretty\") {\n std::string json = \"erase me\";\n serializeJsonPretty(doc, json);\n\n REQUIRE(\"{\\r\\n \\\"key\\\": \\\"value\\\"\\r\\n}\" == json);\n }\n}\n\nTEST_CASE(\"serialize an std::string containing a NUL\") {\n JsonDocument doc;\n doc.set(\"hello\\0world\"_s);\n\n std::string json = \"erase me\";\n serializeJson(doc, json);\n CHECK(\"\\\"hello\\\\u0000world\\\"\" == json);\n}\n" }, { "path": "extras/tests/JsonVariant/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonVariantTests\n\tadd.cpp\n\tas.cpp\n\tclear.cpp\n\tcompare.cpp\n\tconverters.cpp\n\tcopy.cpp\n\tis.cpp\n\tisnull.cpp\n\tmisc.cpp\n\tnesting.cpp\n\tnullptr.cpp\n\tor.cpp\n\toverflow.cpp\n\tremove.cpp\n\tset.cpp\n\tsize.cpp\n\tstl_containers.cpp\n\tsubscript.cpp\n\ttypes.cpp\n\tunbound.cpp\n)\n\nadd_test(JsonVariant JsonVariantTests)\n\nset_tests_properties(JsonVariant\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonVariant/add.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariant::add(T)\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n SECTION(\"add integer to new variant\") {\n var.add(42);\n\n REQUIRE(var.as() == \"[42]\");\n }\n\n SECTION(\"add const char* to new variant\") {\n var.add(\"hello\");\n\n REQUIRE(var.as() == \"[\\\"hello\\\"]\");\n }\n\n SECTION(\"add std::string to new variant\") {\n var.add(\"hello\"_s);\n\n REQUIRE(var.as() == \"[\\\"hello\\\"]\");\n }\n\n SECTION(\"add integer to integer\") {\n var.set(123);\n\n var.add(456); // no-op\n\n REQUIRE(var.as() == \"123\");\n }\n\n SECTION(\"add integer to object\") {\n var[\"val\"] = 123;\n\n var.add(456); // no-op\n\n REQUIRE(var.as() == \"{\\\"val\\\":123}\");\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"supports VLAs\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n var.add(vla);\n\n REQUIRE(var.as() == \"[\\\"hello\\\"]\");\n }\n#endif\n}\n\nTEST_CASE(\"JsonVariant::add()\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n SECTION(\"JsonArray\") {\n JsonArray array = var.add();\n array.add(1);\n array.add(2);\n REQUIRE(doc.as() == \"[[1,2]]\");\n }\n\n SECTION(\"JsonVariant\") {\n JsonVariant variant = var.add();\n variant.set(42);\n REQUIRE(doc.as() == \"[42]\");\n }\n}\n\nTEST_CASE(\"JsonObject::add(JsonObject) \") {\n JsonDocument doc1;\n doc1[\"hello\"_s] = \"world\"_s;\n\n TimebombAllocator allocator(10);\n SpyingAllocator spy(&allocator);\n JsonDocument doc2(&spy);\n JsonVariant variant = doc2.to();\n\n SECTION(\"success\") {\n bool result = variant.add(doc1.as());\n\n REQUIRE(result == true);\n REQUIRE(doc2.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n Allocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"partial failure\") { // issue #2081\n allocator.setCountdown(2);\n\n bool result = variant.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"hello\")),\n AllocateFail(sizeofString(\"world\")),\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"complete failure\") {\n allocator.setCountdown(0);\n\n bool result = variant.add(doc1.as());\n\n REQUIRE(result == false);\n REQUIRE(doc2.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n AllocateFail(sizeofPool()),\n });\n }\n}\n" }, { "path": "extras/tests/JsonVariant/as.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Literals.hpp\"\n\nnamespace my {\nusing ArduinoJson::detail::isinf;\n} // namespace my\n\nenum MY_ENUM { ONE = 1, TWO = 2 };\n\nTEST_CASE(\"JsonVariant::as()\") {\n static const char* null = 0;\n\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"not set\") {\n REQUIRE(false == variant.as());\n REQUIRE(0 == variant.as());\n REQUIRE(0.0f == variant.as());\n REQUIRE(0 == variant.as());\n REQUIRE(\"null\" == variant.as());\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(float)\") {\n variant.set(4.2f);\n\n REQUIRE(variant.as());\n REQUIRE(0 == variant.as());\n REQUIRE(variant.as() == \"4.2\");\n REQUIRE(variant.as() == 4L);\n REQUIRE(variant.as() == 4.2f);\n REQUIRE(variant.as() == 4U);\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(double)\") {\n variant.set(4.2);\n\n REQUIRE(variant.as());\n REQUIRE(0 == variant.as());\n REQUIRE(variant.as() == \"4.2\");\n REQUIRE(variant.as() == 4L);\n REQUIRE(variant.as() == 4.2);\n REQUIRE(variant.as() == 4U);\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(0.0)\") {\n variant.set(0.0);\n\n REQUIRE(variant.as() == false);\n REQUIRE(variant.as() == 0L);\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(false)\") {\n variant.set(false);\n\n REQUIRE(false == variant.as());\n REQUIRE(variant.as() == 0.0);\n REQUIRE(variant.as() == 0L);\n REQUIRE(variant.as() == \"false\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(true)\") {\n variant.set(true);\n\n REQUIRE(variant.as());\n REQUIRE(variant.as() == 1.0);\n REQUIRE(variant.as() == 1L);\n REQUIRE(variant.as() == \"true\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(uint32_t)\") {\n variant.set(4294967295U);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 4294967295.0);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == 4294967295U);\n REQUIRE(variant.as() == 4294967295U);\n REQUIRE(variant.as() == \"4294967295\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(int32_t)\") {\n variant.set(-2147483648LL);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == -2147483648LL);\n REQUIRE(variant.as() == -2147483648LL);\n REQUIRE(variant.as() == -2147483648LL);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == \"-2147483648\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(uint64_t)\") {\n variant.set(4294967296U);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 4294967296.0);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == 4294967296U);\n REQUIRE(variant.as() == \"4294967296\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(int64_t)\") {\n variant.set(-2147483649LL);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == -2147483649LL);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == -2147483649LL);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == \"-2147483649\");\n REQUIRE(variant.as().isNull());\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"set(0L)\") {\n variant.set(0L);\n\n REQUIRE(variant.as() == false);\n REQUIRE(variant.as() == 0.0);\n REQUIRE(variant.as() == \"0\");\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(0UL)\") {\n variant.set(0UL);\n\n REQUIRE(variant.as() == false);\n REQUIRE(variant.as() == 0.0);\n REQUIRE(variant.as() == \"0\");\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(null)\") {\n variant.set(null);\n\n REQUIRE(variant.as() == false);\n REQUIRE(variant.as() == 0.0);\n REQUIRE(variant.as() == 0L);\n REQUIRE(variant.as() == \"null\");\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(\\\"42\\\")\") {\n variant.set(\"42\");\n\n REQUIRE(variant.as() == 42L);\n REQUIRE(variant.as() == 42);\n REQUIRE(variant.as() == \"42\");\n }\n\n SECTION(\"set(\\\"hello\\\")\") {\n variant.set(\"hello\");\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 0L);\n REQUIRE(variant.as() == \"hello\"_s);\n REQUIRE(variant.as() == \"hello\"_s);\n REQUIRE(variant.as() == \"hello\"_s);\n REQUIRE(variant.as() == \"hello\");\n }\n\n SECTION(\"set(std::string(\\\"4.2\\\")) (tiny string optimization)\") {\n variant.set(\"4.2\"_s);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 4L);\n REQUIRE(variant.as() == Approx(4.2));\n REQUIRE(variant.as() == \"4.2\"_s);\n REQUIRE(variant.as() == \"4.2\"_s);\n REQUIRE(variant.as() == \"4.2\");\n }\n\n SECTION(\"set(std::string(\\\"123.45\\\"))\") {\n variant.set(\"123.45\"_s);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 123L);\n REQUIRE(variant.as() == Approx(123.45));\n REQUIRE(variant.as() == \"123.45\"_s);\n REQUIRE(variant.as() == \"123.45\"_s);\n REQUIRE(variant.as() == \"123.45\");\n }\n\n SECTION(\"set(\\\"true\\\")\") {\n variant.set(\"true\");\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as() == \"true\");\n }\n\n SECTION(\"set(-1e300)\") {\n variant.set(-1e300);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == -1e300);\n REQUIRE(variant.as() < 0);\n REQUIRE(my::isinf(variant.as()));\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(1e300)\") {\n variant.set(1e300);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 1e300);\n REQUIRE(variant.as() > 0);\n REQUIRE(my::isinf(variant.as()));\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(1e-300)\") {\n variant.set(1e-300);\n\n REQUIRE(variant.as() == true);\n REQUIRE(variant.as() == 1e-300);\n REQUIRE(variant.as() == 0);\n REQUIRE(variant.as().isNull());\n }\n\n SECTION(\"set(serialized(\\\"hello\\\"))\") {\n variant.set(serialized(\"hello\"));\n\n REQUIRE(variant.as().data() == nullptr);\n REQUIRE(variant.as().data() == nullptr);\n }\n\n SECTION(\"to()\") {\n JsonObject obj = variant.to();\n obj[\"key\"] = \"value\";\n\n SECTION(\"as()\") {\n REQUIRE(variant.as() == true);\n }\n\n SECTION(\"as()\") {\n REQUIRE(variant.as() == \"{\\\"key\\\":\\\"value\\\"}\"_s);\n }\n\n SECTION(\"ObjectAsJsonObject\") {\n JsonObject o = variant.as();\n REQUIRE(o.size() == 1);\n REQUIRE(o[\"key\"] == \"value\"_s);\n }\n }\n\n SECTION(\"to()\") {\n JsonArray arr = variant.to();\n arr.add(4);\n arr.add(2);\n\n SECTION(\"as()\") {\n REQUIRE(variant.as() == true);\n }\n\n SECTION(\"as()\") {\n REQUIRE(variant.as() == \"[4,2]\"_s);\n }\n\n SECTION(\"as()\") {\n JsonArray a = variant.as();\n REQUIRE(a.size() == 2);\n REQUIRE(a[0] == 4);\n REQUIRE(a[1] == 2);\n }\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"Smallest int64 negative\") {\n variant.set(\"-9223372036854775808\");\n REQUIRE(variant.as() == -9223372036854775807 - 1);\n }\n\n SECTION(\"Biggest int64 positive\") {\n variant.set(\"9223372036854775807\");\n REQUIRE(variant.as() == 9223372036854775807);\n }\n#endif\n\n SECTION(\"as()\") {\n variant.set(1);\n\n REQUIRE(variant.as() == ONE);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/clear.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariant::clear()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonVariant var = doc.to();\n\n SECTION(\"size goes back to zero\") {\n var.add(42);\n var.clear();\n\n REQUIRE(var.size() == 0);\n }\n\n SECTION(\"isNull() return true\") {\n var.add(\"hello\");\n var.clear();\n\n REQUIRE(var.isNull() == true);\n }\n\n SECTION(\"releases owned string\") {\n var.set(\"hello\"_s);\n var.clear();\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n Deallocate(sizeofString(\"hello\")),\n });\n }\n}\n" }, { "path": "extras/tests/JsonVariant/compare.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n// Most code is already covered by arithmeticCompare.cpp.\n// Here, we're just filling the holes\n\nTEST_CASE(\"Compare JsonVariant with value\") {\n JsonDocument doc;\n JsonVariant a = doc.add();\n\n SECTION(\"null vs (char*)0\") {\n char* b = 0;\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42 vs 42\") {\n a.set(42);\n int b = 42;\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n}\n\nTEST_CASE(\"Compare JsonVariant with JsonVariant\") {\n JsonDocument doc;\n JsonVariant a = doc.add();\n JsonVariant b = doc.add();\n\n SECTION(\"'abc' vs 'abc'\") {\n a.set(\"abc\");\n b.set(\"abc\");\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"'abc' vs 'bcd'\") {\n a.set(\"abc\");\n b.set(\"bcd\");\n\n CHECK(a != b);\n CHECK(a < b);\n CHECK(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"'bcd' vs 'abc'\") {\n a.set(\"bcd\");\n b.set(\"abc\");\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"serialized('abc') vs serialized('abc')\") {\n a.set(serialized(\"abc\"));\n b.set(serialized(\"abc\"));\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"serialized('abc') vs serialized('bcd')\") {\n a.set(serialized(\"abc\"));\n b.set(serialized(\"bcd\"));\n\n CHECK(a != b);\n CHECK(a < b);\n CHECK(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"serialized('bcd') vs serialized('abc')\") {\n a.set(serialized(\"bcd\"));\n b.set(serialized(\"abc\"));\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"MsgPackBinary('abc') vs MsgPackBinary('abc')\") {\n a.set(MsgPackBinary(\"abc\", 4));\n b.set(MsgPackBinary(\"abc\", 4));\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"MsgPackBinary('abc') vs MsgPackBinary('bcd')\") {\n a.set(MsgPackBinary(\"abc\", 4));\n b.set(MsgPackBinary(\"bcd\", 4));\n\n CHECK(a != b);\n CHECK(a < b);\n CHECK(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"MsgPackBinary('bcd') vs MsgPackBinary('abc')\") {\n a.set(MsgPackBinary(\"bcd\", 4));\n b.set(MsgPackBinary(\"abc\", 4));\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"false vs true\") {\n a.set(false);\n b.set(true);\n\n CHECK(a != b);\n CHECK(a < b);\n CHECK(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"false vs -1\") {\n a.set(false);\n b.set(-1);\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"null vs null\") {\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42 vs 42\") {\n a.set(42);\n b.set(42);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42 vs 42U\") {\n a.set(42);\n b.set(42U);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42 vs 42.0\") {\n a.set(42);\n b.set(42.0);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42.0 vs 42\") {\n a.set(42.0);\n b.set(42);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"-42 vs -42\") {\n a.set(-42);\n b.set(-42);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"-42 vs 42\") {\n a.set(-42);\n b.set(42);\n\n CHECK(a != b);\n CHECK(a < b);\n CHECK(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"42 vs -42\") {\n a.set(42);\n b.set(-42);\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"42.0 vs -42\") {\n a.set(42.0);\n b.set(-42);\n\n CHECK(a != b);\n CHECK(a > b);\n CHECK(a >= b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n }\n\n SECTION(\"42U vs 42U\") {\n a.set(42U);\n b.set(42U);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"42U vs 42\") {\n a.set(42U);\n b.set(42);\n\n CHECK(a == b);\n CHECK(a <= b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"[1] vs [1]\") {\n a.add(1);\n b.add(1);\n\n CHECK(a <= b);\n CHECK(a == b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"[1] vs [2]\") {\n a.add(1);\n b.add(2);\n\n CHECK(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n\n SECTION(\"{x:1} vs {x:1}\") {\n a[\"x\"] = 1;\n b[\"x\"] = 1;\n\n CHECK(a <= b);\n CHECK(a == b);\n CHECK(a >= b);\n CHECK_FALSE(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a > b);\n }\n\n SECTION(\"{x:1} vs {x:2}\") {\n a[\"x\"] = 1;\n b[\"x\"] = 2;\n\n CHECK(a != b);\n CHECK_FALSE(a < b);\n CHECK_FALSE(a <= b);\n CHECK_FALSE(a == b);\n CHECK_FALSE(a > b);\n CHECK_FALSE(a >= b);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/converters.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nnamespace {\nstruct Date {\n int day;\n int month;\n int year;\n};\n\nvoid convertToJson(const Date& src, JsonVariant dst) {\n dst[\"day\"] = src.day;\n dst[\"month\"] = src.month;\n dst[\"year\"] = src.year;\n}\n\nvoid convertFromJson(JsonVariantConst src, Date& dst) {\n dst.day = src[\"day\"];\n dst.month = src[\"month\"];\n dst.year = src[\"year\"];\n}\n\nbool canConvertFromJson(JsonVariantConst src, const Date&) {\n return src[\"day\"].is() && src[\"month\"].is() &&\n src[\"year\"].is();\n}\n} // namespace\n\nTEST_CASE(\"Custom converter with overloading\") {\n JsonDocument doc;\n\n SECTION(\"convert JSON to Date\") {\n doc[\"date\"][\"day\"] = 2;\n doc[\"date\"][\"month\"] = 3;\n doc[\"date\"][\"year\"] = 2021;\n\n Date date = doc[\"date\"];\n\n REQUIRE(date.day == 2);\n REQUIRE(date.month == 3);\n REQUIRE(date.year == 2021);\n }\n\n SECTION(\"is() returns true\") {\n doc[\"date\"][\"day\"] = 2;\n doc[\"date\"][\"month\"] = 3;\n doc[\"date\"][\"year\"] = 2021;\n\n REQUIRE(doc[\"date\"].is());\n }\n\n SECTION(\"is() returns false\") {\n doc[\"date\"][\"day\"] = 2;\n doc[\"date\"][\"month\"] = 3;\n doc[\"date\"][\"year\"] = \"2021\";\n\n REQUIRE(doc[\"date\"].is() == false);\n }\n\n SECTION(\"convert Date to JSON\") {\n Date date = {19, 3, 2021};\n doc[\"date\"] = date;\n\n REQUIRE(doc[\"date\"][\"day\"] == 19);\n REQUIRE(doc[\"date\"][\"month\"] == 3);\n REQUIRE(doc[\"date\"][\"year\"] == 2021);\n }\n}\n\nclass Complex {\n public:\n explicit Complex(double r, double i) : real_(r), imag_(i) {}\n\n double real() const {\n return real_;\n }\n\n double imag() const {\n return imag_;\n }\n\n private:\n double real_, imag_;\n};\n\nnamespace ArduinoJson {\ntemplate <>\nstruct Converter {\n static void toJson(const Complex& src, JsonVariant dst) {\n dst[\"real\"] = src.real();\n dst[\"imag\"] = src.imag();\n }\n\n static Complex fromJson(JsonVariantConst src) {\n return Complex(src[\"real\"], src[\"imag\"]);\n }\n\n static bool checkJson(JsonVariantConst src) {\n return src[\"real\"].is() && src[\"imag\"].is();\n }\n};\n} // namespace ArduinoJson\n\nTEST_CASE(\"Custom converter with specialization\") {\n JsonDocument doc;\n\n SECTION(\"convert JSON to Complex\") {\n doc[\"value\"][\"real\"] = 2;\n doc[\"value\"][\"imag\"] = 3;\n\n Complex value = doc[\"value\"];\n\n REQUIRE(value.real() == 2);\n REQUIRE(value.imag() == 3);\n }\n\n SECTION(\"is() returns true\") {\n doc[\"value\"][\"real\"] = 2;\n doc[\"value\"][\"imag\"] = 3;\n\n REQUIRE(doc[\"value\"].is());\n }\n\n SECTION(\"is() returns false\") {\n doc[\"value\"][\"real\"] = 2;\n doc[\"value\"][\"imag\"] = \"3\";\n\n REQUIRE(doc[\"value\"].is() == false);\n }\n\n SECTION(\"convert value to JSON\") {\n doc[\"value\"] = Complex(19, 3);\n\n REQUIRE(doc[\"value\"][\"real\"] == 19);\n REQUIRE(doc[\"value\"][\"imag\"] == 3);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/copy.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \"Allocators.hpp\"\n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariant::set(JsonVariant)\") {\n KillswitchAllocator killswitch;\n SpyingAllocator spyingAllocator(&killswitch);\n JsonDocument doc1(&spyingAllocator);\n JsonDocument doc2(&spyingAllocator);\n JsonVariant var1 = doc1.to();\n JsonVariant var2 = doc2.to();\n\n SECTION(\"stores JsonArray by copy\") {\n JsonArray arr = doc2.to();\n JsonObject obj = arr.add();\n obj[\"hello\"] = \"world\";\n\n var1.set(arr);\n\n arr[0] = 666;\n REQUIRE(var1.as() == \"[{\\\"hello\\\":\\\"world\\\"}]\");\n }\n\n SECTION(\"stores JsonObject by copy\") {\n JsonObject obj = doc2.to();\n JsonArray arr = obj[\"value\"].to();\n arr.add(42);\n\n var1.set(obj);\n\n obj[\"value\"] = 666;\n REQUIRE(var1.as() == \"{\\\"value\\\":[42]}\");\n }\n\n SECTION(\"stores string literals by copy\") {\n var1.set(\"hello!!\");\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"stores char* by copy\") {\n char str[] = \"hello!!\";\n var1.set(str);\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"fails gracefully if string allocation fails\") {\n char str[] = \"hello!!\";\n var1.set(str);\n killswitch.on();\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(doc2.overflowed() == true);\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n AllocateFail(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"stores std::string by copy\") {\n var1.set(\"hello!!\"_s);\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"stores Serialized by copy\") {\n var1.set(serialized(\"hello!!\", 7));\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"stores Serialized by copy\") {\n char str[] = \"hello!!\";\n var1.set(serialized(str, 7));\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"stores Serialized by copy\") {\n var1.set(serialized(\"hello!!\"_s));\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"fails gracefully if raw string allocation fails\") {\n var1.set(serialized(\"hello!!\"_s));\n killswitch.on();\n spyingAllocator.clearLog();\n\n var2.set(var1);\n\n REQUIRE(doc2.overflowed() == true);\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n AllocateFail(sizeofString(\"hello!!\")),\n });\n }\n\n SECTION(\"destination is unbound\") {\n JsonVariant unboundVariant;\n\n unboundVariant.set(var1);\n\n REQUIRE(unboundVariant.isUnbound());\n REQUIRE(unboundVariant.isNull());\n }\n}\n" }, { "path": "extras/tests/JsonVariant/is.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nenum MYENUM2 { ONE = 1, TWO = 2 };\n\nTEST_CASE(\"JsonVariant::is()\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"unbound\") {\n variant = JsonVariant();\n\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"null\") {\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"true\") {\n variant.set(true);\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"false\") {\n variant.set(false);\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"int\") {\n variant.set(42);\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"double\") {\n variant.set(4.2);\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"const char*\") {\n variant.set(\"4.2\");\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"JsonArray\") {\n variant.to();\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n }\n\n SECTION(\"JsonObject\") {\n variant.to();\n\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == false);\n CHECK(variant.is() == true);\n CHECK(variant.is() == true);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/isnull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariant::isNull()\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"returns true when Undefined\") {\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns false when Integer\") {\n variant.set(42);\n\n REQUIRE(variant.isNull() == false);\n }\n\n SECTION(\"returns false when EmptyArray\") {\n JsonDocument doc2;\n JsonArray array = doc2.to();\n\n variant.set(array);\n REQUIRE(variant.isNull() == false);\n }\n\n SECTION(\"returns false when EmptyObject\") {\n JsonDocument doc2;\n JsonObject obj = doc2.to();\n\n variant.set(obj);\n REQUIRE(variant.isNull() == false);\n }\n\n SECTION(\"returns true after set(JsonArray())\") {\n variant.set(JsonArray());\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns true after set(JsonObject())\") {\n variant.set(JsonObject());\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns false after set('hello')\") {\n variant.set(\"hello\");\n REQUIRE(variant.isNull() == false);\n }\n\n SECTION(\"returns true after set((char*)0)\") {\n variant.set(static_cast(0));\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns true after set((const char*)0)\") {\n variant.set(static_cast(0));\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns true after set(serialized((char*)0))\") {\n variant.set(serialized(static_cast(0)));\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns true after set(serialized((const char*)0))\") {\n variant.set(serialized(static_cast(0)));\n REQUIRE(variant.isNull() == true);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/misc.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"VariantData\") {\n REQUIRE(std::is_standard_layout::value ==\n true);\n}\n\nTEST_CASE(\"StringNode\") {\n REQUIRE(std::is_standard_layout::value ==\n true);\n}\n\nTEST_CASE(\"JsonVariant from JsonArray\") {\n SECTION(\"JsonArray is null\") {\n JsonArray arr;\n JsonVariant v = arr;\n REQUIRE(v.isNull() == true);\n }\n\n SECTION(\"JsonArray is not null\") {\n JsonDocument doc;\n JsonArray arr = doc.to();\n arr.add(12);\n arr.add(34);\n\n JsonVariant v = arr;\n\n REQUIRE(v.is() == true);\n REQUIRE(v.size() == 2);\n REQUIRE(v[0] == 12);\n REQUIRE(v[1] == 34);\n }\n}\n\nTEST_CASE(\"JsonVariant from JsonObject\") {\n SECTION(\"JsonObject is null\") {\n JsonObject obj;\n JsonVariant v = obj;\n REQUIRE(v.isNull() == true);\n }\n\n SECTION(\"JsonObject is not null\") {\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"a\"] = 12;\n obj[\"b\"] = 34;\n\n JsonVariant v = obj;\n\n REQUIRE(v.is() == true);\n REQUIRE(v.size() == 2);\n REQUIRE(v[\"a\"] == 12);\n REQUIRE(v[\"b\"] == 34);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariant::nesting()\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n SECTION(\"return 0 if uninitialized\") {\n JsonVariant unitialized;\n REQUIRE(unitialized.nesting() == 0);\n }\n\n SECTION(\"returns 0 for string\") {\n var.set(\"hello\");\n REQUIRE(var.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty object\") {\n var.to();\n REQUIRE(var.nesting() == 1);\n }\n\n SECTION(\"returns 1 for empty array\") {\n var.to();\n REQUIRE(var.nesting() == 1);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/nullptr.cpp", "content": "#include \n\n#include \n\nTEST_CASE(\"nullptr\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"JsonVariant == nullptr\") {\n REQUIRE(variant == nullptr);\n REQUIRE_FALSE(variant != nullptr);\n }\n\n SECTION(\"JsonVariant != nullptr\") {\n variant.set(42);\n\n REQUIRE_FALSE(variant == nullptr);\n REQUIRE(variant != nullptr);\n }\n\n SECTION(\"JsonVariant.set(nullptr)\") {\n variant.set(42);\n variant.set(nullptr);\n\n REQUIRE(variant.isNull());\n }\n\n SECTION(\"JsonVariant.set(nullptr) with unbound reference\") {\n JsonVariant unboundReference;\n\n unboundReference.set(nullptr);\n\n REQUIRE(variant.isNull());\n }\n\n SECTION(\"JsonVariant.is()\") {\n variant.set(42);\n REQUIRE(variant.is() == false);\n\n variant.clear();\n REQUIRE(variant.is() == true);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/or.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariant::operator|()\") {\n JsonDocument doc;\n JsonVariant variant = doc[\"value\"].to();\n\n SECTION(\"null\") {\n SECTION(\"null | const char*\") {\n std::string result = variant | \"default\";\n REQUIRE(result == \"default\");\n }\n\n SECTION(\"null | int\") {\n int result = variant | 42;\n REQUIRE(result == 42);\n }\n\n SECTION(\"null | bool\") {\n bool result = variant | true;\n REQUIRE(result == true);\n }\n\n SECTION(\"null | ElementProxy\") {\n doc[\"array\"][0] = 42;\n\n JsonVariantConst result = variant | doc[\"array\"][0];\n REQUIRE(result == 42);\n }\n\n SECTION(\"null | MemberProxy\") {\n doc[\"other\"] = 42;\n\n JsonVariantConst result = variant | doc[\"other\"];\n REQUIRE(result == 42);\n }\n\n SECTION(\"ElementProxy | ElementProxy\") {\n doc[\"array\"][0] = 42;\n\n JsonVariantConst result = doc[\"array\"][1] | doc[\"array\"][0];\n REQUIRE(result == 42);\n }\n }\n\n SECTION(\"null\") {\n variant.set(static_cast(0));\n\n SECTION(\"null | const char*\") {\n std::string result = variant | \"default\";\n REQUIRE(result == \"default\");\n }\n\n SECTION(\"null | int\") {\n int result = variant | 42;\n REQUIRE(result == 42);\n }\n\n SECTION(\"null | bool\") {\n bool result = variant | true;\n REQUIRE(result == true);\n }\n\n SECTION(\"null | ElementProxy\") {\n doc[\"array\"][0] = 42;\n\n JsonVariantConst result = variant | doc[\"array\"][0];\n REQUIRE(result == 42);\n }\n\n SECTION(\"null | MemberProxy\") {\n doc[\"other\"] = 42;\n\n JsonVariantConst result = variant | doc[\"other\"];\n REQUIRE(result == 42);\n }\n }\n\n SECTION(\"int | const char*\") {\n variant.set(42);\n std::string result = variant | \"default\";\n REQUIRE(result == \"default\");\n }\n\n SECTION(\"int | uint8_t (out of range)\") {\n variant.set(666);\n uint8_t result = variant | static_cast(42);\n REQUIRE(result == 42);\n }\n\n SECTION(\"int | ElementProxy\") {\n variant.set(42);\n doc[\"array\"][0] = 666;\n JsonVariantConst result = variant | doc[\"array\"][0];\n REQUIRE(result == 42);\n }\n\n SECTION(\"int | MemberProxy\") {\n variant.set(42);\n doc[\"other\"] = 666;\n JsonVariantConst result = variant | doc[\"other\"];\n REQUIRE(result == 42);\n }\n\n SECTION(\"int | int\") {\n variant.set(0);\n int result = variant | 666;\n REQUIRE(result == 0);\n }\n\n SECTION(\"double | int\") {\n // NOTE: changed the behavior to fix #981\n variant.set(666.0);\n int result = variant | 42;\n REQUIRE(result == 42);\n }\n\n SECTION(\"bool | bool\") {\n variant.set(false);\n bool result = variant | true;\n REQUIRE(result == false);\n }\n\n SECTION(\"int | bool\") {\n variant.set(0);\n bool result = variant | true;\n REQUIRE(result == true);\n }\n\n SECTION(\"const char* | const char*\") {\n variant.set(\"not default\");\n std::string result = variant | \"default\";\n REQUIRE(result == \"not default\");\n }\n\n SECTION(\"const char* | char*\") {\n char dflt[] = \"default\";\n variant.set(\"not default\");\n std::string result = variant | dflt;\n REQUIRE(result == \"not default\");\n }\n\n SECTION(\"int | char*\") {\n char dflt[] = \"default\";\n variant.set(42);\n std::string result = variant | dflt;\n REQUIRE(result == \"default\");\n }\n\n SECTION(\"const char* | int\") {\n variant.set(\"not default\");\n int result = variant | 42;\n REQUIRE(result == 42);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/overflow.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\ntemplate \nvoid shouldBeOk(TIn value) {\n JsonDocument doc;\n JsonVariant var = doc.to();\n var.set(value);\n REQUIRE(var.as() == TOut(value));\n}\n\ntemplate \nvoid shouldOverflow(TIn value) {\n JsonDocument doc;\n JsonVariant var = doc.to();\n var.set(value);\n REQUIRE(var.as() == 0);\n REQUIRE(var.is() == false);\n}\n\nTEST_CASE(\"Handle integer overflow in stored integer\") {\n SECTION(\"int8_t\") {\n // ok\n shouldBeOk(-128);\n shouldBeOk(42.0);\n shouldBeOk(127);\n\n // too low\n shouldOverflow(-128.1);\n shouldOverflow(-129);\n\n // too high\n shouldOverflow(128);\n shouldOverflow(127.1);\n }\n\n SECTION(\"int16_t\") {\n // ok\n shouldBeOk(-32768);\n shouldBeOk(-32767.9);\n shouldBeOk(32766.9);\n shouldBeOk(32767);\n\n // too low\n shouldOverflow(-32768.1);\n shouldOverflow(-32769);\n\n // too high\n shouldOverflow(32767.1);\n shouldOverflow(32768);\n }\n\n SECTION(\"uint8_t\") {\n // ok\n shouldBeOk(1);\n shouldBeOk(42.0);\n shouldBeOk(255);\n\n // too low\n shouldOverflow(-1);\n shouldOverflow(-0.1);\n\n // to high\n shouldOverflow(255.1);\n shouldOverflow(256);\n shouldOverflow(257);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/remove.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\n\nTEST_CASE(\"JsonVariant::remove(int)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"release top level strings\") {\n doc.add(\"hello\"_s);\n doc.add(\"hello\"_s);\n doc.add(\"world\"_s);\n\n JsonVariant var = doc.as();\n REQUIRE(var.as() == \"[\\\"hello\\\",\\\"hello\\\",\\\"world\\\"]\");\n\n spy.clearLog();\n var.remove(1);\n REQUIRE(var.as() == \"[\\\"hello\\\",\\\"world\\\"]\");\n REQUIRE(spy.log() == AllocatorLog{});\n\n spy.clearLog();\n var.remove(1);\n REQUIRE(var.as() == \"[\\\"hello\\\"]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n\n spy.clearLog();\n var.remove(0);\n REQUIRE(var.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"release strings in nested array\") {\n doc[0][0] = \"hello\"_s;\n\n JsonVariant var = doc.as();\n REQUIRE(var.as() == \"[[\\\"hello\\\"]]\");\n\n spy.clearLog();\n var.remove(0);\n\n REQUIRE(var.as() == \"[]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n}\n\nTEST_CASE(\"JsonVariant::remove(const char *)\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n var[\"a\"] = 1;\n var[\"b\"] = 2;\n\n var.remove(\"a\");\n\n REQUIRE(var.as() == \"{\\\"b\\\":2}\");\n}\n\nTEST_CASE(\"JsonVariant::remove(std::string)\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n var[\"a\"] = 1;\n var[\"b\"] = 2;\n\n var.remove(\"b\"_s);\n\n REQUIRE(var.as() == \"{\\\"a\\\":1}\");\n}\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\nTEST_CASE(\"JsonVariant::remove(VLA)\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n var[\"a\"] = 1;\n var[\"b\"] = 2;\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"b\");\n\n var.remove(\"b\"_s);\n\n REQUIRE(var.as() == \"{\\\"a\\\":1}\");\n}\n#endif\n\nTEST_CASE(\"JsonVariant::remove(JsonVariant) from object\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n var[\"a\"] = \"a\";\n var[\"b\"] = 2;\n var[\"c\"] = \"b\";\n\n var.remove(var[\"c\"]);\n\n REQUIRE(var.as() == \"{\\\"a\\\":\\\"a\\\",\\\"c\\\":\\\"b\\\"}\");\n}\n\nTEST_CASE(\"JsonVariant::remove(JsonVariant) from array\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n var[0] = 3;\n var[1] = 2;\n var[2] = 1;\n\n var.remove(var[2]);\n var.remove(var[3]); // noop\n\n REQUIRE(var.as() == \"[3,1]\");\n}\n" }, { "path": "extras/tests/JsonVariant/set.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nenum ErrorCode { ERROR_01 = 1, ERROR_10 = 10 };\n\nTEST_CASE(\"JsonVariant::set() when there is enough memory\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonVariant variant = doc.to();\n\n SECTION(\"string literal\") {\n bool result = variant.set(\"hello world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello world\"_s); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(11)),\n });\n }\n\n SECTION(\"const char*\") {\n char str[16];\n\n strcpy(str, \"hello\");\n bool result = variant.set(static_cast(str));\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"(const char*)0\") {\n bool result = variant.set(static_cast(0));\n\n REQUIRE(result == true);\n REQUIRE(variant.isNull());\n REQUIRE(variant.as() == nullptr);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"char*\") {\n char str[16];\n\n strcpy(str, \"hello\");\n bool result = variant.set(str);\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"char* (tiny string optimization)\") {\n char str[16];\n\n strcpy(str, \"abc\");\n bool result = variant.set(str);\n strcpy(str, \"def\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"abc\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"(char*)0\") {\n bool result = variant.set(static_cast(0));\n\n REQUIRE(result == true);\n REQUIRE(variant.isNull());\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"unsigned char*\") {\n char str[16];\n\n strcpy(str, \"hello\");\n bool result = variant.set(reinterpret_cast(str));\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"signed char*\") {\n char str[16];\n\n strcpy(str, \"hello\");\n bool result = variant.set(reinterpret_cast(str));\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"VLA\") {\n size_t n = 16;\n char str[n];\n\n strcpy(str, \"hello\");\n bool result = variant.set(str);\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n#endif\n\n SECTION(\"std::string\") {\n std::string str = \"hello\\0world\"_s;\n bool result = variant.set(str);\n str.replace(0, 5, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\\0world\"_s); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello?world\")),\n });\n }\n\n SECTION(\"JsonString\") {\n char str[16];\n\n strcpy(str, \"hello\");\n bool result = variant.set(JsonString(str));\n strcpy(str, \"world\");\n\n REQUIRE(result == true);\n REQUIRE(variant == \"hello\"); // stores by copy\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"enum\") {\n ErrorCode code = ERROR_10;\n\n bool result = variant.set(code);\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 10);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"float\") {\n bool result = variant.set(1.2f);\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 1.2f);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"double\") {\n bool result = variant.set(1.2);\n doc.shrinkToFit();\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 1.2);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(),\n sizeofPool(1)),\n });\n }\n\n SECTION(\"int32_t\") {\n bool result = variant.set(int32_t(42));\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 42);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"int64_t\") {\n bool result = variant.set(int64_t(-2147483649LL));\n doc.shrinkToFit();\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == -2147483649LL);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(),\n sizeofPool(1)),\n });\n }\n\n SECTION(\"uint32_t\") {\n bool result = variant.set(uint32_t(42));\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 42);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"uint64_t\") {\n bool result = variant.set(uint64_t(4294967296));\n doc.shrinkToFit();\n\n REQUIRE(result == true);\n REQUIRE(variant.is() == true);\n REQUIRE(variant.as() == 4294967296);\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(),\n sizeofPool(1)),\n });\n }\n\n SECTION(\"JsonDocument\") {\n JsonDocument doc1;\n doc1[\"hello\"] = \"world\";\n\n // Should copy the doc\n variant.set(doc1);\n doc1.clear();\n\n std::string json;\n serializeJson(doc, json);\n REQUIRE(json == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n}\n\nTEST_CASE(\"JsonVariant::set() with not enough memory\") {\n JsonDocument doc(FailingAllocator::instance());\n\n JsonVariant v = doc.to();\n\n SECTION(\"std::string\") {\n bool result = v.set(\"hello world!!\"_s);\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n\n SECTION(\"Serialized\") {\n bool result = v.set(serialized(\"hello world!!\"_s));\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n\n SECTION(\"char*\") {\n char s[] = \"hello world!!\";\n bool result = v.set(s);\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n\n SECTION(\"float\") {\n bool result = v.set(1.2f);\n\n REQUIRE(result == true);\n REQUIRE(v.is());\n }\n\n SECTION(\"double\") {\n bool result = v.set(1.2);\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n\n SECTION(\"int32_t\") {\n bool result = v.set(-42);\n\n REQUIRE(result == true);\n REQUIRE(v.is());\n }\n\n SECTION(\"int64_t\") {\n bool result = v.set(-2147483649LL);\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n\n SECTION(\"uint32_t\") {\n bool result = v.set(42);\n\n REQUIRE(result == true);\n REQUIRE(v.is());\n }\n\n SECTION(\"uint64_t\") {\n bool result = v.set(4294967296U);\n\n REQUIRE(result == false);\n REQUIRE(v.isNull());\n }\n}\n\nTEST_CASE(\"JsonVariant::set() releases the previous value\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc[\"hello\"] = \"world\"_s;\n spy.clearLog();\n\n JsonVariant v = doc[\"hello\"];\n\n SECTION(\"int\") {\n v.set(42);\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"bool\") {\n v.set(false);\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"const char*\") {\n v.set(\"hello\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"float\") {\n v.set(1.2f);\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"Serialized\") {\n v.set(serialized(\"[]\"));\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n Allocate(sizeofString(\"[]\")),\n });\n }\n}\n\nTEST_CASE(\"JsonVariant::set() reuses 8-bit slot\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonVariant variant = doc.to();\n\n variant.set(1.2);\n doc.shrinkToFit();\n spy.clearLog();\n\n SECTION(\"double\") {\n bool result = variant.set(3.4);\n\n REQUIRE(result == true);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"int64_t\") {\n bool result = variant.set(-2147483649LL);\n\n REQUIRE(result == true);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"uint64_t\") {\n bool result = variant.set(4294967296U);\n\n REQUIRE(result == true);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n}\n" }, { "path": "extras/tests/JsonVariant/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariant::size()\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"unbound reference\") {\n JsonVariant unbound;\n\n CHECK(unbound.size() == 0);\n }\n\n SECTION(\"int\") {\n variant.set(42);\n\n CHECK(variant.size() == 0);\n }\n\n SECTION(\"string\") {\n variant.set(\"hello\");\n\n CHECK(variant.size() == 0);\n }\n\n SECTION(\"object\") {\n variant[\"a\"] = 1;\n variant[\"b\"] = 2;\n\n CHECK(variant.size() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/stl_containers.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \n#include \n#include \n\nnamespace ArduinoJson {\ntemplate \nstruct Converter> {\n static void toJson(const std::vector& src, JsonVariant dst) {\n JsonArray array = dst.to();\n for (T item : src)\n array.add(item);\n }\n\n static std::vector fromJson(JsonVariantConst src) {\n std::vector dst;\n for (T item : src.as())\n dst.push_back(item);\n return dst;\n }\n\n static bool checkJson(JsonVariantConst src) {\n JsonArrayConst array = src;\n bool result = array;\n for (JsonVariantConst item : array)\n result &= item.is();\n return result;\n }\n};\n\ntemplate \nstruct Converter> {\n static void toJson(const std::array& src, JsonVariant dst) {\n JsonArray array = dst.to();\n for (T item : src)\n array.add(item);\n }\n\n static std::array fromJson(JsonVariantConst src) {\n std::array dst;\n dst.fill(0);\n size_t idx = 0;\n for (T item : src.as())\n dst[idx++] = item;\n return dst;\n }\n\n static bool checkJson(JsonVariantConst src) {\n JsonArrayConst array = src;\n bool result = array;\n size_t size = 0;\n for (JsonVariantConst item : array) {\n result &= item.is();\n size++;\n }\n return result && size == N;\n }\n};\n} // namespace ArduinoJson\n\nTEST_CASE(\"vector\") {\n SECTION(\"toJson\") {\n std::vector v = {1, 2};\n\n JsonDocument doc;\n doc.set(v);\n REQUIRE(doc.as() == \"[1,2]\");\n }\n\n SECTION(\"fromJson\") {\n JsonDocument doc;\n doc.add(1);\n doc.add(2);\n\n auto v = doc.as>();\n REQUIRE(v.size() == 2);\n CHECK(v[0] == 1);\n CHECK(v[1] == 2);\n }\n\n SECTION(\"checkJson\") {\n JsonDocument doc;\n CHECK(doc.is>() == false);\n\n doc.add(1);\n doc.add(2);\n CHECK(doc.is>() == true);\n\n doc.add(\"foo\");\n CHECK(doc.is>() == false);\n }\n}\n\nTEST_CASE(\"array\") {\n using array_type = std::array;\n\n SECTION(\"toJson\") {\n array_type v;\n v[0] = 1;\n v[1] = 2;\n\n JsonDocument doc;\n doc.set(v);\n REQUIRE(doc.as() == \"[1,2]\");\n }\n\n SECTION(\"fromJson\") {\n JsonDocument doc;\n doc.add(1);\n doc.add(2);\n\n auto v = doc.as();\n REQUIRE(v.size() == 2);\n CHECK(v[0] == 1);\n CHECK(v[1] == 2);\n }\n\n SECTION(\"checkJson\") {\n JsonDocument doc;\n CHECK(doc.is() == false);\n\n doc.add(1);\n CHECK(doc.is() == false);\n\n doc.add(2);\n CHECK(doc.is() == true);\n\n doc[0] = \"foo\";\n CHECK(doc.is() == false);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariant::operator[]\") {\n JsonDocument doc;\n JsonVariant var = doc.to();\n\n SECTION(\"The JsonVariant is null\") {\n REQUIRE(0 == var.size());\n REQUIRE(var[\"0\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"The JsonVariant is a string\") {\n var.set(\"hello world\");\n REQUIRE(0 == var.size());\n REQUIRE(var[\"0\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"The JsonVariant is a JsonArray\") {\n JsonArray array = var.to();\n\n SECTION(\"get value\") {\n array.add(\"element at index 0\");\n array.add(\"element at index 1\");\n\n REQUIRE(2 == var.size());\n var[0].as();\n // REQUIRE(\"element at index 0\"_s == );\n REQUIRE(\"element at index 1\"_s == var[1]);\n REQUIRE(\"element at index 0\"_s ==\n var[static_cast(0)]); // issue #381\n REQUIRE(var[666].isNull());\n REQUIRE(var[3].isNull());\n REQUIRE(var[\"0\"].isNull());\n }\n\n SECTION(\"set value\") {\n array.add(\"hello\");\n\n var[1] = \"world\";\n\n REQUIRE(var.size() == 2);\n REQUIRE(\"world\"_s == var[1]);\n }\n\n SECTION(\"set value in a nested object\") {\n array.add();\n\n var[0][\"hello\"] = \"world\";\n\n REQUIRE(1 == var.size());\n REQUIRE(1 == var[0].size());\n REQUIRE(\"world\"_s == var[0][\"hello\"]);\n }\n\n SECTION(\"variant[0] when variant contains an integer\") {\n var.set(123);\n\n var[0] = 345; // no-op\n\n REQUIRE(var.is());\n REQUIRE(var.as() == 123);\n }\n\n SECTION(\"use JsonVariant as index\") {\n array.add(\"A\");\n array.add(\"B\");\n array.add(1);\n\n REQUIRE(var[var[2]] == \"B\");\n REQUIRE(var[var[3]].isNull());\n }\n }\n\n SECTION(\"The JsonVariant is a JsonObject\") {\n JsonObject object = var.to();\n\n SECTION(\"get value\") {\n object[\"a\"] = \"element at key \\\"a\\\"\";\n object[\"b\"] = \"element at key \\\"b\\\"\";\n\n REQUIRE(2 == var.size());\n REQUIRE(\"element at key \\\"a\\\"\"_s == var[\"a\"]);\n REQUIRE(\"element at key \\\"b\\\"\"_s == var[\"b\"]);\n REQUIRE(var[\"c\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"set value, key is a const char*\") {\n var[\"hello\"] = \"world\";\n\n REQUIRE(1 == var.size());\n REQUIRE(\"world\"_s == var[\"hello\"]);\n }\n\n SECTION(\"set value, key is a char[]\") {\n char key[] = \"hello\";\n var[key] = \"world\";\n key[0] = '!'; // make sure the key is duplicated\n\n REQUIRE(1 == var.size());\n REQUIRE(\"world\"_s == var[\"hello\"]);\n }\n\n SECTION(\"var[key].to()\") {\n JsonArray arr = var[\"hello\"].to();\n REQUIRE(arr.isNull() == false);\n }\n\n SECTION(\"use JsonVariant as key\") {\n object[\"a\"] = \"A\";\n object[\"ab\"] = \"AB\";\n object[\"ab\\0c\"_s] = \"ABC\";\n object[\"key1\"] = \"a\";\n object[\"key2\"] = \"ab\";\n object[\"key3\"] = \"ab\\0c\"_s;\n object[\"key4\"] = \"foo\";\n\n REQUIRE(var[var[\"key1\"]] == \"A\");\n REQUIRE(var[var[\"key2\"]] == \"AB\");\n REQUIRE(var[var[\"key3\"]] == \"ABC\");\n REQUIRE(var[var[\"key4\"]].isNull());\n REQUIRE(var[var[\"key5\"]].isNull());\n }\n }\n\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"key is a VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n JsonVariant variant = doc.as();\n\n REQUIRE(\"world\"_s == variant[vla]);\n }\n\n SECTION(\"key is a VLA, const JsonVariant\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"hello\");\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n const JsonVariant variant = doc.as();\n\n REQUIRE(\"world\"_s == variant[vla]);\n }\n#endif\n}\n" }, { "path": "extras/tests/JsonVariant/types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\ntemplate \nvoid checkReference(T& expected) {\n JsonVariant variant = expected;\n REQUIRE(expected == variant.as());\n}\n\ntemplate \nvoid checkNumericType() {\n JsonDocument docMin, docMax;\n JsonVariant variantMin = docMin.to();\n JsonVariant variantMax = docMax.to();\n\n T min = std::numeric_limits::min();\n T max = std::numeric_limits::max();\n\n variantMin.set(min);\n variantMax.set(max);\n\n REQUIRE(min == variantMin.as());\n REQUIRE(max == variantMax.as());\n}\n\nTEST_CASE(\"JsonVariant set()/get()\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n JsonVariant variant = doc.to();\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"SizeOfJsonInteger\") {\n REQUIRE(8 == sizeof(JsonInteger));\n }\n#endif\n\n // /!\\ Most test were moved to `JsonVariant/set.cpp`\n // TODO: move the remaining tests too\n\n SECTION(\"False\") {\n variant.set(false);\n REQUIRE(variant.as() == false);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"True\") {\n variant.set(true);\n REQUIRE(variant.as() == true);\n REQUIRE(spy.log() == AllocatorLog{});\n }\n\n SECTION(\"Double\") {\n checkNumericType();\n }\n SECTION(\"Float\") {\n checkNumericType();\n }\n SECTION(\"SChar\") {\n checkNumericType();\n }\n SECTION(\"SInt\") {\n checkNumericType();\n }\n SECTION(\"SLong\") {\n checkNumericType();\n }\n SECTION(\"SShort\") {\n checkNumericType();\n }\n SECTION(\"UChar\") {\n checkNumericType();\n }\n SECTION(\"UInt\") {\n checkNumericType();\n }\n SECTION(\"ULong\") {\n checkNumericType();\n }\n SECTION(\"UShort\") {\n checkNumericType();\n }\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"LongLong\") {\n checkNumericType();\n }\n SECTION(\"ULongLong\") {\n checkNumericType();\n }\n#endif\n\n SECTION(\"Int8\") {\n checkNumericType();\n }\n SECTION(\"Uint8\") {\n checkNumericType();\n }\n SECTION(\"Int16\") {\n checkNumericType();\n }\n SECTION(\"Uint16\") {\n checkNumericType();\n }\n SECTION(\"Int32\") {\n checkNumericType();\n }\n SECTION(\"Uint32\") {\n checkNumericType();\n }\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"Int64\") {\n checkNumericType();\n }\n SECTION(\"Uint64\") {\n checkNumericType();\n }\n#endif\n\n SECTION(\"CanStoreObject\") {\n JsonDocument doc2;\n JsonObject object = doc2.to();\n\n variant.set(object);\n REQUIRE(variant.is());\n REQUIRE(variant.as() == object);\n }\n}\n\nTEST_CASE(\"volatile\") {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n\n SECTION(\"volatile bool\") { // issue #2029\n volatile bool f = true;\n variant.set(f);\n CHECK(variant.is() == true);\n CHECK(variant.as() == true);\n }\n\n SECTION(\"volatile int\") {\n volatile int f = 42;\n variant.set(f);\n CHECK(variant.is() == true);\n CHECK(variant.as() == 42);\n }\n\n SECTION(\"volatile float\") { // issue #1557\n volatile float f = 3.14f;\n variant.set(f);\n CHECK(variant.is() == true);\n CHECK(variant.as() == 3.14f);\n }\n\n SECTION(\"volatile double\") {\n volatile double f = 3.14;\n variant.set(f);\n CHECK(variant.is() == true);\n CHECK(variant.as() == 3.14);\n }\n}\n" }, { "path": "extras/tests/JsonVariant/unbound.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"Unbound JsonVariant\") {\n JsonVariant variant;\n\n SECTION(\"as()\") {\n CHECK(variant.as() == false);\n CHECK(variant.as() == 0);\n CHECK(variant.as() == 0.0f);\n CHECK(variant.as() == 0);\n CHECK(variant.as() == \"null\");\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().isNull());\n CHECK(variant.as().data() == nullptr);\n CHECK(variant.as().size() == 0);\n CHECK(variant.as().data() == nullptr);\n CHECK(variant.as().size() == 0);\n }\n\n SECTION(\"is()\") {\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n CHECK_FALSE(variant.is());\n }\n\n SECTION(\"set()\") {\n CHECK_FALSE(variant.set(\"42\"));\n CHECK_FALSE(variant.set(42.0));\n CHECK_FALSE(variant.set(42L));\n CHECK_FALSE(variant.set(42U));\n CHECK_FALSE(variant.set(serialized(\"42\")));\n CHECK_FALSE(variant.set(serialized(\"42\"_s)));\n CHECK_FALSE(variant.set(true));\n CHECK_FALSE(variant.set(MsgPackBinary(\"hello\", 5)));\n CHECK_FALSE(variant.set(MsgPackExtension(1, \"hello\", 5)));\n }\n\n SECTION(\"add()\") {\n CHECK_FALSE(variant.add(\"42\"));\n CHECK_FALSE(variant.add(42.0));\n CHECK_FALSE(variant.add(42L));\n CHECK_FALSE(variant.add(42U));\n CHECK_FALSE(variant.add(serialized(\"42\")));\n CHECK_FALSE(variant.add(true));\n }\n\n SECTION(\"operator[]\") {\n CHECK(variant[0].isNull());\n CHECK(variant[\"key\"].isNull());\n CHECK_FALSE(variant[0].set(1));\n CHECK_FALSE(variant[\"key\"].set(1));\n CHECK_FALSE(variant[\"key\"_s].set(1));\n }\n\n SECTION(\"remove()\") {\n variant.remove(0);\n variant.remove(\"hello\");\n }\n}\n" }, { "path": "extras/tests/JsonVariantConst/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(JsonVariantConstTests\n\tas.cpp\n\tis.cpp\n\tisnull.cpp\n\tnesting.cpp\n\tsize.cpp\n\tsubscript.cpp\n)\n\nadd_test(JsonVariantConst JsonVariantConstTests)\n\nset_tests_properties(JsonVariantConst\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/JsonVariantConst/as.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariantConst::as()\") {\n JsonDocument doc;\n JsonVariantConst var = doc.to();\n\n doc.set(\"hello\");\n\n REQUIRE(var.as() == true);\n REQUIRE(var.as() == 0L);\n REQUIRE(var.as() == \"hello\"_s);\n REQUIRE(var.as() == \"hello\"_s);\n}\n\nTEST_CASE(\"Invalid conversions\") {\n using namespace ArduinoJson::detail;\n\n JsonVariantConst variant;\n\n CHECK(is_same()), int>::value);\n CHECK(is_same()), float>::value);\n CHECK(is_same()),\n JsonVariantConst>::value);\n CHECK(\n is_same()), JsonObjectConst>::value);\n CHECK(is_same()), JsonArrayConst>::value);\n\n CHECK(is_same()),\n InvalidConversion>::value);\n CHECK(is_same()),\n InvalidConversion>::value);\n CHECK(is_same()),\n InvalidConversion>::value);\n}\n" }, { "path": "extras/tests/JsonVariantConst/is.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nenum MYENUM2 { ONE = 1, TWO = 2 };\n\nTEST_CASE(\"JsonVariantConst::is()\") {\n JsonDocument doc;\n JsonVariantConst var = doc.to();\n\n SECTION(\"unbound\") {\n var = JsonVariantConst();\n\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"null\") {\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"true\") {\n doc.set(true);\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"false\") {\n doc.set(false);\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"int\") {\n doc.set(42);\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"double\") {\n doc.set(4.2);\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"const char*\") {\n doc.set(\"4.2\");\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"JsonArray\") {\n doc.to();\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n\n SECTION(\"JsonObject\") {\n doc.to();\n\n CHECK(var.is() == true);\n CHECK(var.is() == true);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n CHECK(var.is() == false);\n }\n}\n" }, { "path": "extras/tests/JsonVariantConst/isnull.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariantConst::isNull()\") {\n JsonDocument doc;\n JsonVariantConst variant = doc.to();\n\n SECTION(\"returns true when undefined\") {\n REQUIRE(variant.isNull() == true);\n }\n\n SECTION(\"returns false if value is integer\") {\n doc.set(42);\n\n REQUIRE(variant.isNull() == false);\n }\n}\n" }, { "path": "extras/tests/JsonVariantConst/nesting.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariantConst::nesting()\") {\n JsonDocument doc;\n JsonVariantConst var = doc.to();\n\n SECTION(\"return 0 if unbound\") {\n JsonVariantConst unbound;\n REQUIRE(unbound.nesting() == 0);\n }\n\n SECTION(\"returns 0 for string\") {\n doc.set(\"hello\");\n REQUIRE(var.nesting() == 0);\n }\n\n SECTION(\"returns 1 for empty object\") {\n doc.to();\n REQUIRE(var.nesting() == 1);\n }\n\n SECTION(\"returns 1 for empty array\") {\n doc.to();\n REQUIRE(var.nesting() == 1);\n }\n}\n" }, { "path": "extras/tests/JsonVariantConst/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"JsonVariantConst::size()\") {\n JsonDocument doc;\n JsonVariantConst variant = doc.to();\n\n SECTION(\"unbound reference\") {\n JsonVariantConst unbound;\n\n CHECK(unbound.size() == 0);\n }\n\n SECTION(\"int\") {\n doc.set(42);\n\n CHECK(variant.size() == 0);\n }\n\n SECTION(\"string\") {\n doc.set(\"hello\");\n\n CHECK(variant.size() == 0);\n }\n\n SECTION(\"object\") {\n doc[\"a\"] = 1;\n doc[\"b\"] = 2;\n\n CHECK(variant.size() == 2);\n }\n}\n" }, { "path": "extras/tests/JsonVariantConst/subscript.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"JsonVariantConst::operator[]\") {\n JsonDocument doc;\n JsonVariantConst var = doc.to();\n\n SECTION(\"null\") {\n REQUIRE(0 == var.size());\n REQUIRE(var[\"0\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"string\") {\n doc.set(\"hello world\");\n REQUIRE(0 == var.size());\n REQUIRE(var[\"0\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"array\") {\n JsonArray array = doc.to();\n array.add(\"A\");\n array.add(\"B\");\n\n SECTION(\"int\") {\n REQUIRE(\"A\"_s == var[0]);\n REQUIRE(\"B\"_s == var[1]);\n REQUIRE(\"A\"_s == var[static_cast(0)]); // issue #381\n REQUIRE(var[666].isNull());\n REQUIRE(var[3].isNull());\n }\n\n SECTION(\"const char*\") {\n REQUIRE(var[\"0\"].isNull());\n }\n\n SECTION(\"JsonVariant\") {\n array.add(1);\n REQUIRE(var[var[2]] == \"B\"_s);\n REQUIRE(var[var[3]].isNull());\n }\n }\n\n SECTION(\"object\") {\n JsonObject object = doc.to();\n object[\"ab\"_s] = \"AB\";\n object[\"abc\"_s] = \"ABC\";\n object[\"abcd\"_s] = \"ABCD\";\n\n SECTION(\"string literal\") {\n REQUIRE(var[\"ab\"] == \"AB\"_s);\n REQUIRE(var[\"abc\"] == \"ABC\"_s);\n REQUIRE(var[\"abcd\"] == \"ABCD\"_s);\n REQUIRE(var[\"def\"].isNull());\n REQUIRE(var[0].isNull());\n }\n\n SECTION(\"const char*\") {\n REQUIRE(var[static_cast(\"ab\")] == \"AB\"_s);\n REQUIRE(var[static_cast(\"abc\")] == \"ABC\"_s);\n REQUIRE(var[static_cast(\"abc\\0d\")] == \"ABC\"_s);\n REQUIRE(var[static_cast(\"def\")].isNull());\n REQUIRE(var[static_cast(0)].isNull());\n }\n\n SECTION(\"supports std::string\") {\n REQUIRE(var[\"ab\"_s] == \"AB\"_s);\n REQUIRE(var[\"abc\"_s] == \"ABC\"_s);\n REQUIRE(var[\"abcd\"_s] == \"ABCD\"_s);\n REQUIRE(var[\"def\"_s].isNull());\n }\n\n#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \\\n !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)\n SECTION(\"supports VLA\") {\n size_t i = 16;\n char vla[i];\n strcpy(vla, \"abc\");\n\n REQUIRE(var[vla] == \"ABC\"_s);\n }\n#endif\n\n SECTION(\"supports JsonVariant\") {\n object[\"key1\"] = \"ab\";\n object[\"key2\"] = \"abc\";\n object[\"key3\"] = \"abcd\"_s;\n object[\"key4\"] = \"foo\";\n\n REQUIRE(var[var[\"key1\"]] == \"AB\"_s);\n REQUIRE(var[var[\"key2\"]] == \"ABC\"_s);\n REQUIRE(var[var[\"key3\"]] == \"ABCD\"_s);\n REQUIRE(var[var[\"key4\"]].isNull());\n REQUIRE(var[var[\"key5\"]].isNull());\n }\n }\n}\n" }, { "path": "extras/tests/Misc/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(MiscTests\n\tarithmeticCompare.cpp\n\tconflicts.cpp\n\tissue1967.cpp\n\tissue2129.cpp\n\tissue2166.cpp\n\tJsonString.cpp\n\tNoArduinoHeader.cpp\n\tprintable.cpp\n\tReaders.cpp\n\tStringAdapters.cpp\n\tStringWriter.cpp\n\tTypeTraits.cpp\n\tunsigned_char.cpp\n\tUtf16.cpp\n\tUtf8.cpp\n\tversion.cpp\n)\n\nset_target_properties(MiscTests PROPERTIES UNITY_BUILD OFF)\n\nadd_test(Misc MiscTests)\n\nset_tests_properties(Misc\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n\nadd_executable(Issue2181\n\tissue2181.cpp # Cannot be linked with other tests\n)\n\nset_target_properties(Issue2181 PROPERTIES UNITY_BUILD OFF)\n\nadd_test(Issue2181 Issue2181)\n\nset_tests_properties(Issue2181\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n\nif(CMAKE_CXX_COMPILER_ID MATCHES \"Clang\")\n\ttarget_compile_options(Issue2181\n\t\tPRIVATE\n\t\t\t-Wno-keyword-macro # keyword is hidden by macro definition\n\t)\nendif()\n" }, { "path": "extras/tests/Misc/JsonString.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nTEST_CASE(\"JsonString\") {\n SECTION(\"Default constructor creates a null JsonString\") {\n JsonString s;\n\n CHECK(s.isNull() == true);\n CHECK(s.c_str() == 0);\n CHECK(s == JsonString());\n CHECK(s != \"\");\n }\n\n SECTION(\"Null converts to false\") {\n JsonString s;\n\n CHECK(bool(s) == false);\n }\n\n SECTION(\"Empty string converts to true\") {\n JsonString s(\"\");\n\n CHECK(bool(s) == true);\n }\n\n SECTION(\"Non-empty string converts to true\") {\n JsonString s(\"\");\n\n CHECK(bool(s) == true);\n }\n\n SECTION(\"Null strings equals each others\") {\n JsonString a, b;\n\n CHECK(a == b);\n CHECK_FALSE(a != b);\n }\n\n SECTION(\"Null and empty strings differ\") {\n JsonString a, b(\"\");\n\n CHECK_FALSE(a == b);\n CHECK(a != b);\n\n CHECK_FALSE(b == a);\n CHECK(b != a);\n }\n\n SECTION(\"Null and non-empty strings differ\") {\n JsonString a, b(\"hello\");\n\n CHECK_FALSE(a == b);\n CHECK(a != b);\n\n CHECK_FALSE(b == a);\n CHECK(b != a);\n }\n\n SECTION(\"Compare different strings\") {\n JsonString a(\"hello\"), b(\"world\");\n\n CHECK_FALSE(a == b);\n CHECK(a != b);\n }\n\n SECTION(\"Compare identical by pointer\") {\n JsonString a(\"hello\"), b(\"hello\");\n\n CHECK(a == b);\n CHECK_FALSE(a != b);\n }\n\n SECTION(\"Compare identical by value\") {\n char s1[] = \"hello\";\n char s2[] = \"hello\";\n JsonString a(s1), b(s2);\n\n CHECK(a == b);\n CHECK_FALSE(a != b);\n }\n\n SECTION(\"std::stream\") {\n std::stringstream ss;\n ss << JsonString(\"hello world!\");\n CHECK(ss.str() == \"hello world!\");\n }\n\n SECTION(\"Construct with a size\") {\n JsonString s(\"hello world\", 5);\n\n CHECK(s.size() == 5);\n CHECK(s == \"hello\");\n CHECK(s != \"hello world\");\n }\n}\n" }, { "path": "extras/tests/Misc/NoArduinoHeader.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINO 1\n#define ARDUINOJSON_ENABLE_PROGMEM 0\n#define ARDUINOJSON_ENABLE_ARDUINO_STRING 0\n#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 0\n#define ARDUINOJSON_ENABLE_ARDUINO_PRINT 0\n#include \n\n#include \n\nTEST_CASE(\"Arduino.h\") {\n#ifdef ARDUINO_H_INCLUDED\n FAIL(\"Arduino.h should not be included\");\n#else\n INFO(\"Arduino.h not included\");\n#endif\n}\n" }, { "path": "extras/tests/Misc/Readers.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"Reader\") {\n SECTION(\"read()\") {\n std::istringstream src(\"\\x01\\xFF\");\n Reader reader(src);\n\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == -1);\n }\n\n SECTION(\"readBytes() all at once\") {\n std::istringstream src(\"ABC\");\n Reader reader(src);\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 4) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n std::istringstream src(\"ABCDEF\");\n Reader reader(src);\n\n char buffer[12] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 4) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nTEST_CASE(\"BoundedReader\") {\n SECTION(\"read\") {\n BoundedReader reader(\"\\x01\\xFF\", 2);\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == -1);\n REQUIRE(reader.read() == -1);\n }\n\n SECTION(\"readBytes() all at once\") {\n BoundedReader reader(\"ABCD\", 3);\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 4) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n BoundedReader reader(\"ABCDEF\", 6);\n\n char buffer[8] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 4) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nTEST_CASE(\"Reader\") {\n SECTION(\"read()\") {\n Reader reader(\"\\x01\\xFF\\x00\\x12\");\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == 0);\n REQUIRE(reader.read() == 0x12);\n }\n\n SECTION(\"readBytes() all at once\") {\n Reader reader(\"ABCD\");\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 3) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n Reader reader(\"ABCDEF\");\n\n char buffer[8] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 2) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nTEST_CASE(\"IteratorReader\") {\n SECTION(\"read()\") {\n std::string src(\"\\x01\\xFF\");\n IteratorReader reader(src.begin(), src.end());\n\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == -1);\n }\n\n SECTION(\"readBytes() all at once\") {\n std::string src(\"ABC\");\n IteratorReader reader(src.begin(), src.end());\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 4) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n std::string src(\"ABCDEF\");\n IteratorReader reader(src.begin(), src.end());\n\n char buffer[12] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 4) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nclass StreamStub : public Stream {\n public:\n StreamStub(const char* s) : stream_(s) {}\n\n int read() {\n return stream_.get();\n }\n\n size_t readBytes(char* buffer, size_t length) {\n stream_.read(buffer, static_cast(length));\n return static_cast(stream_.gcount());\n }\n\n private:\n std::istringstream stream_;\n};\n\nTEST_CASE(\"Reader\") {\n SECTION(\"read()\") {\n StreamStub src(\"\\x01\\xFF\");\n Reader reader(src);\n\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == -1);\n }\n\n SECTION(\"readBytes() all at once\") {\n StreamStub src(\"ABC\");\n Reader reader(src);\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 4) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n StreamStub src(\"ABCDEF\");\n Reader reader(src);\n\n char buffer[12] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 4) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n" }, { "path": "extras/tests/Misc/StringAdapters.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n#include \n#include \n\n#include \n\n#include \"custom_string.hpp\"\n#include \"weird_strcmp.hpp\"\n\nusing ArduinoJson::JsonString;\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"adaptString()\") {\n SECTION(\"string literal\") {\n auto s = adaptString(\"bravo\\0alpha\");\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"null const char*\") {\n auto s = adaptString(static_cast(0));\n\n CHECK(s.isNull() == true);\n CHECK(s.size() == 0);\n }\n\n SECTION(\"non-null const char*\") {\n const char* p = \"bravo\";\n auto s = adaptString(p);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n CHECK(s.data() == p);\n }\n\n SECTION(\"null const char* + size\") {\n auto s = adaptString(static_cast(0), 10);\n\n CHECK(s.isNull() == true);\n }\n\n SECTION(\"non-null const char* + size\") {\n auto s = adaptString(\"bravo\", 5);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"null Flash string\") {\n auto s = adaptString(static_cast(0));\n\n CHECK(s.isNull() == true);\n CHECK(s.size() == 0);\n }\n\n SECTION(\"non-null Flash string\") {\n auto s = adaptString(F(\"bravo\"));\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"std::string\") {\n std::string orig(\"bravo\");\n auto s = adaptString(orig);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"Arduino String\") {\n ::String orig(\"bravo\");\n auto s = adaptString(orig);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"custom_string\") {\n custom_string orig(\"bravo\");\n auto s = adaptString(orig);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n\n SECTION(\"JsonString\") {\n JsonString orig(\"hello\");\n auto s = adaptString(orig);\n\n CHECK(s.isNull() == false);\n CHECK(s.size() == 5);\n }\n}\n\nstruct EmptyStruct {};\n\nTEST_CASE(\"IsString\") {\n CHECK(IsString::value == true);\n CHECK(IsString>::value == false);\n CHECK(IsString::value == true);\n CHECK(IsString::value == true);\n CHECK(IsString::value == true);\n CHECK(IsString::value == true);\n CHECK(IsString::value == true);\n CHECK(IsString<::String>::value == true);\n CHECK(IsString<::StringSumHelper>::value == true);\n CHECK(IsString::value == false);\n CHECK(IsString::value == true);\n}\n\nTEST_CASE(\"stringCompare\") {\n SECTION(\"ZeroTerminatedRamString vs ZeroTerminatedRamString\") {\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"alpha\")) > 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"bravo\")) == 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"charlie\")) < 0);\n }\n\n SECTION(\"ZeroTerminatedRamString vs SizedRamString\") {\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"alpha?\", 5)) > 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"bravo?\", 4)) > 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"bravo?\", 5)) == 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"bravo?\", 6)) < 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(\"charlie?\", 7)) < 0);\n }\n\n SECTION(\"SizedRamString vs SizedRamString\") {\n // clang-format off\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"alpha?\", 5)) > 0);\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"bravo?\", 5)) == 0);\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"charlie?\", 7)) < 0);\n\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"bravo!\", 4)) > 0);\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"bravo!\", 5)) == 0);\n CHECK(stringCompare(adaptString(\"bravo!\", 5), adaptString(\"bravo!\", 6)) < 0);\n // clang-format on\n }\n\n SECTION(\"FlashString vs FlashString\") {\n // clang-format off\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(F(\"alpha\"))) > 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(F(\"bravo\"))) == 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(F(\"charlie\"))) < 0);\n // clang-format on\n }\n\n SECTION(\"FlashString vs SizedRamString\") {\n // clang-format off\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"alpha?\", 5)) > 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"bravo?\", 5)) == 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"charlie?\", 7)) < 0);\n\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 4)) > 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 5)) == 0);\n CHECK(stringCompare(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 6)) < 0);\n // clang-format on\n }\n\n SECTION(\"ZeroTerminatedRamString vs FlashString\") {\n // clang-format off\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(F(\"alpha?\"), 5)) > 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(F(\"bravo?\"), 4)) > 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(F(\"bravo?\"), 5)) == 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(F(\"bravo?\"), 6)) < 0);\n CHECK(stringCompare(adaptString(\"bravo\"), adaptString(F(\"charlie?\"), 7)) < 0);\n // clang-format on\n }\n}\n\nTEST_CASE(\"stringEquals()\") {\n SECTION(\"ZeroTerminatedRamString vs ZeroTerminatedRamString\") {\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"brav\")) == false);\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"bravo\")) == true);\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"bravo!\")) == false);\n }\n\n SECTION(\"ZeroTerminatedRamString vs SizedRamString\") {\n // clang-format off\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"bravo!\", 4)) == false);\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"bravo!\", 5)) == true);\n CHECK(stringEquals(adaptString(\"bravo\"), adaptString(\"bravo!\", 6)) == false);\n // clang-format on\n }\n\n SECTION(\"FlashString vs SizedRamString\") {\n // clang-format off\n CHECK(stringEquals(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 4)) == false);\n CHECK(stringEquals(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 5)) == true);\n CHECK(stringEquals(adaptString(F(\"bravo\")), adaptString(\"bravo!\", 6)) == false);\n // clang-format on\n }\n\n SECTION(\"SizedRamString vs SizedRamString\") {\n // clang-format off\n CHECK(stringEquals(adaptString(\"bravo?\", 5), adaptString(\"bravo!\", 4)) == false);\n CHECK(stringEquals(adaptString(\"bravo?\", 5), adaptString(\"bravo!\", 5)) == true);\n CHECK(stringEquals(adaptString(\"bravo?\", 5), adaptString(\"bravo!\", 6)) == false);\n // clang-format on\n }\n}\n" }, { "path": "extras/tests/Misc/StringWriter.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#define ARDUINOJSON_STRING_BUFFER_SIZE 5\n#include \n\n#include \n\n#include \"Literals.hpp\"\n#include \"custom_string.hpp\"\n\nusing namespace ArduinoJson::detail;\n\ntemplate \nstatic size_t print(StringWriter& writer, const char* s) {\n return writer.write(reinterpret_cast(s), strlen(s));\n}\n\ntemplate \nstatic size_t print(StringWriter& writer, char c) {\n return writer.write(static_cast(c));\n}\n\ntemplate \nvoid common_tests(StringWriter& writer, const String& output) {\n SECTION(\"InitialState\") {\n REQUIRE(std::string(\"\") == output);\n }\n\n SECTION(\"EmptyString\") {\n REQUIRE(0 == print(writer, \"\"));\n REQUIRE(std::string(\"\") == output);\n }\n\n SECTION(\"OneString\") {\n REQUIRE(4 == print(writer, \"ABCD\"));\n REQUIRE(\"ABCD\"_s == output);\n }\n\n SECTION(\"TwoStrings\") {\n REQUIRE(4 == print(writer, \"ABCD\"));\n REQUIRE(4 == print(writer, \"EFGH\"));\n REQUIRE(\"ABCDEFGH\"_s == output);\n }\n}\n\nTEST_CASE(\"StaticStringWriter\") {\n char output[20] = {0};\n StaticStringWriter writer(output, sizeof(output));\n\n common_tests(writer, static_cast(output));\n\n SECTION(\"OverCapacity\") {\n REQUIRE(20 == print(writer, \"ABCDEFGHIJKLMNOPQRSTUVWXYZ\"));\n REQUIRE(0 == print(writer, \"ABC\"));\n REQUIRE(0 == print(writer, 'D'));\n REQUIRE(\"ABCDEFGHIJKLMNOPQRST\" == std::string(output, 20));\n }\n}\n\nTEST_CASE(\"Writer\") {\n std::string output;\n Writer writer(output);\n common_tests(writer, output);\n}\n\nTEST_CASE(\"Writer\") {\n ::String output;\n Writer<::String> writer(output);\n\n SECTION(\"write(char)\") {\n SECTION(\"writes to temporary buffer\") {\n // accumulate in buffer\n writer.write('a');\n writer.write('b');\n writer.write('c');\n writer.write('d');\n REQUIRE(output == \"\");\n\n // flush when full\n writer.write('e');\n REQUIRE(output == \"abcd\");\n\n // flush on destruction\n writer.write('f');\n writer.~Writer();\n REQUIRE(output == \"abcdef\");\n }\n\n SECTION(\"returns 1 on success\") {\n for (int i = 0; i < ARDUINOJSON_STRING_BUFFER_SIZE; i++) {\n REQUIRE(writer.write('x') == 1);\n }\n }\n\n SECTION(\"returns 0 on error\") {\n output.limitCapacityTo(1);\n\n REQUIRE(writer.write('a') == 1);\n REQUIRE(writer.write('b') == 1);\n REQUIRE(writer.write('c') == 1);\n REQUIRE(writer.write('d') == 1);\n REQUIRE(writer.write('e') == 0);\n REQUIRE(writer.write('f') == 0);\n }\n }\n\n SECTION(\"write(char*, size_t)\") {\n SECTION(\"empty string\") {\n REQUIRE(0 == print(writer, \"\"));\n writer.flush();\n REQUIRE(output == \"\");\n }\n\n SECTION(\"writes to temporary buffer\") {\n // accumulate in buffer\n print(writer, \"abc\");\n REQUIRE(output == \"\");\n\n // flush when full, and continue to accumulate\n print(writer, \"de\");\n REQUIRE(output == \"abcd\");\n\n // flush on destruction\n writer.~Writer();\n REQUIRE(output == \"abcde\");\n }\n }\n}\n\nTEST_CASE(\"Writer\") {\n custom_string output;\n Writer writer(output);\n\n REQUIRE(4 == print(writer, \"ABCD\"));\n REQUIRE(\"ABCD\" == output);\n}\n\nTEST_CASE(\"serializeJson(doc, String)\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n ::String output = \"erase me\";\n\n SECTION(\"sufficient capacity\") {\n serializeJson(doc, output);\n REQUIRE(output == \"{\\\"hello\\\":\\\"world\\\"}\");\n }\n\n SECTION(\"unsufficient capacity\") { // issue #1561\n output.limitCapacityTo(10);\n serializeJson(doc, output);\n REQUIRE(output == \"{\\\"hello\\\"\");\n }\n}\n" }, { "path": "extras/tests/Misc/TypeTraits.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nusing namespace ArduinoJson::detail;\n\nclass EmptyClass {};\nenum EmptyEnum {};\n\nTEST_CASE(\"Polyfills/type_traits\") {\n SECTION(\"is_base_of\") {\n REQUIRE_FALSE(\n static_cast(is_base_of::value));\n REQUIRE(\n static_cast(is_base_of::value));\n }\n\n SECTION(\"is_array\") {\n REQUIRE_FALSE(is_array::value);\n REQUIRE(is_array::value);\n REQUIRE(is_array::value);\n }\n\n SECTION(\"is_const\") {\n CHECK(is_const::value == false);\n CHECK(is_const::value == true);\n }\n\n SECTION(\"is_integral\") {\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n CHECK(is_integral::value == false);\n\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n CHECK(is_integral::value == true);\n\n CHECK(is_integral::value == true);\n }\n\n SECTION(\"is_signed\") {\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == false);\n\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == false);\n\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == false);\n\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == true);\n CHECK(is_signed::value == false);\n }\n\n SECTION(\"is_unsigned\") {\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == true);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n CHECK(is_unsigned::value == false);\n }\n\n SECTION(\"is_floating_point\") {\n CHECK(is_floating_point::value == false);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n CHECK(is_floating_point::value == true);\n }\n\n SECTION(\"is_convertible\") {\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == false);\n CHECK(is_convertible::value == false);\n\n CHECK(is_convertible::value ==\n false);\n CHECK(is_convertible::value == false);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible, JsonVariantConst>::value ==\n true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible,\n JsonVariantConst>::value == true);\n CHECK(is_convertible::value == true);\n CHECK(is_convertible::value == true);\n }\n\n SECTION(\"is_class\") {\n CHECK(is_class::value == false);\n CHECK(is_class::value == false);\n CHECK(is_class::value == false);\n CHECK(is_class::value == true);\n }\n\n SECTION(\"is_enum\") {\n CHECK(is_enum::value == false);\n CHECK(is_enum::value == true);\n CHECK(is_enum::value == false);\n CHECK(is_enum::value == false);\n CHECK(is_enum::value == false);\n CHECK(is_enum::value == false);\n }\n\n SECTION(\"remove_cv\") {\n CHECK(is_same, int>::value);\n CHECK(is_same, int>::value);\n CHECK(is_same, int>::value);\n CHECK(is_same, int>::value);\n CHECK(is_same, decltype(\"toto\")>::value);\n }\n\n SECTION(\"decay\") {\n CHECK(is_same, int>::value);\n CHECK(is_same, int>::value);\n CHECK(is_same, int>::value);\n CHECK(is_same, int*>::value);\n CHECK(is_same, int*>::value);\n CHECK(is_same, const char*>::value);\n }\n}\n\nTEST_CASE(\"is_std_string\") {\n REQUIRE(is_std_string::value == true);\n REQUIRE(is_std_string::value == false);\n}\n" }, { "path": "extras/tests/Misc/Utf16.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nstatic void testUtf16Codepoint(uint16_t codeunit, uint32_t expectedCodepoint) {\n Utf16::Codepoint cp;\n REQUIRE(cp.append(codeunit) == true);\n REQUIRE(cp.value() == expectedCodepoint);\n}\n\nstatic void testUtf16Codepoint(uint16_t codeunit1, uint16_t codeunit2,\n uint32_t expectedCodepoint) {\n Utf16::Codepoint cp;\n REQUIRE(cp.append(codeunit1) == false);\n REQUIRE(cp.append(codeunit2) == true);\n REQUIRE(cp.value() == expectedCodepoint);\n}\n\nTEST_CASE(\"Utf16::Codepoint()\") {\n SECTION(\"U+0000\") {\n testUtf16Codepoint(0x0000, 0x000000);\n }\n\n SECTION(\"U+0001\") {\n testUtf16Codepoint(0x0001, 0x000001);\n }\n\n SECTION(\"U+D7FF\") {\n testUtf16Codepoint(0xD7FF, 0x00D7FF);\n }\n\n SECTION(\"U+E000\") {\n testUtf16Codepoint(0xE000, 0x00E000);\n }\n\n SECTION(\"U+FFFF\") {\n testUtf16Codepoint(0xFFFF, 0x00FFFF);\n }\n\n SECTION(\"U+010000\") {\n testUtf16Codepoint(0xD800, 0xDC00, 0x010000);\n }\n\n SECTION(\"U+010001\") {\n testUtf16Codepoint(0xD800, 0xDC01, 0x010001);\n }\n\n SECTION(\"U+0103FF\") {\n testUtf16Codepoint(0xD800, 0xDFFF, 0x0103FF);\n }\n\n SECTION(\"U+010400\") {\n testUtf16Codepoint(0xD801, 0xDC00, 0x010400);\n }\n\n SECTION(\"U+010400\") {\n testUtf16Codepoint(0xDBFF, 0xDC00, 0x10FC00);\n }\n\n SECTION(\"U+10FFFF\") {\n testUtf16Codepoint(0xDBFF, 0xDFFF, 0x10FFFF);\n }\n}\n" }, { "path": "extras/tests/Misc/Utf8.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nusing namespace ArduinoJson::detail;\n\nstatic void testCodepoint(uint32_t codepoint, std::string expected) {\n ResourceManager resources;\n StringBuilder str(&resources);\n str.startString();\n\n CAPTURE(codepoint);\n Utf8::encodeCodepoint(codepoint, str);\n\n REQUIRE(str.str().c_str() == expected);\n}\n\nTEST_CASE(\"Utf8::encodeCodepoint()\") {\n SECTION(\"U+0000\") {\n testCodepoint(0x0000, \"\");\n }\n\n SECTION(\"U+0001\") {\n testCodepoint(0x0001, \"\\x01\");\n }\n\n SECTION(\"U+007F\") {\n testCodepoint(0x007F, \"\\x7f\");\n }\n\n SECTION(\"U+0080\") {\n testCodepoint(0x0080, \"\\xc2\\x80\");\n }\n\n SECTION(\"U+07FF\") {\n testCodepoint(0x07FF, \"\\xdf\\xbf\");\n }\n\n SECTION(\"U+0800\") {\n testCodepoint(0x0800, \"\\xe0\\xa0\\x80\");\n }\n\n SECTION(\"U+FFFF\") {\n testCodepoint(0xFFFF, \"\\xef\\xbf\\xbf\");\n }\n\n SECTION(\"U+10000\") {\n testCodepoint(0x10000, \"\\xf0\\x90\\x80\\x80\");\n }\n\n SECTION(\"U+10FFFF\") {\n testCodepoint(0x10FFFF, \"\\xf4\\x8f\\xbf\\xbf\");\n }\n}\n" }, { "path": "extras/tests/Misc/arithmeticCompare.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"arithmeticCompare()\") {\n SECTION(\"int vs uint8_t\") {\n CHECK(arithmeticCompare(256, 1) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(41, 42) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompare(42, 42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(43, 42) == COMPARE_RESULT_GREATER);\n }\n\n SECTION(\"unsigned vs int\") {\n CHECK(arithmeticCompare(0, -1) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 41) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(42, 43) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"float vs int\") {\n CHECK(arithmeticCompare(42, 41) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(42, 43) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"int vs unsigned\") {\n CHECK(arithmeticCompare(-1, 0) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompare(0, 0) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(1, 0) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 41) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(42, 43) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"unsigned vs unsigned\") {\n CHECK(arithmeticCompare(42, 41) ==\n COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(42, 42) ==\n COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(42, 43) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"bool vs bool\") {\n CHECK(arithmeticCompare(false, false) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(true, true) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(false, true) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompare(true, false) == COMPARE_RESULT_GREATER);\n }\n\n SECTION(\"bool vs int\") {\n CHECK(arithmeticCompare(false, -1) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(false, 0) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(false, 1) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompare(true, 0) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(true, 1) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(true, 2) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"bool vs int\") {\n CHECK(arithmeticCompare(0, false) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(1, true) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompare(1, false) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompare(0, true) == COMPARE_RESULT_LESS);\n }\n}\n\nTEST_CASE(\"arithmeticCompareNegateLeft()\") {\n SECTION(\"unsigned vs int\") {\n CHECK(arithmeticCompareNegateLeft(0, 1) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompareNegateLeft(42, -41) == COMPARE_RESULT_LESS);\n CHECK(arithmeticCompareNegateLeft(42, -42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompareNegateLeft(42, -43) == COMPARE_RESULT_GREATER);\n }\n\n SECTION(\"unsigned vs unsigned\") {\n CHECK(arithmeticCompareNegateLeft(42, 42) == COMPARE_RESULT_LESS);\n }\n}\n\nTEST_CASE(\"arithmeticCompareNegateRight()\") {\n SECTION(\"int vs unsigned\") {\n CHECK(arithmeticCompareNegateRight(1, 0) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompareNegateRight(-41, 42) == COMPARE_RESULT_GREATER);\n CHECK(arithmeticCompareNegateRight(-42, 42) == COMPARE_RESULT_EQUAL);\n CHECK(arithmeticCompareNegateRight(-43, 42) == COMPARE_RESULT_LESS);\n }\n\n SECTION(\"unsigned vs unsigned\") {\n CHECK(arithmeticCompareNegateRight(42, 42) ==\n COMPARE_RESULT_GREATER);\n }\n}\n" }, { "path": "extras/tests/Misc/conflicts.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n// Include any header that might use the conflicting macros\n#include \n#include \n#include \n\n// All cores\n#define bit()\n#define constrain()\n#define DEFAULT\n#define DISABLED\n#define HIGH\n#define INPUT\n#define LOW\n#define max()\n#define min()\n#define OUTPUT\n#define round()\n#define sq()\n#define word()\n#define bitRead()\n#define bitSet()\n#define bitClear()\n#define bitWrite()\n#define interrupts()\n#define lowByte()\n#define highByte()\n#define DEC\n#define HEX\n#define OCT\n#define BIN\n#define cbi()\n#define sbi()\n\n// ESP8266\n#define _max()\n#define _min()\n\n// Realtek Ameba\n#define isdigit(c) (((c) >= '0') && ((c) <= '9'))\n#define isprint(c)\n#define isxdigit(c)\n#define isspace(c)\n#define isupper(c)\n#define islower(c)\n#define isalpha(c)\n\n// issue #839\n#define BLOCKSIZE\n#define CAPACITY\n\n// issue #1905\n#define _current\n\n// issue #1914\n#define V7 7\n\n// STM32, Mbed, Particle\n#define A0 16\n#define A1 17\n#define A2 18\n\n// catch.hpp mutes several warnings, this file also allows to detect them\n#include \"ArduinoJson.h\"\n" }, { "path": "extras/tests/Misc/custom_string.hpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#pragma once\n\n#include \n\nstruct custom_char_traits : std::char_traits {};\n\nusing custom_string = std::basic_string;\n" }, { "path": "extras/tests/Misc/issue1967.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n// we expect ArduinoJson.h to include \n#define ARDUINOJSON_ENABLE_STD_STRING 1\n\n// but we don't want it to included accidentally\n#undef ARDUINO\n#define ARDUINOJSON_ENABLE_STD_STREAM 0\n#define ARDUINOJSON_ENABLE_STRING_VIEW 0\n\n#include \n" }, { "path": "extras/tests/Misc/issue2129.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\ntemplate \nclass Nullable {\n public:\n Nullable() : value_{} {}\n Nullable(T value) : value_{value} {}\n\n operator T() const {\n return value_;\n }\n\n operator T&() {\n return value_;\n }\n\n bool is_valid() const {\n return value_ != invalid_value_;\n }\n\n T value() const {\n return value_;\n }\n\n private:\n T value_;\n static T invalid_value_;\n};\n\ntemplate <>\nfloat Nullable::invalid_value_ = std::numeric_limits::lowest();\n\ntemplate \nvoid convertToJson(const Nullable& src, JsonVariant dst) {\n if (src.is_valid()) {\n dst.set(src.value());\n } else {\n dst.clear();\n }\n}\n\nTEST_CASE(\"Issue #2129\") {\n Nullable nullable_value = Nullable{123.4f};\n\n JsonDocument doc;\n\n doc[\"value\"] = nullable_value;\n\n REQUIRE(doc[\"value\"].as() == Approx(123.4f));\n}\n" }, { "path": "extras/tests/Misc/issue2166.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nstruct CCLASS {\n static const char mszKey[];\n};\n\nTEST_CASE(\"Issue #2166\") {\n JsonDocument doc;\n doc[CCLASS::mszKey] = 12;\n REQUIRE(doc.as() == \"{\\\"test3\\\":12}\");\n\n JsonObject obj = doc.to();\n obj[CCLASS::mszKey] = 12;\n REQUIRE(doc.as() == \"{\\\"test3\\\":12}\");\n}\n\nconst char CCLASS::mszKey[] = \"test3\";\n" }, { "path": "extras/tests/Misc/issue2181.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define true 0x1\n#define false 0x0\n\n#include \n#include \n\nTEST_CASE(\"Issue #2181\") {\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\"}\");\n}\n" }, { "path": "extras/tests/Misc/printable.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1\n#include \n\n#include \"Allocators.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\n\nstruct PrintOneCharacterAtATime {\n static size_t printStringTo(const std::string& s, Print& p) {\n size_t result = 0;\n for (std::string::const_iterator it = s.begin(); it != s.end(); ++it) {\n size_t n = p.write(uint8_t(*it));\n if (n == 0)\n break;\n result += n;\n }\n return result;\n }\n};\n\nstruct PrintAllAtOnce {\n static size_t printStringTo(const std::string& s, Print& p) {\n return p.write(s.data(), s.size());\n }\n};\n\ntemplate \nstruct PrintableString : public Printable {\n PrintableString(const char* s) : str_(s), total_(0) {}\n\n virtual size_t printTo(Print& p) const {\n size_t result = PrintPolicy::printStringTo(str_, p);\n total_ += result;\n return result;\n }\n\n size_t totalBytesWritten() const {\n return total_;\n }\n\n private:\n std::string str_;\n mutable size_t total_;\n};\n\nTEST_CASE(\"Printable\") {\n SECTION(\"Doesn't overflow\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n const char* value = \"example\";\n\n doc.set(666); // to make sure we override the value\n\n SECTION(\"Via Print::write(char)\") {\n PrintableString printable(value);\n CHECK(doc.set(printable) == true);\n CHECK(doc.as() == value);\n CHECK(printable.totalBytesWritten() == 7);\n CHECK(doc.overflowed() == false);\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"example\")),\n });\n }\n\n SECTION(\"Via Print::write(const char* size_t)\") {\n PrintableString printable(value);\n CHECK(doc.set(printable) == true);\n CHECK(doc.as() == value);\n CHECK(printable.totalBytesWritten() == 7);\n CHECK(doc.overflowed() == false);\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"example\")),\n });\n }\n }\n\n SECTION(\"First allocation fails\") {\n SpyingAllocator spy(FailingAllocator::instance());\n JsonDocument doc(&spy);\n const char* value = \"hello world\";\n\n doc.set(666); // to make sure we override the value\n\n SECTION(\"Via Print::write(char)\") {\n PrintableString printable(value);\n\n bool success = doc.set(printable);\n\n CHECK(success == false);\n CHECK(doc.isNull());\n CHECK(printable.totalBytesWritten() == 0);\n CHECK(doc.overflowed() == true);\n CHECK(spy.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Via Print::write(const char*, size_t)\") {\n PrintableString printable(value);\n\n bool success = doc.set(printable);\n\n CHECK(success == false);\n CHECK(doc.isNull());\n CHECK(printable.totalBytesWritten() == 0);\n CHECK(doc.overflowed() == true);\n CHECK(spy.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n }\n\n SECTION(\"Reallocation fails\") {\n TimebombAllocator timebomb(1);\n SpyingAllocator spy(&timebomb);\n JsonDocument doc(&spy);\n const char* value = \"Lorem ipsum dolor sit amet, cons\"; // > 31 chars\n\n doc.set(666); // to make sure we override the value\n\n SECTION(\"Via Print::write(char)\") {\n PrintableString printable(value);\n\n bool success = doc.set(printable);\n\n CHECK(success == false);\n CHECK(doc.isNull());\n CHECK(printable.totalBytesWritten() == 31);\n CHECK(doc.overflowed() == true);\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n ReallocateFail(sizeofStringBuffer(), sizeofStringBuffer(2)),\n Deallocate(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Via Print::write(const char*, size_t)\") {\n PrintableString printable(value);\n\n bool success = doc.set(printable);\n\n CHECK(success == false);\n CHECK(doc.isNull());\n CHECK(printable.totalBytesWritten() == 31);\n CHECK(doc.overflowed() == true);\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n ReallocateFail(sizeofStringBuffer(), sizeofStringBuffer(2)),\n Deallocate(sizeofStringBuffer()),\n });\n }\n }\n\n SECTION(\"Null variant\") {\n JsonVariant var;\n PrintableString printable = \"Hello World!\";\n CHECK(var.set(printable) == false);\n CHECK(var.isNull());\n CHECK(printable.totalBytesWritten() == 0);\n }\n\n SECTION(\"String deduplication\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(PrintableString(\"Hello World!\"));\n doc.add(PrintableString(\"Hello World!\"));\n REQUIRE(doc.size() == 2);\n CHECK(doc[0] == \"Hello World!\");\n CHECK(doc[1] == \"Hello World!\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"Hello World!\")),\n Allocate(sizeofStringBuffer()),\n Deallocate(sizeofStringBuffer()),\n });\n }\n}\n" }, { "path": "extras/tests/Misc/unsigned_char.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\n#if defined(__clang__)\n# define CONFLICTS_WITH_BUILTIN_OPERATOR\n#endif\n\nTEST_CASE(\"unsigned char[]\") {\n SECTION(\"deserializeJson()\") {\n unsigned char input[] = \"{\\\"a\\\":42}\";\n\n JsonDocument doc;\n DeserializationError err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"deserializeMsgPack()\") {\n unsigned char input[] = \"\\xDE\\x00\\x01\\xA5Hello\\xA5world\";\n\n JsonDocument doc;\n DeserializationError err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"serializeMsgPack(unsigned char[])\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeMsgPack(doc, buffer);\n\n REQUIRE(n == 13);\n REQUIRE(memcmp(buffer, \"\\x81\\xA5hello\\xA5world\", 13) == 0);\n }\n\n SECTION(\"serializeMsgPack(unsigned char*)\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeMsgPack(doc, buffer, sizeof(buffer));\n\n REQUIRE(n == 13);\n REQUIRE(memcmp(buffer, \"\\x81\\xA5hello\\xA5world\", 13) == 0);\n }\n\n SECTION(\"serializeJson(unsigned char[])\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeJson(doc, buffer);\n\n REQUIRE(n == 17);\n REQUIRE(memcmp(buffer, \"{\\\"hello\\\":\\\"world\\\"}\", n) == 0);\n }\n\n SECTION(\"serializeJson(unsigned char*)\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeJson(doc, buffer, sizeof(buffer));\n\n REQUIRE(n == 17);\n REQUIRE(memcmp(buffer, \"{\\\"hello\\\":\\\"world\\\"}\", n) == 0);\n }\n\n SECTION(\"serializeJsonPretty(unsigned char[])\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeJsonPretty(doc, buffer);\n\n REQUIRE(n == 24);\n }\n\n SECTION(\"serializeJsonPretty(unsigned char*)\") {\n unsigned char buffer[32];\n JsonDocument doc;\n doc[\"hello\"] = \"world\";\n\n size_t n = serializeJsonPretty(doc, buffer, sizeof(buffer));\n\n REQUIRE(n == 24);\n }\n\n SECTION(\"JsonVariant\") {\n JsonDocument doc;\n\n SECTION(\"set\") {\n unsigned char value[] = \"42\";\n\n JsonVariant variant = doc.to();\n variant.set(value);\n\n REQUIRE(42 == variant.as());\n }\n\n#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR\n SECTION(\"operator[]\") {\n unsigned char key[] = \"hello\";\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n JsonVariant variant = doc.as();\n\n REQUIRE(\"world\"_s == variant[key]);\n }\n#endif\n\n#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR\n SECTION(\"operator[] const\") {\n unsigned char key[] = \"hello\";\n\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n const JsonVariant variant = doc.as();\n\n REQUIRE(\"world\"_s == variant[key]);\n }\n#endif\n\n SECTION(\"operator==\") {\n unsigned char comparand[] = \"hello\";\n\n JsonVariant variant = doc.to();\n variant.set(\"hello\");\n\n REQUIRE(comparand == variant);\n REQUIRE(variant == comparand);\n REQUIRE_FALSE(comparand != variant);\n REQUIRE_FALSE(variant != comparand);\n }\n\n SECTION(\"operator!=\") {\n unsigned char comparand[] = \"hello\";\n\n JsonVariant variant = doc.to();\n variant.set(\"world\");\n\n REQUIRE(comparand != variant);\n REQUIRE(variant != comparand);\n REQUIRE_FALSE(comparand == variant);\n REQUIRE_FALSE(variant == comparand);\n }\n }\n\n SECTION(\"JsonObject\") {\n#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR\n SECTION(\"operator[]\") {\n unsigned char key[] = \"hello\";\n\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[key] = \"world\";\n\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"JsonObject::operator[] const\") {\n unsigned char key[] = \"hello\";\n\n JsonDocument doc;\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n\n JsonObject obj = doc.as();\n REQUIRE(\"world\"_s == obj[key]);\n }\n#endif\n\n SECTION(\"remove()\") {\n unsigned char key[] = \"hello\";\n\n JsonDocument doc;\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}\");\n JsonObject obj = doc.as();\n obj.remove(key);\n\n REQUIRE(0 == obj.size());\n }\n }\n\n SECTION(\"MemberProxy\") {\n SECTION(\"operator=\") { // issue #416\n unsigned char value[] = \"world\";\n\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"hello\"] = value;\n\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n\n SECTION(\"set()\") {\n unsigned char value[] = \"world\";\n\n JsonDocument doc;\n JsonObject obj = doc.to();\n obj[\"hello\"].set(value);\n\n REQUIRE(\"world\"_s == obj[\"hello\"]);\n }\n }\n\n SECTION(\"JsonArray\") {\n SECTION(\"add()\") {\n unsigned char value[] = \"world\";\n\n JsonDocument doc;\n JsonArray arr = doc.to();\n arr.add(value);\n\n REQUIRE(\"world\"_s == arr[0]);\n }\n }\n\n SECTION(\"ElementProxy\") {\n SECTION(\"set()\") {\n unsigned char value[] = \"world\";\n\n JsonDocument doc;\n JsonArray arr = doc.to();\n arr.add(\"hello\");\n arr[0].set(value);\n\n REQUIRE(\"world\"_s == arr[0]);\n }\n\n SECTION(\"operator=\") {\n unsigned char value[] = \"world\";\n\n JsonDocument doc;\n JsonArray arr = doc.to();\n arr.add(\"hello\");\n arr[0] = value;\n\n REQUIRE(\"world\"_s == arr[0]);\n }\n }\n}\n" }, { "path": "extras/tests/Misc/version.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nusing Catch::Matchers::StartsWith;\n\nTEST_CASE(\"ARDUINOJSON_VERSION\") {\n std::stringstream version;\n\n version << ARDUINOJSON_VERSION_MAJOR << \".\" << ARDUINOJSON_VERSION_MINOR\n << \".\" << ARDUINOJSON_VERSION_REVISION;\n\n REQUIRE_THAT(ARDUINOJSON_VERSION, StartsWith(version.str()));\n}\n" }, { "path": "extras/tests/Misc/weird_strcmp.hpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include // strcmp, strncmp\n\n// Issue #1198: strcmp() implementation that returns a value larger than 8-bit\n\nARDUINOJSON_BEGIN_PRIVATE_NAMESPACE\n\nint strcmp(const char* a, const char* b) {\n int result = ::strcmp(a, b);\n if (result > 0)\n return 2147483647;\n if (result < 0)\n return -214748364;\n return 0;\n}\n\nint strncmp(const char* a, const char* b, size_t n) {\n int result = ::strncmp(a, b, n);\n if (result > 0)\n return 2147483647;\n if (result < 0)\n return -214748364;\n return 0;\n}\n\nARDUINOJSON_END_PRIVATE_NAMESPACE\n" }, { "path": "extras/tests/MixedConfiguration/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(MixedConfigurationTests\n\tdecode_unicode_0.cpp\n\tdecode_unicode_1.cpp\n\tenable_alignment_0.cpp\n\tenable_alignment_1.cpp\n\tenable_comments_0.cpp\n\tenable_comments_1.cpp\n\tenable_infinity_0.cpp\n\tenable_infinity_1.cpp\n\tenable_nan_0.cpp\n\tenable_nan_1.cpp\n\tenable_progmem_1.cpp\n\tissue1707.cpp\n\tstring_length_size_1.cpp\n\tstring_length_size_2.cpp\n\tstring_length_size_4.cpp\n\tuse_double_0.cpp\n\tuse_double_1.cpp\n\tuse_long_long_0.cpp\n\tuse_long_long_1.cpp\n)\n\nset_target_properties(MixedConfigurationTests PROPERTIES UNITY_BUILD OFF)\n\nadd_test(MixedConfiguration MixedConfigurationTests)\n\nset_tests_properties(MixedConfiguration\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/MixedConfiguration/decode_unicode_0.cpp", "content": "#define ARDUINOJSON_DECODE_UNICODE 0\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_DECODE_UNICODE == 0\") {\n JsonDocument doc;\n DeserializationError err = deserializeJson(doc, \"\\\"\\\\uD834\\\\uDD1E\\\"\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"\\\\uD834\\\\uDD1E\");\n}\n" }, { "path": "extras/tests/MixedConfiguration/decode_unicode_1.cpp", "content": "#define ARDUINOJSON_DECODE_UNICODE 1\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_DECODE_UNICODE == 1\") {\n JsonDocument doc;\n DeserializationError err = deserializeJson(doc, \"\\\"\\\\uD834\\\\uDD1E\\\"\");\n\n REQUIRE(err == DeserializationError::Ok);\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_alignment_0.cpp", "content": "#define ARDUINOJSON_VERSION_NAMESPACE NoAlignment\n#define ARDUINOJSON_ENABLE_ALIGNMENT 0\n#include \n\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_ENABLE_ALIGNMENT == 0\") {\n using namespace ArduinoJson::detail;\n\n const size_t N = sizeof(void*);\n\n SECTION(\"isAligned()\") {\n CHECK(isAligned(0) == true);\n CHECK(isAligned(1) == true);\n CHECK(isAligned(N) == true);\n CHECK(isAligned(N + 1) == true);\n CHECK(isAligned(2 * N) == true);\n CHECK(isAligned(2 * N + 1) == true);\n }\n\n SECTION(\"addPadding()\") {\n CHECK(addPadding(0) == 0);\n CHECK(addPadding(1) == 1);\n CHECK(addPadding(N) == N);\n CHECK(addPadding(N + 1) == N + 1);\n }\n\n SECTION(\"AddPadding<>\") {\n const size_t a = AddPadding<0>::value;\n CHECK(a == 0);\n\n const size_t b = AddPadding<1>::value;\n CHECK(b == 1);\n\n const size_t c = AddPadding::value;\n CHECK(c == N);\n\n const size_t d = AddPadding::value;\n CHECK(d == N + 1);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_alignment_1.cpp", "content": "#define ARDUINOJSON_ENABLE_ALIGNMENT 1\n#include \n\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_ENABLE_ALIGNMENT == 1\") {\n using namespace ArduinoJson::detail;\n\n const size_t N = sizeof(void*);\n\n SECTION(\"isAligned()\") {\n CHECK(isAligned(0) == true);\n CHECK(isAligned(1) == false);\n CHECK(isAligned(N) == true);\n CHECK(isAligned(N + 1) == false);\n CHECK(isAligned(2 * N) == true);\n CHECK(isAligned(2 * N + 1) == false);\n }\n\n SECTION(\"addPadding()\") {\n CHECK(addPadding(0) == 0);\n CHECK(addPadding(1) == N);\n CHECK(addPadding(N) == N);\n CHECK(addPadding(N + 1) == 2 * N);\n }\n\n SECTION(\"AddPadding<>\") {\n const size_t a = AddPadding<0>::value;\n CHECK(a == 0);\n\n const size_t b = AddPadding<1>::value;\n CHECK(b == N);\n\n const size_t c = AddPadding::value;\n CHECK(c == N);\n\n const size_t d = AddPadding::value;\n CHECK(d == 2 * N);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_comments_0.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_COMMENTS 0\n#include \n\n#include \n\nTEST_CASE(\"Comments should produce InvalidInput\") {\n JsonDocument doc;\n\n const char* testCases[] = {\n \"/*COMMENT*/ [\\\"hello\\\"]\",\n \"[/*COMMENT*/ \\\"hello\\\"]\",\n \"[\\\"hello\\\"/*COMMENT*/]\",\n \"[\\\"hello\\\"/*COMMENT*/,\\\"world\\\"]\",\n \"[\\\"hello\\\",/*COMMENT*/ \\\"world\\\"]\",\n \"[/*/\\n]\",\n \"[/*COMMENT]\",\n \"[/*COMMENT*]\",\n \"//COMMENT\\n\\t[\\\"hello\\\"]\",\n \"[//COMMENT\\n\\\"hello\\\"]\",\n \"[\\\"hello\\\"//COMMENT\\r\\n]\",\n \"[\\\"hello\\\"//COMMENT\\n,\\\"world\\\"]\",\n \"[\\\"hello\\\",//COMMENT\\n\\\"world\\\"]\",\n \"[/COMMENT\\n]\",\n \"[//COMMENT\",\n \"/*COMMENT*/ {\\\"hello\\\":\\\"world\\\"}\",\n \"{/*COMMENT*/\\\"hello\\\":\\\"world\\\"}\",\n \"{\\\"hello\\\"/*COMMENT*/:\\\"world\\\"}\",\n \"{\\\"hello\\\":/*COMMENT*/\\\"world\\\"}\",\n \"{\\\"hello\\\":\\\"world\\\"/*COMMENT*/}\",\n \"//COMMENT\\n {\\\"hello\\\":\\\"world\\\"}\",\n \"{//COMMENT\\n\\\"hello\\\":\\\"world\\\"}\",\n \"{\\\"hello\\\"//COMMENT\\n:\\\"world\\\"}\",\n \"{\\\"hello\\\"://COMMENT\\n\\\"world\\\"}\",\n \"{\\\"hello\\\":\\\"world\\\"//COMMENT\\n}\",\n \"/{\\\"hello\\\":\\\"world\\\"}\",\n \"{/\\\"hello\\\":\\\"world\\\"}\",\n \"{\\\"hello\\\"/:\\\"world\\\"}\",\n \"{\\\"hello\\\":/\\\"world\\\"}\",\n \"{\\\"hello\\\":\\\"world\\\"/}\",\n \"{\\\"hello\\\":\\\"world\\\"/,\\\"answer\\\":42}\",\n \"{\\\"hello\\\":\\\"world\\\",/\\\"answer\\\":42}\",\n };\n const size_t testCount = sizeof(testCases) / sizeof(testCases[0]);\n\n for (size_t i = 0; i < testCount; i++) {\n const char* input = testCases[i];\n CAPTURE(input);\n REQUIRE(deserializeJson(doc, input) == DeserializationError::InvalidInput);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_comments_1.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_COMMENTS 1\n#include \n\n#include \n\nTEST_CASE(\"Comments in arrays\") {\n JsonDocument doc;\n\n SECTION(\"Block comments\") {\n SECTION(\"Before opening bracket\") {\n DeserializationError err =\n deserializeJson(doc, \"/*COMMENT*/ [\\\"hello\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"After opening bracket\") {\n DeserializationError err =\n deserializeJson(doc, \"[/*COMMENT*/ \\\"hello\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"Before closing bracket\") {\n DeserializationError err = deserializeJson(doc, \"[\\\"hello\\\"/*COMMENT*/]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"After closing bracket\") {\n DeserializationError err = deserializeJson(doc, \"[\\\"hello\\\"]/*COMMENT*/\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"Before comma\") {\n DeserializationError err =\n deserializeJson(doc, \"[\\\"hello\\\"/*COMMENT*/,\\\"world\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"After comma\") {\n DeserializationError err =\n deserializeJson(doc, \"[\\\"hello\\\",/*COMMENT*/ \\\"world\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"/*/\") {\n DeserializationError err = deserializeJson(doc, \"[/*/\\n]\");\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"Unfinished comment\") {\n DeserializationError err = deserializeJson(doc, \"[/*COMMENT]\");\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"Final slash missing\") {\n DeserializationError err = deserializeJson(doc, \"[/*COMMENT*]\");\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n\n SECTION(\"Trailing comments\") {\n SECTION(\"Before opening bracket\") {\n DeserializationError err =\n deserializeJson(doc, \"//COMMENT\\n\\t[\\\"hello\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"After opening bracket\") {\n DeserializationError err = deserializeJson(doc, \"[//COMMENT\\n\\\"hello\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"Before closing bracket\") {\n DeserializationError err =\n deserializeJson(doc, \"[\\\"hello\\\"//COMMENT\\r\\n]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"After closing bracket\") {\n DeserializationError err = deserializeJson(doc, \"[\\\"hello\\\"]//COMMENT\\n\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(1 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n }\n\n SECTION(\"Before comma\") {\n DeserializationError err =\n deserializeJson(doc, \"[\\\"hello\\\"//COMMENT\\n,\\\"world\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"After comma\") {\n DeserializationError err =\n deserializeJson(doc, \"[\\\"hello\\\",//COMMENT\\n\\\"world\\\"]\");\n JsonArray arr = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(2 == arr.size());\n REQUIRE(arr[0] == \"hello\");\n REQUIRE(arr[1] == \"world\");\n }\n\n SECTION(\"Invalid comment\") {\n DeserializationError err = deserializeJson(doc, \"[/COMMENT\\n]\");\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"End document with comment\") {\n DeserializationError err = deserializeJson(doc, \"[//COMMENT\");\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n }\n}\n\nTEST_CASE(\"Comments in objects\") {\n JsonDocument doc;\n\n SECTION(\"Block comments\") {\n SECTION(\"Before opening brace\") {\n DeserializationError err =\n deserializeJson(doc, \"/*COMMENT*/ {\\\"hello\\\":\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After opening brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{/*COMMENT*/\\\"hello\\\":\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before colon\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\"/*COMMENT*/:\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After colon\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":/*COMMENT*/\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before closing brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"/*COMMENT*/}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After closing brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}/*COMMENT*/\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before comma\") {\n DeserializationError err = deserializeJson(\n doc, \"{\\\"hello\\\":\\\"world\\\"/*COMMENT*/,\\\"answer\\\":42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n REQUIRE(obj[\"answer\"] == 42);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err = deserializeJson(\n doc, \"{\\\"hello\\\":\\\"world\\\",/*COMMENT*/\\\"answer\\\":42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n REQUIRE(obj[\"answer\"] == 42);\n }\n }\n\n SECTION(\"Trailing comments\") {\n SECTION(\"Before opening brace\") {\n DeserializationError err =\n deserializeJson(doc, \"//COMMENT\\n {\\\"hello\\\":\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After opening brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{//COMMENT\\n\\\"hello\\\":\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before colon\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\"//COMMENT\\n:\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After colon\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\"://COMMENT\\n\\\"world\\\"}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before closing brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"//COMMENT\\n}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"After closing brace\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}//COMMENT\\n\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before comma\") {\n DeserializationError err = deserializeJson(\n doc, \"{\\\"hello\\\":\\\"world\\\"//COMMENT\\n,\\\"answer\\\":42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n REQUIRE(obj[\"answer\"] == 42);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err = deserializeJson(\n doc, \"{\\\"hello\\\":\\\"world\\\",//COMMENT\\n\\\"answer\\\":42}\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n REQUIRE(obj[\"answer\"] == 42);\n }\n }\n\n SECTION(\"Dangling slash\") {\n SECTION(\"Before opening brace\") {\n DeserializationError err = deserializeJson(doc, \"/{\\\"hello\\\":\\\"world\\\"}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"After opening brace\") {\n DeserializationError err = deserializeJson(doc, \"{/\\\"hello\\\":\\\"world\\\"}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"Before colon\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\"/:\\\"world\\\"}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"After colon\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":/\\\"world\\\"}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"Before closing brace\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"/}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"After closing brace\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"}/\");\n JsonObject obj = doc.as();\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(obj[\"hello\"] == \"world\");\n }\n\n SECTION(\"Before comma\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\"/,\\\"answer\\\":42}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"After comma\") {\n DeserializationError err =\n deserializeJson(doc, \"{\\\"hello\\\":\\\"world\\\",/\\\"answer\\\":42}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n }\n}\n\nTEST_CASE(\"Comments alone\") {\n JsonDocument doc;\n\n SECTION(\"Just a trailing comment with no line break\") {\n DeserializationError err = deserializeJson(doc, \"// comment\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"Just a trailing comment with no a break\") {\n DeserializationError err = deserializeJson(doc, \"// comment\\n\");\n\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n\n SECTION(\"Just a block comment\") {\n DeserializationError err = deserializeJson(doc, \"/*comment*/\");\n\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n\n SECTION(\"Just a slash\") {\n DeserializationError err = deserializeJson(doc, \"/\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n\n SECTION(\"Premature terminator\") {\n DeserializationError err = deserializeJson(doc, \"/* comment\");\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n\n SECTION(\"Premature end on sized input\") {\n DeserializationError err = deserializeJson(doc, \"/* comment */\", 10);\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_infinity_0.cpp", "content": "#define ARDUINOJSON_ENABLE_INFINITY 0\n#include \n\n#include \n#include \n\nstatic void assertParseFails(const char* json) {\n JsonDocument doc;\n DeserializationError err = deserializeJson(doc, json);\n\n REQUIRE(err == DeserializationError::InvalidInput);\n}\n\nstatic void assertJsonEquals(const JsonDocument& doc,\n std::string expectedJson) {\n std::string actualJson;\n serializeJson(doc, actualJson);\n REQUIRE(actualJson == expectedJson);\n}\n\nTEST_CASE(\"ARDUINOJSON_ENABLE_INFINITY == 0\") {\n SECTION(\"serializeJson()\") {\n JsonDocument doc;\n doc.add(std::numeric_limits::infinity());\n doc.add(-std::numeric_limits::infinity());\n\n assertJsonEquals(doc, \"[null,null]\");\n }\n\n SECTION(\"deserializeJson()\") {\n assertParseFails(\"{\\\"X\\\":Infinity}\");\n assertParseFails(\"{\\\"X\\\":-Infinity}\");\n assertParseFails(\"{\\\"X\\\":+Infinity}\");\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_infinity_1.cpp", "content": "#define ARDUINOJSON_ENABLE_INFINITY 1\n#include \n\n#include \n#include \n\nnamespace my {\nusing ArduinoJson::detail::isinf;\n} // namespace my\n\nTEST_CASE(\"ARDUINOJSON_ENABLE_INFINITY == 1\") {\n JsonDocument doc;\n\n SECTION(\"serializeJson()\") {\n doc.add(std::numeric_limits::infinity());\n doc.add(-std::numeric_limits::infinity());\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"[Infinity,-Infinity]\");\n }\n\n SECTION(\"deserializeJson()\") {\n DeserializationError err =\n deserializeJson(doc, \"[Infinity,-Infinity,+Infinity]\");\n float a = doc[0];\n float b = doc[1];\n float c = doc[2];\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(my::isinf(a));\n REQUIRE(a > 0);\n REQUIRE(my::isinf(b));\n REQUIRE(b < 0);\n REQUIRE(my::isinf(c));\n REQUIRE(c > 0);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_nan_0.cpp", "content": "#define ARDUINOJSON_ENABLE_NAN 0\n#include \n\n#include \n#include \n\nTEST_CASE(\"ARDUINOJSON_ENABLE_NAN == 0\") {\n JsonDocument doc;\n JsonObject root = doc.to();\n\n SECTION(\"serializeJson()\") {\n root[\"X\"] = std::numeric_limits::signaling_NaN();\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"X\\\":null}\");\n }\n\n SECTION(\"deserializeJson()\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"X\\\":NaN}\");\n\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_nan_1.cpp", "content": "#define ARDUINOJSON_ENABLE_NAN 1\n#include \n\n#include \n#include \n\nnamespace my {\nusing ArduinoJson::detail::isnan;\n} // namespace my\n\nTEST_CASE(\"ARDUINOJSON_ENABLE_NAN == 1\") {\n JsonDocument doc;\n JsonObject root = doc.to();\n\n SECTION(\"serializeJson()\") {\n root[\"X\"] = std::numeric_limits::signaling_NaN();\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"X\\\":NaN}\");\n }\n\n SECTION(\"deserializeJson()\") {\n DeserializationError err = deserializeJson(doc, \"{\\\"X\\\":NaN}\");\n float x = doc[\"X\"];\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(my::isnan(x));\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/enable_progmem_1.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_PROGMEM 1\n#include \n\n#include \n\nTEST_CASE(\"Flash strings\") {\n JsonDocument doc;\n\n SECTION(\"deserializeJson()\") {\n DeserializationError err = deserializeJson(doc, F(\"{'hello':'world'}\"));\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc[\"hello\"] == \"world\");\n }\n\n SECTION(\"JsonDocument::operator[]\") {\n doc[F(\"hello\")] = F(\"world\");\n\n REQUIRE(doc[\"hello\"] == \"world\");\n }\n\n SECTION(\"JsonDocument::add()\") {\n doc.add(F(\"world\"));\n\n REQUIRE(doc[0] == \"world\");\n }\n\n SECTION(\"JsonVariant::set()\") {\n JsonVariant var = doc.to();\n\n var.set(F(\"world\"));\n\n REQUIRE(var == \"world\");\n }\n\n SECTION(\"MemberProxy::operator==\") {\n doc[\"hello\"] = \"world\";\n\n REQUIRE(doc[\"hello\"] == F(\"world\"));\n }\n\n SECTION(\"ElementProxy::operator==\") {\n doc.add(\"world\");\n\n REQUIRE(doc[0] == F(\"world\"));\n }\n}\n\nTEST_CASE(\"parseNumber()\") { // tables are in Flash\n using ArduinoJson::detail::parseNumber;\n\n CHECK(parseNumber(\"1\") == 1.f);\n CHECK(parseNumber(\"1.23\") == 1.23f);\n CHECK(parseNumber(\"-1.23e34\") == -1.23e34f);\n}\n\nTEST_CASE(\"strlen_P\") {\n CHECK(strlen_P(PSTR(\"\")) == 0);\n CHECK(strlen_P(PSTR(\"a\")) == 1);\n CHECK(strlen_P(PSTR(\"ac\")) == 2);\n}\n\nTEST_CASE(\"strncmp_P\") {\n CHECK(strncmp_P(\"a\", PSTR(\"b\"), 0) == 0);\n CHECK(strncmp_P(\"a\", PSTR(\"b\"), 1) == -1);\n CHECK(strncmp_P(\"b\", PSTR(\"a\"), 1) == 1);\n CHECK(strncmp_P(\"a\", PSTR(\"a\"), 0) == 0);\n CHECK(strncmp_P(\"a\", PSTR(\"b\"), 2) == -1);\n CHECK(strncmp_P(\"b\", PSTR(\"a\"), 2) == 1);\n CHECK(strncmp_P(\"a\", PSTR(\"a\"), 2) == 0);\n}\n\nTEST_CASE(\"strcmp_P\") {\n CHECK(strcmp_P(\"a\", PSTR(\"b\")) == -1);\n CHECK(strcmp_P(\"b\", PSTR(\"a\")) == 1);\n CHECK(strcmp_P(\"a\", PSTR(\"a\")) == 0);\n CHECK(strcmp_P(\"aa\", PSTR(\"ab\")) == -1);\n CHECK(strcmp_P(\"ab\", PSTR(\"aa\")) == 1);\n CHECK(strcmp_P(\"aa\", PSTR(\"aa\")) == 0);\n}\n\nTEST_CASE(\"memcpy_P\") {\n char dst[4];\n CHECK(memcpy_P(dst, PSTR(\"ABC\"), 4) == dst);\n CHECK(dst[0] == 'A');\n CHECK(dst[1] == 'B');\n CHECK(dst[2] == 'C');\n CHECK(dst[3] == 0);\n}\n\nTEST_CASE(\"BoundedReader\") {\n using namespace ArduinoJson::detail;\n\n SECTION(\"read\") {\n BoundedReader reader(F(\"\\x01\\xFF\"), 2);\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == -1);\n REQUIRE(reader.read() == -1);\n }\n\n SECTION(\"readBytes() all at once\") {\n BoundedReader reader(F(\"ABCD\"), 3);\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 4) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n BoundedReader reader(F(\"ABCDEF\"), 6);\n\n char buffer[8] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 4) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nTEST_CASE(\"Reader\") {\n using namespace ArduinoJson::detail;\n\n SECTION(\"read()\") {\n Reader reader(F(\"\\x01\\xFF\\x00\\x12\"));\n REQUIRE(reader.read() == 0x01);\n REQUIRE(reader.read() == 0xFF);\n REQUIRE(reader.read() == 0);\n REQUIRE(reader.read() == 0x12);\n }\n\n SECTION(\"readBytes() all at once\") {\n Reader reader(F(\"ABCD\"));\n\n char buffer[8] = \"abcd\";\n REQUIRE(reader.readBytes(buffer, 3) == 3);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'd');\n }\n\n SECTION(\"readBytes() in two parts\") {\n Reader reader(F(\"ABCDEF\"));\n\n char buffer[8] = \"abcdefg\";\n REQUIRE(reader.readBytes(buffer, 4) == 4);\n REQUIRE(reader.readBytes(buffer + 4, 2) == 2);\n\n REQUIRE(buffer[0] == 'A');\n REQUIRE(buffer[1] == 'B');\n REQUIRE(buffer[2] == 'C');\n REQUIRE(buffer[3] == 'D');\n REQUIRE(buffer[4] == 'E');\n REQUIRE(buffer[5] == 'F');\n REQUIRE(buffer[6] == 'g');\n }\n}\n\nstatic void testStringification(DeserializationError error,\n std::string expected) {\n const __FlashStringHelper* s = error.f_str();\n CHECK(reinterpret_cast(convertFlashToPtr(s)) == expected);\n}\n\n#define TEST_STRINGIFICATION(symbol) \\\n testStringification(DeserializationError::symbol, #symbol)\n\nTEST_CASE(\"DeserializationError::f_str()\") {\n TEST_STRINGIFICATION(Ok);\n TEST_STRINGIFICATION(EmptyInput);\n TEST_STRINGIFICATION(IncompleteInput);\n TEST_STRINGIFICATION(InvalidInput);\n TEST_STRINGIFICATION(NoMemory);\n TEST_STRINGIFICATION(TooDeep);\n}\n" }, { "path": "extras/tests/MixedConfiguration/issue1707.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINO\n#define memcpy_P(dest, src, n) memcpy((dest), (src), (n))\n\n#include \n\n#include \n\nTEST_CASE(\"Issue1707\") {\n JsonDocument doc;\n\n DeserializationError err = deserializeJson(doc, F(\"{\\\"hello\\\":12}\"));\n REQUIRE(err == DeserializationError::Ok);\n}\n" }, { "path": "extras/tests/MixedConfiguration/string_length_size_1.cpp", "content": "#define ARDUINOJSON_STRING_LENGTH_SIZE 1\n#include \n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"ARDUINOJSON_STRING_LENGTH_SIZE == 1\") {\n JsonDocument doc;\n\n SECTION(\"set(std::string)\") {\n SECTION(\"returns true if len <= 255\") {\n auto result = doc.set(std::string(255, '?'));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if len >= 256\") {\n auto result = doc.set(std::string(256, '?'));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"set(MsgPackBinary)\") {\n SECTION(\"returns true if size <= 253\") {\n auto str = std::string(253, '?');\n auto result = doc.set(MsgPackBinary(str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if size >= 254\") {\n auto str = std::string(254, '?');\n auto result = doc.set(MsgPackBinary(str.data(), str.size()));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"set(MsgPackExtension)\") {\n SECTION(\"returns true if size <= 252\") {\n auto str = std::string(252, '?');\n auto result = doc.set(MsgPackExtension(1, str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if size >= 253\") {\n auto str = std::string(253, '?');\n auto result = doc.set(MsgPackExtension(1, str.data(), str.size()));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"deserializeJson()\") {\n SECTION(\"returns Ok if string length <= 255\") {\n auto input = \"\\\"\" + std::string(255, '?') + \"\\\"\";\n\n auto err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if string length >= 256\") {\n auto input = \"\\\"\" + std::string(256, '?') + \"\\\"\";\n\n auto err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n }\n\n SECTION(\"deserializeMsgPack()\") {\n SECTION(\"returns Ok if string length <= 255\") {\n auto input = \"\\xd9\\xff\" + std::string(255, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if string length >= 256\") {\n auto input = \"\\xda\\x01\\x00\"_s + std::string(256, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"returns Ok if binary size <= 253\") {\n auto input = \"\\xc4\\xfd\" + std::string(253, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if binary size >= 254\") {\n auto input = \"\\xc4\\xfe\" + std::string(254, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"returns Ok if extension size <= 252\") {\n auto input = \"\\xc7\\xfc\\x01\" + std::string(252, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if binary size >= 253\") {\n auto input = \"\\xc7\\xfd\\x01\" + std::string(253, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/string_length_size_2.cpp", "content": "#define ARDUINOJSON_STRING_LENGTH_SIZE 2\n#include \n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"ARDUINOJSON_STRING_LENGTH_SIZE == 2\") {\n JsonDocument doc;\n\n SECTION(\"set(std::string)\") {\n SECTION(\"returns true if len <= 65535\") {\n auto result = doc.set(std::string(65535, '?'));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if len >= 65536\") {\n auto result = doc.set(std::string(65536, '?'));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"set(MsgPackBinary)\") {\n SECTION(\"returns true if size <= 65532\") {\n auto str = std::string(65532, '?');\n auto result = doc.set(MsgPackBinary(str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if size >= 65533\") {\n auto str = std::string(65533, '?');\n auto result = doc.set(MsgPackBinary(str.data(), str.size()));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"set(MsgPackExtension)\") {\n SECTION(\"returns true if size <= 65531\") {\n auto str = std::string(65531, '?');\n auto result = doc.set(MsgPackExtension(1, str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n\n SECTION(\"returns false if size >= 65532\") {\n auto str = std::string(65532, '?');\n auto result = doc.set(MsgPackExtension(1, str.data(), str.size()));\n\n REQUIRE(result == false);\n REQUIRE(doc.overflowed() == true);\n }\n }\n\n SECTION(\"deserializeJson()\") {\n SECTION(\"returns Ok if string length <= 65535\") {\n auto input = \"\\\"\" + std::string(65535, '?') + \"\\\"\";\n\n auto err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if string length >= 65536\") {\n auto input = \"\\\"\" + std::string(65536, '?') + \"\\\"\";\n\n auto err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n }\n\n SECTION(\"deserializeMsgPack()\") {\n SECTION(\"returns Ok if string length <= 65535\") {\n auto input = \"\\xda\\xff\\xff\" + std::string(65535, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if string length >= 65536\") {\n auto input = \"\\xdb\\x00\\x01\\x00\\x00\"_s + std::string(65536, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"returns Ok if binary size <= 65532\") {\n auto input = \"\\xc5\\xff\\xfc\" + std::string(65532, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if binary size >= 65534\") {\n auto input = \"\\xc5\\xff\\xfd\" + std::string(65534, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n // https://oss-fuzz.com/testcase?key=5354792971993088\n SECTION(\"doesn't overflow if binary size == 0xFFFF\") {\n auto input = \"\\xc5\\xff\\xff\"_s;\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"returns Ok if extension size <= 65531\") {\n auto input = \"\\xc8\\xff\\xfb\\x01\" + std::string(65531, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns NoMemory if extension size >= 65532\") {\n auto input = \"\\xc8\\xff\\xfc\\x01\" + std::string(65532, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/string_length_size_4.cpp", "content": "#define ARDUINOJSON_STRING_LENGTH_SIZE 4\n#include \n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"ARDUINOJSON_STRING_LENGTH_SIZE == 4\") {\n JsonDocument doc;\n\n SECTION(\"set(std::string)\") {\n SECTION(\"returns true if string length >= 65536\") {\n auto result = doc.set(std::string(65536, '?'));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n }\n\n SECTION(\"set(MsgPackBinary)\") {\n SECTION(\"returns true if size >= 65536\") {\n auto str = std::string(65536, '?');\n auto result = doc.set(MsgPackBinary(str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n }\n\n SECTION(\"set(MsgPackExtension)\") {\n SECTION(\"returns true if size >= 65532\") {\n auto str = std::string(65532, '?');\n auto result = doc.set(MsgPackExtension(1, str.data(), str.size()));\n\n REQUIRE(result == true);\n REQUIRE(doc.overflowed() == false);\n }\n }\n\n SECTION(\"deserializeJson()\") {\n SECTION(\"returns Ok if string length >= 65536\") {\n auto input = \"\\\"\" + std::string(65536, '?') + \"\\\"\";\n\n auto err = deserializeJson(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n }\n\n SECTION(\"deserializeMsgPack()\") {\n SECTION(\"returns Ok if string size >= 65536\") {\n auto input = \"\\xda\\xff\\xff\" + std::string(65536, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns Ok if binary size >= 65536\") {\n auto input = \"\\xc5\\xff\\xff\" + std::string(65536, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"returns Ok if extension size >= 65532\") {\n auto input = \"\\xc8\\xff\\xfb\\x01\" + std::string(65532, '?');\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n // https://oss-fuzz.com/testcase?key=5354792971993088\n SECTION(\"doesn't overflow if binary size == 0xFFFFFFFF\") {\n auto input = \"\\xc6\\xff\\xff\\xff\\xff\"_s;\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"doesn't overflow if string size == 0xFFFFFFFF\") {\n auto input = \"\\xdb\\xff\\xff\\xff\\xff???????????????????\"_s;\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err != DeserializationError::Ok);\n }\n\n SECTION(\"bin 32\") {\n auto str = std::string(65536, '?');\n auto input = \"\\xc6\\x00\\x01\\x00\\x00\"_s + str;\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto binary = doc.as();\n REQUIRE(binary.size() == 65536);\n REQUIRE(binary.data() != nullptr);\n REQUIRE(std::string(reinterpret_cast(binary.data()),\n binary.size()) == str);\n }\n\n SECTION(\"ext 32 deserialization\") {\n auto str = std::string(65536, '?');\n auto input = \"\\xc9\\x00\\x01\\x00\\x00\\x2a\"_s + str;\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto value = doc.as();\n REQUIRE(value.type() == 42);\n REQUIRE(value.size() == 65536);\n REQUIRE(value.data() != nullptr);\n REQUIRE(std::string(reinterpret_cast(value.data()),\n value.size()) == str);\n }\n }\n\n SECTION(\"serializeMsgPack()\") {\n SECTION(\"bin 32 serialization\") {\n auto str = std::string(65536, '?');\n doc.set(MsgPackBinary(str.data(), str.size()));\n\n std::string output;\n auto result = serializeMsgPack(doc, output);\n\n REQUIRE(result == 5 + str.size());\n REQUIRE(output == \"\\xc6\\x00\\x01\\x00\\x00\"_s + str);\n }\n\n SECTION(\"ext 32 serialization\") {\n auto str = std::string(65536, '?');\n doc.set(MsgPackExtension(42, str.data(), str.size()));\n\n std::string output;\n auto result = serializeMsgPack(doc, output);\n\n REQUIRE(result == 6 + str.size());\n REQUIRE(output == \"\\xc9\\x00\\x01\\x00\\x00\\x2a\"_s + str);\n }\n\n SECTION(\"str 32 serialization\") {\n auto str = std::string(65536, '?');\n doc.set(str);\n\n std::string output;\n auto result = serializeMsgPack(doc, output);\n\n REQUIRE(result == 5 + str.size());\n REQUIRE(output == \"\\xDB\\x00\\x01\\x00\\x00\"_s + str);\n }\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/use_double_0.cpp", "content": "#define ARDUINOJSON_USE_DOUBLE 0\n#include \n\n#include \n\nnamespace my {\nusing ArduinoJson::detail::isinf;\n} // namespace my\n\nvoid checkFloat(const char* input, float expected) {\n using ArduinoJson::detail::NumberType;\n using ArduinoJson::detail::parseNumber;\n CAPTURE(input);\n auto result = parseNumber(input);\n REQUIRE(result.type() == NumberType::Float);\n REQUIRE(result.asFloat() == Approx(expected));\n}\n\nTEST_CASE(\"ARDUINOJSON_USE_DOUBLE == 0\") {\n SECTION(\"serializeJson()\") {\n JsonDocument doc;\n JsonObject root = doc.to();\n\n root[\"pi\"] = 3.14;\n root[\"e\"] = 2.72;\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"pi\\\":3.14,\\\"e\\\":2.72}\");\n }\n\n SECTION(\"parseNumber()\") {\n using ArduinoJson::detail::NumberType;\n using ArduinoJson::detail::parseNumber;\n\n SECTION(\"Large positive number\") {\n auto result = parseNumber(\"1e300\");\n REQUIRE(result.type() == NumberType::Float);\n REQUIRE(result.asFloat() > 0);\n REQUIRE(my::isinf(result.asFloat()));\n }\n\n SECTION(\"Large negative number\") {\n auto result = parseNumber(\"-1e300\");\n REQUIRE(result.type() == NumberType::Float);\n REQUIRE(result.asFloat() < 0);\n REQUIRE(my::isinf(result.asFloat()));\n }\n\n SECTION(\"Too small to be represented\") {\n auto result = parseNumber(\"1e-300\");\n REQUIRE(result.type() == NumberType::Float);\n REQUIRE(result.asFloat() == 0);\n }\n\n SECTION(\"MantissaTooLongToFit\") {\n checkFloat(\"0.340282346638528861111111111111\", 0.34028234663852886f);\n checkFloat(\"34028234663852886.11111111111111\", 34028234663852886.0f);\n checkFloat(\"34028234.66385288611111111111111\", 34028234.663852886f);\n\n checkFloat(\"-0.340282346638528861111111111111\", -0.34028234663852886f);\n checkFloat(\"-34028234663852886.11111111111111\", -34028234663852886.0f);\n checkFloat(\"-34028234.66385288611111111111111\", -34028234.663852886f);\n }\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/use_double_1.cpp", "content": "#define ARDUINOJSON_USE_DOUBLE 1\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_USE_DOUBLE == 1\") {\n JsonDocument doc;\n JsonObject root = doc.to();\n\n root[\"pi\"] = 3.14;\n root[\"e\"] = 2.72;\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"pi\\\":3.14,\\\"e\\\":2.72}\");\n}\n" }, { "path": "extras/tests/MixedConfiguration/use_long_long_0.cpp", "content": "#define ARDUINOJSON_USE_LONG_LONG 0\n#include \n\n#include \n\n#include \"Literals.hpp\"\n\nTEST_CASE(\"ARDUINOJSON_USE_LONG_LONG == 0\") {\n JsonDocument doc;\n\n SECTION(\"smoke test\") {\n doc[\"A\"] = 42;\n doc[\"B\"] = 84;\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"A\\\":42,\\\"B\\\":84}\");\n }\n\n SECTION(\"deserializeMsgPack()\") {\n SECTION(\"cf 00 00 00 00 ff ff ff ff\") {\n auto err =\n deserializeMsgPack(doc, \"\\xcf\\x00\\x00\\x00\\x00\\xff\\xff\\xff\\xff\"_s);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == 0xFFFFFFFF);\n }\n\n SECTION(\"cf 00 00 00 01 00 00 00 00\") {\n auto err =\n deserializeMsgPack(doc, \"\\xcf\\x00\\x00\\x00\\x01\\x00\\x00\\x00\\x00\"_s);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.isNull());\n }\n }\n}\n" }, { "path": "extras/tests/MixedConfiguration/use_long_long_1.cpp", "content": "#define ARDUINOJSON_USE_LONG_LONG 1\n#include \n\n#include \n\nTEST_CASE(\"ARDUINOJSON_USE_LONG_LONG == 1\") {\n JsonDocument doc;\n JsonObject root = doc.to();\n\n root[\"A\"] = 123456789123456789;\n root[\"B\"] = 987654321987654321;\n\n std::string json;\n serializeJson(doc, json);\n\n REQUIRE(json == \"{\\\"A\\\":123456789123456789,\\\"B\\\":987654321987654321}\");\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(MsgPackDeserializerTests\n\tdeserializeArray.cpp\n\tdeserializeObject.cpp\n\tdeserializeVariant.cpp\n\tdestination_types.cpp\n\tdoubleToFloat.cpp\n\terrors.cpp\n\tfilter.cpp\n\tinput_types.cpp\n\tnestingLimit.cpp\n)\n\nadd_test(MsgPackDeserializer MsgPackDeserializerTests)\n\nset_tests_properties(MsgPackDeserializer\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/MsgPackDeserializer/deserializeArray.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n\nTEST_CASE(\"deserialize MsgPack array\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n\n SECTION(\"fixarray\") {\n SECTION(\"empty\") {\n const char* input = \"\\x90\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 0);\n }\n\n SECTION(\"two integers\") {\n const char* input = \"\\x92\\x01\\x02\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 2);\n REQUIRE(array[0] == 1);\n REQUIRE(array[1] == 2);\n }\n\n SECTION(\"tiny strings\") {\n DeserializationError error =\n deserializeMsgPack(doc, \"\\x92\\xA3xxx\\xA3yyy\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(doc.size() == 2);\n REQUIRE(doc[0] == \"xxx\");\n REQUIRE(doc[1] == \"yyy\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"xxx\")),\n // Buffer is reused for the next string\n Deallocate(sizeofString(\"xxx\")),\n Reallocate(sizeofPool(), sizeofPool(2)),\n });\n }\n }\n\n SECTION(\"array 16\") {\n SECTION(\"empty\") {\n const char* input = \"\\xDC\\x00\\x00\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 0);\n }\n\n SECTION(\"two strings\") {\n const char* input = \"\\xDC\\x00\\x02\\xA5hello\\xA5world\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 2);\n REQUIRE(array[0] == \"hello\");\n REQUIRE(array[1] == \"world\");\n }\n }\n\n SECTION(\"array 32\") {\n SECTION(\"empty\") {\n const char* input = \"\\xDD\\x00\\x00\\x00\\x00\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 0);\n }\n\n SECTION(\"two floats\") {\n const char* input =\n \"\\xDD\\x00\\x00\\x00\\x02\\xCA\\x00\\x00\\x00\\x00\\xCA\\x40\\x48\\xF5\\xC3\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonArray array = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(array.size() == 2);\n REQUIRE(array[0] == 0.0f);\n REQUIRE(array[1] == 3.14f);\n }\n }\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/deserializeObject.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"deserialize MsgPack object\") {\n JsonDocument doc;\n\n SECTION(\"fixmap\") {\n SECTION(\"empty\") {\n const char* input = \"\\x80\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 0);\n }\n\n SECTION(\"two integers\") {\n const char* input = \"\\x82\\xA3one\\x01\\xA3two\\x02\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"one\"] == 1);\n REQUIRE(obj[\"two\"] == 2);\n }\n\n SECTION(\"key is str 8\") {\n const char* input = \"\\x82\\xd9\\x03one\\x01\\xd9\\x03two\\x02\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"one\"] == 1);\n REQUIRE(obj[\"two\"] == 2);\n }\n\n SECTION(\"key is str 16\") {\n const char* input = \"\\x82\\xda\\x00\\x03one\\x01\\xda\\x00\\x03two\\x02\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"one\"] == 1);\n REQUIRE(obj[\"two\"] == 2);\n }\n\n SECTION(\"key is str 32\") {\n const char* input =\n \"\\x82\\xdb\\x00\\x00\\x00\\x03one\\x01\\xdb\\x00\\x00\\x00\\x03two\\x02\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"one\"] == 1);\n REQUIRE(obj[\"two\"] == 2);\n }\n }\n\n SECTION(\"map 16\") {\n SECTION(\"empty\") {\n const char* input = \"\\xDE\\x00\\x00\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 0);\n }\n\n SECTION(\"two strings\") {\n const char* input = \"\\xDE\\x00\\x02\\xA1H\\xA5hello\\xA1W\\xA5world\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"H\"] == \"hello\");\n REQUIRE(obj[\"W\"] == \"world\");\n }\n }\n\n SECTION(\"map 32\") {\n SECTION(\"empty\") {\n const char* input = \"\\xDF\\x00\\x00\\x00\\x00\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 0);\n }\n\n SECTION(\"two floats\") {\n const char* input =\n \"\\xDF\\x00\\x00\\x00\\x02\\xA4zero\\xCA\\x00\\x00\\x00\\x00\\xA2pi\\xCA\\x40\\x48\"\n \"\\xF5\\xC3\";\n\n DeserializationError error = deserializeMsgPack(doc, input);\n JsonObject obj = doc.as();\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(obj.size() == 2);\n REQUIRE(obj[\"zero\"] == 0.0f);\n REQUIRE(obj[\"pi\"] == 3.14f);\n }\n }\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/deserializeVariant.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\ntemplate \nstatic void checkValue(const char* input, T expected) {\n JsonDocument doc;\n\n DeserializationError error = deserializeMsgPack(doc, input);\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n REQUIRE(doc.as() == expected);\n}\n\nstatic void checkError(size_t timebombCountDown, const char* input,\n DeserializationError expected) {\n TimebombAllocator timebomb(timebombCountDown);\n JsonDocument doc(&timebomb);\n\n DeserializationError error = deserializeMsgPack(doc, input);\n\n CAPTURE(input);\n REQUIRE(error == expected);\n}\n\nTEST_CASE(\"deserialize MsgPack value\") {\n SECTION(\"nil\") {\n checkValue(\"\\xc0\", nullptr);\n }\n\n SECTION(\"bool\") {\n checkValue(\"\\xc2\", false);\n checkValue(\"\\xc3\", true);\n }\n\n SECTION(\"positive fixint\") {\n checkValue(\"\\x00\", 0);\n checkValue(\"\\x7F\", 127);\n }\n\n SECTION(\"negative fixint\") {\n checkValue(\"\\xe0\", -32);\n checkValue(\"\\xff\", -1);\n }\n\n SECTION(\"uint 8\") {\n checkValue(\"\\xcc\\x00\", 0);\n checkValue(\"\\xcc\\xff\", 255);\n }\n\n SECTION(\"uint 16\") {\n checkValue(\"\\xcd\\x00\\x00\", 0);\n checkValue(\"\\xcd\\xFF\\xFF\", 65535);\n checkValue(\"\\xcd\\x30\\x39\", 12345);\n }\n\n SECTION(\"uint 32\") {\n checkValue(\"\\xCE\\x00\\x00\\x00\\x00\", 0x00000000U);\n checkValue(\"\\xCE\\xFF\\xFF\\xFF\\xFF\", 0xFFFFFFFFU);\n checkValue(\"\\xCE\\x12\\x34\\x56\\x78\", 0x12345678U);\n }\n\n SECTION(\"uint 64\") {\n#if ARDUINOJSON_USE_LONG_LONG\n checkValue(\"\\xCF\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", 0U);\n checkValue(\"\\xCF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\",\n 0xFFFFFFFFFFFFFFFFU);\n checkValue(\"\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\",\n 0x123456789ABCDEF0U);\n#else\n checkValue(\"\\xCF\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", nullptr);\n checkValue(\"\\xCF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\", nullptr);\n checkValue(\"\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\", nullptr);\n#endif\n }\n\n SECTION(\"int 8\") {\n checkValue(\"\\xd0\\x00\", 0);\n checkValue(\"\\xd0\\xff\", -1);\n }\n\n SECTION(\"int 16\") {\n checkValue(\"\\xD1\\x00\\x00\", 0);\n checkValue(\"\\xD1\\xFF\\xFF\", -1);\n checkValue(\"\\xD1\\xCF\\xC7\", -12345);\n }\n\n SECTION(\"int 32\") {\n checkValue(\"\\xD2\\x00\\x00\\x00\\x00\", 0);\n checkValue(\"\\xD2\\xFF\\xFF\\xFF\\xFF\", -1);\n checkValue(\"\\xD2\\xB6\\x69\\xFD\\x2E\", -1234567890);\n }\n\n SECTION(\"int 64\") {\n#if ARDUINOJSON_USE_LONG_LONG\n checkValue(\"\\xD3\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", int64_t(0U));\n checkValue(\"\\xD3\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\",\n int64_t(0xFFFFFFFFFFFFFFFFU));\n checkValue(\"\\xD3\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\",\n int64_t(0x123456789ABCDEF0));\n#else\n checkValue(\"\\xD3\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", nullptr);\n checkValue(\"\\xD3\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\", nullptr);\n checkValue(\"\\xD3\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\", nullptr);\n#endif\n }\n\n SECTION(\"float 32\") {\n checkValue(\"\\xCA\\x00\\x00\\x00\\x00\", 0.0f);\n checkValue(\"\\xCA\\x40\\x48\\xF5\\xC3\", 3.14f);\n }\n\n SECTION(\"float 64\") {\n checkValue(\"\\xCB\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", 0.0);\n checkValue(\"\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\\x12\\x6F\", 3.1415);\n }\n\n SECTION(\"fixstr\") {\n checkValue(\"\\xA0\", std::string(\"\"));\n checkValue(\"\\xABhello world\", \"hello world\"_s);\n checkValue(\"\\xBFhello world hello world hello !\",\n \"hello world hello world hello !\"_s);\n }\n\n SECTION(\"str 8\") {\n checkValue(\"\\xd9\\x05hello\", \"hello\"_s);\n }\n\n SECTION(\"str 16\") {\n checkValue(\"\\xda\\x00\\x05hello\", \"hello\"_s);\n }\n\n SECTION(\"str 32\") {\n checkValue(\"\\xdb\\x00\\x00\\x00\\x05hello\", \"hello\"_s);\n }\n\n SECTION(\"bin 8\") {\n JsonDocument doc;\n\n DeserializationError error = deserializeMsgPack(doc, \"\\xc4\\x01?\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto binary = doc.as();\n REQUIRE(binary.size() == 1);\n REQUIRE(binary.data() != nullptr);\n REQUIRE(reinterpret_cast(binary.data())[0] == '?');\n }\n\n SECTION(\"bin 16\") {\n JsonDocument doc;\n auto str = std::string(256, '?');\n auto input = \"\\xc5\\x01\\x00\"_s + str;\n\n DeserializationError error = deserializeMsgPack(doc, input);\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto binary = doc.as();\n REQUIRE(binary.size() == 0x100);\n REQUIRE(binary.data() != nullptr);\n REQUIRE(std::string(reinterpret_cast(binary.data()),\n binary.size()) == str);\n }\n\n SECTION(\"fixext 1\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xd4\\x01\\x02\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 1);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 2);\n }\n\n SECTION(\"fixext 2\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xd5\\x01\\x02\\x03\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 2);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 2);\n REQUIRE(data[1] == 3);\n }\n\n SECTION(\"fixext 4\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xd6\\x01\\x02\\x03\\x04\\x05\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 4);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 2);\n REQUIRE(data[1] == 3);\n REQUIRE(data[2] == 4);\n REQUIRE(data[3] == 5);\n }\n\n SECTION(\"fixext 8\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xd7\\x01????????\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 8);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == '?');\n REQUIRE(data[7] == '?');\n }\n\n SECTION(\"fixext 16\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xd8\\x01?????????????????\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 16);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == '?');\n REQUIRE(data[15] == '?');\n }\n\n SECTION(\"ext 8\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xc7\\x02\\x01\\x03\\x04\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 2);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 3);\n REQUIRE(data[1] == 4);\n }\n\n SECTION(\"ext 16\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xc8\\x00\\x02\\x01\\x03\\x04\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 2);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 3);\n REQUIRE(data[1] == 4);\n }\n\n SECTION(\"ext 32\") {\n JsonDocument doc;\n\n auto error = deserializeMsgPack(doc, \"\\xc9\\x00\\x00\\x00\\x02\\x01\\x03\\x04\");\n\n REQUIRE(error == DeserializationError::Ok);\n REQUIRE(doc.is());\n auto ext = doc.as();\n REQUIRE(ext.type() == 1);\n REQUIRE(ext.size() == 2);\n auto data = reinterpret_cast(ext.data());\n REQUIRE(data[0] == 3);\n REQUIRE(data[1] == 4);\n }\n}\n\nTEST_CASE(\"deserializeMsgPack() under memory constaints\") {\n SECTION(\"single values always fit\") {\n checkError(0, \"\\xc0\", DeserializationError::Ok); // nil\n checkError(0, \"\\xc2\", DeserializationError::Ok); // false\n checkError(0, \"\\xc3\", DeserializationError::Ok); // true\n checkError(0, \"\\xcc\\x00\", DeserializationError::Ok); // uint 8\n checkError(0, \"\\xcd\\x30\\x39\", DeserializationError::Ok); // uint 16\n checkError(0, \"\\xCE\\x12\\x34\\x56\\x78\",\n DeserializationError::Ok); // uint 32\n }\n\n SECTION(\"fixstr\") {\n checkError(2, \"\\xA7ZZZZZZZ\", DeserializationError::Ok);\n checkError(0, \"\\xA7ZZZZZZZ\", DeserializationError::NoMemory);\n }\n\n SECTION(\"str 8\") {\n checkError(2, \"\\xD9\\x07ZZZZZZZ\", DeserializationError::Ok);\n checkError(0, \"\\xD9\\x07ZZZZZZZ\", DeserializationError::NoMemory);\n }\n\n SECTION(\"str 16\") {\n checkError(2, \"\\xDA\\x00\\x07ZZZZZZZ\", DeserializationError::Ok);\n checkError(0, \"\\xDA\\x00\\x07ZZZZZZZ\", DeserializationError::NoMemory);\n }\n\n SECTION(\"str 32\") {\n checkError(2, \"\\xDB\\x00\\x00\\x00\\x07ZZZZZZZ\", DeserializationError::Ok);\n checkError(0, \"\\xDB\\x00\\x00\\x00\\x07ZZZZZZZ\",\n DeserializationError::NoMemory);\n }\n\n SECTION(\"fixarray\") {\n checkError(0, \"\\x90\", DeserializationError::Ok); // []\n checkError(0, \"\\x91\\x01\",\n DeserializationError::NoMemory); // [1]\n checkError(1, \"\\x91\\x01\",\n DeserializationError::Ok); // [1]\n }\n\n SECTION(\"array 16\") {\n checkError(0, \"\\xDC\\x00\\x00\", DeserializationError::Ok);\n checkError(0, \"\\xDC\\x00\\x01\\x01\", DeserializationError::NoMemory);\n checkError(1, \"\\xDC\\x00\\x01\\x01\", DeserializationError::Ok);\n }\n\n SECTION(\"array 32\") {\n checkError(0, \"\\xDD\\x00\\x00\\x00\\x00\", DeserializationError::Ok);\n checkError(0, \"\\xDD\\x00\\x00\\x00\\x01\\x01\", DeserializationError::NoMemory);\n checkError(1, \"\\xDD\\x00\\x00\\x00\\x01\\x01\", DeserializationError::Ok);\n }\n\n SECTION(\"fixmap\") {\n SECTION(\"{}\") {\n checkError(0, \"\\x80\", DeserializationError::Ok);\n }\n SECTION(\"{Hello:1}\") {\n checkError(1, \"\\x81\\xA5Hello\\x01\", DeserializationError::NoMemory);\n checkError(2, \"\\x81\\xA5Hello\\x01\", DeserializationError::Ok);\n }\n SECTION(\"{Hello:1,World:2}\") {\n checkError(2, \"\\x82\\xA5Hello\\x01\\xA5World\\x02\",\n DeserializationError::NoMemory);\n checkError(3, \"\\x82\\xA5Hello\\x01\\xA5World\\x02\", DeserializationError::Ok);\n }\n }\n\n SECTION(\"map 16\") {\n SECTION(\"{}\") {\n checkError(0, \"\\xDE\\x00\\x00\", DeserializationError::Ok);\n }\n SECTION(\"{Hello:1}\") {\n checkError(1, \"\\xDE\\x00\\x01\\xA5Hello\\x01\",\n DeserializationError::NoMemory);\n checkError(2, \"\\xDE\\x00\\x01\\xA5Hello\\x01\", DeserializationError::Ok);\n }\n SECTION(\"{Hello:1,World:2}\") {\n checkError(2, \"\\xDE\\x00\\x02\\xA5Hello\\x01\\xA5World\\x02\",\n DeserializationError::NoMemory);\n checkError(3, \"\\xDE\\x00\\x02\\xA5Hello\\x01\\xA5World\\x02\",\n DeserializationError::Ok);\n }\n }\n\n SECTION(\"map 32\") {\n SECTION(\"{}\") {\n checkError(0, \"\\xDF\\x00\\x00\\x00\\x00\", DeserializationError::Ok);\n }\n SECTION(\"{H:1}\") {\n checkError(1, \"\\xDF\\x00\\x00\\x00\\x01\\xA1H\\x01\",\n DeserializationError::NoMemory);\n checkError(2, \"\\xDF\\x00\\x00\\x00\\x01\\xA1H\\x01\", DeserializationError::Ok);\n }\n SECTION(\"{Hello:1,World:2}\") {\n checkError(2, \"\\xDF\\x00\\x00\\x00\\x02\\xA5Hello\\x01\\xA5World\\x02\",\n DeserializationError::NoMemory);\n checkError(3, \"\\xDF\\x00\\x00\\x00\\x02\\xA1H\\x01\\xA1W\\x02\",\n DeserializationError::Ok);\n }\n }\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/destination_types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofArray;\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"deserializeMsgPack(JsonDocument&)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n auto err = deserializeMsgPack(doc, \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[42]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofPool()),\n Deallocate(sizeofString(\"hello\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofArray(1)),\n });\n}\n\nTEST_CASE(\"deserializeMsgPack(JsonVariant)\") {\n SECTION(\"variant is bound\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n JsonVariant variant = doc[0];\n\n auto err = deserializeMsgPack(variant, \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[[42]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"variant is unbound\") {\n JsonVariant variant;\n\n auto err = deserializeMsgPack(variant, \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n\nTEST_CASE(\"deserializeMsgPack(ElementProxy)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc.add(\"hello\"_s);\n spy.clearLog();\n\n SECTION(\"element already exists\") {\n auto err = deserializeMsgPack(doc[0], \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[[42]]\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"element must be created exists\") {\n auto err = deserializeMsgPack(doc[1], \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"[\\\"hello\\\",[42]]\");\n REQUIRE(spy.log() == AllocatorLog{});\n }\n}\n\nTEST_CASE(\"deserializeMsgPack(MemberProxy)\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n doc[\"hello\"_s] = \"world\"_s;\n spy.clearLog();\n\n SECTION(\"member already exists\") {\n auto err = deserializeMsgPack(doc[\"hello\"], \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{\\\"hello\\\":[42]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Deallocate(sizeofString(\"world\")),\n });\n }\n\n SECTION(\"member must be created\") {\n auto err = deserializeMsgPack(doc[\"value\"], \"\\x91\\x2A\");\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.as() == \"{\\\"hello\\\":\\\"world\\\",\\\"value\\\":[42]}\");\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"value\")),\n });\n }\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/doubleToFloat.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\ntemplate \nstatic void check(const char* input, T expected) {\n T actual;\n uint8_t* f = reinterpret_cast(&actual);\n const uint8_t* d = reinterpret_cast(input);\n doubleToFloat(d, f);\n fixEndianness(actual);\n CHECK(actual == expected);\n}\n\nTEST_CASE(\"doubleToFloat()\") {\n check(\"\\x40\\x09\\x21\\xCA\\xC0\\x83\\x12\\x6F\", 3.1415f);\n check(\"\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", 0.0f);\n check(\"\\x80\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", -0.0f);\n check(\"\\xC0\\x5E\\xDC\\xCC\\xCC\\xCC\\xCC\\xCD\", -123.45f);\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/errors.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Allocators.hpp\"\n\nTEST_CASE(\"deserializeMsgPack() returns InvalidInput\") {\n JsonDocument doc;\n\n SECTION(\"integer as key\") {\n auto err = deserializeMsgPack(doc, \"\\x81\\x01\\xA1H\", 3);\n REQUIRE(err == DeserializationError::InvalidInput);\n }\n}\n\nTEST_CASE(\"deserializeMsgPack() returns EmptyInput\") {\n JsonDocument doc;\n\n SECTION(\"from sized buffer\") {\n auto err = deserializeMsgPack(doc, \"\", 0);\n\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n\n SECTION(\"from stream\") {\n std::istringstream input(\"\");\n\n auto err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::EmptyInput);\n }\n}\n\nstatic void testIncompleteInput(const char* input, size_t len) {\n JsonDocument doc;\n REQUIRE(deserializeMsgPack(doc, input, len) == DeserializationError::Ok);\n\n while (--len) {\n REQUIRE(deserializeMsgPack(doc, input, len) ==\n DeserializationError::IncompleteInput);\n }\n}\n\nTEST_CASE(\"deserializeMsgPack() returns IncompleteInput\") {\n SECTION(\"empty input\") {\n testIncompleteInput(\"\\x00\", 1);\n }\n\n SECTION(\"fixarray\") {\n testIncompleteInput(\"\\x91\\x01\", 2);\n }\n\n SECTION(\"array 16\") {\n testIncompleteInput(\"\\xDC\\x00\\x01\\x01\", 4);\n }\n\n SECTION(\"array 32\") {\n testIncompleteInput(\"\\xDD\\x00\\x00\\x00\\x01\\x01\", 6);\n }\n\n SECTION(\"fixmap\") {\n testIncompleteInput(\"\\x81\\xA3one\\x01\", 6);\n }\n\n SECTION(\"map 16\") {\n testIncompleteInput(\"\\xDE\\x00\\x01\\xA3one\\x01\", 8);\n }\n\n SECTION(\"map 32\") {\n testIncompleteInput(\"\\xDF\\x00\\x00\\x00\\x01\\xA3one\\x01\", 10);\n testIncompleteInput(\"\\xDF\\x00\\x00\\x00\\x01\\xd9\\x03one\\x01\", 11);\n }\n\n SECTION(\"uint 8\") {\n testIncompleteInput(\"\\xcc\\x01\", 2);\n }\n\n SECTION(\"uint 16\") {\n testIncompleteInput(\"\\xcd\\x00\\x01\", 3);\n }\n\n SECTION(\"uint 32\") {\n testIncompleteInput(\"\\xCE\\x00\\x00\\x00\\x01\", 5);\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"uint 64\") {\n testIncompleteInput(\"\\xCF\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", 9);\n }\n#endif\n\n SECTION(\"int 8\") {\n testIncompleteInput(\"\\xD0\\x01\", 2);\n }\n\n SECTION(\"int 16\") {\n testIncompleteInput(\"\\xD1\\x00\\x01\", 3);\n }\n\n SECTION(\"int 32\") {\n testIncompleteInput(\"\\xD2\\x00\\x00\\x00\\x01\", 5);\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"int 64\") {\n testIncompleteInput(\"\\xD3\\x00\\x00\\x00\\x00\\x00\\x00\\x00\\x00\", 9);\n }\n#endif\n\n SECTION(\"float 32\") {\n testIncompleteInput(\"\\xCA\\x40\\x48\\xF5\\xC3\", 5);\n }\n\n SECTION(\"float 64\") {\n testIncompleteInput(\"\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\\x12\\x6F\", 9);\n }\n\n SECTION(\"fixstr\") {\n testIncompleteInput(\"\\xABhello world\", 12);\n }\n\n SECTION(\"str 8\") {\n testIncompleteInput(\"\\xd9\\x05hello\", 7);\n }\n\n SECTION(\"str 16\") {\n testIncompleteInput(\"\\xda\\x00\\x05hello\", 8);\n }\n\n SECTION(\"str 32\") {\n testIncompleteInput(\"\\xdb\\x00\\x00\\x00\\x05hello\", 10);\n }\n\n SECTION(\"bin 8\") {\n testIncompleteInput(\"\\xc4\\x01X\", 3);\n }\n\n SECTION(\"bin 16\") {\n testIncompleteInput(\"\\xc5\\x00\\x01X\", 4);\n }\n\n SECTION(\"bin 32\") {\n testIncompleteInput(\"\\xc6\\x00\\x00\\x00\\x01X\", 6);\n }\n\n SECTION(\"ext 8\") {\n testIncompleteInput(\"\\xc7\\x01\\x01\\x01\", 4);\n }\n\n SECTION(\"ext 16\") {\n testIncompleteInput(\"\\xc8\\x00\\x01\\x01\\x01\", 5);\n }\n\n SECTION(\"ext 32\") {\n testIncompleteInput(\"\\xc9\\x00\\x00\\x00\\x01\\x01\\x01\", 7);\n }\n\n SECTION(\"fixext 1\") {\n testIncompleteInput(\"\\xd4\\x01\\x01\", 3);\n }\n\n SECTION(\"fixext 2\") {\n testIncompleteInput(\"\\xd5\\x01\\x01\\x02\", 4);\n }\n\n SECTION(\"fixext 4\") {\n testIncompleteInput(\"\\xd6\\x01\\x01\\x02\\x03\\x04\", 6);\n }\n\n SECTION(\"fixext 8\") {\n testIncompleteInput(\"\\xd7\\x01\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\", 10);\n }\n\n SECTION(\"fixext 16\") {\n testIncompleteInput(\n \"\\xd8\\x01\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\\x0E\"\n \"\\x0F\\x10\",\n 18);\n }\n}\n\nTEST_CASE(\n \"deserializeMsgPack() returns NoMemory when string allocation fails\") {\n TimebombAllocator allocator(0);\n JsonDocument doc(&allocator);\n\n SECTION(\"fixstr\") {\n DeserializationError err = deserializeMsgPack(doc, \"\\xA5hello\", 9);\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"bin 8\") {\n DeserializationError err = deserializeMsgPack(doc, \"\\xC4\\x01X\", 3);\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n\nTEST_CASE(\n \"deserializeMsgPack() returns NoMemory if extension allocation fails\") {\n JsonDocument doc(FailingAllocator::instance());\n\n SECTION(\"uint32_t should pass\") {\n auto err = deserializeMsgPack(doc, \"\\xceXXXX\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"uint64_t should fail\") {\n auto err = deserializeMsgPack(doc, \"\\xcfXXXXXXXX\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"int32_t should pass\") {\n auto err = deserializeMsgPack(doc, \"\\xd2XXXX\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"int64_t should fail\") {\n auto err = deserializeMsgPack(doc, \"\\xd3XXXXXXXX\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n\n SECTION(\"float should pass\") {\n auto err = deserializeMsgPack(doc, \"\\xcaXXXX\");\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"double should fail\") {\n auto err = deserializeMsgPack(doc, \"\\xcbXXXXXXXX\");\n\n REQUIRE(err == DeserializationError::NoMemory);\n }\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/filter.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"deserializeMsgPack() filter\") {\n SpyingAllocator spy;\n JsonDocument doc(&spy);\n DeserializationError error;\n\n JsonDocument filter;\n DeserializationOption::Filter filterOpt(filter);\n\n SECTION(\"root is fixmap\") {\n SECTION(\"filter = {include:true,ignore:false)\") {\n filter[\"include\"] = true;\n filter[\"ignore\"] = false;\n\n SECTION(\"input truncated after ignored key\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\", 8, filterOpt);\n\n CHECK(error == DeserializationError::IncompleteInput);\n CHECK(doc.as() == \"{}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n });\n }\n\n SECTION(\"input truncated after inside skipped uint 8\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xCC\\x2A\\xA7include\\x2A\",\n 9, filterOpt);\n\n CHECK(error == DeserializationError::IncompleteInput);\n CHECK(doc.as() == \"{}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n });\n }\n\n SECTION(\"input truncated after before skipped string size\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xd9\", 9, filterOpt);\n\n CHECK(error == DeserializationError::IncompleteInput);\n CHECK(doc.as() == \"{}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n });\n }\n\n SECTION(\"input truncated after before skipped ext size\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xC7\", 9, filterOpt);\n\n CHECK(error == DeserializationError::IncompleteInput);\n CHECK(doc.as() == \"{}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n });\n }\n\n SECTION(\"skip nil\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xC0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"reject 0xc1\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xC1\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::InvalidInput);\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n });\n }\n\n SECTION(\"skip false\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xC2\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip true\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xC3\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip positive fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip negative fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xFF\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip uint 8\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xCC\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip int 8\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA6ignore\\xD0\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip uint 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xcd\\x30\\x39\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip int 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xD1\\xCF\\xC7\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip uint 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xCE\\x12\\x34\\x56\\x78\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip int 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xD2\\xB6\\x69\\xFD\\x2E\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip uint 64\") {\n error = deserializeMsgPack(\n doc,\n \"\\x82\\xA6ignore\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip int 64\") {\n error = deserializeMsgPack(\n doc,\n \"\\x82\\xA6ignore\\xD3\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip float 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xCA\\x40\\x48\\xF5\\xC3\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip float 64\") {\n error = deserializeMsgPack(\n doc,\n \"\\x82\\xA6ignore\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\\x12\\x6F\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixstr\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xABhello world\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip str 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xd9\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip str 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xda\\x00\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip str 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xdb\\x00\\x00\\x00\\x05hello\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip bin 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xC4\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip bin 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xC5\\x00\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip bin 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xC6\\x00\\x00\\x00\\x05hello\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixarray\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\x92\\x01\\x02\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip array 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\xDC\\x00\\x02\\xA5hello\\xA5world\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip array 32\") {\n error = deserializeMsgPack(\n doc,\n \"\\x82\\xA6ignore\"\n \"\\xDD\\x00\\x00\\x00\\x02\\xCA\\x00\\x00\\x00\\x00\\xCA\\x40\\x48\\xF5\\xC3\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixmap\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA6ignore\\x82\\xA3one\\x01\\xA3two\\x02\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip map 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xDE\\x00\\x02\\xA1H\\xA5hello\\xA1W\\xA5world\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip map 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xDF\\x00\\x00\\x00\\x02\"\n \"\\xA4zero\\xCA\\x00\\x00\\x00\\x00\"\n \"\\xA2pi\\xCA\\x40\\x48\\xF5\\xC3\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixext 1\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xd4\\x01\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixext 2\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xd5\\x01\\x02\\x03\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixext 4\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xd6\\x01\\x02\\x03\\x04\\x05\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixext 8\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xd7\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip fixext 16\") {\n error =\n deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xd8\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\"\n \"\\x0B\\x0C\\x0D\\x0E\\x0F\\x10\\x11\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip ext 8\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xc7\\x02\\x00\\x01\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip ext 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xc8\\x00\\x02\\x00\\x01\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n\n SECTION(\"skip ext 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA6ignore\"\n \"\\xc9\\x00\\x00\\x00\\x02\\x00\\x01\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"ignore\")),\n Deallocate(sizeofString(\"ignore\")),\n Allocate(sizeofString(\"include\")),\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofObject(1)),\n });\n }\n }\n\n SECTION(\"Filter = {arronly:[{measure:true}],include:true}\") {\n filter[\"onlyarr\"][0][\"measure\"] = true;\n filter[\"include\"] = true;\n\n CAPTURE(filter.as());\n\n SECTION(\"include fixarray\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\\x92\"\n \"\\x82\\xA8location\\x01\\xA7measure\\x02\"\n \"\\x82\\xA8location\\x02\\xA7measure\\x04\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyarr\\\":[{\\\"measure\\\":2},{\\\"measure\\\":4}],\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofArray(2) +\n 2 * sizeofObject(1)),\n });\n }\n\n SECTION(\"include array 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\"\n \"\\xDC\\x00\\x02\"\n \"\\x82\\xA8location\\x01\\xA7measure\\x02\"\n \"\\x82\\xA8location\\x02\\xA7measure\\x04\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyarr\\\":[{\\\"measure\\\":2},{\\\"measure\\\":4}],\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofArray(2) +\n 2 * sizeofObject(1)),\n });\n }\n\n SECTION(\"include array 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\"\n \"\\xDD\\x00\\x00\\x00\\x02\"\n \"\\x82\\xA8location\\x01\\xA7measure\\x02\"\n \"\\x82\\xA8location\\x02\\xA7measure\\x04\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyarr\\\":[{\\\"measure\\\":2},{\\\"measure\\\":4}],\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofArray(2) +\n 2 * sizeofObject(1)),\n });\n }\n\n SECTION(\"skip null\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyarr\\xC0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip false\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyarr\\xC2\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip true\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyarr\\xC3\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip positive fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyarr\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip negative fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyarr\\xFF\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xCC\\x2A\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xcd\\x30\\x39\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xCE\\x12\\x34\\x56\\x78\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\"\n \"\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xD0\\x2A\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xD1\\xCF\\xC7\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xD2\\xB6\\x69\\xFD\\x2E\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\\xD3\\x12\\x34\\x56\\x78\\x9A\\xBC\"\n \"\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip float 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xCA\\x40\\x48\\xF5\\xC3\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip float 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\"\n \"\\x12\\x6F\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip fixstr\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xABhello world\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip str 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xd9\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n }\n\n SECTION(\"skip str 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xda\\x00\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n }\n\n SECTION(\"skip str 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\xdb\\x00\\x00\\x00\\x05hello\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip fixmap\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyarr\\x82\\xA3one\\x01\\xA3two\\x02\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"one\")),\n Deallocate(sizeofString(\"one\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip map 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\"\n \"\\xDE\\x00\\x02\\xA1H\\xA5hello\\xA1W\\xA5world\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"H\")),\n Deallocate(sizeofString(\"H\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip map 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyarr\"\n \"\\xDF\\x00\\x00\\x00\\x02\"\n \"\\xA4zero\\xCA\\x00\\x00\\x00\\x00\"\n \"\\xA2pi\\xCA\\x40\\x48\\xF5\\xC3\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyarr\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"zero\")),\n Deallocate(sizeofString(\"zero\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n }\n }\n\n SECTION(\"root is fixarray\") {\n SECTION(\"filter = [false, true]\") {\n filter[0] = false; // only the first elment of the filter matters\n filter[1] = true; // so this one is ignored\n\n SECTION(\"input = [1,2,3]\") {\n error = deserializeMsgPack(doc, \"\\x93\\x01\\x02\\x03\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"[]\");\n CHECK(spy.log() == AllocatorLog());\n }\n }\n\n SECTION(\"filter = [true, false]\") {\n filter[0] = true; // only the first elment of the filter matters\n filter[1] = false; // so this one is ignored\n\n SECTION(\"input = [1,2,3]\") {\n error = deserializeMsgPack(doc, \"\\x93\\x01\\x02\\x03\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"[1,2,3]\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofArray(3)),\n });\n }\n }\n }\n\n SECTION(\"Filter = {onlyobj:{measure:true},include:true}\") {\n filter[\"onlyobj\"][\"measure\"] = true;\n filter[\"include\"] = true;\n\n CAPTURE(filter.as());\n\n SECTION(\"include fixmap\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\"\n \"\\x82\\xA8location\\x01\\xA7measure\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyobj\\\":{\\\"measure\\\":2},\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyobj\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofObject(1)),\n });\n }\n\n SECTION(\"include map 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\"\n \"\\xDE\\x00\\x02\\xA8location\\x01\\xA7measure\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyobj\\\":{\\\"measure\\\":2},\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyobj\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofObject(1)),\n });\n }\n\n SECTION(\"include map 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\"\n \"\\xDF\\x00\\x00\\x00\\x02\"\n \"\\xA8location\\x01\\xA7measure\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() ==\n \"{\\\"onlyobj\\\":{\\\"measure\\\":2},\\\"include\\\":42}\");\n CHECK(spy.log() ==\n AllocatorLog{\n Allocate(sizeofString(\"onlyobj\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"location\")),\n Reallocate(sizeofString(\"location\"), sizeofString(\"measure\")),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2) + sizeofObject(1)),\n });\n }\n\n SECTION(\"skip null\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xC0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip false\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xC2\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip true\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xC3\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip positive fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip negative fixint\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xFF\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 8\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xCC\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xcd\\x30\\x39\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xCE\\x12\\x34\\x56\\x78\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip uint 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\"\n \"\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 8\") {\n error = deserializeMsgPack(doc, \"\\x82\\xA7onlyobj\\xD0\\x2A\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xD1\\xCF\\xC7\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xD2\\xB6\\x69\\xFD\\x2E\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip int 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\\xD3\\x12\\x34\\x56\\x78\\x9A\\xBC\"\n \"\\xDE\\xF0\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip float 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xCA\\x40\\x48\\xF5\\xC3\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip float 64\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\"\n \"\\x12\\x6F\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip fixstr\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xABhello world\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip str 8\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xd9\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n }\n\n SECTION(\"skip str 16\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xda\\x00\\x05hello\\xA7include\\x2A\", filterOpt);\n\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n }\n\n SECTION(\"skip str 32\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\xdb\\x00\\x00\\x00\\x05hello\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip fixarray\") {\n error = deserializeMsgPack(\n doc, \"\\x82\\xA7onlyobj\\x92\\x01\\x02\\xA7include\\x2A\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip array 16\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\\xDC\\x00\\x01\\xA7\"\n \"example\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n\n SECTION(\"skip array 32\") {\n error = deserializeMsgPack(doc,\n \"\\x82\\xA7onlyobj\"\n \"\\xDD\\x00\\x00\\x00\\x02\\x01\\x02\"\n \"\\xA7include\\x2A\",\n filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"onlyobj\\\":null,\\\"include\\\":42}\");\n CHECK(spy.log() == AllocatorLog{\n Allocate(sizeofString(\"onlyarr\")),\n Allocate(sizeofPool()),\n Allocate(sizeofString(\"include\")),\n Reallocate(sizeofPool(), sizeofObject(2)),\n });\n }\n }\n\n SECTION(\"filter = true\") {\n filter.set(true);\n\n error = deserializeMsgPack(doc, \"\\x90\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.is() == true);\n CHECK(doc.size() == 0);\n }\n\n SECTION(\"filter = false\") {\n filter.set(false);\n\n SECTION(\"input = fixarray\") {\n error = deserializeMsgPack(doc, \"\\x92\\x01\\x02\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.isNull() == true);\n }\n\n SECTION(\"input = array 16\") {\n error = deserializeMsgPack(doc, \"\\xDC\\x00\\x02\\x01\\x02\", filterOpt);\n\n CHECK(error == DeserializationError::Ok);\n CHECK(doc.isNull() == true);\n }\n\n SECTION(\"array too deep\") {\n error = deserializeMsgPack(doc, \"\\x91\\x91\\x91\\x91\\x91\", 5, filterOpt,\n DeserializationOption::NestingLimit(4));\n\n CHECK(error == DeserializationError::TooDeep);\n }\n\n SECTION(\"object too deep\") {\n error = deserializeMsgPack(\n doc, \"\\x81\\xA1z\\x81\\xA1z\\x81\\xA1z\\x81\\xA1z\\x81\\xA1z\", 15, filterOpt,\n DeserializationOption::NestingLimit(4));\n\n CHECK(error == DeserializationError::TooDeep);\n }\n }\n}\n\nTEST_CASE(\"Zero-copy mode\") { // issue #1697\n char input[] = \"\\x82\\xA7include\\x01\\xA6ignore\\x02\";\n\n JsonDocument filter;\n filter[\"include\"] = true;\n\n JsonDocument doc;\n DeserializationError err =\n deserializeMsgPack(doc, input, 18, DeserializationOption::Filter(filter));\n\n CHECK(err == DeserializationError::Ok);\n CHECK(doc.as() == \"{\\\"include\\\":1}\");\n}\n\nTEST_CASE(\"Overloads\") {\n JsonDocument doc;\n JsonDocument filter;\n\n using namespace DeserializationOption;\n\n // deserializeMsgPack(..., Filter)\n\n SECTION(\"const char*, Filter\") {\n deserializeMsgPack(doc, \"{}\", Filter(filter));\n }\n\n SECTION(\"const char*, size_t, Filter\") {\n deserializeMsgPack(doc, \"{}\", 2, Filter(filter));\n }\n\n SECTION(\"const std::string&, Filter\") {\n deserializeMsgPack(doc, \"{}\"_s, Filter(filter));\n }\n\n SECTION(\"std::istream&, Filter\") {\n std::stringstream s(\"{}\");\n deserializeMsgPack(doc, s, Filter(filter));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], Filter\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeMsgPack(doc, vla, Filter(filter));\n }\n#endif\n\n // deserializeMsgPack(..., Filter, NestingLimit)\n\n SECTION(\"const char*, Filter, NestingLimit\") {\n deserializeMsgPack(doc, \"{}\", Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"const char*, size_t, Filter, NestingLimit\") {\n deserializeMsgPack(doc, \"{}\", 2, Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"const std::string&, Filter, NestingLimit\") {\n deserializeMsgPack(doc, \"{}\"_s, Filter(filter), NestingLimit(5));\n }\n\n SECTION(\"std::istream&, Filter, NestingLimit\") {\n std::stringstream s(\"{}\");\n deserializeMsgPack(doc, s, Filter(filter), NestingLimit(5));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], Filter, NestingLimit\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeMsgPack(doc, vla, Filter(filter), NestingLimit(5));\n }\n#endif\n\n // deserializeMsgPack(..., NestingLimit, Filter)\n\n SECTION(\"const char*, NestingLimit, Filter\") {\n deserializeMsgPack(doc, \"{}\", NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"const char*, size_t, NestingLimit, Filter\") {\n deserializeMsgPack(doc, \"{}\", 2, NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"const std::string&, NestingLimit, Filter\") {\n deserializeMsgPack(doc, \"{}\"_s, NestingLimit(5), Filter(filter));\n }\n\n SECTION(\"std::istream&, NestingLimit, Filter\") {\n std::stringstream s(\"{}\");\n deserializeMsgPack(doc, s, NestingLimit(5), Filter(filter));\n }\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\n SECTION(\"char[n], NestingLimit, Filter\") {\n size_t i = 4;\n char vla[i];\n strcpy(vla, \"{}\");\n deserializeMsgPack(doc, vla, NestingLimit(5), Filter(filter));\n }\n#endif\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/input_types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"CustomReader.hpp\"\n#include \"Literals.hpp\"\n\nusing ArduinoJson::detail::sizeofObject;\n\nTEST_CASE(\"deserializeMsgPack(const std::string&)\") {\n JsonDocument doc;\n\n SECTION(\"should accept const string\") {\n const std::string input(\"\\x92\\x01\\x02\");\n\n DeserializationError err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"should accept temporary string\") {\n DeserializationError err = deserializeMsgPack(doc, \"\\x92\\x01\\x02\"_s);\n\n REQUIRE(err == DeserializationError::Ok);\n }\n\n SECTION(\"should duplicate content\") {\n std::string input(\"\\x91\\xA5hello\");\n\n DeserializationError err = deserializeMsgPack(doc, input);\n input[2] = 'X'; // alter the string tomake sure we made a copy\n\n JsonArray array = doc.as();\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(\"hello\"_s == array[0]);\n }\n\n SECTION(\"should accept a zero in input\") {\n DeserializationError err = deserializeMsgPack(doc, \"\\x92\\x00\\x02\"_s);\n\n REQUIRE(err == DeserializationError::Ok);\n JsonArray arr = doc.as();\n REQUIRE(arr[0] == 0);\n REQUIRE(arr[1] == 2);\n }\n}\n\nTEST_CASE(\"deserializeMsgPack(std::istream&)\") {\n JsonDocument doc;\n\n SECTION(\"should accept a zero in input\") {\n std::istringstream input(\"\\x92\\x00\\x02\"_s);\n\n DeserializationError err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::Ok);\n JsonArray arr = doc.as();\n REQUIRE(arr[0] == 0);\n REQUIRE(arr[1] == 2);\n }\n\n SECTION(\"should detect incomplete input\") {\n std::istringstream input(\"\\x92\\x00\\x02\");\n\n DeserializationError err = deserializeMsgPack(doc, input);\n\n REQUIRE(err == DeserializationError::IncompleteInput);\n }\n}\n\n#ifdef HAS_VARIABLE_LENGTH_ARRAY\nTEST_CASE(\"deserializeMsgPack(VLA)\") {\n size_t i = 16;\n char vla[i];\n memcpy(vla, \"\\xDE\\x00\\x01\\xA5Hello\\xA5world\", 15);\n\n JsonDocument doc;\n DeserializationError err = deserializeMsgPack(doc, vla);\n\n REQUIRE(err == DeserializationError::Ok);\n}\n#endif\n\nTEST_CASE(\"deserializeMsgPack(CustomReader)\") {\n JsonDocument doc;\n CustomReader reader(\"\\x92\\xA5Hello\\xA5world\");\n DeserializationError err = deserializeMsgPack(doc, reader);\n\n REQUIRE(err == DeserializationError::Ok);\n REQUIRE(doc.size() == 2);\n REQUIRE(doc[0] == \"Hello\");\n REQUIRE(doc[1] == \"world\");\n}\n" }, { "path": "extras/tests/MsgPackDeserializer/nestingLimit.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression);\n#define SHOULD_FAIL(expression) \\\n REQUIRE(DeserializationError::TooDeep == expression);\n\nTEST_CASE(\"JsonDeserializer nesting\") {\n JsonDocument doc;\n\n SECTION(\"Input = const char*\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeMsgPack(doc, \"\\xA1H\", nesting)); // \"H\"\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x90\", nesting)); // []\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x80\", nesting)); // {}\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeMsgPack(doc, \"\\x90\", nesting)); // {}\n SHOULD_WORK(deserializeMsgPack(doc, \"\\x80\", nesting)); // []\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x81\\xA1H\\x80\", nesting)); // {H:{}}\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x91\\x90\", nesting)); // [[]]\n }\n }\n\n SECTION(\"char* and size_t\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeMsgPack(doc, \"\\xA1H\", 2, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x90\", 1, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x80\", 1, nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeMsgPack(doc, \"\\x90\", 1, nesting));\n SHOULD_WORK(deserializeMsgPack(doc, \"\\x80\", 1, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x81\\xA1H\\x80\", 4, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, \"\\x91\\x90\", 2, nesting));\n }\n }\n\n SECTION(\"Input = std::string\") {\n using std::string;\n\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n SHOULD_WORK(deserializeMsgPack(doc, string(\"\\xA1H\"), nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, string(\"\\x90\"), nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, string(\"\\x80\"), nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n SHOULD_WORK(deserializeMsgPack(doc, string(\"\\x90\"), nesting));\n SHOULD_WORK(deserializeMsgPack(doc, string(\"\\x80\"), nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, string(\"\\x81\\xA1H\\x80\"), nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, string(\"\\x91\\x90\"), nesting));\n }\n }\n\n SECTION(\"Input = std::istream\") {\n SECTION(\"limit = 0\") {\n DeserializationOption::NestingLimit nesting(0);\n std::istringstream good(\"\\xA1H\"); // \"H\"\n std::istringstream bad(\"\\x90\"); // []\n SHOULD_WORK(deserializeMsgPack(doc, good, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, bad, nesting));\n }\n\n SECTION(\"limit = 1\") {\n DeserializationOption::NestingLimit nesting(1);\n std::istringstream good(\"\\x90\"); // []\n std::istringstream bad(\"\\x91\\x90\"); // [[]]\n SHOULD_WORK(deserializeMsgPack(doc, good, nesting));\n SHOULD_FAIL(deserializeMsgPack(doc, bad, nesting));\n }\n }\n}\n" }, { "path": "extras/tests/MsgPackSerializer/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(MsgPackSerializerTests\n\tdestination_types.cpp\n\tmeasure.cpp\n\tmisc.cpp\n\tserializeArray.cpp\n\tserializeObject.cpp\n\tserializeVariant.cpp\n)\n\nadd_test(MsgPackSerializer MsgPackSerializerTests)\n\nset_tests_properties(MsgPackSerializer\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/MsgPackSerializer/destination_types.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"serialize MsgPack to various destination types\") {\n JsonDocument doc;\n JsonObject object = doc.to();\n object[\"hello\"] = \"world\";\n const char* expected_result = \"\\x81\\xA5hello\\xA5world\";\n const size_t expected_length = 13;\n\n SECTION(\"std::string\") {\n std::string result;\n size_t len = serializeMsgPack(object, result);\n\n REQUIRE(expected_result == result);\n REQUIRE(expected_length == len);\n }\n\n /* SECTION(\"std::vector\") {\n std::vector result;\n size_t len = serializeMsgPack(object, result);\n\n REQUIRE(std::vector(expected_result, expected_result + 13) ==\n result);\n REQUIRE(expected_length == len);\n } */\n\n SECTION(\"char[] larger than needed\") {\n char result[64];\n memset(result, 42, sizeof(result));\n size_t len = serializeMsgPack(object, result);\n\n REQUIRE(expected_length == len);\n REQUIRE(std::string(expected_result, len) == std::string(result, len));\n REQUIRE(result[len] == 42);\n }\n\n SECTION(\"char[] of the right size\") { // #1545\n char result[13];\n size_t len = serializeMsgPack(object, result);\n\n REQUIRE(expected_length == len);\n REQUIRE(std::string(expected_result, len) == std::string(result, len));\n }\n\n SECTION(\"char*\") {\n char result[64];\n memset(result, 42, sizeof(result));\n size_t len = serializeMsgPack(object, result, 64);\n\n REQUIRE(expected_length == len);\n REQUIRE(std::string(expected_result, len) == std::string(result, len));\n REQUIRE(result[len] == 42);\n }\n}\n" }, { "path": "extras/tests/MsgPackSerializer/measure.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nTEST_CASE(\"measureMsgPack()\") {\n JsonDocument doc;\n JsonObject object = doc.to();\n object[\"hello\"] = \"world\";\n\n REQUIRE(measureMsgPack(doc) == 13);\n}\n" }, { "path": "extras/tests/MsgPackSerializer/misc.cpp", "content": "#include \n#include \n#include \n\ntemplate \nvoid check(T value, const std::string& expected) {\n JsonDocument doc;\n doc.to().set(value);\n char buffer[256] = \"\";\n size_t returnValue = serializeMsgPack(doc, buffer, sizeof(buffer));\n REQUIRE(expected == buffer);\n REQUIRE(expected.size() == returnValue);\n}\n\nTEST_CASE(\"serializeMsgPack(MemberProxy)\") {\n JsonDocument doc;\n deserializeJson(doc, \"{\\\"hello\\\":42}\");\n JsonObject obj = doc.as();\n std::string result;\n\n serializeMsgPack(obj[\"hello\"], result);\n\n REQUIRE(result == \"*\");\n}\n\nTEST_CASE(\"serializeMsgPack(ElementProxy)\") {\n JsonDocument doc;\n deserializeJson(doc, \"[42]\");\n JsonArray arr = doc.as();\n std::string result;\n\n serializeMsgPack(arr[0], result);\n\n REQUIRE(result == \"*\");\n}\n\nTEST_CASE(\"serializeMsgPack(JsonVariantSubscript)\") {\n JsonDocument doc;\n deserializeJson(doc, \"[42]\");\n JsonVariant var = doc.as();\n std::string result;\n\n serializeMsgPack(var[0], result);\n\n REQUIRE(result == \"*\");\n}\n" }, { "path": "extras/tests/MsgPackSerializer/serializeArray.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_SLOT_ID_SIZE 4 // required to reach 65536 elements\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\nstatic void check(const JsonArray array, const char* expected_data,\n size_t expected_len) {\n std::string expected(expected_data, expected_data + expected_len);\n std::string actual;\n size_t len = serializeMsgPack(array, actual);\n CAPTURE(array);\n REQUIRE(len == expected_len);\n REQUIRE(actual == expected);\n}\n\ntemplate \nstatic void check(const JsonArray array, const char (&expected_data)[N]) {\n const size_t expected_len = N - 1;\n check(array, expected_data, expected_len);\n}\n\nstatic void check(const JsonArray array, const std::string& expected) {\n check(array, expected.data(), expected.length());\n}\n\nTEST_CASE(\"serialize MsgPack array\") {\n JsonDocument doc;\n JsonArray array = doc.to();\n\n SECTION(\"empty\") {\n check(array, \"\\x90\");\n }\n\n SECTION(\"fixarray\") {\n array.add(\"hello\");\n array.add(\"world\");\n\n check(array, \"\\x92\\xA5hello\\xA5world\");\n }\n\n SECTION(\"array 16\") {\n for (int i = 0; i < 16; i++)\n array.add(i);\n\n check(array,\n \"\\xDC\\x00\\x10\\x00\\x01\\x02\\x03\\x04\\x05\\x06\\x07\\x08\\x09\\x0A\\x0B\\x0C\\x0D\"\n \"\\x0E\\x0F\");\n }\n\n SECTION(\"array 32\") {\n const char* nil = 0;\n for (int i = 0; i < 65536; i++)\n array.add(nil);\n REQUIRE(array.size() == 65536);\n\n check(array, \"\\xDD\\x00\\x01\\x00\\x00\"_s + std::string(65536, '\\xc0'));\n }\n}\n" }, { "path": "extras/tests/MsgPackSerializer/serializeObject.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Literals.hpp\"\n\nstatic void check(const JsonObject object, const char* expected_data,\n size_t expected_len) {\n std::string expected(expected_data, expected_data + expected_len);\n std::string actual;\n size_t len = serializeMsgPack(object, actual);\n CAPTURE(object);\n REQUIRE(len == expected_len);\n REQUIRE(actual == expected);\n}\n\ntemplate \nstatic void check(const JsonObject object, const char (&expected_data)[N]) {\n const size_t expected_len = N - 1;\n check(object, expected_data, expected_len);\n}\n\n// TODO: used by the commented test\n// static void check(const JsonObject object, const std::string& expected) {\n// check(object, expected.data(), expected.length());\n//}\n\nTEST_CASE(\"serialize MsgPack object\") {\n JsonDocument doc;\n JsonObject object = doc.to();\n\n SECTION(\"empty\") {\n check(object, \"\\x80\");\n }\n\n SECTION(\"fixmap\") {\n object[\"hello\"] = \"world\";\n\n check(object, \"\\x81\\xA5hello\\xA5world\");\n }\n\n SECTION(\"map 16\") {\n for (int i = 0; i < 16; ++i) {\n char key[16];\n snprintf(key, sizeof(key), \"i%X\", i);\n object[key] = i;\n }\n\n check(object,\n \"\\xDE\\x00\\x10\\xA2i0\\x00\\xA2i1\\x01\\xA2i2\\x02\\xA2i3\\x03\\xA2i4\\x04\\xA2i5\"\n \"\\x05\\xA2i6\\x06\\xA2i7\\x07\\xA2i8\\x08\\xA2i9\\x09\\xA2iA\\x0A\\xA2iB\\x0B\\xA2\"\n \"iC\\x0C\\xA2iD\\x0D\\xA2iE\\x0E\\xA2iF\\x0F\");\n }\n\n // TODO: improve performance and uncomment\n // SECTION(\"map 32\") {\n // std::string expected(\"\\xDF\\x00\\x01\\x00\\x00\", 5);\n //\n // for (int i = 0; i < 65536; ++i) {\n // char kv[16];\n // snprintf(kv, sizeof(kv), \"%04x\", i);\n // object[kv] = kv;\n // expected += '\\xA4';\n // expected += kv;\n // expected += '\\xA4';\n // expected += kv;\n // }\n //\n // check(object, expected);\n // }\n\n SECTION(\"serialized(const char*)\") {\n object[\"hello\"] = serialized(\"\\xDB\\x00\\x01\\x00\\x00\", 5);\n check(object, \"\\x81\\xA5hello\\xDB\\x00\\x01\\x00\\x00\");\n }\n\n SECTION(\"serialized(std::string)\") {\n object[\"hello\"] = serialized(\"\\xDB\\x00\\x01\\x00\\x00\"_s);\n check(object, \"\\x81\\xA5hello\\xDB\\x00\\x01\\x00\\x00\");\n }\n}\n" }, { "path": "extras/tests/MsgPackSerializer/serializeVariant.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \"Literals.hpp\"\n\ntemplate \nstatic void checkVariant(T value, const char* expected_data,\n size_t expected_len) {\n JsonDocument doc;\n JsonVariant variant = doc.to();\n variant.set(value);\n std::string expected(expected_data, expected_data + expected_len);\n std::string actual;\n size_t len = serializeMsgPack(variant, actual);\n CAPTURE(variant);\n REQUIRE(len == expected_len);\n REQUIRE(actual == expected);\n}\n\ntemplate \nstatic void checkVariant(T value, const char (&expected_data)[N]) {\n const size_t expected_len = N - 1;\n checkVariant(value, expected_data, expected_len);\n}\n\ntemplate \nstatic void checkVariant(T value, const std::string& expected) {\n checkVariant(value, expected.data(), expected.length());\n}\n\nTEST_CASE(\"serialize MsgPack value\") {\n SECTION(\"unbound\") {\n checkVariant(JsonVariant(), \"\\xC0\"); // we represent undefined as nil\n }\n\n SECTION(\"nil\") {\n const char* nil = 0; // ArduinoJson uses a string for null\n checkVariant(nil, \"\\xC0\");\n }\n\n SECTION(\"bool\") {\n checkVariant(false, \"\\xC2\");\n checkVariant(true, \"\\xC3\");\n }\n\n SECTION(\"positive fixint\") {\n SECTION(\"signed\") {\n checkVariant(0, \"\\x00\");\n checkVariant(127, \"\\x7F\");\n }\n SECTION(\"unsigned\") {\n checkVariant(0U, \"\\x00\");\n checkVariant(127U, \"\\x7F\");\n }\n }\n\n SECTION(\"uint 8\") {\n checkVariant(128, \"\\xCC\\x80\");\n checkVariant(255, \"\\xCC\\xFF\");\n }\n\n SECTION(\"uint 16\") {\n checkVariant(256, \"\\xCD\\x01\\x00\");\n checkVariant(0xFFFF, \"\\xCD\\xFF\\xFF\");\n }\n\n SECTION(\"uint 32\") {\n checkVariant(0x00010000U, \"\\xCE\\x00\\x01\\x00\\x00\");\n checkVariant(0x12345678U, \"\\xCE\\x12\\x34\\x56\\x78\");\n checkVariant(0xFFFFFFFFU, \"\\xCE\\xFF\\xFF\\xFF\\xFF\");\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"uint 64\") {\n checkVariant(0x0001000000000000U, \"\\xCF\\x00\\x01\\x00\\x00\\x00\\x00\\x00\\x00\");\n checkVariant(0x123456789ABCDEF0U, \"\\xCF\\x12\\x34\\x56\\x78\\x9A\\xBC\\xDE\\xF0\");\n checkVariant(0xFFFFFFFFFFFFFFFFU, \"\\xCF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\\xFF\");\n }\n#endif\n\n SECTION(\"negative fixint\") {\n checkVariant(-1, \"\\xFF\");\n checkVariant(-32, \"\\xE0\");\n }\n\n SECTION(\"int 8\") {\n checkVariant(-33, \"\\xD0\\xDF\");\n checkVariant(-128, \"\\xD0\\x80\");\n }\n\n SECTION(\"int 16\") {\n checkVariant(-129, \"\\xD1\\xFF\\x7F\");\n checkVariant(-32768, \"\\xD1\\x80\\x00\");\n }\n\n SECTION(\"int 32\") {\n checkVariant(-32769, \"\\xD2\\xFF\\xFF\\x7F\\xFF\");\n checkVariant(-2147483647 - 1, \"\\xD2\\x80\\x00\\x00\\x00\");\n }\n\n#if ARDUINOJSON_USE_LONG_LONG\n SECTION(\"int 64\") {\n checkVariant(int64_t(0xFEDCBA9876543210),\n \"\\xD3\\xFE\\xDC\\xBA\\x98\\x76\\x54\\x32\\x10\");\n }\n#endif\n\n SECTION(\"float 32\") {\n checkVariant(1.25, \"\\xCA\\x3F\\xA0\\x00\\x00\");\n checkVariant(9.22337204e+18f, \"\\xca\\x5f\\x00\\x00\\x00\");\n }\n\n SECTION(\"float 64\") {\n checkVariant(3.1415, \"\\xCB\\x40\\x09\\x21\\xCA\\xC0\\x83\\x12\\x6F\");\n }\n\n SECTION(\"fixstr\") {\n checkVariant(\"\", \"\\xA0\");\n checkVariant(\"hello world hello world hello !\",\n \"\\xBFhello world hello world hello !\");\n }\n\n SECTION(\"str 8\") {\n checkVariant(\"hello world hello world hello !!\",\n \"\\xD9\\x20hello world hello world hello !!\");\n }\n\n SECTION(\"str 16\") {\n std::string shortest(256, '?');\n checkVariant(shortest.c_str(), \"\\xDA\\x01\\x00\"_s + shortest);\n\n std::string longest(65535, '?');\n checkVariant(longest.c_str(), \"\\xDA\\xFF\\xFF\"_s + longest);\n }\n\n#if ARDUINOJSON_STRING_LENGTH_SIZE > 2\n SECTION(\"str 32\") {\n std::string shortest(65536, '?');\n checkVariant(shortest.c_str(), \"\\xDB\\x00\\x01\\x00\\x00\"_s + shortest);\n }\n#endif\n\n SECTION(\"serialized(const char*)\") {\n checkVariant(serialized(\"\\xDA\\xFF\\xFF\"), \"\\xDA\\xFF\\xFF\");\n checkVariant(serialized(\"\\xDB\\x00\\x01\\x00\\x00\", 5), \"\\xDB\\x00\\x01\\x00\\x00\");\n }\n\n SECTION(\"bin 8\") {\n checkVariant(MsgPackBinary(\"?\", 1), \"\\xC4\\x01?\");\n }\n\n SECTION(\"bin 16\") {\n auto str = std::string(256, '?');\n checkVariant(MsgPackBinary(str.data(), str.size()), \"\\xC5\\x01\\x00\"_s + str);\n }\n\n // bin 32 is tested in string_length_size_4.cpp\n\n SECTION(\"fixext 1\") {\n checkVariant(MsgPackExtension(1, \"\\x02\", 1), \"\\xD4\\x01\\x02\");\n }\n\n SECTION(\"fixext 2\") {\n checkVariant(MsgPackExtension(1, \"\\x03\\x04\", 2), \"\\xD5\\x01\\x03\\x04\");\n }\n\n SECTION(\"fixext 4\") {\n checkVariant(MsgPackExtension(1, \"\\x05\\x06\\x07\\x08\", 4),\n \"\\xD6\\x01\\x05\\x06\\x07\\x08\");\n }\n\n SECTION(\"fixext 8\") {\n checkVariant(MsgPackExtension(1, \"????????\", 8), \"\\xD7\\x01????????\");\n }\n\n SECTION(\"fixext 16\") {\n checkVariant(MsgPackExtension(1, \"????????????????\", 16),\n \"\\xD8\\x01????????????????\");\n }\n\n SECTION(\"ext 8\") {\n checkVariant(MsgPackExtension(2, \"???\", 3), \"\\xC7\\x03\\x02???\");\n checkVariant(MsgPackExtension(2, \"?????\", 5), \"\\xC7\\x05\\x02?????\");\n checkVariant(MsgPackExtension(2, \"???????\", 7), \"\\xC7\\x07\\x02???????\");\n checkVariant(MsgPackExtension(2, \"?????????\", 9), \"\\xC7\\x09\\x02?????????\");\n checkVariant(MsgPackExtension(2, \"???????????????\", 15),\n \"\\xC7\\x0F\\x02???????????????\");\n checkVariant(MsgPackExtension(2, \"?????????????????\", 17),\n \"\\xC7\\x11\\x02?????????????????\");\n }\n\n SECTION(\"ext 16\") {\n auto str = std::string(256, '?');\n checkVariant(MsgPackExtension(2, str.data(), str.size()),\n \"\\xC8\\x01\\x00\\x02\"_s + str);\n }\n\n SECTION(\"serialize round double as integer\") { // Issue #1718\n checkVariant(-32768.0, \"\\xD1\\x80\\x00\");\n checkVariant(-129.0, \"\\xD1\\xFF\\x7F\");\n checkVariant(-128.0, \"\\xD0\\x80\");\n checkVariant(-33.0, \"\\xD0\\xDF\");\n checkVariant(-32.0, \"\\xE0\");\n checkVariant(-1.0, \"\\xFF\");\n checkVariant(0.0, \"\\x00\");\n checkVariant(127.0, \"\\x7F\");\n checkVariant(128.0, \"\\xCC\\x80\");\n checkVariant(255.0, \"\\xCC\\xFF\");\n checkVariant(256.0, \"\\xCD\\x01\\x00\");\n }\n}\n" }, { "path": "extras/tests/Numbers/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(NumbersTests\n\tconvertNumber.cpp\n\tdecomposeFloat.cpp\n\tparseDouble.cpp\n\tparseFloat.cpp\n\tparseInteger.cpp\n\tparseNumber.cpp\n)\n\nadd_test(Numbers NumbersTests)\n\nset_tests_properties(Numbers\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/Numbers/convertNumber.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"canConvertNumber()\") {\n SECTION(\"int8_t -> int8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(-128) == true);\n }\n\n SECTION(\"int8_t -> int16_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(-128) == true);\n }\n\n SECTION(\"int8_t -> uint8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(-128) == false);\n }\n\n SECTION(\"int8_t -> uint16_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(-128) == false);\n }\n\n SECTION(\"int16_t -> int8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(128) == false);\n CHECK(canConvertNumber(-128) == true);\n CHECK(canConvertNumber(-129) == false);\n }\n\n SECTION(\"int16_t -> uint8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(255) == true);\n CHECK(canConvertNumber(256) == false);\n CHECK(canConvertNumber(-1) == false);\n }\n\n SECTION(\"uint8_t -> int8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(128) == false);\n CHECK(canConvertNumber(255) == false);\n }\n\n SECTION(\"uint8_t -> int16_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(128) == true);\n CHECK(canConvertNumber(255) == true);\n }\n\n SECTION(\"uint8_t -> uint8_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(128) == true);\n CHECK(canConvertNumber(255) == true);\n }\n\n SECTION(\"uint8_t -> uint16_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(127) == true);\n CHECK(canConvertNumber(128) == true);\n CHECK(canConvertNumber(255) == true);\n }\n\n SECTION(\"float -> int32_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-2.147483904e9f) == false);\n CHECK(canConvertNumber(-2.147483648e+9f) == true);\n CHECK(canConvertNumber(2.14748352e+9f) == true);\n CHECK(canConvertNumber(2.14748365e+9f) == false);\n }\n\n SECTION(\"double -> int32_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-2.147483649e+9) == false);\n CHECK(canConvertNumber(-2.147483648e+9) == true);\n CHECK(canConvertNumber(2.147483647e+9) == true);\n CHECK(canConvertNumber(2.147483648e+9) == false);\n }\n\n SECTION(\"float -> uint32_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-1.401298e-45f) == false);\n CHECK(canConvertNumber(4.29496704e+9f) == true);\n CHECK(canConvertNumber(4.294967296e+9f) == false);\n }\n\n SECTION(\"float -> int64_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-9.22337204e+18f) == true);\n CHECK(canConvertNumber(9.22337149e+18f) == true);\n CHECK(canConvertNumber(9.22337204e+18f) == false);\n }\n\n SECTION(\"double -> int64_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-9.2233720368547758e+18) == true);\n CHECK(canConvertNumber(9.2233720368547748e+18) == true);\n CHECK(canConvertNumber(9.2233720368547758e+18) == false);\n }\n\n SECTION(\"float -> uint64_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-1.401298e-45f) == false);\n CHECK(canConvertNumber(1.84467429741979238e+19f) == true);\n CHECK(canConvertNumber(1.844674407370955161e+19f) ==\n false);\n }\n\n SECTION(\"double -> uint64_t\") {\n CHECK(canConvertNumber(0) == true);\n CHECK(canConvertNumber(-4.9406564584124e-324) == false);\n CHECK(canConvertNumber(1.844674407370954958e+19) == true);\n CHECK(canConvertNumber(1.844674407370955166e+19) ==\n false);\n }\n}\n" }, { "path": "extras/tests/Numbers/decomposeFloat.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"decomposeFloat()\") {\n SECTION(\"1.7976931348623157E+308\") {\n auto parts = decomposeFloat(1.7976931348623157E+308, 9);\n REQUIRE(parts.integral == 1);\n REQUIRE(parts.decimal == 797693135);\n REQUIRE(parts.decimalPlaces == 9);\n REQUIRE(parts.exponent == 308);\n }\n\n SECTION(\"4.94065645841247e-324\") {\n auto parts = decomposeFloat(4.94065645841247e-324, 9);\n REQUIRE(parts.integral == 4);\n REQUIRE(parts.decimal == 940656458);\n REQUIRE(parts.decimalPlaces == 9);\n REQUIRE(parts.exponent == -324);\n }\n\n SECTION(\"3.4E+38\") {\n auto parts = decomposeFloat(3.4E+38f, 6);\n REQUIRE(parts.integral == 3);\n REQUIRE(parts.decimal == 4);\n REQUIRE(parts.decimalPlaces == 1);\n REQUIRE(parts.exponent == 38);\n }\n\n SECTION(\"1.17549435e−38\") {\n auto parts = decomposeFloat(1.17549435e-38f, 6);\n REQUIRE(parts.integral == 1);\n REQUIRE(parts.decimal == 175494);\n REQUIRE(parts.decimalPlaces == 6);\n REQUIRE(parts.exponent == -38);\n }\n}\n" }, { "path": "extras/tests/Numbers/parseDouble.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_USE_DOUBLE 1\n#define ARDUINOJSON_ENABLE_NAN 1\n#define ARDUINOJSON_ENABLE_INFINITY 1\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nvoid checkDouble(const char* input, double expected) {\n CAPTURE(input);\n REQUIRE(parseNumber(input) == Approx(expected));\n}\n\nvoid checkDoubleNaN(const char* input) {\n CAPTURE(input);\n double result = parseNumber(input);\n REQUIRE(result != result);\n}\n\nvoid checkDoubleInf(const char* input, bool negative) {\n CAPTURE(input);\n double x = parseNumber(input);\n if (negative)\n REQUIRE(x < 0);\n else\n REQUIRE(x > 0);\n REQUIRE(x == x); // not a NaN\n REQUIRE(x * 2 == x); // a property of infinity\n}\n\nTEST_CASE(\"parseNumber()\") {\n SECTION(\"Short_NoExponent\") {\n checkDouble(\"3.14\", 3.14);\n checkDouble(\"-3.14\", -3.14);\n checkDouble(\"+3.14\", +3.14);\n }\n\n SECTION(\"Short_NoDot\") {\n checkDouble(\"1E+308\", 1E+308);\n checkDouble(\"-1E+308\", -1E+308);\n checkDouble(\"+1E-308\", +1E-308);\n checkDouble(\"+1e+308\", +1e+308);\n checkDouble(\"-1e-308\", -1e-308);\n }\n\n SECTION(\"Max\") {\n checkDouble(\".017976931348623147e+310\", 1.7976931348623147e+308);\n checkDouble(\".17976931348623147e+309\", 1.7976931348623147e+308);\n checkDouble(\"1.7976931348623147e+308\", 1.7976931348623147e+308);\n checkDouble(\"17.976931348623147e+307\", 1.7976931348623147e+308);\n checkDouble(\"179.76931348623147e+306\", 1.7976931348623147e+308);\n }\n\n SECTION(\"Min\") {\n checkDouble(\".022250738585072014e-306\", 2.2250738585072014e-308);\n checkDouble(\".22250738585072014e-307\", 2.2250738585072014e-308);\n checkDouble(\"2.2250738585072014e-308\", 2.2250738585072014e-308);\n checkDouble(\"22.250738585072014e-309\", 2.2250738585072014e-308);\n checkDouble(\"222.50738585072014e-310\", 2.2250738585072014e-308);\n }\n\n SECTION(\"VeryLong\") {\n checkDouble(\"0.00000000000000000000000000000001\", 1e-32);\n checkDouble(\"100000000000000000000000000000000.0\", 1e+32);\n checkDouble(\n \"100000000000000000000000000000000.00000000000000000000000000000\",\n 1e+32);\n }\n\n SECTION(\"MantissaTooLongToFit\") {\n checkDouble(\"0.179769313486231571111111111111\", 0.17976931348623157);\n checkDouble(\"17976931348623157.11111111111111\", 17976931348623157.0);\n checkDouble(\"1797693.134862315711111111111111\", 1797693.1348623157);\n\n checkDouble(\"-0.179769313486231571111111111111\", -0.17976931348623157);\n checkDouble(\"-17976931348623157.11111111111111\", -17976931348623157.0);\n checkDouble(\"-1797693.134862315711111111111111\", -1797693.1348623157);\n }\n\n SECTION(\"ExponentTooBig\") {\n checkDoubleInf(\"1e309\", false);\n checkDoubleInf(\"-1e309\", true);\n checkDoubleInf(\"1e65535\", false);\n checkDouble(\"1e-65535\", 0.0);\n }\n\n SECTION(\"NaN\") {\n checkDoubleNaN(\"NaN\");\n checkDoubleNaN(\"nan\");\n }\n\n SECTION(\"Overflow exponent with decimal part\") { // Issue #2220\n checkDoubleNaN(\n \"0.000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000001\");\n }\n\n SECTION(\"Overflow exponent with integral part\") {\n checkDoubleNaN(\n \"10000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\"\n \"00000000000000000000000000000000000000000000000000\");\n }\n}\n" }, { "path": "extras/tests/Numbers/parseFloat.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#define ARDUINOJSON_ENABLE_NAN 1\n#define ARDUINOJSON_ENABLE_INFINITY 1\n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nvoid checkFloat(const char* input, float expected) {\n CAPTURE(input);\n auto result = parseNumber(input);\n REQUIRE(result.type() == NumberType::Float);\n REQUIRE(result.asFloat() == Approx(expected));\n}\n\nvoid checkFloatNaN(const char* input) {\n CAPTURE(input);\n float result = parseNumber(input);\n REQUIRE(result != result);\n}\n\nvoid checkFloatInf(const char* input, bool negative) {\n CAPTURE(input);\n float x = parseNumber(input);\n if (negative)\n REQUIRE(x < 0);\n else\n REQUIRE(x > 0);\n REQUIRE(x == x); // not a NaN\n REQUIRE(x * 2 == x); // a property of infinity\n}\n\nTEST_CASE(\"parseNumber()\") {\n SECTION(\"Float_Short_NoExponent\") {\n checkFloat(\"3.14\", 3.14f);\n checkFloat(\"-3.14\", -3.14f);\n checkFloat(\"+3.14\", +3.14f);\n }\n\n SECTION(\"Short_NoDot\") {\n checkFloat(\"1E+38\", 1E+38f);\n checkFloat(\"-1E+38\", -1E+38f);\n checkFloat(\"+1E-38\", +1E-38f);\n checkFloat(\"+1e+38\", +1e+38f);\n checkFloat(\"-1e-38\", -1e-38f);\n }\n\n SECTION(\"Max\") {\n checkFloat(\"340.2823e+36\", 3.402823e+38f);\n checkFloat(\"34.02823e+37\", 3.402823e+38f);\n checkFloat(\"3.402823e+38\", 3.402823e+38f);\n checkFloat(\"0.3402823e+39\", 3.402823e+38f);\n checkFloat(\"0.03402823e+40\", 3.402823e+38f);\n checkFloat(\"0.003402823e+41\", 3.402823e+38f);\n }\n\n SECTION(\"VeryLong\") {\n checkFloat(\"0.00000000000000000000000000000001\", 1e-32f);\n\n // The following don't work because they have many digits so parseNumber()\n // treats them as double. But it's not an issue because JsonVariant will use\n // a float to store them.\n //\n // checkFloat(\"100000000000000000000000000000000.0\", 1e+32f);\n // checkFloat(\n // \"100000000000000000000000000000000.00000000000000000000000000000\",\n // 1e+32f);\n }\n\n SECTION(\"NaN\") {\n checkFloatNaN(\"NaN\");\n checkFloatNaN(\"nan\");\n }\n\n SECTION(\"Infinity\") {\n checkFloatInf(\"Infinity\", false);\n checkFloatInf(\"+Infinity\", false);\n checkFloatInf(\"-Infinity\", true);\n checkFloatInf(\"inf\", false);\n checkFloatInf(\"+inf\", false);\n checkFloatInf(\"-inf\", true);\n }\n}\n" }, { "path": "extras/tests/Numbers/parseInteger.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\ntemplate \nvoid checkInteger(const char* input, T expected) {\n CAPTURE(input);\n T actual = parseNumber(input);\n REQUIRE(expected == actual);\n}\n\nTEST_CASE(\"parseNumber()\") {\n checkInteger(\"-128\", -128);\n checkInteger(\"127\", 127);\n checkInteger(\"+127\", 127);\n checkInteger(\"3.14\", 3);\n checkInteger(\"x42\", 0);\n checkInteger(\"128\", 0); // overflow\n checkInteger(\"-129\", 0); // overflow\n}\n\nTEST_CASE(\"parseNumber()\") {\n checkInteger(\"-32768\", -32768);\n checkInteger(\"32767\", 32767);\n checkInteger(\"+32767\", 32767);\n checkInteger(\"3.14\", 3);\n checkInteger(\"x42\", 0);\n checkInteger(\"-32769\", 0); // overflow\n checkInteger(\"32768\", 0); // overflow\n}\n\nTEST_CASE(\"parseNumber()\") {\n checkInteger(\"-2147483648\", (-2147483647 - 1));\n checkInteger(\"2147483647\", 2147483647);\n checkInteger(\"+2147483647\", 2147483647);\n checkInteger(\"3.14\", 3);\n checkInteger(\"x42\", 0);\n checkInteger(\"-2147483649\", 0); // overflow\n checkInteger(\"2147483648\", 0); // overflow\n}\n\nTEST_CASE(\"parseNumber()\") {\n checkInteger(\"0\", 0);\n checkInteger(\"-0\", 0);\n checkInteger(\"255\", 255);\n checkInteger(\"+255\", 255);\n checkInteger(\"3.14\", 3);\n checkInteger(\"x42\", 0);\n checkInteger(\"-1\", 0);\n checkInteger(\"256\", 0);\n}\n\nTEST_CASE(\"parseNumber()\") {\n checkInteger(\"0\", 0);\n checkInteger(\"65535\", 65535);\n checkInteger(\"+65535\", 65535);\n checkInteger(\"3.14\", 3);\n // checkInteger(\" 42\", 0);\n checkInteger(\"x42\", 0);\n checkInteger(\"-1\", 0);\n checkInteger(\"65536\", 0);\n}\n" }, { "path": "extras/tests/Numbers/parseNumber.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\nusing namespace ArduinoJson;\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"Test unsigned integer overflow\") {\n Number first, second;\n\n // Avoids MSVC warning C4127 (conditional expression is constant)\n size_t integerSize = sizeof(JsonInteger);\n\n if (integerSize == 8) {\n first = parseNumber(\"18446744073709551615\");\n second = parseNumber(\"18446744073709551616\");\n } else {\n first = parseNumber(\"4294967295\");\n second = parseNumber(\"4294967296\");\n }\n\n REQUIRE(first.type() == NumberType::UnsignedInteger);\n REQUIRE(second.type() == NumberType::Double);\n}\n\nTEST_CASE(\"Test signed integer overflow\") {\n Number first, second;\n\n // Avoids MSVC warning C4127 (conditional expression is constant)\n size_t integerSize = sizeof(JsonInteger);\n\n if (integerSize == 8) {\n first = parseNumber(\"-9223372036854775808\");\n second = parseNumber(\"-9223372036854775809\");\n } else {\n first = parseNumber(\"-2147483648\");\n second = parseNumber(\"-2147483649\");\n }\n\n REQUIRE(first.type() == NumberType::SignedInteger);\n REQUIRE(second.type() == NumberType::Double);\n}\n\nTEST_CASE(\"Invalid value\") {\n auto result = parseNumber(\"6a3\");\n\n REQUIRE(result.type() == NumberType::Invalid);\n}\n\nTEST_CASE(\"float\") {\n auto result = parseNumber(\"3.402823e38\");\n\n REQUIRE(result.type() == NumberType::Float);\n}\n\nTEST_CASE(\"double\") {\n auto result = parseNumber(\"1.7976931348623157e308\");\n\n REQUIRE(result.type() == NumberType::Double);\n}\n" }, { "path": "extras/tests/ResourceManager/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(ResourceManagerTests\n\tallocVariant.cpp\n\tclear.cpp\n\tsaveString.cpp\n\tshrinkToFit.cpp\n\tsize.cpp\n\tStringBuffer.cpp\n\tStringBuilder.cpp\n\tswap.cpp\n)\n\nadd_compile_definitions(ResourceManagerTests\n\tARDUINOJSON_SLOT_ID_SIZE=1 # require less RAM for overflow tests\n\tARDUINOJSON_POOL_CAPACITY=16\n)\n\nadd_test(ResourceManager ResourceManagerTests)\n\nset_tests_properties(ResourceManager\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/ResourceManager/StringBuffer.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n#include \"Literals.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"StringBuffer\") {\n SpyingAllocator spy;\n ResourceManager resources(&spy);\n StringBuffer sb(&resources);\n VariantData variant;\n\n SECTION(\"Tiny string\") {\n auto ptr = sb.reserve(3);\n strcpy(ptr, \"hi!\");\n sb.save(&variant);\n\n REQUIRE(variant.type == VariantType::TinyString);\n REQUIRE(variant.asString() == \"hi!\");\n }\n\n SECTION(\"Tiny string can't contain NUL\") {\n auto ptr = sb.reserve(3);\n memcpy(ptr, \"a\\0b\", 3);\n sb.save(&variant);\n\n REQUIRE(variant.type == VariantType::LongString);\n\n auto str = variant.asString();\n REQUIRE(str.size() == 3);\n REQUIRE(str.c_str()[0] == 'a');\n REQUIRE(str.c_str()[1] == 0);\n REQUIRE(str.c_str()[2] == 'b');\n }\n\n SECTION(\"Tiny string can't have 4 characters\") {\n auto ptr = sb.reserve(4);\n strcpy(ptr, \"alfa\");\n sb.save(&variant);\n\n REQUIRE(variant.type == VariantType::LongString);\n REQUIRE(variant.asString() == \"alfa\");\n }\n}\n" }, { "path": "extras/tests/ResourceManager/StringBuilder.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson;\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"StringBuilder\") {\n KillswitchAllocator killswitch;\n SpyingAllocator spyingAllocator(&killswitch);\n ResourceManager resources(&spyingAllocator);\n\n SECTION(\"Empty string\") {\n StringBuilder str(&resources);\n VariantData data;\n\n str.startString();\n str.save(&data);\n\n REQUIRE(resources.overflowed() == false);\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofStringBuffer()),\n });\n REQUIRE(data.type == VariantType::TinyString);\n }\n\n SECTION(\"Tiny string\") {\n StringBuilder str(&resources);\n\n str.startString();\n str.append(\"url\");\n\n REQUIRE(str.isValid() == true);\n REQUIRE(str.str() == \"url\");\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofStringBuffer()),\n });\n\n VariantData data;\n str.save(&data);\n\n REQUIRE(resources.overflowed() == false);\n REQUIRE(data.type == VariantType::TinyString);\n REQUIRE(data.asString() == \"url\");\n }\n\n SECTION(\"Short string fits in first allocation\") {\n StringBuilder str(&resources);\n\n str.startString();\n str.append(\"hello\");\n\n REQUIRE(str.isValid() == true);\n REQUIRE(str.str() == \"hello\");\n REQUIRE(resources.overflowed() == false);\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n Allocate(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Long string needs reallocation\") {\n StringBuilder str(&resources);\n const char* lorem =\n \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do \"\n \"eiusmod tempor incididunt ut labore et dolore magna aliqua.\";\n\n str.startString();\n str.append(lorem);\n\n REQUIRE(str.isValid() == true);\n REQUIRE(str.str() == lorem);\n REQUIRE(resources.overflowed() == false);\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer(1)),\n Reallocate(sizeofStringBuffer(1), sizeofStringBuffer(2)),\n Reallocate(sizeofStringBuffer(2), sizeofStringBuffer(3)),\n });\n }\n\n SECTION(\"Realloc fails\") {\n StringBuilder str(&resources);\n\n str.startString();\n killswitch.on();\n str.append(\n \"Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do \"\n \"eiusmod tempor incididunt ut labore et dolore magna aliqua.\");\n\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n ReallocateFail(sizeofStringBuffer(), sizeofStringBuffer(2)),\n Deallocate(sizeofStringBuffer()),\n });\n REQUIRE(str.isValid() == false);\n REQUIRE(resources.overflowed() == true);\n }\n\n SECTION(\"Initial allocation fails\") {\n StringBuilder str(&resources);\n\n killswitch.on();\n str.startString();\n\n REQUIRE(str.isValid() == false);\n REQUIRE(resources.overflowed() == true);\n REQUIRE(spyingAllocator.log() == AllocatorLog{\n AllocateFail(sizeofStringBuffer()),\n });\n }\n}\n\nstatic VariantData saveString(StringBuilder& builder, const char* s) {\n VariantData data;\n builder.startString();\n builder.append(s);\n builder.save(&data);\n return data;\n}\n\nTEST_CASE(\"StringBuilder::save() deduplicates strings\") {\n SpyingAllocator spy;\n ResourceManager resources(&spy);\n StringBuilder builder(&resources);\n\n SECTION(\"Basic\") {\n auto s1 = saveString(builder, \"hello\");\n auto s2 = saveString(builder, \"world\");\n auto s3 = saveString(builder, \"hello\");\n\n REQUIRE(s1.asString() == \"hello\");\n REQUIRE(s2.asString() == \"world\");\n REQUIRE(+s1.asString().c_str() == +s3.asString().c_str()); // same address\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"world\")),\n Allocate(sizeofStringBuffer()),\n });\n }\n\n SECTION(\"Requires terminator\") {\n auto s1 = saveString(builder, \"hello world\");\n auto s2 = saveString(builder, \"hello\");\n\n REQUIRE(s1.asString() == \"hello world\");\n REQUIRE(s2.asString() == \"hello\");\n REQUIRE(+s2.asString().c_str() !=\n +s1.asString().c_str()); // different address\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello world\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello\")),\n });\n }\n\n SECTION(\"Don't overrun\") {\n auto s1 = saveString(builder, \"hello world\");\n auto s2 = saveString(builder, \"worl\");\n\n REQUIRE(s1.asString() == \"hello world\");\n REQUIRE(s2.asString() == \"worl\");\n REQUIRE(s2.asString().c_str() !=\n s1.asString().c_str()); // different address\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"hello world\")),\n Allocate(sizeofStringBuffer()),\n Reallocate(sizeofStringBuffer(), sizeofString(\"worl\")),\n });\n }\n}\n" }, { "path": "extras/tests/ResourceManager/allocVariant.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"ResourceManager::allocVariant()\") {\n SECTION(\"Returns different pointer\") {\n ResourceManager resources;\n\n auto s1 = resources.allocVariant();\n REQUIRE(s1.ptr() != nullptr);\n auto s2 = resources.allocVariant();\n REQUIRE(s2.ptr() != nullptr);\n\n REQUIRE(s1.ptr() != s2.ptr());\n }\n\n SECTION(\"Returns the same slot after calling freeVariant()\") {\n ResourceManager resources;\n\n auto s1 = resources.allocVariant();\n auto s2 = resources.allocVariant();\n resources.freeVariant(s1);\n resources.freeVariant(s2);\n auto s3 = resources.allocVariant();\n auto s4 = resources.allocVariant();\n auto s5 = resources.allocVariant();\n\n REQUIRE(s2.id() != s1.id());\n REQUIRE(s3.id() == s2.id());\n REQUIRE(s4.id() == s1.id());\n REQUIRE(s5.id() != s1.id());\n REQUIRE(s5.id() != s2.id());\n }\n\n SECTION(\"Returns aligned pointers\") {\n ResourceManager resources;\n\n REQUIRE(isAligned(resources.allocVariant().ptr()));\n REQUIRE(isAligned(resources.allocVariant().ptr()));\n }\n\n SECTION(\"Returns null if pool list allocation fails\") {\n ResourceManager resources(FailingAllocator::instance());\n\n auto variant = resources.allocVariant();\n REQUIRE(variant.id() == NULL_SLOT);\n REQUIRE(variant.ptr() == nullptr);\n }\n\n SECTION(\"Returns null if pool allocation fails\") {\n ResourceManager resources(FailingAllocator::instance());\n\n resources.allocVariant();\n\n auto variant = resources.allocVariant();\n REQUIRE(variant.id() == NULL_SLOT);\n REQUIRE(variant.ptr() == nullptr);\n }\n\n SECTION(\"Try overflow pool counter\") {\n ResourceManager resources;\n\n // this test assumes SlotId is 8-bit; otherwise it consumes a lot of memory\n // tyhe GitHub Workflow gets killed\n REQUIRE(NULL_SLOT == 255);\n\n // fill all the pools\n for (SlotId i = 0; i < NULL_SLOT; i++) {\n auto slot = resources.allocVariant();\n REQUIRE(slot.id() == i); // or != NULL_SLOT\n REQUIRE(slot.ptr() != nullptr);\n }\n\n REQUIRE(resources.overflowed() == false);\n\n // now all allocations should fail\n for (int i = 0; i < 10; i++) {\n auto slot = resources.allocVariant();\n REQUIRE(slot.id() == NULL_SLOT);\n REQUIRE(slot.ptr() == nullptr);\n }\n\n REQUIRE(resources.overflowed() == true);\n }\n}\n" }, { "path": "extras/tests/ResourceManager/clear.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"ResourceManager::clear()\") {\n ResourceManager resources;\n\n SECTION(\"Discards allocated variants\") {\n resources.allocVariant();\n\n resources.clear();\n REQUIRE(resources.size() == 0);\n }\n\n SECTION(\"Discards allocated strings\") {\n resources.saveString(adaptString(\"123456789\"));\n REQUIRE(resources.size() == sizeofString(9));\n\n resources.clear();\n\n REQUIRE(resources.size() == 0);\n }\n}\n" }, { "path": "extras/tests/ResourceManager/saveString.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nstatic StringNode* saveString(ResourceManager& resources, const char* s) {\n return resources.saveString(adaptString(s));\n}\n\nstatic StringNode* saveString(ResourceManager& resources, const char* s,\n size_t n) {\n return resources.saveString(adaptString(s, n));\n}\n\nTEST_CASE(\"ResourceManager::saveString()\") {\n ResourceManager resources;\n\n SECTION(\"Duplicates different strings\") {\n auto a = saveString(resources, \"hello\");\n auto b = saveString(resources, \"world\");\n REQUIRE(+a->data != +b->data);\n REQUIRE(a->length == 5);\n REQUIRE(b->length == 5);\n REQUIRE(a->references == 1);\n REQUIRE(b->references == 1);\n REQUIRE(resources.size() == sizeofString(\"hello\") + sizeofString(\"world\"));\n }\n\n SECTION(\"Deduplicates identical strings\") {\n auto a = saveString(resources, \"hello\");\n auto b = saveString(resources, \"hello\");\n REQUIRE(a == b);\n REQUIRE(a->length == 5);\n REQUIRE(a->references == 2);\n REQUIRE(resources.size() == sizeofString(\"hello\"));\n }\n\n SECTION(\"Deduplicates identical strings that contain NUL\") {\n auto a = saveString(resources, \"hello\\0world\", 11);\n auto b = saveString(resources, \"hello\\0world\", 11);\n REQUIRE(a == b);\n REQUIRE(a->length == 11);\n REQUIRE(a->references == 2);\n REQUIRE(resources.size() == sizeofString(\"hello world\"));\n }\n\n SECTION(\"Don't stop on first NUL\") {\n auto a = saveString(resources, \"hello\");\n auto b = saveString(resources, \"hello\\0world\", 11);\n REQUIRE(a != b);\n REQUIRE(a->length == 5);\n REQUIRE(b->length == 11);\n REQUIRE(a->references == 1);\n REQUIRE(b->references == 1);\n REQUIRE(resources.size() ==\n sizeofString(\"hello\") + sizeofString(\"hello world\"));\n }\n\n SECTION(\"Returns NULL when allocation fails\") {\n ResourceManager pool2(FailingAllocator::instance());\n REQUIRE(saveString(pool2, \"a\") == nullptr);\n }\n}\n" }, { "path": "extras/tests/ResourceManager/shrinkToFit.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"ResourceManager::shrinkToFit()\") {\n SpyingAllocator spyingAllocator;\n ResourceManager resources(&spyingAllocator);\n\n SECTION(\"empty\") {\n resources.shrinkToFit();\n\n REQUIRE(spyingAllocator.log() == AllocatorLog{});\n }\n\n SECTION(\"only one pool\") {\n resources.allocVariant();\n\n resources.shrinkToFit();\n\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofPool()),\n Reallocate(sizeofPool(), sizeofPool(1)),\n });\n }\n\n SECTION(\"more pools than initial count\") {\n for (size_t i = 0;\n i < ARDUINOJSON_POOL_CAPACITY * ARDUINOJSON_INITIAL_POOL_COUNT + 1;\n i++)\n resources.allocVariant();\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Allocate(sizeofPool()) * ARDUINOJSON_INITIAL_POOL_COUNT,\n Allocate(sizeofPoolList(ARDUINOJSON_INITIAL_POOL_COUNT * 2)),\n Allocate(sizeofPool()),\n });\n\n spyingAllocator.clearLog();\n resources.shrinkToFit();\n\n REQUIRE(spyingAllocator.log() ==\n AllocatorLog{\n Reallocate(sizeofPool(), sizeofPool(1)),\n Reallocate(sizeofPoolList(ARDUINOJSON_INITIAL_POOL_COUNT * 2),\n sizeofPoolList(ARDUINOJSON_INITIAL_POOL_COUNT + 1)),\n });\n }\n}\n" }, { "path": "extras/tests/ResourceManager/size.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nTEST_CASE(\"ResourceManager::size()\") {\n TimebombAllocator timebomb(0);\n ResourceManager resources(&timebomb);\n\n SECTION(\"Initial size is 0\") {\n REQUIRE(0 == resources.size());\n }\n\n SECTION(\"Doesn't grow when allocation of second pool fails\") {\n timebomb.setCountdown(1);\n for (size_t i = 0; i < ARDUINOJSON_POOL_CAPACITY; i++)\n resources.allocVariant();\n size_t size = resources.size();\n\n resources.allocVariant();\n\n REQUIRE(size == resources.size());\n }\n}\n" }, { "path": "extras/tests/ResourceManager/swap.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n\n#include \n\n#include \"Allocators.hpp\"\n\nusing namespace ArduinoJson::detail;\n\nstatic void fullPreallocatedPools(ResourceManager& resources) {\n for (int i = 0;\n i < ARDUINOJSON_INITIAL_POOL_COUNT * ARDUINOJSON_POOL_CAPACITY; i++)\n resources.allocVariant();\n}\n\nTEST_CASE(\"ResourceManager::swap()\") {\n SECTION(\"Both using preallocated pool list\") {\n SpyingAllocator spy;\n ResourceManager a(&spy);\n ResourceManager b(&spy);\n\n auto a1 = a.allocVariant();\n auto b1 = b.allocVariant();\n\n swap(a, b);\n\n REQUIRE(a1.ptr() == b.getVariant(a1.id()));\n REQUIRE(b1.ptr() == a.getVariant(b1.id()));\n\n REQUIRE(spy.log() == AllocatorLog{\n Allocate(sizeofPool()) * 2,\n });\n }\n\n SECTION(\"Only left using preallocated pool list\") {\n SpyingAllocator spy;\n ResourceManager a(&spy);\n ResourceManager b(&spy);\n fullPreallocatedPools(b);\n\n auto a1 = a.allocVariant();\n auto b1 = b.allocVariant();\n swap(a, b);\n\n REQUIRE(a1.ptr() == b.getVariant(a1.id()));\n REQUIRE(b1.ptr() == a.getVariant(b1.id()));\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()) * (ARDUINOJSON_INITIAL_POOL_COUNT + 1),\n Allocate(sizeofPoolList(ARDUINOJSON_INITIAL_POOL_COUNT * 2)),\n Allocate(sizeofPool()),\n });\n }\n\n SECTION(\"Only right using preallocated pool list\") {\n SpyingAllocator spy;\n ResourceManager a(&spy);\n fullPreallocatedPools(a);\n ResourceManager b(&spy);\n\n auto a1 = a.allocVariant();\n auto b1 = b.allocVariant();\n swap(a, b);\n\n REQUIRE(a1.ptr() == b.getVariant(a1.id()));\n REQUIRE(b1.ptr() == a.getVariant(b1.id()));\n\n REQUIRE(spy.log() ==\n AllocatorLog{\n Allocate(sizeofPool()) * ARDUINOJSON_INITIAL_POOL_COUNT,\n Allocate(sizeofPoolList(ARDUINOJSON_INITIAL_POOL_COUNT * 2)),\n Allocate(sizeofPool()) * 2,\n });\n }\n\n SECTION(\"None is using preallocated pool list\") {\n SpyingAllocator spy;\n ResourceManager a(&spy);\n fullPreallocatedPools(a);\n ResourceManager b(&spy);\n fullPreallocatedPools(b);\n\n auto a1 = a.allocVariant();\n auto b1 = b.allocVariant();\n\n swap(a, b);\n\n REQUIRE(a1.ptr() == b.getVariant(a1.id()));\n REQUIRE(b1.ptr() == a.getVariant(b1.id()));\n }\n}\n" }, { "path": "extras/tests/TextFormatter/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright © 2014-2025, Benoit BLANCHON\n# MIT License\n\nadd_executable(TextFormatterTests\n\twriteFloat.cpp\n\twriteInteger.cpp\n\twriteString.cpp\n)\n\nset_target_properties(TextFormatterTests PROPERTIES UNITY_BUILD OFF)\n\nadd_test(TextFormatter TextFormatterTests)\n\nset_tests_properties(TextFormatter\n\tPROPERTIES\n\t\tLABELS \"Catch\"\n)\n" }, { "path": "extras/tests/TextFormatter/writeFloat.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#define ARDUINOJSON_ENABLE_NAN 1\n#define ARDUINOJSON_ENABLE_INFINITY 1\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\ntemplate \nvoid check(TFloat input, const std::string& expected) {\n std::string output;\n Writer sb(output);\n TextFormatter> writer(sb);\n writer.writeFloat(input);\n REQUIRE(writer.bytesWritten() == output.size());\n CHECK(expected == output);\n}\n\nTEST_CASE(\"TextFormatter::writeFloat(double)\") {\n SECTION(\"Pi\") {\n check(3.14159265359, \"3.141592654\");\n }\n\n SECTION(\"Signaling NaN\") {\n double nan = std::numeric_limits::signaling_NaN();\n check(nan, \"NaN\");\n }\n\n SECTION(\"Quiet NaN\") {\n double nan = std::numeric_limits::quiet_NaN();\n check(nan, \"NaN\");\n }\n\n SECTION(\"Infinity\") {\n double inf = std::numeric_limits::infinity();\n check(inf, \"Infinity\");\n check(-inf, \"-Infinity\");\n }\n\n SECTION(\"Zero\") {\n check(0.0, \"0\");\n check(-0.0, \"0\");\n }\n\n SECTION(\"Espilon\") {\n check(2.2250738585072014E-308, \"2.225073859e-308\");\n check(-2.2250738585072014E-308, \"-2.225073859e-308\");\n }\n\n SECTION(\"Max double\") {\n check(1.7976931348623157E+308, \"1.797693135e308\");\n check(-1.7976931348623157E+308, \"-1.797693135e308\");\n }\n\n SECTION(\"Big exponent\") {\n // this test increases coverage of normalize()\n check(1e255, \"1e255\");\n check(1e-255, \"1e-255\");\n }\n\n SECTION(\"Exponentation when <= 1e-5\") {\n check(1e-4, \"0.0001\");\n check(1e-5, \"1e-5\");\n\n check(-1e-4, \"-0.0001\");\n check(-1e-5, \"-1e-5\");\n }\n\n SECTION(\"Exponentation when >= 1e7\") {\n check(9999999.999, \"9999999.999\");\n check(10000000.0, \"1e7\");\n\n check(-9999999.999, \"-9999999.999\");\n check(-10000000.0, \"-1e7\");\n }\n\n SECTION(\"Rounding when too many decimals\") {\n check(0.000099999999999, \"0.0001\");\n check(0.0000099999999999, \"1e-5\");\n check(0.9999999996, \"1\");\n }\n\n SECTION(\"9 decimal places\") {\n check(0.100000001, \"0.100000001\");\n check(0.999999999, \"0.999999999\");\n\n check(9.000000001, \"9.000000001\");\n check(9.999999999, \"9.999999999\");\n }\n\n SECTION(\"10 decimal places\") {\n check(0.1000000001, \"0.1\");\n check(0.9999999999, \"1\");\n\n check(9.0000000001, \"9\");\n check(9.9999999999, \"10\");\n }\n}\n\nTEST_CASE(\"TextFormatter::writeFloat(float)\") {\n SECTION(\"Pi\") {\n check(3.14159265359f, \"3.141593\");\n }\n\n SECTION(\"999.9\") { // issue #543\n check(999.9f, \"999.9\");\n }\n\n SECTION(\"24.3\") { // # issue #588\n check(24.3f, \"24.3\");\n }\n}\n" }, { "path": "extras/tests/TextFormatter/writeInteger.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n#include \n#include \n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\ntemplate \nvoid checkWriteInteger(T value, std::string expected) {\n char output[64] = {0};\n StaticStringWriter sb(output, sizeof(output));\n TextFormatter writer(sb);\n writer.writeInteger(value);\n REQUIRE(expected == output);\n REQUIRE(writer.bytesWritten() == expected.size());\n}\n\nTEST_CASE(\"int8_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(-128, \"-128\");\n checkWriteInteger(127, \"127\");\n}\n\nTEST_CASE(\"uint8_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(255, \"255\");\n}\n\nTEST_CASE(\"int16_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(-32768, \"-32768\");\n checkWriteInteger(32767, \"32767\");\n}\n\nTEST_CASE(\"uint16_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(65535, \"65535\");\n}\n\nTEST_CASE(\"int32_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(-2147483647 - 1, \"-2147483648\");\n checkWriteInteger(2147483647, \"2147483647\");\n}\n\nTEST_CASE(\"uint32_t\") {\n checkWriteInteger(0, \"0\");\n checkWriteInteger(4294967295U, \"4294967295\");\n}\n" }, { "path": "extras/tests/TextFormatter/writeString.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright © 2014-2025, Benoit BLANCHON\n// MIT License\n\n#include \n\n#include \n#include \n\nusing namespace ArduinoJson::detail;\n\nvoid check(const char* input, std::string expected) {\n char output[64] = {0};\n StaticStringWriter sb(output, sizeof(output));\n TextFormatter writer(sb);\n writer.writeString(input);\n REQUIRE(expected == output);\n REQUIRE(writer.bytesWritten() == expected.size());\n}\n\nTEST_CASE(\"TextFormatter::writeString()\") {\n SECTION(\"EmptyString\") {\n check(\"\", \"\\\"\\\"\");\n }\n\n SECTION(\"QuotationMark\") {\n check(\"\\\"\", \"\\\"\\\\\\\"\\\"\");\n }\n\n SECTION(\"ReverseSolidus\") {\n check(\"\\\\\", \"\\\"\\\\\\\\\\\"\");\n }\n\n SECTION(\"Solidus\") {\n check(\"/\", \"\\\"/\\\"\"); // but the JSON format allows \\/\n }\n\n SECTION(\"Backspace\") {\n check(\"\\b\", \"\\\"\\\\b\\\"\");\n }\n\n SECTION(\"Formfeed\") {\n check(\"\\f\", \"\\\"\\\\f\\\"\");\n }\n\n SECTION(\"Newline\") {\n check(\"\\n\", \"\\\"\\\\n\\\"\");\n }\n\n SECTION(\"CarriageReturn\") {\n check(\"\\r\", \"\\\"\\\\r\\\"\");\n }\n\n SECTION(\"HorizontalTab\") {\n check(\"\\t\", \"\\\"\\\\t\\\"\");\n }\n}\n" }, { "path": "extras/tests/catch/.clang-format", "content": "DisableFormat: true\nSortIncludes: false\n" }, { "path": "extras/tests/catch/CMakeLists.txt", "content": "# ArduinoJson - https://arduinojson.org\n# Copyright Benoit Blanchon 2014-2021\n# MIT License\n\nset(CMAKE_CXX_STANDARD 17)\nset(CMAKE_CXX_STANDARD_REQUIRED OFF)\n\nadd_library(catch\n\tcatch.hpp\n\tcatch.cpp\n)\n\ntarget_include_directories(catch\n\tPUBLIC\n\t\t${CMAKE_CURRENT_SOURCE_DIR}\n)\n\nif(MINGW)\n\t# prevent \"too many sections (32837)\" with MinGW\n\ttarget_compile_options(catch PRIVATE -Wa,-mbig-obj)\nendif()\n" }, { "path": "extras/tests/catch/catch.cpp", "content": "// ArduinoJson - https://arduinojson.org\n// Copyright Benoit Blanchon 2014-2021\n// MIT License\n\n#define CATCH_CONFIG_MAIN\n#include \"catch.hpp\"\n" }, { "path": "extras/tests/catch/catch.hpp", "content": "/*\n * Catch v2.13.10\n * Generated: 2022-10-16 11:01:23.452308\n * ----------------------------------------------------------\n * This file has been merged from multiple headers. Please don't edit it directly\n * Copyright (c) 2022 Two Blue Cubes Ltd. All rights reserved.\n *\n * Distributed under the Boost Software License, Version 1.0. (See accompanying\n * file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)\n */\n#ifndef TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n#define TWOBLUECUBES_SINGLE_INCLUDE_CATCH_HPP_INCLUDED\n// start catch.hpp\n\n\n#define CATCH_VERSION_MAJOR 2\n#define CATCH_VERSION_MINOR 13\n#define CATCH_VERSION_PATCH 10\n\n#ifdef __clang__\n# pragma clang system_header\n#elif defined __GNUC__\n# pragma GCC system_header\n#endif\n\n// start catch_suppress_warnings.h\n\n#ifdef __clang__\n# ifdef __ICC // icpc defines the __clang__ macro\n# pragma warning(push)\n# pragma warning(disable: 161 1682)\n# else // __ICC\n# pragma clang diagnostic push\n# pragma clang diagnostic ignored \"-Wpadded\"\n# pragma clang diagnostic ignored \"-Wswitch-enum\"\n# pragma clang diagnostic ignored \"-Wcovered-switch-default\"\n# endif\n#elif defined __GNUC__\n // Because REQUIREs trigger GCC's -Wparentheses, and because still\n // supported version of g++ have only buggy support for _Pragmas,\n // Wparentheses have to be suppressed globally.\n# pragma GCC diagnostic ignored \"-Wparentheses\" // See #674 for details\n\n# pragma GCC diagnostic push\n# pragma GCC diagnostic ignored \"-Wunused-variable\"\n# pragma GCC diagnostic ignored \"-Wpadded\"\n#endif\n// end catch_suppress_warnings.h\n#if defined(CATCH_CONFIG_MAIN) || defined(CATCH_CONFIG_RUNNER)\n# define CATCH_IMPL\n# define CATCH_CONFIG_ALL_PARTS\n#endif\n\n// In the impl file, we want to have access to all parts of the headers\n// Can also be used to sanely support PCHs\n#if defined(CATCH_CONFIG_ALL_PARTS)\n# define CATCH_CONFIG_EXTERNAL_INTERFACES\n# if defined(CATCH_CONFIG_DISABLE_MATCHERS)\n# undef CATCH_CONFIG_DISABLE_MATCHERS\n# endif\n# if !defined(CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER)\n# define CATCH_CONFIG_ENABLE_CHRONO_STRINGMAKER\n# endif\n#endif\n\n#if !defined(CATCH_CONFIG_IMPL_ONLY)\n// start catch_platform.h\n\n// See e.g.:\n// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html\n#ifdef __APPLE__\n# include \n# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \\\n (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)\n# define CATCH_PLATFORM_MAC\n# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)\n# define CATCH_PLATFORM_IPHONE\n# endif\n\n#elif defined(linux) || defined(__linux) || defined(__linux__)\n# define CATCH_PLATFORM_LINUX\n\n#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)\n# define CATCH_PLATFORM_WINDOWS\n#endif\n\n// end catch_platform.h\n\n#ifdef CATCH_IMPL\n# ifndef CLARA_CONFIG_MAIN\n# define CLARA_CONFIG_MAIN_NOT_DEFINED\n# define CLARA_CONFIG_MAIN\n# endif\n#endif\n\n// start catch_user_interfaces.h\n\nnamespace Catch {\n unsigned int rngSeed();\n}\n\n// end catch_user_interfaces.h\n// start catch_tag_alias_autoregistrar.h\n\n// start catch_common.h\n\n// start catch_compiler_capabilities.h\n\n// Detect a number of compiler features - by compiler\n// The following features are defined:\n//\n// CATCH_CONFIG_COUNTER : is the __COUNTER__ macro supported?\n// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?\n// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?\n// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?\n// ****************\n// Note to maintainers: if new toggles are added please document them\n// in configuration.md, too\n// ****************\n\n// In general each macro has a _NO_ form\n// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.\n// Many features, at point of detection, define an _INTERNAL_ macro, so they\n// can be combined, en-mass, with the _NO_ forms later.\n\n#ifdef __cplusplus\n\n# if (__cplusplus >= 201402L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201402L)\n# define CATCH_CPP14_OR_GREATER\n# endif\n\n# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)\n# define CATCH_CPP17_OR_GREATER\n# endif\n\n#endif\n\n// Only GCC compiler should be used in this block, so other compilers trying to\n// mask themselves as GCC should be ignored.\n#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__)\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( \"GCC diagnostic push\" )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( \"GCC diagnostic pop\" )\n\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)\n\n#endif\n\n#if defined(__clang__)\n\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( \"clang diagnostic push\" )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( \"clang diagnostic pop\" )\n\n// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug\n// which results in calls to destructors being emitted for each temporary,\n// without a matching initialization. In practice, this can result in something\n// like `std::string::~string` being called on an uninitialized value.\n//\n// For example, this code will likely segfault under IBM XL:\n// ```\n// REQUIRE(std::string(\"12\") + \"34\" == \"1234\")\n// ```\n//\n// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.\n# if !defined(__ibmxl__) && !defined(__CUDACC__)\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */\n# endif\n\n# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wexit-time-destructors\\\"\" ) \\\n _Pragma( \"clang diagnostic ignored \\\"-Wglobal-constructors\\\"\")\n\n# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wparentheses\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wunused-variable\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wgnu-zero-variadic-macro-arguments\\\"\" )\n\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \\\n _Pragma( \"clang diagnostic ignored \\\"-Wunused-template\\\"\" )\n\n#endif // __clang__\n\n////////////////////////////////////////////////////////////////////////////////\n// Assume that non-Windows platforms support posix signals by default\n#if !defined(CATCH_PLATFORM_WINDOWS)\n #define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// We know some environments not to support full POSIX signals\n#if defined(__CYGWIN__) || defined(__QNX__) || defined(__EMSCRIPTEN__) || defined(__DJGPP__)\n #define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS\n#endif\n\n#ifdef __OS400__\n# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS\n# define CATCH_CONFIG_COLOUR_NONE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Android somehow still does not support std::to_string\n#if defined(__ANDROID__)\n# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING\n# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Not all Windows environments support SEH properly\n#if defined(__MINGW32__)\n# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// PS4\n#if defined(__ORBIS__)\n# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// Cygwin\n#ifdef __CYGWIN__\n\n// Required for some versions of Cygwin to declare gettimeofday\n// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin\n# define _BSD_SOURCE\n// some versions of cygwin (most) do not support std::to_string. Use the libstd check.\n// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813\n# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \\\n && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))\n\n# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING\n\n# endif\n#endif // __CYGWIN__\n\n////////////////////////////////////////////////////////////////////////////////\n// Visual C++\n#if defined(_MSC_VER)\n\n// Universal Windows platform does not support SEH\n// Or console colours (or console at all...)\n# if defined(WINAPI_FAMILY) && (WINAPI_FAMILY == WINAPI_FAMILY_APP)\n# define CATCH_CONFIG_COLOUR_NONE\n# else\n# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH\n# endif\n\n# if !defined(__clang__) // Handle Clang masquerading for msvc\n\n// MSVC traditional preprocessor needs some workaround for __VA_ARGS__\n// _MSVC_TRADITIONAL == 0 means new conformant preprocessor\n// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor\n# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)\n# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n# endif // MSVC_TRADITIONAL\n\n// Only do this if we're not using clang on Windows, which uses `diagnostic push` & `diagnostic pop`\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION __pragma( warning(push) )\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION __pragma( warning(pop) )\n# endif // __clang__\n\n#endif // _MSC_VER\n\n#if defined(_REENTRANT) || defined(_MSC_VER)\n// Enable async processing, as -pthread is specified or no additional linking is required\n# define CATCH_INTERNAL_CONFIG_USE_ASYNC\n#endif // _MSC_VER\n\n////////////////////////////////////////////////////////////////////////////////\n// Check if we are compiled with -fno-exceptions or equivalent\n#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)\n# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n// DJGPP\n#ifdef __DJGPP__\n# define CATCH_INTERNAL_CONFIG_NO_WCHAR\n#endif // __DJGPP__\n\n////////////////////////////////////////////////////////////////////////////////\n// Embarcadero C++Build\n#if defined(__BORLANDC__)\n #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n\n// Use of __COUNTER__ is suppressed during code analysis in\n// CLion/AppCode 2017.2.x and former, because __COUNTER__ is not properly\n// handled by it.\n// Otherwise all supported compilers support COUNTER macro,\n// but user still might want to turn it off\n#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )\n #define CATCH_INTERNAL_CONFIG_COUNTER\n#endif\n\n////////////////////////////////////////////////////////////////////////////////\n\n// RTX is a special version of Windows that is real time.\n// This means that it is detected as Windows, but does not provide\n// the same set of capabilities as real Windows does.\n#if defined(UNDER_RTSS) || defined(RTX64_BUILD)\n #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH\n #define CATCH_INTERNAL_CONFIG_NO_ASYNC\n #define CATCH_CONFIG_COLOUR_NONE\n#endif\n\n#if !defined(_GLIBCXX_USE_C99_MATH_TR1)\n#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER\n#endif\n\n// Various stdlib support checks that require __has_include\n#if defined(__has_include)\n // Check if string_view is available and usable\n #if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW\n #endif\n\n // Check if optional is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n\n // Check if byte is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # include \n # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)\n # define CATCH_INTERNAL_CONFIG_CPP17_BYTE\n # endif\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n\n // Check if variant is available and usable\n # if __has_include() && defined(CATCH_CPP17_OR_GREATER)\n # if defined(__clang__) && (__clang_major__ < 8)\n // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852\n // fix should be in clang 8, workaround in libstdc++ 8.2\n # include \n # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)\n # define CATCH_CONFIG_NO_CPP17_VARIANT\n # else\n # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT\n # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)\n # else\n # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT\n # endif // defined(__clang__) && (__clang_major__ < 8)\n # endif // __has_include() && defined(CATCH_CPP17_OR_GREATER)\n#endif // defined(__has_include)\n\n#if defined(CATCH_INTERNAL_CONFIG_COUNTER) && !defined(CATCH_CONFIG_NO_COUNTER) && !defined(CATCH_CONFIG_COUNTER)\n# define CATCH_CONFIG_COUNTER\n#endif\n#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)\n# define CATCH_CONFIG_WINDOWS_SEH\n#endif\n// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.\n#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)\n# define CATCH_CONFIG_POSIX_SIGNALS\n#endif\n// This is set by default, because we assume that compilers with no wchar_t support are just rare exceptions.\n#if !defined(CATCH_INTERNAL_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_NO_WCHAR) && !defined(CATCH_CONFIG_WCHAR)\n# define CATCH_CONFIG_WCHAR\n#endif\n\n#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)\n# define CATCH_CONFIG_CPP11_TO_STRING\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)\n# define CATCH_CONFIG_CPP17_OPTIONAL\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)\n# define CATCH_CONFIG_CPP17_STRING_VIEW\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)\n# define CATCH_CONFIG_CPP17_VARIANT\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)\n# define CATCH_CONFIG_CPP17_BYTE\n#endif\n\n#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)\n# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)\n# define CATCH_CONFIG_NEW_CAPTURE\n#endif\n\n#if !defined(CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)\n# define CATCH_CONFIG_DISABLE_EXCEPTIONS\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)\n# define CATCH_CONFIG_POLYFILL_ISNAN\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)\n# define CATCH_CONFIG_USE_ASYNC\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_NO_ANDROID_LOGWRITE) && !defined(CATCH_CONFIG_ANDROID_LOGWRITE)\n# define CATCH_CONFIG_ANDROID_LOGWRITE\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)\n# define CATCH_CONFIG_GLOBAL_NEXTAFTER\n#endif\n\n// Even if we do not think the compiler has that warning, we still have\n// to provide a macro that can be used by the code.\n#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)\n# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION\n#endif\n#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)\n# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_WARNINGS\n#endif\n#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS\n#endif\n\n// The goal of this macro is to avoid evaluation of the arguments, but\n// still have the compiler warn on problems inside...\n#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)\n# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)\n#endif\n\n#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)\n# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#elif defined(__clang__) && (__clang_major__ < 5)\n# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#endif\n\n#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS)\n# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS\n#endif\n\n#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)\n#define CATCH_TRY if ((true))\n#define CATCH_CATCH_ALL if ((false))\n#define CATCH_CATCH_ANON(type) if ((false))\n#else\n#define CATCH_TRY try\n#define CATCH_CATCH_ALL catch (...)\n#define CATCH_CATCH_ANON(type) catch (type)\n#endif\n\n#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)\n#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#endif\n\n// end catch_compiler_capabilities.h\n#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line\n#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )\n#ifdef CATCH_CONFIG_COUNTER\n# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )\n#else\n# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )\n#endif\n\n#include \n#include \n#include \n\n// We need a dummy global operator<< so we can bring it into Catch namespace later\nstruct Catch_global_namespace_dummy {};\nstd::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);\n\nnamespace Catch {\n\n struct CaseSensitive { enum Choice {\n Yes,\n No\n }; };\n\n class NonCopyable {\n NonCopyable( NonCopyable const& ) = delete;\n NonCopyable( NonCopyable && ) = delete;\n NonCopyable& operator = ( NonCopyable const& ) = delete;\n NonCopyable& operator = ( NonCopyable && ) = delete;\n\n protected:\n NonCopyable();\n virtual ~NonCopyable();\n };\n\n struct SourceLineInfo {\n\n SourceLineInfo() = delete;\n SourceLineInfo( char const* _file, std::size_t _line ) noexcept\n : file( _file ),\n line( _line )\n {}\n\n SourceLineInfo( SourceLineInfo const& other ) = default;\n SourceLineInfo& operator = ( SourceLineInfo const& ) = default;\n SourceLineInfo( SourceLineInfo&& ) noexcept = default;\n SourceLineInfo& operator = ( SourceLineInfo&& ) noexcept = default;\n\n bool empty() const noexcept { return file[0] == '\\0'; }\n bool operator == ( SourceLineInfo const& other ) const noexcept;\n bool operator < ( SourceLineInfo const& other ) const noexcept;\n\n char const* file;\n std::size_t line;\n };\n\n std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info );\n\n // Bring in operator<< from global namespace into Catch namespace\n // This is necessary because the overload of operator<< above makes\n // lookup stop at namespace Catch\n using ::operator<<;\n\n // Use this in variadic streaming macros to allow\n // >> +StreamEndStop\n // as well as\n // >> stuff +StreamEndStop\n struct StreamEndStop {\n std::string operator+() const;\n };\n template\n T const& operator + ( T const& value, StreamEndStop ) {\n return value;\n }\n}\n\n#define CATCH_INTERNAL_LINEINFO \\\n ::Catch::SourceLineInfo( __FILE__, static_cast( __LINE__ ) )\n\n// end catch_common.h\nnamespace Catch {\n\n struct RegistrarForTagAliases {\n RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );\n };\n\n} // end namespace Catch\n\n#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \\\n CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \\\n CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \\\n namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \\\n CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION\n\n// end catch_tag_alias_autoregistrar.h\n// start catch_test_registry.h\n\n// start catch_interfaces_testcase.h\n\n#include \n\nnamespace Catch {\n\n class TestSpec;\n\n struct ITestInvoker {\n virtual void invoke () const = 0;\n virtual ~ITestInvoker();\n };\n\n class TestCase;\n struct IConfig;\n\n struct ITestCaseRegistry {\n virtual ~ITestCaseRegistry();\n virtual std::vector const& getAllTests() const = 0;\n virtual std::vector const& getAllTestsSorted( IConfig const& config ) const = 0;\n };\n\n bool isThrowSafe( TestCase const& testCase, IConfig const& config );\n bool matchTest( TestCase const& testCase, TestSpec const& testSpec, IConfig const& config );\n std::vector filterTests( std::vector const& testCases, TestSpec const& testSpec, IConfig const& config );\n std::vector const& getAllTestCasesSorted( IConfig const& config );\n\n}\n\n// end catch_interfaces_testcase.h\n// start catch_stringref.h\n\n#include \n#include \n#include \n#include \n\nnamespace Catch {\n\n /// A non-owning string class (similar to the forthcoming std::string_view)\n /// Note that, because a StringRef may be a substring of another string,\n /// it may not be null terminated.\n class StringRef {\n public:\n using size_type = std::size_t;\n using const_iterator = const char*;\n\n private:\n static constexpr char const* const s_empty = \"\";\n\n char const* m_start = s_empty;\n size_type m_size = 0;\n\n public: // construction\n constexpr StringRef() noexcept = default;\n\n StringRef( char const* rawChars ) noexcept;\n\n constexpr StringRef( char const* rawChars, size_type size ) noexcept\n : m_start( rawChars ),\n m_size( size )\n {}\n\n StringRef( std::string const& stdString ) noexcept\n : m_start( stdString.c_str() ),\n m_size( stdString.size() )\n {}\n\n explicit operator std::string() const {\n return std::string(m_start, m_size);\n }\n\n public: // operators\n auto operator == ( StringRef const& other ) const noexcept -> bool;\n auto operator != (StringRef const& other) const noexcept -> bool {\n return !(*this == other);\n }\n\n auto operator[] ( size_type index ) const noexcept -> char {\n assert(index < m_size);\n return m_start[index];\n }\n\n public: // named queries\n constexpr auto empty() const noexcept -> bool {\n return m_size == 0;\n }\n constexpr auto size() const noexcept -> size_type {\n return m_size;\n }\n\n // Returns the current start pointer. If the StringRef is not\n // null-terminated, throws std::domain_exception\n auto c_str() const -> char const*;\n\n public: // substrings and searches\n // Returns a substring of [start, start + length).\n // If start + length > size(), then the substring is [start, size()).\n // If start > size(), then the substring is empty.\n auto substr( size_type start, size_type length ) const noexcept -> StringRef;\n\n // Returns the current start pointer. May not be null-terminated.\n auto data() const noexcept -> char const*;\n\n constexpr auto isNullTerminated() const noexcept -> bool {\n return m_start[m_size] == '\\0';\n }\n\n public: // iterators\n constexpr const_iterator begin() const { return m_start; }\n constexpr const_iterator end() const { return m_start + m_size; }\n };\n\n auto operator += ( std::string& lhs, StringRef const& sr ) -> std::string&;\n auto operator << ( std::ostream& os, StringRef const& sr ) -> std::ostream&;\n\n constexpr auto operator \"\" _sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {\n return StringRef( rawChars, size );\n }\n} // namespace Catch\n\nconstexpr auto operator \"\" _catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {\n return Catch::StringRef( rawChars, size );\n}\n\n// end catch_stringref.h\n// start catch_preprocessor.hpp\n\n\n#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__\n#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))\n#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))\n\n#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__\n// MSVC needs more evaluations\n#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))\n#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))\n#else\n#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)\n#endif\n\n#define CATCH_REC_END(...)\n#define CATCH_REC_OUT\n\n#define CATCH_EMPTY()\n#define CATCH_DEFER(id) id CATCH_EMPTY()\n\n#define CATCH_REC_GET_END2() 0, CATCH_REC_END\n#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2\n#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1\n#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT\n#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)\n#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)\n\n#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )\n\n#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )\n#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )\n\n// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,\n// and passes userdata as the first parameter to each invocation,\n// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)\n#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))\n\n#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))\n\n#define INTERNAL_CATCH_EXPAND1(param) INTERNAL_CATCH_EXPAND2(param)\n#define INTERNAL_CATCH_EXPAND2(...) INTERNAL_CATCH_NO## __VA_ARGS__\n#define INTERNAL_CATCH_DEF(...) INTERNAL_CATCH_DEF __VA_ARGS__\n#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF\n#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)\n#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__\n#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))\n#else\n// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF\n#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)\n#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__\n#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)\n#endif\n\n#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__\n#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)\n\n#define INTERNAL_CATCH_REMOVE_PARENS(...) INTERNAL_CATCH_EXPAND1(INTERNAL_CATCH_DEF __VA_ARGS__)\n\n#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR\n#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper())\n#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))\n#else\n#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper()))\n#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))\n#endif\n\n#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\\\n CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)\n\n#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)\n#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)\n#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)\n#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)\n#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)\n#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)\n#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)\n#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)\n#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)\n#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)\n#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)\n\n#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N\n\n#define INTERNAL_CATCH_TYPE_GEN\\\n template struct TypeList {};\\\n template\\\n constexpr auto get_wrapper() noexcept -> TypeList { return {}; }\\\n template class...> struct TemplateTypeList{};\\\n template class...Cs>\\\n constexpr auto get_wrapper() noexcept -> TemplateTypeList { return {}; }\\\n template\\\n struct append;\\\n template\\\n struct rewrap;\\\n template class, typename...>\\\n struct create;\\\n template class, typename>\\\n struct convert;\\\n \\\n template \\\n struct append { using type = T; };\\\n template< template class L1, typename...E1, template class L2, typename...E2, typename...Rest>\\\n struct append, L2, Rest...> { using type = typename append, Rest...>::type; };\\\n template< template class L1, typename...E1, typename...Rest>\\\n struct append, TypeList, Rest...> { using type = L1; };\\\n \\\n template< template class Container, template class List, typename...elems>\\\n struct rewrap, List> { using type = TypeList>; };\\\n template< template class Container, template class List, class...Elems, typename...Elements>\\\n struct rewrap, List, Elements...> { using type = typename append>, typename rewrap, Elements...>::type>::type; };\\\n \\\n template