Add more tests for `JsonVariantConst`

extras/tests/CMakeLists.txt

@@ -23,6 +23,7 @@ add_subdirectory(JsonObject)
 add_subdirectory(JsonObjectConst)
 add_subdirectory(JsonSerializer)
 add_subdirectory(JsonVariant)
+add_subdirectory(JsonVariantConst)
 add_subdirectory(ResourceManager)
 add_subdirectory(Misc)
 add_subdirectory(MixedConfiguration)

extras/tests/JsonVariant/as.cpp

@@ -251,17 +251,6 @@ TEST_CASE("JsonVariant::as()") {
   }
 #endif
 
-  SECTION("should work on JsonVariantConst") {
-    variant.set("hello");
-
-    JsonVariantConst cvar = variant;
-
-    REQUIRE(cvar.as<bool>() == true);
-    REQUIRE(cvar.as<long>() == 0L);
-    REQUIRE(cvar.as<const char*>() == std::string("hello"));
-    REQUIRE(cvar.as<std::string>() == std::string("hello"));
-  }
-
   SECTION("as<enum>()") {
     variant.set(1);
 

extras/tests/JsonVariant/containsKey.cpp

@@ -24,19 +24,3 @@ TEST_CASE("JsonVariant::containsKey()") {
     REQUIRE(var.containsKey(std::string("world")) == false);
   }
 }
-
-TEST_CASE("JsonVariantConst::containsKey()") {
-  JsonDocument doc;
-  doc["hello"] = "world";
-  JsonVariantConst cvar = doc.as<JsonVariant>();
-
-  SECTION("containsKey(const char*) returns true") {
-    REQUIRE(cvar.containsKey("hello") == true);
-    REQUIRE(cvar.containsKey("world") == false);
-  }
-
-  SECTION("containsKey(std::string) returns true") {
-    REQUIRE(cvar.containsKey(std::string("hello")) == true);
-    REQUIRE(cvar.containsKey(std::string("world")) == false);
-  }
-}

extras/tests/JsonVariant/is.cpp

@@ -162,158 +162,3 @@ TEST_CASE("JsonVariant::is<T>()") {
     CHECK(variant.is<JsonVariantConst>() == true);
   }
 }
