add arduino json lib

#182

lib/ArduinoJson/test/JsonVariant/CMakeLists.txt

@@ -0,0 +1,19 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
+# MIT License
+
+add_executable(JsonVariantTests 
+	as.cpp
+	compare.cpp
+	copy.cpp
+	is.cpp
+	or.cpp
+	printTo.cpp
+	set_get.cpp
+	subscript.cpp
+	success.cpp
+	undefined.cpp
+)
+
+target_link_libraries(JsonVariantTests catch)
+add_test(JsonVariant JsonVariantTests)

lib/ArduinoJson/test/JsonVariant/as.cpp

@@ -0,0 +1,232 @@
+// 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::as()") {
+  SECTION("DoubleAsBool") {
+    JsonVariant variant = 4.2;
+    REQUIRE(variant.as<bool>());
+  }
+
+  SECTION("DoubleAsCstr") {
+    JsonVariant variant = 4.2;
+    REQUIRE_FALSE(variant.as<const char*>());
+  }
+
+  SECTION("DoubleAsString") {
+    JsonVariant variant = 4.2;
+    REQUIRE(std::string("4.2") == variant.as<std::string>());
+  }
+
+  SECTION("DoubleAsLong") {
+    JsonVariant variant = 4.2;
+    REQUIRE(4L == variant.as<long>());
+  }
+
+  SECTION("DoubleAsUnsigned") {
+    JsonVariant variant = 4.2;
+    REQUIRE(4U == variant.as<unsigned>());
+  }
+
+  SECTION("DoubleZeroAsBool") {
+    JsonVariant variant = 0.0;
+    REQUIRE_FALSE(variant.as<bool>());
+  }
+
+  SECTION("DoubleZeroAsLong") {
+    JsonVariant variant = 0.0;
+    REQUIRE(0L == variant.as<long>());
+  }
+
+  SECTION("FalseAsBool") {
+    JsonVariant variant = false;
+    REQUIRE_FALSE(variant.as<bool>());
+  }
+
+  SECTION("FalseAsDouble") {
+    JsonVariant variant = false;
+    REQUIRE(0.0 == variant.as<double>());
+  }
+
+  SECTION("FalseAsLong") {
+    JsonVariant variant = false;
+    REQUIRE(0L == variant.as<long>());
+  }
+
+  SECTION("FalseAsString") {
+    JsonVariant variant = false;
+    REQUIRE(std::string("false") == variant.as<std::string>());
+  }
+
+  SECTION("TrueAsBool") {
+    JsonVariant variant = true;
+    REQUIRE(variant.as<bool>());
+  }
+
+  SECTION("TrueAsDouble") {
+    JsonVariant variant = true;
+    REQUIRE(1.0 == variant.as<double>());
+  }
+
+  SECTION("TrueAsLong") {
+    JsonVariant variant = true;
+    REQUIRE(1L == variant.as<long>());
+  }
+
+  SECTION("TrueAsString") {
+    JsonVariant variant = true;
+    REQUIRE(std::string("true") == variant.as<std::string>());
+  }
+
+  SECTION("LongAsBool") {
+    JsonVariant variant = 42L;
+    REQUIRE(variant.as<bool>());
+  }
+
+  SECTION("LongZeroAsBool") {
+    JsonVariant variant = 0L;
+    REQUIRE_FALSE(variant.as<bool>());
+  }
+
+  SECTION("PositiveLongAsDouble") {
+    JsonVariant variant = 42L;
+    REQUIRE(42.0 == variant.as<double>());
+  }
+
+  SECTION("NegativeLongAsDouble") {
+    JsonVariant variant = -42L;
+    REQUIRE(-42.0 == variant.as<double>());
+  }
+
+  SECTION("LongAsString") {
+    JsonVariant variant = 42L;
+    REQUIRE(std::string("42") == variant.as<std::string>());
+  }
+
+  SECTION("LongZeroAsDouble") {
+    JsonVariant variant = 0L;
+    REQUIRE(0.0 == variant.as<double>());
+  }
+
+  SECTION("NullAsBool") {
+    JsonVariant variant = null;
+    REQUIRE_FALSE(variant.as<bool>());
+  }
+
+  SECTION("NullAsDouble") {
+    JsonVariant variant = null;
+    REQUIRE(0.0 == variant.as<double>());
+  }
+
+  SECTION("NullAsLong") {
+    JsonVariant variant = null;
+    REQUIRE(0L == variant.as<long>());
+  }
+
+  SECTION("NullAsString") {
+    JsonVariant variant = null;
+    REQUIRE(std::string("null") == variant.as<std::string>());
+  }
+
+  SECTION("NumberStringAsBool") {
+    JsonVariant variant = "42";
+    REQUIRE(variant.as<bool>());
+  }
+
+  SECTION("NumberStringAsLong") {
+    JsonVariant variant = "42";
+    REQUIRE(42L == variant.as<long>());
+  }
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+  SECTION("NumberStringAsInt64Negative") {
+    JsonVariant variant = "-9223372036854775808";
+    REQUIRE(-9223372036854775807 - 1 == variant.as<long long>());
+  }
+
+  SECTION("NumberStringAsInt64Positive") {
+    JsonVariant variant = "9223372036854775807";
+    REQUIRE(9223372036854775807 == variant.as<long long>());
+  }
+#endif
+
+  SECTION("RandomStringAsBool") {
+    JsonVariant variant = "hello";
+    REQUIRE_FALSE(variant.as<bool>());
+  }
+
+  SECTION("RandomStringAsLong") {
+    JsonVariant variant = "hello";
+    REQUIRE(0L == variant.as<long>());
+  }
+
+  SECTION("RandomStringAsConstCharPtr") {
+    JsonVariant variant = "hello";
+    REQUIRE(std::string("hello") == variant.as<const char*>());
+  }
+
+  SECTION("RandomStringAsCharPtr") {
+    JsonVariant variant = "hello";
+    REQUIRE(std::string("hello") == variant.as<char*>());
+  }
+
+  SECTION("RandomStringAsString") {
+    JsonVariant variant = "hello";
+    REQUIRE(std::string("hello") == variant.as<std::string>());
+  }
+
+  SECTION("TrueStringAsBool") {
+    JsonVariant variant = "true";
+    REQUIRE(variant.as<bool>());
+  }
+
+  SECTION("TrueStringAsLong") {
+    JsonVariant variant = "true";
+    REQUIRE(1L == variant.as<long>());
+  }
+
+  SECTION("ObjectAsString") {
+    DynamicJsonBuffer buffer;
+
+    JsonObject& obj = buffer.createObject();
+    obj["key"] = "value";
+
+    JsonVariant variant = obj;
+    REQUIRE(std::string("{\"key\":\"value\"}") == variant.as<std::string>());
+  }
+
+  SECTION("ArrayAsString") {
+    DynamicJsonBuffer buffer;
+
+    JsonArray& arr = buffer.createArray();
+    arr.add(4);
+    arr.add(2);
+
+    JsonVariant variant = arr;
+    REQUIRE(std::string("[4,2]") == variant.as<std::string>());
+  }
+
+  SECTION("ArrayAsJsonArray") {
+    DynamicJsonBuffer buffer;
+    JsonArray& arr = buffer.createArray();
+
+    JsonVariant variant = arr;
+    REQUIRE(&arr == &variant.as<JsonArray&>());
+    REQUIRE(&arr == &variant.as<JsonArray>());  // <- shorthand
+  }
+
+  SECTION("ObjectAsJsonObject") {
+    DynamicJsonBuffer buffer;
+    JsonObject& arr = buffer.createObject();
+
+    JsonVariant variant = arr;
+    REQUIRE(&arr == &variant.as<JsonObject&>());
+    REQUIRE(&arr == &variant.as<JsonObject>());  // <- shorthand
+  }
+}

