add arduino json lib

#182

lib/ArduinoJson/test/Misc/CMakeLists.txt

@@ -0,0 +1,18 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
+# MIT License
+
+add_executable(MiscTests 
+	deprecated.cpp
+	FloatParts.cpp
+	std_stream.cpp
+	std_string.cpp
+	StringBuilder.cpp
+	StringTraits.cpp
+	TypeTraits.cpp
+	unsigned_char.cpp
+	vla.cpp
+)
+
+target_link_libraries(MiscTests catch)
+add_test(Misc MiscTests)

lib/ArduinoJson/test/Misc/FloatParts.cpp

@@ -0,0 +1,44 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Serialization/FloatParts.hpp>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+TEST_CASE("FloatParts<double>") {
+  SECTION("1.7976931348623157E+308") {
+    FloatParts<double> parts(1.7976931348623157E+308);
+    REQUIRE(parts.integral == 1);
+    REQUIRE(parts.decimal == 797693135);
+    REQUIRE(parts.decimalPlaces == 9);
+    REQUIRE(parts.exponent == 308);
+  }
+
+  SECTION("4.94065645841247e-324") {
+    FloatParts<double> parts(4.94065645841247e-324);
+    REQUIRE(parts.integral == 4);
+    REQUIRE(parts.decimal == 940656458);
+    REQUIRE(parts.decimalPlaces == 9);
+    REQUIRE(parts.exponent == -324);
+  }
+}
+
+TEST_CASE("FloatParts<float>") {
+  SECTION("3.4E+38") {
+    FloatParts<float> parts(3.4E+38f);
+    REQUIRE(parts.integral == 3);
+    REQUIRE(parts.decimal == 4);
+    REQUIRE(parts.decimalPlaces == 1);
+    REQUIRE(parts.exponent == 38);
+  }
+
+  SECTION("1.17549435e−38") {
+    FloatParts<float> parts(1.17549435e-38f);
+    REQUIRE(parts.integral == 1);
+    REQUIRE(parts.decimal == 175494);
+    REQUIRE(parts.decimalPlaces == 6);
+    REQUIRE(parts.exponent == -38);
+  }
+}

lib/ArduinoJson/test/Misc/StringBuilder.cpp

@@ -0,0 +1,50 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+template <typename StringBuilder, typename String>
+void common_tests(StringBuilder& sb, const String& output) {
+  SECTION("InitialState") {
+    REQUIRE(std::string("") == output);
+  }
+
+  SECTION("EmptyString") {
+    REQUIRE(0 == sb.print(""));
+    REQUIRE(std::string("") == output);
+  }
+
+  SECTION("OneString") {
+    REQUIRE(4 == sb.print("ABCD"));
+    REQUIRE(std::string("ABCD") == output);
+  }
+
+  SECTION("TwoStrings") {
+    REQUIRE(4 == sb.print("ABCD"));
+    REQUIRE(4 == sb.print("EFGH"));
+    REQUIRE(std::string("ABCDEFGH") == output);
+  }
+}
+
+TEST_CASE("StaticStringBuilder") {
+  char output[20];
+  StaticStringBuilder sb(output, sizeof(output));
+
+  common_tests(sb, static_cast<const char*>(output));
+
+  SECTION("OverCapacity") {
+    REQUIRE(19 == sb.print("ABCDEFGHIJKLMNOPQRSTUVWXYZ"));
+    REQUIRE(0 == sb.print("ABC"));
+    REQUIRE(std::string("ABCDEFGHIJKLMNOPQRS") == output);
+  }
+}
+
+TEST_CASE("DynamicStringBuilder") {
+  std::string output;
+  DynamicStringBuilder<std::string> sb(output);
+  common_tests(sb, output);
+}

lib/ArduinoJson/test/Misc/StringTraits.cpp

