Organized test files in subfolders

test/JsonVariant/as.cpp

@@ -0,0 +1,234 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+
+#include <gtest/gtest.h>
+#include <stdint.h>
+
+static const char* null = 0;
+
+TEST(JsonVariant_As_Tests, DoubleAsBool) {
+  JsonVariant variant = 4.2;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsCstr) {
+  JsonVariant variant = 4.2;
+  ASSERT_FALSE(variant.as<const char*>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsString) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(std::string("4.20"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsLong) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(4L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsUnsigned) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(4U, variant.as<unsigned>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleZeroAsBool) {
+  JsonVariant variant = 0.0;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleZeroAsLong) {
+  JsonVariant variant = 0.0;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsBool) {
+  JsonVariant variant = false;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsDouble) {
+  JsonVariant variant = false;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsLong) {
+  JsonVariant variant = false;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, FalseAsString) {
+  JsonVariant variant = false;
+  ASSERT_EQ(std::string("false"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsBool) {
+  JsonVariant variant = true;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsDouble) {
+  JsonVariant variant = true;
+  ASSERT_EQ(1.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsLong) {
+  JsonVariant variant = true;
+  ASSERT_EQ(1L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, TrueAsString) {
+  JsonVariant variant = true;
+  ASSERT_EQ(std::string("true"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsBool) {
+  JsonVariant variant = 42L;
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, LongZeroAsBool) {
+  JsonVariant variant = 0L;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, PositiveLongAsDouble) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(42.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, NegativeLongAsDouble) {
+  JsonVariant variant = -42L;
+  ASSERT_EQ(-42.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsString) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(std::string("42"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, LongZeroAsDouble) {
+  JsonVariant variant = 0L;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsBool) {
+  JsonVariant variant = null;
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsDouble) {
+  JsonVariant variant = null;
+  ASSERT_EQ(0.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsLong) {
+  JsonVariant variant = null;
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, NullAsString) {
+  JsonVariant variant = null;
+  ASSERT_EQ(std::string("null"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, NumberStringAsBool) {
+  JsonVariant variant = "42";
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, NumberStringAsLong) {
+  JsonVariant variant = "42";
+  ASSERT_EQ(42L, variant.as<long>());
+}
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST(JsonVariant_As_Tests, NumberStringAsInt64Negative) {
+  JsonVariant variant = "-9223372036854775808";
+  ASSERT_EQ(-9223372036854775807 - 1, variant.as<long long>());
+}
+
+TEST(JsonVariant_As_Tests, NumberStringAsInt64Positive) {
+  JsonVariant variant = "9223372036854775807";
+  ASSERT_EQ(9223372036854775807, variant.as<long long>());
+}
+#endif
+
+TEST(JsonVariant_As_Tests, RandomStringAsBool) {
+  JsonVariant variant = "hello";
+  ASSERT_FALSE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsLong) {
+  JsonVariant variant = "hello";
+  ASSERT_EQ(0L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsConstCharPtr) {
+  JsonVariant variant = "hello";
+  ASSERT_STREQ("hello", variant.as<const char*>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsCharPtr) {
+  JsonVariant variant = "hello";
+  ASSERT_STREQ("hello", variant.as<char*>());
+}
+
+TEST(JsonVariant_As_Tests, RandomStringAsString) {
+  JsonVariant variant = "hello";
+  ASSERT_EQ(std::string("hello"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, TrueStringAsBool) {
+  JsonVariant variant = "true";
+  ASSERT_TRUE(variant.as<bool>());
+}
+
+TEST(JsonVariant_As_Tests, TrueStringAsLong) {
+  JsonVariant variant = "true";
+  ASSERT_EQ(1L, variant.as<long>());
+}
+
+TEST(JsonVariant_As_Tests, ObjectAsString) {
+  DynamicJsonBuffer buffer;
+
+  JsonObject& obj = buffer.createObject();
+  obj["key"] = "value";
+
+  JsonVariant variant = obj;
+  ASSERT_EQ(std::string("{\"key\":\"value\"}"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, ArrayAsString) {
+  DynamicJsonBuffer buffer;
+
+  JsonArray& arr = buffer.createArray();
+  arr.add(4);
+  arr.add(2);
+
+  JsonVariant variant = arr;
+  ASSERT_EQ(std::string("[4,2]"), variant.as<std::string>());
+}
+
+TEST(JsonVariant_As_Tests, ArrayAsJsonArray) {
+  DynamicJsonBuffer buffer;
+  JsonArray& arr = buffer.createArray();
+
+  JsonVariant variant = arr;
+  ASSERT_EQ(&arr, &variant.as<JsonArray&>());
+  ASSERT_EQ(&arr, &variant.as<JsonArray>());  // <- shorthand
+}
+
+TEST(JsonVariant_As_Tests, ObjectAsJsonObject) {
+  DynamicJsonBuffer buffer;
+  JsonObject& arr = buffer.createObject();
+
+  JsonVariant variant = arr;
+  ASSERT_EQ(&arr, &variant.as<JsonObject&>());
+  ASSERT_EQ(&arr, &variant.as<JsonObject>());  // <- shorthand
+}

test/JsonVariant/compare.cpp

@@ -0,0 +1,228 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class JsonVariant_Comparison_Tests : public ::testing::Test {
+ protected:
+  template <typename T>
+  void testValue(T low, T mid, T high) {
+    setValueTo(mid);
+    mustBeEqualTo(mid);
+    mustBeGreaterThan(low);
+    mustBeLessThan(high);
+  }
+
+ private:
+  template <typename T>
+  void setValueTo(T expected) {
+    actual = expected;
+  }
+
+  template <typename T>
+  void mustBeEqualTo(T expected) {
+    EXPECT_EQ(expected, actual);  // operator==
+    EXPECT_EQ(actual, expected);  // operator==
+    EXPECT_LE(expected, actual);  // operator<=
+    EXPECT_LE(actual, expected);  // operator<=
+    EXPECT_GE(expected, actual);  // operator>=
+    EXPECT_GE(actual, expected);  // operator>=
+  }
+
+  template <typename T>
+  void mustBeGreaterThan(T expected) {
+    EXPECT_GT(actual, expected);  // operator>
+    EXPECT_LT(expected, actual);  // operator<
+    EXPECT_NE(actual, expected);  // operator!=
+    EXPECT_NE(expected, actual);  // operator!=
+  }
+
+  template <typename T>
+  void mustBeLessThan(T expected) {
+    EXPECT_LT(actual, expected);  // operator<
+    EXPECT_GT(expected, actual);  // operator<
+    EXPECT_NE(actual, expected);  // operator!=
+    EXPECT_NE(expected, actual);  // operator!=
+  }
+
+  JsonVariant actual;
+};
+
+TEST_F(JsonVariant_Comparison_Tests, Double) {
+  testValue<double>(123.44, 123.45, 123.46);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, Float) {
+  testValue<float>(123.44f, 123.45f, 123.46f);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SChar) {
+  testValue<signed char>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SInt) {
+  testValue<signed int>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SLong) {
+  testValue<signed long>(122L, 123L, 124L);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SShort) {
+  testValue<signed short>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UChar) {
+  testValue<unsigned char>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UInt) {
+  testValue<unsigned int>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, ULong) {
+  testValue<unsigned long>(122L, 123L, 124L);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UShort) {
+  testValue<unsigned short>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, StringLiteral) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonVariant variant = jsonBuffer.parse("\"hello\"");
+
+  ASSERT_TRUE(variant == "hello");
+  ASSERT_FALSE(variant != "hello");
+
+  ASSERT_TRUE(variant != "world");
+  ASSERT_FALSE(variant == "world");
+
+  ASSERT_TRUE("hello" == variant);
+  ASSERT_FALSE("hello" != variant);
+
+  ASSERT_TRUE("world" != variant);
+  ASSERT_FALSE("world" == variant);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, String) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonVariant variant = jsonBuffer.parse("\"hello\"");
+
+  ASSERT_TRUE(variant == std::string("hello"));
+  ASSERT_FALSE(variant != std::string("hello"));
+
+  ASSERT_TRUE(variant != std::string("world"));
+  ASSERT_FALSE(variant == std::string("world"));
+
+  ASSERT_TRUE(std::string("hello") == variant);
+  ASSERT_FALSE(std::string("hello") != variant);
+
+  ASSERT_TRUE(std::string("world") != variant);
+  ASSERT_FALSE(std::string("world") == variant);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, IntegerInVariant) {
+  JsonVariant variant1 = 42;
+  JsonVariant variant2 = 42;
+  JsonVariant variant3 = 666;
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, StringInVariant) {
+  JsonVariant variant1 = "0hello" + 1;  // make sure they have
+  JsonVariant variant2 = "1hello" + 1;  // different addresses
+  JsonVariant variant3 = "world";
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, DoubleInVariant) {
+  JsonVariant variant1 = 42.0;
+  JsonVariant variant2 = 42.0;
+  JsonVariant variant3 = 666.0;
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, BoolInVariant) {
+  JsonVariant variant1 = true;
+  JsonVariant variant2 = true;
+  JsonVariant variant3 = false;
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, ArrayInVariant) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array1 = jsonBuffer.createArray();
+  JsonArray& array2 = jsonBuffer.createArray();
+
+  JsonVariant variant1 = array1;
+  JsonVariant variant2 = array1;
+  JsonVariant variant3 = array2;
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, ObjectInVariant) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject& obj1 = jsonBuffer.createObject();
+  JsonObject& obj2 = jsonBuffer.createObject();
+
+  JsonVariant variant1 = obj1;
+  JsonVariant variant2 = obj1;
+  JsonVariant variant3 = obj2;
+
+  ASSERT_TRUE(variant1 == variant2);
+  ASSERT_FALSE(variant1 != variant2);
+
+  ASSERT_TRUE(variant1 != variant3);
+  ASSERT_FALSE(variant1 == variant3);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, 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++) {
+      ASSERT_TRUE(variants[i] != variants[j]);
+      ASSERT_FALSE(variants[i] == variants[j]);
+    }
+  }
+}

test/JsonVariant/copy.cpp

@@ -0,0 +1,68 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class JsonVariant_Copy_Tests : public ::testing::Test {
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _variant1;
+  JsonVariant _variant2;
+};
+
+TEST_F(JsonVariant_Copy_Tests, IntegersAreCopiedByValue) {
+  _variant1 = 123;
+  _variant2 = _variant1;
+  _variant1 = 456;
+
+  EXPECT_EQ(123, _variant2.as<int>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, DoublesAreCopiedByValue) {
+  _variant1 = 123.45;
+  _variant2 = _variant1;
+  _variant1 = 456.78;
+
+  EXPECT_EQ(123.45, _variant2.as<double>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, BooleansAreCopiedByValue) {
+  _variant1 = true;
+  _variant2 = _variant1;
+  _variant1 = false;
+
+  EXPECT_TRUE(_variant2.as<bool>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, StringsAreCopiedByValue) {
+  _variant1 = "hello";
+  _variant2 = _variant1;
+  _variant1 = "world";
+
+  EXPECT_STREQ("hello", _variant2.as<const char *>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, ObjectsAreCopiedByReference) {
+  JsonObject &object = _jsonBuffer.createObject();
+
+  _variant1 = object;
+
+  object["hello"] = "world";
+
+  EXPECT_EQ(1, _variant1.as<JsonObject>().size());
+}
+
+TEST_F(JsonVariant_Copy_Tests, ArraysAreCopiedByReference) {
+  JsonArray &array = _jsonBuffer.createArray();
+
+  _variant1 = array;
+
+  array.add("world");
+
+  EXPECT_EQ(1, _variant1.as<JsonArray>().size());
+}

test/JsonVariant/is.cpp

@@ -0,0 +1,262 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+#define SUITE JsonVariant_Is_Tests
+
+template <typename TTo, typename TFrom>
+void assertIsNot(TFrom value) {
+  JsonVariant variant = value;
+  ASSERT_FALSE(variant.is<TTo>());
+}
+
+template <typename TTo>
+void assertIsNot(JsonArray& value) {
+  JsonVariant variant = value;
+  ASSERT_FALSE(variant.is<TTo>());
+}
+
+template <typename TTo, typename TFrom>
+void assertIs(TFrom value) {
+  JsonVariant variant = value;
+  ASSERT_TRUE(variant.is<TTo>());
+}
+
+template <typename TTo>
+void assertIs(JsonArray& value) {
+  JsonVariant variant = value;
+  ASSERT_TRUE(variant.is<TTo>());
+}
+
+TEST(SUITE, ArrayIsArray) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIs<JsonArray&>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotBool) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<bool>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotDouble) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<double>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotFloat) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<float>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotInt) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<int>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotLong) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<long>(jsonBuffer.createArray());
+}
+TEST(SUITE, ArrayIsNotString) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<const char*>(jsonBuffer.createArray());
+}
+
+TEST(SUITE, BoolIsArray) {
+  assertIsNot<JsonArray&>(true);
+}
+TEST(SUITE, BoolIsBool) {
+  assertIs<bool>(true);
+}
+TEST(SUITE, BoolIsDouble) {
+  assertIsNot<double>(true);
+}
+TEST(SUITE, BoolIsFloat) {
+  assertIsNot<float>(true);
+}
+TEST(SUITE, BoolIsInt) {
+  assertIsNot<int>(true);
+}
+TEST(SUITE, BoolIsLong) {
+  assertIsNot<long>(true);
+}
+TEST(SUITE, BoolIsString) {
+  assertIsNot<const char*>(true);
+}
+
+TEST(SUITE, DoubleIsArray) {
+  assertIsNot<JsonArray&>(4.2);
+}
+TEST(SUITE, DoubleIsBool) {
+  assertIsNot<bool>(4.2);
+}
+TEST(SUITE, DoubleIsDouble) {
+  assertIs<double>(4.2);
+}
+TEST(SUITE, DoubleIsFloat) {
+  assertIs<float>(4.2);
+}
+TEST(SUITE, DoubleIsInt) {
+  assertIsNot<int>(4.2);
+}
+TEST(SUITE, DoubleIsLong) {
+  assertIsNot<long>(4.2);
+}
+TEST(SUITE, DoubleIsString) {
+  assertIsNot<const char*>(4.2);
+}
+
+TEST(SUITE, LongIsArray) {
+  assertIsNot<JsonArray&>(42L);
+}
+TEST(SUITE, LongIsBool) {
+  assertIsNot<bool>(42L);
+}
+TEST(SUITE, LongIsDouble) {
+  assertIsNot<double>(42L);
+}
+TEST(SUITE, LongIsFloat) {
+  assertIsNot<float>(42L);
+}
+TEST(SUITE, LongIsInt) {
+  assertIs<int>(42L);
+}
+TEST(SUITE, LongIsLong) {
+  assertIs<long>(42L);
+}
+TEST(SUITE, LongIsString) {
+  assertIsNot<const char*>(42L);
+}
+
+TEST(SUITE, StringIsArray) {
+  assertIsNot<JsonArray&>("42");
+}
+TEST(SUITE, StringIsBool) {
+  assertIsNot<bool>("42");
+}
+TEST(SUITE, StringIsDouble) {
+  assertIsNot<double>("42");
+}
+TEST(SUITE, StringIsFloat) {
+  assertIsNot<float>("42");
+}
+TEST(SUITE, StringIsInt) {
+  assertIsNot<int>("42");
+}
+TEST(SUITE, StringIsLong) {
+  assertIsNot<long>("42");
+}
+TEST(SUITE, StringIsString) {
+  assertIs<const char*>("42");
+}
+
+TEST(SUITE, UnparsedTrueIsArray) {
+  assertIsNot<JsonArray&>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsBool) {
+  assertIs<bool>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsDouble) {
+  assertIsNot<double>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsFloat) {
+  assertIsNot<float>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsInt) {
+  assertIsNot<int>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsLong) {
+  assertIsNot<long>(RawJson("true"));
+}
+TEST(SUITE, UnparsedTrueIsString) {
+  assertIsNot<const char*>(RawJson("true"));
+}
+
+TEST(SUITE, UnparsedFalseIsArray) {
+  assertIsNot<JsonArray&>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsBool) {
+  assertIs<bool>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsDouble) {
+  assertIsNot<double>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsFloat) {
+  assertIsNot<float>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsInt) {
+  assertIsNot<int>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsLong) {
+  assertIsNot<long>(RawJson("false"));
+}
+TEST(SUITE, UnparsedFalseIsString) {
+  assertIsNot<const char*>(RawJson("false"));
+}
+
+TEST(SUITE, UnparsedIntIsArray) {
+  assertIsNot<JsonArray&>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsBool) {
+  assertIsNot<bool>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsDouble) {
+  assertIsNot<double>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsFloat) {
+  assertIsNot<float>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsInt) {
+  assertIs<int>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsLong) {
+  assertIs<long>(RawJson("42"));
+}
+TEST(SUITE, UnparsedIntIsString) {
+  assertIsNot<const char*>(RawJson("42"));
+}
+
+TEST(SUITE, UnparsedFloatIsBool) {
+  assertIsNot<bool>(RawJson("4.2e-10"));
+}
+TEST(SUITE, UnparsedFloatIsDouble) {
+  assertIs<double>(RawJson("4.2e-10"));
+}
+TEST(SUITE, UnparsedFloatIsFloat) {
+  assertIs<float>(RawJson("4.2e-10"));
+}
+TEST(SUITE, UnparsedFloatIsInt) {
+  assertIsNot<int>(RawJson("4.2e-10"));
+}
+TEST(SUITE, UnparsedFloatIsLong) {
+  assertIsNot<long>(RawJson("4.2e-10"));
+}
+TEST(SUITE, UnparsedFloatIsStr) {
+  assertIsNot<const char*>(RawJson("4.2"));
+}
+
+TEST(SUITE, UnparsedNullIsArray) {
+  assertIsNot<JsonArray&>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsBool) {
+  assertIsNot<bool>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsDouble) {
+  assertIsNot<double>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsFloat) {
+  assertIsNot<float>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsInt) {
+  assertIsNot<int>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsLong) {
+  assertIsNot<long>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsConstCharPtr) {
+  assertIs<const char*>(RawJson("null"));
+}
+TEST(SUITE, UnparsedNullIsCharPtr) {
+  assertIs<char*>(RawJson("null"));
+}

test/JsonVariant/printTo.cpp

@@ -0,0 +1,133 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+#include <limits>
+
+class JsonVariant_PrintTo_Tests : public testing::Test {
+ protected:
+  JsonVariant variant;
+
+  void outputMustBe(const char *expected) {
+    char buffer[256] = "";
+    size_t n = variant.printTo(buffer, sizeof(buffer));
+    ASSERT_STREQ(expected, buffer);
+    ASSERT_EQ(strlen(expected), n);
+  }
+};
+
+TEST_F(JsonVariant_PrintTo_Tests, Empty) {
+  outputMustBe("");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Null) {
+  variant = static_cast<char *>(0);
+  outputMustBe("null");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, String) {
+  variant = "hello";
+  outputMustBe("\"hello\"");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleZero) {
+  variant = 0.0;
+  outputMustBe("0.00");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleDefaultDigits) {
+  variant = 3.14159265358979323846;
+  outputMustBe("3.14");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleFourDigits) {
+  variant = JsonVariant(3.14159265358979323846, 4);
+  outputMustBe("3.1416");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Infinity) {
+  variant = std::numeric_limits<double>::infinity();
+  outputMustBe("Infinity");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, MinusInfinity) {
+  variant = -std::numeric_limits<double>::infinity();
+  outputMustBe("-Infinity");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, SignalingNaN) {
+  variant = std::numeric_limits<double>::signaling_NaN();
+  outputMustBe("NaN");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, QuietNaN) {
+  variant = std::numeric_limits<double>::quiet_NaN();
+  outputMustBe("NaN");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, VeryBigPositiveDouble) {
+  variant = JsonVariant(3.14159265358979323846e42, 4);
+  outputMustBe("3.1416e42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, VeryBigNegativeDouble) {
+  variant = JsonVariant(-3.14159265358979323846e42, 4);
+  outputMustBe("-3.1416e42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, VerySmallPositiveDouble) {
+  variant = JsonVariant(3.14159265358979323846e-42, 4);
+  outputMustBe("3.1416e-42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, VerySmallNegativeDouble) {
+  variant = JsonVariant(-3.14159265358979323846e-42, 4);
+  outputMustBe("-3.1416e-42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Integer) {
+  variant = 42;
+  outputMustBe("42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, NegativeLong) {
+  variant = -42;
+  outputMustBe("-42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, UnsignedLong) {
+  variant = 4294967295UL;
+  outputMustBe("4294967295");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, True) {
+  variant = true;
+  outputMustBe("true");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, OneFalse) {
+  variant = false;
+  outputMustBe("false");
+}
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST_F(JsonVariant_PrintTo_Tests, NegativeInt64) {
+  variant = -9223372036854775807 - 1;
+  outputMustBe("-9223372036854775808");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, PositiveInt64) {
+  variant = 9223372036854775807;
+  outputMustBe("9223372036854775807");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, UInt64) {
+  variant = 18446744073709551615;
+  outputMustBe("18446744073709551615");
+}
+#endif

test/JsonVariant/set_get.cpp

@@ -0,0 +1,134 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+#include <stdint.h>
+#include <limits>
+
+class JsonVariant_Storage_Tests : public ::testing::Test {
+ protected:
+  template <typename T>
+  void testValue(T expected) {
+    JsonVariant variant = expected;
+    EXPECT_EQ(expected, variant.as<T>());
+  }
+
+  template <typename T>
+  void testReference(T &expected) {
+    JsonVariant variant = expected;
+    EXPECT_EQ(expected, variant.as<T &>());
+  }
+
+  template <typename T>
+  void testNumericType() {
+    T min = std::numeric_limits<T>::min();
+    T max = std::numeric_limits<T>::max();
+
+    JsonVariant variantMin(min);
+    JsonVariant variantMax(max);
+
+    EXPECT_EQ(min, variantMin.as<T>());
+    EXPECT_EQ(max, variantMax.as<T>());
+  }
+};
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST_F(JsonVariant_Storage_Tests, SizeOfJsonInteger) {
+  ASSERT_EQ(8, sizeof(Internals::JsonInteger));
+}
+#endif
+
+TEST_F(JsonVariant_Storage_Tests, Null) {
+  testValue<const char *>(NULL);
+}
+TEST_F(JsonVariant_Storage_Tests, String) {
+  testValue<const char *>("hello");
+}
+
+TEST_F(JsonVariant_Storage_Tests, False) {
+  testValue<bool>(false);
+}
+TEST_F(JsonVariant_Storage_Tests, True) {
+  testValue<bool>(true);
+}
+
+TEST_F(JsonVariant_Storage_Tests, Double) {
+  testNumericType<double>();
+}
+TEST_F(JsonVariant_Storage_Tests, Float) {
+  testNumericType<float>();
+}
+TEST_F(JsonVariant_Storage_Tests, Char) {
+  testNumericType<char>();
+}
+TEST_F(JsonVariant_Storage_Tests, SChar) {
+  testNumericType<signed char>();
+}
+TEST_F(JsonVariant_Storage_Tests, SInt) {
+  testNumericType<signed int>();
+}
+TEST_F(JsonVariant_Storage_Tests, SLong) {
+  testNumericType<signed long>();
+}
+TEST_F(JsonVariant_Storage_Tests, SShort) {
+  testNumericType<signed short>();
+}
+TEST_F(JsonVariant_Storage_Tests, UChar) {
+  testNumericType<unsigned char>();
+}
+TEST_F(JsonVariant_Storage_Tests, UInt) {
+  testNumericType<unsigned int>();
+}
+TEST_F(JsonVariant_Storage_Tests, ULong) {
+  testNumericType<unsigned long>();
+}
+TEST_F(JsonVariant_Storage_Tests, UShort) {
+  testNumericType<unsigned short>();
+}
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST_F(JsonVariant_Storage_Tests, LongLong) {
+  testNumericType<unsigned long long>();
+}
+TEST_F(JsonVariant_Storage_Tests, ULongLong) {
+  testNumericType<unsigned long long>();
+}
+#endif
+
+TEST_F(JsonVariant_Storage_Tests, Int8) {
+  testNumericType<int8_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Uint8) {
+  testNumericType<uint8_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Int16) {
+  testNumericType<int16_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Uint16) {
+  testNumericType<uint16_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Int32) {
+  testNumericType<int32_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Uint32) {
+  testNumericType<uint32_t>();
+}
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+TEST_F(JsonVariant_Storage_Tests, Int64) {
+  testNumericType<int64_t>();
+}
+TEST_F(JsonVariant_Storage_Tests, Uint64) {
+  testNumericType<uint64_t>();
+}
+#endif
+
+TEST_F(JsonVariant_Storage_Tests, CanStoreObject) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject &object = jsonBuffer.createObject();
+
+  testReference(object);
+}

test/JsonVariant/subscript.cpp

@@ -0,0 +1,82 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class JsonVariant_Subscript_Tests : public ::testing::Test {
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _variant;
+};
+
+TEST_F(JsonVariant_Subscript_Tests, Array) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add("element at index 0");
+  array.add("element at index 1");
+
+  _variant = array;
+
+  EXPECT_EQ(2, _variant.size());
+  EXPECT_STREQ("element at index 0", _variant[0]);
+  EXPECT_STREQ("element at index 1", _variant[1]);
+  EXPECT_STREQ("element at index 0",
+               _variant[static_cast<unsigned char>(0)]);  // issue #381
+  EXPECT_FALSE(_variant[-1].success());
+  EXPECT_FALSE(_variant[3].success());
+  EXPECT_FALSE(_variant["0"].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, Object) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["a"] = "element at key \"a\"";
+  object["b"] = "element at key \"b\"";
+
+  _variant = object;
+
+  EXPECT_EQ(2, _variant.size());
+  EXPECT_STREQ("element at key \"a\"", _variant["a"]);
+  EXPECT_STREQ("element at key \"b\"", _variant["b"]);
+  EXPECT_FALSE(_variant["c"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, Undefined) {
+  _variant = JsonVariant();
+  EXPECT_EQ(0, _variant.size());
+  EXPECT_FALSE(_variant["0"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, String) {
+  _variant = "hello world";
+  EXPECT_EQ(0, _variant.size());
+  EXPECT_FALSE(_variant["0"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, ObjectSetValue) {
+  _variant = _jsonBuffer.createObject();
+  _variant["hello"] = "world";
+  EXPECT_EQ(1, _variant.size());
+  EXPECT_STREQ("world", _variant["hello"]);
+}
+
+TEST_F(JsonVariant_Subscript_Tests, ArraySetValue) {
+  _variant = _jsonBuffer.parseArray("[\"hello\"]");
+  _variant[0] = "world";
+  EXPECT_EQ(1, _variant.size());
+  EXPECT_STREQ("world", _variant[0]);
+}
+
+TEST_F(JsonVariant_Subscript_Tests, NestedObjectSetValue) {
+  _variant = _jsonBuffer.parseArray("[{}]");
+  _variant[0]["hello"] = "world";
+  EXPECT_EQ(1, _variant.size());
+  EXPECT_EQ(1, _variant[0].size());
+  EXPECT_STREQ("world", _variant[0]["hello"]);
+}

test/JsonVariant/success.cpp

@@ -0,0 +1,43 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenUndefined) {
+  JsonVariant variant;
+  EXPECT_FALSE(variant.success());
+}
+
+TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenInteger) {
+  JsonVariant variant = 0;
+  EXPECT_TRUE(variant.success());
+}
+
+TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenEmptyArray) {
+  DynamicJsonBuffer jsonBuffer;
+
+  JsonVariant variant = jsonBuffer.createArray();
+  EXPECT_TRUE(variant.success());
+}
+
+TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenEmptyObject) {
+  DynamicJsonBuffer jsonBuffer;
+
+  JsonVariant variant = jsonBuffer.createObject();
+  EXPECT_TRUE(variant.success());
+}
+
+TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenInvalidArray) {
+  JsonVariant variant = JsonArray::invalid();
+  EXPECT_FALSE(variant.success());
+}
+
+TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenInvalidObject) {
+  JsonVariant variant = JsonObject::invalid();
+  EXPECT_FALSE(variant.success());
+}

test/JsonVariant/undefined.cpp

@@ -0,0 +1,58 @@
+// Copyright Benoit Blanchon 2014-2017
+// MIT License
+//
+// Arduino JSON library
+// https://bblanchon.github.io/ArduinoJson/
+// If you like this project, please add a star!
+
+#include <ArduinoJson.h>
+#include <gtest/gtest.h>
+
+class JsonVariant_Undefined_Tests : public ::testing::Test {
+ protected:
+  JsonVariant variant;
+};
+
+TEST_F(JsonVariant_Undefined_Tests, AsLongReturns0) {
+  EXPECT_EQ(0, variant.as<long>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsUnsignedReturns0) {
+  EXPECT_EQ(0, variant.as<unsigned>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsStringReturnsNull) {
+  EXPECT_EQ(0, variant.as<char*>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsDoubleReturns0) {
+  EXPECT_EQ(0, variant.as<double>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsBoolReturnsFalse) {
+  EXPECT_FALSE(variant.as<bool>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsArrayReturnInvalid) {
+  EXPECT_EQ(JsonArray::invalid(), variant.as<JsonArray&>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsConstArrayReturnInvalid) {
+  EXPECT_EQ(JsonArray::invalid(), variant.as<const JsonArray&>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsObjectReturnInvalid) {
+  EXPECT_EQ(JsonObject::invalid(), variant.as<JsonObject&>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsConstObjectReturnInvalid) {
+  EXPECT_EQ(JsonObject::invalid(), variant.as<const JsonObject&>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsArrayWrapperReturnInvalid) {
+  EXPECT_EQ(JsonArray::invalid(), variant.as<JsonArray>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsObjectWrapperReturnInvalid) {
+  EXPECT_EQ(JsonObject::invalid(), variant.as<JsonObject>());
+}