lib/ArduinoJson/test/JsonVariant/compare.cpp

@@ -0,0 +1,232 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+template <typename T>
+void checkEquals(JsonVariant a, T b) {
+  REQUIRE(b == a);
+  REQUIRE(a == b);
+  REQUIRE(b <= a);
+  REQUIRE(a <= b);
+  REQUIRE(b >= a);
+  REQUIRE(a >= b);
+
+  REQUIRE_FALSE(b != a);
+  REQUIRE_FALSE(a != b);
+  REQUIRE_FALSE(b > a);
+  REQUIRE_FALSE(a > b);
+  REQUIRE_FALSE(b < a);
+  REQUIRE_FALSE(a < b);
+}
+
+template <typename T>
+void checkGreater(JsonVariant a, T b) {
+  REQUIRE(a > b);
+  REQUIRE(b < a);
+  REQUIRE(a != b);
+  REQUIRE(b != a);
+
+  REQUIRE_FALSE(a < b);
+  REQUIRE_FALSE(b > a);
+  REQUIRE_FALSE(a == b);
+  REQUIRE_FALSE(b == a);
+}
+
+template <typename T>
+void checkLower(JsonVariant a, T b) {
+  REQUIRE(a < b);
+  REQUIRE(b > a);
+  REQUIRE(a != b);
+  REQUIRE(b != a);
+
+  REQUIRE_FALSE(a > b);
+  REQUIRE_FALSE(b < a);
+  REQUIRE_FALSE(a == b);
+  REQUIRE_FALSE(b == a);
+}
+
+template <typename T>
+void checkComparisons(T low, T mid, T high) {
+  checkEquals(mid, mid);
+  checkGreater(mid, low);
+  checkLower(mid, high);
+}
+
+TEST_CASE("JsonVariant comparisons") {
+  SECTION("Double") {
+    checkComparisons<double>(123.44, 123.45, 123.46);
+  }
+
+  SECTION("Float") {
+    checkComparisons<float>(123.44f, 123.45f, 123.46f);
+  }
+
+  SECTION("SChar") {
+    checkComparisons<signed char>(122, 123, 124);
+  }
+
+  SECTION("SInt") {
+    checkComparisons<signed int>(122, 123, 124);
+  }
+
+  SECTION("SLong") {
+    checkComparisons<signed long>(122L, 123L, 124L);
+  }
+
+  SECTION("SShort") {
+    checkComparisons<signed short>(122, 123, 124);
+  }
+
+  SECTION("UChar") {
+    checkComparisons<unsigned char>(122, 123, 124);
+  }
+
+  SECTION("UInt") {
+    checkComparisons<unsigned int>(122, 123, 124);
+  }
+
+  SECTION("ULong") {
+    checkComparisons<unsigned long>(122L, 123L, 124L);
+  }
+
+  SECTION("UShort") {
+    checkComparisons<unsigned short>(122, 123, 124);
+  }
+
+  SECTION("StringLiteral") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonVariant variant = jsonBuffer.parse("\"hello\"");
+
+    REQUIRE(variant == "hello");
+    REQUIRE_FALSE(variant != "hello");
+
+    REQUIRE(variant != "world");
+    REQUIRE_FALSE(variant == "world");
+
+    REQUIRE("hello" == variant);
+    REQUIRE_FALSE("hello" != variant);
+
+    REQUIRE("world" != variant);
+    REQUIRE_FALSE("world" == variant);
+  }
+
+  SECTION("String") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonVariant variant = jsonBuffer.parse("\"hello\"");
+
+    REQUIRE(variant == std::string("hello"));
+    REQUIRE_FALSE(variant != std::string("hello"));
+
+    REQUIRE(variant != std::string("world"));
+    REQUIRE_FALSE(variant == std::string("world"));
+
+    REQUIRE(std::string("hello") == variant);
+    REQUIRE_FALSE(std::string("hello") != variant);
+
+    REQUIRE(std::string("world") != variant);
+    REQUIRE_FALSE(std::string("world") == variant);
+  }
+
+  SECTION("IntegerInVariant") {
+    JsonVariant variant1 = 42;
+    JsonVariant variant2 = 42;
+    JsonVariant variant3 = 666;
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("StringInVariant") {
+    JsonVariant variant1 = "0hello" + 1;  // make sure they have
+    JsonVariant variant2 = "1hello" + 1;  // different addresses
+    JsonVariant variant3 = "world";
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("DoubleInVariant") {
+    JsonVariant variant1 = 42.0;
+    JsonVariant variant2 = 42.0;
+    JsonVariant variant3 = 666.0;
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("BoolInVariant") {
+    JsonVariant variant1 = true;
+    JsonVariant variant2 = true;
+    JsonVariant variant3 = false;
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("ArrayInVariant") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonArray& array1 = jsonBuffer.createArray();
+    JsonArray& array2 = jsonBuffer.createArray();
+
+    JsonVariant variant1 = array1;
+    JsonVariant variant2 = array1;
+    JsonVariant variant3 = array2;
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("ObjectInVariant") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject& obj1 = jsonBuffer.createObject();
+    JsonObject& obj2 = jsonBuffer.createObject();
+
+    JsonVariant variant1 = obj1;
+    JsonVariant variant2 = obj1;
+    JsonVariant variant3 = obj2;
+
+    REQUIRE(variant1 == variant2);
+    REQUIRE_FALSE(variant1 != variant2);
+
+    REQUIRE(variant1 != variant3);
+    REQUIRE_FALSE(variant1 == variant3);
+  }
+
+  SECTION("VariantsOfDifferentTypes") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonVariant variants[] = {
+        true,
+        42,
+        666.667,
+        "hello",
+        jsonBuffer.createArray(),
+        jsonBuffer.createObject(),
+    };
+    size_t n = sizeof(variants) / sizeof(variants[0]);
+
+    for (size_t i = 0; i < n; i++) {
+      for (size_t j = i + 1; j < n; j++) {
+        REQUIRE(variants[i] != variants[j]);
+        REQUIRE_FALSE(variants[i] == variants[j]);
+      }
+    }
+  }
+}

lib/ArduinoJson/test/JsonVariant/copy.cpp

@@ -0,0 +1,64 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariant copy") {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _variant1;
+  JsonVariant _variant2;
+
+  SECTION("IntegersAreCopiedByValue") {
+    _variant1 = 123;
+    _variant2 = _variant1;
+    _variant1 = 456;
+
+    REQUIRE(123 == _variant2.as<int>());
+  }
+
+  SECTION("DoublesAreCopiedByValue") {
+    _variant1 = 123.45;
+    _variant2 = _variant1;
+    _variant1 = 456.78;
+
+    REQUIRE(123.45 == _variant2.as<double>());
+  }
+
+  SECTION("BooleansAreCopiedByValue") {
+    _variant1 = true;
+    _variant2 = _variant1;
+    _variant1 = false;
+
+    REQUIRE(_variant2.as<bool>());
+  }
+
+  SECTION("StringsAreCopiedByValue") {
+    _variant1 = "hello";
+    _variant2 = _variant1;
+    _variant1 = "world";
+
+    REQUIRE(std::string("hello") == _variant2.as<const char *>());
+  }
+
+  SECTION("ObjectsAreCopiedByReference") {
+    JsonObject &object = _jsonBuffer.createObject();
+
+    _variant1 = object;
+
+    object["hello"] = "world";
+
+    REQUIRE(1 == _variant1.as<JsonObject>().size());
+  }
+
+  SECTION("ArraysAreCopiedByReference") {
+    JsonArray &array = _jsonBuffer.createArray();
+
+    _variant1 = array;
+
+    array.add("world");
+
+    REQUIRE(1 == _variant1.as<JsonArray>().size());
+  }
+}

