Store parsed token as string and allow conversion between various types (issues #64, #69, #90, #93)

test/ArduinoString_Tests.cpp

@@ -164,3 +164,37 @@ TEST_F(ArduinoStringTests, JsonArraySubscript) {
   eraseString(value);
   ASSERT_STREQ("world", array[0]);
 }
+
+TEST_F(ArduinoStringTests, JsonArray_PrintTo) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add(4);
+  array.add(2);
+  String json;
+  array.printTo(json);
+  ASSERT_EQ(String("[4,2]"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonArray_PrettyPrintTo) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add(4);
+  array.add(2);
+  String json;
+  array.prettyPrintTo(json);
+  ASSERT_EQ(String("[\r\n  4,\r\n  2\r\n]"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_PrintTo) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["key"] = "value";
+  String json;
+  object.printTo(json);
+  ASSERT_EQ(String("{\"key\":\"value\"}"), json);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_PrettyPrintTo) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["key"] = "value";
+  String json;
+  object.prettyPrintTo(json);
+  ASSERT_EQ(String("{\r\n  \"key\": \"value\"\r\n}"), json);
+}

test/Issue90.cpp

@@ -0,0 +1,28 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <limits.h>  // for LONG_MAX
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.h>
+
+#define SUITE Issue90
+
+using namespace ArduinoJson::Internals;
+
+static const char* superLong =
+    "12345678901234567890123456789012345678901234567890123456789012345678901234"
+    "5678901234567890123456789012345678901234567890123456789012345678901234567";
+
+static const JsonVariant variant = Unparsed(superLong);
+
+TEST(SUITE, IsNotALong) { ASSERT_FALSE(variant.is<long>()); }
+
+TEST(SUITE, AsLong) { ASSERT_EQ(LONG_MAX, variant.as<long>()); }
+
+TEST(SUITE, IsAString) { ASSERT_FALSE(variant.is<const char*>()); }
+
+TEST(SUITE, AsString) { ASSERT_STREQ(superLong, variant.as<const char*>()); }

test/JsonParser_Array_Tests.cpp

@@ -144,26 +144,6 @@ TEST_F(JsonParser_Array_Tests, TwoNulls) {
   secondElementMustBe(nullCharPtr);
 }
 
-TEST_F(JsonParser_Array_Tests, IncompleteNull) {
-  whenInputIs("[nul!]");
-  parseMustFail();
-}
-
-TEST_F(JsonParser_Array_Tests, IncompleteTrue) {
-  whenInputIs("[tru!]");
-  parseMustFail();
-}
-
-TEST_F(JsonParser_Array_Tests, IncompleteFalse) {
-  whenInputIs("[fals!]");
-  parseMustFail();
-}
-
-TEST_F(JsonParser_Array_Tests, MixedTrueFalse) {
-  whenInputIs("[trufalse]");
-  parseMustFail();
-}
-
 TEST_F(JsonParser_Array_Tests, TwoStringsDoubleQuotes) {
   whenInputIs("[ \"hello\" , \"world\" ]");
 

test/JsonVariant_As_Tests.cpp

@@ -0,0 +1,177 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.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(String("4.20"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, DoubleAsLong) {
+  JsonVariant variant = 4.2;
+  ASSERT_EQ(4L, variant.as<long>());
+}
+
+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(String("0"), variant.as<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(String("1"), variant.as<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, LongAsDouble) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(42.0, variant.as<double>());
+}
+
+TEST(JsonVariant_As_Tests, LongAsString) {
+  JsonVariant variant = 42L;
+  ASSERT_EQ(String("42"), variant.as<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(String("null"), variant.as<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>());
+}
+
+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, 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(String("{\"key\":\"value\"}"), variant.as<String>());
+}
+
+TEST(JsonVariant_As_Tests, ArrayAsString) {
+  DynamicJsonBuffer buffer;
+
+  JsonArray& arr = buffer.createArray();
+  arr.add(4);
+  arr.add(2);
+
+  JsonVariant variant = arr;
+  ASSERT_EQ(String("[4,2]"), variant.as<String>());
+}

test/JsonVariant_Is_Tests.cpp

@@ -0,0 +1,92 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#define ARDUINOJSON_ENABLE_STD_STREAM
+#include <ArduinoJson.h>
+
+#define SUITE JsonVariant_Is_Tests
+
+using namespace ArduinoJson::Internals;
+
+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, ArrayIsArry) { assertIs<JsonArray&>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsBool) { assertIsNot<bool>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsDouble) { assertIsNot<double>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsFloat) { assertIsNot<float>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsInt) { assertIsNot<int>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsLong) { assertIsNot<long>(JsonArray::invalid()); }
+TEST(SUITE, ArrayIsString) { assertIsNot<const char*>(JsonArray::invalid()); }
+
+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, UnparsedIntIsArra) { assertIsNot<JsonArray&>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(Unparsed("42")); }
+
+TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(Unparsed("4.2")); }

test/JsonWriter_WriteString_Tests.cpp

@@ -7,14 +7,14 @@
 #include <gtest/gtest.h>
 
 #include <ArduinoJson/Internals/JsonWriter.hpp>
-#include <ArduinoJson/Internals/StringBuilder.hpp>
+#include <ArduinoJson/Internals/StaticStringBuilder.hpp>
 
 using namespace ArduinoJson::Internals;
 
 class JsonWriter_WriteString_Tests : public testing::Test {
  protected:
   void whenInputIs(const char *input) {
-    StringBuilder sb(buffer, sizeof(buffer));
+    StaticStringBuilder sb(buffer, sizeof(buffer));
     JsonWriter writer(sb);
     writer.writeString(input);
     returnValue = writer.bytesWritten();

test/StringBuilderTests.cpp

@@ -5,14 +5,14 @@
 // https://github.com/bblanchon/ArduinoJson
 
 #include <gtest/gtest.h>
-#include <ArduinoJson/Internals/StringBuilder.hpp>
+#include <ArduinoJson/Internals/StaticStringBuilder.hpp>
 
 using namespace ArduinoJson::Internals;
 
 class StringBuilderTests : public testing::Test {
  protected:
   virtual void SetUp() {
-    _stringBuilder = new StringBuilder(_buffer, sizeof(_buffer));
+    _stringBuilder = new StaticStringBuilder(_buffer, sizeof(_buffer));
   }
 
   virtual void TearDown() { delete _stringBuilder; }