Initial commit of Arduino libraries

ArduinoJson/extras/tests/JsonVariantConst/CMakeLists.txt

@@ -0,0 +1,19 @@
+# ArduinoJson - https://arduinojson.org
+# Copyright © 2014-2025, Benoit BLANCHON
+# MIT License
+
+add_executable(JsonVariantConstTests
+	as.cpp
+	is.cpp
+	isnull.cpp
+	nesting.cpp
+	size.cpp
+	subscript.cpp
+)
+
+add_test(JsonVariantConst JsonVariantConstTests)
+
+set_tests_properties(JsonVariantConst
+	PROPERTIES
+		LABELS "Catch"
+)

ArduinoJson/extras/tests/JsonVariantConst/as.cpp

@@ -0,0 +1,42 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+
+#include "Literals.hpp"
+
+TEST_CASE("JsonVariantConst::as<T>()") {
+  JsonDocument doc;
+  JsonVariantConst var = doc.to<JsonVariant>();
+
+  doc.set("hello");
+
+  REQUIRE(var.as<bool>() == true);
+  REQUIRE(var.as<long>() == 0L);
+  REQUIRE(var.as<const char*>() == "hello"_s);
+  REQUIRE(var.as<std::string>() == "hello"_s);
+}
+
+TEST_CASE("Invalid conversions") {
+  using namespace ArduinoJson::detail;
+
+  JsonVariantConst variant;
+
+  CHECK(is_same<decltype(variant.as<int>()), int>::value);
+  CHECK(is_same<decltype(variant.as<float>()), float>::value);
+  CHECK(is_same<decltype(variant.as<JsonVariantConst>()),
+                JsonVariantConst>::value);
+  CHECK(
+      is_same<decltype(variant.as<JsonObjectConst>()), JsonObjectConst>::value);
+  CHECK(is_same<decltype(variant.as<JsonArrayConst>()), JsonArrayConst>::value);
+
+  CHECK(is_same<decltype(variant.as<JsonVariant>()),
+                InvalidConversion<JsonVariantConst, JsonVariant>>::value);
+  CHECK(is_same<decltype(variant.as<JsonObject>()),
+                InvalidConversion<JsonVariantConst, JsonObject>>::value);
+  CHECK(is_same<decltype(variant.as<JsonArray>()),
+                InvalidConversion<JsonVariantConst, JsonArray>>::value);
+}

ArduinoJson/extras/tests/JsonVariantConst/is.cpp