lib/ArduinoJson/test/JsonVariant/is.cpp

@@ -0,0 +1,115 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+void checkIsArray(JsonVariant var) {
+  REQUIRE(var.is<JsonArray>());
+  REQUIRE(var.is<JsonArray&>());
+  REQUIRE(var.is<const JsonArray>());
+  REQUIRE(var.is<const JsonArray&>());
+
+  REQUIRE_FALSE(var.is<bool>());
+  REQUIRE_FALSE(var.is<double>());
+  REQUIRE_FALSE(var.is<float>());
+  REQUIRE_FALSE(var.is<int>());
+  REQUIRE_FALSE(var.is<long>());
+  REQUIRE_FALSE(var.is<const char*>());
+  REQUIRE_FALSE(var.is<JsonObject>());
+}
+
+void checkIsBool(JsonVariant var) {
+  REQUIRE(var.is<bool>());
+
+  REQUIRE_FALSE(var.is<double>());
+  REQUIRE_FALSE(var.is<float>());
+  REQUIRE_FALSE(var.is<int>());
+  REQUIRE_FALSE(var.is<long>());
+  REQUIRE_FALSE(var.is<const char*>());
+  REQUIRE_FALSE(var.is<JsonArray>());
+  REQUIRE_FALSE(var.is<JsonObject>());
+}
+
+void checkIsFloat(JsonVariant var) {
+  REQUIRE(var.is<double>());
+  REQUIRE(var.is<float>());
+
+  REQUIRE_FALSE(var.is<bool>());
+  REQUIRE_FALSE(var.is<int>());
+  REQUIRE_FALSE(var.is<long>());
+  REQUIRE_FALSE(var.is<const char*>());
+  REQUIRE_FALSE(var.is<JsonArray>());
+  REQUIRE_FALSE(var.is<JsonObject>());
+}
+
+void checkIsInteger(JsonVariant var) {
+  REQUIRE(var.is<long>());
+  REQUIRE(var.is<int>());
+  REQUIRE(var.is<float>());
+  REQUIRE(var.is<double>());
+
+  REQUIRE_FALSE(var.is<bool>());
+  REQUIRE_FALSE(var.is<const char*>());
+  REQUIRE_FALSE(var.is<JsonArray>());
+  REQUIRE_FALSE(var.is<JsonObject>());
+}
+
+void checkIsString(JsonVariant var) {
+  REQUIRE(var.is<const char*>());
+
+  REQUIRE_FALSE(var.is<bool>());
+  REQUIRE_FALSE(var.is<int>());
+  REQUIRE_FALSE(var.is<double>());
+  REQUIRE_FALSE(var.is<float>());
+  REQUIRE_FALSE(var.is<long>());
+  REQUIRE_FALSE(var.is<JsonArray>());
+  REQUIRE_FALSE(var.is<JsonObject>());
+}
+
+TEST_CASE("JsonVariant::is()") {
+  DynamicJsonBuffer jsonBuffer;
+
+  SECTION("JsonArray") {
+    checkIsArray(jsonBuffer.createArray());
+  }
+
+  SECTION("bool") {
+    checkIsBool(true);
+    checkIsBool(false);
+  }
+
+  SECTION("double") {
+    checkIsFloat(4.2);
+  }
+
+  SECTION("int") {
+    checkIsInteger(42);
+  }
+
+  SECTION("long") {
+    checkIsInteger(42L);
+  }
+
+  SECTION("string") {
+    checkIsString("42");
+  }
+
+  SECTION("unparsed bool") {
+    checkIsBool(RawJson("true"));
+    checkIsBool(RawJson("false"));
+  }
+
+  SECTION("unparsed int") {
+    checkIsInteger(RawJson("42"));
+  }
+
+  SECTION("unparsed float") {
+    checkIsFloat(RawJson("4.2e-10"));
+  }
+
+  SECTION("unparsed null") {
+    checkIsString(RawJson("null"));
+  }
+}

