Added JsonPrintable::measureLength() (issue #75)

Conflicts:
	JsonGenerator.cpp
	JsonGenerator.h
	JsonGenerator/EscapedString.cpp
	JsonGenerator/EscapedString.h
	JsonGenerator/IndentedPrint.cpp
	JsonGenerator/IndentedPrint.h
	JsonGenerator/JsonArray.h
	JsonGenerator/JsonArrayBase.cpp
	JsonGenerator/JsonArrayBase.h
	JsonGenerator/JsonObject.h
	JsonGenerator/JsonObjectBase.cpp
	JsonGenerator/JsonObjectBase.h
	JsonGenerator/JsonPrettyPrint.cpp
	JsonGenerator/JsonPrettyPrint.h
	JsonGenerator/JsonPrintable.cpp
	JsonGenerator/JsonPrintable.h
	JsonGenerator/JsonValue.cpp
	JsonGenerator/JsonValue.h
	JsonGenerator/Print.cpp
	JsonGenerator/Print.h
	JsonGenerator/Printable.h
	JsonGenerator/StringBuilder.cpp
	JsonGenerator/StringBuilder.h
	JsonGeneratorTests/EscapedStringTests.cpp
	JsonGeneratorTests/Issue10.cpp
	JsonGeneratorTests/JsonArrayTests.cpp
	JsonGeneratorTests/JsonObject_Indexer_Tests.cpp
	JsonGeneratorTests/JsonObject_PrintTo_Tests.cpp
	JsonGeneratorTests/JsonValue_Cast_Tests.cpp
	JsonGeneratorTests/JsonValue_PrintTo_Tests.cpp
	JsonGeneratorTests/PrettyPrint_Array_Tests.cpp
	JsonGeneratorTests/PrettyPrint_Object_Tests.cpp
	JsonGeneratorTests/PrettyPrint_String_Tests.cpp
	JsonGeneratorTests/StringBuilderTests.cpp
	JsonParser.cpp
	JsonParser.h
	JsonParser/JsonArray.cpp
	JsonParser/JsonArray.h
	JsonParser/JsonArrayIterator.h
	JsonParser/JsonObject.cpp
	JsonParser/JsonObject.h
	JsonParser/JsonObjectIterator.h
	JsonParser/JsonPair.h
	JsonParser/JsonParser.h
	JsonParser/JsonParserBase.cpp
	JsonParser/JsonParserBase.h
	JsonParser/JsonToken.cpp
	JsonParser/JsonToken.h
	JsonParser/JsonValue.cpp
	JsonParser/JsonValue.h
	JsonParser/README.md
	JsonParserTests/GbathreeBug.cpp
	JsonParserTests/JsonArrayIteratorTests.cpp
	JsonParserTests/JsonArrayTests.cpp
	JsonParserTests/JsonObjectIteratorTests.cpp
	JsonParserTests/JsonObjectTests.cpp
	JsonParserTests/JsonStringTests.cpp
	JsonParserTests/TestHashGenerator.cpp
	README.md
	library.json

.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+/.idea
+/build
+/bin
+/lib

.travis.yml

@@ -0,0 +1,12 @@
+language: c++
+compiler:
+  - gcc
+  - clang
+before_install:
+  - sudo pip install cpp-coveralls
+before_script:
+  - cmake -DCOVERAGE=true .
+script:
+  - make && make test
+after_success:
+  - coveralls --exclude test --exclude third-party --gcov-options '\-lp'

ArduinoJson.cpp

@@ -0,0 +1,24 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#ifdef ARDUINO
+
+// This file is here to help the Arduino IDE find the other files.
+
+#include "src/Arduino/Print.cpp"
+#include "src/DynamicJsonBuffer.cpp"
+#include "src/Internals/IndentedPrint.cpp"
+#include "src/Internals/JsonParser.cpp"
+#include "src/Internals/List.cpp"
+#include "src/Internals/Prettyfier.cpp"
+#include "src/Internals/QuotedString.cpp"
+#include "src/Internals/StringBuilder.cpp"
+#include "src/JsonArray.cpp"
+#include "src/JsonBuffer.cpp"
+#include "src/JsonObject.cpp"
+#include "src/JsonVariant.cpp"
+
+#endif

ArduinoJson.h

@@ -0,0 +1,13 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#ifdef ARDUINO
+
+// This file is here to help the Arduino IDE find the other files.
+
+#include "include/ArduinoJson.h"
+
+#endif

CHANGELOG.md

@@ -1,10 +1,128 @@
-ArduinoJsonParser change log
-============================
+Arduino JSON: change log
+========================
+
+v4.4
+----
+
+* Added `JsonArray::measureLength()` and `JsonObject::measureLength()` (issue #75)
+
+v4.3
+----
+
+* Added `JsonArray::removeAt()` to remove an element of an array (issue #58)
+* Fixed stack-overflow in `DynamicJsonBuffer` when parsing huge JSON files (issue #65)
+* Fixed wrong return value of `parseArray()` and `parseObject()` when allocation fails (issue #68)
+
+v4.2
+----
+
+* Switched back to old library layout (issues #39, #43 and #45)
+* Removed global new operator overload (issue #40, #45 and #46)
+* Added an example with EthernetServer
+
+v4.1
+----
+
+* Added DynamicJsonBuffer (issue #19)
+
+v4.0
+----
+
+* Unified parser and generator API (issue #23)
+* Updated library layout, now requires Arduino 1.0.6 or newer
+
+**BREAKING CHANGE**: API changed significantly, see [Migrating code to the new API](https://github.com/bblanchon/ArduinoJson/wiki/Migrating-code-to-the-new-API).
+
+
+v3.4
+----
+
+* Fixed escaped char parsing (issue #16)
+
+
+v3.3
+----
+
+* Added indented output for the JSON generator (issue #11), see example bellow.
+* Added `IndentedPrint`, a decorator for `Print` to allow indented output
+
+Example:
+
+    JsonOject<2> json;
+    json["key"] = "value";
+    json.prettyPrintTo(Serial);
+
+v3.2
+----
+
+* Fixed a bug when adding nested object in `JsonArray` (bug introduced in v3.1).
+
+v3.1
+----
+
+* Calling `Generator::JsonObject::add()` twice with the same `key` now replaces the `value`
+* Added `Generator::JsonObject::operator[]`, see bellow the new API
+* Added `Generator::JsonObject::remove()` (issue #9)
+
+Old generator API:
+
+	JsonObject<3> root; 
+    root.add("sensor", "gps");
+    root.add("time", 1351824120);
+    root.add("data", array);
+
+New generator API:
+
+	JsonObject<3> root; 
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
+    root["data"] = array;
+
+v3.0
+----
+
+* New parser API, see bellow
+* Renamed `JsonHashTable` into `JsonObject`
+* Added iterators for `JsonArray` and `JsonObject` (issue #4)
+
+Old parser API:
+
+    JsonHashTable root = parser.parseHashTable(json);
+
+	char*  sensor    = root.getString("sensor");
+	long   time      = root.getLong("time");
+	double latitude  = root.getArray("data").getDouble(0);
+    double longitude = root.getArray("data").getDouble(1);
+
+New parser API:
+
+	JsonObject root = parser.parse(json);
+
+	char*  sensor    = root["sensor"];
+    long   time      = root["time"];
+    double latitude  = root["data"][0];
+    double longitude = root["data"][1];
+
+v2.1
+----
+
+* Fixed case `#include "jsmn.cpp"` which caused an error in Linux (issue #6)
+* Fixed a buffer overrun in JSON Parser (issue #5)
+
+v2.0
+----
+
+* Added JSON encoding (issue #2)
+* Renamed the library `ArduinoJsonParser` becomes `ArduinoJson`
+
+**Breaking change**: you need to add the following line at the top of your program.
+
+	using namespace ArduinoJson::Parser;
 
 v1.2
 ----
 
-* Example: changed `char[] json` into `char json[]`. Damn it C# !
+* Fixed error in JSON parser example (issue #1)
 
 v1.1
 ----

CMakeLists.txt

@@ -0,0 +1,20 @@
+cmake_minimum_required(VERSION 2.8.4)
+project(ArduinoJson)
+
+enable_testing()
+
+set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/lib)
+set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin)
+
+if(MSVC)
+	add_definitions(-D_CRT_SECURE_NO_WARNINGS -W4)
+endif()
+
+if(${COVERAGE})
+	set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -coverage")
+	set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} -coverage")
+endif()
+
+add_subdirectory(src)
+add_subdirectory(test)

JsonArray.cpp

@@ -1,67 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-JsonArray::JsonArray(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_ARRAY)
-		makeInvalid();
-}
-
-
-/*
-* Returns the token for the value at the specified index
-*/
-jsmntok_t* JsonArray::getToken(int index)
-{
-	// sanity check
-	if (json == 0 || tokens == 0 || index < 0 || index >= tokens[0].size)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// skip all tokens before the specified index
-	for (int i = 0; i < index; i++)
-	{
-		// move forward: current + nested tokens
-		currentToken += 1 + getNestedTokenCount(currentToken);
-	}
-
-	return currentToken;
-}
-
-JsonArray JsonArray::getArray(int index)
-{
-	return JsonArray(json, getToken(index));
-}
-
-bool JsonArray::getBool(int index)
-{
-	return getBoolFromToken(getToken(index));
-}
-
-double JsonArray::getDouble(int index)
-{
-	return getDoubleFromToken(getToken(index));
-}
-
-JsonHashTable JsonArray::getHashTable(int index)
-{
-	return JsonHashTable(json, getToken(index));
-}
-
-long JsonArray::getLong(int index)
-{
-	return getLongFromToken(getToken(index));
-}
-
-char* JsonArray::getString(int index)
-{
-	return getStringFromToken(getToken(index));
-}

JsonArray.h

@@ -1,42 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014 - MIT License
- */
-
-#ifndef __JSONARRAY_H
-#define __JSONARRAY_H
-
-#include "JsonObjectBase.h"
-
-class JsonHashTable;
-
-class JsonArray : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	friend class JsonHashTable;
-
-public:
-
-	JsonArray()	{}
-
-	int getLength()
-	{
-		return tokens != 0 ? tokens[0].size : 0;
-	}
-
-	JsonArray getArray(int index);
-	bool getBool(int index);
-	double getDouble(int index);
-	JsonHashTable getHashTable(int index);
-	long getLong(int index);
-	char* getString(int index);
-
-private:
-
-	JsonArray(char* json, jsmntok_t* tokens);
-	jsmntok_t* getToken(int index);
-};
-
-#endif

JsonHashTable.cpp

@@ -1,84 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#include "JsonArray.h"
-#include "JsonHashTable.h"
-
-#include <string.h> // for strcmp()
-
-JsonHashTable::JsonHashTable(char* json, jsmntok_t* tokens)
-: JsonObjectBase(json, tokens)
-{
-	if (tokens == 0 || tokens[0].type != JSMN_OBJECT)
-		makeInvalid();
-}
-
-/*
-* Returns the token for the value associated with the specified key
-*/
-jsmntok_t* JsonHashTable::getToken(const char* desiredKey)
-{	
-	// sanity check
-	if (json == 0 || tokens == 0 || desiredKey == 0)
-		return 0;
-
-	// skip first token, it's the whole object
-	jsmntok_t* currentToken = tokens + 1;
-
-	// scan each keys
-	for (int i = 0; i < tokens[0].size / 2 ; i++)
-	{
-		// get key token string
-		char* key = getStringFromToken(currentToken);
-
-		// compare with desired name
-		if (strcmp(desiredKey, key) == 0)
-		{
-			// return the value token that follows the key token
-			return currentToken + 1;
-		}
-
-		// move forward: key + value + nested tokens
-		currentToken += 2 + getNestedTokenCount(currentToken + 1);
-	}
-
-	// nothing found, return NULL
-	return 0; 
-}
-
-bool JsonHashTable::containsKey(const char* key)
-{
-	return getToken(key) != 0;
-}
-
-JsonArray JsonHashTable::getArray(const char* key)
-{
-	return JsonArray(json, getToken(key));
-}
-
-bool JsonHashTable::getBool(const char* key)
-{
-	return getBoolFromToken(getToken(key));
-}
-
-double JsonHashTable::getDouble(const char* key)
-{
-	return getDoubleFromToken(getToken(key));
-}
-
-JsonHashTable JsonHashTable::getHashTable(const char* key)
-{
-	return JsonHashTable(json, getToken(key));
-}
-
-long JsonHashTable::getLong(const char* key)
-{
-	return getLongFromToken(getToken(key));
-}
-
-char* JsonHashTable::getString(const char* key)
-{
-	return getStringFromToken(getToken(key));
-}

JsonHashTable.h

@@ -1,39 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#ifndef __JSONHASHTABLE_H
-#define __JSONHASHTABLE_H
-
-#include "JsonObjectBase.h"
-
-class JsonArray;
-
-class JsonHashTable : public JsonObjectBase
-{
-	template <int N>
-	friend class JsonParser;
-
-	friend class JsonArray;
-
-public:
-
-	JsonHashTable() {}
-
-	bool containsKey(const char* key);
-
-	JsonArray getArray(const char* key);
-	bool getBool(const char* key);
-	double getDouble(const char* key);
-	JsonHashTable getHashTable(const char* key);
-	long getLong(const char* key);
-	char* getString(const char* key);
-
-private:
-
-	JsonHashTable(char* json, jsmntok_t* tokens);
-	jsmntok_t* getToken(const char* key);
-};
-
-#endif

JsonObjectBase.cpp

@@ -1,67 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#include "JsonObjectBase.h"
-
-#include <stdlib.h> // for strtol, strtod
-
-int JsonObjectBase::getNestedTokenCount(jsmntok_t* token)
-{
-	int end = token->end;
-	int count = 0;	
-
-	token++;
-
-	while (token->start < end)
-	{
-		token++;
-		count++;
-	}
-
-	return count;
-}
-
-bool JsonObjectBase::getBoolFromToken(jsmntok_t* token)
-{
-	if (token->type != JSMN_PRIMITIVE) return 0;
-
-	// "true"
-	if (json[token->start] == 't') return true;
-
-	// "false"
-	if (json[token->start] == 'f') return false;
-
-	// "null"
-	if (json[token->start] == 'n') return false;
-	
-	// number
-	return strtol(json + token->start, 0, 0) != 0;
-}
-
-double JsonObjectBase::getDoubleFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-	return strtod(json + token->start, 0);
-}
-
-long JsonObjectBase::getLongFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE) return 0;
-
-	return strtol(json + token->start, 0, 0);
-}
-
-char* JsonObjectBase::getStringFromToken(jsmntok_t* token)
-{
-	if (token == 0 || token->type != JSMN_PRIMITIVE && token->type != JSMN_STRING)
-		return 0;
-
-	// add null terminator to the string
-	json[token->end] = 0;
-
-	return json + token->start;
-}

JsonObjectBase.h

@@ -1,52 +0,0 @@
-/*
- * malloc-free JSON parser for Arduino
- * Benoit Blanchon 2014
- * MIT License
- */
-
-#ifndef __JSONOBJECTBASE_H
-#define __JSONOBJECTBASE_H
-
-#include "utility/jsmn.h"
-
-class JsonObjectBase
-{
-public:
-
-	JsonObjectBase()
-	{
-		makeInvalid();
-	}
-
-	bool success() 
-	{ 
-		return json != 0 && tokens != 0;
-	}
-
-protected:
-	
-	JsonObjectBase(char* json, jsmntok_t* tokens)
-	{
-		this->json = json;
-		this->tokens = tokens;
-	}
-		
-	void makeInvalid()
-	{
-		json = 0;
-		tokens = 0;
-	}
-	
-	static int getNestedTokenCount(jsmntok_t* token);
-
-	bool getBoolFromToken(jsmntok_t* token);
-	double getDoubleFromToken(jsmntok_t* token);
-	long getLongFromToken(jsmntok_t* token);
-	char* getStringFromToken(jsmntok_t* token);
-
-	char* json;
-	jsmntok_t* tokens;
-};
-
-#endif
-

JsonParser.h

@@ -1,69 +0,0 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
-
-#ifndef __JSONPARSER_H
-#define __JSONPARSER_H
-
-#include "JsonHashTable.h"
-#include "JsonArray.h"
-
-/*
-* The JSON parser.
-*
-* You need to specifiy the number of token to be allocated for that parser.
-* Values from 16 to 32 are recommended.
-* The parser size will be MAX_TOKEN*8 bytes.
-* Don't forget that the memory size of standard Arduino board is only 2KB
-*
-* CAUTION: JsonArray and JsonHashTable contain pointers to tokens of the
-* JsonParser, so they need the JsonParser to be in memory to work.
-* As a result, you must not create JsonArray and JsonHashTable that have a 
-* longer life that the JsonParser.
-*/
-template <int MAX_TOKENS>
-class JsonParser
-{
-public:
-
-	/*
-	* Parse the JSON string and return a array.
-	*
-	* The content of the string may be altered to add '\0' at the
-	* end of string tokens
-	*/ 
-	JsonArray parseArray(char* json)
-	{
-		return JsonArray(json, parse(json));
-	}
-
-	/*
-	* Parse the JSON string and return a array.
-	*
-	* The content of the string may be altered to add '\0' at the
-	* end of string tokens
-	*/
-	JsonHashTable parseHashTable(char* json)
-	{
-		return JsonHashTable(json, parse(json));
-	}
-
-private:
-
-	jsmntok_t* parse(char* json)
-	{
-		jsmn_parser parser;
-		jsmn_init(&parser);
-
-		if (JSMN_SUCCESS != jsmn_parse(&parser, json, tokens, MAX_TOKENS))
-			return 0;
-
-		return tokens;
-	}
-
-	jsmntok_t tokens[MAX_TOKENS];
-};
-
-#endif
-

LICENSE.md

@@ -0,0 +1,10 @@
+The MIT License (MIT)
+---------------------
+
+Copyright © 2014 Benoit BLANCHON
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -1,416 +1,81 @@
-An efficient JSON parser for Arduino
-====================================
+Arduino JSON library
+====================
 
-This library is an thin C++ wrapper around the *jsmn* tokenizer: http://zserge.com/jsmn.html
+[![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)
 
-It's design to be very lightweight, works without any allocation on the heap (no malloc) and supports nested objects.
+*An elegant and efficient JSON library for embedded systems.*
 
-It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library on any other C++ project.
+It's design 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.
 
 Features
 --------
 
-* Based on the well-proven [jsmn](http://zserge.com/jsmn.html) tokenizer
-* Supports nested objects
-* Works with fixed memory allocation : no `malloc()`
-* Low footprint
+* JSON decoding
+* JSON encoding (with optional indentation)
+* Elegant API, very easy to use 
+* Fixed memory allocation (no malloc)
+* Small footprint
 * MIT License
 
+Quick start
+-----------
 
-Example
--------
+#### Decoding / Parsing
+   
+    char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    char json[] = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
+    StaticJsonBuffer<200> jsonBuffer;
 
-    JsonParser<32> parser;
+    JsonObject& root = jsonBuffer.parseObject(json);
 
-    JsonHashTable hashTable = parser.parseHashTable(json);
+    const char* sensor = root["sensor"];
+    long time          = root["time"];
+    double latitude    = root["data"][0];
+    double longitude   = root["data"][1];
 
-    if (!hashTable.success())
-    {
-        return;
-    }
+#### Encoding / Generating
+   
+    StaticJsonBuffer<200> jsonBuffer;
 
-    char* name = hashTable.getString("Name");
+    JsonObject& root = jsonBuffer.createObject();
+    root["sensor"] = "gps";
+    root["time"] = 1351824120;
 
-    JsonArray skills = hashTable.getArray("Skills");
+    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
 
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
+    root.printTo(Serial);
+    // This prints:
+    // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
 
 
-
-How to  use ?
+Documentation
 -------------
 
-### 1. Install the library
+The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki) 
 
-Download the library and extract it to:
-
-    <your Arduino Sketch folder>/libraries/ArduinoJsonParser
-
-### 2. Import in your sketch
-
-Just add the following line on the top of your `.ino` file:
-
-    #include <JsonParser.h>
-    
-### 3. Create a parser
-
-To extract data from the JSON string, you need to create a `JsonParser`, and specify the number of token you allocate for the parser itself:
-
-    JsonParser<32> parser;
-    
-> #### How to choose the number of tokens ?
-
-> A token is an element of the JSON object: either a key, a value, an hash-table or an array.
-> As an example the `char json[]` on the top of this page contains 12 tokens (don't forget to count 1 for the whole object and 1 more for the array itself).
-
-> The more tokens you allocate, the more complex the JSON can be, but also the more memory is occupied.
-> Each token takes 8 bytes, so `sizeof(JsonParser<32>)` is 256 bytes which is quite big in an Arduino with only 2KB of RAM.
-> Don't forget that you also have to store the JSON string in RAM and it's probably big.
-
-> 32 tokens may seem small, but it's very decent for an 8-bit processor, you wouldn't get better results with other JSON libraries.
-
-### 4. Extract data
-
-To use this library, you need to know beforehand what is the type of data contained in the JSON string, which is very likely.
-
-The root object has to be either a hash-table (like `{"key":"value"}`) or an array (like `[1,2]`). 
-
-The nested objects can be either arrays, booleans, hash-tables, numbers or strings.
-If you need other type, you can get the string value and parse it yourself.
-
-#### Hash-table
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    {
-        "Name":"Blanchon",
-        "Skills":[
-            "C",
-            "C++",
-            "C#"],
-        "Age":32,
-        "Online":true
-    }
-
-In this case the root object of the JSON string is a hash-table, so you need to extract a `JsonHashTable`:
-   
-    JsonHashTable root = parser.parseHashTable(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the member you need:
-    
-    char* name = hashTable.getString("Name");
-
-    JsonArray skills = hashTable.getArray("Skills");
-
-    int age = hashTable.getLong("Age");
-
-    bool online = hashTable.getBool("Online");
-    
-#### Array
-
-Consider we have a `char json[]` containing to the following JSON string:
-
-    [
-        [ 1.2, 3.4 ],
-        [ 5.6, 7.8 ]               
-    ]
-
-In this case the root object of the JSON string is an array, so you need to extract a `JsonArray`:
-   
-    JsonArray root = parser.parseArray(json);
-    
-To check if the parsing was successful, you must check:
-
-    if (!root.success())
-    {
-        // Parsing fail: could be an invalid JSON, or too many tokens
-    }
-    
-And then extract the content by its index in the array:
-    
-    JsonArray row0 = root.getArray(0);
-    double a = row0.getDouble(0);
-    
-or simply:
-
-    double a = root.getArray(0).getDouble(0);
-
-
-Common pitfalls
----------------
-
-### 1. Not enough tokens
-
-By design, the library has no way to tell you why `JsonParser::parseArray()` or `JsonParser::parseHashTable()` failed.
-
-There are basically two reasons why they may fail:
-
-1. the JSON string is invalid
-2. the JSON string contains more tokens that the parser can store
-
-So, if you are sure the JSON string is correct and you still can't parse it, you should slightly increase the number of token of the parser.
-
-### 2. Not enough memory
-
-You may go into unpredictable trouble if you allocate more memory than your processor really has.
-It's a very common issue in embedded development. 
-
-To diagnose this, look at every big objects in you code and sum their size to check that they fit in RAM.
-
-For example, don't do this:
-
-    char json[1024];        // 1 KB
-    JsonParser<64> parser;    // 512 B
-
-because it may be too big for a processor with only 2 KB: you need free memory to store other variables and the call stack.
-
-That is why an 8-bit processor is not able to parse long and complex JSON strings.
-
-### 3. JsonParser not in memory
-
-To reduce the memory consumption, `JsonArray` and `JsonHashTable` contains pointer to the token that are inside the `JsonParser`. This can only work if the `JsonParser` is still in memory.
-
-For example, don't do this:
-
-    JsonArray getArray(char* json)
-    {
-        JsonParser<16> parser;
-        return parser.parseArray(parser); 
-    }
-
-because the local variable `parser` will be *removed* from memory when the function `getArray()` returns, and the pointer inside `JsonArray` will point to an invalid location.
-
-### 4. JSON string is altered
-
-This will probably never be an issue, but you need to be aware of this feature.
-
-When you pass a `char[]` to `JsonParser::parseArray()` or `JsonParser::parseHashTable()`, the content of the string will be altered to add `\0` at the end of the tokens.
-
-This is because we want functions like `JsonArray::getString()` to return a null-terminating string without any memory allocation.
-   
-
-Memory usage
+Testimonials
 ------------
 
-Here are the size of the main classes of the library.
+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 have no such problem so far with your library. It is working perfectly with my web services.
 
-This table is for an 8-bit Arduino, types would be bigger on a 32-bit processor.
+From Arduino's Forum user `gbathree`:
+> Thanks so much - this is an awesome library!  If you want to see what we're doing with it - the project is located at www.photosynq.org.
 
-<table>
-    <tr>
-        <th>Type</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>Parser&lt;N&gt;</td>
-        <td>8 x N</td>
-    </tr>
-    <tr>
-        <td>JsonArray</td>
-        <td>4</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable</td>
-        <td>4</td>
-    </tr>
-</table> 
+From StackOverflow user `thegreendroid`:
+> It has a really elegant, simple API and it works like a charm on embedded and Windows/Linux platforms. We recently started using this on an embedded project and I can vouch for its quality.
 
+From GitHub user `zacsketches`:
 
-Code size
----------
+> Thanks for a great library!!!
+> 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!!
 
-Theses tables has been created by analyzing the map file generated by AVR-GCC after adding `-Wl,-Map,foo.map` to the command line.
+---
 
-As you'll see the code size if between 1680 and 3528 bytes, depending on the features you use.
-
-### Minimum setup
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strcmp(char*,char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>jsmn_init(jsmn_parser*)</td>
-        <td>20</td>
-    </tr>
-    <tr>
-        <td>jsmn_parse(jsmn_parser*, char const*, jsmntok_t*, unsigned int)</td>
-        <td>960</td>
-    </tr>
-    <tr>
-        <td>JsonParser::parse(char*)</td>
-        <td>106</td>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getNestedTokenCount(jsmntok_t*)</td>
-        <td>84</td>        
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getStringFromToken(jsmntok_t*)</td>
-        <td>68</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::JsonArray(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getToken(int)</td>
-        <td>112</td>        
-    </tr>
-    <tr>
-        <td>JsonArray::getString(int)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::JsonHashTable(char*, jsmntok_t*)</td>
-        <td>42</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getToken(char*)</td>
-        <td>180</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getString(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>1680</td>
-    </tr>
-</table>
-
-### Additional space to parse nested  objects
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonArray::getArray(int)</td>
-        <td>42</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getHashTable(int)</td>
-        <td>64</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getArray(char*)</td>
-        <td>64</td>
-    </tr>
-    <tr>
-        <td>JsonHashTable::getHashTable(char*)</td>
-        <td>42</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>212</td>
-    </tr>
-</table>
-
-### Additional space to parse `bool` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>JsonObjectBase::getBoolFromToken(jsmntok_t*)</td>
-        <td>82</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getBool(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getBool(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>130</td>
-    </tr>
-</table>
-
-### Additional space to parse `double` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtod(char*,int)</td>
-        <td>704</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getDoubleFromToken(jsmntok_t*)</td>
-        <td>44</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getDouble(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getDouble(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>796</td>
-    </tr>
-</table>
-
-### Additional space to parse `long` values
-
-<table>
-    <tr>
-        <th>Function</th>
-        <th>Size in bytes</th>
-    </tr>
-    <tr>
-        <td>strtol(char*,char**,int)</td>
-        <td>606</td>
-    </tr>    
-    <tr>
-        <td>JsonObjectBase::getLongFromToken(jsmntok_t*)</td>
-        <td>56</td>
-    </tr>    
-    <tr>
-        <td>JsonArray::getLong(int)</td>
-        <td>18</td>        
-    </tr>
-    <tr>
-        <td>JsonHashTable::getLong(char*)</td>
-        <td>18</td>
-    </tr>
-    <tr>
-        <td>TOTAL</td>
-        <td>710</td>
-    </tr>
-</table>
-
-
-Links
------
-
-* [The project for which I made me this library](http://blog.benoitblanchon.fr/rfid-payment-terminal/)
-* [Blog post on the motivation for this library](http://blog.benoitblanchon.fr/arduino-json-parser/)
+Found this library useful? [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

@@ -0,0 +1,30 @@
+/*
+ * Arduino JSON library - IndentedPrint example
+ * Benoit Blanchon 2014 - MIT License
+ */
+
+#include <ArduinoJson.h>
+
+using namespace ArduinoJson::Internals;
+
+void setup() {
+  Serial.begin(9600);
+
+  IndentedPrint serial(Serial);
+  serial.setTabSize(4);
+
+  serial.println("This is at indentation 0");
+  serial.indent();
+  serial.println("This is at indentation 1");
+  serial.println("This is also at indentation 1");
+  serial.indent();
+  serial.println("This is at indentation 2");
+
+  serial.unindent();
+  serial.unindent();
+  serial.println("This is back at indentation 0");
+}
+
+void loop() {
+  // not used in this example
+}

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -0,0 +1,42 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <ArduinoJson.h>
+
+void setup() {
+  Serial.begin(9600);
+
+  StaticJsonBuffer<200> jsonBuffer;
+
+  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
+
+  root.printTo(Serial);
+  // This prints:
+  // {"sensor":"gps","time":1351824120,"data":[48.756080,2.302038]}
+
+  Serial.println();
+
+  root.prettyPrintTo(Serial);
+  // This prints:
+  // {
+  //   "sensor": "gps",
+  //   "time": 1351824120,
+  //   "data": [
+  //     48.756080,
+  //     2.302038
+  //   ]
+  // }
+}
+
+void loop() {
+  // not used in this example
+}

examples/JsonParserExample/JsonParserExample.ino

@@ -1,94 +1,37 @@
-/*
-* malloc-free JSON parser for Arduino
-* Benoit Blanchon 2014 - MIT License
-*/
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
 
-#include <JsonParser.h>
+#include <ArduinoJson.h>
 
-void ParseAnObject()
-{
-    char json[] = "{\"Name\":\"Blanchon\",\"Skills\":[\"C\",\"C++\",\"C#\"],\"Age\":32,\"Online\":true}";
+void setup() {
+  Serial.begin(9600);
 
-    JsonParser<32> parser;
+  StaticJsonBuffer<200> jsonBuffer;
 
-    Serial.print("Parse ");
-    Serial.println(json);
+  char json[] =
+      "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
-    JsonHashTable hashTable = parser.parseHashTable(json);
+  JsonObject& root = jsonBuffer.parseObject(json);
 
-    if (!hashTable.success())
-    {
-        Serial.println("JsonParser.parseHashTable() failed");
-        return;
-    }
+  if (!root.success()) {
+    Serial.println("parseObject() failed");
+    return;
+  }
 
-    char* name = hashTable.getString("Name");
-    Serial.print("name=");
-    Serial.println(name);
+  const char* sensor = root["sensor"];
+  long time = root["time"];
+  double latitude = root["data"][0];
+  double longitude = root["data"][1];
 
-    JsonArray skills = hashTable.getArray("Skills");
-    Serial.println("skills:");
-    for (int i = 0; i < skills.getLength(); i++)
-    {
-        char* value = skills.getString(i);
-        Serial.print(i);
-        Serial.print(" ");
-        Serial.println(value);
-    }
-
-    int age = hashTable.getLong("Age");
-    Serial.print("age=");
-    Serial.println(age);
-
-    bool online = hashTable.getBool("Online");
-    Serial.print("online=");
-    Serial.println(online);
+  Serial.println(sensor);
+  Serial.println(time);
+  Serial.println(latitude, 6);
+  Serial.println(longitude, 6);
 }
 
-void ParseAnArray()
-{
-    char json[] = "[[1.2,3.4],[5.6,7.8]]";
-
-    JsonParser<32> parser;
-
-    Serial.print("Parse ");
-    Serial.println(json);
-
-    JsonArray array = parser.parseArray(json);
-
-    if (!array.success())
-    {
-        Serial.println("JsonParser.parseArray() failed");
-        return;
-    }
-
-    for (int i = 0; i < array.getLength(); i++)
-    {
-        Serial.println(i);
-
-        JsonArray innerArray = array.getArray(i);
-
-        for (int j = 0; j < innerArray.getLength(); j++)
-        {
-            double value = innerArray.getDouble(j);
-
-            Serial.print("  ");
-            Serial.print(j);
-            Serial.print("=");
-            Serial.println(value);
-        }
-    }
-}
-
-void setup()
-{
-    Serial.begin(9600);
-
-    ParseAnObject();
-    ParseAnArray();
-}
-
-void loop()
-{
-
-}
+void loop() {
+  // not used in this example
+}

examples/JsonServer/JsonServer.ino

@@ -0,0 +1,74 @@
+// Sample Arduino Json Web Server
+// Created by Benoit Blanchon.
+// Heavily inspired by "Web Server" from David A. Mellis and Tom Igoe
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress ip(192, 168, 0, 177);
+EthernetServer server(80);
+
+bool readRequest(EthernetClient& client) {
+  bool currentLineIsBlank = true;
+  while (client.connected()) {
+    if (client.available()) {
+      char c = client.read();
+      if (c == '\n' && currentLineIsBlank) {
+        return true;
+      } else if (c == '\n') {
+        currentLineIsBlank = true;
+      } else if (c != '\r') {
+        currentLineIsBlank = false;
+      }
+    }
+  }
+  return false;
+}
+
+JsonObject& prepareResponse(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
+
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    int value = analogRead(pin);
+    analogValues.add(value);
+  }
+
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    int value = digitalRead(pin);
+    digitalValues.add(value);
+  }
+
+  return root;
+}
+
+void writeResponse(EthernetClient& client, JsonObject& json) {
+  client.println("HTTP/1.1 200 OK");
+  client.println("Content-Type: application/json");
+  client.println("Connection: close");
+  client.println();
+
+  json.prettyPrintTo(client);
+}
+
+void setup() {
+  Ethernet.begin(mac, ip);
+  server.begin();
+}
+
+void loop() {
+  EthernetClient client = server.available();
+  if (client) {
+    bool success = readRequest(client);
+    if (success) {
+      StaticJsonBuffer<500> jsonBuffer;
+      JsonObject& json = prepareResponse(jsonBuffer);
+      writeResponse(client, json);
+    }
+    delay(1);
+    client.stop();
+  }
+}

examples/JsonUdpBeacon/JsonUdpBeacon.ino

@@ -0,0 +1,55 @@
+// Send a JSON object on UDP at regular interval
+//
+// You can easily test this program with netcat:
+// $ nc -ulp 8888
+//
+// by Benoit Blanchon, MIT License 2015
+
+#include <SPI.h>
+#include <Ethernet.h>
+#include <ArduinoJson.h>
+
+byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
+IPAddress localIp(192, 168, 0, 177);
+IPAddress remoteIp(192, 168, 0, 109);
+unsigned int remotePort = 8888;
+unsigned localPort = 8888;
+EthernetUDP udp;
+
+JsonObject& buildJson(JsonBuffer& jsonBuffer) {
+  JsonObject& root = jsonBuffer.createObject();
+
+  JsonArray& analogValues = root.createNestedArray("analog");
+  for (int pin = 0; pin < 6; pin++) {
+    int value = analogRead(pin);
+    analogValues.add(value);
+  }
+
+  JsonArray& digitalValues = root.createNestedArray("digital");
+  for (int pin = 0; pin < 14; pin++) {
+    int value = digitalRead(pin);
+    digitalValues.add(value);
+  }
+
+  return root;
+}
+
+void sendJson(JsonObject& json) {
+  udp.beginPacket(remoteIp, remotePort);
+  json.printTo(udp);
+  udp.println();
+  udp.endPacket();
+}
+
+void setup() {
+  Ethernet.begin(mac, localIp);
+  udp.begin(localPort);
+}
+
+void loop() {
+  delay(1000);
+
+  StaticJsonBuffer<300> jsonBuffer;
+  JsonObject& json = buildJson(jsonBuffer);
+  sendJson(json);
+}

include/ArduinoJson.h

@@ -0,0 +1,12 @@
+// Copyright Benoit Blanchon 2014
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/DynamicJsonBuffer.hpp"
+#include "../include/ArduinoJson/JsonArray.hpp"
+#include "../include/ArduinoJson/JsonObject.hpp"
+#include "../include/ArduinoJson/StaticJsonBuffer.hpp"
+
+using namespace ArduinoJson;

include/ArduinoJson/Arduino/Print.hpp

@@ -0,0 +1,31 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#ifndef ARDUINO
+
+#include <stddef.h>
+#include <stdint.h>
+
+// This class reproduces Arduino's Print
+class Print {
+ public:
+  virtual ~Print() {}
+
+  virtual size_t write(uint8_t) = 0;
+
+  size_t print(const char[]);
+  size_t print(double, int = 2);
+  size_t print(long);
+  size_t println();
+};
+
+#else
+
+#include <Print.h>
+
+#endif

include/ArduinoJson/DynamicJsonBuffer.hpp

@@ -0,0 +1,46 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonBuffer.hpp"
+
+#include <stdlib.h>
+
+namespace ArduinoJson {
+
+// Forward declaration
+namespace Internals {
+struct DynamicJsonBufferBlock;
+}
+
+// Implements a JsonBuffer with dynamic memory allocation.
+// You are strongly encouraged to consider using StaticJsonBuffer which is much
+// more suitable for embedded systems.
+class DynamicJsonBuffer : public JsonBuffer {
+ public:
+  DynamicJsonBuffer();
+  ~DynamicJsonBuffer();
+
+  size_t size() const;
+
+ protected:
+  virtual void* alloc(size_t bytes);
+
+ private:
+  typedef Internals::DynamicJsonBufferBlock Block;
+
+  static const size_t FIRST_BLOCK_CAPACITY = 32;
+
+  static Block* createBlock(size_t capacity);
+
+  inline bool canAllocInHead(size_t bytes) const;
+  inline void* allocInHead(size_t bytes);
+  inline void addNewBlock();
+
+  Block* _head;
+};
+}

include/ArduinoJson/Internals/DummyPrint.hpp

@@ -0,0 +1,20 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A dummy Print implementation used in JsonPrintable::measureLength()
+class DummyPrint : public Print {
+ public:
+  virtual size_t write(uint8_t) { return 1; }
+};
+}
+}

include/ArduinoJson/Internals/IndentedPrint.hpp

@@ -0,0 +1,54 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Decorator on top of Print to allow indented output.
+// This class is used by JsonPrintable::prettyPrintTo() but can also be used
+// for your own purpose, like logging.
+class IndentedPrint : public Print {
+ public:
+  explicit IndentedPrint(Print &p) : sink(&p) {
+    level = 0;
+    tabSize = 2;
+    isNewLine = true;
+  }
+
+  virtual size_t write(uint8_t);
+
+  // Adds one level of indentation
+  void indent() {
+    if (level < MAX_LEVEL) level++;
+  }
+
+  // Removes one level of indentation
+  void unindent() {
+    if (level > 0) level--;
+  }
+
+  // Set the number of space printed for each level of indentation
+  void setTabSize(uint8_t n) {
+    if (n < MAX_TAB_SIZE) tabSize = n & MAX_TAB_SIZE;
+  }
+
+ private:
+  Print *sink;
+  uint8_t level : 4;
+  uint8_t tabSize : 3;
+  bool isNewLine : 1;
+
+  size_t writeTabs();
+
+  static const int MAX_LEVEL = 15;    // because it's only 4 bits
+  static const int MAX_TAB_SIZE = 7;  // because it's only 3 bits
+};
+}
+}

include/ArduinoJson/Internals/JsonBufferAllocated.hpp

@@ -0,0 +1,23 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+class JsonBufferAllocated {
+ public:
+  void *operator new(size_t n, JsonBuffer *jsonBuffer) throw() {
+    return jsonBuffer->alloc(n);
+  }
+
+  void operator delete(void *, JsonBuffer *) throw() {}
+};
+}
+}

include/ArduinoJson/Internals/JsonParser.hpp

@@ -0,0 +1,42 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "../JsonVariant.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Parse JSON string to create JsonArrays and JsonObjects
+// This internal class is not indended to be used directly.
+// Instead, use JsonBuffer.parseArray() or .parseObject()
+class JsonParser {
+ public:
+  JsonParser(JsonBuffer *buffer, char *json, uint8_t nestingLimit)
+      : _buffer(buffer), _ptr(json), _nestingLimit(nestingLimit) {}
+
+  JsonArray &parseArray();
+  JsonObject &parseObject();
+
+ private:
+  bool skip(char charToSkip);
+  bool skip(const char *wordToSkip);
+  void skipSpaces();
+
+  void parseAnythingTo(JsonVariant &destination);
+  inline void parseBooleanTo(JsonVariant &destination);
+  inline void parseNullTo(JsonVariant &destination);
+  inline void parseNumberTo(JsonVariant &destination);
+  inline const char *parseString();
+
+  JsonBuffer *_buffer;
+  char *_ptr;
+  uint8_t _nestingLimit;
+};
+}
+}

include/ArduinoJson/Internals/JsonPrintable.hpp

@@ -0,0 +1,65 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "DummyPrint.hpp"
+#include "IndentedPrint.hpp"
+#include "JsonWriter.hpp"
+#include "Prettyfier.hpp"
+#include "StringBuilder.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Implements all the overloads of printTo() and prettyPrintTo()
+// Caution: this class use a template parameter to avoid virtual methods.
+// This is a bit curious but allows to reduce the size of JsonVariant, JsonArray
+// and JsonObject.
+template <typename T>
+class JsonPrintable {
+ public:
+  size_t printTo(Print &print) const {
+    JsonWriter writer(print);
+    downcast().writeTo(writer);
+    return writer.bytesWritten();
+  }
+
+  size_t printTo(char *buffer, size_t bufferSize) const {
+    StringBuilder sb(buffer, bufferSize);
+    return printTo(sb);
+  }
+
+  size_t prettyPrintTo(IndentedPrint &print) const {
+    Prettyfier p(print);
+    return printTo(p);
+  }
+
+  size_t prettyPrintTo(char *buffer, size_t bufferSize) const {
+    StringBuilder sb(buffer, bufferSize);
+    return prettyPrintTo(sb);
+  }
+
+  size_t prettyPrintTo(Print &print) const {
+    IndentedPrint indentedPrint = IndentedPrint(print);
+    return prettyPrintTo(indentedPrint);
+  }
+
+  size_t measureLength() const {
+    DummyPrint dp;
+    return printTo(dp);
+  }
+
+  size_t measurePrettyLength() const {
+    DummyPrint dp;
+    return prettyPrintTo(dp);
+  }
+
+ private:
+  const T &downcast() const { return *static_cast<const T *>(this); }
+};
+}
+}

include/ArduinoJson/Internals/JsonVariantContent.hpp

@@ -0,0 +1,28 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+
+// Forward declarations
+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 {
+  bool asBoolean;
+  double asDouble;       // asDouble is also used for float
+  long asLong;           // asLong is also used for char, short and int
+  const char* asString;  // asString can be null
+  JsonArray* asArray;    // asArray cannot be null
+  JsonObject* asObject;  // asObject cannot be null
+};
+}
+}

include/ArduinoJson/Internals/JsonVariantType.hpp

@@ -0,0 +1,33 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Enumerated type to know the current type of a JsonVariant.
+// The value determines which member of JsonVariantContent is used.
+enum JsonVariantType {
+  JSON_INVALID,    // a special state for JsonVariant::invalid()
+  JSON_UNDEFINED,  // the JsonVariant has not been initialized
+  JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject
+  JSON_BOOLEAN,    // the JsonVariant stores a bool
+  JSON_STRING,     // the JsonVariant stores a const char*
+  JSON_LONG,       // the JsonVariant stores a long
+
+  // The following values are reserved for double 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
+  // ...
+};
+}
+}

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -0,0 +1,64 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+#include "QuotedString.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Writes the JSON tokens to a Print implementation
+// This class is used by:
+// - JsonArray::writeTo()
+// - JsonObject::writeTo()
+// - JsonVariant::writeTo()
+// Its derived by PrettyJsonWriter that overrides some members to add
+// indentation.
+class JsonWriter {
+ public:
+  explicit JsonWriter(Print &sink) : _sink(sink), _length(0) {}
+
+  // Returns the number of bytes sent to the Print implementation.
+  // This is very handy for implementations of printTo() that must return the
+  // number of bytes written.
+  size_t bytesWritten() { return _length; }
+
+  void beginArray() { write('['); }
+  void endArray() { write(']'); }
+
+  void beginObject() { write('{'); }
+  void endObject() { write('}'); }
+
+  void writeColon() { write(':'); }
+  void writeComma() { write(','); }
+
+  void writeString(const char *value) {
+    _length += QuotedString::printTo(value, _sink);
+  }
+
+  void writeLong(long value) { _length += _sink.print(value); }
+
+  void writeBoolean(bool value) {
+    _length += _sink.print(value ? "true" : "false");
+  }
+  void writeDouble(double value, uint8_t decimals) {
+    _length += _sink.print(value, decimals);
+  }
+
+ protected:
+  void write(char c) { _length += _sink.write(c); }
+  void write(const char *s) { _length += _sink.print(s); }
+
+  Print &_sink;
+  size_t _length;
+
+ private:
+  JsonWriter &operator=(const JsonWriter &);  // cannot be assigned
+};
+}
+}

include/ArduinoJson/Internals/List.hpp

@@ -0,0 +1,72 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../JsonBuffer.hpp"
+#include "ListConstIterator.hpp"
+#include "ListIterator.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A singly linked list of T.
+// The linked list is composed of ListNode<T>.
+// It is derived by JsonArray and JsonObject
+template <typename T>
+class List {
+ public:
+  typedef T value_type;
+  typedef ListNode<T> node_type;
+  typedef ListIterator<T> iterator;
+  typedef ListConstIterator<T> const_iterator;
+
+  // Creates an empty List<T> attached to a JsonBuffer.
+  // The JsonBuffer allows to allocate new nodes.
+  // When buffer is NULL, the List is not able to grow and success() returns
+  // false. This is used to identify bad memory allocations and parsing
+  // failures.
+  explicit List(JsonBuffer *buffer) : _buffer(buffer), _firstNode(NULL) {}
+
+  // Returns true if the object is valid
+  // Would return false in the following situation:
+  // - the memory allocation failed (StaticJsonBuffer was too small)
+  // - the JSON parsing failed
+  bool success() const { return _buffer != NULL; }
+
+  // Returns the numbers of elements in the list.
+  // For a JsonObject, it would return the number of key-value pairs
+  int size() const;
+
+  iterator begin() { return iterator(_firstNode); }
+  iterator end() { return iterator(NULL); }
+
+  const_iterator begin() const { return const_iterator(_firstNode); }
+  const_iterator end() const { return const_iterator(NULL); }
+
+ protected:
+  node_type *createNode() {
+    if (!_buffer) return NULL;
+    return new (_buffer) node_type();
+  }
+
+  void addNode(node_type *nodeToAdd) {
+    if (_firstNode) {
+      node_type *lastNode = _firstNode;
+      while (lastNode->next) lastNode = lastNode->next;
+      lastNode->next = nodeToAdd;
+    } else {
+      _firstNode = nodeToAdd;
+    }
+  }
+
+  void removeNode(node_type *nodeToRemove);
+
+  JsonBuffer *_buffer;
+  node_type *_firstNode;
+};
+}
+}

include/ArduinoJson/Internals/ListConstIterator.hpp

@@ -0,0 +1,40 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "ListNode.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A read-only forward itertor for List<T>
+template <typename T>
+class ListConstIterator {
+ public:
+  explicit ListConstIterator(const ListNode<T> *node = NULL) : _node(node) {}
+
+  const T &operator*() const { return _node->content; }
+  const T *operator->() { return &_node->content; }
+
+  bool operator==(const ListConstIterator<T> &other) const {
+    return _node == other._node;
+  }
+
+  bool operator!=(const ListConstIterator<T> &other) const {
+    return _node != other._node;
+  }
+
+  ListConstIterator<T> &operator++() {
+    if (_node) _node = _node->next;
+    return *this;
+  }
+
+ private:
+  const ListNode<T> *_node;
+};
+}
+}

include/ArduinoJson/Internals/ListIterator.hpp

@@ -0,0 +1,43 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "ListNode.hpp"
+#include "ListConstIterator.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A read-write forward iterator for List<T>
+template <typename T>
+class ListIterator {
+ public:
+  explicit ListIterator(ListNode<T> *node = NULL) : _node(node) {}
+
+  T &operator*() const { return _node->content; }
+  T *operator->() { return &_node->content; }
+
+  bool operator==(const ListIterator<T> &other) const {
+    return _node == other._node;
+  }
+
+  bool operator!=(const ListIterator<T> &other) const {
+    return _node != other._node;
+  }
+
+  ListIterator<T> &operator++() {
+    if (_node) _node = _node->next;
+    return *this;
+  }
+
+  operator ListConstIterator<T>() const { return ListConstIterator<T>(_node); }
+
+ private:
+  ListNode<T> *_node;
+};
+}
+}

