Fixed GCC warning "declaration shadows a member" (issue #103)

Fix typo in Readme & clean file

CHANGELOG.md

@@ -1,8 +1,23 @@
 ArduinoJson: change log
 =======================
 
-v5.0 (currently in beta)
-----
+v5.0.2
+------
+
+* Fixed segmentation fault in `parseObject(String)` and `parseArray(String)`, when the 
+  `StaticJsonBuffer` is too small to hold a copy of the string
+* Fixed Clang warning "register specifier is deprecated" (issue #102)
+* Fixed GCC warning "declaration shadows a member" (issue #103)
+* Fixed memory alignment, which made ESP8266 crash (issue #104)
+* Fixed compilation on Visual Studio 2010 and 2012 (issue #107)
+
+v5.0.1
+------
+
+* Fixed compilation with Arduino 1.0.6 (issue #99)
+
+v5.0.0
+------
 
 * Added support of `String` class (issues #55, #56, #70, #77)
 * Added `JsonBuffer::strdup()` to make a copy of a string (issues #10, #57)

LICENSE.md

@@ -1,10 +1,10 @@
 The MIT License (MIT)
 ---------------------
 
-Copyright © 2014 Benoit BLANCHON
+Copyright © 2014-2015 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.
+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,11 +1,11 @@
 Arduino JSON library
 ====================
 
-[![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master)
+[![Build status](https://ci.appveyor.com/api/projects/status/m7s53wav1l0abssg/branch/master?svg=true)](https://ci.appveyor.com/project/bblanchon/arduinojson/branch/master) [![Build Status](https://travis-ci.org/bblanchon/ArduinoJson.svg?branch=master)](https://travis-ci.org/bblanchon/ArduinoJson) [![Coverage Status](https://img.shields.io/coveralls/bblanchon/ArduinoJson.svg)](https://coveralls.io/r/bblanchon/ArduinoJson?branch=master) 
 
 *An elegant and efficient JSON library for embedded systems.*
 
-It's design to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
+It's designed to have the most intuitive API, the smallest footprint and works without any allocation on the heap (no malloc).
 
 It has been written with Arduino in mind, but it isn't linked to Arduino libraries so you can use this library in any other C++ project.
 
@@ -14,7 +14,7 @@ Features
 
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
-* Elegant API, very easy to use 
+* Elegant API, very easy to use
 * Efficient (no malloc, nor copy)
 * Portable (written in C++98)
 * Self-contained (no external dependency)
@@ -25,7 +25,7 @@ Quick start
 -----------
 
 #### Decoding / Parsing
-   
+
     char json[] = "{\"sensor\":\"gps\",\"time\":1351824120,\"data\":[48.756080,2.302038]}";
 
     StaticJsonBuffer<200> jsonBuffer;
@@ -38,7 +38,7 @@ Quick start
     double longitude   = root["data"][1];
 
 #### Encoding / Generating
-   
+
     StaticJsonBuffer<200> jsonBuffer;
 
     JsonObject& root = jsonBuffer.createObject();
@@ -57,13 +57,13 @@ Quick start
 Documentation
 -------------
 
-The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki) 
+The documentation is available online in the [Arduino JSON wiki](https://github.com/bblanchon/ArduinoJson/wiki)
 
 Testimonials
 ------------
 
 From Arduino's Forum user `jflaplante`:
-> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while. 
+> I tried aJson json-arduino before trying your library. I always ran into memory problem after a while.
 > I have no such problem so far with your library. It is working perfectly with my web services.
 
 From Arduino's Forum user `gbathree`:
@@ -80,4 +80,4 @@ From GitHub user `zacsketches`:
 
 ---
 
-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:
+Found this library useful? Please star this project or [help me back with a donation!](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=donate%40benoitblanchon%2efr&lc=GB&item_name=Benoit%20Blanchon&item_number=Arduino%20JSON&currency_code=EUR&bn=PP%2dDonationsBF%3abtn_donate_LG%2egif%3aNonHosted) :smile:

examples/IndentedPrintExample/IndentedPrintExample.ino

@@ -1,7 +1,8 @@
-/*
- * Arduino JSON library - IndentedPrint example
- * Benoit Blanchon 2014 - MIT License
- */
+// Copyright Benoit Blanchon 2014-2015
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
 
 #include <ArduinoJson.h>
 
@@ -27,4 +28,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

examples/JsonGeneratorExample/JsonGeneratorExample.ino

@@ -1,4 +1,4 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2015
 // MIT License
 //
 // Arduino JSON library
@@ -39,4 +39,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

examples/JsonParserExample/JsonParserExample.ino

@@ -1,4 +1,4 @@
-// Copyright Benoit Blanchon 2014
+// Copyright Benoit Blanchon 2014-2015
 // MIT License
 //
 // Arduino JSON library
@@ -34,4 +34,4 @@ void setup() {
 
 void loop() {
   // not used in this example
-}
+}

include/ArduinoJson/Arduino/String.hpp

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

include/ArduinoJson/Internals/BlockJsonBuffer.hpp

@@ -63,7 +63,7 @@ class BlockJsonBuffer : public JsonBuffer {
 
   void* allocInHead(size_t bytes) {
     void* p = _head->data + _head->size;
-    _head->size += bytes;
+    _head->size += round_size_up(bytes);
     return p;
   }
 
@@ -76,8 +76,8 @@ class BlockJsonBuffer : public JsonBuffer {
   }
 
   bool addNewBlock(size_t capacity) {
-    size_t size = sizeof(EmptyBlock) + capacity;
-    Block* block = static_cast<Block*>(_allocator.allocate(size));
+    size_t bytes = sizeof(EmptyBlock) + capacity;
+    Block* block = static_cast<Block*>(_allocator.allocate(bytes));
     if (block == NULL) return false;
     block->capacity = capacity;
     block->size = 0;

include/ArduinoJson/Internals/DynamicStringBuilder.hpp

@@ -23,6 +23,8 @@ class DynamicStringBuilder : public Print {
   }
 
  private:
+  DynamicStringBuilder &operator=(const DynamicStringBuilder &);
+
   String &_str;
 };
 }

include/ArduinoJson/Internals/JsonParser.hpp

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

include/ArduinoJson/Internals/JsonWriter.hpp

@@ -8,6 +8,7 @@
 
 #include "../Arduino/Print.hpp"
 #include "Encoding.hpp"
+#include "ForceInline.hpp"
 
 namespace ArduinoJson {
 namespace Internals {
@@ -69,7 +70,7 @@ class JsonWriter {
 
  protected:
   void write(char c) { _length += _sink.write(c); }
-  void write(const char *s) { _length += _sink.print(s); }
+  FORCE_INLINE void write(const char *s) { _length += _sink.print(s); }
 
   Print &_sink;
   size_t _length;

include/ArduinoJson/JsonArraySubscript.hpp

@@ -14,14 +14,7 @@ class JsonArraySubscript : public JsonSubscriptBase<JsonArraySubscript> {
   FORCE_INLINE JsonArraySubscript(JsonArray& array, size_t index)
       : _array(array), _index(index) {}
 
-  using JsonSubscriptBase::operator=;
-
-  FORCE_INLINE JsonArraySubscript& operator=(const JsonArraySubscript& other) {
-    // to prevent Visual Studio warning C4512: assignment operator could not be
-    // generated
-    _array.set(_index, other._array.get(other._index));
-    return *this;
-  }
+  using JsonSubscriptBase<JsonArraySubscript>::operator=;
 
   FORCE_INLINE bool success() const { return _index < _array.size(); }
 

include/ArduinoJson/JsonBuffer.hpp

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

include/ArduinoJson/JsonObjectSubscript.hpp

@@ -19,13 +19,6 @@ class JsonObjectSubscript
 
   using JsonSubscriptBase<JsonObjectSubscript<TKey> >::operator=;
 
-  FORCE_INLINE JsonObjectSubscript<TKey>& operator=(
-      const JsonObjectSubscript<TKey>& other) {
-    // to prevent Visual Studio warning C4512: assignment operator could not be
-    // generated
-    return set(other.get());
-  }
-
   FORCE_INLINE bool success() const { return _object.containsKey(_key); }
 
   FORCE_INLINE operator JsonVariant() const { return _object.get(_key); }

include/ArduinoJson/JsonSubscriptBase.hpp

@@ -74,9 +74,9 @@ class JsonSubscriptBase : public JsonVariantBase<TImpl> {
  private:
   template <typename TValue>
   FORCE_INLINE TImpl& assign(TValue value) {
-    TImpl* impl = static_cast<TImpl*>(this);
-    impl->template set<TValue>(value);
-    return *impl;
+    TImpl* that = static_cast<TImpl*>(this);
+    that->template set<TValue>(value);
+    return *that;
   }
 };
 }

include/ArduinoJson/JsonVariant.ipp

@@ -101,7 +101,7 @@ const char *JsonVariant::as<const char *>() const;
 
 template <>
 inline bool JsonVariant::as<bool>() const {
-  return as<long>();
+  return as<long>() != 0;
 }
 
 template <>

include/ArduinoJson/StaticJsonBuffer.hpp

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

library.properties

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

scripts/create-size-graph.sh

@@ -0,0 +1,42 @@
+#!/bin/bash
+
+set -eu
+
+OUTPUT="$(pwd)/sizes.csv"
+
+echo "Tag;Date;Parser;Generator" > $OUTPUT
+
+cd $(dirname $(dirname $0))
+
+git tag | while read TAG
+do 
+
+	git checkout -q tags/$TAG
+
+	DATE=$(git log -1 --date=short --pretty=format:%cd)
+	PARSER_SIZE=$(arduino --verify examples/JsonParserExample/JsonParserExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
+	
+	if [ -e 'examples/JsonGeneratorExample/JsonGeneratorExample.ino' ]; then
+		GENERATOR_SIZE=$(arduino --verify examples/JsonGeneratorExample/JsonGeneratorExample.ino 2>/dev/null  | grep -e 'Sketch uses' | sed 's/.*uses \([0-9]*\).\([0-9]\+\).*/\1\2/')
+	else
+		GENERATOR_SIZE=""
+	fi
+
+	echo $TAG 
+	if [ ! -z "$PARSER_SIZE" ]
+	then
+		echo "JsonParserExample = $PARSER_SIZE bytes"
+	else
+		echo "JsonParserExample compilation failed."
+	fi
+
+	if [ ! -z "$GENERATOR_SIZE" ]
+	then
+		echo "JsonGeneratorExample = $GENERATOR_SIZE bytes"
+	else
+		echo "JsonGeneratorExample compilation failed."
+	fi
+
+	echo "$TAG;$DATE;$PARSER_SIZE;$GENERATOR_SIZE" >> $OUTPUT
+
+done

src/Arduino/Print.cpp

@@ -17,6 +17,13 @@
 #pragma GCC diagnostic ignored "-Wfloat-conversion"
 #endif
 
+// Visual Studo 2012 didn't have isnan, nor isinf
+#if defined(_MSC_VER) && _MSC_VER <= 1700
+#include <float.h>
+#define isnan(x) _isnan(x)
+#define isinf(x) (!_finite(x))
+#endif
+
 size_t Print::print(const char s[]) {
   size_t n = 0;
   while (*s) {

src/Arduino/String.cpp

@@ -16,12 +16,6 @@ String::String(double value, unsigned char digits) {
   *this = tmp;
 }
 
-String::String(int value) {
-  char tmp[32];
-  sprintf(tmp, "%d", value);
-  *this = tmp;
-}
-
 String::String(long value) {
   char tmp[32];
   sprintf(tmp, "%ld", value);

src/CMakeLists.txt

@@ -43,6 +43,7 @@ endif()
 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
 	add_definitions(
 		-Wc++11-compat
+		-Wdeprecated-register
 	)
 endif()
 

src/Internals/JsonParser.cpp

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

src/JsonVariant.cpp

@@ -99,19 +99,25 @@ bool JsonVariant::is<double>() const {
 }
 
 void JsonVariant::writeTo(JsonWriter &writer) const {
-  if (_type == JSON_ARRAY) _content.asArray->writeTo(writer);
+  if (_type == JSON_ARRAY)
+    _content.asArray->writeTo(writer);
 
-  if (_type == JSON_OBJECT) _content.asObject->writeTo(writer);
+  else if (_type == JSON_OBJECT)
+    _content.asObject->writeTo(writer);
 
-  if (_type == JSON_STRING) writer.writeString(_content.asString);
+  else if (_type == JSON_STRING)
+    writer.writeString(_content.asString);
 
-  if (_type == JSON_UNPARSED) writer.writeRaw(_content.asString);
+  else if (_type == JSON_UNPARSED)
+    writer.writeRaw(_content.asString);
 
-  if (_type == JSON_LONG) writer.writeLong(_content.asLong);
+  else if (_type == JSON_LONG)
+    writer.writeLong(_content.asLong);
 
-  if (_type == JSON_BOOLEAN) writer.writeBoolean(_content.asLong);
+  else if (_type == JSON_BOOLEAN)
+    writer.writeBoolean(_content.asLong != 0);
 
-  if (_type >= JSON_DOUBLE_0_DECIMALS) {
+  else if (_type >= JSON_DOUBLE_0_DECIMALS) {
     uint8_t decimals = static_cast<uint8_t>(_type - JSON_DOUBLE_0_DECIMALS);
     writer.writeDouble(_content.asDouble, decimals);
   }

test/CMakeLists.txt

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

test/DynamicJsonBuffer_Basic_Tests.cpp

@@ -22,9 +22,9 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, InitialSizeIsZero) {
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, SizeIncreasesAfterAlloc) {
   buffer.alloc(1);
-  ASSERT_EQ(1, buffer.size());
+  ASSERT_LE(1, buffer.size());
   buffer.alloc(1);
-  ASSERT_EQ(2, buffer.size());
+  ASSERT_LE(2, buffer.size());
 }
 
 TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {
@@ -32,3 +32,12 @@ TEST_F(DynamicJsonBuffer_Basic_Tests, ReturnDifferentPointer) {
   void* p2 = buffer.alloc(2);
   ASSERT_NE(p1, p2);
 }
+
+TEST_F(DynamicJsonBuffer_Basic_Tests, Alignment) {
+  size_t mask = sizeof(void*) - 1;
+
+  for (size_t size = 1; size <= sizeof(void*); size++) {
+    size_t addr = reinterpret_cast<size_t>(buffer.alloc(1));
+    ASSERT_EQ(0, addr & mask);
+  }
+}

test/JsonParser_Nested_Tests.cpp

@@ -13,21 +13,26 @@ TEST(JsonParser_Nested_Tests, ArrayNestedInObject) {
 
   JsonObject &object = jsonBuffer.parseObject(jsonString);
   JsonArray &array1 = object["ab"];
-  JsonArray &array2 = object["cd"];
+  const JsonArray &array2 = object["cd"];
+  JsonArray &array3 = object["ef"];
 
   ASSERT_TRUE(object.success());
 
   ASSERT_TRUE(array1.success());
   ASSERT_TRUE(array2.success());
+  ASSERT_FALSE(array3.success());
 
   ASSERT_EQ(2, array1.size());
   ASSERT_EQ(2, array2.size());
+  ASSERT_EQ(0, array3.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>());
+
+  EXPECT_EQ(0, array3[0].as<int>());
 }
 
 TEST(JsonParser_Nested_Tests, ObjectNestedInArray) {
@@ -37,18 +42,22 @@ TEST(JsonParser_Nested_Tests, ObjectNestedInArray) {
 
   JsonArray &array = jsonBuffer.parseArray(jsonString);
   JsonObject &object1 = array[0];
-  JsonObject &object2 = array[1];
+  const JsonObject &object2 = array[1];
+  JsonObject &object3 = array[2];
 
   ASSERT_TRUE(array.success());
 
   ASSERT_TRUE(object1.success());
   ASSERT_TRUE(object2.success());
+  ASSERT_FALSE(object3.success());
 
   ASSERT_EQ(2, object1.size());
   ASSERT_EQ(2, object2.size());
+  ASSERT_EQ(0, object3.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>());
+  EXPECT_EQ(0, object3["e"].as<int>());
 }

test/JsonVariant_As_Tests.cpp

@@ -145,6 +145,11 @@ TEST(JsonVariant_As_Tests, RandomStringAsLong) {
   ASSERT_EQ(0L, variant.as<long>());
 }
 
+TEST(JsonVariant_As_Tests, RandomStringAsString) {
+  JsonVariant variant = "hello";
+  ASSERT_EQ(String("hello"), variant.as<String>());
+}
+
 TEST(JsonVariant_As_Tests, TrueStringAsBool) {
   JsonVariant variant = "true";
   ASSERT_TRUE(variant.as<bool>());

test/StaticJsonBuffer_Basic_Tests.cpp

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

test/StaticJsonBuffer_ParseArray_Tests.cpp

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

test/StaticJsonBuffer_ParseObject_Tests.cpp

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