lib/ArduinoJson/test/JsonVariant/or.cpp

@@ -0,0 +1,83 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+static const JsonVariant undefined;
+static const JsonVariant null = static_cast<const char*>(0);
+
+TEST_CASE("JsonVariant::operator|()") {
+  SECTION("undefined | const char*") {
+    std::string result = undefined | "default";
+    REQUIRE(result == "default");
+  }
+
+  SECTION("undefined | int") {
+    int result = undefined | 42;
+    REQUIRE(result == 42);
+  }
+
+  SECTION("undefined | bool") {
+    bool result = undefined | true;
+    REQUIRE(result == true);
+  }
+
+  SECTION("null | const char*") {
+    std::string result = null | "default";
+    REQUIRE(result == "default");
+  }
+
+  SECTION("null | int") {
+    int result = null | 42;
+    REQUIRE(result == 42);
+  }
+
+  SECTION("null | bool") {
+    bool result = null | true;
+    REQUIRE(result == true);
+  }
+
+  SECTION("int | const char*") {
+    JsonVariant variant = 42;
+    std::string result = variant | "default";
+    REQUIRE(result == "default");
+  }
+
+  SECTION("int | int") {
+    JsonVariant variant = 0;
+    int result = variant | 666;
+    REQUIRE(result == 0);
+  }
+
+  SECTION("double | int") {
+    JsonVariant variant = 42.0;
+    int result = variant | 666;
+    REQUIRE(result == 42);
+  }
+
+  SECTION("bool | bool") {
+    JsonVariant variant = false;
+    bool result = variant | true;
+    REQUIRE(result == false);
+  }
+
+  SECTION("int | bool") {
+    JsonVariant variant = 0;
+    bool result = variant | true;
+    REQUIRE(result == true);
+  }
+
+  SECTION("const char* | const char*") {
+    JsonVariant variant = "not default";
+    std::string result = variant | "default";
+    REQUIRE(result == "not default");
+  }
+
+  SECTION("const char* | int") {
+    JsonVariant variant = "not default";
+    int result = variant | 42;
+    REQUIRE(result == 42);
+  }
+}