include/ArduinoJson/Internals/ListNode.hpp

@@ -0,0 +1,26 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>  // for NULL
+
+#include "JsonBufferAllocated.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A node for a singly-linked list.
+// Used by List<T> and its iterators.
+template <typename T>
+struct ListNode : public Internals::JsonBufferAllocated {
+  ListNode() : next(NULL) {}
+
+  ListNode<T> *next;
+  T content;
+};
+}
+}

include/ArduinoJson/Internals/Prettyfier.hpp

@@ -0,0 +1,46 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "IndentedPrint.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// Converts a compact JSON string into an indented one.
+class Prettyfier : public Print {
+ public:
+  explicit Prettyfier(IndentedPrint& p) : _sink(p) {
+    _previousChar = 0;
+    _inString = false;
+  }
+
+  virtual size_t write(uint8_t);
+
+ private:
+  Prettyfier& operator=(const Prettyfier&);  // cannot be assigned
+
+  bool inEmptyBlock() { return _previousChar == '{' || _previousChar == '['; }
+
+  size_t handleStringChar(uint8_t);
+  size_t handleMarkupChar(uint8_t);
+
+  size_t handleBlockClose(uint8_t);
+  size_t handleBlockOpen(uint8_t);
+  size_t handleColumn();
+  size_t handleComma();
+  size_t handleQuoteOpen();
+  size_t handleNormalChar(uint8_t);
+  size_t indentIfNeeded();
+  size_t unindentIfNeeded();
+
+  uint8_t _previousChar;
+  IndentedPrint& _sink;
+  bool _inString;
+};
+}
+}

