Add more tests for JsonVariantConst

extras/tests/JsonVariantConst/CMakeLists.txt

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

extras/tests/JsonVariantConst/as.cpp

@@ -0,0 +1,19 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.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*>() == std::string("hello"));
+  REQUIRE(var.as<std::string>() == std::string("hello"));
+}

extras/tests/JsonVariantConst/containsKey.cpp

@@ -0,0 +1,33 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariantConst::containsKey()") {
+  JsonDocument doc;
+  doc["hello"] = "world";
+  JsonVariantConst var = doc.as<JsonVariant>();
+
+  SECTION("support const char*") {
+    REQUIRE(var.containsKey("hello") == true);
+    REQUIRE(var.containsKey("world") == false);
+  }
+
+  SECTION("support std::string") {
+    REQUIRE(var.containsKey(std::string("hello")) == true);
+    REQUIRE(var.containsKey(std::string("world")) == false);
+  }
+
+#ifdef HAS_VARIABLE_LENGTH_ARRAY
+  SECTION("supports VLA") {
+    size_t i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    REQUIRE(true == var.containsKey(vla));
+  }
+#endif
+}

extras/tests/JsonVariantConst/is.cpp

@@ -0,0 +1,162 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, 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);
+  }
+}

extras/tests/JsonVariantConst/isnull.cpp

@@ -0,0 +1,21 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, 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);
+  }
+}

extras/tests/JsonVariantConst/nesting.cpp

@@ -0,0 +1,31 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, 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);
+  }
+}

extras/tests/JsonVariantConst/size.cpp

@@ -0,0 +1,36 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, 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);
+  }
+}

extras/tests/JsonVariantConst/subscript.cpp

@@ -0,0 +1,68 @@
+// ArduinoJson - https://arduinojson.org
+// Copyright © 2014-2024, Benoit BLANCHON
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.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");
+
+    REQUIRE(std::string("A") == var[0]);
+    REQUIRE(std::string("B") == var[1]);
+    REQUIRE(std::string("A") ==
+            var[static_cast<unsigned char>(0)]);  // issue #381
+    REQUIRE(var[666].isNull());
+    REQUIRE(var[3].isNull());
+    REQUIRE(var["0"].isNull());
+  }
+
+  SECTION("object") {
+    JsonObject object = doc.to<JsonObject>();
+    object["a"] = "A";
+    object["b"] = "B";
+
+    SECTION("supports const char*") {
+      REQUIRE(std::string("A") == var["a"]);
+      REQUIRE(std::string("B") == var["b"]);
+      REQUIRE(var["c"].isNull());
+      REQUIRE(var[0].isNull());
+    }
+
+    SECTION("supports std::string") {
+      REQUIRE(std::string("A") == var[std::string("a")]);
+      REQUIRE(std::string("B") == var[std::string("b")]);
+      REQUIRE(var[std::string("c")].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, "a");
+
+      REQUIRE(std::string("A") == var[vla]);
+    }
+#endif
+  }
+}