lib/ArduinoJson/test/JsonVariant/printTo.cpp

@@ -0,0 +1,66 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <limits>
+
+void check(JsonVariant variant, const std::string &expected) {
+  char buffer[256] = "";
+  size_t returnValue = variant.printTo(buffer, sizeof(buffer));
+  REQUIRE(expected == buffer);
+  REQUIRE(expected.size() == returnValue);
+}
+
+TEST_CASE("JsonVariant::printTo()") {
+  SECTION("Empty") {
+    check(JsonVariant(), "");
+  }
+
+  SECTION("Null") {
+    check(static_cast<char *>(0), "null");
+  }
+
+  SECTION("String") {
+    check("hello", "\"hello\"");
+  }
+
+  SECTION("Double") {
+    check(3.1415927, "3.1415927");
+  }
+
+  SECTION("Integer") {
+    check(42, "42");
+  }
+
+  SECTION("NegativeLong") {
+    check(-42, "-42");
+  }
+
+  SECTION("UnsignedLong") {
+    check(4294967295UL, "4294967295");
+  }
+
+  SECTION("True") {
+    check(true, "true");
+  }
+
+  SECTION("OneFalse") {
+    check(false, "false");
+  }
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+  SECTION("NegativeInt64") {
+    check(-9223372036854775807 - 1, "-9223372036854775808");
+  }
+
+  SECTION("PositiveInt64") {
+    check(9223372036854775807, "9223372036854775807");
+  }
+
+  SECTION("UInt64") {
+    check(18446744073709551615U, "18446744073709551615");
+  }
+#endif
+}