include/ArduinoJson/Internals/QuotedString.hpp

@@ -0,0 +1,29 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// An helper class to print and extract doubly-quoted strings
+class QuotedString {
+ public:
+  // Writes a doubly-quote string to a Print implementation.
+  // It adds the double quotes (") at the beginning and the end of the string.
+  // It escapes the special characters as required by the JSON specifications.
+  static size_t printTo(const char *, Print &);
+
+  // Reads a doubly-quoted string from a buffer.
+  // It removes the double quotes (").
+  // It unescapes the special character as required by the JSON specification,
+  // with the exception of the Unicode characters (\u0000).
+  static char *extractFrom(char *input, char **end);
+};
+}
+}

include/ArduinoJson/Internals/ReferenceType.hpp

@@ -0,0 +1,34 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A type that is meant to be used by reference only (JsonArray and JsonObject)
+class ReferenceType {
+ public:
+  bool operator==(const ReferenceType& other) const {
+    // two JsonArray are equal if they are the same instance
+    // (we don't compare the content)
+    return this == &other;
+  }
+
+  bool operator!=(const ReferenceType& other) const { return this != &other; }
+
+ protected:
+  ReferenceType() {}
+
+ private:
+  // copy constructor is private
+  ReferenceType(const ReferenceType&);
+
+  // copy operator is private
+  ReferenceType& operator=(const ReferenceType&);
+};
+}
+}

include/ArduinoJson/Internals/StringBuilder.hpp

@@ -0,0 +1,30 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "../Arduino/Print.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+
+// A Print implementation that allows to write in a char[]
+class StringBuilder : public Print {
+ public:
+  StringBuilder(char *buf, int size)
+      : buffer(buf), capacity(size - 1), length(0) {
+    buffer[0] = '\0';
+  }
+
+  virtual size_t write(uint8_t c);
+
+ private:
+  char *buffer;
+  int capacity;
+  int length;
+};
+}
+}

include/ArduinoJson/JsonArray.hpp

@@ -0,0 +1,95 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "Internals/JsonBufferAllocated.hpp"
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/List.hpp"
+#include "Internals/ReferenceType.hpp"
+#include "JsonVariant.hpp"
+
+// Returns the size (in bytes) of an array with n elements.
+// Can be very handy to determine the size of a StaticJsonBuffer.
+#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonArray) + (NUMBER_OF_ELEMENTS) * sizeof(JsonArray::node_type))
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonObject;
+class JsonBuffer;
+
+// An array of JsonVariant.
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createArray() or JsonBuffer::parseArray().
+// A JsonArray can be serialized to a JSON string via JsonArray::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseArray().
+class JsonArray : public Internals::JsonPrintable<JsonArray>,
+                  public Internals::ReferenceType,
+                  public Internals::List<JsonVariant>,
+                  public Internals::JsonBufferAllocated {
+  // JsonBuffer is a friend because it needs to call the private constructor.
+  friend class JsonBuffer;
+
+ public:
+  // Returns the JsonVariant at the specified index (synonym for operator[])
+  JsonVariant &at(int index) const;
+
+  // Returns the JsonVariant at the specified index (synonym for at())
+  JsonVariant &operator[](int index) const { return at(index); }
+
+  // Adds an uninitialized JsonVariant at the end of the array.
+  // Return a reference or JsonVariant::invalid() if allocation fails.
+  JsonVariant &add();
+
+  // Adds the specified value at the end of the array.
+  template <typename T>
+  void add(T value) {
+    add().set(value);
+  }
+
+  // Adds the specified double value at the end of the array.
+  // The value will be printed with the specified number of decimal digits.
+  void add(double value, uint8_t decimals) { add().set(value, decimals); }
+
+  // Adds a reference to the specified JsonArray at the end of the array.
+  void add(JsonArray &array) { add().set(array); }
+
+  // Adds a reference to the specified JsonObject at the end of the array.
+  void add(JsonObject &obejct) { add().set(obejct); }
+
+  // Creates a JsonArray and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createArray() and JsonArray::add()
+  JsonArray &createNestedArray();
+
+  // Creates a JsonObject and adds a reference at the end of the array.
+  // It's a shortcut for JsonBuffer::createObject() and JsonArray::add()
+  JsonObject &createNestedObject();
+
+  // Removes element at specified index.
+  void removeAt(int index);
+
+  // Returns a reference an invalid JsonArray.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonArray &invalid() { return _invalid; }
+
+  // Serialize the array to the specified JsonWriter.
+  void writeTo(Internals::JsonWriter &writer) const;
+
+ private:
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  explicit JsonArray(JsonBuffer *buffer)
+      : Internals::List<JsonVariant>(buffer) {}
+
+  node_type *getNodeAt(int index) const;
+
+  // The instance returned by JsonArray::invalid()
+  static JsonArray _invalid;
+};
+}

include/ArduinoJson/JsonBuffer.hpp

