Fixed JsonVariant::success() which didn't propagate JsonArray::success() nor JsonObject::success() (issue #342).

CHANGELOG.md

@@ -6,6 +6,7 @@ HEAD
 
 * Fixed `-Wparentheses` warning introduced in v5.6.5 (PR #335 by @nuket)
 * Added `.mbedignore` for ARM mbdeb (PR #334 by @nuket)
+* Fixed  `JsonVariant::success()` which didn't propagate `JsonArray::success()` nor `JsonObject::success()` (issue #342).
 
 v5.6.5
 ------

include/ArduinoJson/JsonArray.ipp

@@ -8,11 +8,29 @@
 #pragma once
 
 #include "JsonArray.hpp"
-#include "JsonObject.hpp"
 #include "JsonArraySubscript.hpp"
+#include "JsonObject.hpp"
 
 namespace ArduinoJson {
 
+inline JsonVariant::JsonVariant(JsonArray &array) {
+  if (array.success()) {
+    _type = Internals::JSON_ARRAY;
+    _content.asArray = &array;
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
+}
+
+inline JsonVariant::JsonVariant(JsonObject &object) {
+  if (object.success()) {
+    _type = Internals::JSON_OBJECT;
+    _content.asObject = &object;
+  } else {
+    _type = Internals::JSON_UNDEFINED;
+  }
+}
+
 template <>
 inline bool JsonArray::setNodeValue(node_type *node, String &value) {
   const char *copy = _buffer->strdup(value);

include/ArduinoJson/JsonVariant.hpp

@@ -107,16 +107,10 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   }
 
   // Create a JsonVariant containing a reference to an array.
-  JsonVariant(JsonArray &array) {
-    _type = Internals::JSON_ARRAY;
-    _content.asArray = &array;
-  }
+  JsonVariant(JsonArray &array);
 
   // Create a JsonVariant containing a reference to an object.
-  JsonVariant(JsonObject &object) {
-    _type = Internals::JSON_OBJECT;
-    _content.asObject = &object;
-  }
+  JsonVariant(JsonObject &object);
 
   // Get the variant as the specified type.
   //

test/JsonVariant_Is_Tests.cpp

@@ -34,26 +34,33 @@ void assertIs(JsonArray& value) {
   ASSERT_TRUE(variant.is<TTo>());
 }
 
-TEST(SUITE, ArrayIsArry) {
-  assertIs<JsonArray&>(JsonArray::invalid());
+TEST(SUITE, ArrayIsArray) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIs<JsonArray&>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsBool) {
-  assertIsNot<bool>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotBool) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<bool>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsDouble) {
-  assertIsNot<double>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotDouble) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<double>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsFloat) {
-  assertIsNot<float>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotFloat) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<float>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsInt) {
-  assertIsNot<int>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotInt) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<int>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsLong) {
-  assertIsNot<long>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotLong) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<long>(jsonBuffer.createArray());
 }
-TEST(SUITE, ArrayIsString) {
-  assertIsNot<const char*>(JsonArray::invalid());
+TEST(SUITE, ArrayIsNotString) {
+  DynamicJsonBuffer jsonBuffer;
+  assertIsNot<const char*>(jsonBuffer.createArray());
 }
 
 TEST(SUITE, BoolIsArray) {

test/JsonVariant_Success_Tests.cpp

@@ -0,0 +1,43 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/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());
+}