Set version to 5.0.6

Add library category

.gitignore

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

CHANGELOG.md

@@ -1,6 +1,40 @@
 ArduinoJson: change log
 =======================
 
+v5.0.6
+------
+
+* Added parameter to `DynamicJsonBuffer` constructor to set initial size (issue #152)
+* Fixed warning about library category in Arduino 1.6.6 (issue #147)
+* Examples: Added a loop to wait for serial port to be ready (issue #156)
+
+v5.0.5
+------
+
+* Added 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
+------
+
+* Fixed segmentation fault in `parseObject(String)` and `parseArray(String)`, when the 
+  `StaticJsonBuffer` is too small to hold a copy of the string
+* Fixed Clang warning "register specifier is deprecated" (issue #102)
+* Fixed GCC warning "declaration shadows a member" (issue #103)
+* Fixed memory alignment, which made ESP8266 crash (issue #104)
+* Fixed compilation on Visual Studio 2010 and 2012 (issue #107)
+
 v5.0.1
 ------
 

README.md

@@ -1,11 +1,11 @@
 Arduino JSON library
 ====================
 
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master)
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) 
 
 *An elegant and efficient JSON library for embedded systems.*
 
-It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
+It's designed to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
 It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
@@ -14,56 +14,68 @@ Features
 
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
-* Elegant API, very easy to use 
+* Elegant API, very easy to use
 * Efficient (no malloc, nor copy)
 * Portable (written in C++98)
 * Self-contained (no external dependency)
 * 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]}";
 
-    StaticJsonBuffer<200> jsonBuffer;
+```c++
+char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    JsonObject& root = jsonBuffer.parseObject(json);
+StaticJsonBuffer<200> jsonBuffer;
 
-    const char* sensor = root["sensor"];
-    long time          = root["time"];
-    double latitude    = root["data"][0];
-    double longitude   = root["data"][1];
+JsonObject& root = jsonBuffer.parseObject(json);
+
+const char* sensor = root["sensor"];
+long time          = root["time"];
+double latitude    = root["data"][0];
+double longitude   = root["data"][1];
+```
 
 #### Encoding / Generating
-   
-    StaticJsonBuffer<200> jsonBuffer;
 
-    JsonObject& root = jsonBuffer.createObject();
-    root["sensor"] = "gps";
-    root["time"] = 1351824120;
+```c++
+StaticJsonBuffer<200> jsonBuffer;
 
-    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
+JsonObject& root = jsonBuffer.createObject();
+root["sensor"] = "gps";
+root["time"] = 1351824120;
 
-    root.printTo(Serial);
-    // This prints:
-    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+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]}
+```
 
 
 Documentation
 -------------
 
-The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki) 
+The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki)
 
 Testimonials
 ------------
 
 From Arduino's Forum user `jflaplante`:
-> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while. 
+> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
 > I have no such problem so far with your library. It is working perfectly with my web services.
 
 From Arduino's Forum user `gbathree`:
@@ -78,6 +90,26 @@ 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.
+
+Donators
+--------
+
+Special thanks to the following persons and companies who made generous donations to the library author:
+
+* Robert Murphy
+* Surge Communications
+* Alex Scott
+* Firepick Services LLC
+* A B Doodkorte
+* Scott Smith
+
 ---
 
 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,9 @@ using namespace ArduinoJson::Internals;
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
   IndentedPrint serial(Serial);
   serial.setTabSize(4);

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -8,6 +8,9 @@
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
   StaticJsonBuffer<200> jsonBuffer;
 

examples/JsonParserExample/JsonParserExample.ino

@@ -8,6 +8,9 @@
 
 void setup() {
   Serial.begin(9600);
+  while (!Serial) {
+    // wait serial port initialization
+  }
 
   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/BlockJsonBuffer.hpp

@@ -31,7 +31,8 @@ class BlockJsonBuffer : public JsonBuffer {
   };
 
  public:
-  BlockJsonBuffer() : _head(NULL) {}
+  BlockJsonBuffer(size_t initialSize = 256)
+      : _head(NULL), _nextBlockSize(initialSize) {}
 
   ~BlockJsonBuffer() {
     Block* currentBlock = _head;
@@ -55,29 +56,28 @@ class BlockJsonBuffer : public JsonBuffer {
   }
 
  private:
-  static const size_t FIRST_BLOCK_CAPACITY = 32;
-
   bool canAllocInHead(size_t bytes) const {
     return _head != NULL && _head->size + bytes <= _head->capacity;
   }
 
   void* allocInHead(size_t bytes) {
     void* p = _head->data + _head->size;
-    _head->size += bytes;
+    _head->size += round_size_up(bytes);
     return p;
   }
 
   void* allocInNewBlock(size_t bytes) {
-    size_t capacity = FIRST_BLOCK_CAPACITY;
+    size_t capacity = _nextBlockSize;
     if (_head != NULL) capacity = _head->capacity * 2;
     if (bytes > capacity) capacity = bytes;
     if (!addNewBlock(capacity)) return NULL;
+    _nextBlockSize *= 2;
     return allocInHead(bytes);
   }
 
   bool addNewBlock(size_t capacity) {
-    size_t size = sizeof(EmptyBlock) + capacity;
-    Block* block = static_cast<Block*>(_allocator.allocate(size));
+    size_t bytes = sizeof(EmptyBlock) + capacity;
+    Block* block = static_cast<Block*>(_allocator.allocate(bytes));
     if (block == NULL) return false;
     block->capacity = capacity;
     block->size = 0;
@@ -86,8 +86,9 @@ class BlockJsonBuffer : public JsonBuffer {
     return true;
   }
 
-  Block* _head;
   TAllocator _allocator;
+  Block* _head;
+  size_t _nextBlockSize;
 };
 }
 }

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/JsonParser.hpp

@@ -19,7 +19,7 @@ class JsonParser {
  public:
   JsonParser(JsonBuffer *buffer, char *json, uint8_t nestingLimit)
       : _buffer(buffer),
-        _readPtr(json),
+        _readPtr(json ? json : ""),
         _writePtr(json),
         _nestingLimit(nestingLimit) {}
 

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -6,6 +6,9 @@
 
 #pragma once
 
+#include "JsonFloat.hpp"
+#include "JsonInteger.hpp"
+
 namespace ArduinoJson {
 
 // Forward declarations
@@ -13,15 +16,14 @@ 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
-  const char* asString;  // asString can be null
-  JsonArray* asArray;    // asArray cannot be null
-  JsonObject* asObject;  // asObject cannot be null
+  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/JsonBuffer.hpp

@@ -59,9 +59,15 @@ class JsonBuffer {
   // allocation fails.
   JsonArray &parseArray(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
 
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonArray &parseArray(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseArray(strdup(json), nesting);
+  }
+
   // Same as above with a String class
   JsonArray &parseArray(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
-    return parseArray(strdup(json), nesting);
+    return parseArray(json.c_str(), nesting);
   }
 
   // Allocates and populate a JsonObject from a JSON string.
@@ -76,30 +82,54 @@ class JsonBuffer {
   // allocation fails.
   JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
 
-  // Same as above with a String class
-  JsonObject &parseObject(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+  // Same with a const char*.
+  // With this overload, the JsonBuffer will make a copy of the string
+  JsonObject &parseObject(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
     return parseObject(strdup(json), nesting);
   }
 
+  // Same as above with a String class
+  JsonObject &parseObject(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
+    return parseObject(json.c_str(), nesting);
+  }
+
   // Duplicate a string
-  char *strdup(const char *src) { return strdup(src, strlen(src)); }
+  char *strdup(const char *src) {
+    return src ? strdup(src, strlen(src)) : NULL;
+  }
   char *strdup(const String &src) { return strdup(src.c_str(), src.length()); }
-  char *strdup(const char *, size_t);
 
   // Allocates n bytes in the JsonBuffer.
   // Return a pointer to the allocated memory or NULL if allocation fails.
   virtual void *alloc(size_t size) = 0;
 
+ protected:
+  // Preserve aligment if nessary
+  static FORCE_INLINE size_t round_size_up(size_t bytes) {
+#if defined ARDUINO_ARCH_AVR
+    // alignment isn't needed for 8-bit AVR
+    return bytes;
+#else
+    const size_t x = sizeof(void *) - 1;
+    return (bytes + x) & ~x;
+#endif
+  }
+
+ private:
+  char *strdup(const char *, size_t);
+
   // Default value of nesting limit of parseArray() and parseObject().
   //
-  // The nesting limit is a contain on the level of nesting allowed in the JSON
+  // The nesting limit is a contain on the level of nesting allowed in the
+  // JSON
   // string.
   // If set to 0, only a flat array or objects can be parsed.
   // If set to 1, the object can contain nested arrays or objects but only 1
   // level deep.
   // And bigger values will allow more level of nesting.
   //
-  // The purpose of this feature is to prevent stack overflow that could lead to
+  // The purpose of this feature is to prevent stack overflow that could
+  // lead to
   // a security risk.
   static const uint8_t DEFAULT_LIMIT = 10;
 };

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,15 +68,15 @@ 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* impl = static_cast<TImpl*>(this);
-    impl->template set<TValue>(value);
-    return *impl;
+    TImpl* that = static_cast<TImpl*>(this);
+    that->template set<TValue>(value);
+    return *that;
   }
 };
 }

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>

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -21,11 +21,10 @@ class StaticJsonBuffer : public JsonBuffer {
   size_t capacity() const { return CAPACITY; }
   size_t size() const { return _size; }
 
- protected:
   virtual void* alloc(size_t bytes) {
     if (_size + bytes > CAPACITY) return NULL;
     void* p = &_buffer[_size];
-    _size += bytes;
+    _size += round_size_up(bytes);
     return p;
   }
 

library.properties

@@ -1,8 +1,9 @@
 name=ArduinoJson
-version=5.0.1
+version=5.0.6
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
 paragraph=Like this project? Please star it on GitHub!
+category=Data Processing
 url=https://github.com/bblanchon/ArduinoJson
 architectures=*

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

@@ -17,6 +17,13 @@
 #pragma GCC diagnostic ignored "-Wfloat-conversion"
 #endif
 
+// Visual Studo 2012 didn't have isnan, nor isinf
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#define isnan(x) _isnan(x)
+#define isinf(x) (!_finite(x))
+#endif
+
 size_t Print::print(const char s[]) {
   size_t n = 0;
   while (*s) {
@@ -53,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
@@ -43,6 +44,7 @@ endif()
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	add_definitions(
 		-Wc++11-compat
+		-Wdeprecated-register
 	)
 endif()
 

src/Internals/JsonParser.cpp

@@ -16,7 +16,7 @@ using namespace ArduinoJson;
 using namespace ArduinoJson::Internals;
 
 bool JsonParser::skip(char charToSkip) {
-  register const char *ptr = skipSpacesAndComments(_readPtr);
+  const char *ptr = skipSpacesAndComments(_readPtr);
   if (*ptr != charToSkip) return false;
   ptr++;
   _readPtr = skipSpacesAndComments(ptr);

src/JsonVariant.cpp

@@ -16,6 +16,29 @@ using namespace ArduinoJson::Internals;
 
 namespace ArduinoJson {
 
+template <typename TFloat>
+static TFloat parse(const char *);
+
+template <>
+float parse<float>(const char *s) {
+  return static_cast<float>(strtod(s, NULL));
+}
+
+template <>
+double parse<double>(const char *s) {
+  return strtod(s, NULL);
+}
+
+template <>
+long parse<long>(const char *s) {
+  return strtol(s, NULL, 10);
+}
+
+template <>
+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/CMakeLists.txt

@@ -10,6 +10,11 @@ include_directories(
 
 add_definitions(-DGTEST_HAS_PTHREAD=0)
 
+# Workaround for Visual Studio 2012
+if (MSVC AND MSVC_VERSION EQUAL 1700)
+  add_definitions(-D_VARIADIC_MAX=10)
+endif()
+
 add_executable(ArduinoJsonTests 
     ${TESTS_FILES}
 	${INC_FILES}

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_EQ(1, buffer.size());
+  ASSERT_LE(1U, buffer.size());
   buffer.alloc(1);
-  ASSERT_EQ(2, buffer.size());
+  ASSERT_LE(2U, buffer.size());
 }
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {
@@ -32,3 +32,12 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {
   void* p2 = buffer.alloc(2);
   ASSERT_NE(p1, p2);
 }
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, Alignment) {
+  size_t mask = sizeof(void*) - 1;
+
+  for (size_t size = 1; size <= sizeof(void*); size++) {
+    size_t addr = reinterpret_cast<size_t>(buffer.alloc(1));
+    ASSERT_EQ(0, addr & mask);
+  }
+}

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 {
-   public:
-    void* allocate(size_t) { return NULL; }
-    void deallocate(void*) {}
-  };
+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

@@ -13,11 +13,11 @@ using namespace ArduinoJson;
 
 class StaticJsonBuffer_Basic_Tests : public testing::Test {
  protected:
-  StaticJsonBuffer<42> buffer;
+  StaticJsonBuffer<64> buffer;
 };
 
 TEST_F(StaticJsonBuffer_Basic_Tests, CapacityMatchTemplateParameter) {
-  ASSERT_EQ(42, buffer.capacity());
+  ASSERT_EQ(64, buffer.capacity());
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, InitialSizeIsZero) {
@@ -26,34 +26,43 @@ TEST_F(StaticJsonBuffer_Basic_Tests, InitialSizeIsZero) {
 
 TEST_F(StaticJsonBuffer_Basic_Tests, GrowsAfterAlloc) {
   buffer.alloc(1);
-  ASSERT_EQ(1, buffer.size());
+  ASSERT_LE(1U, buffer.size());
   buffer.alloc(1);
-  ASSERT_EQ(2, buffer.size());
+  ASSERT_LE(2U, buffer.size());
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenFull) {
-  buffer.alloc(42);
+  buffer.alloc(64);
   buffer.alloc(1);
-  ASSERT_EQ(42, buffer.size());
+  ASSERT_EQ(64, buffer.size());
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenTooSmall) {
-  buffer.alloc(43);
+  buffer.alloc(65);
   ASSERT_EQ(0, buffer.size());
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNonNull) {
-  void *p = buffer.alloc(42);
+  void *p = buffer.alloc(64);
   ASSERT_NE(static_cast<void *>(0), p);
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenFull) {
-  buffer.alloc(42);
+  buffer.alloc(64);
   void *p = buffer.alloc(1);
   ASSERT_EQ(NULL, p);
 }
 
 TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenTooSmall) {
-  void *p = buffer.alloc(43);
+  void *p = buffer.alloc(65);
   ASSERT_EQ(NULL, p);
 }
+
+TEST_F(StaticJsonBuffer_Basic_Tests, Alignment) {
+  size_t mask = sizeof(void *) - 1;
+
+  for (size_t size = 1; size <= sizeof(void *); size++) {
+    size_t addr = reinterpret_cast<size_t>(buffer.alloc(1));
+    ASSERT_EQ(0, addr & mask);
+  }
+}

test/StaticJsonBuffer_ParseArray_Tests.cpp

@@ -69,4 +69,12 @@ TEST_F(StaticJsonBuffer_ParseArray_Tests,
   with(bufferOfRightSize);
   whenInputIs("[{}]");
   parseMustSucceed();
-}
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, CharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>().parseArray((char*)0).success());
+}
+
+TEST_F(StaticJsonBuffer_ParseArray_Tests, ConstCharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>().parseArray((const char*)0).success());
+}

test/StaticJsonBuffer_ParseObject_Tests.cpp

@@ -70,4 +70,12 @@ TEST_F(StaticJsonBuffer_ParseObject_Tests,
   with(bufferOfRightSize);
   whenInputIs("{\"a\":[]}");
   parseMustSucceed();
-}
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, CharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>().parseObject((char*)0).success());
+}
+
+TEST_F(StaticJsonBuffer_ParseObject_Tests, ConstCharPtrNull) {
+  ASSERT_FALSE(StaticJsonBuffer<100>().parseObject((const char*)0).success());
+}