@@ -0,0 +1,87 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>  // for size_t
+#include <stdint.h>  // for uint8_t
+
+#if defined(__clang__)
+#pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+#elif defined(__GNUC__)
+#pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+#endif
+
+namespace ArduinoJson {
+class JsonArray;
+class JsonObject;
+
+// Entry point for using the library.
+//
+// Handle the memory management (done in derived classes) and calls the parser.
+// This abstract class is implemented by StaticJsonBuffer which implements a
+// fixed memory allocation.
+class JsonBuffer {
+ public:
+  // CAUTION: NO VIRTUAL DESTRUCTOR!
+  // If we add a virtual constructor the Arduino compiler will add malloc() and
+  // free() to the binary, adding 706 useless bytes.
+  // virtual ~JsonBuffer() {}
+
+  // Allocates an empty JsonArray.
+  //
+  // Returns a reference to the new JsonArray or JsonArray::invalid() if the
+  // allocation fails.
+  JsonArray &createArray();
+
+  // Allocates an empty JsonObject.
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonObject &createObject();
+
+  // Allocates and populate a JsonArray from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit (see comment on DEFAULT_LIMIT)
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonArray &parseArray(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // Allocates and populate a JsonObject from a JSON string.
+  //
+  // The First argument is a pointer to the JSON string, the memory must be
+  // writable
+  // because the parser will insert null-terminators and replace escaped chars.
+  //
+  // The second argument set the nesting limit (see comment on DEFAULT_LIMIT)
+  //
+  // Returns a reference to the new JsonObject or JsonObject::invalid() if the
+  // allocation fails.
+  JsonObject &parseObject(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
+
+  // 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;
+
+  // Default value of nesting limit of parseArray() and parseObject().
+  //
+  // 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
+  // a security risk.
+  static const uint8_t DEFAULT_LIMIT = 10;
+};
+}

include/ArduinoJson/JsonObject.hpp

@@ -0,0 +1,107 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "Internals/JsonBufferAllocated.hpp"
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/List.hpp"
+#include "Internals/ReferenceType.hpp"
+#include "JsonPair.hpp"
+
+// Returns the size (in bytes) of an object with n elements.
+// Can be very handy to determine the size of a StaticJsonBuffer.
+#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
+  (sizeof(JsonObject) + (NUMBER_OF_ELEMENTS) * sizeof(JsonObject::node_type))
+
+namespace ArduinoJson {
+
+// Forward declarations
+class JsonArray;
+class JsonBuffer;
+
+// A dictionary of JsonVariant indexed by string (char*)
+//
+// The constructor is private, instances must be created via
+// JsonBuffer::createObject() or JsonBuffer::parseObject().
+// A JsonObject can be serialized to a JSON string via JsonObject::printTo().
+// It can also be deserialized from a JSON string via JsonBuffer::parseObject().
+class JsonObject : public Internals::JsonPrintable<JsonObject>,
+                   public Internals::ReferenceType,
+                   public Internals::List<JsonPair>,
+                   public Internals::JsonBufferAllocated {
+  // JsonBuffer is a friend because it needs to call the private constructor.
+  friend class JsonBuffer;
+
+ public:
+  typedef const char *key_type;
+  typedef JsonPair value_type;
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a reference or JsonVariant::invalid() if not found.
+  JsonVariant &at(key_type key);
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a constant reference or JsonVariant::invalid() if not found.
+  const JsonVariant &at(key_type key) const;
+
+  // Gets or create the JsonVariant associated with the specified key.
+  // Returns a reference or JsonVariant::invalid() if allocation failed.
+  JsonVariant &operator[](key_type key);
+
+  // Gets the JsonVariant associated with the specified key.
+  // Returns a constant reference or JsonVariant::invalid() if not found.
+  const JsonVariant &operator[](key_type key) const { return at(key); }
+
+  // Adds an uninitialized JsonVariant associated with the specified key.
+  // Return a reference or JsonVariant::invalid() if allocation fails.
+  JsonVariant &add(key_type key) { return (*this)[key]; }
+
+  // Adds the specified key with the specified value.
+  template <typename T>
+  void add(key_type key, T value) {
+    add(key).set(value);
+  }
+
+  // Adds the specified key with a reference to the specified JsonArray.
+  void add(key_type key, JsonArray &array) { add(key).set(array); }
+
+  // Adds the specified key with a reference to the specified JsonObject.
+  void add(key_type key, JsonObject &object) { add(key).set(object); }
+
+  // Creates and adds a JsonArray.
+  // This is a shortcut for JsonBuffer::createArray() and JsonObject::add().
+  JsonArray &createNestedArray(key_type key);
+
+  // Creates and adds a JsonObject.
+  // This is a shortcut for JsonBuffer::createObject() and JsonObject::add().
+  JsonObject &createNestedObject(key_type key);
+
+  // Tells weither the specified key is present and associated with a value.
+  bool containsKey(key_type key) const { return at(key).success(); }
+
+  // Removes the specified key and the associated value.
+  void remove(key_type key);
+
+  // Returns a reference an invalid JsonObject.
+  // This object is meant to replace a NULL pointer.
+  // This is used when memory allocation or JSON parsing fail.
+  static JsonObject &invalid() { return _invalid; }
+
+  // Serialize the object to the specified JsonWriter
+  void writeTo(Internals::JsonWriter &writer) const;
+
+ private:
+  // Create an empty JsonArray attached to the specified JsonBuffer.
+  explicit JsonObject(JsonBuffer *buffer) : Internals::List<JsonPair>(buffer) {}
+
+  // Returns the list node that matches the specified key.
+  node_type *getNodeAt(key_type key) const;
+
+  // The instance returned by JsonObject::invalid()
+  static JsonObject _invalid;
+};
+}

include/ArduinoJson/JsonPair.hpp

@@ -0,0 +1,18 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonVariant.hpp"
+
+namespace ArduinoJson {
+
+// A key value pair for JsonObject.
+struct JsonPair {
+  const char* key;
+  JsonVariant value;
+};
+}

include/ArduinoJson/JsonVariant.hpp

@@ -0,0 +1,286 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <stddef.h>
+#include <stdint.h>  // for uint8_t
+
+#include "Internals/JsonPrintable.hpp"
+#include "Internals/JsonVariantContent.hpp"
+#include "Internals/JsonVariantType.hpp"
+
+namespace ArduinoJson {
+
+// Forward declarations.
+class JsonArray;
+class JsonObject;
+
+// A variant that can be a any value serializable to a JSON value.
+//
+// It can be set to:
+// - a boolean
+// - a char, short, int or a long (signed or unsigned)
+// - a string (const char*)
+// - a reference to a JsonArray or JsonObject
+class JsonVariant : public Internals::JsonPrintable<JsonVariant> {
+ public:
+  // Creates an uninitialized JsonVariant
+  JsonVariant() : _type(Internals::JSON_UNDEFINED) {}
+
+  // Initializes a JsonVariant with the specified value.
+  template <typename T>
+  explicit JsonVariant(T value) {
+    set(value);
+  }
+
+  // Tells weither the variant is valid.
+  bool success() const {
+    return _type != Internals::JSON_INVALID &&
+           _type != Internals::JSON_UNDEFINED;
+  }
+
+  // Sets the variant to a boolean value.
+  // It will be serialized as "true" or "false" in JSON.
+  void set(bool value);
+
+  // Sets the variant to a floating point value.
+  // The second argument specifies the number of decimal digits to write in
+  // the JSON string.
+  void set(double value, uint8_t decimals = 2);
+
+  // Sets the variant to be an integer value.
+  void set(signed long value);
+  void set(signed char value) { set(static_cast<long>(value)); }
+  void set(signed int value) { set(static_cast<long>(value)); }
+  void set(signed short value) { set(static_cast<long>(value)); }
+  void set(unsigned char value) { set(static_cast<long>(value)); }
+  void set(unsigned int value) { set(static_cast<long>(value)); }
+  void set(unsigned long value) { set(static_cast<long>(value)); }
+  void set(unsigned short value) { set(static_cast<long>(value)); }
+
+  // Sets the variant to be a string.
+  void set(const char *value);
+
+  // Sets the variant to be a reference to an array.
+  void set(JsonArray &array);
+
+  // Sets the variant to be a reference to an object.
+  void set(JsonObject &object);
+
+  // Sets the variant to the specified value.
+  template <typename T>
+  JsonVariant &operator=(T value) {
+    set(value);
+    return *this;
+  }
+
+  // Sets the variant to be a reference to an array.
+  JsonVariant &operator=(JsonArray &array) {
+    set(array);
+    return *this;
+  }
+
+  // Sets the variant to be a reference to an object.
+  JsonVariant &operator=(JsonObject &object) {
+    set(object);
+    return *this;
+  }
+
+  // Gets the variant as a boolean value.
+  // Returns false if the variant is not a boolean value.
+  operator bool() const;
+
+  // Gets the variant as a floating-point value.
+  // Returns 0.0 if the variant is not a floating-point value
+  operator double() const;
+  operator float() const { return static_cast<float>(as<double>()); }
+
+  // Gets the variant as an integer value.
+  // Returns 0 if the variant is not an integer value.
+  operator signed long() const;
+  operator signed char() const { return cast_long_to<signed char>(); }
+  operator signed int() const { return cast_long_to<signed int>(); }
+  operator signed short() const { return cast_long_to<signed short>(); }
+  operator unsigned char() const { return cast_long_to<unsigned char>(); }
+  operator unsigned int() const { return cast_long_to<unsigned int>(); }
+  operator unsigned long() const { return cast_long_to<unsigned long>(); }
+  operator unsigned short() const { return cast_long_to<unsigned short>(); }
+
+  // Gets the variant as a string.
+  // Returns NULL if variant is not a string.
+  operator const char *() const;
+  const char *asString() const { return as<const char *>(); }
+
+  // Gets the variant as an array.
+  // Returns a reference to the JsonArray or JsonArray::invalid() if the variant
+  // is not an array.
+  operator JsonArray &() const;
+  JsonArray &asArray() const { return as<JsonArray &>(); }
+
+  // Gets the variant as an object.
+  // Returns a reference to the JsonObject or JsonObject::invalid() if the
+  // variant is not an object.
+  operator JsonObject &() const;
+  JsonObject &asObject() const { return as<JsonObject &>(); }
+
+  // Get the variant as the specified type.
+  // See cast operators for details.
+  template <typename T>
+  T as() const {
+    return static_cast<T>(*this);
+  }
+
+  // Tells weither the variant has the specified type.
+  // Returns true if the variant has type type T, false otherwise.
+  template <typename T>
+  bool is() const {
+    return false;
+  }
+
+  // Returns an invalid variant.
+  // This is meant to replace a NULL pointer.
+  static JsonVariant &invalid() { return _invalid; }
+
+  // Serialize the variant to a JsonWriter
+  void writeTo(Internals::JsonWriter &writer) const;
+
+  // Mimics an array or an object.
+  // Returns the size of the array or object if the variant has that type.
+  // Returns 0 if the variant is neither an array nor an object
+  size_t size() const;
+
+  // Mimics an array.
+  // Returns the element at specified index if the variant is an array.
+  // Returns JsonVariant::invalid() if the variant is not an array.
+  JsonVariant &operator[](int index);
+
+  // Mimics an object.
+  // Returns the value associated with the specified key if the variant is an
+  // object.
+  // Return JsonVariant::invalid() if the variant is not an object.
+  JsonVariant &operator[](const char *key);
+
+ private:
+  // Special constructor used only to create _invalid.
+  explicit JsonVariant(Internals::JsonVariantType type) : _type(type) {}
+
+  // Helper for interger cast operators
+  template <typename T>
+  T cast_long_to() const {
+    return static_cast<T>(as<long>());
+  }
+
+  // The current type of the variant
+  Internals::JsonVariantType _type;
+
+  // The various alternatives for the value of the variant.
+  Internals::JsonVariantContent _content;
+
+  // The instance returned by JsonVariant::invalid()
+  static JsonVariant _invalid;
+};
+
+template <>
+inline bool JsonVariant::is<long>() const {
+  return _type == Internals::JSON_LONG;
+}
+
+template <>
+inline bool JsonVariant::is<double>() const {
+  return _type >= Internals::JSON_DOUBLE_0_DECIMALS;
+}
+
+template <>
+inline bool JsonVariant::is<bool>() const {
+  return _type == Internals::JSON_BOOLEAN;
+}
+
+template <>
+inline bool JsonVariant::is<const char *>() const {
+  return _type == Internals::JSON_STRING;
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<const JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<const JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <typename T>
+inline bool operator==(const JsonVariant &left, T right) {
+  return left.as<T>() == right;
+}
+
+template <typename T>
+inline bool operator==(T left, const JsonVariant &right) {
+  return left == right.as<T>();
+}
+
+template <typename T>
+inline bool operator!=(const JsonVariant &left, T right) {
+  return left.as<T>() != right;
+}
+
+template <typename T>
+inline bool operator!=(T left, const JsonVariant &right) {
+  return left != right.as<T>();
+}
+
+template <typename T>
+inline bool operator<=(const JsonVariant &left, T right) {
+  return left.as<T>() <= right;
+}
+
+template <typename T>
+inline bool operator<=(T left, const JsonVariant &right) {
+  return left <= right.as<T>();
+}
+
+template <typename T>
+inline bool operator>=(const JsonVariant &left, T right) {
+  return left.as<T>() >= right;
+}
+
+template <typename T>
+inline bool operator>=(T left, const JsonVariant &right) {
+  return left >= right.as<T>();
+}
+
+template <typename T>
+inline bool operator<(const JsonVariant &left, T right) {
+  return left.as<T>() < right;
+}
+
+template <typename T>
+inline bool operator<(T left, const JsonVariant &right) {
+  return left < right.as<T>();
+}
+
+template <typename T>
+inline bool operator>(const JsonVariant &left, T right) {
+  return left.as<T>() > right;
+}
+
+template <typename T>
+inline bool operator>(T left, const JsonVariant &right) {
+  return left > right.as<T>();
+}
+}

include/ArduinoJson/StaticJsonBuffer.hpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include "JsonBuffer.hpp"
+
+namespace ArduinoJson {
+
+// Implements a JsonBuffer with fixed memory allocation.
+// The template paramenter CAPACITY specifies the capacity of the buffer in
+// bytes.
+template <size_t CAPACITY>
+class StaticJsonBuffer : public JsonBuffer {
+ public:
+  explicit StaticJsonBuffer() : _size(0) {}
+
+  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;
+    return p;
+  }
+
+ private:
+  uint8_t _buffer[CAPACITY];
+  size_t _size;
+};
+}

keywords.txt

@@ -1,10 +1,14 @@
-JsonParser	KEYWORD1
 JsonArray	KEYWORD1
-JsonHashTable	KEYWORD1
-getArray	KEYWORD2
-getBool	KEYWORD2
-getDouble	KEYWORD2
-getHashTableKEYWORD2
-getLong	KEYWORD2
+JsonObject	KEYWORD1
+JsonVariant	KEYWORD1
+StaticJsonBuffer	KEYWORD1
+add	KEYWORD2
+createArray	KEYWORD2
+createNestedArray	KEYWORD2
+createNestedObject	KEYWORD2
+createObject	KEYWORD2
 parseArray	KEYWORD2
-parseHashTable	KEYWORD2
+parseObject	KEYWORD2
+prettyPrintTo	KEYWORD2
+printTo	KEYWORD2
+success	KEYWORD2

library.json

@@ -0,0 +1,17 @@
+{
+  "name": "Json",
+  "keywords": "json, rest, http, web",
+  "description": "An elegant and efficient JSON library for embedded systems",
+  "repository":
+  {
+    "type": "git",
+    "url": "https://github.com/bblanchon/ArduinoJson.git"
+  },
+  "authors":
+  {
+    "name": "Benoit Blanchon",
+    "url": "http://blog.benoitblanchon.fr"
+  },
+  "frameworks": "arduino",
+  "platforms": "atmelavr"  
+}

scripts/build-arduino-package.sh

@@ -0,0 +1,23 @@
+#!/bin/bash
+
+ZIP="C:\Program Files\7-Zip\7z.exe"
+TAG=$(git describe)
+OUTPUT="ArduinoJson-$TAG.zip"
+
+cd ../..
+
+# remove existing file
+rm -f $OUTPUT
+
+# create zip
+"$ZIP" a $OUTPUT \
+	ArduinoJson/CHANGELOG.md \
+	ArduinoJson/examples \
+	ArduinoJson/include \
+	ArduinoJson/keywords.txt \
+	ArduinoJson/LICENSE.md \
+	ArduinoJson/README.md \
+	ArduinoJson/src	\
+	ArduinoJson/ArduinoJson.h \
+	ArduinoJson/ArduinoJson.cpp	\
+    -x!ArduinoJson/src/CMakeLists.txt

scripts/cpplint.sh

@@ -0,0 +1,5 @@
+CPPLINT="python third-party/cpplint/cpplint.py"
+FLAGS="--filter=-runtime/printf,-runtime/int,-readability/todo,-build/namespace,-runtime/references,-readability/streams"
+
+cd ..
+$CPPLINT $FLAGS $(find include src test -regex ".*\.[hc]pp$")

scripts/create-build-envs.sh

@@ -0,0 +1,29 @@
+#!/bin/bash
+
+export PATH="$PATH:/Applications/CMake.app/Contents/bin/"
+
+cd $(dirname $0)/..
+ROOT=$(pwd)
+
+mkdir "build"
+cd build
+BUILD=$(pwd)
+
+build-env()
+{
+	cd $BUILD
+	mkdir "$1"
+	cd "$1"
+	cmake "$ROOT" -G "$2"
+}
+
+if [[ $(uname) == MINGW* ]]
+then
+	build-env "Make" "MinGW Makefiles"
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
+	build-env "VisualStudio" "Visual Studio 12 2013"
+else
+	build-env "SublimeText" "Sublime Text 2 - Ninja"
+	build-env "Make" "Unix Makefiles"
+	build-env "Xcode" "Xcode"
+fi

scripts/format-code.sh

@@ -0,0 +1,7 @@
+cd ..
+FILES=$(find include src test -regex ".*\.[ch]pp$")
+
+clang-format -style=Google -i  $FILES
+
+# insert newline at end of file
+sed -i -e '$a\' $FILES

scripts/run-tests.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+FILE=../bin/ArduinoJsonTests.exe
+MD5=""
+
+file_changed() {
+	[[ ! -f  "$FILE" ]] && return 1
+	NEW_MD5=$(md5sum $FILE)
+	[[ "$MD5" == "$NEW_MD5" ]] && return 1
+	MD5=$NEW_MD5
+	return 0
+}
+
+test_succeed() {
+	echo -en "\007"{,}
+}
+
+test_failed() {
+	echo -en "\007"{,,,,,,,,,,,}
+}
+
+run_tests() {
+	$FILE
+	case $? in
+	0)
+		test_succeed
+		;;
+	1)	
+		test_failed
+		;;
+	esac
+}
+
+while true
+do
+	if file_changed
+	then	
+		run_tests
+	else
+		sleep 2
+	fi
+done
+
+

src/Arduino/Print.cpp

@@ -0,0 +1,52 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#ifndef ARDUINO
+
+#include "../../include/ArduinoJson/Arduino/Print.hpp"
+
+#include <math.h>   // for isnan() and isinf()
+#include <stdio.h>  // for sprintf()
+
+size_t Print::print(const char s[]) {
+  size_t n = 0;
+  while (*s) {
+    n += write(*s++);
+  }
+  return n;
+}
+
+size_t Print::print(double value, int digits) {
+  // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L218
+  if (isnan(value)) return print("nan");
+  if (isinf(value)) return print("inf");
+
+  char tmp[32];
+
+  // https://github.com/arduino/Arduino/blob/db8cbf24c99dc930b9ccff1a43d018c81f178535/hardware/arduino/sam/cores/arduino/Print.cpp#L220
+  bool isBigDouble = value > 4294967040.0 || value < -4294967040.0;
+
+  if (isBigDouble) {
+    // Arduino's implementation prints "ovf"
+    // We prefer trying to use scientific notation, since we have sprintf
+    sprintf(tmp, "%g", value);
+  } else {
+    // Here we have the exact same output as Arduino's implementation
+    sprintf(tmp, "%.*f", digits, value);
+  }
+
+  return print(tmp);
+}
+
+size_t Print::print(long value) {
+  char tmp[32];
+  sprintf(tmp, "%ld", value);
+  return print(tmp);
+}
+
+size_t Print::println() { return write('\r') + write('\n'); }
+
+#endif

src/CMakeLists.txt