@@ -0,0 +1,22 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+template <typename String>
+bool should_duplicate() {
+  return StringTraits<String>::should_duplicate;
+}
+
+TEST_CASE("StringTraits") {
+  SECTION("should_duplicate") {
+    REQUIRE(false == should_duplicate<const char*>());
+    REQUIRE(true == should_duplicate<char*>());
+    REQUIRE(true == should_duplicate<RawJsonString<char*> >());
+    REQUIRE(false == should_duplicate<RawJsonString<const char*> >());
+  }
+}

lib/ArduinoJson/test/Misc/TypeTraits.cpp

@@ -0,0 +1,37 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+TEST_CASE("TypeTraits") {
+  SECTION("IsBaseOf") {
+    REQUIRE_FALSE(
+        static_cast<bool>(IsBaseOf<std::istream, std::ostringstream>::value));
+    REQUIRE(
+        static_cast<bool>(IsBaseOf<std::istream, std::istringstream>::value));
+    REQUIRE(static_cast<bool>(
+        IsBaseOf<JsonVariantBase<JsonObjectSubscript<const char*> >,
+                 JsonObjectSubscript<const char*> >::value));
+  }
+
+  SECTION("IsArray") {
+    REQUIRE_FALSE((IsArray<const char*>::value));
+    REQUIRE((IsArray<const char[]>::value));
+    REQUIRE((IsArray<const char[10]>::value));
+  }
+
+  SECTION("IsVariant") {
+    REQUIRE(
+        static_cast<bool>(IsVariant<JsonObjectSubscript<const char*> >::value));
+    REQUIRE(static_cast<bool>(IsVariant<JsonVariant>::value));
+  }
+
+  SECTION("IsConst") {
+    REQUIRE_FALSE((IsConst<char>::value));
+    REQUIRE((IsConst<const char>::value));
+  }
+}

lib/ArduinoJson/test/Misc/deprecated.cpp

@@ -0,0 +1,140 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#define ARDUINOJSON_ENABLE_DEPRECATED 1
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+#elif defined(_MSC_VER)
+#pragma warning(disable : 4996)
+#endif
+
+TEST_CASE("Deprecated functions") {
+  DynamicJsonBuffer jsonBuffer;
+
+  SECTION("JsonVariant::asArray()") {
+    JsonVariant variant = jsonBuffer.createArray();
+    REQUIRE(variant.asArray().success());
+  }
+
+  SECTION("JsonVariant::asObject()") {
+    JsonVariant variant = jsonBuffer.createObject();
+    REQUIRE(variant.asObject().success());
+  }
+
+  SECTION("JsonVariant::asString()") {
+    JsonVariant variant = "hello";
+    REQUIRE(std::string("hello") == variant.asString());
+  }
+
+  SECTION("JsonArray::removeAt()") {
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.removeAt(0);
+  }
+
+  SECTION("JsonVariant::JsonVariant(float, uint8_t)") {
+    JsonVariant variant(3.14f, 2);
+    REQUIRE(variant == 3.14f);
+  }
+
+  SECTION("JsonVariant::JsonVariant(double, uint8_t)") {
+    JsonVariant variant(3.14, 2);
+    REQUIRE(variant == 3.14);
+  }
+
+  SECTION("float_with_n_digits()") {
+    JsonVariant variant = float_with_n_digits(3.14f, 4);
+    REQUIRE(variant == 3.14f);
+  }
+
+  SECTION("double_with_n_digits()") {
+    JsonVariant variant = double_with_n_digits(3.14f, 4);
+    REQUIRE(variant == 3.14f);
+  }
+
+  SECTION("JsonArraySubscript::set(double, uint8_t)") {
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add(666);
+    arr[0].set(123.45, 2);
+    REQUIRE(123.45 == arr[0].as<double>());
+    REQUIRE(true == arr[0].is<double>());
+    REQUIRE(false == arr[0].is<int>());
+  }
+
+  SECTION("JsonArray::add(double, uint8_t)") {
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add(3.14159265358979323846, 4);
+  }
+
+  SECTION("JsonArray::add(float, uint8_t)") {
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add(3.14159265358979323846f, 4);
+  }
+
+  SECTION("JsonObject::set(unsigned char[], double, uint8_t)") {
+    unsigned char key[] = "hello";
+
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set(key, 3.14, 2);
+
+    REQUIRE(3.14 == obj["hello"]);
+  }
+
+  SECTION("JsonObject::set(const char*, double, uint8_t)") {
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set("hello", 123.45, 2);
+
+    REQUIRE(123.45 == obj["hello"].as<double>());
+    REQUIRE(obj["hello"].is<double>());
+    REQUIRE_FALSE(obj["hello"].is<long>());
+  }
+
+  SECTION("JsonObjectSubscript::set(double, uint8_t)") {
+    JsonObject& obj = jsonBuffer.createObject();
+    obj["hello"].set(123.45, 2);
+
+    REQUIRE(true == obj["hello"].is<double>());
+    REQUIRE(false == obj["hello"].is<long>());
+    REQUIRE(123.45 == obj["hello"].as<double>());
+  }
+}
+
+TEST_CASE("DynamicJsonBuffer::strdup()") {
+  DynamicJsonBuffer buffer;
+
+  SECTION("char*") {
+    char original[] = "hello";
+    const char* copy = buffer.strdup(original);
+    strcpy(original, "world");
+    REQUIRE(std::string("hello") == copy);
+  }
+
+  SECTION("unsigned char*") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    const char* dup = jsonBuffer.strdup(value);
+
+    REQUIRE(static_cast<const void*>(value) != static_cast<const void*>(dup));
+    REQUIRE(std::string("world") == dup);
+  }
+
+  SECTION("std::string") {
+    std::string original("hello");
+    const char* copy = buffer.strdup(original);
+    original[0] = 'w';
+    REQUIRE(std::string("hello") == copy);
+  }
+
+  SECTION("NULL") {
+    const char* original = NULL;
+    const char* copy = buffer.strdup(original);
+    REQUIRE(0 == copy);
+  }
+}