-
-TEST_CASE("JsonVariantConst::is<T>()") {
-  JsonDocument doc;
-  JsonVariant variant = doc.to<JsonVariant>();
-  JsonVariantConst cvariant = variant;
-
-  SECTION("unbound") {
-    cvariant = JsonVariantConst();
-
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonArrayConst>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonObjectConst>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonVariantConst>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("null") {
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("true") {
-    variant.set(true);
-
-    CHECK(cvariant.is<bool>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("false") {
-    variant.set(false);
-
-    CHECK(cvariant.is<bool>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("int") {
-    variant.set(42);
-
-    CHECK(cvariant.is<int>() == true);
-    CHECK(cvariant.is<short>() == true);
-    CHECK(cvariant.is<long>() == true);
-    CHECK(cvariant.is<double>() == true);
-    CHECK(cvariant.is<float>() == true);
-    CHECK(cvariant.is<MYENUM2>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-  }
-
-  SECTION("double") {
-    variant.set(4.2);
-
-    CHECK(cvariant.is<double>() == true);
-    CHECK(cvariant.is<float>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<std::string>() == false);
-    CHECK(cvariant.is<JsonString>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("const char*") {
-    variant.set("4.2");
-
-    CHECK(cvariant.is<const char*>() == true);
-    CHECK(cvariant.is<const char*>() == true);
-    CHECK(cvariant.is<std::string>() == true);
-    CHECK(cvariant.is<JsonString>() == true);
-    CHECK(cvariant.is<double>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("JsonArray") {
-    variant.to<JsonArray>();
-
-    CHECK(cvariant.is<JsonArrayConst>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonObjectConst>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-
-  SECTION("JsonObject") {
-    variant.to<JsonObject>();
-
-    CHECK(cvariant.is<JsonObjectConst>() == true);
-    CHECK(cvariant.is<JsonVariantConst>() == true);
-    CHECK(cvariant.is<JsonObject>() == false);
-    CHECK(cvariant.is<JsonVariant>() == false);
-    CHECK(cvariant.is<JsonArray>() == false);
-    CHECK(cvariant.is<JsonArrayConst>() == false);
-    CHECK(cvariant.is<int>() == false);
-    CHECK(cvariant.is<float>() == false);
-    CHECK(cvariant.is<bool>() == false);
-    CHECK(cvariant.is<const char*>() == false);
-    CHECK(cvariant.is<MYENUM2>() == false);
-  }
-}

extras/tests/JsonVariant/isnull.cpp

@@ -69,12 +69,4 @@ TEST_CASE("JsonVariant::isNull()") {
     variant.set(serialized(static_cast<const char*>(0)));
     REQUIRE(variant.isNull() == true);
   }
-
-  SECTION("works with JsonVariantConst") {
-    variant.set(42);
-
-    JsonVariantConst cvar = variant;
-
-    REQUIRE(cvar.isNull() == false);
-  }
 }

extras/tests/JsonVariant/subscript.cpp

@@ -130,75 +130,3 @@ TEST_CASE("JsonVariant::operator[]") {
   }
 #endif
 }
-
-TEST_CASE("JsonVariantConst::operator[]") {
-  JsonDocument doc;
-  JsonVariant var = doc.to<JsonVariant>();
-  JsonVariantConst cvar = var;
-
-  SECTION("The JsonVariant is null") {
-    REQUIRE(0 == cvar.size());
-    REQUIRE(cvar["0"].isNull());
-    REQUIRE(cvar[0].isNull());
-  }
-
-  SECTION("The JsonVariant is a string") {
-    var.set("hello world");
-    REQUIRE(0 == cvar.size());
-    REQUIRE(cvar["0"].isNull());
-    REQUIRE(cvar[0].isNull());
-  }
-
-  SECTION("The JsonVariant is a JsonArray") {
-    JsonArray array = var.to<JsonArray>();
-
-    SECTION("get value") {
-      array.add("element at index 0");
-      array.add("element at index 1");
-
-      REQUIRE(2 == cvar.size());
-      REQUIRE(std::string("element at index 0") == cvar[0]);
-      REQUIRE(std::string("element at index 1") == cvar[1]);
-      REQUIRE(std::string("element at index 0") ==
-              var[static_cast<unsigned char>(0)]);  // issue #381
-      REQUIRE(cvar[666].isNull());
-      REQUIRE(cvar[3].isNull());
-      REQUIRE(cvar["0"].isNull());
-    }
-  }
-
-  SECTION("The JsonVariant is a JsonObject") {
-    JsonObject object = var.to<JsonObject>();
-
-    SECTION("get value") {
-      object["a"] = "element at key \"a\"";
-      object["b"] = "element at key \"b\"";
-
-      REQUIRE(2 == cvar.size());
-      REQUIRE(std::string("element at key \"a\"") == cvar["a"]);
-      REQUIRE(std::string("element at key \"b\"") == cvar["b"]);
-      REQUIRE(cvar["c"].isNull());
-      REQUIRE(cvar[0].isNull());
-    }
-  }
-
-  SECTION("Auto promote null JsonVariant to JsonObject") {
-    var["hello"] = "world";
-
-    REQUIRE(var.is<JsonObject>() == true);
-  }
-
-  SECTION("Don't auto promote non-null JsonVariant to JsonObject") {
-    var.set(42);
-    var["hello"] = "world";
-
-    REQUIRE(var.is<JsonObject>() == false);
-  }
-
-  SECTION("Don't auto promote null JsonVariant to JsonObject when reading") {
-    const char* value = var["hello"];
-
-    REQUIRE(var.is<JsonObject>() == false);
-    REQUIRE(value == 0);
-  }
-}

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
+  }
+}