@@ -0,0 +1,48 @@
+file(GLOB_RECURSE INC_FILES ../include/*.hpp)
+file(GLOB_RECURSE SRC_FILES *.cpp)
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
+	add_definitions(
+		-fno-exceptions
+		-pedantic
+		-Wall
+		-Wcast-align
+		-Wcast-qual
+		-Wconversion
+		-Wctor-dtor-privacy
+		-Wdisabled-optimization
+		-Werror
+		-Wextra
+		-Wformat=2
+		-Winit-self
+		-Wmissing-include-dirs
+		-Wno-parentheses
+		-Wno-sign-conversion
+		-Wno-unused
+		-Wno-variadic-macros
+		-Wnon-virtual-dtor
+		-Wold-style-cast
+		-Woverloaded-virtual
+		-Wredundant-decls
+		-Wshadow
+		-Wsign-promo
+		-Wstrict-overflow=5
+		-Wundef
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
+	add_definitions(
+		-Wlogical-op
+		-Wnoexcept
+		-Wstrict-null-sentinel
+	)
+endif()
+
+if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+	add_definitions(
+		-Wc++11-compat
+	)
+endif()
+
+add_library(ArduinoJson ${SRC_FILES} ${INC_FILES})

src/DynamicJsonBuffer.cpp

@@ -0,0 +1,79 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/DynamicJsonBuffer.hpp"
+
+namespace ArduinoJson {
+namespace Internals {
+struct DynamicJsonBufferBlockWithoutData {
+  DynamicJsonBufferBlock* next;
+  size_t capacity;
+  size_t size;
+};
+
+
+struct DynamicJsonBufferBlock : DynamicJsonBufferBlockWithoutData {
+  uint8_t data[1];
+};
+}
+}
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+DynamicJsonBuffer::DynamicJsonBuffer() {
+  _head = createBlock(FIRST_BLOCK_CAPACITY);
+}
+
+DynamicJsonBuffer::~DynamicJsonBuffer() {
+  Block* currentBlock = _head;
+
+  while (currentBlock != NULL) {
+    Block* nextBlock = currentBlock->next;
+    free(currentBlock);
+    currentBlock = nextBlock;
+  }
+}
+
+size_t DynamicJsonBuffer::size() const {
+  size_t total = 0;
+
+  for (const Block* b = _head; b != NULL; b = b->next) {
+    total += b->size;
+  }
+
+  return total;
+}
+
+void* DynamicJsonBuffer::alloc(size_t bytes) {
+  if (!canAllocInHead(bytes)) addNewBlock();
+  return allocInHead(bytes);
+}
+
+bool DynamicJsonBuffer::canAllocInHead(size_t bytes) const {
+  return _head->size + bytes <= _head->capacity;
+}
+
+void* DynamicJsonBuffer::allocInHead(size_t bytes) {
+  void* p = _head->data + _head->size;
+  _head->size += bytes;
+  return p;
+}
+
+void DynamicJsonBuffer::addNewBlock() {
+  Block* block = createBlock(_head->capacity * 2);
+  block->next = _head;
+  _head = block;
+}
+
+DynamicJsonBuffer::Block* DynamicJsonBuffer::createBlock(size_t capacity) {
+  size_t blkSize = sizeof(DynamicJsonBufferBlockWithoutData) + capacity;
+  Block* block = static_cast<Block*>(malloc(blkSize));
+  block->capacity = capacity;
+  block->size = 0;
+  block->next = NULL;
+  return block;
+}

src/Internals/IndentedPrint.cpp

@@ -0,0 +1,29 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/IndentedPrint.hpp"
+
+using namespace ArduinoJson::Internals;
+
+size_t IndentedPrint::write(uint8_t c) {
+  size_t n = 0;
+
+  if (isNewLine) n += writeTabs();
+
+  n += sink->write(c);
+
+  isNewLine = c == '\n';
+
+  return n;
+}
+
+inline size_t IndentedPrint::writeTabs() {
+  size_t n = 0;
+
+  for (int i = 0; i < level * tabSize; i++) n += sink->write(' ');
+
+  return n;
+}

src/Internals/JsonParser.cpp

@@ -0,0 +1,197 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/JsonParser.hpp"
+
+#include <stdlib.h>  // for strtol, strtod
+#include <ctype.h>
+
+#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
+#include "../../include/ArduinoJson/JsonArray.hpp"
+#include "../../include/ArduinoJson/JsonBuffer.hpp"
+#include "../../include/ArduinoJson/JsonObject.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+void JsonParser::skipSpaces() {
+  while (isspace(*_ptr)) _ptr++;
+}
+
+bool JsonParser::skip(char charToSkip) {
+  skipSpaces();
+  if (*_ptr != charToSkip) return false;
+  _ptr++;
+  skipSpaces();
+  return true;
+}
+
+bool JsonParser::skip(const char *wordToSkip) {
+  const char *charToSkip = wordToSkip;
+  while (*charToSkip && *_ptr == *charToSkip) {
+    charToSkip++;
+    _ptr++;
+  }
+  return *charToSkip == '\0';
+}
+
+void JsonParser::parseAnythingTo(JsonVariant &destination) {
+  if (_nestingLimit == 0) return;
+  _nestingLimit--;
+
+  skipSpaces();
+
+  switch (*_ptr) {
+    case '[':
+      destination = parseArray();
+      break;
+
+    case '{':
+      destination = parseObject();
+      break;
+
+    case 't':
+    case 'f':
+      parseBooleanTo(destination);
+      break;
+
+    case '-':
+    case '.':
+    case '0':
+    case '1':
+    case '2':
+    case '3':
+    case '4':
+    case '5':
+    case '6':
+    case '7':
+    case '8':
+    case '9':
+      parseNumberTo(destination);
+      break;
+
+    case 'n':
+      parseNullTo(destination);
+      break;
+
+    case '\'':
+    case '\"':
+      destination = parseString();
+      break;
+  }
+
+  _nestingLimit++;
+}
+
+JsonArray &JsonParser::parseArray() {
+  // Create an empty array
+  JsonArray &array = _buffer->createArray();
+
+  // Check opening braket
+  if (!skip('[')) goto ERROR_MISSING_BRACKET;
+  if (skip(']')) goto SUCCESS_EMPTY_ARRAY;
+
+  // Read each value
+  for (;;) {
+    // 1 - Parse value
+    JsonVariant &value = array.add();
+    parseAnythingTo(value);
+    if (!value.success()) goto ERROR_INVALID_VALUE;
+
+    // 2 - More values?
+    if (skip(']')) goto SUCCES_NON_EMPTY_ARRAY;
+    if (!skip(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_ARRAY:
+SUCCES_NON_EMPTY_ARRAY:
+  return array;
+
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACKET:
+ERROR_MISSING_COMMA:
+  return JsonArray::invalid();
+}
+
+JsonObject &JsonParser::parseObject() {
+  // Create an empty object
+  JsonObject &object = _buffer->createObject();
+
+  // Check opening brace
+  if (!skip('{')) goto ERROR_MISSING_BRACE;
+  if (skip('}')) goto SUCCESS_EMPTY_OBJECT;
+
+  // Read each key value pair
+  for (;;) {
+    // 1 - Parse key
+    const char *key = parseString();
+    if (!key) goto ERROR_INVALID_KEY;
+    if (!skip(':')) goto ERROR_MISSING_COLON;
+
+    // 2 - Parse value
+    JsonVariant &value = object.add(key);
+    parseAnythingTo(value);
+    if (!value.success()) goto ERROR_INVALID_VALUE;
+
+    // 3 - More keys/values?
+    if (skip('}')) goto SUCCESS_NON_EMPTY_OBJECT;
+    if (!skip(',')) goto ERROR_MISSING_COMMA;
+  }
+
+SUCCESS_EMPTY_OBJECT:
+SUCCESS_NON_EMPTY_OBJECT:
+  return object;
+
+ERROR_INVALID_KEY:
+ERROR_INVALID_VALUE:
+ERROR_MISSING_BRACE:
+ERROR_MISSING_COLON:
+ERROR_MISSING_COMMA:
+  return JsonObject::invalid();
+}
+
+void JsonParser::parseBooleanTo(JsonVariant &destination) {
+  if (skip("true"))
+    destination = true;
+  else if (skip("false"))
+    destination = false;
+  else
+    destination = JsonVariant::invalid();
+}
+
+void JsonParser::parseNumberTo(JsonVariant &destination) {
+  char *endOfLong;
+  long longValue = strtol(_ptr, &endOfLong, 10);
+  char stopChar = *endOfLong;
+
+  // Could it be a floating point value?
+  bool couldBeFloat = stopChar == '.' || stopChar == 'e' || stopChar == 'E';
+
+  if (couldBeFloat) {
+    // Yes => parse it as a double
+    double doubleValue = strtod(_ptr, &_ptr);
+    // Count the decimal digits
+    uint8_t decimals = static_cast<uint8_t>(_ptr - endOfLong - 1);
+    // Set the variant as a double
+    destination.set(doubleValue, decimals);
+  } else {
+    // No => set the variant as a long
+    _ptr = endOfLong;
+    destination = longValue;
+  }
+}
+
+void JsonParser::parseNullTo(JsonVariant &destination) {
+  const char *NULL_STRING = NULL;
+  if (skip("null"))
+    destination = NULL_STRING;
+  else
+    destination = JsonVariant::invalid();
+}
+
+const char *JsonParser::parseString() {
+  return QuotedString::extractFrom(_ptr, &_ptr);
+}

src/Internals/List.cpp

@@ -0,0 +1,34 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/List.hpp"
+
+#include "../../include/ArduinoJson/JsonPair.hpp"
+#include "../../include/ArduinoJson/JsonVariant.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+template <typename T>
+int List<T>::size() const {
+  int nodeCount = 0;
+  for (node_type *node = _firstNode; node; node = node->next) nodeCount++;
+  return nodeCount;
+}
+
+template <typename T>
+void List<T>::removeNode(node_type *nodeToRemove) {
+  if (!nodeToRemove) return;
+  if (nodeToRemove == _firstNode) {
+    _firstNode = nodeToRemove->next;
+  } else {
+    for (node_type *node = _firstNode; node; node = node->next)
+      if (node->next == nodeToRemove) node->next = nodeToRemove->next;
+  }
+}
+
+template class ArduinoJson::Internals::List<JsonPair>;
+template class ArduinoJson::Internals::List<JsonVariant>;

src/Internals/Prettyfier.cpp

@@ -0,0 +1,86 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/Prettyfier.hpp"
+
+using namespace ArduinoJson::Internals;
+
+size_t Prettyfier::write(uint8_t c) {
+  size_t n = _inString ? handleStringChar(c) : handleMarkupChar(c);
+  _previousChar = c;
+  return n;
+}
+
+inline size_t Prettyfier::handleStringChar(uint8_t c) {
+  bool isQuote = c == '"' && _previousChar != '\\';
+
+  if (isQuote) _inString = false;
+
+  return _sink.write(c);
+}
+
+inline size_t Prettyfier::handleMarkupChar(uint8_t c) {
+  switch (c) {
+    case '{':
+    case '[':
+      return handleBlockOpen(c);
+
+    case '}':
+    case ']':
+      return handleBlockClose(c);
+
+    case ':':
+      return handleColumn();
+
+    case ',':
+      return handleComma();
+
+    case '"':
+      return handleQuoteOpen();
+
+    default:
+      return handleNormalChar(c);
+  }
+}
+
+inline size_t Prettyfier::handleBlockOpen(uint8_t c) {
+  return indentIfNeeded() + _sink.write(c);
+}
+
+inline size_t Prettyfier::handleBlockClose(uint8_t c) {
+  return unindentIfNeeded() + _sink.write(c);
+}
+
+inline size_t Prettyfier::handleColumn() {
+  return _sink.write(':') + _sink.write(' ');
+}
+
+inline size_t Prettyfier::handleComma() {
+  return _sink.write(',') + _sink.println();
+}
+
+inline size_t Prettyfier::handleQuoteOpen() {
+  _inString = true;
+  return indentIfNeeded() + _sink.write('"');
+}
+
+inline size_t Prettyfier::handleNormalChar(uint8_t c) {
+  return indentIfNeeded() + _sink.write(c);
+}
+
+size_t Prettyfier::indentIfNeeded() {
+  if (!inEmptyBlock()) return 0;
+
+  _sink.indent();
+  return _sink.println();
+}
+
+size_t Prettyfier::unindentIfNeeded() {
+  if (inEmptyBlock()) return 0;
+
+  _sink.unindent();
+  return _sink.println();
+}

src/Internals/QuotedString.cpp

@@ -0,0 +1,103 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/QuotedString.hpp"
+
+using namespace ArduinoJson::Internals;
+
+// How to escape special chars:
+// specialChars[2*i+1] => the special char
+// specialChars[2*i] => the char to use instead
+static const char specialChars[] = "\"\"\\\\b\bf\fn\nr\rt\t";
+
+static inline char getSpecialChar(char c) {
+  // Optimized for code size on a 8-bit AVR
+
+  const char *p = specialChars;
+
+  while (p[0] && p[1] != c) {
+    p += 2;
+  }
+
+  return p[0];
+}
+
+static inline size_t printCharTo(char c, Print &p) {
+  char specialChar = getSpecialChar(c);
+
+  return specialChar ? p.write('\\') + p.write(specialChar) : p.write(c);
+}
+
+size_t QuotedString::printTo(const char *s, Print &p) {
+  if (!s) return p.print("null");
+
+  size_t n = p.write('\"');
+
+  while (*s) {
+    n += printCharTo(*s++, p);
+  }
+
+  return n + p.write('\"');
+}
+
+static char unescapeChar(char c) {
+  // Optimized for code size on a 8-bit AVR
+
+  const char *p = specialChars + 4;
+
+  for (;;) {
+    if (p[0] == '\0') return c;
+    if (p[0] == c) return p[1];
+    p += 2;
+  }
+}
+
+static inline bool isQuote(char c) { return c == '\"' || c == '\''; }
+
+char *QuotedString::extractFrom(char *input, char **endPtr) {
+  char firstChar = *input;
+
+  if (!isQuote(firstChar)) {
+    // must start with a quote
+    return NULL;
+  }
+
+  char stopChar = firstChar;  // closing quote is the same as opening quote
+
+  char *startPtr = input + 1;  // skip the quote
+  char *readPtr = startPtr;
+  char *writePtr = startPtr;
+  char c;
+
+  for (;;) {
+    c = *readPtr++;
+
+    if (c == '\0') {
+      // premature ending
+      return NULL;
+    }
+
+    if (c == stopChar) {
+      // closing quote
+      break;
+    }
+
+    if (c == '\\') {
+      // replace char
+      c = unescapeChar(*readPtr++);
+    }
+
+    *writePtr++ = c;
+  }
+
+  // end the string here
+  *writePtr = '\0';
+
+  // update end ptr
+  *endPtr = readPtr;
+
+  return startPtr;
+}

src/Internals/StringBuilder.cpp

@@ -0,0 +1,17 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../../include/ArduinoJson/Internals/StringBuilder.hpp"
+
+using namespace ArduinoJson::Internals;
+
+size_t StringBuilder::write(uint8_t c) {
+  if (length >= capacity) return 0;
+
+  buffer[length++] = c;
+  buffer[length] = '\0';
+  return 1;
+}

src/JsonArray.cpp

@@ -0,0 +1,67 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/JsonArray.hpp"
+
+#include "../include/ArduinoJson/JsonBuffer.hpp"
+#include "../include/ArduinoJson/JsonObject.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+JsonArray JsonArray::_invalid(NULL);
+
+JsonVariant &JsonArray::at(int index) const {
+  node_type *node = getNodeAt(index);
+  return node ? node->content : JsonVariant::invalid();
+}
+
+JsonVariant &JsonArray::add() {
+  node_type *node = createNode();
+  if (!node) return JsonVariant::invalid();
+
+  addNode(node);
+
+  return node->content;
+}
+
+JsonArray &JsonArray::createNestedArray() {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(array);
+  return array;
+}
+
+JsonObject &JsonArray::createNestedObject() {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(object);
+  return object;
+}
+
+JsonArray::node_type *JsonArray::getNodeAt(int index) const {
+  node_type *node = _firstNode;
+  while (node && index--) node = node->next;
+  return node;
+}
+
+void JsonArray::removeAt(int index) { removeNode(getNodeAt(index)); }
+
+void JsonArray::writeTo(JsonWriter &writer) const {
+  writer.beginArray();
+
+  const node_type *child = _firstNode;
+  while (child) {
+    child->content.writeTo(writer);
+
+    child = child->next;
+    if (!child) break;
+
+    writer.writeComma();
+  }
+
+  writer.endArray();
+}

src/JsonBuffer.cpp

@@ -0,0 +1,34 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/JsonBuffer.hpp"
+
+#include "../include/ArduinoJson/Internals/JsonParser.hpp"
+#include "../include/ArduinoJson/JsonArray.hpp"
+#include "../include/ArduinoJson/JsonObject.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+JsonArray &JsonBuffer::createArray() {
+  JsonArray *ptr = new (this) JsonArray(this);
+  return ptr ? *ptr : JsonArray::invalid();
+}
+
+JsonObject &JsonBuffer::createObject() {
+  JsonObject *ptr = new (this) JsonObject(this);
+  return ptr ? *ptr : JsonObject::invalid();
+}
+
+JsonArray &JsonBuffer::parseArray(char *json, uint8_t nestingLimit) {
+  JsonParser parser(this, json, nestingLimit);
+  return parser.parseArray();
+}
+
+JsonObject &JsonBuffer::parseObject(char *json, uint8_t nestingLimit) {
+  JsonParser parser(this, json, nestingLimit);
+  return parser.parseObject();
+}

src/JsonObject.cpp

@@ -0,0 +1,85 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/JsonObject.hpp"
+
+#include <string.h>  // for strcmp
+
+#include "../include/ArduinoJson/Internals/StringBuilder.hpp"
+#include "../include/ArduinoJson/JsonArray.hpp"
+#include "../include/ArduinoJson/JsonBuffer.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+JsonObject JsonObject::_invalid(NULL);
+
+JsonVariant &JsonObject::at(const char *key) {
+  node_type *node = getNodeAt(key);
+  return node ? node->content.value : JsonVariant::invalid();
+}
+
+const JsonVariant &JsonObject::at(const char *key) const {
+  node_type *node = getNodeAt(key);
+  return node ? node->content.value : JsonVariant::invalid();
+}
+
+JsonVariant &JsonObject::operator[](const char *key) {
+  // try to find an existing node
+  node_type *node = getNodeAt(key);
+
+  // not fount => create a new one
+  if (!node) {
+    node = createNode();
+    if (!node) return JsonVariant::invalid();
+
+    node->content.key = key;
+    addNode(node);
+  }
+
+  return node->content.value;
+}
+
+void JsonObject::remove(char const *key) { removeNode(getNodeAt(key)); }
+
+JsonArray &JsonObject::createNestedArray(char const *key) {
+  if (!_buffer) return JsonArray::invalid();
+  JsonArray &array = _buffer->createArray();
+  add(key, array);
+  return array;
+}
+
+JsonObject &JsonObject::createNestedObject(const char *key) {
+  if (!_buffer) return JsonObject::invalid();
+  JsonObject &object = _buffer->createObject();
+  add(key, object);
+  return object;
+}
+
+JsonObject::node_type *JsonObject::getNodeAt(const char *key) const {
+  for (node_type *node = _firstNode; node; node = node->next) {
+    if (!strcmp(node->content.key, key)) return node;
+  }
+  return NULL;
+}
+
+void JsonObject::writeTo(JsonWriter &writer) const {
+  writer.beginObject();
+
+  const node_type *node = _firstNode;
+  while (node) {
+    writer.writeString(node->content.key);
+    writer.writeColon();
+    node->content.value.writeTo(writer);
+
+    node = node->next;
+    if (!node) break;
+
+    writer.writeComma();
+  }
+
+  writer.endObject();
+}

src/JsonVariant.cpp

@@ -0,0 +1,108 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "../include/ArduinoJson/JsonVariant.hpp"
+
+#include "../include/ArduinoJson/JsonArray.hpp"
+#include "../include/ArduinoJson/JsonObject.hpp"
+
+using namespace ArduinoJson;
+using namespace ArduinoJson::Internals;
+
+JsonVariant JsonVariant::_invalid(JSON_INVALID);
+
+JsonVariant::operator JsonArray &() const {
+  return _type == JSON_ARRAY ? *_content.asArray : JsonArray::invalid();
+}
+
+JsonVariant::operator JsonObject &() const {
+  return _type == JSON_OBJECT ? *_content.asObject : JsonObject::invalid();
+}
+
+JsonVariant::operator bool() const {
+  return _type == JSON_BOOLEAN ? _content.asBoolean : false;
+}
+
+JsonVariant::operator const char *() const {
+  return _type == JSON_STRING ? _content.asString : NULL;
+}
+
+JsonVariant::operator double() const {
+  return _type >= JSON_DOUBLE_0_DECIMALS ? _content.asDouble : 0;
+}
+
+JsonVariant::operator long() const {
+  return _type == JSON_LONG ? _content.asLong : 0;
+}
+
+void JsonVariant::set(bool value) {
+  if (_type == JSON_INVALID) return;
+  _type = Internals::JSON_BOOLEAN;
+  _content.asBoolean = value;
+}
+
+void JsonVariant::set(const char *value) {
+  if (_type == JSON_INVALID) return;
+  _type = JSON_STRING;
+  _content.asString = value;
+}
+
+void JsonVariant::set(double value, uint8_t decimals) {
+  if (_type == JSON_INVALID) return;
+  _type = static_cast<JsonVariantType>(JSON_DOUBLE_0_DECIMALS + decimals);
+  _content.asDouble = value;
+}
+
+void JsonVariant::set(long value) {
+  if (_type == JSON_INVALID) return;
+  _type = JSON_LONG;
+  _content.asLong = value;
+}
+
+void JsonVariant::set(JsonArray &array) {
+  if (_type == JSON_INVALID) return;
+  _type = array.success() ? JSON_ARRAY : JSON_INVALID;
+  _content.asArray = &array;
+}
+
+void JsonVariant::set(JsonObject &object) {
+  if (_type == JSON_INVALID) return;
+  _type = object.success() ? JSON_OBJECT : JSON_INVALID;
+  _content.asObject = &object;
+}
+
+size_t JsonVariant::size() const {
+  if (_type == JSON_ARRAY) return _content.asArray->size();
+  if (_type == JSON_OBJECT) return _content.asObject->size();
+  return 0;
+}
+
+JsonVariant &JsonVariant::operator[](int index) {
+  if (_type != JSON_ARRAY) return JsonVariant::invalid();
+  return _content.asArray->operator[](index);
+}
+
+JsonVariant &JsonVariant::operator[](const char *key) {
+  if (_type != JSON_OBJECT) return JsonVariant::invalid();
+  return _content.asObject->operator[](key);
+}
+
+void JsonVariant::writeTo(JsonWriter &writer) const {
+  if (is<const JsonArray &>())
+    as<const JsonArray &>().writeTo(writer);
+  else if (is<const JsonObject &>())
+    as<const JsonObject &>().writeTo(writer);
+  else if (is<const char *>())
+    writer.writeString(as<const char *>());
+  else if (is<long>())
+    writer.writeLong(as<long>());
+  else if (is<bool>())
+    writer.writeBoolean(as<bool>());
+  else if (is<double>()) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
+    writer.writeDouble(as<double>(), decimals);
+  }
+}

test/CMakeLists.txt

@@ -0,0 +1,21 @@
+set(GTEST_DIR ../third-party/gtest-1.7.0)
+
+file(GLOB_RECURSE INC_FILES ../include/*.h)
+file(GLOB TESTS_FILES *.hpp *.cpp)
+
+include_directories(
+	../include
+    ${GTEST_DIR}
+    ${GTEST_DIR}/include)
+
+add_definitions(-DGTEST_HAS_PTHREAD=0)
+
+add_executable(ArduinoJsonTests 
+    ${TESTS_FILES}
+	${INC_FILES}
+    ${GTEST_DIR}/src/gtest-all.cc
+    ${GTEST_DIR}/src/gtest_main.cc)
+
+target_link_libraries(ArduinoJsonTests ArduinoJson)
+
+add_test(ArduinoJsonTests ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/ArduinoJsonTests)

test/DynamicJsonBuffer_Array_Tests.cpp

@@ -0,0 +1,32 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+TEST(DynamicJsonBuffer_Array_Tests, GrowsWithArray) {
+  DynamicJsonBuffer jsonBuffer;
+
+  JsonArray &array = jsonBuffer.createArray();
+  ASSERT_EQ(JSON_ARRAY_SIZE(0), jsonBuffer.size());
+
+  array.add("hello");
+  ASSERT_EQ(JSON_ARRAY_SIZE(1), jsonBuffer.size());
+
+  array.add("world");
+  ASSERT_EQ(JSON_ARRAY_SIZE(2), jsonBuffer.size());
+}
+
+TEST(DynamicJsonBuffer_Array_Tests, CanAdd1000Values) {
+  DynamicJsonBuffer jsonBuffer;
+
+  JsonArray &array = jsonBuffer.createArray();
+
+  for (int i = 1; i <= 1000; i++) {
+    array.add("hello");
+    ASSERT_EQ(array.size(), i);
+  }
+}

test/DynamicJsonBuffer_Basic_Tests.cpp

@@ -0,0 +1,34 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+
+#define protected public
+#include <ArduinoJson/DynamicJsonBuffer.hpp>
+
+using namespace ArduinoJson;
+
+class DynamicJsonBuffer_Basic_Tests : public testing::Test {
+ protected:
+  DynamicJsonBuffer buffer;
+};
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, InitialSizeIsZero) {
+  ASSERT_EQ(0, buffer.size());
+}
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, SizeIncreasesAfterAlloc) {
+  buffer.alloc(1);
+  ASSERT_EQ(1, buffer.size());
+  buffer.alloc(1);
+  ASSERT_EQ(2, buffer.size());
+}
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {
+  void* p1 = buffer.alloc(1);
+  void* p2 = buffer.alloc(2);
+  ASSERT_NE(p1, p2);
+}

test/DynamicJsonBuffer_Object_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>
+
+TEST(DynamicJsonBuffer_Object_Tests, GrowsWithObject) {
+  DynamicJsonBuffer json;
+
+  JsonObject &obj = json.createObject();
+  ASSERT_EQ(JSON_OBJECT_SIZE(0), json.size());
+
+  obj["hello"];
+  ASSERT_EQ(JSON_OBJECT_SIZE(1), json.size());
+
+  obj["world"];
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), json.size());
+
+  obj["world"];  // <- same value, should not grow
+  ASSERT_EQ(JSON_OBJECT_SIZE(2), json.size());
+}

test/GbathreeBug.cpp

@@ -0,0 +1,191 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+#include "Printers.hpp"
+
+class GbathreeBug : public testing::Test {
+ public:
+  GbathreeBug() : _object(_buffer.parseObject(getJson())) {}
+
+ protected:
+  char _json[1024];
+  DynamicJsonBuffer _buffer;
+  const JsonObject& _object;
+
+ private:
+  char* getJson() {
+    strcpy(_json,
+           "{\"protocol_name\":\"fluorescence\",\"repeats\":1,\"wait\":0,"
+           "\"averages\":1,\"measurements\":3,\"meas2_light\":15,\"meas1_"
+           "baseline\":0,\"act_light\":20,\"pulsesize\":25,\"pulsedistance\":"
+           "10000,\"actintensity1\":50,\"actintensity2\":255,\"measintensity\":"
+           "255,\"calintensity\":255,\"pulses\":[50,50,50],\"act\":[2,1,2,2],"
+           "\"red\":[2,2,2,2],\"detectors\":[[34,34,34,34],[34,34,34,34],[34,"
+           "34,34,34],[34,34,34,34]],\"alta\":[2,2,2,2],\"altb\":[2,2,2,2],"
+           "\"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,"
+           "15,15]],\"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],"
+           "[15,15,15,15]],\"altc\":[2,2,2,2],\"altd\":[2,2,2,2]}");
+    return _json;
+  }
+};
+
+TEST_F(GbathreeBug, Success) { EXPECT_TRUE(_object.success()); }
+
+TEST_F(GbathreeBug, ProtocolName) {
+  EXPECT_STREQ("fluorescence", _object.at("protocol_name").asString());
+}
+
+TEST_F(GbathreeBug, Repeats) { EXPECT_EQ(1, _object["repeats"]); }
+
+TEST_F(GbathreeBug, Wait) { EXPECT_EQ(0, _object["wait"]); }
+
+TEST_F(GbathreeBug, Measurements) { EXPECT_EQ(3, _object["measurements"]); }
+
+TEST_F(GbathreeBug, Meas2_Light) { EXPECT_EQ(15, _object["meas2_light"]); }
+
+TEST_F(GbathreeBug, Meas1_Baseline) { EXPECT_EQ(0, _object["meas1_baseline"]); }
+
+TEST_F(GbathreeBug, Act_Light) { EXPECT_EQ(20, _object["act_light"]); }
+
+TEST_F(GbathreeBug, Pulsesize) { EXPECT_EQ(25, _object["pulsesize"]); }
+
+TEST_F(GbathreeBug, Pulsedistance) {
+  EXPECT_EQ(10000, _object["pulsedistance"]);
+}
+
+TEST_F(GbathreeBug, Actintensity1) { EXPECT_EQ(50, _object["actintensity1"]); }
+
+TEST_F(GbathreeBug, Actintensity2) { EXPECT_EQ(255, _object["actintensity2"]); }
+
+TEST_F(GbathreeBug, Measintensity) { EXPECT_EQ(255, _object["measintensity"]); }
+
+TEST_F(GbathreeBug, Calintensity) { EXPECT_EQ(255, _object["calintensity"]); }
+
+TEST_F(GbathreeBug, Pulses) {
+  // "pulses":[50,50,50]
+
+  JsonArray& array = _object.at("pulses");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(3, array.size());
+
+  for (int i = 0; i < 3; i++) {
+    EXPECT_EQ(50, array[i]);
+  }
+}
+
+TEST_F(GbathreeBug, Act) {
+  // "act":[2,1,2,2]
+
+  JsonArray& array = _object.at("act");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(4, array.size());
+  EXPECT_EQ(2, array[0]);
+  EXPECT_EQ(1, array[1]);
+  EXPECT_EQ(2, array[2]);
+  EXPECT_EQ(2, array[3]);
+}
+
+TEST_F(GbathreeBug, Detectors) {
+  // "detectors":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]]
+
+  JsonArray& array = _object.at("detectors");
+  EXPECT_TRUE(array.success());
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    JsonArray& nestedArray = array[i];
+    EXPECT_EQ(4, nestedArray.size());
+
+    for (int j = 0; j < 4; j++) EXPECT_EQ(34, nestedArray[j]);
+  }
+}
+
+TEST_F(GbathreeBug, Alta) {
+  // alta:[2,2,2,2]
+
+  JsonArray& array = _object.at("alta");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    EXPECT_EQ(2, array[i]);
+  }
+}
+
+TEST_F(GbathreeBug, Altb) {
+  // altb:[2,2,2,2]
+
+  JsonArray& array = _object.at("altb");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    EXPECT_EQ(2, array[i]);
+  }
+}
+
+TEST_F(GbathreeBug, Measlights) {
+  // "measlights":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
+
+  JsonArray& array = _object.at("measlights");
+  EXPECT_TRUE(array.success());
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    JsonArray& nestedArray = array[i];
+
+    EXPECT_EQ(4, nestedArray.size());
+
+    for (int j = 0; j < 4; j++) EXPECT_EQ(15, nestedArray[j]);
+  }
+}
+
+TEST_F(GbathreeBug, Measlights2) {
+  // "measlights2":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
+
+  JsonArray& array = _object.at("measlights2");
+  EXPECT_TRUE(array.success());
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    JsonArray& nestedArray = array[i];
+    EXPECT_EQ(4, nestedArray.size());
+
+    for (int j = 0; j < 4; j++) EXPECT_EQ(15, nestedArray[j]);
+  }
+}
+
+TEST_F(GbathreeBug, Altc) {
+  // altc:[2,2,2,2]
+
+  JsonArray& array = _object.at("altc");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    EXPECT_EQ(2, array[i]);
+  }
+}
+
+TEST_F(GbathreeBug, Altd) {
+  // altd:[2,2,2,2]
+
+  JsonArray& array = _object.at("altd");
+  EXPECT_TRUE(array.success());
+
+  EXPECT_EQ(4, array.size());
+
+  for (int i = 0; i < 4; i++) {
+    EXPECT_EQ(2, array[i]);
+  }
+}

test/IntegrationTests.cpp

@@ -0,0 +1,104 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class IntegrationTests : public testing::TestWithParam<const char*> {
+  static const size_t MAX_JSON_SIZE = 10000;
+
+ protected:
+  virtual void SetUp() {
+    _input = GetParam();
+    strcpy(_inputBuffer, _input);
+  }
+
+  void parseThenPrint(char* input, char* output) {
+    DynamicJsonBuffer buffer;
+    buffer.parseObject(input).printTo(output, MAX_JSON_SIZE);
+  }
+
+  void parseThenPrettyPrint(char* input, char* output) {
+    DynamicJsonBuffer buffer;
+    buffer.parseObject(input).prettyPrintTo(output, MAX_JSON_SIZE);
+  }
+
+  const char* _input;
+  char _inputBuffer[MAX_JSON_SIZE];
+  char _outputBuffer[MAX_JSON_SIZE];
+  char _intermediateBuffer[MAX_JSON_SIZE];
+};
+
+TEST_P(IntegrationTests, ParseThenPrint) {
+  parseThenPrint(_inputBuffer, _outputBuffer);
+  ASSERT_STREQ(_input, _outputBuffer);
+}
+
+TEST_P(IntegrationTests, ParseThenPrettyPrintThenParseThenPrint) {
+  parseThenPrettyPrint(_inputBuffer, _intermediateBuffer);
+  parseThenPrint(_intermediateBuffer, _outputBuffer);
+  ASSERT_STREQ(_input, _outputBuffer);
+}
+
+INSTANTIATE_TEST_CASE_P(
+    OpenWeatherMap, IntegrationTests,
+    testing::Values(
+        "{\"coord\":{\"lon\":145.77,\"lat\":-16.92},\"sys\":{\"type\":1,\"id\":"
+        "8166,\"message\":0.1222,\"country\":\"AU\",\"sunrise\":1414784325,"
+        "\"sunset\":1414830137},\"weather\":[{\"id\":801,\"main\":\"Clouds\","
+        "\"description\":\"few clouds\",\"icon\":\"02n\"}],\"base\":\"cmc "
+        "stations\",\"main\":{\"temp\":296.15,\"pressure\":1014,\"humidity\":"
+        "83,\"temp_min\":296.15,\"temp_max\":296.15},\"wind\":{\"speed\":2.22,"
+        "\"deg\":114.501},\"clouds\":{\"all\":20},\"dt\":1414846800,\"id\":"
+        "2172797,\"name\":\"Cairns\",\"cod\":200}"));
+
+INSTANTIATE_TEST_CASE_P(
+    YahooQueryLanguage, IntegrationTests,
+    testing::Values(
+        "{\"query\":{\"count\":40,\"created\":\"2014-11-01T14:16:49Z\","
+        "\"lang\":\"fr-FR\",\"results\":{\"item\":[{\"title\":\"Burkina army "
+        "backs Zida as interim leader\"},{\"title\":\"British jets intercept "
+        "Russian bombers\"},{\"title\":\"Doubts chip away at nation's most "
+        "trusted agencies\"},{\"title\":\"Cruise ship stuck off Norway, no "
+        "damage\"},{\"title\":\"U.S. military launches 10 air strikes in "
+        "Syria, Iraq\"},{\"title\":\"Blackout hits Bangladesh as line from "
+        "India fails\"},{\"title\":\"Burkina Faso president in Ivory Coast "
+        "after ouster\"},{\"title\":\"Kurds in Turkey rally to back city "
+        "besieged by IS\"},{\"title\":\"A majority of Scots would vote for "
+        "independence now:poll\"},{\"title\":\"Tunisia elections possible "
+        "model for region\"},{\"title\":\"Islamic State kills 85 more members "
+        "of Iraqi tribe\"},{\"title\":\"Iraqi officials:IS extremists line "
+        "up, kill 50\"},{\"title\":\"Burkina Faso army backs presidential "
+        "guard official to lead transition\"},{\"title\":\"Kurdish peshmerga "
+        "arrive with weapons in Syria's Kobani\"},{\"title\":\"Driver sought "
+        "in crash that killed 3 on Halloween\"},{\"title\":\"Ex-Marine arrives "
+        "in US after release from Mexico jail\"},{\"title\":\"UN panel "
+        "scrambling to finish climate report\"},{\"title\":\"Investigators, "
+        "Branson go to spacecraft crash site\"},{\"title\":\"Soldiers vie for "
+        "power after Burkina Faso president quits\"},{\"title\":\"For a man "
+        "without a party, turnout is big test\"},{\"title\":\"'We just had a "
+        "hunch':US marshals nab Eric Frein\"},{\"title\":\"Boko Haram leader "
+        "threatens to kill German hostage\"},{\"title\":\"Nurse free to move "
+        "about as restrictions eased\"},{\"title\":\"Former Burkina president "
+        "Compaore arrives in Ivory Coast:sources\"},{\"title\":\"Libyan port "
+        "rebel leader refuses to hand over oil ports to rival "
+        "group\"},{\"title\":\"Iraqi peshmerga fighters prepare for Syria "
+        "battle\"},{\"title\":\"1 Dem Senate candidate welcoming Obama's "
+        "help\"},{\"title\":\"Bikers cancel party after police recover "
+        "bar\"},{\"title\":\"New question in Texas:Can Davis survive "
+        "defeat?\"},{\"title\":\"Ukraine rebels to hold election, despite "
+        "criticism\"},{\"title\":\"Iraqi officials say Islamic State group "
+        "lines up, kills 50 tribesmen, women in Anbar "
+        "province\"},{\"title\":\"James rebounds, leads Cavaliers past "
+        "Bulls\"},{\"title\":\"UK warns travelers they could be terror "
+        "targets\"},{\"title\":\"Hello Kitty celebrates 40th "
+        "birthday\"},{\"title\":\"A look at people killed during space "
+        "missions\"},{\"title\":\"Nigeria's purported Boko Haram leader says "
+        "has 'married off' girls:AFP\"},{\"title\":\"Mexico orders immediate "
+        "release of Marine veteran\"},{\"title\":\"As election closes in, "
+        "Obama on center stage\"},{\"title\":\"Body of Zambian president "
+        "arrives home\"},{\"title\":\"South Africa arrests 2 Vietnamese for "
+        "poaching\"}]}}}"));

test/Issue10.cpp

@@ -0,0 +1,67 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+struct Person {
+  int id;
+  char name[32];
+};
+
+class Issue10 : public testing::Test {
+ protected:
+  virtual void SetUp() {
+    Person boss;
+    boss.id = 1;
+    strcpy(boss.name, "Jeff");
+    Person employee;
+    employee.id = 2;
+    strcpy(employee.name, "John");
+    persons[0] = boss;
+    persons[1] = employee;
+  }
+
+  template <typename T>
+  void checkJsonString(const T &p) {
+    char buffer[256];
+    p.printTo(buffer, sizeof(buffer));
+
+    EXPECT_STREQ("[{\"id\":1,\"name\":\"Jeff\"},{\"id\":2,\"name\":\"John\"}]",
+                 buffer);
+  }
+
+  StaticJsonBuffer<JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2)> json;
+  Person persons[2];
+};
+
+TEST_F(Issue10, PopulateArrayByAddingAnObject) {
+  JsonArray &array = json.createArray();
+
+  for (int i = 0; i < 2; i++) {
+    JsonObject &object = json.createObject();
+
+    object["id"] = persons[i].id;
+    object["name"] = persons[i].name;
+
+    array.add(object);
+  }
+
+  checkJsonString(array);
+}
+
+TEST_F(Issue10, PopulateArrayByCreatingNestedObjects) {
+  JsonArray &array = json.createArray();
+
+  for (int i = 0; i < 2; i++) {
+    JsonObject &object = array.createNestedObject();
+
+    object["id"] = persons[i].id;
+    object["name"] = persons[i].name;
+  }
+
+  checkJsonString(array);
+}

test/Issue34.cpp

@@ -0,0 +1,39 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class Issue34 : public testing::Test {
+ protected:
+  template <typename T>
+  void test_with_value(T expected) {
+    StaticJsonBuffer<JSON_OBJECT_SIZE(1)> jsonBuffer;
+
+    JsonObject& jsonObject = jsonBuffer.createObject();
+
+    jsonObject["key"] = expected;
+    T actual = jsonObject["key"];
+
+    ASSERT_EQ(expected, actual);
+  }
+};
+
+TEST_F(Issue34, int8_t) { test_with_value<int8_t>(1); }
+
+TEST_F(Issue34, uint8_t) { test_with_value<uint8_t>(2); }
+
+TEST_F(Issue34, int16_t) { test_with_value<int16_t>(3); }
+
+TEST_F(Issue34, uint16_t) { test_with_value<uint16_t>(4); }
+
+TEST_F(Issue34, int32_t) { test_with_value<int32_t>(5); }
+
+TEST_F(Issue34, uint32_t) { test_with_value<uint32_t>(6); }
+
+TEST_F(Issue34, float) { test_with_value<float>(7); }
+
+TEST_F(Issue34, double) { test_with_value<double>(8); }

test/Issue67.cpp

@@ -0,0 +1,47 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class Issue67 : public testing::Test {
+ public:
+  void whenInputIs(double value) { _variant = value; }
+
+  void outputMustBe(const char* expected) {
+    char buffer[1024];
+    _variant.printTo(buffer, sizeof(buffer));
+    ASSERT_STREQ(expected, buffer);
+  }
+
+ private:
+  JsonVariant _variant;
+};
+
+TEST_F(Issue67, BigPositiveDouble) {
+  whenInputIs(1e100);
+  outputMustBe("1e+100");
+}
+
+TEST_F(Issue67, BigNegativeDouble) {
+  whenInputIs(-1e100);
+  outputMustBe("-1e+100");
+}
+
+TEST_F(Issue67, Zero) {
+  whenInputIs(0.0);
+  outputMustBe("0.00");
+}
+
+TEST_F(Issue67, SmallPositiveDouble) {
+  whenInputIs(111.111);
+  outputMustBe("111.11");
+}
+
+TEST_F(Issue67, SmallNegativeDouble) {
+  whenInputIs(-111.111);
+  outputMustBe("-111.11");
+}

test/JsonArray_Container_Tests.cpp

@@ -0,0 +1,174 @@
+// 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, 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_Invalid_Tests.cpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+TEST(JsonArray_Invalid_Tests, AtFails) {
+  ASSERT_FALSE(JsonArray::invalid().at(0).success());
+}
+
+TEST(JsonArray_Invalid_Tests, SubscriptFails) {
+  ASSERT_FALSE(JsonArray::invalid()[0].success());
+}
+
+TEST(JsonArray_Invalid_Tests, AddFails) {
+  JsonArray& array = JsonArray::invalid();
+  array.add(1);
+  ASSERT_EQ(0, array.size());
+}
+
+TEST(JsonArray_Invalid_Tests, CreateNestedArrayFails) {
+  ASSERT_FALSE(JsonArray::invalid().createNestedArray().success());
+}
+
+TEST(JsonArray_Invalid_Tests, CreateNestedObjectFails) {
+  ASSERT_FALSE(JsonArray::invalid().createNestedObject().success());
+}
+
+TEST(JsonArray_Invalid_Tests, PrintToWritesBrackets) {
+  char buffer[32];
+  JsonArray::invalid().printTo(buffer, sizeof(buffer));
+  ASSERT_STREQ("[]", buffer);
+}

test/JsonArray_Iterator_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>
+
+template <typename TIterator>
+static void run_iterator_test() {
+  StaticJsonBuffer<JSON_ARRAY_SIZE(2)> jsonBuffer;
+
+  JsonArray &array = jsonBuffer.createArray();
+  array.add(12);
+  array.add(34);
+
+  TIterator it = array.begin();
+  TIterator end = array.end();
+
+  EXPECT_NE(end, it);
+  EXPECT_EQ(12, it->template as<int>());
+  EXPECT_EQ(12, static_cast<int>(*it));
+  ++it;
+  EXPECT_NE(end, it);
+  EXPECT_EQ(34, it->template as<int>());
+  EXPECT_EQ(34, static_cast<int>(*it));
+  ++it;
+  EXPECT_EQ(end, it);
+}
+
+TEST(JsonArray_Iterator_Test, RunItertorToEnd) {
+  run_iterator_test<JsonArray::iterator>();
+}
+
+TEST(JsonArray_Iterator_Test, RunConstItertorToEnd) {
+  run_iterator_test<JsonArray::const_iterator>();
+}

test/JsonArray_PrettyPrintTo_Tests.cpp

@@ -0,0 +1,81 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonArray_PrettyPrintTo_Tests : public testing::Test {
+ public:
+  JsonArray_PrettyPrintTo_Tests() : array(jsonBuffer.createArray()) {}
+
+ protected:
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray& array;
+
+  void outputMustBe(const char* expected) {
+    char actual[256];
+
+    size_t actualLen = array.prettyPrintTo(actual, sizeof(actual));
+    size_t measuredLen = array.measurePrettyLength();
+
+    EXPECT_STREQ(expected, actual);
+    EXPECT_EQ(strlen(expected), actualLen);
+    EXPECT_EQ(strlen(expected), measuredLen);
+  }
+};
+
+TEST_F(JsonArray_PrettyPrintTo_Tests, Empty) { outputMustBe("[]"); }
+
+TEST_F(JsonArray_PrettyPrintTo_Tests, OneElement) {
+  array.add(1);
+
+  outputMustBe(
+      "[\r\n"
+      "  1\r\n"
+      "]");
+}
+
+TEST_F(JsonArray_PrettyPrintTo_Tests, TwoElements) {
+  array.add(1);
+  array.add(2);
+
+  outputMustBe(
+      "[\r\n"
+      "  1,\r\n"
+      "  2\r\n"
+      "]");
+}
+
+TEST_F(JsonArray_PrettyPrintTo_Tests, EmptyNestedArrays) {
+  array.createNestedArray();
+  array.createNestedArray();
+
+  outputMustBe(
+      "[\r\n"
+      "  [],\r\n"
+      "  []\r\n"
+      "]");
+}
+
+TEST_F(JsonArray_PrettyPrintTo_Tests, NestedArrays) {
+  JsonArray& nested1 = array.createNestedArray();
+  nested1.add(1);
+  nested1.add(2);
+
+  JsonObject& nested2 = array.createNestedObject();
+  nested2["key"] = 3;
+
+  outputMustBe(
+      "[\r\n"
+      "  [\r\n"
+      "    1,\r\n"
+      "    2\r\n"
+      "  ],\r\n"
+      "  {\r\n"
+      "    \"key\": 3\r\n"
+      "  }\r\n"
+      "]");
+}

test/JsonArray_PrintTo_Tests.cpp

@@ -0,0 +1,128 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonArray_PrintTo_Tests : public testing::Test {
+ public:
+  JsonArray_PrintTo_Tests() : array(json.createArray()) {}
+
+ protected:
+  StaticJsonBuffer<JSON_ARRAY_SIZE(2)> json;
+  JsonArray &array;
+
+  void outputMustBe(const char *expected) {
+    size_t actualLen = array.printTo(buffer, sizeof(buffer));
+    size_t measuredLen = array.measureLength();
+
+    EXPECT_STREQ(expected, buffer);
+    EXPECT_EQ(strlen(expected), actualLen);
+    EXPECT_EQ(strlen(expected), measuredLen);
+  }
+
+ private:
+  char buffer[256];
+};
+
+TEST_F(JsonArray_PrintTo_Tests, Empty) { outputMustBe("[]"); }
+
+TEST_F(JsonArray_PrintTo_Tests, Null) {
+  array.add(static_cast<char *>(0));
+
+  outputMustBe("[null]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneString) {
+  array.add("hello");
+
+  outputMustBe("[\"hello\"]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, TwoStrings) {
+  array.add("hello");
+  array.add("world");
+
+  outputMustBe("[\"hello\",\"world\"]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneStringOverCapacity) {
+  array.add("hello");
+  array.add("world");
+  array.add("lost");
+
+  outputMustBe("[\"hello\",\"world\"]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneDoubleDefaultDigits) {
+  array.add(3.14159265358979323846);
+  outputMustBe("[3.14]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneDoubleFourDigits) {
+  array.add(3.14159265358979323846, 4);
+  outputMustBe("[3.1416]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneInteger) {
+  array.add(1);
+
+  outputMustBe("[1]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, TwoIntegers) {
+  array.add(1);
+  array.add(2);
+
+  outputMustBe("[1,2]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneIntegerOverCapacity) {
+  array.add(1);
+  array.add(2);
+  array.add(3);
+
+  outputMustBe("[1,2]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneTrue) {
+  array.add(true);
+
+  outputMustBe("[true]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneFalse) {
+  array.add(false);
+
+  outputMustBe("[false]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, TwoBooleans) {
+  array.add(false);
+  array.add(true);
+
+  outputMustBe("[false,true]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneBooleanOverCapacity) {
+  array.add(false);
+  array.add(true);
+  array.add(false);
+
+  outputMustBe("[false,true]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneEmptyNestedArray) {
+  array.createNestedArray();
+
+  outputMustBe("[[]]");
+}
+
+TEST_F(JsonArray_PrintTo_Tests, OneEmptyNestedHash) {
+  array.createNestedObject();
+
+  outputMustBe("[{}]");
+}

test/JsonObject_Container_Tests.cpp

@@ -0,0 +1,126 @@
+// 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"];
+  EXPECT_EQ(1, _object.size());
+
+  _object["world"];
+  EXPECT_EQ(2, _object.size());
+}
+
+TEST_F(JsonObject_Container_Tests, DoNotGrow_WhenSameValueIsAdded) {
+  _object["hello"];
+  EXPECT_EQ(1, _object.size());
+
+  _object["hello"];
+  EXPECT_EQ(1, _object.size());
+}
+
+TEST_F(JsonObject_Container_Tests, Shrink_WhenValuesAreRemoved) {
+  _object["hello"];
+  _object["world"];
+
+  _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"];
+  _object["world"];
+
+  _object.remove(":-P");
+
+  EXPECT_EQ(2, _object.size());
+}
+
+TEST_F(JsonObject_Container_Tests, CanStoreIntegers) {
+  _object["hello"] = 123;
+  _object["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["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["world"] = false;
+
+  EXPECT_TRUE(_object["hello"].as<bool>());
+  EXPECT_FALSE(_object["world"].as<bool>());
+}
+
+TEST_F(JsonObject_Container_Tests, CanStoreStrings) {
+  _object["hello"] = "h3110";
+  _object["world"] = "w0r1d";
+
+  EXPECT_STREQ("h3110", _object["hello"].as<const char*>());
+  EXPECT_STREQ("w0r1d", _object["world"].as<const char*>());
+}
+
+TEST_F(JsonObject_Container_Tests, CanStoreInnerArrays) {
+  JsonArray& innerarray1 = _jsonBuffer.createArray();
+  JsonArray& innerarray2 = _jsonBuffer.createArray();
+
+  _object["hello"] = innerarray1;
+  _object["world"] = innerarray2;
+
+  EXPECT_EQ(&innerarray1, &_object["hello"].asArray());
+  EXPECT_EQ(&innerarray2, &_object["world"].asArray());
+}
+
+TEST_F(JsonObject_Container_Tests, CanStoreInnerObjects) {
+  JsonObject& innerObject1 = _jsonBuffer.createObject();
+  JsonObject& innerObject2 = _jsonBuffer.createObject();
+
+  _object["hello"] = innerObject1;
+  _object["world"] = innerObject2;
+
+  EXPECT_EQ(&innerObject1, &_object["hello"].asObject());
+  EXPECT_EQ(&innerObject2, &_object["world"].asObject());
+}
+
+TEST_F(JsonObject_Container_Tests, ContainsKeyReturnFalseForNonExistingKey) {
+  EXPECT_FALSE(_object.containsKey("hello"));
+}
+
+TEST_F(JsonObject_Container_Tests, ContainsKeyReturnTrueForDefinedValue) {
+  _object.add("hello", 42);
+  EXPECT_TRUE(_object.containsKey("hello"));
+}
+
+TEST_F(JsonObject_Container_Tests, ContainsKeyReturnFalseForUndefinedValue) {
+  _object.add("hello");
+  EXPECT_FALSE(_object.containsKey("hello"));
+}

test/JsonObject_Invalid_Tests.cpp

@@ -0,0 +1,36 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+TEST(JsonObject_Invalid_Tests, AtFails) {
+  ASSERT_FALSE(JsonObject::invalid().at(0).success());
+}
+
+TEST(JsonObject_Invalid_Tests, SubscriptFails) {
+  ASSERT_FALSE(JsonObject::invalid()[0].success());
+}
+
+TEST(JsonObject_Invalid_Tests, AddFails) {
+  JsonObject& array = JsonObject::invalid();
+  array.add("hello", "world");
+  ASSERT_EQ(0, array.size());
+}
+
+TEST(JsonObject_Invalid_Tests, CreateNestedArrayFails) {
+  ASSERT_FALSE(JsonObject::invalid().createNestedArray("hello").success());
+}
+
+TEST(JsonObject_Invalid_Tests, CreateNestedObjectFails) {
+  ASSERT_FALSE(JsonObject::invalid().createNestedObject("world").success());
+}
+
+TEST(JsonObject_Invalid_Tests, PrintToWritesBraces) {
+  char buffer[32];
+  JsonObject::invalid().printTo(buffer, sizeof(buffer));
+  ASSERT_STREQ("{}", buffer);
+}

test/JsonObject_Iterator_Tests.cpp

@@ -0,0 +1,57 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+#include "Printers.hpp"
+
+class JsonObject_Iterator_Test : public testing::Test {
+ public:
+  JsonObject_Iterator_Test() : _object(_buffer.createObject()) {
+    _object["ab"] = 12;
+    _object["cd"] = 34;
+  }
+
+ protected:
+  StaticJsonBuffer<JSON_OBJECT_SIZE(2)> _buffer;
+  JsonObject& _object;
+};
+
+TEST_F(JsonObject_Iterator_Test, NonConstIterator) {
+  JsonObject::iterator it = _object.begin();
+  ASSERT_NE(_object.end(), it);
+  EXPECT_STREQ("ab", it->key);
+  EXPECT_EQ(12, it->value);
+  it->key = "a.b";
+  it->value = 1.2;
+  ++it;
+  ASSERT_NE(_object.end(), it);
+  EXPECT_STREQ("cd", it->key);
+  EXPECT_EQ(34, it->value);
+  it->key = "c.d";
+  it->value = 3.4;
+  ++it;
+  ASSERT_EQ(_object.end(), it);
+
+  ASSERT_EQ(2, _object.size());
+  EXPECT_EQ(1.2, _object["a.b"]);
+  EXPECT_EQ(3.4, _object["c.d"]);
+}
+
+TEST_F(JsonObject_Iterator_Test, ConstIterator) {
+  const JsonObject& const_object = _object;
+  JsonObject::const_iterator it = const_object.begin();
+
+  ASSERT_NE(const_object.end(), it);
+  EXPECT_STREQ("ab", it->key);
+  EXPECT_EQ(12, it->value);
+  ++it;
+  ASSERT_NE(const_object.end(), it);
+  EXPECT_STREQ("cd", it->key);
+  EXPECT_EQ(34, it->value);
+  ++it;
+  ASSERT_EQ(const_object.end(), it);
+}

test/JsonObject_PrettyPrintTo_Tests.cpp

@@ -0,0 +1,79 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonObject_PrettyPrintTo_Tests : public testing::Test {
+ public:
+  JsonObject_PrettyPrintTo_Tests() : _object(_jsonBuffer.createObject()) {}
+
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject &_object;
+
+  void outputMustBe(const char *expected) {
+    char buffer[256];
+
+    size_t actualLen = _object.prettyPrintTo(buffer, sizeof(buffer));
+    size_t measuredLen = _object.measurePrettyLength();
+
+    EXPECT_STREQ(expected, buffer);
+    EXPECT_EQ(strlen(expected), actualLen);
+    EXPECT_EQ(strlen(expected), measuredLen);
+  }
+};
+
+TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyObject) { outputMustBe("{}"); }
+
+TEST_F(JsonObject_PrettyPrintTo_Tests, OneMember) {
+  _object["key"] = "value";
+
+  outputMustBe(
+      "{\r\n"
+      "  \"key\": \"value\"\r\n"
+      "}");
+}
+
+TEST_F(JsonObject_PrettyPrintTo_Tests, TwoMembers) {
+  _object["key1"] = "value1";
+  _object["key2"] = "value2";
+
+  outputMustBe(
+      "{\r\n"
+      "  \"key1\": \"value1\",\r\n"
+      "  \"key2\": \"value2\"\r\n"
+      "}");
+}
+
+TEST_F(JsonObject_PrettyPrintTo_Tests, EmptyNestedContainers) {
+  _object.createNestedObject("key1");
+  _object.createNestedArray("key2");
+
+  outputMustBe(
+      "{\r\n"
+      "  \"key1\": {},\r\n"
+      "  \"key2\": []\r\n"
+      "}");
+}
+
+TEST_F(JsonObject_PrettyPrintTo_Tests, NestedContainers) {
+  JsonObject &nested1 = _object.createNestedObject("key1");
+  nested1["a"] = 1;
+
+  JsonArray &nested2 = _object.createNestedArray("key2");
+  nested2.add(2);
+
+  outputMustBe(
+      "{\r\n"
+      "  \"key1\": {\r\n"
+      "    \"a\": 1\r\n"
+      "  },\r\n"
+      "  \"key2\": [\r\n"
+      "    2\r\n"
+      "  ]\r\n"
+      "}");
+}

test/JsonObject_PrintTo_Tests.cpp

@@ -0,0 +1,141 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+using namespace ArduinoJson::Internals;
+
+class JsonObject_PrintTo_Tests : public testing::Test {
+ public:
+  JsonObject_PrintTo_Tests() : object(json.createObject()) {}
+
+ protected:
+  void outputMustBe(const char *expected) {
+    char actual[256];
+    size_t actualLen = object.printTo(actual, sizeof(actual));
+    size_t measuredLen = object.measureLength();
+
+    EXPECT_STREQ(expected, actual);
+    EXPECT_EQ(strlen(expected), actualLen);
+    EXPECT_EQ(strlen(expected), measuredLen);
+  }
+
+  StaticJsonBuffer<JSON_OBJECT_SIZE(2)> json;
+  JsonObject &object;
+};
+
+TEST_F(JsonObject_PrintTo_Tests, EmptyObject) { outputMustBe("{}"); }
+
+TEST_F(JsonObject_PrintTo_Tests, OneString) {
+  object["key"] = "value";
+
+  outputMustBe("{\"key\":\"value\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, TwoStrings) {
+  object["key1"] = "value1";
+  object["key2"] = "value2";
+
+  outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, RemoveFirst) {
+  object["key1"] = "value1";
+  object["key2"] = "value2";
+  object.remove("key1");
+
+  outputMustBe("{\"key2\":\"value2\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, RemoveLast) {
+  object["key1"] = "value1";
+  object["key2"] = "value2";
+  object.remove("key2");
+
+  outputMustBe("{\"key1\":\"value1\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, RemoveUnexistingKey) {
+  object["key1"] = "value1";
+  object["key2"] = "value2";
+  object.remove("key3");
+
+  outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, ReplaceExistingKey) {
+  object["key"] = "value1";
+  object["key"] = "value2";
+
+  outputMustBe("{\"key\":\"value2\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneStringOverCapacity) {
+  object["key1"] = "value1";
+  object["key2"] = "value2";
+  object["key3"] = "value3";
+
+  outputMustBe("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneInteger) {
+  object["key"] = 1;
+  outputMustBe("{\"key\":1}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneDoubleFourDigits) {
+  object["key"].set(3.14159265358979323846, 4);
+  outputMustBe("{\"key\":3.1416}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneDoubleDefaultDigits) {
+  object["key"] = 3.14159265358979323846;
+  outputMustBe("{\"key\":3.14}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneNull) {
+  object["key"] = static_cast<char *>(0);
+  outputMustBe("{\"key\":null}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneTrue) {
+  object["key"] = true;
+  outputMustBe("{\"key\":true}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneFalse) {
+  object["key"] = false;
+  outputMustBe("{\"key\":false}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedArrayViaProxy) {
+  JsonArray &nestedArray = json.createArray();
+
+  object["key"] = nestedArray;
+
+  outputMustBe("{\"key\":[]}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedObjectViaProxy) {
+  JsonObject &nestedArray = json.createObject();
+
+  object["key"] = nestedArray;
+
+  outputMustBe("{\"key\":{}}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedObject) {
+  object.createNestedObject("key");
+
+  outputMustBe("{\"key\":{}}");
+}
+
+TEST_F(JsonObject_PrintTo_Tests, OneEmptyNestedArray) {
+  object.createNestedArray("key");
+
+  outputMustBe("{\"key\":[]}");
+}

test/JsonParser_Array_Tests.cpp

@@ -0,0 +1,164 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonParser_Array_Tests : public testing::Test {
+ protected:
+  void whenInputIs(const char *json) {
+    strcpy(_jsonString, json);
+    _array = &_jsonBuffer.parseArray(_jsonString);
+  }
+
+  void parseMustSucceed() { EXPECT_TRUE(_array->success()); }
+
+  void parseMustFail() {
+    EXPECT_FALSE(_array->success());
+    EXPECT_EQ(0, _array->size());
+  }
+
+  void sizeMustBe(int expected) { ASSERT_EQ(expected, _array->size()); }
+
+  template <typename T>
+  void firstElementMustBe(T expected) {
+    elementAtIndexMustBe(0, expected);
+  }
+
+  template <typename T>
+  void secondElementMustBe(T expected) {
+    elementAtIndexMustBe(1, expected);
+  }
+
+  template <typename T>
+  void elementAtIndexMustBe(int index, T expected) {
+    EXPECT_EQ(expected, _array->at(index).as<T>());
+  }
+
+  void elementAtIndexMustBe(int index, const char *expected) {
+    EXPECT_STREQ(expected, _array->at(index).as<const char *>());
+  }
+
+  DynamicJsonBuffer _jsonBuffer;
+  JsonArray *_array;
+  char _jsonString[256];
+};
+
+TEST_F(JsonParser_Array_Tests, EmptyArray) {
+  whenInputIs("[]");
+
+  parseMustSucceed();
+  sizeMustBe(0);
+}
+
+TEST_F(JsonParser_Array_Tests, MissingOpeningBracket) {
+  whenInputIs("]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, ArrayWithNoEnd) {
+  whenInputIs("[");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, EmptyArrayWithLeadingSpaces) {
+  whenInputIs("  []");
+
+  parseMustSucceed();
+  sizeMustBe(0);
+}
+
+TEST_F(JsonParser_Array_Tests, Garbage) {
+  whenInputIs("%*$£¤");
+
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, OneInteger) {
+  whenInputIs("[42]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe(42);
+}
+
+TEST_F(JsonParser_Array_Tests, OneIntegerWithSpacesBefore) {
+  whenInputIs("[ \t\r\n42]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe(42);
+}
+
+TEST_F(JsonParser_Array_Tests, OneIntegerWithSpaceAfter) {
+  whenInputIs("[42 \t\r\n]");
+
+  parseMustSucceed();
+  sizeMustBe(1);
+  firstElementMustBe(42);
+}
+
+TEST_F(JsonParser_Array_Tests, TwoIntegers) {
+  whenInputIs("[42,84]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe(42);
+  secondElementMustBe(84);
+}
+
+TEST_F(JsonParser_Array_Tests, TwoDoubles) {
+  whenInputIs("[4.2,1e2]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe(4.2);
+  secondElementMustBe(1e2);
+}
+
+TEST_F(JsonParser_Array_Tests, TwoBooleans) {
+  whenInputIs("[true,false]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe(true);
+  secondElementMustBe(false);
+}
+
+TEST_F(JsonParser_Array_Tests, TwoNulls) {
+  const char *const nullCharPtr = 0;
+
+  whenInputIs("[null,null]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe(nullCharPtr);
+  secondElementMustBe(nullCharPtr);
+}
+
+TEST_F(JsonParser_Array_Tests, IncompleteNull) {
+  whenInputIs("[nul!]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, IncompleteTrue) {
+  whenInputIs("[tru!]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, IncompleteFalse) {
+  whenInputIs("[fals!]");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Array_Tests, TwoStrings) {
+  whenInputIs("[\"hello\",\"world\"]");
+
+  parseMustSucceed();
+  sizeMustBe(2);
+  firstElementMustBe("hello");
+  secondElementMustBe("world");
+}

test/JsonParser_Nested_Tests.cpp

@@ -0,0 +1,54 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+TEST(JsonParser_Nested_Tests, ArrayNestedInObject) {
+  DynamicJsonBuffer jsonBuffer;
+  char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } ";
+
+  JsonObject &object = jsonBuffer.parseObject(jsonString);
+  JsonArray &array1 = object["ab"];
+  JsonArray &array2 = object["cd"];
+
+  ASSERT_TRUE(object.success());
+
+  ASSERT_TRUE(array1.success());
+  ASSERT_TRUE(array2.success());
+
+  ASSERT_EQ(2, array1.size());
+  ASSERT_EQ(2, array2.size());
+
+  EXPECT_EQ(1, array1[0].as<int>());
+  EXPECT_EQ(2, array1[1].as<int>());
+
+  EXPECT_EQ(3, array2[0].as<int>());
+  EXPECT_EQ(4, array2[1].as<int>());
+}
+
+TEST(JsonParser_Nested_Tests, ObjectNestedInArray) {
+  DynamicJsonBuffer jsonBuffer;
+  char jsonString[] =
+      " [ { \"a\" : 1 , \"b\" : 2 } , { \"c\" : 3 , \"d\" : 4 } ] ";
+
+  JsonArray &array = jsonBuffer.parseArray(jsonString);
+  JsonObject &object1 = array[0];
+  JsonObject &object2 = array[1];
+
+  ASSERT_TRUE(array.success());
+
+  ASSERT_TRUE(object1.success());
+  ASSERT_TRUE(object2.success());
+
+  ASSERT_EQ(2, object1.size());
+  ASSERT_EQ(2, object2.size());
+
+  EXPECT_EQ(1, object1["a"].as<int>());
+  EXPECT_EQ(2, object1["b"].as<int>());
+  EXPECT_EQ(3, object2["c"].as<int>());
+  EXPECT_EQ(4, object2["d"].as<int>());
+}

test/JsonParser_NestingLimit_Tests.cpp

@@ -0,0 +1,84 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonParser_NestingLimit_Tests : public testing::Test {
+ protected:
+  void whenNestingLimitIs(uint8_t nestingLimit) {
+    _nestingLimit = nestingLimit;
+  }
+
+  void parseArrayMustFail(const char *json) {
+    ASSERT_FALSE(tryParseArray(json));
+  }
+
+  void parseArrayMustSucceed(const char *json) {
+    ASSERT_TRUE(tryParseArray(json));
+  }
+
+  void parseObjectMustFail(const char *json) {
+    ASSERT_FALSE(tryParseObject(json));
+  }
+
+  void parseObjectMustSucceed(const char *json) {
+    ASSERT_TRUE(tryParseObject(json));
+  }
+
+ private:
+  bool tryParseArray(const char *json) {
+    DynamicJsonBuffer buffer;
+    char s[256];
+    strcpy(s, json);
+    return buffer.parseArray(s, _nestingLimit).success();
+  }
+
+  bool tryParseObject(const char *json) {
+    DynamicJsonBuffer buffer;
+    char s[256];
+    strcpy(s, json);
+    return buffer.parseObject(s, _nestingLimit).success();
+  }
+
+  uint8_t _nestingLimit;
+};
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit0) {
+  whenNestingLimitIs(0);
+  parseArrayMustSucceed("[]");
+  parseArrayMustFail("[[]]");
+}
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit1) {
+  whenNestingLimitIs(1);
+  parseArrayMustSucceed("[[]]");
+  parseArrayMustFail("[[[]]]");
+}
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseArrayWithNestingLimit2) {
+  whenNestingLimitIs(2);
+  parseArrayMustSucceed("[[[]]]");
+  parseArrayMustFail("[[[[]]]]");
+}
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit0) {
+  whenNestingLimitIs(0);
+  parseObjectMustSucceed("{}");
+  parseObjectMustFail("{\"key\":{}}");
+}
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit1) {
+  whenNestingLimitIs(1);
+  parseObjectMustSucceed("{\"key\":{}}");
+  parseObjectMustFail("{\"key\":{\"key\":{}}}");
+}
+
+TEST_F(JsonParser_NestingLimit_Tests, ParseObjectWithNestingLimit2) {
+  whenNestingLimitIs(2);
+  parseObjectMustSucceed("{\"key\":{\"key\":{}}}");
+  parseObjectMustFail("{\"key\":{\"key\":{\"key\":{}}}}");
+}

test/JsonParser_Object_Tests.cpp

@@ -0,0 +1,173 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonParser_Object_Test : public testing::Test {
+ protected:
+  void whenInputIs(const char *jsonString) {
+    strcpy(_jsonString, jsonString);
+    _object = &_jsonBuffer.parseObject(_jsonString);
+  }
+
+  void parseMustSucceed() { EXPECT_TRUE(_object->success()); }
+
+  void parseMustFail() { EXPECT_FALSE(_object->success()); }
+
+  void sizeMustBe(int expected) { EXPECT_EQ(expected, _object->size()); }
+
+  void keyMustHaveValue(const char *key, const char *expected) {
+    EXPECT_STREQ(expected, _object->at(key).as<const char *>());
+  }
+
+  template <typename T>
+  void keyMustHaveValue(const char *key, T expected) {
+    EXPECT_EQ(expected, _object->at(key).as<T>());
+  }
+
+ private:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonObject *_object;
+  char _jsonString[256];
+};
+
+TEST_F(JsonParser_Object_Test, EmptyObject) {
+  whenInputIs("{}");
+  parseMustSucceed();
+  sizeMustBe(0);
+}
+
+TEST_F(JsonParser_Object_Test, MissingOpeningBrace) {
+  whenInputIs("}");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Object_Test, MissingClosingBrace) {
+  whenInputIs("{");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Object_Test, MissingColonAndValue) {
+  whenInputIs("{\"key\"}");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Object_Test, MissingQuotesAndColonAndValue) {
+  whenInputIs("{key}");
+  parseMustFail();
+}
+
+TEST_F(JsonParser_Object_Test, OneString) {
+  whenInputIs("{\"key\":\"value\"}");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, OneStringSingleQuotes) {
+  whenInputIs("{'key':'value'}");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, OneStringSpaceBeforeKey) {
+  whenInputIs("{ \"key\":\"value\"}");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, OneStringSpaceAfterKey) {
+  whenInputIs("{\"key\" :\"value\"}");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, OneStringSpaceBeforeValue) {
+  whenInputIs("{\"key\": \"value\"}");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, OneStringSpaceAfterValue) {
+  whenInputIs("{\"key\":\"value\" }");
+  parseMustSucceed();
+  sizeMustBe(1);
+  keyMustHaveValue("key", "value");
+}
+
+TEST_F(JsonParser_Object_Test, TwoStrings) {
+  whenInputIs("{\"key1\":\"value1\",\"key2\":\"value2\"}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", "value1");
+  keyMustHaveValue("key2", "value2");
+}
+
+TEST_F(JsonParser_Object_Test, TwoStringsSpaceBeforeComma) {
+  whenInputIs("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", "value1");
+  keyMustHaveValue("key2", "value2");
+}
+
+TEST_F(JsonParser_Object_Test, TwoStringsSpaceAfterComma) {
+  whenInputIs("{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", "value1");
+  keyMustHaveValue("key2", "value2");
+}
+
+TEST_F(JsonParser_Object_Test, EndingWithAComma) {
+  whenInputIs("{\"key1\":\"value1\",}");
+  parseMustFail();
+  sizeMustBe(0);
+}
+
+TEST_F(JsonParser_Object_Test, TwoIntergers) {
+  whenInputIs("{\"key1\":42,\"key2\":-42}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", 42);
+  keyMustHaveValue("key2", -42);
+}
+
+TEST_F(JsonParser_Object_Test, TwoDoubles) {
+  whenInputIs("{\"key1\":12.345,\"key2\":-7E89}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", 12.345);
+  keyMustHaveValue("key2", -7E89);
+}
+
+TEST_F(JsonParser_Object_Test, TwoBooleans) {
+  whenInputIs("{\"key1\":true,\"key2\":false}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", true);
+  keyMustHaveValue("key2", false);
+}
+
+TEST_F(JsonParser_Object_Test, TwoNulls) {
+  const char *const nullstr = 0;
+
+  whenInputIs("{\"key1\":null,\"key2\":null}");
+  parseMustSucceed();
+  sizeMustBe(2);
+  keyMustHaveValue("key1", nullstr);
+  keyMustHaveValue("key2", nullstr);
+}
+
+TEST_F(JsonParser_Object_Test, NullForKey) {
+  whenInputIs("null:\"value\"}");
+  parseMustFail();
+}

test/JsonVariant_Comparison_Tests.cpp

@@ -0,0 +1,96 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson/JsonVariant.hpp>
+#include "Printers.hpp"
+
+using namespace ArduinoJson;
+
+class JsonVariant_Comparison_Tests : public ::testing::Test {
+ protected:
+  template <typename T>
+  void testValue(T low, T mid, T high) {
+    setValueTo(mid);
+    mustBeEqualTo(mid);
+    mustBeGreaterThan(low);
+    mustBeLessThan(high);
+  }
+
+ private:
+  template <typename T>
+  void setValueTo(T expected) {
+    actual = expected;
+  }
+
+  template <typename T>
+  void mustBeEqualTo(T expected) {
+    EXPECT_EQ(expected, actual);  // operator==
+    EXPECT_EQ(actual, expected);  // operator==
+    EXPECT_LE(expected, actual);  // operator<=
+    EXPECT_LE(actual, expected);  // operator<=
+    EXPECT_GE(expected, actual);  // operator>=
+    EXPECT_GE(actual, expected);  // operator>=
+  }
+
+  template <typename T>
+  void mustBeGreaterThan(T expected) {
+    EXPECT_GT(actual, expected);  // operator>
+    EXPECT_LT(expected, actual);  // operator<
+    EXPECT_NE(actual, expected);  // operator!=
+    EXPECT_NE(expected, actual);  // operator!=
+  }
+
+  template <typename T>
+  void mustBeLessThan(T expected) {
+    EXPECT_LT(actual, expected);  // operator<
+    EXPECT_GT(expected, actual);  // operator<
+    EXPECT_NE(actual, expected);  // operator!=
+    EXPECT_NE(expected, actual);  // operator!=
+  }
+
+  JsonVariant actual;
+};
+
+TEST_F(JsonVariant_Comparison_Tests, Double) {
+  testValue<double>(123.44, 123.45, 123.46);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, Float) {
+  testValue<float>(123.44f, 123.45f, 123.46f);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SChar) {
+  testValue<signed char>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SInt) {
+  testValue<signed int>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SLong) {
+  testValue<signed long>(122L, 123L, 124L);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, SShort) {
+  testValue<signed short>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UChar) {
+  testValue<unsigned char>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UInt) {
+  testValue<unsigned int>(122, 123, 124);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, ULong) {
+  testValue<unsigned long>(122L, 123L, 124L);
+}
+
+TEST_F(JsonVariant_Comparison_Tests, UShort) {
+  testValue<unsigned short>(122, 123, 124);
+}

test/JsonVariant_Copy_Tests.cpp

@@ -0,0 +1,67 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonVariant_Copy_Tests : public ::testing::Test {
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _variant1;
+  JsonVariant _variant2;
+};
+
+TEST_F(JsonVariant_Copy_Tests, IntegersAreCopiedByValue) {
+  _variant1 = 123;
+  _variant2 = _variant1;
+  _variant1 = 456;
+
+  EXPECT_EQ(123, _variant2.as<int>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, DoublesAreCopiedByValue) {
+  _variant1 = 123.45;
+  _variant2 = _variant1;
+  _variant1 = 456.78;
+
+  EXPECT_EQ(123.45, _variant2.as<double>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, BooleansAreCopiedByValue) {
+  _variant1 = true;
+  _variant2 = _variant1;
+  _variant1 = false;
+
+  EXPECT_TRUE(_variant2.as<bool>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, StringsAreCopiedByValue) {
+  _variant1 = "hello";
+  _variant2 = _variant1;
+  _variant1 = "world";
+
+  EXPECT_STREQ("hello", _variant2.as<const char *>());
+}
+
+TEST_F(JsonVariant_Copy_Tests, ObjectsAreCopiedByReference) {
+  JsonObject &object = _jsonBuffer.createObject();
+
+  _variant1 = object;
+
+  object["hello"] = "world";
+
+  EXPECT_EQ(1, _variant1.asObject().size());
+}
+
+TEST_F(JsonVariant_Copy_Tests, ArraysAreCopiedByReference) {
+  JsonArray &array = _jsonBuffer.createArray();
+
+  _variant1 = array;
+
+  array.add("world");
+
+  EXPECT_EQ(1, _variant1.asArray().size());
+}

test/JsonVariant_Invalid_Tests.cpp

@@ -0,0 +1,75 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+#include "Printers.hpp"
+
+class JsonVariant_Invalid_Tests : public ::testing::Test {
+ public:
+  JsonVariant_Invalid_Tests() : variant(JsonVariant::invalid()) {}
+
+ protected:
+  JsonVariant variant;
+};
+
+TEST_F(JsonVariant_Invalid_Tests, SuccessReturnsFalse) {
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsLongReturns0) {
+  EXPECT_EQ(0, variant.as<long>());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsStringReturnsNull) {
+  EXPECT_EQ(0, variant.asString());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsDoubleReturns0) {
+  EXPECT_EQ(0, variant.as<double>());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsBoolReturnsFalse) {
+  EXPECT_FALSE(variant.as<bool>());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsArrayReturnInvalid) {
+  EXPECT_EQ(JsonArray::invalid(), variant.asArray());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, AsObjectReturnInvalid) {
+  EXPECT_EQ(JsonObject::invalid(), variant.asObject());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToLong) {
+  variant = 0L;
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToDouble) {
+  variant = 0.0;
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToString) {
+  variant = static_cast<const char*>(NULL);
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToBool) {
+  variant = false;
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToArray) {
+  variant = JsonArray::invalid();
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Invalid_Tests, CanNotBeSetToObject) {
+  variant = JsonObject::invalid();
+  EXPECT_FALSE(variant.success());
+}

test/JsonVariant_PrintTo_Tests.cpp

@@ -0,0 +1,72 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonVariant_PrintTo_Tests : public testing::Test {
+ protected:
+  JsonVariant variant;
+
+  void outputMustBe(const char *expected) {
+    char buffer[256] = "";
+    size_t n = variant.printTo(buffer, sizeof(buffer));
+    EXPECT_STREQ(expected, buffer);
+    EXPECT_EQ(strlen(expected), n);
+  }
+};
+
+TEST_F(JsonVariant_PrintTo_Tests, Empty) { outputMustBe(""); }
+
+TEST_F(JsonVariant_PrintTo_Tests, Null) {
+  variant = static_cast<char *>(0);
+  outputMustBe("null");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, String) {
+  variant = "hello";
+  outputMustBe("\"hello\"");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleZero) {
+  variant = 0.0;
+  outputMustBe("0.00");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleDefaultDigits) {
+  variant = 3.14159265358979323846;
+  outputMustBe("3.14");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, DoubleFourDigits) {
+  variant.set(3.14159265358979323846, 4);
+  outputMustBe("3.1416");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Integer) {
+  variant = 42;
+  outputMustBe("42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Long) {
+  variant = 42L;
+  outputMustBe("42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, Char) {
+  variant = '*';
+  outputMustBe("42");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, True) {
+  variant = true;
+  outputMustBe("true");
+}
+
+TEST_F(JsonVariant_PrintTo_Tests, OneFalse) {
+  variant = false;
+  outputMustBe("false");
+}

test/JsonVariant_Storage_Tests.cpp

@@ -0,0 +1,48 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonVariant_Storage_Tests : public ::testing::Test {
+ protected:
+  template <typename T>
+  void testValue(T expected) {
+    _actual.set(expected);
+    EXPECT_EQ(expected, _actual.as<T>());
+  }
+
+  template <typename T>
+  void testReference(T &expected) {
+    _actual.set(expected);
+    EXPECT_EQ(expected, _actual.as<T &>());
+  }
+
+ private:
+  JsonVariant _actual;
+};
+
+TEST_F(JsonVariant_Storage_Tests, Double) { testValue<double>(123.45); }
+TEST_F(JsonVariant_Storage_Tests, False) { testValue<bool>(false); }
+TEST_F(JsonVariant_Storage_Tests, Float) { testValue<float>(123.45f); }
+TEST_F(JsonVariant_Storage_Tests, Null) { testValue<const char *>(NULL); }
+TEST_F(JsonVariant_Storage_Tests, SChar) { testValue<signed char>(123); }
+TEST_F(JsonVariant_Storage_Tests, SInt) { testValue<signed int>(123); }
+TEST_F(JsonVariant_Storage_Tests, SLong) { testValue<signed long>(123L); }
+TEST_F(JsonVariant_Storage_Tests, SShort) { testValue<signed short>(123); }
+TEST_F(JsonVariant_Storage_Tests, String) { testValue<const char *>("hello"); }
+TEST_F(JsonVariant_Storage_Tests, True) { testValue<bool>(true); }
+TEST_F(JsonVariant_Storage_Tests, UChar) { testValue<unsigned char>(123); }
+TEST_F(JsonVariant_Storage_Tests, UInt) { testValue<unsigned int>(123U); }
+TEST_F(JsonVariant_Storage_Tests, ULong) { testValue<unsigned long>(123UL); }
+TEST_F(JsonVariant_Storage_Tests, UShort) { testValue<unsigned short>(123); }
+
+TEST_F(JsonVariant_Storage_Tests, CanStoreObject) {
+  DynamicJsonBuffer jsonBuffer;
+  JsonObject &object = jsonBuffer.createObject();
+
+  testReference(object);
+}

test/JsonVariant_Subscript_Tests.cpp

@@ -0,0 +1,64 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+
+class JsonVariant_Subscript_Tests : public ::testing::Test {
+ protected:
+  DynamicJsonBuffer _jsonBuffer;
+  JsonVariant _variant;
+};
+
+TEST_F(JsonVariant_Subscript_Tests, Array) {
+  JsonArray &array = _jsonBuffer.createArray();
+  array.add("element at index 0");
+  array.add("element at index 1");
+
+  _variant = array;
+
+  EXPECT_EQ(2, _variant.size());
+  EXPECT_STREQ("element at index 0", _variant[0].asString());
+  EXPECT_STREQ("element at index 1", _variant[1].asString());
+  EXPECT_FALSE(_variant[-1].success());
+  EXPECT_FALSE(_variant[3].success());
+  EXPECT_FALSE(_variant["0"].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, Object) {
+  JsonObject &object = _jsonBuffer.createObject();
+  object["a"] = "element at key \"a\"";
+  object["b"] = "element at key \"b\"";
+
+  _variant = object;
+
+  EXPECT_EQ(2, _variant.size());
+  EXPECT_STREQ("element at key \"a\"", _variant["a"].asString());
+  EXPECT_STREQ("element at key \"b\"", _variant["b"].asString());
+  EXPECT_FALSE(_variant["c"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, Undefined) {
+  _variant = JsonVariant();
+  EXPECT_EQ(0, _variant.size());
+  EXPECT_FALSE(_variant["0"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, Invalid) {
+  _variant = JsonVariant::invalid();
+  EXPECT_EQ(0, _variant.size());
+  EXPECT_FALSE(_variant["0"].success());
+  EXPECT_FALSE(_variant[0].success());
+}
+
+TEST_F(JsonVariant_Subscript_Tests, String) {
+  _variant = "hello world";
+  EXPECT_EQ(0, _variant.size());
+  EXPECT_FALSE(_variant["0"].success());
+  EXPECT_FALSE(_variant[0].success());
+}

test/JsonVariant_Undefined_Tests.cpp

@@ -0,0 +1,74 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson.h>
+#include "Printers.hpp"
+
+class JsonVariant_Undefined_Tests : public ::testing::Test {
+ protected:
+  JsonVariant variant;
+};
+
+TEST_F(JsonVariant_Undefined_Tests, SuccessReturnsFalse) {
+  EXPECT_FALSE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsLongReturns0) {
+  EXPECT_EQ(0, variant.as<long>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsStringReturnsNull) {
+  EXPECT_EQ(0, variant.asString());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsDoubleReturns0) {
+  EXPECT_EQ(0, variant.as<double>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsBoolReturnsFalse) {
+  EXPECT_FALSE(variant.as<bool>());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsArrayReturnInvalid) {
+  EXPECT_EQ(JsonArray::invalid(), variant.asArray());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, AsObjectReturnInvalid) {
+  EXPECT_EQ(JsonObject::invalid(), variant.asObject());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToLong) {
+  variant = 0L;
+  EXPECT_TRUE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToDouble) {
+  variant = 0.0;
+  EXPECT_TRUE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToString) {
+  variant = static_cast<const char*>(NULL);
+  EXPECT_TRUE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToBool) {
+  variant = false;
+  EXPECT_TRUE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToArray) {
+  DynamicJsonBuffer jsonBuffer;
+  variant = jsonBuffer.createArray();
+  EXPECT_TRUE(variant.success());
+}
+
+TEST_F(JsonVariant_Undefined_Tests, CanBeSetToObject) {
+  DynamicJsonBuffer jsonBuffer;
+  variant = jsonBuffer.createObject();
+  EXPECT_TRUE(variant.success());
+}

test/Printers.cpp

@@ -0,0 +1,38 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include "Printers.hpp"
+#include <ArduinoJson/JsonArray.hpp>
+
+class StreamPrintAdapter : public Print {
+ public:
+  explicit StreamPrintAdapter(std::ostream& os) : _os(os) {}
+
+  virtual size_t write(uint8_t c) {
+    _os << static_cast<char>(c);
+    return 1;
+  }
+
+ private:
+  // cannot be assigned
+  StreamPrintAdapter& operator=(const StreamPrintAdapter&);
+
+  std::ostream& _os;
+};
+
+std::ostream& ArduinoJson::operator<<(std::ostream& os,
+                                      const ArduinoJson::JsonVariant& v) {
+  StreamPrintAdapter adapter(os);
+  v.printTo(adapter);
+  return os;
+}
+
+std::ostream& ArduinoJson::operator<<(std::ostream& os,
+                                      const ArduinoJson::JsonArray& v) {
+  StreamPrintAdapter adapter(os);
+  v.printTo(adapter);
+  return os;
+}

test/Printers.hpp

@@ -0,0 +1,15 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#pragma once
+
+#include <ArduinoJson/JsonVariant.hpp>
+#include <ostream>
+
+namespace ArduinoJson {
+std::ostream& operator<<(std::ostream& os, const ArduinoJson::JsonVariant& v);
+std::ostream& operator<<(std::ostream& os, const ArduinoJson::JsonArray& v);
+}

test/QuotedString_ExtractFrom_Tests.cpp

@@ -0,0 +1,136 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+#include <ArduinoJson/Internals/QuotedString.hpp>
+
+using namespace ArduinoJson::Internals;
+
+class QuotedString_ExtractFrom_Tests : public testing::Test {
+ protected:
+  void whenInputIs(const char *json) {
+    strcpy(_jsonString, json);
+    _result = QuotedString::extractFrom(_jsonString, &_trailing);
+  }
+
+  void resultMustBe(const char *expected) { EXPECT_STREQ(expected, _result); }
+
+  void trailingMustBe(const char *expected) {
+    EXPECT_STREQ(expected, _trailing);
+  }
+
+ private:
+  char _jsonString[256];
+  char *_result;
+  char *_trailing;
+};
+
+TEST_F(QuotedString_ExtractFrom_Tests, EmptyDoubleQuotedString) {
+  whenInputIs("\"\"");
+
+  resultMustBe("");
+  trailingMustBe("");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, NoQuotes) {
+  whenInputIs("hello world");
+
+  resultMustBe(0);
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, MissingClosingQuote) {
+  whenInputIs("\"hello world");
+
+  resultMustBe(0);
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EmptySingleQuotedString) {
+  whenInputIs("''");
+
+  resultMustBe("");
+  trailingMustBe("");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, SimpleDoubleQuotedString) {
+  whenInputIs("\"hello world\"");
+
+  resultMustBe("hello world");
+  trailingMustBe("");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, DoubleQuotedStringWithTrailing) {
+  whenInputIs("\"hello\" world");
+
+  resultMustBe("hello");
+  trailingMustBe(" world");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, SingleQuotedStringWithTrailing) {
+  whenInputIs("'hello' world");
+
+  resultMustBe("hello");
+  trailingMustBe(" world");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, CurlyBraces) {
+  whenInputIs("\"{hello:world}\"");
+  resultMustBe("{hello:world}");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, SquareBraquets) {
+  whenInputIs("\"[hello,world]\"");
+  resultMustBe("[hello,world]");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedDoubleQuote) {
+  whenInputIs("\"hello \\\"world\\\"\"");
+  resultMustBe("hello \"world\"");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedSingleQuote) {
+  whenInputIs("\"hello \\\'world\\\'\"");
+  resultMustBe("hello 'world'");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedSolidus) {
+  whenInputIs("\"hello \\/world\\/\"");
+  resultMustBe("hello /world/");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedReverseSolidus) {
+  whenInputIs("\"hello \\\\world\\\\\"");
+  resultMustBe("hello \\world\\");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedBackspace) {
+  whenInputIs("\"hello \\bworld\\b\"");
+  resultMustBe("hello \bworld\b");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedFormfeed) {
+  whenInputIs("\"hello \\fworld\\f\"");
+  resultMustBe("hello \fworld\f");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedNewline) {
+  whenInputIs("\"hello \\nworld\\n\"");
+  resultMustBe("hello \nworld\n");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedCarriageReturn) {
+  whenInputIs("\"hello \\rworld\\r\"");
+  resultMustBe("hello \rworld\r");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, EscapedTab) {
+  whenInputIs("\"hello \\tworld\\t\"");
+  resultMustBe("hello \tworld\t");
+}
+
+TEST_F(QuotedString_ExtractFrom_Tests, AllEscapedCharsTogether) {
+  whenInputIs("\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"");
+  resultMustBe("1\"2\\3/4\b5\f6\n7\r8\t9");
+}

test/QuotedString_PrintTo_Tests.cpp

@@ -0,0 +1,79 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+
+#include <ArduinoJson/Internals/QuotedString.hpp>
+#include <ArduinoJson/Internals/StringBuilder.hpp>
+
+using namespace ArduinoJson::Internals;
+
+class QuotedString_PrintTo_Tests : public testing::Test {
+ protected:
+  void whenInputIs(const char *input) {
+    StringBuilder sb(buffer, sizeof(buffer));
+    returnValue = QuotedString::printTo(input, sb);
+  }
+
+  void outputMustBe(const char *expected) {
+    EXPECT_STREQ(expected, buffer);
+    EXPECT_EQ(strlen(expected), returnValue);
+  }
+
+ private:
+  char buffer[1024];
+  size_t returnValue;
+};
+
+TEST_F(QuotedString_PrintTo_Tests, Null) {
+  whenInputIs(0);
+  outputMustBe("null");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, EmptyString) {
+  whenInputIs("");
+  outputMustBe("\"\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, QuotationMark) {
+  whenInputIs("\"");
+  outputMustBe("\"\\\"\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, ReverseSolidus) {
+  whenInputIs("\\");
+  outputMustBe("\"\\\\\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, Solidus) {
+  whenInputIs("/");
+  outputMustBe("\"/\"");  // but the JSON format allows \/
+}
+
+TEST_F(QuotedString_PrintTo_Tests, Backspace) {
+  whenInputIs("\b");
+  outputMustBe("\"\\b\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, Formfeed) {
+  whenInputIs("\f");
+  outputMustBe("\"\\f\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, Newline) {
+  whenInputIs("\n");
+  outputMustBe("\"\\n\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, CarriageReturn) {
+  whenInputIs("\r");
+  outputMustBe("\"\\r\"");
+}
+
+TEST_F(QuotedString_PrintTo_Tests, HorizontalTab) {
+  whenInputIs("\t");
+  outputMustBe("\"\\t\"");
+}

test/StaticJsonBuffer_Basic_Tests.cpp

@@ -0,0 +1,59 @@
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+
+#include <gtest/gtest.h>
+
+#define protected public
+#include <ArduinoJson/StaticJsonBuffer.hpp>
+
+using namespace ArduinoJson;
+
+class StaticJsonBuffer_Basic_Tests : public testing::Test {
+ protected:
+  StaticJsonBuffer<42> buffer;
+};
+
+TEST_F(StaticJsonBuffer_Basic_Tests, CapacityMatchTemplateParameter) {
+  ASSERT_EQ(42, buffer.capacity());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, InitialSizeIsZero) {
+  ASSERT_EQ(0, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, GrowsAfterAlloc) {
+  buffer.alloc(1);
+  ASSERT_EQ(1, buffer.size());
+  buffer.alloc(1);
+  ASSERT_EQ(2, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenFull) {
+  buffer.alloc(42);
+  buffer.alloc(1);
+  ASSERT_EQ(42, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, DoesntGrowWhenTooSmall) {
+  buffer.alloc(43);
+  ASSERT_EQ(0, buffer.size());
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNonNull) {
+  void *p = buffer.alloc(42);
+  ASSERT_NE(static_cast<void *>(0), p);
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenFull) {
+  buffer.alloc(42);
+  void *p = buffer.alloc(1);
+  ASSERT_EQ(NULL, p);
+}
+
+TEST_F(StaticJsonBuffer_Basic_Tests, ReturnsNullWhenTooSmall) {
+  void *p = buffer.alloc(43);
+  ASSERT_EQ(NULL, p);
+}