lib/ArduinoJson/test/JsonVariant/set_get.cpp

@@ -0,0 +1,130 @@
+// 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) {
+  JsonVariant variant = 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() {
+  T min = std::numeric_limits<T>::min();
+  T max = std::numeric_limits<T>::max();
+
+  JsonVariant variantMin(min);
+  JsonVariant variantMax(max);
+
+  REQUIRE(min == variantMin.as<T>());
+  REQUIRE(max == variantMax.as<T>());
+}
+
+TEST_CASE("JsonVariant set()/get()") {
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+  SECTION("SizeOfJsonInteger") {
+    REQUIRE(8 == sizeof(Internals::JsonInteger));
+  }
+#endif
+
+  SECTION("Null") {
+    checkValue<const char *>(NULL);
+  }
+  SECTION("String") {
+    checkValue<const char *>("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 || ARDUINOJSON_USE_INT64
+  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 || ARDUINOJSON_USE_INT64
+  SECTION("Int64") {
+    checkNumericType<int64_t>();
+  }
+  SECTION("Uint64") {
+    checkNumericType<uint64_t>();
+  }
+#endif
+
+  SECTION("CanStoreObject") {
+    DynamicJsonBuffer jsonBuffer;
+    JsonObject &object = jsonBuffer.createObject();
+
+    checkReference(object);
+  }
+}

lib/ArduinoJson/test/JsonVariant/subscript.cpp

@@ -0,0 +1,77 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariant::operator[]") {
+  DynamicJsonBuffer _jsonBuffer;
+
+  SECTION("Array") {
+    JsonArray &array = _jsonBuffer.createArray();
+    array.add("element at index 0");
+    array.add("element at index 1");
+
+    JsonVariant var = array;
+
+    REQUIRE(2 == var.size());
+    REQUIRE(std::string("element at index 0") == var[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
+    REQUIRE_FALSE(var[666].success());
+    REQUIRE_FALSE(var[3].success());
+    REQUIRE_FALSE(var["0"].success());
+  }
+
+  SECTION("Object") {
+    JsonObject &object = _jsonBuffer.createObject();
+    object["a"] = "element at key \"a\"";
+    object["b"] = "element at key \"b\"";
+
+    JsonVariant var = object;
+
+    REQUIRE(2 == var.size());
+    REQUIRE(std::string("element at key \"a\"") == var["a"]);
+    REQUIRE(std::string("element at key \"b\"") == var["b"]);
+    REQUIRE_FALSE(var["c"].success());
+    REQUIRE_FALSE(var[0].success());
+  }
+
+  SECTION("Undefined") {
+    JsonVariant var = JsonVariant();
+    REQUIRE(0 == var.size());
+    REQUIRE_FALSE(var["0"].success());
+    REQUIRE_FALSE(var[0].success());
+  }
+
+  SECTION("String") {
+    JsonVariant var = "hello world";
+    REQUIRE(0 == var.size());
+    REQUIRE_FALSE(var["0"].success());
+    REQUIRE_FALSE(var[0].success());
+  }
+
+  SECTION("ObjectSetValue") {
+    JsonVariant var = _jsonBuffer.createObject();
+    var["hello"] = "world";
+    REQUIRE(1 == var.size());
+    REQUIRE(std::string("world") == var["hello"]);
+  }
+
+  SECTION("ArraySetValue") {
+    JsonVariant var = _jsonBuffer.parseArray("[\"hello\"]");
+    var[0] = "world";
+    REQUIRE(1 == var.size());
+    REQUIRE(std::string("world") == var[0]);
+  }
+
+  SECTION("NestedObjectSetValue") {
+    JsonVariant var = _jsonBuffer.parseArray("[{}]");
+    var[0]["hello"] = "world";
+    REQUIRE(1 == var.size());
+    REQUIRE(1 == var[0].size());
+    REQUIRE(std::string("world") == var[0]["hello"]);
+  }
+}

lib/ArduinoJson/test/JsonVariant/success.cpp

@@ -0,0 +1,42 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariant::success()") {
+  SECTION("ReturnsFalse_WhenUndefined") {
+    JsonVariant variant;
+    REQUIRE(false == variant.success());
+  }
+
+  SECTION("ReturnsTrue_WhenInteger") {
+    JsonVariant variant = 0;
+    REQUIRE(true == variant.success());
+  }
+
+  SECTION("ReturnsTrue_WhenEmptyArray") {
+    DynamicJsonBuffer jsonBuffer;
+
+    JsonVariant variant = jsonBuffer.createArray();
+    REQUIRE(true == variant.success());
+  }
+
+  SECTION("ReturnsTrue_WhenEmptyObject") {
+    DynamicJsonBuffer jsonBuffer;
+
+    JsonVariant variant = jsonBuffer.createObject();
+    REQUIRE(true == variant.success());
+  }
+
+  SECTION("ReturnsFalse_WhenInvalidArray") {
+    JsonVariant variant = JsonArray::invalid();
+    REQUIRE(false == variant.success());
+  }
+
+  SECTION("ReturnsFalse_WhenInvalidObject") {
+    JsonVariant variant = JsonObject::invalid();
+    REQUIRE(false == variant.success());
+  }
+}

lib/ArduinoJson/test/JsonVariant/undefined.cpp

@@ -0,0 +1,54 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("JsonVariant undefined") {
+  JsonVariant variant;
+
+  SECTION("AsLongReturns0") {
+    REQUIRE(0 == variant.as<long>());
+  }
+
+  SECTION("AsUnsignedReturns0") {
+    REQUIRE(0 == variant.as<unsigned>());
+  }
+
+  SECTION("AsStringReturnsNull") {
+    REQUIRE(0 == variant.as<char*>());
+  }
+
+  SECTION("AsDoubleReturns0") {
+    REQUIRE(0 == variant.as<double>());
+  }
+
+  SECTION("AsBoolReturnsFalse") {
+    REQUIRE(false == variant.as<bool>());
+  }
+
+  SECTION("AsArrayReturnInvalid") {
+    REQUIRE(JsonArray::invalid() == variant.as<JsonArray&>());
+  }
+
+  SECTION("AsConstArrayReturnInvalid") {
+    REQUIRE(JsonArray::invalid() == variant.as<const JsonArray&>());
+  }
+
+  SECTION("AsObjectReturnInvalid") {
+    REQUIRE(JsonObject::invalid() == variant.as<JsonObject&>());
+  }
+
+  SECTION("AsConstObjectReturnInvalid") {
+    REQUIRE(JsonObject::invalid() == variant.as<const JsonObject&>());
+  }
+
+  SECTION("AsArrayWrapperReturnInvalid") {
+    REQUIRE(JsonArray::invalid() == variant.as<JsonArray>());
+  }
+
+  SECTION("AsObjectWrapperReturnInvalid") {
+    REQUIRE(JsonObject::invalid() == variant.as<JsonObject>());
+  }
+}