JsonVariant automatically promotes to JsonObject or JsonArray on write

test/JsonVariant/CMakeLists.txt

@@ -3,18 +3,21 @@
 # MIT License
 
 add_executable(JsonVariantTests
+	add.cpp
 	as.cpp
 	compare.cpp
 	copy.cpp
+	createNested.cpp
 	get.cpp
 	is.cpp
 	isnull.cpp
 	memoryUsage.cpp
-	nesting.cpp
 	misc.cpp
+	nesting.cpp
 	or.cpp
 	set.cpp
 	subscript.cpp
+	types.cpp
 	undefined.cpp
 )
 

test/JsonVariant/add.cpp

@@ -0,0 +1,39 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+
+static const char* null = 0;
+
+TEST_CASE("JsonVariant::add()") {
+  DynamicJsonDocument doc(4096);
+  JsonVariant var = doc.to<JsonVariant>();
+
+  SECTION("No argument") {
+    JsonVariant nested = var.add();
+
+    REQUIRE(var.is<JsonArray>() == true);
+    REQUIRE(nested.isNull() == true);
+  }
+
+  SECTION("integer") {
+    var.add(42);
+
+    REQUIRE(var.as<std::string>() == "[42]");
+  }
+
+  SECTION("const char*") {
+    var.add("hello");
+
+    REQUIRE(var.as<std::string>() == "[\"hello\"]");
+  }
+
+  SECTION("std::string") {
+    var.add(std::string("hello"));
+
+    REQUIRE(var.as<std::string>() == "[\"hello\"]");
+  }
+}

test/JsonVariant/createNested.cpp

@@ -0,0 +1,88 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+
+static const char* null = 0;
+
+TEST_CASE("JsonVariant::createNestedObject()") {
+  DynamicJsonDocument doc(4096);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("promotes to array") {
+    JsonObject obj = variant.createNestedObject();
+    obj["value"] = "42";
+
+    REQUIRE(variant.is<JsonArray>() == true);
+    REQUIRE(variant[0]["value"] == 42);
+    REQUIRE(obj.isNull() == false);
+  }
+
+  SECTION("works on MemberProxy") {
+    JsonObject obj = variant["items"].createNestedObject();
+    obj["value"] = "42";
+
+    REQUIRE(variant["items"][0]["value"] == 42);
+  }
+}
+
+TEST_CASE("JsonVariant::createNestedArray()") {
+  DynamicJsonDocument doc(4096);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("promotes to array") {
+    JsonArray arr = variant.createNestedArray();
+
+    REQUIRE(variant.is<JsonArray>() == true);
+    REQUIRE(arr.isNull() == false);
+  }
+
+  SECTION("works on MemberProxy") {
+    JsonArray arr = variant["items"].createNestedArray();
+    arr.add("42");
+
+    REQUIRE(variant["items"][0][0] == 42);
+  }
+}
+
+TEST_CASE("JsonVariant::createNestedObject(key)") {
+  DynamicJsonDocument doc(4096);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("promotes to object") {
+    JsonObject obj = variant.createNestedObject("weather");
+    obj["temp"] = "42";
+
+    REQUIRE(variant.is<JsonObject>() == true);
+    REQUIRE(variant["weather"]["temp"] == 42);
+  }
+
+  SECTION("works on MemberProxy") {
+    JsonObject obj = variant["status"].createNestedObject("weather");
+    obj["temp"] = "42";
+
+    REQUIRE(variant["status"]["weather"]["temp"] == 42);
+  }
+}
+
+TEST_CASE("JsonVariant::createNestedArray(key)") {
+  DynamicJsonDocument doc(4096);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  SECTION("promotes to object") {
+    JsonArray arr = variant.createNestedArray("items");
+
+    REQUIRE(variant.is<JsonObject>() == true);
+    REQUIRE(arr.isNull() == false);
+  }
+
+  SECTION("works on MemberProxy") {
+    JsonArray arr = variant["weather"].createNestedArray("temp");
+    arr.add("42");
+
+    REQUIRE(variant["weather"]["temp"][0] == 42);
+  }
+}

test/JsonVariant/get.cpp

@@ -3,138 +3,27 @@
 // MIT License
 
 #include <ArduinoJson.h>
-#include <stdint.h>
 #include <catch.hpp>
-#include <limits>
 