lib/ArduinoJson/test/Misc/std_stream.cpp

@@ -0,0 +1,84 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <sstream>
+
+TEST_CASE("std::stream") {
+  SECTION("JsonVariantFalse") {
+    std::ostringstream os;
+    JsonVariant variant = false;
+    os << variant;
+    REQUIRE("false" == os.str());
+  }
+
+  SECTION("JsonVariantString") {
+    std::ostringstream os;
+    JsonVariant variant = "coucou";
+    os << variant;
+    REQUIRE("\"coucou\"" == os.str());
+  }
+
+  SECTION("JsonObject") {
+    std::ostringstream os;
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& object = jsonBuffer.createObject();
+    object["key"] = "value";
+    os << object;
+    REQUIRE("{\"key\":\"value\"}" == os.str());
+  }
+
+  SECTION("JsonObjectSubscript") {
+    std::ostringstream os;
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& object = jsonBuffer.createObject();
+    object["key"] = "value";
+    os << object["key"];
+    REQUIRE("\"value\"" == os.str());
+  }
+
+  SECTION("JsonArray") {
+    std::ostringstream os;
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& array = jsonBuffer.createArray();
+    array.add("value");
+    os << array;
+    REQUIRE("[\"value\"]" == os.str());
+  }
+
+  SECTION("JsonArraySubscript") {
+    std::ostringstream os;
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& array = jsonBuffer.createArray();
+    array.add("value");
+    os << array[0];
+    REQUIRE("\"value\"" == os.str());
+  }
+
+  SECTION("ParseArray") {
+    std::istringstream json(" [ 42 /* comment */ ] ");
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.parseArray(json);
+    REQUIRE(true == arr.success());
+    REQUIRE(1 == arr.size());
+    REQUIRE(42 == arr[0]);
+  }
+
+  SECTION("ParseObject") {
+    std::istringstream json(" { hello : world // comment\n }");
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject(json);
+    REQUIRE(true == obj.success());
+    REQUIRE(1 == obj.size());
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("ShouldNotReadPastTheEnd") {
+    std::istringstream json("{}123");
+    DynamicJsonBuffer jsonBuffer;
+    jsonBuffer.parseObject(json);
+    REQUIRE('1' == json.get());
+  }
+}

lib/ArduinoJson/test/Misc/std_string.cpp

@@ -0,0 +1,243 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+static void eraseString(std::string &str) {
+  char *p = const_cast<char *>(str.c_str());
+  while (*p) *p++ = '*';
+}
+
+TEST_CASE("std::string") {
+  DynamicJsonBuffer jb;
+
+  SECTION("JsonBuffer_ParseArray") {
+    std::string json("[\"hello\"]");
+    JsonArray &array = jb.parseArray(json);
+    eraseString(json);
+    REQUIRE(true == array.success());
+    REQUIRE(std::string("hello") == array[0]);
+  }
+
+  SECTION("JsonBuffer_ParseObject") {
+    std::string json("{\"hello\":\"world\"}");
+    JsonObject &object = jb.parseObject(json);
+    eraseString(json);
+    REQUIRE(true == object.success());
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_Subscript") {
+    char json[] = "{\"key\":\"value\"}";
+    JsonObject &object = jb.parseObject(json);
+    REQUIRE(std::string("value") == object[std::string("key")]);
+  }
+
+  SECTION("JsonObject_ConstSubscript") {
+    char json[] = "{\"key\":\"value\"}";
+    const JsonObject &object = jb.parseObject(json);
+    REQUIRE(std::string("value") == object[std::string("key")]);
+  }
+
+  SECTION("JsonObject_SetKey") {
+    JsonObject &object = jb.createObject();
+    std::string key("hello");
+    object.set(key, "world");
+    eraseString(key);
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_SetValue") {
+    JsonObject &object = jb.createObject();
+    std::string value("world");
+    object.set("hello", value);
+    eraseString(value);
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_SetKeyValue") {
+    JsonObject &object = jb.createObject();
+    std::string key("hello");
+    std::string value("world");
+    object.set(key, value);
+    eraseString(key);
+    eraseString(value);
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_SetToArraySubscript") {
+    JsonArray &arr = jb.createArray();
+    arr.add("world");
+
+    JsonObject &object = jb.createObject();
+    object.set(std::string("hello"), arr[0]);
+
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_SetToObjectSubscript") {
+    JsonObject &arr = jb.createObject();
+    arr.set("x", "world");
+
+    JsonObject &object = jb.createObject();
+    object.set(std::string("hello"), arr["x"]);
+
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObject_Get") {
+    char json[] = "{\"key\":\"value\"}";
+    const JsonObject &object = jb.parseObject(json);
+    REQUIRE(std::string("value") ==
+            object.get<const char *>(std::string("key")));
+  }
+
+  SECTION("JsonObject_GetT") {
+    char json[] = "{\"key\":\"value\"}";
+    const JsonObject &object = jb.parseObject(json);
+    REQUIRE(std::string("value") ==
+            object.get<const char *>(std::string("key")));
+  }
+
+  SECTION("JsonObject_IsT") {
+    char json[] = "{\"key\":\"value\"}";
+    const JsonObject &object = jb.parseObject(json);
+    REQUIRE(true == object.is<const char *>(std::string("key")));
+  }
+
+  SECTION("JsonObject_CreateNestedObject") {
+    std::string key = "key";
+    char json[64];
+    JsonObject &object = jb.createObject();
+    object.createNestedObject(key);
+    eraseString(key);
+    object.printTo(json, sizeof(json));
+    REQUIRE(std::string("{\"key\":{}}") == json);
+  }
+
+  SECTION("JsonObject_CreateNestedArray") {
+    std::string key = "key";
+    char json[64];
+    JsonObject &object = jb.createObject();
+    object.createNestedArray(key);
+    eraseString(key);
+    object.printTo(json, sizeof(json));
+    REQUIRE(std::string("{\"key\":[]}") == json);
+  }
+
+  SECTION("JsonObject_ContainsKey") {
+    char json[] = "{\"key\":\"value\"}";
+    const JsonObject &object = jb.parseObject(json);
+    REQUIRE(true == object.containsKey(std::string("key")));
+  }
+
+  SECTION("JsonObject_Remove") {
+    char json[] = "{\"key\":\"value\"}";
+    JsonObject &object = jb.parseObject(json);
+    REQUIRE(1 == object.size());
+    object.remove(std::string("key"));
+    REQUIRE(0 == object.size());
+  }
+
+  SECTION("JsonObjectSubscript_SetKey") {
+    JsonObject &object = jb.createObject();
+    std::string key("hello");
+    object[key] = "world";
+    eraseString(key);
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonObjectSubscript_SetValue") {
+    JsonObject &object = jb.createObject();
+    std::string value("world");
+    object["hello"] = value;
+    eraseString(value);
+    REQUIRE(std::string("world") == object["hello"]);
+  }
+
+  SECTION("JsonArray_Add") {
+    JsonArray &array = jb.createArray();
+    std::string value("hello");
+    array.add(value);
+    eraseString(value);
+    REQUIRE(std::string("hello") == array[0]);
+  }
+
+  SECTION("JsonArray_Set") {
+    JsonArray &array = jb.createArray();
+    std::string value("world");
+    array.add("hello");
+    array.set(0, value);
+    eraseString(value);
+    REQUIRE(std::string("world") == array[0]);
+  }
+
+  SECTION("JsonArraySubscript") {
+    JsonArray &array = jb.createArray();
+    std::string value("world");
+    array.add("hello");
+    array[0] = value;
+    eraseString(value);
+    REQUIRE(std::string("world") == array[0]);
+  }
+
+  SECTION("JsonArray_PrintTo") {
+    JsonArray &array = jb.createArray();
+    array.add(4);
+    array.add(2);
+    std::string json;
+    array.printTo(json);
+    REQUIRE(std::string("[4,2]") == json);
+  }
+
+  SECTION("JsonArray_PrettyPrintTo") {
+    JsonArray &array = jb.createArray();
+    array.add(4);
+    array.add(2);
+    std::string json;
+    array.prettyPrintTo(json);
+    REQUIRE(std::string("[\r\n  4,\r\n  2\r\n]") == json);
+  }
+
+  SECTION("JsonObject_PrintTo") {
+    JsonObject &object = jb.createObject();
+    object["key"] = "value";
+    std::string json;
+    object.printTo(json);
+    REQUIRE(std::string("{\"key\":\"value\"}") == json);
+  }
+
+  SECTION("JsonObject_PrettyPrintTo") {
+    JsonObject &object = jb.createObject();
+    object["key"] = "value";
+    std::string json;
+    object.prettyPrintTo(json);
+    REQUIRE(std::string("{\r\n  \"key\": \"value\"\r\n}") == json);
+  }
+
+  SECTION("JsonBuffer_GrowWhenAddingNewKey") {
+    JsonObject &object = jb.createObject();
+    std::string key1("hello"), key2("world");
+
+    object[key1] = 1;
+    size_t sizeBefore = jb.size();
+    object[key2] = 2;
+    size_t sizeAfter = jb.size();
+
+    REQUIRE(sizeAfter - sizeBefore >= key2.size());
+  }
+
+  SECTION("JsonBuffer_DontGrowWhenReusingKey") {
+    JsonObject &object = jb.createObject();
+    std::string key("hello");
+
+    object[key] = 1;
+    size_t sizeBefore = jb.size();
+    object[key] = 2;
+    size_t sizeAfter = jb.size();
+
+    REQUIRE(sizeBefore == sizeAfter);
+  }
+}

lib/ArduinoJson/test/Misc/unsigned_char.cpp

@@ -0,0 +1,262 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#if defined(__clang__)
+#define CONFLICTS_WITH_BUILTIN_OPERATOR
+#endif
+
+TEST_CASE("unsigned char string") {
+  SECTION("JsonBuffer::parseArray") {
+    unsigned char json[] = "[42]";
+
+    StaticJsonBuffer<JSON_ARRAY_SIZE(1)> jsonBuffer;
+    JsonArray& arr = jsonBuffer.parseArray(json);
+
+    REQUIRE(true == arr.success());
+  }
+
+  SECTION("JsonBuffer::parseObject") {
+    unsigned char json[] = "{\"a\":42}";
+
+    StaticJsonBuffer<JSON_OBJECT_SIZE(1)> jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject(json);
+
+    REQUIRE(true == obj.success());
+  }
+
+  SECTION("JsonVariant constructor") {
+    unsigned char value[] = "42";
+
+    JsonVariant variant(value);
+
+    REQUIRE(42 == variant.as<int>());
+  }
+
+  SECTION("JsonVariant assignment operator") {
+    unsigned char value[] = "42";
+
+    JsonVariant variant(666);
+    variant = value;
+
+    REQUIRE(42 == variant.as<int>());
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonVariant::operator[]") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonVariant variant = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == variant[key]);
+  }
+#endif
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonVariant::operator[] const") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == variant[key]);
+  }
+#endif
+
+  SECTION("JsonVariant::operator==") {
+    unsigned char comparand[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = "hello";
+
+    REQUIRE(comparand == variant);
+    REQUIRE(variant == comparand);
+    REQUIRE_FALSE(comparand != variant);
+    REQUIRE_FALSE(variant != comparand);
+  }
+
+  SECTION("JsonVariant::operator!=") {
+    unsigned char comparand[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = "world";
+
+    REQUIRE(comparand != variant);
+    REQUIRE(variant != comparand);
+    REQUIRE_FALSE(comparand == variant);
+    REQUIRE_FALSE(variant == comparand);
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonObject::operator[]") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj[key] = "world";
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+#endif
+
+  SECTION("JsonObjectSubscript::operator=") {  // issue #416
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj["hello"] = value;
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("JsonObjectSubscript::set()") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj["hello"].set(value);
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonObject::operator[] const") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == obj[key]);
+  }
+#endif
+
+  SECTION("JsonObject::get()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == obj.get<char*>(key));
+  }
+
+  SECTION("JsonObject::set() key") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set(key, "world");
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("JsonObject::set() value") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set("hello", value);
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("JsonObject::set key&value") {
+    unsigned char key[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set(key, key);
+
+    REQUIRE(std::string("world") == obj["world"]);
+  }
+
+  SECTION("JsonObject::containsKey()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(true == obj.containsKey(key));
+  }
+
+  SECTION("JsonObject::remove()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+    obj.remove(key);
+
+    REQUIRE(0 == obj.size());
+  }
+
+  SECTION("JsonObject::is()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":42}");
+
+    REQUIRE(true == obj.is<int>(key));
+  }
+
+  SECTION("JsonObject::createNestedArray()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.createNestedArray(key);
+  }
+
+  SECTION("JsonObject::createNestedObject()") {
+    unsigned char key[] = "hello";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.createNestedObject(key);
+  }
+
+  SECTION("JsonArray::add()") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add(value);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArray::set()") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr.set(0, value);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArraySubscript::set()") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr[0].set(value);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArraySubscript::operator=") {
+    unsigned char value[] = "world";
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr[0] = value;
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+}

lib/ArduinoJson/test/Misc/vla.cpp

@@ -0,0 +1,331 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wvla-extension"
+#define CONFLICTS_WITH_BUILTIN_OPERATOR
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wvla"
+#else
+#define VLA_NOT_SUPPORTED
+#endif
+
+#ifndef VLA_NOT_SUPPORTED
+
+TEST_CASE("Variable Length Array") {
+  SECTION("ParseArray") {
+    int i = 8;
+    char vla[i];
+    strcpy(vla, "[42]");
+
+    StaticJsonBuffer<JSON_ARRAY_SIZE(1)> jsonBuffer;
+    JsonArray& arr = jsonBuffer.parseArray(vla);
+
+    REQUIRE(true == arr.success());
+  }
+
+  SECTION("ParseObject") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "{\"a\":42}");
+
+    StaticJsonBuffer<JSON_OBJECT_SIZE(1)> jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject(vla);
+
+    REQUIRE(true == obj.success());
+  }
+
+  SECTION("Parse") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "42");
+
+    StaticJsonBuffer<1> jsonBuffer;
+    JsonVariant variant = jsonBuffer.parse(vla);
+
+    REQUIRE(42 == variant.as<int>());
+  }
+
+  SECTION("JsonVariant_Constructor") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "42");
+
+    JsonVariant variant(vla);
+
+    REQUIRE(42 == variant.as<int>());
+  }
+
+  SECTION("JsonVariant_Assign") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "42");
+
+    JsonVariant variant(666);
+    variant = vla;
+
+    REQUIRE(42 == variant.as<int>());
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonVariant_Subscript") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonVariant variant = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == variant[vla]);
+  }
+#endif
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonVariant_Subscript_Const") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == variant[vla]);
+  }
+#endif
+
+  SECTION("JsonVariant_Equals") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = "hello";
+
+    REQUIRE((vla == variant));
+    REQUIRE((variant == vla));
+    REQUIRE_FALSE((vla != variant));
+    REQUIRE_FALSE((variant != vla));
+  }
+
+  SECTION("JsonVariant_Differs") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonVariant variant = "world";
+
+    REQUIRE((vla != variant));
+    REQUIRE((variant != vla));
+    REQUIRE_FALSE((vla == variant));
+    REQUIRE_FALSE((variant == vla));
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonObject_Subscript") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj[vla] = "world";
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+#endif
+
+  SECTION("JsonObject_Subscript_Assign") {  // issue #416
+    int i = 32;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj["hello"] = vla;
+
+    REQUIRE(std::string("world") == obj["hello"].as<char*>());
+  }
+
+  SECTION("JsonObject_Subscript_Set") {
+    int i = 32;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj["hello"].set(vla);
+
+    REQUIRE(std::string("world") == obj["hello"].as<char*>());
+  }
+
+#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
+  SECTION("JsonObject_Subscript_Const") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == obj[vla]);
+  }
+#endif
+
+  SECTION("JsonObject_Get") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(std::string("world") == obj.get<char*>(vla));
+  }
+
+  SECTION("JsonObject_Set_Key") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set(vla, "world");
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("JsonObject_Set_Value") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set("hello", vla);
+
+    REQUIRE(std::string("world") == obj["hello"]);
+  }
+
+  SECTION("JsonObject_Set_KeyAndValue") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.set(vla, vla);
+
+    REQUIRE(std::string("world") == obj["world"]);
+  }
+
+  SECTION("JsonObject_ContainsKey") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    const JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+
+    REQUIRE(true == obj.containsKey(vla));
+  }
+
+  SECTION("JsonObject_Remove") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":\"world\"}");
+    obj.remove(vla);
+
+    REQUIRE(0 == obj.size());
+  }
+
+  SECTION("JsonObject_Is") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.parseObject("{\"hello\":42}");
+
+    REQUIRE(true == obj.is<int>(vla));
+  }
+
+  SECTION("JsonObject_CreateNestedArray") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.createNestedArray(vla);
+  }
+
+  SECTION("JsonObject_CreateNestedObject") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "hello");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj = jsonBuffer.createObject();
+    obj.createNestedObject(vla);
+  }
+
+  SECTION("JsonArray_Add") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add(vla);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArray_Set") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr.set(0, vla);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArraySubscript_Set") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr[0].set(vla);
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+
+  SECTION("JsonArraySubscript_Assign") {
+    int i = 16;
+    char vla[i];
+    strcpy(vla, "world");
+
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& arr = jsonBuffer.createArray();
+    arr.add("hello");
+    arr[0] = vla;
+
+    REQUIRE(std::string("world") == arr[0]);
+  }
+}
+#endif