Use float instead of double to reduce the size of JsonVariant (issue #134)

.gitignore

@@ -4,3 +4,5 @@
 /bin
 /lib
 /sftp-config.json
+.tags
+.tags_sorted_by_file

CHANGELOG.md

@@ -1,6 +1,23 @@
 ArduinoJson: change log
 =======================
 
+v5.0.5
+------
+
+* Add overload `JsonObjectSuscript::set(value, decimals)` (issue #143)
+* Use `float` instead of `double` to reduce the size of `JsonVariant` (issue #134)
+
+v5.0.4
+------
+
+* Fixed ambiguous overload with `JsonArraySubscript` and `JsonObjectSubscript` (issue #122)
+
+v5.0.3
+------
+
+* Fixed `printTo(String)` which wrote numbers instead of strings (issue #120)
+* Fixed return type of `JsonArray::is<T>()` and some others (issue #121)
+
 v5.0.2
 ------
 

README.md

@@ -21,37 +21,49 @@ Features
 * Small footprint
 * MIT License
 
+Works on
+--------
+
+* All Arduino boards
+* ESP8266
+* Teensy
+* Computers (Windows, Linux, OSX...)
+
 Quick start
 -----------
 
 #### Decoding / Parsing
 
-    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    StaticJsonBuffer<200> jsonBuffer;
+StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.parseObject(json);
+JsonObject& root = jsonBuffer.parseObject(json);
 
-    const char* sensor = root["sensor"];
-    long time          = root["time"];
-    double latitude    = root["data"][0];
-    double longitude   = root["data"][1];
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
+```
 
 #### Encoding / Generating
 
-    StaticJsonBuffer<200> jsonBuffer;
+```c++
+StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-    JsonArray& data = root.createNestedArray("data");
-    data.add(48.756080, 6);  // 6 is the number of decimals to print
-    data.add(2.302038, 6);   // if not specified, 2 digits are printed
+JsonArray& data = root.createNestedArray("data");
+data.add(48.756080, 6);  // 6 is the number of decimals to print
+data.add(2.302038, 6);   // if not specified, 2 digits are printed
 
-    root.printTo(Serial);
-    // This prints:
-    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+root.printTo(Serial);
+// This prints:
+// {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+```
 
 
 Documentation
@@ -78,6 +90,14 @@ From GitHub user `zacsketches`:
 > I've been watching you consistently develop this library over the past six months, and I used it today for a publish and subscribe architecture designed to help hobbyists move into more advanced robotics. Your library allowed me to implement remote subscription in order to facilitate multi-processor robots.
 > ArduinoJson saved me a week's worth of time!!
 
+[From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
+
+> This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.
+
+[From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
+
+> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.
+
 ---
 
 Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -10,6 +10,7 @@ using namespace ArduinoJson::Internals;
 
 void setup() {
   Serial.begin(9600);
+  // delay(1000); <--needed for some boards (like Teensy)
 
   IndentedPrint serial(Serial);
   serial.setTabSize(4);

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -8,6 +8,7 @@
 
 void setup() {
   Serial.begin(9600);
+  // delay(1000); <--needed for some boards (like Teensy)
 
   StaticJsonBuffer<200> jsonBuffer;
 

examples/JsonParserExample/JsonParserExample.ino

@@ -8,6 +8,7 @@
 
 void setup() {
   Serial.begin(9600);
+  // delay(1000); <--needed for some boards (like Teensy)
 
   StaticJsonBuffer<200> jsonBuffer;
 

include/ArduinoJson/Arduino/Print.hpp

@@ -20,6 +20,7 @@ class Print {
 
   size_t print(const char[]);
   size_t print(double, int = 2);
+  size_t print(int);
   size_t print(long);
   size_t println();
 };

include/ArduinoJson/Arduino/String.hpp

@@ -16,6 +16,7 @@ class String : public std::string {
   String(const char *cstr = "") : std::string(cstr) {}
   String(const String &str) : std::string(str) {}
   explicit String(long);
+  explicit String(int);
   explicit String(double, unsigned char decimalPlaces = 2);
 };
 

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -18,7 +18,8 @@ class DynamicStringBuilder : public Print {
   DynamicStringBuilder(String &str) : _str(str) {}
 
   virtual size_t write(uint8_t c) {
-    _str += c;
+    // Need to cast to char, otherwise String will print a number (issue #120)
+    _str += static_cast<char>(c);
     return 1;
   }
 

include/ArduinoJson/Internals/JsonFloat.hpp

@@ -0,0 +1,20 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+#ifdef ARDUINO
+// On embedded platform, we with use float instead of double to keep JsonVariant
+// small (issue #134)
+typedef float JsonFloat;
+#else
+typedef double JsonFloat;
+#endif
+}
+}

include/ArduinoJson/Internals/JsonInteger.hpp

@@ -0,0 +1,13 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+typedef long JsonInteger;
+}
+}

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -6,6 +6,9 @@
 
 #pragma once
 
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
+
 namespace ArduinoJson {
 
 // Forward declarations
@@ -13,12 +16,11 @@ class JsonArray;
 class JsonObject;
 
 namespace Internals {
-
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  double asDouble;       // asDouble is also used for float
-  long asLong;           // asLong is also used for bool, char, short and int
+  JsonFloat asFloat;      // used for double and float
+  JsonInteger asInteger;  // used for bool, char, short, int and longs
   const char* asString;   // asString can be null
   JsonArray* asArray;     // asArray cannot be null
   JsonObject* asObject;   // asObject cannot be null

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -19,17 +19,17 @@ enum JsonVariantType {
   JSON_UNPARSED,   // the JsonVariant contains an unparsed string
   JSON_STRING,     // the JsonVariant stores a const char*
   JSON_BOOLEAN,    // the JsonVariant stores a bool
-  JSON_LONG,       // the JsonVariant stores a long
+  JSON_INTEGER,    // the JsonVariant stores an integer
   JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
   JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
 
-  // The following values are reserved for double values
+  // The following values are reserved for float values
   // Multiple values are used for double, depending on the number of decimal
   // digits that must be printed in the JSON output.
   // This little trick allow to save one extra member in JsonVariant
-  JSON_DOUBLE_0_DECIMALS
-  // JSON_DOUBLE_1_DECIMAL
-  // JSON_DOUBLE_2_DECIMALS
+  JSON_FLOAT_0_DECIMALS
+  // JSON_FLOAT_1_DECIMAL
+  // JSON_FLOAT_2_DECIMALS
   // ...
 };
 }

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -9,6 +9,8 @@
 #include "../Arduino/Print.hpp"
 #include "Encoding.hpp"
 #include "ForceInline.hpp"
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -60,9 +62,9 @@ class JsonWriter {
     }
   }
 
-  void writeLong(long value) { _length += _sink.print(value); }
+  void writeInteger(JsonInteger value) { _length += _sink.print(value); }
 
-  void writeDouble(double value, uint8_t decimals) {
+  void writeFloat(JsonFloat value, uint8_t decimals) {
     _length += _sink.print(value, decimals);
   }
 

include/ArduinoJson/Internals/StaticStringBuilder.hpp

@@ -14,7 +14,7 @@ namespace Internals {
 // A Print implementation that allows to write in a char[]
 class StaticStringBuilder : public Print {
  public:
-  StaticStringBuilder(char *buf, int size)
+  StaticStringBuilder(char *buf, size_t size)
       : buffer(buf), capacity(size - 1), length(0) {
     buffer[0] = '\0';
   }
@@ -23,8 +23,8 @@ class StaticStringBuilder : public Print {
 
  private:
   char *buffer;
-  int capacity;
-  int length;
+  size_t capacity;
+  size_t length;
 };
 }
 }

include/ArduinoJson/JsonArray.hpp

@@ -63,7 +63,8 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   FORCE_INLINE bool add(const String &value);
   FORCE_INLINE bool add(JsonArray &array);
   FORCE_INLINE bool add(JsonObject &object);
-  FORCE_INLINE bool add(const JsonVariant &object);
+  template <typename T>
+  FORCE_INLINE bool add(const T &value);
 
   // Sets the value at specified index.
   FORCE_INLINE void set(size_t index, bool value);
@@ -81,7 +82,8 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
   FORCE_INLINE void set(size_t index, const String &value);
   FORCE_INLINE void set(size_t index, JsonArray &array);
   FORCE_INLINE void set(size_t index, JsonObject &object);
-  FORCE_INLINE void set(size_t index, const JsonVariant &object);
+  template <typename T>
+  FORCE_INLINE void set(size_t index, const T &value);
 
   // Gets the value at the specified index.
   FORCE_INLINE JsonVariant get(size_t index) const;
@@ -92,7 +94,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
 
   // Check the type of the value at specified index.
   template <typename T>
-  FORCE_INLINE T is(size_t index) const;
+  FORCE_INLINE bool is(size_t index) const;
 
   // Creates a JsonArray and adds a reference at the end of the array.
   // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()

include/ArduinoJson/JsonArray.ipp

@@ -77,8 +77,9 @@ inline bool JsonArray::add(JsonObject &object) {
   return addNode<JsonObject &>(object);
 }
 
-inline bool JsonArray::add(const JsonVariant &object) {
-  return addNode<const JsonVariant &>(object);
+template <typename T>
+inline bool JsonArray::add(const T &variant) {
+  return addNode<const JsonVariant &>(variant);
 }
 
 template <typename TValue>
@@ -149,8 +150,9 @@ inline void JsonArray::set(size_t index, JsonObject &object) {
   return setNodeAt<JsonObject &>(index, object);
 }
 
-inline void JsonArray::set(size_t index, const JsonVariant &object) {
-  return setNodeAt<const JsonVariant &>(index, object);
+template <typename T>
+inline void JsonArray::set(size_t index, const T &variant) {
+  return setNodeAt<const JsonVariant &>(index, variant);
 }
 
 template <typename TValue>
@@ -182,7 +184,7 @@ inline T JsonArray::get(size_t index) const {
 }
 
 template <typename T>
-inline T JsonArray::is(size_t index) const {
+inline bool JsonArray::is(size_t index) const {
   node_type *node = getNodeAt(index);
   return node ? node->content.is<T>() : false;
 }

include/ArduinoJson/JsonArraySubscript.hpp

@@ -8,6 +8,11 @@
 
 #include "JsonSubscriptBase.hpp"
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
 namespace ArduinoJson {
 class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
  public:
@@ -16,6 +21,15 @@ class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
 
   using JsonSubscriptBase<JsonArraySubscript>::operator=;
 
+  JsonArraySubscript& operator=(const JsonArraySubscript& src) {
+    return assign<const JsonVariant&>(src);
+  }
+
+  template <typename T>
+  JsonArraySubscript& operator=(const T& src) {
+    return assign<const JsonVariant&>(src);
+  }
+
   FORCE_INLINE bool success() const { return _index < _array.size(); }
 
   FORCE_INLINE operator JsonVariant() const { return _array.get(_index); }
@@ -26,7 +40,7 @@ class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
   }
 
   template <typename T>
-  FORCE_INLINE T is() const {
+  FORCE_INLINE bool is() const {
     return _array.is<T>(_index);
   }
 
@@ -52,3 +66,7 @@ inline std::ostream& operator<<(std::ostream& os,
 #endif
 
 }  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/ArduinoJson/JsonObject.hpp

@@ -65,6 +65,9 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   FORCE_INLINE bool set(const char* key, JsonArray& array);
   FORCE_INLINE bool set(const char* key, JsonObject& object);
   FORCE_INLINE bool set(const char* key, const JsonVariant& value);
+  template <typename T>
+  FORCE_INLINE bool set(const char* key, const T& value);
+
   FORCE_INLINE bool set(const String& key, bool value);
   FORCE_INLINE bool set(const String& key, float value, uint8_t decimals = 2);
   FORCE_INLINE bool set(const String& key, double value, uint8_t decimals = 2);
@@ -81,6 +84,8 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
   FORCE_INLINE bool set(const String& key, JsonArray& array);
   FORCE_INLINE bool set(const String& key, JsonObject& object);
   FORCE_INLINE bool set(const String& key, const JsonVariant& value);
+  template <typename T>
+  FORCE_INLINE bool set(const String& key, const T& value);
 
   // Gets the value associated with the specified key.
   FORCE_INLINE JsonVariant get(JsonObjectKey) const;

include/ArduinoJson/JsonObject.ipp

@@ -116,6 +116,10 @@ inline bool JsonObject::set(const char *key, JsonObject &object) {
 inline bool JsonObject::set(const char *key, const JsonVariant &value) {
   return setNodeAt<const char *, const JsonVariant &>(key, value);
 }
+template <typename T>
+inline bool JsonObject::set(const char *key, const T &value) {
+  return setNodeAt<const char *, JsonVariant>(key, value);
+}
 inline bool JsonObject::set(const String &key, bool value) {
   return setNodeAt<const String &, bool>(key, value);
 }
@@ -166,6 +170,10 @@ inline bool JsonObject::set(const String &key, JsonObject &object) {
 inline bool JsonObject::set(const String &key, const JsonVariant &value) {
   return setNodeAt<const String &, const JsonVariant &>(key, value);
 }
+template <typename T>
+inline bool JsonObject::set(const String &key, const T &value) {
+  return setNodeAt<const String &, JsonVariant>(key, value);
+}
 
 template <typename TKey, typename TValue>
 inline bool JsonObject::setNodeAt(TKey key, TValue value) {

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -8,6 +8,11 @@
 
 #include "JsonSubscriptBase.hpp"
 
+#ifdef _MSC_VER
+#pragma warning(push)
+#pragma warning(disable : 4522)
+#endif
+
 namespace ArduinoJson {
 
 template <typename TKey>
@@ -19,6 +24,17 @@ class JsonObjectSubscript
 
   using JsonSubscriptBase<JsonObjectSubscript<TKey> >::operator=;
 
+  JsonObjectSubscript<TKey>& operator=(const JsonObjectSubscript<TKey>& src) {
+    return JsonSubscriptBase<JsonObjectSubscript<TKey> >::template assign<
+        JsonVariant>(src);
+  }
+
+  template <typename T>
+  JsonObjectSubscript<TKey>& operator=(const T& src) {
+    return JsonSubscriptBase<JsonObjectSubscript<TKey> >::template assign<
+        JsonVariant>(src);
+  }
+
   FORCE_INLINE bool success() const { return _object.containsKey(_key); }
 
   FORCE_INLINE operator JsonVariant() const { return _object.get(_key); }
@@ -29,7 +45,7 @@ class JsonObjectSubscript
   }
 
   template <typename TValue>
-  FORCE_INLINE TValue is() const {
+  FORCE_INLINE bool is() const {
     return _object.is<TValue>(_key);
   }
 
@@ -38,6 +54,11 @@ class JsonObjectSubscript
     return _object.set(_key, value);
   }
 
+  template <typename TValue>
+  FORCE_INLINE bool set(TValue value, uint8_t decimals) {
+    return _object.set(_key, value, decimals);
+  }
+
   FORCE_INLINE JsonVariant get() { return _object.get(_key); }
 
   void writeTo(Internals::JsonWriter& writer) const {
@@ -60,4 +81,8 @@ inline std::ostream& operator<<(
   return source.printTo(os);
 }
 #endif
-}
+}  // namespace ArduinoJson
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif

include/ArduinoJson/JsonSubscriptBase.hpp

@@ -68,10 +68,10 @@ class JsonSubscriptBase : public JsonVariantBase<TImpl> {
   }
 
   FORCE_INLINE TImpl& operator=(JsonVariant value) {
-    return assign<JsonVariant>(value);
+    return assign<const JsonVariant&>(value);
   }
 
- private:
+ protected:
   template <typename TValue>
   FORCE_INLINE TImpl& assign(TValue value) {
     TImpl* that = static_cast<TImpl*>(this);

include/ArduinoJson/JsonVariant.hpp

@@ -83,6 +83,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
   static T invalid();
 
  private:
+  Internals::JsonFloat asFloat() const;
+  Internals::JsonInteger asInteger() const;
+
   // The current type of the variant
   Internals::JsonVariantType _type;
 

include/ArduinoJson/JsonVariant.ipp

@@ -11,8 +11,9 @@
 namespace ArduinoJson {
 
 inline JsonVariant::JsonVariant(bool value) {
-  _type = Internals::JSON_BOOLEAN;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_BOOLEAN;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(const char *value) {
@@ -26,15 +27,15 @@ inline JsonVariant::JsonVariant(Internals::Unparsed value) {
 }
 
 inline JsonVariant::JsonVariant(double value, uint8_t decimals) {
-  _type = static_cast<Internals::JsonVariantType>(
-      Internals::JSON_DOUBLE_0_DECIMALS + decimals);
-  _content.asDouble = value;
+  using namespace Internals;
+  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
+  _content.asFloat = static_cast<JsonFloat>(value);
 }
 
 inline JsonVariant::JsonVariant(float value, uint8_t decimals) {
-  _type = static_cast<Internals::JsonVariantType>(
-      Internals::JSON_DOUBLE_0_DECIMALS + decimals);
-  _content.asDouble = value;
+  using namespace Internals;
+  _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
+  _content.asFloat = static_cast<JsonFloat>(value);
 }
 
 inline JsonVariant::JsonVariant(JsonArray &array) {
@@ -48,51 +49,53 @@ inline JsonVariant::JsonVariant(JsonObject &object) {
 }
 
 inline JsonVariant::JsonVariant(signed char value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(signed int value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(signed long value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(signed short value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(unsigned char value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(unsigned int value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(unsigned long value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
 inline JsonVariant::JsonVariant(unsigned short value) {
-  _type = Internals::JSON_LONG;
-  _content.asLong = value;
+  using namespace Internals;
+  _type = JSON_INTEGER;
+  _content.asInteger = static_cast<JsonInteger>(value);
 }
 
-template <>
-double JsonVariant::as<double>() const;
-
-template <>
-long JsonVariant::as<long>() const;
-
 template <>
 String JsonVariant::as<String>() const;
 
@@ -101,47 +104,57 @@ const char *JsonVariant::as<const char *>() const;
 
 template <>
 inline bool JsonVariant::as<bool>() const {
-  return as<long>() != 0;
+  return asInteger() != 0;
 }
 
 template <>
 inline signed char JsonVariant::as<signed char>() const {
-  return static_cast<signed char>(as<long>());
+  return static_cast<signed char>(asInteger());
 }
 
 template <>
 inline unsigned char JsonVariant::as<unsigned char>() const {
-  return static_cast<unsigned char>(as<long>());
+  return static_cast<unsigned char>(asInteger());
 }
 
 template <>
 inline signed short JsonVariant::as<signed short>() const {
-  return static_cast<signed short>(as<long>());
+  return static_cast<signed short>(asInteger());
 }
 
 template <>
 inline unsigned short JsonVariant::as<unsigned short>() const {
-  return static_cast<unsigned short>(as<long>());
+  return static_cast<unsigned short>(asInteger());
 }
 
 template <>
 inline signed int JsonVariant::as<signed int>() const {
-  return static_cast<signed int>(as<long>());
+  return static_cast<signed int>(asInteger());
 }
 
 template <>
 inline unsigned int JsonVariant::as<unsigned int>() const {
-  return static_cast<unsigned int>(as<long>());
+  return static_cast<unsigned int>(asInteger());
 }
 
 template <>
 inline unsigned long JsonVariant::as<unsigned long>() const {
-  return static_cast<unsigned long>(as<long>());
+  return static_cast<unsigned long>(asInteger());
+}
+
+template <>
+inline signed long JsonVariant::as<signed long>() const {
+  return static_cast<unsigned long>(asInteger());
+}
+
+template <>
+inline double JsonVariant::as<double>() const {
+  return static_cast<double>(asFloat());
 }
 
 template <>
 inline float JsonVariant::as<float>() const {
-  return static_cast<float>(as<double>());
+  return static_cast<float>(asFloat());
 }
 
 template <typename T>

library.properties

@@ -1,5 +1,5 @@
 name=ArduinoJson
-version=5.0.2
+version=5.0.5
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.

scripts/build-old-arduino-package.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG-old-layout.zip"
+
+cd $(dirname $0)/..
+
+cat > ArduinoJson.h <<END
+// WARNING:
+// --------
+// This file is a workaround for old version of the Arduino IDE.
+// If you are using Arduino IDE 1.0.6 or above, then you installed the wrong 
+// package of ArduinoJson.
+// In that case, just delete the current installation and install the package.
+
+END
+cp ArduinoJson.h ArduinoJson.cpp
+
+cat "include/ArduinoJson.h" | sed 's!include "!include "include/!g' >> ArduinoJson.h
+
+find src -name "*.cpp" |
+while read FILE; do
+	echo >> ArduinoJson.cpp
+	echo "// $FILE" >> ArduinoJson.cpp
+	echo "//" >> ArduinoJson.cpp
+	cat "$FILE" | sed 's!\.\./!!g' >> ArduinoJson.cpp
+done
+
+unix2dos ArduinoJson.cpp
+unix2dos ArduinoJson.h
+
+pushd ..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zipman dos2
+7z a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/examples \
+	ArduinoJson/include/ArduinoJson \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/ArduinoJson.h \
+	ArduinoJson/ArduinoJson.cpp \
+	-x!ArduinoJson/src/CMakeLists.txt
+
+popd
+
+rm ArduinoJson.h
+rm ArduinoJson.cpp

src/Arduino/Print.cpp

@@ -60,6 +60,12 @@ size_t Print::print(long value) {
   return print(tmp);
 }
 
+size_t Print::print(int value) {
+  char tmp[32];
+  sprintf(tmp, "%d", value);
+  return print(tmp);
+}
+
 size_t Print::println() { return write('\r') + write('\n'); }
 
 #endif

src/Arduino/String.cpp

@@ -22,4 +22,10 @@ String::String(long value) {
   *this = tmp;
 }
 
+String::String(int value) {
+  char tmp[32];
+  sprintf(tmp, "%d", value);
+  *this = tmp;
+}
+
 #endif

src/CMakeLists.txt

@@ -5,6 +5,7 @@ file(GLOB_RECURSE CPP_FILES *.cpp)
 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	add_definitions(
 		-fno-exceptions
+		-fno-rtti
 		-pedantic
 		-Wall
 		-Wcast-align

src/JsonVariant.cpp

@@ -16,6 +16,29 @@ using namespace ArduinoJson::Internals;
 
 namespace ArduinoJson {
 
+template <typename TFloat>
+static TFloat parse(const char *);
+
+template <>
+FORCE_INLINE float parse<float>(const char *s) {
+  return static_cast<float>(strtod(s, NULL));
+}
+
+template <>
+FORCE_INLINE double parse<double>(const char *s) {
+  return strtod(s, NULL);
+}
+
+template <>
+FORCE_INLINE long parse<long>(const char *s) {
+  return strtol(s, NULL, 10);
+}
+
+template <>
+FORCE_INLINE int parse<int>(const char *s) {
+  return atoi(s);
+}
+
 template <>
 const char *JsonVariant::as<const char *>() const {
   if (_type == JSON_UNPARSED && _content.asString &&
@@ -25,29 +48,27 @@ const char *JsonVariant::as<const char *>() const {
   return NULL;
 }
 
-template <>
-double JsonVariant::as<double>() const {
-  if (_type >= JSON_DOUBLE_0_DECIMALS) return _content.asDouble;
+JsonFloat JsonVariant::asFloat() const {
+  if (_type >= JSON_FLOAT_0_DECIMALS) return _content.asFloat;
 
-  if (_type == JSON_LONG || _type == JSON_BOOLEAN)
-    return static_cast<double>(_content.asLong);
+  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
+    return static_cast<JsonFloat>(_content.asInteger);
 
   if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString)
-    return strtod(_content.asString, NULL);
+    return parse<JsonFloat>(_content.asString);
 
   return 0.0;
 }
 
-template <>
-long JsonVariant::as<long>() const {
-  if (_type == JSON_LONG || _type == JSON_BOOLEAN) return _content.asLong;
+JsonInteger JsonVariant::asInteger() const {
+  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN) return _content.asInteger;
 
-  if (_type >= JSON_DOUBLE_0_DECIMALS)
-    return static_cast<long>(_content.asDouble);
+  if (_type >= JSON_FLOAT_0_DECIMALS)
+    return static_cast<JsonInteger>(_content.asFloat);
 
   if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString) {
     if (!strcmp("true", _content.asString)) return 1;
-    return strtol(_content.asString, NULL, 10);
+    return parse<JsonInteger>(_content.asString);
   }
 
   return 0L;
@@ -59,12 +80,12 @@ String JsonVariant::as<String>() const {
       _content.asString != NULL)
     return String(_content.asString);
 
-  if (_type == JSON_LONG || _type == JSON_BOOLEAN)
-    return String(_content.asLong);
+  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
+    return String(_content.asInteger);
 
-  if (_type >= JSON_DOUBLE_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
-    return String(_content.asDouble, decimals);
+  if (_type >= JSON_FLOAT_0_DECIMALS) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
+    return String(_content.asFloat, decimals);
   }
 
   String s;
@@ -74,7 +95,7 @@ String JsonVariant::as<String>() const {
 
 template <>
 bool JsonVariant::is<signed long>() const {
-  if (_type == JSON_LONG) return true;
+  if (_type == JSON_INTEGER) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
 
@@ -87,7 +108,7 @@ bool JsonVariant::is<signed long>() const {
 
 template <>
 bool JsonVariant::is<double>() const {
-  if (_type >= JSON_DOUBLE_0_DECIMALS) return true;
+  if (_type >= JSON_FLOAT_0_DECIMALS) return true;
 
   if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
 
@@ -111,15 +132,15 @@ void JsonVariant::writeTo(JsonWriter &writer) const {
   else if (_type == JSON_UNPARSED)
     writer.writeRaw(_content.asString);
 
-  else if (_type == JSON_LONG)
-    writer.writeLong(_content.asLong);
+  else if (_type == JSON_INTEGER)
+    writer.writeInteger(_content.asInteger);
 
   else if (_type == JSON_BOOLEAN)
-    writer.writeBoolean(_content.asLong != 0);
+    writer.writeBoolean(_content.asInteger != 0);
 
-  else if (_type >= JSON_DOUBLE_0_DECIMALS) {
-    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
-    writer.writeDouble(_content.asDouble, decimals);
+  else if (_type >= JSON_FLOAT_0_DECIMALS) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
+    writer.writeFloat(_content.asFloat, decimals);
   }
 }
 }

test/ArduinoString_Tests.cpp

@@ -71,6 +71,26 @@ TEST_F(ArduinoStringTests, JsonObject_SetKeyValue) {
   ASSERT_STREQ("world", object["hello"]);
 }
 
+TEST_F(ArduinoStringTests, JsonObject_SetToArraySubscript) {
+  JsonArray &arr = _jsonBuffer.createArray();
+  arr.add("world");
+
+  JsonObject &object = _jsonBuffer.createObject();
+  object.set(String("hello"), arr[0]);
+
+  ASSERT_STREQ("world", object["hello"]);
+}
+
+TEST_F(ArduinoStringTests, JsonObject_SetToObjectSubscript) {
+  JsonObject &arr = _jsonBuffer.createObject();
+  arr.set("x", "world");
+
+  JsonObject &object = _jsonBuffer.createObject();
+  object.set(String("hello"), arr["x"]);
+
+  ASSERT_STREQ("world", object["hello"]);
+}
+
 TEST_F(ArduinoStringTests, JsonObject_Get) {
   char json[] = "{\"key\":\"value\"}";
   const JsonObject &object = _jsonBuffer.parseObject(json);

test/DynamicJsonBuffer_Basic_Tests.cpp

@@ -22,9 +22,9 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, InitialSizeIsZero) {
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, SizeIncreasesAfterAlloc) {
   buffer.alloc(1);
-  ASSERT_LE(1, buffer.size());
+  ASSERT_LE(1U, buffer.size());
   buffer.alloc(1);
-  ASSERT_LE(2, buffer.size());
+  ASSERT_LE(2U, buffer.size());
 }
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {

test/DynamicJsonBuffer_NoMemory_Tests.cpp

@@ -7,17 +7,22 @@
 #include <gtest/gtest.h>
 #include <ArduinoJson.h>
 
-class DynamicJsonBuffer_NoMemory_Tests : public ::testing::Test {
-  class NoMemoryAllocator {
+class NoMemoryAllocator {
  public:
   void* allocate(size_t) { return NULL; }
   void deallocate(void*) {}
-  };
+};
 
+class DynamicJsonBuffer_NoMemory_Tests : public ::testing::Test {
  protected:
   Internals::BlockJsonBuffer<NoMemoryAllocator> _jsonBuffer;
 };
 
+TEST_F(DynamicJsonBuffer_NoMemory_Tests, FixCodeCoverage) {
+  // call this function to fix code coverage
+  NoMemoryAllocator().deallocate(NULL);
+}
+
 TEST_F(DynamicJsonBuffer_NoMemory_Tests, CreateArray) {
   ASSERT_FALSE(_jsonBuffer.createArray().success());
 }

test/JsonArray_Add_Tests.cpp

@@ -0,0 +1,90 @@
+// 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>
+
+class JsonArray_Add_Tests : public ::testing::Test {
+ protected:
+  JsonArray_Add_Tests() : _array(_jsonBuffer.createArray()) {}
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& _array;
+};
+
+#define TEST_(name) TEST_F(JsonArray_Add_Tests, name)
+
+TEST_(SizeIncreased_WhenValuesAreAdded) {
+  _array.add("hello");
+  EXPECT_EQ(1U, _array.size());
+}
+
+TEST_(StoreInteger) {
+  _array.add(123);
+  EXPECT_EQ(123, _array[0].as<int>());
+  EXPECT_TRUE(_array[0].is<int>());
+  EXPECT_FALSE(_array[0].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _array.add(123.45);
+  EXPECT_EQ(123.45, _array[0].as<double>());
+  EXPECT_TRUE(_array[0].is<double>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreBoolean) {
+  _array.add(true);
+  EXPECT_EQ(true, _array[0].as<bool>());
+  EXPECT_TRUE(_array[0].is<bool>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreString) {
+  _array.add("hello");
+  EXPECT_STREQ("hello", _array[0].as<const char*>());
+  EXPECT_TRUE(_array[0].is<const char*>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _array.add(arr);
+
+  EXPECT_EQ(&arr, &_array[0].as<JsonArray&>());
+  EXPECT_TRUE(_array[0].is<JsonArray&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _array.add(obj);
+
+  EXPECT_EQ(&obj, &_array[0].as<JsonObject&>());
+  EXPECT_TRUE(_array[0].is<JsonObject&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add("hello");
+
+  _array.add(arr[0]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj["x"] = "hello";
+
+  _array.add(obj["x"]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}

test/JsonArray_Basic_Tests.cpp

@@ -0,0 +1,41 @@
+// 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 TEST_(name) TEST(JsonArray_Basic_Tests, name)
+
+TEST_(SuccessIsTrue) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& array = _jsonBuffer.createArray();
+
+  EXPECT_TRUE(array.success());
+}
+
+TEST_(InitialSizeIsZero) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& array = _jsonBuffer.createArray();
+
+  EXPECT_EQ(0U, array.size());
+}
+
+TEST_(CreateNestedArray) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& array = _jsonBuffer.createArray();
+
+  JsonArray& arr = array.createNestedArray();
+  EXPECT_EQ(&arr, &array[0].as<JsonArray&>());
+}
+
+TEST_(CreateNestedObject) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& array = _jsonBuffer.createArray();
+
+  JsonObject& obj = array.createNestedObject();
+  EXPECT_EQ(&obj, &array[0].as<JsonObject&>());
+}

test/JsonArray_Container_Tests.cpp

@@ -1,180 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#include <gtest/gtest.h>
-#include <ArduinoJson.h>
-
-class JsonArray_Container_Tests : public ::testing::Test {
- protected:
-  JsonArray_Container_Tests() : _array(_jsonBuffer.createArray()) {}
-
-  template <typename T>
-  void firstMustEqual(T expected) {
-    itemMustEqual(0, expected);
-  }
-
-  template <typename T>
-  void secondMustEqual(T expected) {
-    itemMustEqual(1, expected);
-  }
-
-  template <typename T>
-  void firstMustReference(const T& expected) {
-    itemMustReference(0, expected);
-  }
-
-  template <typename T>
-  void secondMustReference(const T& expected) {
-    itemMustReference(1, expected);
-  }
-
-  void sizeMustBe(int expected) { EXPECT_EQ(expected, _array.size()); }
-
-  DynamicJsonBuffer _jsonBuffer;
-  JsonArray& _array;
-
- private:
-  template <typename T>
-  void itemMustEqual(int index, T expected) {
-    EXPECT_EQ(expected, _array[index].as<T>());
-  }
-
-  template <typename T>
-  void itemMustReference(int index, const T& expected) {
-    EXPECT_EQ(&expected, &_array[index].as<T&>());
-  }
-};
-
-template <>
-void JsonArray_Container_Tests::itemMustEqual(int index, const char* expected) {
-  EXPECT_STREQ(expected, _array[index].asString());
-}
-
-TEST_F(JsonArray_Container_Tests, SuccessIsTrue) {
-  EXPECT_TRUE(_array.success());
-}
-
-TEST_F(JsonArray_Container_Tests, InitialSizeIsZero) { sizeMustBe(0); }
-
-TEST_F(JsonArray_Container_Tests, Grow_WhenValuesAreAdded) {
-  _array.add("hello");
-  sizeMustBe(1);
-
-  _array.add("world");
-  sizeMustBe(2);
-}
-
-TEST_F(JsonArray_Container_Tests, DontGrow_WhenValuesAreReplaced) {
-  _array.add("hello");
-  _array[0] = "world";
-  sizeMustBe(1);
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreIntegers) {
-  _array.add(123);
-  _array.add(456);
-
-  firstMustEqual(123);
-  secondMustEqual(456);
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreDoubles) {
-  _array.add(123.45);
-  _array.add(456.78);
-
-  firstMustEqual(123.45);
-  secondMustEqual(456.78);
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreBooleans) {
-  _array.add(true);
-  _array.add(false);
-
-  firstMustEqual(true);
-  secondMustEqual(false);
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreStrings) {
-  _array.add("hello");
-  _array.add("world");
-
-  firstMustEqual("hello");
-  secondMustEqual("world");
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreNestedArrays) {
-  JsonArray& inner_array1 = _jsonBuffer.createArray();
-  JsonArray& inner_array2 = _jsonBuffer.createArray();
-
-  _array.add(inner_array1);
-  _array.add(inner_array2);
-
-  firstMustReference(inner_array1);
-  secondMustReference(inner_array2);
-}
-
-TEST_F(JsonArray_Container_Tests, CanStoreNestedObjects) {
-  JsonObject& innerObject1 = _jsonBuffer.createObject();
-  JsonObject& innerObject2 = _jsonBuffer.createObject();
-
-  _array.add(innerObject1);
-  _array.add(innerObject2);
-
-  firstMustReference(innerObject1);
-  secondMustReference(innerObject2);
-}
-
-TEST_F(JsonArray_Container_Tests, CanCreateNestedArrays) {
-  JsonArray& inner_array1 = _array.createNestedArray();
-  JsonArray& inner_array2 = _array.createNestedArray();
-
-  firstMustReference(inner_array1);
-  secondMustReference(inner_array2);
-}
-
-TEST_F(JsonArray_Container_Tests, CanCreateNestedObjects) {
-  JsonObject& innerObject1 = _array.createNestedObject();
-  JsonObject& innerObject2 = _array.createNestedObject();
-
-  firstMustReference(innerObject1);
-  secondMustReference(innerObject2);
-}
-
-TEST_F(JsonArray_Container_Tests, RemoveFirstElement) {
-  _array.add("one");
-  _array.add("two");
-  _array.add("three");
-
-  _array.removeAt(0);
-
-  sizeMustBe(2);
-  firstMustEqual("two");
-  secondMustEqual("three");
-}
-
-TEST_F(JsonArray_Container_Tests, RemoveMiddleElement) {
-  _array.add("one");
-  _array.add("two");
-  _array.add("three");
-
-  _array.removeAt(1);
-
-  sizeMustBe(2);
-  firstMustEqual("one");
-  secondMustEqual("three");
-}
-
-TEST_F(JsonArray_Container_Tests, RemoveLastElement) {
-  _array.add("one");
-  _array.add("two");
-  _array.add("three");
-
-  _array.removeAt(2);
-
-  sizeMustBe(2);
-  firstMustEqual("one");
-  secondMustEqual("two");
-}

test/JsonArray_Remove_Tests.cpp

@@ -0,0 +1,46 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonArray_Remove_Tests : public ::testing::Test {
+ protected:
+  JsonArray_Remove_Tests() : _array(_jsonBuffer.createArray()) {
+    _array.add("one");
+    _array.add("two");
+    _array.add("three");
+  }
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& _array;
+};
+
+#define TEST_(name) TEST_F(JsonArray_Remove_Tests, name)
+
+TEST_(RemoveFirstElement) {
+  _array.removeAt(0);
+
+  EXPECT_EQ(2, _array.size());
+  EXPECT_STREQ("two", _array[0]);
+  EXPECT_STREQ("three", _array[1]);
+}
+
+TEST_(RemoveMiddleElement) {
+  _array.removeAt(1);
+
+  EXPECT_EQ(2, _array.size());
+  EXPECT_STREQ("one", _array[0]);
+  EXPECT_STREQ("three", _array[1]);
+}
+
+TEST_(RemoveLastElement) {
+  _array.removeAt(2);
+
+  EXPECT_EQ(2, _array.size());
+  EXPECT_STREQ("one", _array[0]);
+  EXPECT_STREQ("two", _array[1]);
+}

test/JsonArray_Set_Tests.cpp

@@ -0,0 +1,90 @@
+// 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>
+
+class JsonArray_Set_Tests : public ::testing::Test {
+ protected:
+  JsonArray_Set_Tests() : _array(_jsonBuffer.createArray()) { _array.add(0); }
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& _array;
+};
+
+#define TEST_(name) TEST_F(JsonArray_Set_Tests, name)
+
+TEST_(SizeIsUnchanged) {
+  _array.set(0, "hello");
+  EXPECT_EQ(1U, _array.size());
+}
+
+TEST_(StoreInteger) {
+  _array.set(0, 123);
+  EXPECT_EQ(123, _array[0].as<int>());
+  EXPECT_TRUE(_array[0].is<int>());
+  EXPECT_FALSE(_array[0].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _array.set(0, 123.45);
+  EXPECT_EQ(123.45, _array[0].as<double>());
+  EXPECT_TRUE(_array[0].is<double>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreBoolean) {
+  _array.set(0, true);
+  EXPECT_EQ(true, _array[0].as<bool>());
+  EXPECT_TRUE(_array[0].is<bool>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreString) {
+  _array.set(0, "hello");
+  EXPECT_STREQ("hello", _array[0].as<const char*>());
+  EXPECT_TRUE(_array[0].is<const char*>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _array.set(0, arr);
+
+  EXPECT_EQ(&arr, &_array[0].as<JsonArray&>());
+  EXPECT_TRUE(_array[0].is<JsonArray&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _array.set(0, obj);
+
+  EXPECT_EQ(&obj, &_array[0].as<JsonObject&>());
+  EXPECT_TRUE(_array[0].is<JsonObject&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add("hello");
+
+  _array.set(0, arr[0]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj["x"] = "hello";
+
+  _array.set(0, obj["x"]);
+
+  EXPECT_STREQ("hello", _array[0]);
+}

test/JsonArray_Subscript_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>
+
+class JsonArray_Subscript_Tests : public ::testing::Test {
+ protected:
+  JsonArray_Subscript_Tests() : _array(_jsonBuffer.createArray()) {
+    _array.add(0);
+  }
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray& _array;
+};
+
+#define TEST_(name) TEST_F(JsonArray_Subscript_Tests, name)
+
+TEST_(SizeIsUnchanged) {
+  _array[0] = "hello";
+  EXPECT_EQ(1U, _array.size());
+}
+
+TEST_(StoreInteger) {
+  _array[0] = 123;
+  EXPECT_EQ(123, _array[0].as<int>());
+  EXPECT_TRUE(_array[0].is<int>());
+  EXPECT_FALSE(_array[0].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _array[0] = 123.45;
+  EXPECT_EQ(123.45, _array[0].as<double>());
+  EXPECT_TRUE(_array[0].is<double>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreBoolean) {
+  _array[0] = true;
+  EXPECT_EQ(true, _array[0].as<bool>());
+  EXPECT_TRUE(_array[0].is<bool>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreString) {
+  _array[0] = "hello";
+  EXPECT_STREQ("hello", _array[0].as<const char*>());
+  EXPECT_TRUE(_array[0].is<const char*>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _array[0] = arr;
+
+  EXPECT_EQ(&arr, &_array[0].as<JsonArray&>());
+  EXPECT_TRUE(_array[0].is<JsonArray&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreNestedObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _array[0] = obj;
+
+  EXPECT_EQ(&obj, &_array[0].as<JsonObject&>());
+  EXPECT_TRUE(_array[0].is<JsonObject&>());
+  EXPECT_FALSE(_array[0].is<int>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add("hello");
+
+  _array[0] = arr[0];
+
+  EXPECT_STREQ("hello", _array[0]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj["x"] = "hello";
+
+  _array[0] = obj["x"];
+
+  EXPECT_STREQ("hello", _array[0]);
+}

test/JsonObject_Basic_Tests.cpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+#define TEST_(name) TEST(JsonObject_Basic_Tests, name)
+
+TEST_(InitialSizeIsZero) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+
+  EXPECT_EQ(0, _object.size());
+}
+
+TEST_(SuccessIsTrue) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+
+  EXPECT_TRUE(_object.success());
+}

test/JsonObject_Container_Tests.cpp

@@ -1,121 +0,0 @@
-// Copyright Benoit Blanchon 2014-2015
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-
-#include <gtest/gtest.h>
-#include <ArduinoJson.h>
-
-class JsonObject_Container_Tests : public ::testing::Test {
- public:
-  JsonObject_Container_Tests() : _object(_jsonBuffer.createObject()) {}
-
- protected:
-  DynamicJsonBuffer _jsonBuffer;
-  JsonObject& _object;
-};
-
-TEST_F(JsonObject_Container_Tests, InitialSizeIsZero) {
-  EXPECT_EQ(0, _object.size());
-}
-
-TEST_F(JsonObject_Container_Tests, Grow_WhenValuesAreAdded) {
-  _object["hello"] = 1;
-  EXPECT_EQ(1, _object.size());
-
-  _object.set("world", 2);
-  EXPECT_EQ(2, _object.size());
-}
-
-TEST_F(JsonObject_Container_Tests, DoNotGrow_WhenSameValueIsAdded) {
-  _object["hello"] = 1;
-  EXPECT_EQ(1, _object.size());
-
-  _object["hello"] = 2;
-  EXPECT_EQ(1, _object.size());
-}
-
-TEST_F(JsonObject_Container_Tests, Shrink_WhenValuesAreRemoved) {
-  _object["hello"] = 1;
-  _object["world"] = 2;
-
-  _object.remove("hello");
-  EXPECT_EQ(1, _object.size());
-
-  _object.remove("world");
-  EXPECT_EQ(0, _object.size());
-}
-
-TEST_F(JsonObject_Container_Tests,
-       DoNotShrink_WhenRemoveIsCalledWithAWrongKey) {
-  _object["hello"] = 1;
-  _object["world"] = 2;
-
-  _object.remove(":-P");
-
-  EXPECT_EQ(2, _object.size());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreIntegers) {
-  _object["hello"] = 123;
-  _object.set("world", 456);
-
-  EXPECT_EQ(123, _object["hello"].as<int>());
-  EXPECT_EQ(456, _object["world"].as<int>());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreDoubles) {
-  _object["hello"] = 123.45;
-  _object.set("world", 456.78);
-
-  EXPECT_EQ(123.45, _object["hello"].as<double>());
-  EXPECT_EQ(456.78, _object["world"].as<double>());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreBooleans) {
-  _object["hello"] = true;
-  _object.set("world", false);
-
-  EXPECT_TRUE(_object["hello"].as<bool>());
-  EXPECT_FALSE(_object["world"].as<bool>());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreStrings) {
-  _object["hello"] = "h3110";
-  _object.set("world", "w0r1d");
-
-  EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
-  EXPECT_STREQ("w0r1d", _object["world"].as<const char*>());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreArrays) {
-  JsonArray& array1 = _jsonBuffer.createArray();
-  JsonArray& array2 = _jsonBuffer.createArray();
-
-  _object["hello"] = array1;
-  _object.set("world", array2);
-
-  EXPECT_EQ(&array1, &_object["hello"].asArray());
-  EXPECT_EQ(&array2, &_object["world"].asArray());
-}
-
-TEST_F(JsonObject_Container_Tests, CanStoreObjects) {
-  JsonObject& object1 = _jsonBuffer.createObject();
-  JsonObject& object2 = _jsonBuffer.createObject();
-
-  _object["hello"] = object1;
-  _object.set("world", object2);
-
-  EXPECT_EQ(&object1, &_object["hello"].asObject());
-  EXPECT_EQ(&object2, &_object["world"].asObject());
-}
-
-TEST_F(JsonObject_Container_Tests, ContainsKeyReturnsFalseForNonExistingKey) {
-  EXPECT_FALSE(_object.containsKey("hello"));
-}
-
-TEST_F(JsonObject_Container_Tests, ContainsKeyReturnsTrueForDefinedValue) {
-  _object.set("hello", 42);
-  EXPECT_TRUE(_object.containsKey("hello"));
-}

test/JsonObject_ContainsKey_Tests.cpp

@@ -0,0 +1,38 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+#define TEST_(name) TEST(JsonObject_Basic_Tests, name)
+
+TEST_(ContainsKeyReturnsFalseForNonExistingKey) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+
+  _object.set("hello", 42);
+
+  EXPECT_FALSE(_object.containsKey("world"));
+}
+
+TEST_(ContainsKeyReturnsTrueForDefinedValue) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+
+  _object.set("hello", 42);
+
+  EXPECT_TRUE(_object.containsKey("hello"));
+}
+
+TEST_(ContainsKeyReturnsFalseAfterRemove) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+
+  _object.set("hello", 42);
+  _object.remove("hello");
+
+  EXPECT_FALSE(_object.containsKey("hello"));
+}

test/JsonObject_Remove_Tests.cpp

@@ -0,0 +1,30 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+#define TEST_(name) TEST(JsonObject_Remove_Tests, name)
+
+TEST_(SizeDecreased_WhenValuesAreRemoved) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+  _object["hello"] = 1;
+
+  _object.remove("hello");
+
+  EXPECT_EQ(0, _object.size());
+}
+
+TEST_(SizeUntouched_WhenRemoveIsCalledWithAWrongKey) {
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object = _jsonBuffer.createObject();
+  _object["hello"] = 1;
+
+  _object.remove("world");
+
+  EXPECT_EQ(1, _object.size());
+}

test/JsonObject_Set_Tests.cpp

@@ -0,0 +1,109 @@
+// 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>
+
+class JsonObject_Set_Tests : public ::testing::Test {
+ public:
+  JsonObject_Set_Tests() : _object(_jsonBuffer.createObject()) {}
+
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object;
+};
+
+#define TEST_(name) TEST_F(JsonObject_Set_Tests, name)
+
+TEST_(SizeIncreased_WhenValuesAreAdded) {
+  _object.set("hello", 42);
+  EXPECT_EQ(1, _object.size());
+}
+
+TEST_(SizeUntouched_WhenSameValueIsAdded) {
+  _object["hello"] = 1;
+  _object["hello"] = 2;
+  EXPECT_EQ(1, _object.size());
+}
+
+TEST_(StoreInteger) {
+  _object.set("hello", 123);
+
+  EXPECT_EQ(123, _object["hello"].as<int>());
+  EXPECT_TRUE(_object["hello"].is<int>());
+  EXPECT_FALSE(_object["hello"].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _object.set("hello", 123.45);
+
+  EXPECT_EQ(123.45, _object["hello"].as<double>());
+  EXPECT_TRUE(_object["hello"].is<double>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+}
+
+TEST_(StoreDoubleWithDigits) {
+  _object.set("hello", 123.45, 2);
+
+  EXPECT_EQ(123.45, _object["hello"].as<double>());
+  EXPECT_TRUE(_object["hello"].is<double>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+}
+
+TEST_(StoreBoolean) {
+  _object.set("hello", true);
+
+  EXPECT_TRUE(_object["hello"].as<bool>());
+  EXPECT_TRUE(_object["hello"].is<bool>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+}
+
+TEST_(StoreString) {
+  _object.set("hello", "h3110");
+
+  EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
+  EXPECT_TRUE(_object["hello"].is<const char*>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+}
+
+TEST_(StoreArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _object.set("hello", arr);
+
+  EXPECT_EQ(&arr, &_object["hello"].asArray());
+  EXPECT_TRUE(_object["hello"].is<JsonArray&>());
+  EXPECT_FALSE(_object["hello"].is<JsonObject&>());
+}
+
+TEST_(StoreObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _object.set("hello", obj);
+
+  EXPECT_EQ(&obj, &_object["hello"].asObject());
+  EXPECT_TRUE(_object["hello"].is<JsonObject&>());
+  EXPECT_FALSE(_object["hello"].is<JsonArray&>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add(42);
+
+  _object.set("a", arr[0]);
+
+  EXPECT_EQ(42, _object["a"]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj.set("x", 42);
+
+  _object.set("a", obj["x"]);
+
+  EXPECT_EQ(42, _object["a"]);
+}

test/JsonObject_Subscript_Tests.cpp

@@ -0,0 +1,109 @@
+// 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>
+
+class JsonObject_Subscript_Tests : public ::testing::Test {
+ public:
+  JsonObject_Subscript_Tests() : _object(_jsonBuffer.createObject()) {}
+
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject& _object;
+};
+
+#define TEST_(name) TEST_F(JsonObject_Subscript_Tests, name)
+
+TEST_(SizeIncreased_WhenValuesAreAdded) {
+  _object["hello"] = 1;
+  EXPECT_EQ(1, _object.size());
+}
+
+TEST_(SizeUntouched_WhenSameValueIsAdded) {
+  _object["hello"] = 1;
+  _object["hello"] = 2;
+  EXPECT_EQ(1, _object.size());
+}
+
+TEST_(StoreInteger) {
+  _object["hello"] = 123;
+
+  EXPECT_EQ(123, _object["hello"].as<int>());
+  EXPECT_TRUE(_object["hello"].is<int>());
+  EXPECT_FALSE(_object["hello"].is<double>());
+}
+
+TEST_(StoreDouble) {
+  _object["hello"] = 123.45;
+
+  EXPECT_TRUE(_object["hello"].is<double>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+  EXPECT_EQ(123.45, _object["hello"].as<double>());
+}
+
+TEST_(StoreDoubleWithDigits) {
+  _object["hello"].set(123.45, 2);
+
+  EXPECT_TRUE(_object["hello"].is<double>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+  EXPECT_EQ(123.45, _object["hello"].as<double>());
+}
+
+TEST_(StoreBoolean) {
+  _object["hello"] = true;
+
+  EXPECT_TRUE(_object["hello"].is<bool>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+  EXPECT_TRUE(_object["hello"].as<bool>());
+}
+
+TEST_(StoreString) {
+  _object["hello"] = "h3110";
+
+  EXPECT_TRUE(_object["hello"].is<const char*>());
+  EXPECT_FALSE(_object["hello"].is<long>());
+  EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
+}
+
+TEST_(StoreArray) {
+  JsonArray& arr = _jsonBuffer.createArray();
+
+  _object["hello"] = arr;
+
+  EXPECT_EQ(&arr, &_object["hello"].asArray());
+  EXPECT_TRUE(_object["hello"].is<JsonArray&>());
+  EXPECT_FALSE(_object["hello"].is<JsonObject&>());
+}
+
+TEST_(StoreObject) {
+  JsonObject& obj = _jsonBuffer.createObject();
+
+  _object["hello"] = obj;
+
+  EXPECT_EQ(&obj, &_object["hello"].asObject());
+  EXPECT_TRUE(_object["hello"].is<JsonObject&>());
+  EXPECT_FALSE(_object["hello"].is<JsonArray&>());
+}
+
+TEST_(StoreArraySubscript) {
+  JsonArray& arr = _jsonBuffer.createArray();
+  arr.add(42);
+
+  _object["a"] = arr[0];
+
+  EXPECT_EQ(42, _object["a"]);
+}
+
+TEST_(StoreObjectSubscript) {
+  JsonObject& obj = _jsonBuffer.createObject();
+  obj.set("x", 42);
+
+  _object["a"] = obj["x"];
+
+  EXPECT_EQ(42, _object["a"]);
+}

test/StaticJsonBuffer_Basic_Tests.cpp

@@ -26,9 +26,9 @@ TEST_F(StaticJsonBuffer_Basic_Tests, InitialSizeIsZero) {
 
 TEST_F(StaticJsonBuffer_Basic_Tests, GrowsAfterAlloc) {
   buffer.alloc(1);
-  ASSERT_LE(1, buffer.size());
+  ASSERT_LE(1U, buffer.size());
   buffer.alloc(1);
-  ASSERT_LE(2, buffer.size());
+  ASSERT_LE(2U, buffer.size());
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenFull) {