From ffb9b6d1bab1fe806c57ef4908d3a13316268016 Mon Sep 17 00:00:00 2001
From: Benoit Blanchon <github@benoitblanchon.fr>
Date: Mon, 29 Aug 2016 20:54:39 +0200
Subject: [PATCH] Fixed  `JsonVariant::success()` which didn't propagate
 `JsonArray::success()` nor `JsonObject::success()` (issue #342).

---
 CHANGELOG.md                        |  1 +
 include/ArduinoJson/JsonArray.ipp   | 20 +++++++++++++-
 include/ArduinoJson/JsonVariant.hpp | 10 ++-----
 test/CMakeLists.txt                 |  2 +-
 test/JsonVariant_Is_Tests.cpp       | 35 +++++++++++++----------
 test/JsonVariant_Success_Tests.cpp  | 43 +++++++++++++++++++++++++++++
 6 files changed, 87 insertions(+), 24 deletions(-)
 create mode 100644 test/JsonVariant_Success_Tests.cpp

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4a8c8d59..00a7ccad 100644
--- a/CHANGELOG.md
+++ b/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
 ------
diff --git a/include/ArduinoJson/JsonArray.ipp b/include/ArduinoJson/JsonArray.ipp
index 0507addf..4058c91c 100644
--- a/include/ArduinoJson/JsonArray.ipp
+++ b/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);
diff --git a/include/ArduinoJson/JsonVariant.hpp b/include/ArduinoJson/JsonVariant.hpp
index f0953cf5..e1ed9558 100644
--- a/include/ArduinoJson/JsonVariant.hpp
+++ b/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.
   //
diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
index 66917a9d..d64431d4 100644
--- a/test/CMakeLists.txt
+++ b/test/CMakeLists.txt
@@ -1,6 +1,6 @@
 # Copyright Benoit Blanchon 2014-2016
 # MIT License
-# 
+#
 # Arduino JSON library
 # https://github.com/bblanchon/ArduinoJson
 # If you like this project, please add a star!
diff --git a/test/JsonVariant_Is_Tests.cpp b/test/JsonVariant_Is_Tests.cpp
index 7670f3a5..b8f1e7b4 100644
--- a/test/JsonVariant_Is_Tests.cpp
+++ b/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) {
diff --git a/test/JsonVariant_Success_Tests.cpp b/test/JsonVariant_Success_Tests.cpp
new file mode 100644
index 00000000..5a8d7b34
--- /dev/null
+++ b/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());
+}