-template <typename T>
-void checkValue(T expected) {
+TEST_CASE("JsonVariant::get()") {
   DynamicJsonDocument doc(4096);
-  JsonVariant variant = doc.to<JsonVariant>();
+  JsonVariant var = doc.to<JsonVariant>();
 
-  variant.set(expected);
-  REQUIRE(expected == variant.as<T>());
-}
+  SECTION("get(const char*)") {
+    var["value"] = 42;
 
-template <typename T>
-void checkReference(T &expected) {
-  JsonVariant variant = expected;
-  REQUIRE(expected == variant.as<T &>());
-}
-
-template <typename T>
-void checkNumericType() {
-  DynamicJsonDocument docMin(4096), docMax(4096);
-  JsonVariant variantMin = docMin.to<JsonVariant>();
-  JsonVariant variantMax = docMax.to<JsonVariant>();
-
-  T min = std::numeric_limits<T>::min();
-  T max = std::numeric_limits<T>::max();
-
-  variantMin.set(min);
-  variantMax.set(max);
-
-  REQUIRE(min == variantMin.as<T>());
-  REQUIRE(max == variantMax.as<T>());
-}
-
-TEST_CASE("JsonVariant set()/get()") {
-#if ARDUINOJSON_USE_LONG_LONG
-  SECTION("SizeOfJsonInteger") {
-    REQUIRE(8 == sizeof(JsonInteger));
-  }
-#endif
-
-  SECTION("Null") {
-    checkValue<const char *>(NULL);
-  }
-  SECTION("const char*") {
-    checkValue<const char *>("hello");
-  }
-  SECTION("std::string") {
-    checkValue<std::string>("hello");
+    REQUIRE(var.get("value") == 42);
   }
 
-  SECTION("False") {
-    checkValue<bool>(false);
-  }
-  SECTION("True") {
-    checkValue<bool>(true);
+  SECTION("get(std::string)") {
+    var["value"] = 42;
+
+    REQUIRE(var.get(std::string("value")) == 42);
   }
 
-  SECTION("Double") {
-    checkNumericType<double>();
-  }
-  SECTION("Float") {
-    checkNumericType<float>();
-  }
-  SECTION("Char") {
-    checkNumericType<char>();
-  }
-  SECTION("SChar") {
-    checkNumericType<signed char>();
-  }
-  SECTION("SInt") {
-    checkNumericType<signed int>();
-  }
-  SECTION("SLong") {
-    checkNumericType<signed long>();
-  }
-  SECTION("SShort") {
-    checkNumericType<signed short>();
-  }
-  SECTION("UChar") {
-    checkNumericType<unsigned char>();
-  }
-  SECTION("UInt") {
-    checkNumericType<unsigned int>();
-  }
-  SECTION("ULong") {
-    checkNumericType<unsigned long>();
-  }
-  SECTION("UShort") {
-    checkNumericType<unsigned short>();
-  }
-#if ARDUINOJSON_USE_LONG_LONG
-  SECTION("LongLong") {
-    checkNumericType<unsigned long long>();
-  }
-  SECTION("ULongLong") {
-    checkNumericType<unsigned long long>();
-  }
-#endif
+  SECTION("get(int)") {
+    var.add().set(42);
 
-  SECTION("Int8") {
-    checkNumericType<int8_t>();
-  }
-  SECTION("Uint8") {
-    checkNumericType<uint8_t>();
-  }
-  SECTION("Int16") {
-    checkNumericType<int16_t>();
-  }
-  SECTION("Uint16") {
-    checkNumericType<uint16_t>();
-  }
-  SECTION("Int32") {
-    checkNumericType<int32_t>();
-  }
-  SECTION("Uint32") {
-    checkNumericType<uint32_t>();
-  }
-#if ARDUINOJSON_USE_LONG_LONG
-  SECTION("Int64") {
-    checkNumericType<int64_t>();
-  }
-  SECTION("Uint64") {
-    checkNumericType<uint64_t>();
-  }
-#endif
-
-  SECTION("CanStoreObject") {
-    DynamicJsonDocument doc(4096);
-    JsonObject object = doc.to<JsonObject>();
-
-    checkValue<JsonObject>(object);
+    REQUIRE(var.get(0) == 42);
   }
 }

test/JsonVariant/subscript.cpp

@@ -30,7 +30,8 @@ TEST_CASE("JsonVariant::operator[]") {
       array.add("element at index 1");
 
       REQUIRE(2 == var.size());
-      REQUIRE(std::string("element at index 0") == var[0]);
+      var[0].as<std::string>();
+      // REQUIRE(std::string("element at index 0") == );
       REQUIRE(std::string("element at index 1") == var[1]);
       REQUIRE(std::string("element at index 0") ==
               var[static_cast<unsigned char>(0)]);  // issue #381
@@ -171,4 +172,24 @@ TEST_CASE("JsonVariantConst::operator[]") {
       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);
+  }
 }

test/JsonVariant/types.cpp

@@ -0,0 +1,140 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <stdint.h>
+#include <catch.hpp>
+#include <limits>
+
+template <typename T>
+void checkValue(T expected) {
+  DynamicJsonDocument doc(4096);
+  JsonVariant variant = doc.to<JsonVariant>();
+
+  variant.set(expected);
+  REQUIRE(expected == variant.as<T>());
+}
+
+template <typename T>
+void checkReference(T &expected) {
+  JsonVariant variant = expected;
+  REQUIRE(expected == variant.as<T &>());
+}
+
+template <typename T>
+void checkNumericType() {
+  DynamicJsonDocument docMin(4096), docMax(4096);
+  JsonVariant variantMin = docMin.to<JsonVariant>();
+  JsonVariant variantMax = docMax.to<JsonVariant>();
+
+  T min = std::numeric_limits<T>::min();
+  T max = std::numeric_limits<T>::max();
+
+  variantMin.set(min);
+  variantMax.set(max);
+
+  REQUIRE(min == variantMin.as<T>());
+  REQUIRE(max == variantMax.as<T>());
+}
+
+TEST_CASE("JsonVariant set()/get()") {
+#if ARDUINOJSON_USE_LONG_LONG
+  SECTION("SizeOfJsonInteger") {
+    REQUIRE(8 == sizeof(JsonInteger));
+  }
+#endif
+
+  SECTION("Null") {
+    checkValue<const char *>(NULL);
+  }
+  SECTION("const char*") {
+    checkValue<const char *>("hello");
+  }
+  SECTION("std::string") {
+    checkValue<std::string>("hello");
+  }
+
+  SECTION("False") {
+    checkValue<bool>(false);
+  }
+  SECTION("True") {
+    checkValue<bool>(true);
+  }
+
+  SECTION("Double") {
+    checkNumericType<double>();
+  }
+  SECTION("Float") {
+    checkNumericType<float>();
+  }
+  SECTION("Char") {
+    checkNumericType<char>();
+  }
+  SECTION("SChar") {
+    checkNumericType<signed char>();
+  }
+  SECTION("SInt") {
+    checkNumericType<signed int>();
+  }
+  SECTION("SLong") {
+    checkNumericType<signed long>();
+  }
+  SECTION("SShort") {
+    checkNumericType<signed short>();
+  }
+  SECTION("UChar") {
+    checkNumericType<unsigned char>();
+  }
+  SECTION("UInt") {
+    checkNumericType<unsigned int>();
+  }
+  SECTION("ULong") {
+    checkNumericType<unsigned long>();
+  }
+  SECTION("UShort") {
+    checkNumericType<unsigned short>();
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  SECTION("LongLong") {
+    checkNumericType<unsigned long long>();
+  }
+  SECTION("ULongLong") {
+    checkNumericType<unsigned long long>();
+  }
+#endif
+
+  SECTION("Int8") {
+    checkNumericType<int8_t>();
+  }
+  SECTION("Uint8") {
+    checkNumericType<uint8_t>();
+  }
+  SECTION("Int16") {
+    checkNumericType<int16_t>();
+  }
+  SECTION("Uint16") {
+    checkNumericType<uint16_t>();
+  }
+  SECTION("Int32") {
+    checkNumericType<int32_t>();
+  }
+  SECTION("Uint32") {
+    checkNumericType<uint32_t>();
+  }
+#if ARDUINOJSON_USE_LONG_LONG
+  SECTION("Int64") {
+    checkNumericType<int64_t>();
+  }
+  SECTION("Uint64") {
+    checkNumericType<uint64_t>();
+  }
+#endif
+
+  SECTION("CanStoreObject") {
+    DynamicJsonDocument doc(4096);
+    JsonObject object = doc.to<JsonObject>();
+
+    checkValue<JsonObject>(object);
+  }
+}