@@ -0,0 +1,162 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+enum MYENUM2 { ONE = 1, TWO = 2 };
+
+TEST_CASE("JsonVariantConst::is<T>()") {
+  JsonDocument doc;
+  JsonVariantConst var = doc.to<JsonVariant>();
+
+  SECTION("unbound") {
+    var = JsonVariantConst();
+
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonArrayConst>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonObjectConst>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<JsonVariantConst>() == false);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("null") {
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("true") {
+    doc.set(true);
+
+    CHECK(var.is<bool>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("false") {
+    doc.set(false);
+
+    CHECK(var.is<bool>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("int") {
+    doc.set(42);
+
+    CHECK(var.is<int>() == true);
+    CHECK(var.is<short>() == true);
+    CHECK(var.is<long>() == true);
+    CHECK(var.is<double>() == true);
+    CHECK(var.is<float>() == true);
+    CHECK(var.is<MYENUM2>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+  }
+
+  SECTION("double") {
+    doc.set(4.2);
+
+    CHECK(var.is<double>() == true);
+    CHECK(var.is<float>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<std::string>() == false);
+    CHECK(var.is<JsonString>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("const char*") {
+    doc.set("4.2");
+
+    CHECK(var.is<const char*>() == true);
+    CHECK(var.is<const char*>() == true);
+    CHECK(var.is<std::string>() == true);
+    CHECK(var.is<JsonString>() == true);
+    CHECK(var.is<double>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("JsonArray") {
+    doc.to<JsonArray>();
+
+    CHECK(var.is<JsonArrayConst>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonObjectConst>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+
+  SECTION("JsonObject") {
+    doc.to<JsonObject>();
+
+    CHECK(var.is<JsonObjectConst>() == true);
+    CHECK(var.is<JsonVariantConst>() == true);
+    CHECK(var.is<JsonObject>() == false);
+    CHECK(var.is<JsonVariant>() == false);
+    CHECK(var.is<JsonArray>() == false);
+    CHECK(var.is<JsonArrayConst>() == false);
+    CHECK(var.is<int>() == false);
+    CHECK(var.is<float>() == false);
+    CHECK(var.is<bool>() == false);
+    CHECK(var.is<const char*>() == false);
+    CHECK(var.is<MYENUM2>() == false);
+  }
+}

ArduinoJson/extras/tests/JsonVariantConst/isnull.cpp

@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariantConst::isNull()") {
+  JsonDocument doc;
+  JsonVariantConst variant = doc.to<JsonVariant>();
+
+  SECTION("returns true when undefined") {
+    REQUIRE(variant.isNull() == true);
+  }
+
+  SECTION("returns false if value is integer") {
+    doc.set(42);
+
+    REQUIRE(variant.isNull() == false);
+  }
+}

ArduinoJson/extras/tests/JsonVariantConst/nesting.cpp

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariantConst::nesting()") {
+  JsonDocument doc;
+  JsonVariantConst var = doc.to<JsonVariant>();
+
+  SECTION("return 0 if unbound") {
+    JsonVariantConst unbound;
+    REQUIRE(unbound.nesting() == 0);
+  }
+
+  SECTION("returns 0 for string") {
+    doc.set("hello");
+    REQUIRE(var.nesting() == 0);
+  }
+
+  SECTION("returns 1 for empty object") {
+    doc.to<JsonObject>();
+    REQUIRE(var.nesting() == 1);
+  }
+
+  SECTION("returns 1 for empty array") {
+    doc.to<JsonArray>();
+    REQUIRE(var.nesting() == 1);
+  }
+}

ArduinoJson/extras/tests/JsonVariantConst/size.cpp

@@ -0,0 +1,36 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariantConst::size()") {
+  JsonDocument doc;
+  JsonVariantConst variant = doc.to<JsonVariant>();
+
+  SECTION("unbound reference") {
+    JsonVariantConst unbound;
+
+    CHECK(unbound.size() == 0);
+  }
+
+  SECTION("int") {
+    doc.set(42);
+
+    CHECK(variant.size() == 0);
+  }
+
+  SECTION("string") {
+    doc.set("hello");
+
+    CHECK(variant.size() == 0);
+  }
+
+  SECTION("object") {
+    doc["a"] = 1;
+    doc["b"] = 2;
+
+    CHECK(variant.size() == 2);
+  }
+}

ArduinoJson/extras/tests/JsonVariantConst/subscript.cpp

@@ -0,0 +1,104 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2025, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#include "Literals.hpp"
+
+TEST_CASE("JsonVariantConst::operator[]") {
+  JsonDocument doc;
+  JsonVariantConst var = doc.to<JsonVariant>();
+
+  SECTION("null") {
+    REQUIRE(0 == var.size());
+    REQUIRE(var["0"].isNull());
+    REQUIRE(var[0].isNull());
+  }
+
+  SECTION("string") {
+    doc.set("hello world");
+    REQUIRE(0 == var.size());
+    REQUIRE(var["0"].isNull());
+    REQUIRE(var[0].isNull());
+  }
+
+  SECTION("array") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add("A");
+    array.add("B");
+
+    SECTION("int") {
+      REQUIRE("A"_s == var[0]);
+      REQUIRE("B"_s == var[1]);
+      REQUIRE("A"_s == var[static_cast<unsigned char>(0)]);  // issue #381
+      REQUIRE(var[666].isNull());
+      REQUIRE(var[3].isNull());
+    }
+
+    SECTION("const char*") {
+      REQUIRE(var["0"].isNull());
+    }
+
+    SECTION("JsonVariant") {
+      array.add(1);
+      REQUIRE(var[var[2]] == "B"_s);
+      REQUIRE(var[var[3]].isNull());
+    }
+  }
+
+  SECTION("object") {
+    JsonObject object = doc.to<JsonObject>();
+    object["ab"_s] = "AB";
+    object["abc"_s] = "ABC";
+    object["abc\0d"_s] = "ABCD";
+
+    SECTION("string literal") {
+      REQUIRE(var["ab"] == "AB"_s);
+      REQUIRE(var["abc"] == "ABC"_s);
+      REQUIRE(var["abc\0d"] == "ABCD"_s);
+      REQUIRE(var["def"].isNull());
+      REQUIRE(var[0].isNull());
+    }
+
+    SECTION("const char*") {
+      REQUIRE(var[static_cast<const char*>("ab")] == "AB"_s);
+      REQUIRE(var[static_cast<const char*>("abc")] == "ABC"_s);
+      REQUIRE(var[static_cast<const char*>("abc\0d")] == "ABC"_s);
+      REQUIRE(var[static_cast<const char*>("def")].isNull());
+      REQUIRE(var[static_cast<const char*>(0)].isNull());
+    }
+
+    SECTION("supports std::string") {
+      REQUIRE(var["ab"_s] == "AB"_s);
+      REQUIRE(var["abc"_s] == "ABC"_s);
+      REQUIRE(var["abc\0d"_s] == "ABCD"_s);
+      REQUIRE(var["def"_s].isNull());
+    }
+
+#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \
+    !defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)
+    SECTION("supports VLA") {
+      size_t i = 16;
+      char vla[i];
+      strcpy(vla, "abc");
+
+      REQUIRE(var[vla] == "ABC"_s);
+    }
+#endif
+
+    SECTION("supports JsonVariant") {
+      object["key1"] = "ab";
+      object["key2"] = "abc";
+      object["key3"] = "abc\0d"_s;
+      object["key4"] = "foo";
+
+      REQUIRE(var[var["key1"]] == "AB"_s);
+      REQUIRE(var[var["key2"]] == "ABC"_s);
+      REQUIRE(var[var["key3"]] == "ABCD"_s);
+      REQUIRE(var[var["key4"]].isNull());
+      REQUIRE(var[var["key5"]].isNull());
+    }
+  }
+}