Set version to 5.1.0-beta.1

Added support of long long (issue #171 )
2025-07-27 09:17:32 +02:00 · 2016-02-01 21:26:15 +01:00 · 2016-02-01 21:17:32 +01:00
55 changed files with 460 additions and 1411 deletions
--- a/.travis.yml
+++ b/.travis.yml
@ -1,85 +1,15 @@
 sudo: false
 language: cpp
-matrix:
-  include:
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.4']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.4
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.5
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.6']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.6
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.7']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.7
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.8']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.8
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-4.9']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-4.9
-    - compiler: gcc
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test']
-          packages: ['g++-5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=g++-5
-    - compiler: clang
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.5']
-          packages: ['clang-3.5']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.5
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.6']
-          packages: ['clang-3.6']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.6
-    - compiler: clang
-      addons:
-        apt:
-          sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.7']
-          packages: ['clang-3.7']
-      env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.7
-    # - compiler: clang
-    #   addons:
-    #     apt:
-    #       sources: ['ubuntu-toolchain-r-test','llvm-toolchain-precise-3.8']
-    #       packages: ['clang-3.8']
-    #   env: SCRIPT=cmake CMAKE_CXX_COMPILER=clang++-3.8
-    - compiler: gcc
-      env: SCRIPT=coverage
-    - env: SCRIPT=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
-    - env: SCRIPT=arduino VERSION=1.6.8 BOARD=arduino:avr:uno
-    - env: SCRIPT=platformio BOARD=uno
-    - env: SCRIPT=platformio BOARD=due
-    - env: SCRIPT=platformio BOARD=esp01
-    - env: SCRIPT=platformio BOARD=teensy31
 cache:
  directories:
    - "~/.platformio"
-script: scripts/travis/$SCRIPT.sh
+env:
+  - COMPILER=gcc
+  - COMPILER=clang
+  - COMPILER=arduino VERSION=1.5.8 BOARD=arduino:avr:uno
+  - COMPILER=arduino VERSION=1.6.7 BOARD=arduino:avr:uno
+  - COMPILER=platformio BOARD=uno
+  - COMPILER=platformio BOARD=due
+  - COMPILER=platformio BOARD=esp01
+  - COMPILER=platformio BOARD=teensy31
+script: scripts/travis/$COMPILER.sh
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,26 +1,6 @@
 ArduinoJson: change log
 =======================

-v5.3.0
------
-
-* Added custom implementation of `ftoa` (issues #266, #267, #269 and #270)
-* Added `JsonVariant JsonBuffer::parse()` (issue #265)
-* Fixed `unsigned long` printed as `signed long` (issue #170)
-
-v5.2.0
------
-
-* Added `JsonVariant::as<char*>()` as a synonym for `JsonVariant::as<const char*>()` (issue #257)
-* Added example `JsonHttpClient` (issue #256)
-* Added `JsonArray::copyTo()` and `JsonArray::copyFrom()` (issue #254)
-* Added `RawJson()` to insert pregenerated JSON portions (issue #259)
-
-v5.1.1
------
-
-* Removed `String` duplication when one replaces a value in a `JsonObject` (PR #232 by @ulion)
-
 v5.1.0
 ------

--- a/README.md
+++ b/README.md
@ -15,8 +15,7 @@ Features
 * JSON decoding (comments are supported)
 * JSON encoding (with optional indentation)
 * Elegant API, very easy to use
-* Fixed memory allocation (zero malloc)
-* No data duplication (zero copy)
+* Efficient (no malloc, nor copy)
 * Portable (written in C++98)
 * Self-contained (no external dependency)
 * Small footprint
@ -25,13 +24,12 @@ Features
 Works on
 --------

-* All Arduino boards (Uno, Due, Mini, Micro, Yun...)
+* All Arduino boards
 * ESP8266
 * Teensy
 * Intel Edison
 * PlatformIO
 * Energia
-* RedBearLab boards (BLE Nano...)
 * Computers (Windows, Linux, OSX...)

 See [FAQ: Compatibility issues](https://github.com/bblanchon/ArduinoJson/wiki/Compatibility-issues)
@ -92,18 +90,18 @@ 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`:
+
 > 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!!

 [From Reddit user `erm_what_`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusjk8c):
+
 > This is a great library and I wouldn't be able to do the project I'm doing without it. I completely recommend it.

 [From Reddit user `makerhacks`](https://www.reddit.com/r/arduino/comments/3jj6ep/announcing_arduinojson_50/cusqg7b):
-> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.

-[From Twitter user `@hemalchevli`](https://twitter.com/hemalchevli/status/715788439397011456):
-> ArduinoJson library should be used as a benchmark/reference for making libraries. Truly elegant.
+> I am just starting an ESP8266 clock project and now I can output JSON from my server script and interpret it painlessly.

 Donators
 --------
@ -117,7 +115,6 @@ Special thanks to the following persons and companies who made generous donation
 * A B Doodkorte
 * Scott Smith
 * Johann Stieger
-* Gustavo Donizeti Gini

 ---

--- a/appveyor.yml
+++ b/appveyor.yml
@ -1,16 +0,0 @@
-version: 5.3.0.{build}
-environment:
-  matrix:
-  - CMAKE_GENERATOR: Visual Studio 14 2015
-  - CMAKE_GENERATOR: Visual Studio 12 2013
-  - CMAKE_GENERATOR: Visual Studio 11 2012
-  - CMAKE_GENERATOR: Visual Studio 10 2010
-  - CMAKE_GENERATOR: MinGW Makefiles
-configuration: Debug
-before_build:
- set PATH=C:\MinGW\bin;%PATH:C:\Program Files\Git\usr\bin;=% # Workaround for CMake not wanting sh.exe on PATH for MinGW
- cmake -DCMAKE_BUILD_TYPE=%CONFIGURATION% -G "%CMAKE_GENERATOR%" .
-build_script:
- cmake --build . --config %CONFIGURATION%
-test_script:
- ctest -V .
--- a/examples/JsonHttpClient/JsonHttpClient.ino
+++ b/examples/JsonHttpClient/JsonHttpClient.ino
@ -1,195 +0,0 @@
-// Sample Arduino Json Web Client
-// Downloads and parse http://jsonplaceholder.typicode.com/users/1
-//
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <SPI.h>
-#include <Ethernet.h>
-
-EthernetClient client;
-
-const char* server = "jsonplaceholder.typicode.com";  // server's address
-const char* resource = "/users/1";                    // http resource
-const unsigned long BAUD_RATE = 9600;                 // serial connection speed
-const unsigned long HTTP_TIMEOUT = 10000;  // max respone time from server
-const size_t MAX_CONTENT_SIZE = 512;       // max size of the HTTP response
-
-// The type of data that we want to extract from the page
-struct UserData {
-  char name[32];
-  char company[32];
-};
-
-// ARDUINO entry point #1: runs once when you press reset or power the board
-void setup() {
-  initSerial();
-  initEthernet();
-}
-
-// ARDUINO entry point #2: runs over and over again forever
-void loop() {
-  if (connect(server)) {
-    if (sendRequest(server, resource) && skipResponseHeaders()) {
-      char response[MAX_CONTENT_SIZE];
-      readReponseContent(response, sizeof(response));
-
-      UserData userData;
-      if (parseUserData(response, &userData)) {
-        printUserData(&userData);
-      }
-    }
-    disconnect();
-  }
-  wait();
-}
-
-// Initialize Serial port
-void initSerial() {
-  Serial.begin(BAUD_RATE);
-  while (!Serial) {
-    ;  // wait for serial port to initialize
-  }
-  Serial.println("Serial ready");
-}
-
-// Initialize Ethernet library
-void initEthernet() {
-  byte mac[] = {0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED};
-  if (!Ethernet.begin(mac)) {
-    Serial.println("Failed to configure Ethernet");
-    return;
-  }
-  Serial.println("Ethernet ready");
-  delay(1000);
-}
-
-// Open connection to the HTTP server
-bool connect(const char* hostName) {
-  Serial.print("Connect to ");
-  Serial.println(hostName);
-
-  bool ok = client.connect(hostName, 80);
-
-  Serial.println(ok ? "Connected" : "Connection Failed!");
-  return ok;
-}
-
-// Send the HTTP GET request to the server
-bool sendRequest(const char* host, const char* resource) {
-  Serial.print("GET ");
-  Serial.println(resource);
-
-  client.print("GET ");
-  client.print(resource);
-  client.println(" HTTP/1.1");
-  client.print("Host: ");
-  client.println(server);
-  client.println("Connection: close");
-  client.println();
-
-  return true;
-}
-
-// Skip HTTP headers so that we are at the beginning of the response's body
-bool skipResponseHeaders() {
-  // HTTP headers end with an empty line
-  char endOfHeaders[] = "\r\n\r\n";
-
-  client.setTimeout(HTTP_TIMEOUT);
-  bool ok = client.find(endOfHeaders);
-
-  if (!ok) {
-    Serial.println("No response or invalid response!");
-  }
-
-  return ok;
-}
-
-// Read the body of the response from the HTTP server
-void readReponseContent(char* content, size_t maxSize) {
-  size_t length = client.readBytes(content, maxSize);
-  content[length] = 0;
-  Serial.println(content);
-}
-
-// Parse the JSON from the input string and extract the interesting values
-// Here is the JSON we need to parse
-// {
-//   "id": 1,
-//   "name": "Leanne Graham",
-//   "username": "Bret",
-//   "email": "Sincere@april.biz",
-//   "address": {
-//     "street": "Kulas Light",
-//     "suite": "Apt. 556",
-//     "city": "Gwenborough",
-//     "zipcode": "92998-3874",
-//     "geo": {
-//       "lat": "-37.3159",
-//       "lng": "81.1496"
-//     }
-//   },
-//   "phone": "1-770-736-8031 x56442",
-//   "website": "hildegard.org",
-//   "company": {
-//     "name": "Romaguera-Crona",
-//     "catchPhrase": "Multi-layered client-server neural-net",
-//     "bs": "harness real-time e-markets"
-//   }
-// }
-bool parseUserData(char* content, struct UserData* userData) {
-  // Compute optimal size of the JSON buffer according to what we need to parse.
-  // This is only required if you use StaticJsonBuffer.
-  const size_t BUFFER_SIZE =
-      JSON_OBJECT_SIZE(8)     // the root object has 8 elements
-      + JSON_OBJECT_SIZE(5)   // the "address" object has 5 elements
-      + JSON_OBJECT_SIZE(2)   // the "geo" object has 2 elements
-      + JSON_OBJECT_SIZE(3);  // the "company" object has 3 elements
-
-  // Allocate a temporary memory pool on the stack
-  StaticJsonBuffer<BUFFER_SIZE> jsonBuffer;
-  // If the memory pool is too big for the stack, use this instead:
-  // DynamicJsonBuffer jsonBuffer;
-
-  JsonObject& root = jsonBuffer.parseObject(content);
-
-  if (!root.success()) {
-    Serial.println("JSON parsing failed!");
-    return false;
-  }
-
-  // Here were copy the strings we're interested in
-  strcpy(userData->name, root["name"]);
-  strcpy(userData->company, root["company"]["name"]);
-  // It's not mandatory to make a copy, you could just use the pointers
-  // Since, they are pointing inside the "content" buffer, so you need to make
-  // sure it's still in memory when you read the string
-
-  return true;
-}
-
-// Print the data extracted from the JSON
-void printUserData(const struct UserData* userData) {
-  Serial.print("Name = ");
-  Serial.println(userData->name);
-  Serial.print("Company = ");
-  Serial.println(userData->company);
-}
-
-// Close the connection with the HTTP server
-void disconnect() {
-  Serial.println("Disconnect");
-  client.stop();
-}
-
-// Pause for a 1 minute
-void wait() {
-  Serial.println("Wait 60 seconds");
-  delay(60000);
-}
--- a/include/ArduinoJson/Arduino/Print.hpp
+++ b/include/ArduinoJson/Arduino/Print.hpp
@ -9,6 +9,9 @@

 #ifndef ARDUINO

+#include "../TypeTraits/EnableIf.hpp"
+#include "../TypeTraits/IsIntegral.hpp"
+
 #include <stddef.h>
 #include <stdint.h>

@ -19,15 +22,36 @@ class Print {

  virtual size_t write(uint8_t) = 0;

-  size_t print(const char* s) {
+  size_t print(const char[]);
+  size_t print(double, int = 2);
+
+  template <typename TIntegral>
+  typename ArduinoJson::TypeTraits::EnableIf<
+      ArduinoJson::TypeTraits::IsIntegral<TIntegral>::value, size_t>::type
+  print(TIntegral value) {
+    // see http://clc-wiki.net/wiki/K%26R2_solutions:Chapter_3:Exercise_4
+    char buffer[22];
+
    size_t n = 0;
-    while (*s) {
-      n += write(*s++);
+    if (value < 0) {
+      value = -value;
+      n += write('-');
    }
+    uint8_t i = 0;
+    do {
+      TIntegral digit = value % 10;
+      value /= 10;
+      buffer[i++] = static_cast<char>(digit >= 0 ? '0' + digit : '0' - digit);
+    } while (value);
+
+    while (i > 0) {
+      n += write(buffer[--i]);
+    }
+
    return n;
  }

-  size_t println() { return write('\r') + write('\n'); }
+  size_t println();
 };

 #else
--- a/include/ArduinoJson/Internals/JsonInteger.hpp
+++ b/include/ArduinoJson/Internals/JsonInteger.hpp
@ -14,13 +14,10 @@ namespace Internals {

 #if ARDUINOJSON_USE_LONG_LONG
 typedef long long JsonInteger;
-typedef unsigned long long JsonUInt;
 #elif ARDUINOJSON_USE_INT64
 typedef __int64 JsonInteger;
-typedef unsigned _int64 JsonUInt;
 #else
 typedef long JsonInteger;
-typedef unsigned long JsonUInt;
 #endif
 }
 }
--- a/include/ArduinoJson/Internals/JsonParser.hpp
+++ b/include/ArduinoJson/Internals/JsonParser.hpp
@ -27,12 +27,6 @@ class JsonParser {
  JsonArray &parseArray();
  JsonObject &parseObject();

-  JsonVariant parseVariant() {
-    JsonVariant result;
-    parseAnythingTo(&result);
-    return result;
-  }
-
 private:
  bool skip(char charToSkip);

--- a/include/ArduinoJson/Internals/JsonVariantContent.hpp
+++ b/include/ArduinoJson/Internals/JsonVariantContent.hpp
@ -20,11 +20,11 @@ namespace Internals {
 // A union that defines the actual content of a JsonVariant.
 // The enum JsonVariantType determines which member is in use.
 union JsonVariantContent {
-  JsonFloat asFloat;     // used for double and float
-  JsonUInt asInteger;    // used for bool, char, short, int and longs
-  const char* asString;  // asString can be null
-  JsonArray* asArray;    // asArray cannot be null
-  JsonObject* asObject;  // asObject cannot be null
+  JsonFloat asFloat;      // used for double and float
+  JsonInteger asInteger;  // used for bool, char, short, int and longs
+  const char* asString;   // asString can be null
+  JsonArray* asArray;     // asArray cannot be null
+  JsonObject* asObject;   // asObject cannot be null
 };
 }
 }
--- a/include/ArduinoJson/Internals/JsonVariantType.hpp
+++ b/include/ArduinoJson/Internals/JsonVariantType.hpp
@ -16,15 +16,13 @@ namespace Internals {
 // Enumerated type to know the current type of a JsonVariant.
 // The value determines which member of JsonVariantContent is used.
 enum JsonVariantType {
-  JSON_UNDEFINED,         // JsonVariant has not been initialized
-  JSON_UNPARSED,          // JsonVariant contains an unparsed string
-  JSON_STRING,            // JsonVariant stores a const char*
-  JSON_BOOLEAN,           // JsonVariant stores a bool
-  JSON_POSITIVE_INTEGER,  // JsonVariant stores an unsigned long
-  JSON_NEGATIVE_INTEGER,  // JsonVariant stores an unsigned long that must be
-                          // negated
-  JSON_ARRAY,             // JsonVariant stores a pointer to a JsonArray
-  JSON_OBJECT,            // JsonVariant stores a pointer to a JsonObject
+  JSON_UNDEFINED,  // the JsonVariant has not been initialized
+  JSON_UNPARSED,   // the JsonVariant contains an unparsed string
+  JSON_STRING,     // the JsonVariant stores a const char*
+  JSON_BOOLEAN,    // the JsonVariant stores a bool
+  JSON_INTEGER,    // the JsonVariant stores an integer
+  JSON_ARRAY,      // the JsonVariant stores a pointer to a JsonArray
+  JSON_OBJECT,     // the JsonVariant stores a pointer to a JsonObject

  // The following values are reserved for float values
  // Multiple values are used for double, depending on the number of decimal
--- a/include/ArduinoJson/Internals/JsonWriter.hpp
+++ b/include/ArduinoJson/Internals/JsonWriter.hpp
@ -8,9 +8,6 @@
 #pragma once

 #include "../Arduino/Print.hpp"
-#include "../Polyfills/isNaN.hpp"
-#include "../Polyfills/isInfinity.hpp"
-#include "../Polyfills/normalize.hpp"
 #include "Encoding.hpp"
 #include "ForceInline.hpp"
 #include "JsonFloat.hpp"
@ -35,107 +32,49 @@ class JsonWriter {
  // number of bytes written.
  size_t bytesWritten() const { return _length; }

-  void beginArray() { writeRaw('['); }
-  void endArray() { writeRaw(']'); }
+  void beginArray() { write('['); }
+  void endArray() { write(']'); }

-  void beginObject() { writeRaw('{'); }
-  void endObject() { writeRaw('}'); }
+  void beginObject() { write('{'); }
+  void endObject() { write('}'); }

-  void writeColon() { writeRaw(':'); }
-  void writeComma() { writeRaw(','); }
+  void writeColon() { write(':'); }
+  void writeComma() { write(','); }

-  void writeBoolean(bool value) { writeRaw(value ? "true" : "false"); }
+  void writeBoolean(bool value) { write(value ? "true" : "false"); }

  void writeString(const char *value) {
    if (!value) {
-      writeRaw("null");
+      write("null");
    } else {
-      writeRaw('\"');
+      write('\"');
      while (*value) writeChar(*value++);
-      writeRaw('\"');
+      write('\"');
    }
  }

  void writeChar(char c) {
    char specialChar = Encoding::escapeChar(c);
    if (specialChar) {
-      writeRaw('\\');
-      writeRaw(specialChar);
+      write('\\');
+      write(specialChar);
    } else {
-      writeRaw(c);
+      write(c);
    }
  }

-  void writeFloat(JsonFloat value, int digits = 2) {
-    if (Polyfills::isNaN(value)) return writeRaw("NaN");
+  void writeInteger(JsonInteger value) { _length += _sink.print(value); }

-    if (value < 0.0) {
-      writeRaw('-');
-      value = -value;
-    }
-
-    if (Polyfills::isInfinity(value)) return writeRaw("Infinity");
-
-    short powersOf10;
-    if (value > 1000 || value < 0.001) {
-      powersOf10 = Polyfills::normalize(value);
-    } else {
-      powersOf10 = 0;
-    }
-
-    // Round correctly so that print(1.999, 2) prints as "2.00"
-    JsonFloat rounding = 0.5;
-    for (uint8_t i = 0; i < digits; ++i) rounding /= 10.0;
-
-    value += rounding;
-
-    // Extract the integer part of the value and print it
-    JsonUInt int_part = static_cast<JsonUInt>(value);
-    JsonFloat remainder = value - static_cast<JsonFloat>(int_part);
-    writeInteger(int_part);
-
-    // Print the decimal point, but only if there are digits beyond
-    if (digits > 0) {
-      writeRaw('.');
-    }
-
-    // Extract digits from the remainder one at a time
-    while (digits-- > 0) {
-      remainder *= 10.0;
-      JsonUInt toPrint = JsonUInt(remainder);
-      writeInteger(JsonUInt(remainder));
-      remainder -= static_cast<JsonFloat>(toPrint);
-    }
-
-    if (powersOf10 < 0) {
-      writeRaw("e-");
-      writeInteger(-powersOf10);
-    }
-
-    if (powersOf10 > 0) {
-      writeRaw('e');
-      writeInteger(powersOf10);
-    }
+  void writeFloat(JsonFloat value, uint8_t decimals) {
+    _length += _sink.print(value, decimals);
  }

-  void writeInteger(JsonUInt value) {
-    char buffer[22];
-
-    uint8_t i = 0;
-    do {
-      buffer[i++] = static_cast<char>(value % 10 + '0');
-      value /= 10;
-    } while (value);
-
-    while (i > 0) {
-      writeRaw(buffer[--i]);
-    }
-  }
-
-  void writeRaw(const char *s) { _length += _sink.print(s); }
-  void writeRaw(char c) { _length += _sink.write(c); }
+  void writeRaw(const char *s) { return write(s); }

 protected:
+  void write(char c) { _length += _sink.write(c); }
+  FORCE_INLINE void write(const char *s) { _length += _sink.print(s); }
+
  Print &_sink;
  size_t _length;

--- a/include/ArduinoJson/Internals/Parse.hpp
+++ b/include/ArduinoJson/Internals/Parse.hpp
@ -29,11 +29,6 @@ inline long parse<long>(const char *s) {
  return strtol(s, NULL, 10);
 }

-template <>
-inline unsigned long parse<unsigned long>(const char *s) {
-  return strtoul(s, NULL, 10);
-}
-
 template <>
 inline int parse<int>(const char *s) {
  return atoi(s);
@ -44,11 +39,6 @@ template <>
 inline long long parse<long long>(const char *s) {
  return strtoll(s, NULL, 10);
 }
-
-template <>
-inline unsigned long long parse<unsigned long long>(const char *s) {
-  return strtoull(s, NULL, 10);
-}
 #endif

 #if ARDUINOJSON_USE_INT64
@ -56,11 +46,6 @@ template <>
 inline __int64 parse<__int64>(const char *s) {
  return _strtoi64(s, NULL, 10);
 }
-
-template <>
-inline unsigned __int64 parse<unsigned __int64>(const char *s) {
-  return _strtoui64(s, NULL, 10);
-}
 #endif
 }
 }
--- a/include/ArduinoJson/Internals/Unparsed.hpp
+++ b/include/ArduinoJson/Internals/Unparsed.hpp
@ -8,14 +8,14 @@
 #pragma once

 namespace ArduinoJson {
-
-// A special type of data that can be used to insert pregenerated JSON portions.
-class RawJson {
+namespace Internals {
+class Unparsed {
 public:
-  explicit RawJson(const char* str) : _str(str) {}
+  explicit Unparsed(const char* str) : _str(str) {}
  operator const char*() const { return _str; }

 private:
  const char* _str;
 };
 }
+}
--- a/include/ArduinoJson/JsonArray.hpp
+++ b/include/ArduinoJson/JsonArray.hpp
@ -12,10 +12,6 @@
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonVariant.hpp"
-#include "TypeTraits/EnableIf.hpp"
-#include "TypeTraits/IsFloatingPoint.hpp"
-#include "TypeTraits/IsReference.hpp"
-#include "TypeTraits/IsSame.hpp"

 // Returns the size (in bytes) of an array with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@ -74,8 +70,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  template <typename T>
  FORCE_INLINE bool add(
      T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type * = 0) {
    return addNode<T>(value);
  }
  // bool add(const String&)
@ -85,16 +80,16 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  template <typename T>
  FORCE_INLINE bool add(
      const T &value,
-      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T &>::value, T>::type * = 0) {
    return addNode<T &>(const_cast<T &>(value));
  }
  // bool add(float value, uint8_t decimals);
  // bool add(double value, uint8_t decimals);
  template <typename T>
  FORCE_INLINE bool add(
-      T value, uint8_t decimals,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      T value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    uint8_t>::type decimals) {
    return addNode<JsonVariant>(JsonVariant(value, decimals));
  }

@ -107,8 +102,7 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  template <typename T>
  FORCE_INLINE bool set(
      size_t index, T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type * = 0) {
    return setNodeAt<T>(index, value);
  }
  // bool set(size_t index, const String&)
@ -118,16 +112,16 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  template <typename T>
  FORCE_INLINE bool set(
      size_t index, const T &value,
-      typename TypeTraits::EnableIf<CanSet<T &>::value>::type * = 0) {
+      typename TypeTraits::EnableIf<CanSet<T &>::value, T>::type * = 0) {
    return setNodeAt<T &>(index, const_cast<T &>(value));
  }
  // bool set(size_t index, float value, uint8_t decimals = 2);
  // bool set(size_t index, double value, uint8_t decimals = 2);
  template <typename T>
  FORCE_INLINE bool set(
-      size_t index, T value, uint8_t decimals,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      size_t index, T value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    uint8_t>::type decimals) {
    return setNodeAt<const JsonVariant &>(index, JsonVariant(value, decimals));
  }

@ -161,59 +155,6 @@ class JsonArray : public Internals::JsonPrintable<JsonArray>,
  // Serialize the array to the specified JsonWriter.
  void writeTo(Internals::JsonWriter &writer) const;

-  // Imports a 1D array
-  template <typename T, size_t N>
-  bool copyFrom(T(&array)[N]) {
-    return copyFrom(array, N);
-  }
-
-  // Imports a 1D array
-  template <typename T>
-  bool copyFrom(T *array, size_t len) {
-    bool ok = true;
-    for (size_t i = 0; i < len; i++) {
-      ok &= add(array[i]);
-    }
-    return ok;
-  }
-
-  // Imports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  bool copyFrom(T(&array)[N1][N2]) {
-    bool ok = true;
-    for (size_t i = 0; i < N1; i++) {
-      JsonArray &nestedArray = createNestedArray();
-      for (size_t j = 0; j < N2; j++) {
-        ok &= nestedArray.add(array[i][j]);
-      }
-    }
-    return ok;
-  }
-
-  // Exports a 1D array
-  template <typename T, size_t N>
-  size_t copyTo(T(&array)[N]) const {
-    return copyTo(array, N);
-  }
-
-  // Exports a 1D array
-  template <typename T>
-  size_t copyTo(T *array, size_t len) const {
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < len; ++it)
-      array[i++] = *it;
-    return i;
-  }
-
-  // Exports a 2D array
-  template <typename T, size_t N1, size_t N2>
-  void copyTo(T(&array)[N1][N2]) const {
-    size_t i = 0;
-    for (const_iterator it = begin(); it != end() && i < N1; ++it) {
-      it->asArray().copyTo(array[i++]);
-    }
-  }
-
 private:
  node_type *getNodeAt(size_t index) const;

--- a/include/ArduinoJson/JsonArraySubscript.hpp
+++ b/include/ArduinoJson/JsonArraySubscript.hpp
@ -77,6 +77,11 @@ inline std::ostream& operator<<(std::ostream& os,
 }
 #endif

+template <>
+struct JsonVariant::IsConstructibleFrom<JsonArraySubscript> {
+  static const bool value = true;
+};
+
 }  // namespace ArduinoJson

 #ifdef _MSC_VER
--- a/include/ArduinoJson/JsonBuffer.hpp
+++ b/include/ArduinoJson/JsonBuffer.hpp
@ -94,21 +94,6 @@ class JsonBuffer {
    return parseObject(json.c_str(), nesting);
  }

-  // Generalized version of parseArray() and parseObject(), also works for
-  // integral types.
-  JsonVariant parse(char *json, uint8_t nestingLimit = DEFAULT_LIMIT);
-
-  // Same with a const char*.
-  // With this overload, the JsonBuffer will make a copy of the string
-  JsonVariant parse(const char *json, uint8_t nesting = DEFAULT_LIMIT) {
-    return parse(strdup(json), nesting);
-  }
-
-  // Same as above with a String class
-  JsonVariant parse(const String &json, uint8_t nesting = DEFAULT_LIMIT) {
-    return parse(json.c_str(), nesting);
-  }
-
  // Duplicate a string
  char *strdup(const char *src) {
    return src ? strdup(src, strlen(src)) : NULL;
--- a/include/ArduinoJson/JsonObject.hpp
+++ b/include/ArduinoJson/JsonObject.hpp
@ -13,10 +13,6 @@
 #include "Internals/List.hpp"
 #include "Internals/ReferenceType.hpp"
 #include "JsonPair.hpp"
-#include "TypeTraits/EnableIf.hpp"
-#include "TypeTraits/IsFloatingPoint.hpp"
-#include "TypeTraits/IsReference.hpp"
-#include "TypeTraits/IsSame.hpp"

 // Returns the size (in bytes) of an object with n elements.
 // Can be very handy to determine the size of a StaticJsonBuffer.
@ -71,12 +67,10 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
  // bool set(TKey key, float value);
  // bool set(TKey key, double value);
  // bool set(TKey key, const char* value);
-  // bool set(TKey key, RawJson value);
  template <typename T>
  FORCE_INLINE bool set(
      JsonObjectKey key, T value,
-      typename TypeTraits::EnableIf<
-          CanSet<T>::value && !TypeTraits::IsReference<T>::value>::type* = 0) {
+      typename TypeTraits::EnableIf<CanSet<T>::value, void>::type* = 0) {
    return setNodeAt<T>(key, value);
  }
  // bool set(Key, String&);
@ -86,16 +80,16 @@ class JsonObject : public Internals::JsonPrintable<JsonObject>,
  template <typename T>
  FORCE_INLINE bool set(
      JsonObjectKey key, const T& value,
-      typename TypeTraits::EnableIf<CanSet<T&>::value>::type* = 0) {
+      typename TypeTraits::EnableIf<CanSet<T&>::value, T>::type* = 0) {
    return setNodeAt<T&>(key, const_cast<T&>(value));
  }
  // bool set(Key, float value, uint8_t decimals);
  // bool set(Key, double value, uint8_t decimals);
  template <typename TValue>
  FORCE_INLINE bool set(
-      JsonObjectKey key, TValue value, uint8_t decimals,
-      typename TypeTraits::EnableIf<
-          TypeTraits::IsFloatingPoint<TValue>::value>::type* = 0) {
+      JsonObjectKey key, TValue value,
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<TValue>::value,
+                                    uint8_t>::type decimals) {
    return setNodeAt<const JsonVariant&>(key, JsonVariant(value, decimals));
  }

--- a/include/ArduinoJson/JsonObject.ipp
+++ b/include/ArduinoJson/JsonObject.ipp
@ -55,12 +55,8 @@ inline void JsonObject::remove(JsonObjectKey key) {
 template <typename T>
 inline bool JsonObject::setNodeAt(JsonObjectKey key, T value) {
  node_type *node = getNodeAt(key.c_str());
-  if (!node) {
-    node = addNewNode();
-    if (!node || !setNodeKey(node, key))
-      return false;
-  }
-  return setNodeValue<T>(node, value);
+  if (!node) node = addNewNode();
+  return node && setNodeKey(node, key) && setNodeValue<T>(node, value);
 }

 inline bool JsonObject::setNodeKey(node_type *node, JsonObjectKey key) {
--- a/include/ArduinoJson/JsonObjectSubscript.hpp
+++ b/include/ArduinoJson/JsonObjectSubscript.hpp
@ -92,6 +92,10 @@ inline std::ostream& operator<<(
 }
 #endif

+template <typename T>
+struct JsonVariant::IsConstructibleFrom<JsonObjectSubscript<T> > {
+  static const bool value = true;
+};
 }  // namespace ArduinoJson

 #ifdef _MSC_VER
--- a/include/ArduinoJson/JsonVariant.hpp
+++ b/include/ArduinoJson/JsonVariant.hpp
@ -13,14 +13,14 @@
 #include "Internals/JsonPrintable.hpp"
 #include "Internals/JsonVariantContent.hpp"
 #include "Internals/JsonVariantType.hpp"
+#include "Internals/Unparsed.hpp"
 #include "JsonVariantBase.hpp"
-#include "RawJson.hpp"
 #include "TypeTraits/EnableIf.hpp"
 #include "TypeTraits/IsFloatingPoint.hpp"
 #include "TypeTraits/IsIntegral.hpp"
-#include "TypeTraits/IsSame.hpp"
 #include "TypeTraits/RemoveConst.hpp"
 #include "TypeTraits/RemoveReference.hpp"
+#include "TypeTraits/IsSame.hpp"

 namespace ArduinoJson {

@ -55,47 +55,31 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  template <typename T>
  FORCE_INLINE JsonVariant(
      T value, uint8_t decimals = 2,
-      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value>::type
-          * = 0) {
+      typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
+                                    T>::type * = 0) {
    using namespace Internals;
    _type = static_cast<JsonVariantType>(JSON_FLOAT_0_DECIMALS + decimals);
    _content.asFloat = static_cast<JsonFloat>(value);
  }

  // Create a JsonVariant containing an integer value.
-  // JsonVariant(signed short)
-  // JsonVariant(signed int)
-  // JsonVariant(signed long)
+  // JsonVariant(short)
+  // JsonVariant(int)
+  // JsonVariant(long)
  template <typename T>
  FORCE_INLINE JsonVariant(
-      T value, typename TypeTraits::EnableIf<
-                   TypeTraits::IsSignedIntegral<T>::value>::type * = 0) {
+      T value, typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
+                                             T>::type * = 0) {
    using namespace Internals;
-    if (value >= 0) {
-      _type = JSON_POSITIVE_INTEGER;
-      _content.asInteger = static_cast<JsonUInt>(value);
-    } else {
-      _type = JSON_NEGATIVE_INTEGER;
-      _content.asInteger = static_cast<JsonUInt>(-value);
-    }
-  }
-  // JsonVariant(unsigned short)
-  // JsonVariant(unsigned int)
-  // JsonVariant(unsigned long)
-  template <typename T>
-  FORCE_INLINE JsonVariant(
-      T value, typename TypeTraits::EnableIf<
-                   TypeTraits::IsUnsignedIntegral<T>::value>::type * = 0) {
-    using namespace Internals;
-    _type = JSON_POSITIVE_INTEGER;
-    _content.asInteger = static_cast<JsonUInt>(value);
+    _type = JSON_INTEGER;
+    _content.asInteger = static_cast<JsonInteger>(value);
  }

  // Create a JsonVariant containing a string.
  FORCE_INLINE JsonVariant(const char *value);

  // Create a JsonVariant containing an unparsed string
-  FORCE_INLINE JsonVariant(RawJson value);
+  FORCE_INLINE JsonVariant(Internals::Unparsed value);

  // Create a JsonVariant containing a reference to an array.
  FORCE_INLINE JsonVariant(JsonArray &array);
@ -104,27 +88,14 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  FORCE_INLINE JsonVariant(JsonObject &object);

  // Get the variant as the specified type.
-  //
-  // short as<signed short>() const;
-  // int as<signed int>() const;
-  // long as<signed long>() const;
+  // short as<short>() const;
+  // int as<int>() const;
+  // long as<long>() const;
  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsSignedIntegral<T>::value,
-                                      T>::type
+  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value, T>::type
  as() const {
    return static_cast<T>(asInteger());
  }
-  //
-  // short as<unsigned short>() const;
-  // int as<unsigned int>() const;
-  // long as<unsigned long>() const;
-  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsUnsignedIntegral<T>::value,
-                                      T>::type
-  as() const {
-    return static_cast<T>(asUnsignedInteger());
-  }
-  //
  // double as<double>() const;
  // float as<float>() const;
  template <typename T>
@ -133,7 +104,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  as() const {
    return static_cast<T>(asFloat());
  }
-  //
  // const String as<String>() const;
  template <typename T>
  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, String>::value,
@ -141,17 +111,14 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  as() const {
    return toString();
  }
-  //
  // const char* as<const char*>() const;
  // const char* as<char*>() const;
  template <typename T>
-  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
-                                    TypeTraits::IsSame<T, char *>::value,
+  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value,
                                const char *>::type
  as() const {
    return asString();
  }
-  //
  // const bool as<bool>() const
  template <typename T>
  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
@ -159,7 +126,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  as() const {
    return asInteger() != 0;
  }
-  //
  // JsonArray& as<JsonArray> const;
  // JsonArray& as<JsonArray&> const;
  // JsonArray& as<const JsonArray&> const;
@ -173,7 +139,6 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  as() const {
    return asArray();
  }
-  //
  // JsonObject& as<JsonObject> const;
  // JsonObject& as<JsonObject&> const;
  // JsonObject& as<const JsonObject&> const;
@ -190,71 +155,8 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {

  // Tells weither the variant has the specified type.
  // Returns true if the variant has type type T, false otherwise.
-  //
-  // short as<short>() const;
-  // int as<int>() const;
-  // long as<long>() const;
  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsIntegral<T>::value,
-                                      bool>::type
-  is() const {
-    return isInteger();
-  }
-  //
-  // double is<double>() const;
-  // float is<float>() const;
-  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsFloatingPoint<T>::value,
-                                      bool>::type
-  is() const {
-    return isFloat();
-  }
-  //
-  // const bool is<bool>() const
-  template <typename T>
-  const typename TypeTraits::EnableIf<TypeTraits::IsSame<T, bool>::value,
-                                      bool>::type
-  is() const {
-    return isBoolean();
-  }
-  //
-  // bool is<const char*>() const;
-  // bool is<char*>() const;
-  template <typename T>
-  typename TypeTraits::EnableIf<TypeTraits::IsSame<T, const char *>::value ||
-                                    TypeTraits::IsSame<T, char *>::value,
-                                bool>::type
-  is() const {
-    return isString();
-  }
-  //
-  // bool is<JsonArray> const;
-  // bool is<JsonArray&> const;
-  // bool is<const JsonArray&> const;
-  template <typename T>
-  typename TypeTraits::EnableIf<
-      TypeTraits::IsSame<
-          typename TypeTraits::RemoveConst<
-              typename TypeTraits::RemoveReference<T>::type>::type,
-          JsonArray>::value,
-      bool>::type
-  is() const {
-    return isArray();
-  }
-  //
-  // JsonObject& as<JsonObject> const;
-  // JsonObject& as<JsonObject&> const;
-  // JsonObject& as<const JsonObject&> const;
-  template <typename T>
-  typename TypeTraits::EnableIf<
-      TypeTraits::IsSame<
-          typename TypeTraits::RemoveConst<
-              typename TypeTraits::RemoveReference<T>::type>::type,
-          JsonObject>::value,
-      bool>::type
-  is() const {
-    return isObject();
-  }
+  bool is() const;

  // Serialize the variant to a JsonWriter
  void writeTo(Internals::JsonWriter &writer) const;
@ -268,22 +170,9 @@ class JsonVariant : public JsonVariantBase<JsonVariant> {
  JsonObject &asObject() const;

 private:
-  // It's not allowed to store a char
-  template <typename T>
-  FORCE_INLINE JsonVariant(T value,
-                           typename TypeTraits::EnableIf<
-                               TypeTraits::IsSame<T, char>::value>::type * = 0);
-
  String toString() const;
  Internals::JsonFloat asFloat() const;
  Internals::JsonInteger asInteger() const;
-  Internals::JsonUInt asUnsignedInteger() const;
-  bool isBoolean() const;
-  bool isFloat() const;
-  bool isInteger() const;
-  bool isArray() const { return _type == Internals::JSON_ARRAY; }
-  bool isObject() const { return _type == Internals::JSON_OBJECT; }
-  bool isString() const { return _type == Internals::JSON_STRING; }

  // The current type of the variant
  Internals::JsonVariantType _type;
@ -302,25 +191,17 @@ inline JsonVariant double_with_n_digits(double value, uint8_t digits) {

 template <typename T>
 struct JsonVariant::IsConstructibleFrom {
-  static const bool value =
-      TypeTraits::IsIntegral<T>::value ||
-      TypeTraits::IsFloatingPoint<T>::value ||
-      TypeTraits::IsSame<T, bool>::value ||
-      TypeTraits::IsSame<T, char *>::value ||
-      TypeTraits::IsSame<T, const char *>::value ||
-      TypeTraits::IsSame<T, RawJson>::value ||
-      TypeTraits::IsSame<T, JsonArray &>::value ||
-      TypeTraits::IsSame<T, const JsonArray &>::value ||
-      TypeTraits::IsSame<T, JsonArraySubscript &>::value ||
-      TypeTraits::IsSame<T, const JsonArraySubscript &>::value ||
-      TypeTraits::IsSame<T, JsonObject &>::value ||
-      TypeTraits::IsSame<T, const JsonObject &>::value ||
-      TypeTraits::IsSame<T, JsonObjectSubscript<const char *> &>::value ||
-      TypeTraits::IsSame<T, const JsonObjectSubscript<const char *> &>::value ||
-      TypeTraits::IsSame<T, JsonObjectSubscript<String> &>::value ||
-      TypeTraits::IsSame<T, const JsonObjectSubscript<String> &>::value ||
-      TypeTraits::IsSame<T, JsonVariant &>::value ||
-      TypeTraits::IsSame<T, const JsonVariant &>::value;
+  static const bool value = TypeTraits::IsIntegral<T>::value ||
+                            TypeTraits::IsFloatingPoint<T>::value ||
+                            TypeTraits::IsSame<T, bool>::value ||
+                            TypeTraits::IsSame<T, char *>::value ||
+                            TypeTraits::IsSame<T, const char *>::value ||
+                            TypeTraits::IsSame<T, JsonArray &>::value ||
+                            TypeTraits::IsSame<T, const JsonArray &>::value ||
+                            TypeTraits::IsSame<T, JsonObject &>::value ||
+                            TypeTraits::IsSame<T, const JsonObject &>::value ||
+                            TypeTraits::IsSame<T, JsonVariant &>::value ||
+                            TypeTraits::IsSame<T, const JsonVariant &>::value;
 };
 }

--- a/include/ArduinoJson/JsonVariant.ipp
+++ b/include/ArduinoJson/JsonVariant.ipp
@ -26,7 +26,7 @@ inline JsonVariant::JsonVariant(const char *value) {
  _content.asString = value;
 }

-inline JsonVariant::JsonVariant(RawJson value) {
+inline JsonVariant::JsonVariant(Internals::Unparsed value) {
  _type = Internals::JSON_UNPARSED;
  _content.asString = value;
 }
@ -46,43 +46,99 @@ inline T JsonVariant::invalid() {
  return T();
 }

-inline Internals::JsonInteger JsonVariant::asInteger() const {
-  using namespace Internals;
-  switch (_type) {
-    case JSON_UNDEFINED:
-      return 0;
-    case JSON_POSITIVE_INTEGER:
-    case JSON_BOOLEAN:
-      return _content.asInteger;
-    case JSON_NEGATIVE_INTEGER:
-      return -static_cast<Internals::JsonInteger>(_content.asInteger);
-    case JSON_STRING:
-    case JSON_UNPARSED:
-      if (!_content.asString) return 0;
-      if (!strcmp("true", _content.asString)) return 1;
-      return parse<Internals::JsonInteger>(_content.asString);
-    default:
-      return static_cast<Internals::JsonInteger>(_content.asFloat);
-  }
+template <typename T>
+inline bool JsonVariant::is() const {
+  return false;
 }

-inline Internals::JsonUInt JsonVariant::asUnsignedInteger() const {
-  using namespace Internals;
-  switch (_type) {
-    case JSON_UNDEFINED:
-      return 0;
-    case JSON_POSITIVE_INTEGER:
-    case JSON_BOOLEAN:
-    case JSON_NEGATIVE_INTEGER:
-      return _content.asInteger;
-    case JSON_STRING:
-    case JSON_UNPARSED:
-      if (!_content.asString) return 0;
-      if (!strcmp("true", _content.asString)) return 1;
-      return parse<Internals::JsonUInt>(_content.asString);
-    default:
-      return static_cast<Internals::JsonUInt>(_content.asFloat);
+template <>  // in .cpp
+bool JsonVariant::is<signed long>() const;
+
+template <>  // in .cpp
+bool JsonVariant::is<double>() const;
+
+template <>  // int .cpp
+bool JsonVariant::is<bool>() const;
+
+template <>
+inline bool JsonVariant::is<char const *>() const {
+  return _type == Internals::JSON_STRING;
+}
+
+template <>
+inline bool JsonVariant::is<float>() const {
+  return is<double>();
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonArray const &>() const {
+  return _type == Internals::JSON_ARRAY;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<JsonObject const &>() const {
+  return _type == Internals::JSON_OBJECT;
+}
+
+template <>
+inline bool JsonVariant::is<signed char>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<signed int>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<signed short>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned char>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned int>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned long>() const {
+  return is<signed long>();
+}
+
+template <>
+inline bool JsonVariant::is<unsigned short>() const {
+  return is<signed long>();
+}
+
+inline Internals::JsonInteger JsonVariant::asInteger() const {
+  if (_type == Internals::JSON_INTEGER || _type == Internals::JSON_BOOLEAN)
+    return _content.asInteger;
+
+  if (_type >= Internals::JSON_FLOAT_0_DECIMALS)
+    return static_cast<Internals::JsonInteger>(_content.asFloat);
+
+  if ((_type == Internals::JSON_STRING || _type == Internals::JSON_UNPARSED) &&
+      _content.asString) {
+    if (!strcmp("true", _content.asString)) return 1;
+    return Internals::parse<Internals::JsonInteger>(_content.asString);
  }
+
+  return 0L;
 }

 #if ARDUINOJSON_ENABLE_STD_STREAM
--- a/include/ArduinoJson/Polyfills/isInfinity.hpp
+++ b/include/ArduinoJson/Polyfills/isInfinity.hpp
@ -1,45 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-// If Visual Studo <= 2012
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-#include <float.h>
-#else
-#include <math.h>
-#endif
-
-namespace ArduinoJson {
-namespace Polyfills {
-
-// If Visual Studo <= 2012
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-template <typename T>
-bool isInfinity(T x) {
-  return !_finite(x);
-}
-#else
-template <typename T>
-bool isInfinity(T x) {
-  return isinf(x);
-}
-
-#ifdef __GLIBC__
-template <>
-inline bool isInfinity<double>(double x) {
-  return isinfl(x);
-}
-
-template <>
-inline bool isInfinity<float>(float x) {
-  return isinff(x);
-}
-#endif
-#endif
-}
-}
--- a/include/ArduinoJson/Polyfills/isNaN.hpp
+++ b/include/ArduinoJson/Polyfills/isNaN.hpp
@ -1,46 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-// If Visual Studo <= 2012
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-#include <float.h>
-#else
-#include <math.h>
-#endif
-
-namespace ArduinoJson {
-namespace Polyfills {
-
-// If Visual Studo <= 2012
-#if defined(_MSC_VER) && _MSC_VER <= 1700
-template <typename T>
-bool isNaN(T x) {
-  return _isnan(x) != 0;
-}
-#else
-template <typename T>
-bool isNaN(T x) {
-  return isnan(x);
-}
-
-#ifdef __GLIBC__
-template <>
-inline bool isNaN<double>(double x) {
-  return isnanl(x);
-}
-
-template <>
-inline bool isNaN<float>(float x) {
-  return isnanf(x);
-}
-#endif
-
-#endif
-}
-}
--- a/include/ArduinoJson/Polyfills/normalize.hpp
+++ b/include/ArduinoJson/Polyfills/normalize.hpp
@ -1,47 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-namespace ArduinoJson {
-namespace Polyfills {
-
-#ifdef ARDUINO
-
-// on embedded platform, favor code size over speed
-
-template <typename T>
-short normalize(T& value) {
-  short powersOf10 = 0;
-  while (value && value < 1) {
-    powersOf10--;
-    value *= 10;
-  }
-  while (value > 10) {
-    powersOf10++;
-    value /= 10;
-  }
-  return powersOf10;
-}
-
-#else
-
-// on non-embedded platform, favor speed over code size
-
-template <typename T>
-short normalize(T& value) {
-  if (value == 0.0) return 0;
-
-  short powersOf10 = static_cast<short>(floor(log10(value)));
-  value /= pow(T(10), powersOf10);
-
-  return powersOf10;
-}
-
-#endif
-}
-}
--- a/include/ArduinoJson/TypeTraits/EnableIf.hpp
+++ b/include/ArduinoJson/TypeTraits/EnableIf.hpp
@ -11,7 +11,7 @@ namespace ArduinoJson {
 namespace TypeTraits {

 // A meta-function that return the type T if Condition is true.
-template <bool Condition, typename T = void>
+template <bool Condition, typename T>
 struct EnableIf {};

 template <typename T>
--- a/include/ArduinoJson/TypeTraits/IsIntegral.hpp
+++ b/include/ArduinoJson/TypeTraits/IsIntegral.hpp
@ -7,10 +7,9 @@

 #pragma once

-#include "../Configuration.hpp"
 #include "IsSame.hpp"
-#include "IsSignedIntegral.hpp"
-#include "IsUnsignedIntegral.hpp"
+
+#include <stdint.h>

 namespace ArduinoJson {
 namespace TypeTraits {
@ -18,8 +17,19 @@ namespace TypeTraits {
 // A meta-function that returns true if T is an integral type.
 template <typename T>
 struct IsIntegral {
-  static const bool value = TypeTraits::IsSignedIntegral<T>::value ||
-                            TypeTraits::IsUnsignedIntegral<T>::value ||
+  static const bool value = TypeTraits::IsSame<T, signed char>::value ||
+                            TypeTraits::IsSame<T, unsigned char>::value ||
+                            TypeTraits::IsSame<T, signed short>::value ||
+                            TypeTraits::IsSame<T, unsigned short>::value ||
+                            TypeTraits::IsSame<T, signed int>::value ||
+                            TypeTraits::IsSame<T, unsigned int>::value ||
+                            TypeTraits::IsSame<T, signed long>::value ||
+                            TypeTraits::IsSame<T, unsigned long>::value ||
+#ifndef ARDUINO
+                            // on a computer add support for 64 bit
+                            TypeTraits::IsSame<T, int64_t>::value ||
+                            TypeTraits::IsSame<T, uint64_t>::value ||
+#endif
                            TypeTraits::IsSame<T, char>::value;
 };
 }
--- a/include/ArduinoJson/TypeTraits/IsReference.hpp
+++ b/include/ArduinoJson/TypeTraits/IsReference.hpp
@ -1,24 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-namespace ArduinoJson {
-namespace TypeTraits {
-
-// A meta-function that returns true if T is a reference
-template <typename T>
-struct IsReference {
-  static const bool value = false;
-};
-
-template <typename T>
-struct IsReference<T&> {
-  static const bool value = true;
-};
-}
-}
--- a/include/ArduinoJson/TypeTraits/IsSignedIntegral.hpp
+++ b/include/ArduinoJson/TypeTraits/IsSignedIntegral.hpp
@ -1,33 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../Configuration.hpp"
-#include "IsSame.hpp"
-
-namespace ArduinoJson {
-namespace TypeTraits {
-
-// A meta-function that returns true if T is an integral type.
-template <typename T>
-struct IsSignedIntegral {
-  static const bool value = TypeTraits::IsSame<T, signed char>::value ||
-                            TypeTraits::IsSame<T, signed short>::value ||
-                            TypeTraits::IsSame<T, signed int>::value ||
-                            TypeTraits::IsSame<T, signed long>::value ||
-#if ARDUINOJSON_USE_LONG_LONG
-                            TypeTraits::IsSame<T, signed long long>::value ||
-#endif
-
-#if ARDUINOJSON_USE_INT64
-                            TypeTraits::IsSame<T, signed __int64>::value ||
-#endif
-                            false;
-};
-}
-}
--- a/include/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp
+++ b/include/ArduinoJson/TypeTraits/IsUnsignedIntegral.hpp
@ -1,33 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#pragma once
-
-#include "../Configuration.hpp"
-#include "IsSame.hpp"
-
-namespace ArduinoJson {
-namespace TypeTraits {
-
-// A meta-function that returns true if T is an integral type.
-template <typename T>
-struct IsUnsignedIntegral {
-  static const bool value = TypeTraits::IsSame<T, unsigned char>::value ||
-                            TypeTraits::IsSame<T, unsigned short>::value ||
-                            TypeTraits::IsSame<T, unsigned int>::value ||
-                            TypeTraits::IsSame<T, unsigned long>::value ||
-#if ARDUINOJSON_USE_LONG_LONG
-                            TypeTraits::IsSame<T, unsigned long long>::value ||
-#endif
-
-#if ARDUINOJSON_USE_INT64
-                            TypeTraits::IsSame<T, unsigned __int64>::value ||
-#endif
-                            false;
-};
-}
-}
--- a/library.json
+++ b/library.json
@ -6,7 +6,7 @@
    "type": "git",
    "url": "https://github.com/bblanchon/ArduinoJson.git"
  },
-  "version": "5.3.0",
+  "version": "5.1.0-beta.1",
  "authors": {
    "name": "Benoit Blanchon",
    "url": "http://blog.benoitblanchon.fr"
--- a/library.properties
+++ b/library.properties
@ -1,5 +1,5 @@
 name=ArduinoJson
-version=5.3.0
+version=5.1.0-beta.1
 author=Benoit Blanchon <blog.benoitblanchon.fr>
 maintainer=Benoit Blanchon <blog.benoitblanchon.fr>
 sentence=An efficient and elegant JSON library for Arduino.
--- a/scripts/create-build-envs.sh
+++ b/scripts/create-build-envs.sh
@ -21,9 +21,9 @@ if [[ $(uname) == MINGW* ]]
 then
 	build-env "Make" "MinGW Makefiles"
 	build-env "SublimeText" "Sublime Text 2 - Ninja"
-	build-env "VisualStudio" "Visual Studio 14 2015"
+	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
+fi
--- a/scripts/travis/arduino.sh
+++ b/scripts/travis/arduino.sh
@ -11,6 +11,5 @@ export PATH=$PATH:/tmp/arduino/
  
 ln -s $PWD /tmp/arduino/libraries/ArduinoJson

-for EXAMPLE in $PWD/examples/*/*.ino; do
-	arduino --verify --board $BOARD $EXAMPLE
-done
+arduino --verify --board $BOARD $PWD/examples/JsonParserExample/JsonParserExample.ino
+arduino --verify --board $BOARD $PWD/examples/JsonGeneratorExample/JsonGeneratorExample.ino
--- a/scripts/travis/clang.sh
+++ b/scripts/travis/clang.sh
@ -1,7 +1,10 @@
 #!/bin/sh -eux

+export CC=clang
+export CXX=clang++
+
 curl -sS https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1

-/tmp/bin/cmake -DCMAKE_CXX_COMPILER=$CMAKE_CXX_COMPILER .
+/tmp/bin/cmake .
 make 
 make test
--- a/scripts/travis/coverage.sh
+++ b/scripts/travis/coverage.sh
@ -1,5 +1,8 @@
 #!/bin/sh -eux

+export CC=gcc
+export CXX=g++
+
 curl https://cmake.org/files/v3.4/cmake-3.4.0-Linux-x86_64.tar.gz | tar xz -C /tmp --strip 1

 /tmp/bin/cmake -DCOVERAGE=true .
--- a/src/Arduino/Print.cpp
+++ b/src/Arduino/Print.cpp
@ -0,0 +1,60 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#ifndef ARDUINO
+
+#include "../../include/ArduinoJson/Arduino/Print.hpp"
+
+#include <stdio.h>
+#include <math.h>  // for isnan() and isinf()
+
+// only for GCC 4.9+
+#if defined(__GNUC__) && \
+    (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9))
+#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) {
+    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::println() { return write('\r') + write('\n'); }
+
+#endif
--- a/src/CMakeLists.txt
+++ b/src/CMakeLists.txt
@ -10,7 +10,7 @@ file(GLOB_RECURSE IPP_FILES ../include/*.ipp)
 file(GLOB_RECURSE CPP_FILES *.cpp)

 if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
-	add_compile_options(
+	add_definitions(
 		-fno-exceptions
 		-fno-rtti
 		-pedantic
@ -40,30 +40,25 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU|Clang)")
 	)
 endif()

-if(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
-	add_compile_options(
+if(CMAKE_CXX_COMPILER_ID MATCHES "(GNU)")
+	add_definitions(
+		-Wlogical-op
+		-Wnoexcept
 		-Wstrict-null-sentinel
 	)
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.5)
-		add_compile_options(-Wlogical-op) # the flag exists in 4.4 but is buggy
-	endif()
-
-	if(CMAKE_CXX_COMPILER_VERSION VERSION_GREATER 4.6)
-		add_compile_options(-Wnoexcept)
-	endif()
 endif()

 if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
-	add_compile_options(
+	add_definitions(
 		-Wc++11-compat
 		-Wdeprecated-register
 	)
 endif()

 if(MSVC)
-	add_definitions(-D_CRT_SECURE_NO_WARNINGS)
-	add_compile_options(-W4)
+	add_definitions(
+		-D_CRT_SECURE_NO_WARNINGS
+		-W4)
 endif()

 add_library(ArduinoJson ${CPP_FILES} ${HPP_FILES} ${IPP_FILES})
--- a/src/Internals/JsonParser.cpp
+++ b/src/Internals/JsonParser.cpp
@ -195,7 +195,7 @@ bool JsonParser::parseStringTo(JsonVariant *destination) {
  if (hasQuotes) {
    *destination = value;
  } else {
-    *destination = RawJson(value);
+    *destination = Unparsed(value);
  }
  return true;
 }
--- a/src/JsonBuffer.cpp
+++ b/src/JsonBuffer.cpp
@ -34,11 +34,6 @@ JsonObject &JsonBuffer::parseObject(char *json, uint8_t nestingLimit) {
  return parser.parseObject();
 }

-JsonVariant JsonBuffer::parse(char *json, uint8_t nestingLimit) {
-  JsonParser parser(this, json, nestingLimit);
-  return parser.parseVariant();
-}
-
 char *JsonBuffer::strdup(const char *source, size_t length) {
  size_t size = length + 1;
  char *dest = static_cast<char *>(alloc(size));
--- a/src/JsonVariant.cpp
+++ b/src/JsonVariant.cpp
@ -26,20 +26,15 @@ const char *JsonVariant::asString() const {
 }

 JsonFloat JsonVariant::asFloat() const {
-  switch (_type) {
-    case JSON_UNDEFINED:
-      return 0;
-    case JSON_POSITIVE_INTEGER:
-    case JSON_BOOLEAN:
-      return static_cast<JsonFloat>(_content.asInteger);
-    case JSON_NEGATIVE_INTEGER:
-      return -static_cast<JsonFloat>(_content.asInteger);
-    case JSON_STRING:
-    case JSON_UNPARSED:
-      return _content.asString ? parse<JsonFloat>(_content.asString) : 0;
-    default:
-      return _content.asFloat;
-  }
+  if (_type >= JSON_FLOAT_0_DECIMALS) return _content.asFloat;
+
+  if (_type == JSON_INTEGER || _type == JSON_BOOLEAN)
+    return static_cast<JsonFloat>(_content.asInteger);
+
+  if ((_type == JSON_STRING || _type == JSON_UNPARSED) && _content.asString)
+    return parse<JsonFloat>(_content.asString);
+
+  return 0.0;
 }

 String JsonVariant::toString() const {
@ -52,7 +47,8 @@ String JsonVariant::toString() const {
  return s;
 }

-bool JsonVariant::isBoolean() const {
+template <>
+bool JsonVariant::is<bool>() const {
  if (_type == JSON_BOOLEAN) return true;

  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
@ -61,9 +57,9 @@ bool JsonVariant::isBoolean() const {
         !strcmp(_content.asString, "false");
 }

-bool JsonVariant::isInteger() const {
-  if (_type == JSON_POSITIVE_INTEGER || _type == JSON_NEGATIVE_INTEGER)
-    return true;
+template <>
+bool JsonVariant::is<signed long>() const {
+  if (_type == JSON_INTEGER) return true;

  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;

@ -74,7 +70,8 @@ bool JsonVariant::isInteger() const {
  return *end == '\0' && errno == 0;
 }

-bool JsonVariant::isFloat() const {
+template <>
+bool JsonVariant::is<double>() const {
  if (_type >= JSON_FLOAT_0_DECIMALS) return true;

  if (_type != JSON_UNPARSED || _content.asString == NULL) return false;
@ -87,39 +84,27 @@ bool JsonVariant::isFloat() const {
 }

 void JsonVariant::writeTo(JsonWriter &writer) const {
-  switch (_type) {
-    case JSON_UNDEFINED:
-      return;
+  if (_type == JSON_ARRAY)
+    _content.asArray->writeTo(writer);

-    case JSON_ARRAY:
-      _content.asArray->writeTo(writer);
-      return;
+  else if (_type == JSON_OBJECT)
+    _content.asObject->writeTo(writer);

-    case JSON_OBJECT:
-      _content.asObject->writeTo(writer);
-      return;
+  else if (_type == JSON_STRING)
+    writer.writeString(_content.asString);

-    case JSON_STRING:
-      writer.writeString(_content.asString);
-      return;
+  else if (_type == JSON_UNPARSED)
+    writer.writeRaw(_content.asString);

-    case JSON_UNPARSED:
-      writer.writeRaw(_content.asString);
-      return;
+  else if (_type == JSON_INTEGER)
+    writer.writeInteger(_content.asInteger);

-    case JSON_NEGATIVE_INTEGER:
-      writer.writeRaw('-');
-    case JSON_POSITIVE_INTEGER:
-      writer.writeInteger(_content.asInteger);
-      return;
+  else if (_type == JSON_BOOLEAN)
+    writer.writeBoolean(_content.asInteger != 0);

-    case JSON_BOOLEAN:
-      writer.writeBoolean(_content.asInteger != 0);
-      return;
-
-    default:
-      uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
-      writer.writeFloat(_content.asFloat, decimals);
+  else if (_type >= JSON_FLOAT_0_DECIMALS) {
+    uint8_t decimals = static_cast<uint8_t>(_type - JSON_FLOAT_0_DECIMALS);
+    writer.writeFloat(_content.asFloat, decimals);
  }
 }
 }
--- a/test/ArduinoString_Tests.cpp
+++ b/test/ArduinoString_Tests.cpp
@ -219,27 +219,3 @@ TEST_F(ArduinoStringTests, JsonObject_PrettyPrintTo) {
  object.prettyPrintTo(json);
  ASSERT_EQ(String("{\r\n  \"key\": \"value\"\r\n}"), json);
 }
-
-TEST_F(ArduinoStringTests, JsonBuffer_GrowWhenAddingNewKey) {
-  JsonObject &object = _jsonBuffer.createObject();
-  String key1("hello"), key2("world");
-
-  object[key1] = 1;
-  size_t sizeBefore = _jsonBuffer.size();
-  object[key2] = 2;
-  size_t sizeAfter = _jsonBuffer.size();
-
-  ASSERT_GT(sizeAfter - sizeBefore, key2.size());
-}
-
-TEST_F(ArduinoStringTests, JsonBuffer_DontGrowWhenReusingKey) {
-  JsonObject &object = _jsonBuffer.createObject();
-  String key("hello");
-
-  object[key] = 1;
-  size_t sizeBefore = _jsonBuffer.size();
-  object[key] = 2;
-  size_t sizeAfter = _jsonBuffer.size();
-
-  ASSERT_EQ(sizeBefore, sizeAfter);
-}
--- a/test/Issue67.cpp
+++ b/test/Issue67.cpp
@ -0,0 +1,48 @@
+// Copyright Benoit Blanchon 2014-2016
+// MIT License
+//
+// Arduino JSON library
+// https://github.com/bblanchon/ArduinoJson
+// If you like this project, please add a star!
+
+#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");
+}
--- a/test/Issue90.cpp
+++ b/test/Issue90.cpp
@ -14,11 +14,13 @@

 #define SUITE Issue90

+using namespace ArduinoJson::Internals;
+
 static const char* superLong =
    "12345678901234567890123456789012345678901234567890123456789012345678901234"
    "5678901234567890123456789012345678901234567890123456789012345678901234567";

-static const JsonVariant variant = RawJson(superLong);
+static const JsonVariant variant = Unparsed(superLong);

 TEST(SUITE, IsNotALong) { ASSERT_FALSE(variant.is<long>()); }

--- a/test/JsonArray_CopyFrom_Tests.cpp
+++ b/test/JsonArray_CopyFrom_Tests.cpp
@ -1,64 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <gtest/gtest.h>
-
-TEST(JsonArray_CopyFrom_Tests, OneDimension) {
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[] = {1, 2, 3};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_TRUE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[1,2,3]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, OneDimension_JsonBufferTooSmall) {
-  const size_t SIZE = JSON_ARRAY_SIZE(2);
-  StaticJsonBuffer<SIZE> jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[] = {1, 2, 3};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_FALSE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[1,2]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, TwoDimensions) {
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_TRUE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[[1,2,3],[4,5,6]]", json);
-}
-
-TEST(JsonArray_CopyFrom_Tests, TwoDimensions_JsonBufferTooSmall) {
-  const size_t SIZE =
-      JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
-  StaticJsonBuffer<SIZE> jsonBuffer;
-  JsonArray& array = jsonBuffer.createArray();
-  char json[32];
-  int source[][3] = {{1, 2, 3}, {4, 5, 6}};
-
-  bool ok = array.copyFrom(source);
-  ASSERT_FALSE(ok);
-
-  array.printTo(json, sizeof(json));
-  ASSERT_STREQ("[[1,2,3],[4,5]]", json);
-}
--- a/test/JsonArray_CopyTo_Tests.cpp
+++ b/test/JsonArray_CopyTo_Tests.cpp
@ -1,56 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <ArduinoJson.h>
-#include <gtest/gtest.h>
-
-TEST(JsonArray_CopyTo_Tests, BiggerOneDimensionIntegerArray) {
-  char json[] = "[1,2,3]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[4] = {0};
-  size_t result = array.copyTo(destination);
-
-  ASSERT_EQ(3, result);
-  ASSERT_EQ(1, destination[0]);
-  ASSERT_EQ(2, destination[1]);
-  ASSERT_EQ(3, destination[2]);
-  ASSERT_EQ(0, destination[3]);
-}
-
-TEST(JsonArray_CopyTo_Tests, SmallerOneDimensionIntegerArray) {
-  char json[] = "[1,2,3]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[2] = {0};
-  size_t result = array.copyTo(destination);
-
-  ASSERT_EQ(2, result);
-  ASSERT_EQ(1, destination[0]);
-  ASSERT_EQ(2, destination[1]);
-}
-
-TEST(JsonArray_CopyTo_Tests, TwoOneDimensionIntegerArray) {
-  char json[] = "[[1,2],[3],[4]]";
-
-  DynamicJsonBuffer jsonBuffer;
-  JsonArray& array = jsonBuffer.parseArray(json);
-
-  int destination[3][2] = {0};
-  array.copyTo(destination);
-
-  ASSERT_EQ(1, destination[0][0]);
-  ASSERT_EQ(2, destination[0][1]);
-  ASSERT_EQ(3, destination[1][0]);
-  ASSERT_EQ(0, destination[1][1]);
-  ASSERT_EQ(4, destination[2][0]);
-  ASSERT_EQ(0, destination[2][1]);
-}
--- a/test/JsonArray_PrintTo_Tests.cpp
+++ b/test/JsonArray_PrintTo_Tests.cpp
@ -96,12 +96,6 @@ TEST_F(JsonArray_PrintTo_Tests, TwoIntegers) {
  outputMustBe("[1,2]");
 }

-TEST_F(JsonArray_PrintTo_Tests, RawJson) {
-  array.add(RawJson("{\"key\":\"value\"}"));
-
-  outputMustBe("[{\"key\":\"value\"}]");
-}
-
 TEST_F(JsonArray_PrintTo_Tests, OneIntegerOverCapacity) {
  array.add(1);
  array.add(2);
--- a/test/JsonArray_Subscript_Tests.cpp
+++ b/test/JsonArray_Subscript_Tests.cpp
@ -5,8 +5,8 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!

-#include <ArduinoJson.h>
 #include <gtest/gtest.h>
+#include <ArduinoJson.h>
 #include <stdint.h>

 class JsonArray_Subscript_Tests : public ::testing::Test {
@ -33,14 +33,12 @@ TEST_(StoreInteger) {
  EXPECT_FALSE(_array[0].is<double>());
 }

-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
-TEST_(StoreLongLong) {
+TEST_(StoreInt64) {
  _array[0] = 9223372036854775807;
-  EXPECT_EQ(9223372036854775807, _array[0].as<long long>());
+  EXPECT_EQ(9223372036854775807, _array[0].as<int64_t>());
  EXPECT_TRUE(_array[0].is<int>());
  EXPECT_FALSE(_array[0].is<double>());
 }
-#endif

 TEST_(StoreDouble) {
  _array[0] = 123.45;
--- a/test/JsonObject_PrintTo_Tests.cpp
+++ b/test/JsonObject_PrintTo_Tests.cpp
@ -8,6 +8,8 @@
 #include <ArduinoJson.h>
 #include <gtest/gtest.h>

+using namespace ArduinoJson::Internals;
+
 class JsonObject_PrintTo_Tests : public testing::Test {
 public:
  JsonObject_PrintTo_Tests() : _object(_jsonBuffer.createObject()) {}
@ -73,12 +75,6 @@ TEST_F(JsonObject_PrintTo_Tests, TwoIntegers) {
  outputMustBe("{\"a\":1,\"b\":2}");
 }

-TEST_F(JsonObject_PrintTo_Tests, RawJson) {
-  _object["a"] = RawJson("[1,2]");
-  _object.set("b", RawJson("[4,5]"));
-  outputMustBe("{\"a\":[1,2],\"b\":[4,5]}");
-}
-
 TEST_F(JsonObject_PrintTo_Tests, TwoDoublesFourDigits) {
  _object["a"] = double_with_n_digits(3.14159265358979323846, 4);
  _object.set("b", 2.71828182845904523536, 4);
--- a/test/JsonParser_Array_Tests.cpp
+++ b/test/JsonParser_Array_Tests.cpp
@ -125,14 +125,6 @@ TEST_F(JsonParser_Array_Tests, TwoDoubles) {
  secondElementMustBe(1e2);
 }

-TEST_F(JsonParser_Array_Tests, UnsignedLong) {
-  whenInputIs("[4294967295]");
-
-  parseMustSucceed();
-  sizeMustBe(1);
-  firstElementMustBe(4294967295UL);
-}
-
 TEST_F(JsonParser_Array_Tests, TwoBooleans) {
  whenInputIs("[true,false]");

--- a/test/JsonParser_Variant_Tests.cpp
+++ b/test/JsonParser_Variant_Tests.cpp
@ -1,76 +0,0 @@
-// Copyright Benoit Blanchon 2014-2016
-// MIT License
-//
-// Arduino JSON library
-// https://github.com/bblanchon/ArduinoJson
-// If you like this project, please add a star!
-
-#include <gtest/gtest.h>
-#include <ArduinoJson.h>
-
-class JsonParser_Variant_Test : public testing::Test {
- protected:
-  void whenInputIs(const char* jsonString) {
-    strcpy(_jsonString, jsonString);
-    _result = _jsonBuffer.parse(_jsonString);
-  }
-
-  template <typename T>
-  void resultMustEqual(T expected) {
-    EXPECT_EQ(expected, _result.as<T>());
-  }
-
-  void resultMustEqual(const char* expected) {
-    EXPECT_STREQ(expected, _result.as<char*>());
-  }
-
-  template <typename T>
-  void resultTypeMustBe() {
-    EXPECT_TRUE(_result.is<T>());
-  }
-
- private:
-  DynamicJsonBuffer _jsonBuffer;
-  JsonVariant _result;
-  char _jsonString[256];
-};
-
-TEST_F(JsonParser_Variant_Test, EmptyObject) {
-  whenInputIs("{}");
-  resultTypeMustBe<JsonObject>();
-}
-
-TEST_F(JsonParser_Variant_Test, EmptyArray) {
-  whenInputIs("[]");
-  resultTypeMustBe<JsonArray>();
-}
-
-TEST_F(JsonParser_Variant_Test, Integer) {
-  whenInputIs("42");
-  resultTypeMustBe<int>();
-  resultMustEqual(42);
-}
-
-TEST_F(JsonParser_Variant_Test, Double) {
-  whenInputIs("3.14");
-  resultTypeMustBe<double>();
-  resultMustEqual(3.14);
-}
-
-TEST_F(JsonParser_Variant_Test, String) {
-  whenInputIs("\"hello world\"");
-  resultTypeMustBe<char*>();
-  resultMustEqual("hello world");
-}
-
-TEST_F(JsonParser_Variant_Test, True) {
-  whenInputIs("true");
-  resultTypeMustBe<bool>();
-  resultMustEqual(true);
-}
-
-TEST_F(JsonParser_Variant_Test, False) {
-  whenInputIs("false");
-  resultTypeMustBe<bool>();
-  resultMustEqual(false);
-}
--- a/test/JsonVariant_As_Tests.cpp
+++ b/test/JsonVariant_As_Tests.cpp
@ -5,9 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!

+#include <gtest/gtest.h>
 #include <ArduinoJson.h>

-#include <gtest/gtest.h>
 #include <stdint.h>

 static const char* null = 0;
@ -32,11 +32,6 @@ TEST(JsonVariant_As_Tests, DoubleAsLong) {
  ASSERT_EQ(4L, variant.as<long>());
 }

-TEST(JsonVariant_As_Tests, DoubleAsUnsigned) {
-  JsonVariant variant = 4.2;
-  ASSERT_EQ(4U, variant.as<unsigned>());
-}
-
 TEST(JsonVariant_As_Tests, DoubleZeroAsBool) {
  JsonVariant variant = 0.0;
  ASSERT_FALSE(variant.as<bool>());
@ -97,16 +92,11 @@ TEST(JsonVariant_As_Tests, LongZeroAsBool) {
  ASSERT_FALSE(variant.as<bool>());
 }

-TEST(JsonVariant_As_Tests, PositiveLongAsDouble) {
+TEST(JsonVariant_As_Tests, LongAsDouble) {
  JsonVariant variant = 42L;
  ASSERT_EQ(42.0, variant.as<double>());
 }

-TEST(JsonVariant_As_Tests, NegativeLongAsDouble) {
-  JsonVariant variant = -42L;
-  ASSERT_EQ(-42.0, variant.as<double>());
-}
-
 TEST(JsonVariant_As_Tests, LongAsString) {
  JsonVariant variant = 42L;
  ASSERT_EQ(String("42"), variant.as<String>());
@ -147,17 +137,15 @@ TEST(JsonVariant_As_Tests, NumberStringAsLong) {
  ASSERT_EQ(42L, variant.as<long>());
 }

-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST(JsonVariant_As_Tests, NumberStringAsInt64Negative) {
  JsonVariant variant = "-9223372036854775808";
-  ASSERT_EQ(-9223372036854775807 - 1, variant.as<long long>());
+  ASSERT_EQ(-9223372036854775807 - 1, variant.as<int64_t>());
 }

 TEST(JsonVariant_As_Tests, NumberStringAsInt64Positive) {
  JsonVariant variant = "9223372036854775807";
-  ASSERT_EQ(9223372036854775807, variant.as<long long>());
+  ASSERT_EQ(9223372036854775807, variant.as<int64_t>());
 }
-#endif

 TEST(JsonVariant_As_Tests, RandomStringAsBool) {
  JsonVariant variant = "hello";
@ -169,16 +157,6 @@ TEST(JsonVariant_As_Tests, RandomStringAsLong) {
  ASSERT_EQ(0L, variant.as<long>());
 }

-TEST(JsonVariant_As_Tests, RandomStringAsConstCharPtr) {
-  JsonVariant variant = "hello";
-  ASSERT_STREQ("hello", variant.as<const char*>());
-}
-
-TEST(JsonVariant_As_Tests, RandomStringAsCharPtr) {
-  JsonVariant variant = "hello";
-  ASSERT_STREQ("hello", variant.as<char*>());
-}
-
 TEST(JsonVariant_As_Tests, RandomStringAsString) {
  JsonVariant variant = "hello";
  ASSERT_EQ(String("hello"), variant.as<String>());
--- a/test/JsonVariant_Is_Tests.cpp
+++ b/test/JsonVariant_Is_Tests.cpp
@ -10,6 +10,8 @@

 #define SUITE JsonVariant_Is_Tests

+using namespace ArduinoJson::Internals;
+
 template <typename TTo, typename TFrom>
 void assertIsNot(TFrom value) {
  JsonVariant variant = value;
@ -74,35 +76,37 @@ TEST(SUITE, StringIsInt) { assertIsNot<int>("42"); }
 TEST(SUITE, StringIsLong) { assertIsNot<long>("42"); }
 TEST(SUITE, StringIsString) { assertIs<const char*>("42"); }

-TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(RawJson("true")); }
-TEST(SUITE, UnparsedTrueIsString) { assertIsNot<const char*>(RawJson("true")); }
-
-TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(RawJson("false")); }
-TEST(SUITE, UnparsedFalseIsString) {
-  assertIsNot<const char*>(RawJson("false"));
+TEST(SUITE, UnparsedTrueIsArra) { assertIsNot<JsonArray&>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsBool) { assertIs<bool>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsDouble) { assertIsNot<double>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsFloat) { assertIsNot<float>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsInt) { assertIsNot<int>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsLong) { assertIsNot<long>(Unparsed("true")); }
+TEST(SUITE, UnparsedTrueIsString) {
+  assertIsNot<const char*>(Unparsed("true"));
 }

-TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(RawJson("42")); }
-TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(RawJson("42")); }
+TEST(SUITE, UnparsedFalseIsArra) { assertIsNot<JsonArray&>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsBool) { assertIs<bool>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsDouble) { assertIsNot<double>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsFloat) { assertIsNot<float>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsInt) { assertIsNot<int>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsLong) { assertIsNot<long>(Unparsed("false")); }
+TEST(SUITE, UnparsedFalseIsString) {
+  assertIsNot<const char*>(Unparsed("false"));
+}

-TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(RawJson("4.2e-10")); }
-TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(RawJson("4.2")); }
+TEST(SUITE, UnparsedIntIsArra) { assertIsNot<JsonArray&>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsBool) { assertIsNot<bool>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsDouble) { assertIsNot<double>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsFloat) { assertIsNot<float>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsInt) { assertIs<int>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsLong) { assertIs<long>(Unparsed("42")); }
+TEST(SUITE, UnparsedIntIsString) { assertIsNot<const char*>(Unparsed("42")); }
+
+TEST(SUITE, UnparsedFloatIsBool) { assertIsNot<bool>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsDouble) { assertIs<double>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsFloat) { assertIs<float>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsInt) { assertIsNot<int>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsLong) { assertIsNot<long>(Unparsed("4.2e-10")); }
+TEST(SUITE, UnparsedFloatIsStr) { assertIsNot<const char*>(Unparsed("4.2")); }
--- a/test/JsonVariant_PrintTo_Tests.cpp
+++ b/test/JsonVariant_PrintTo_Tests.cpp
@ -7,7 +7,6 @@

 #include <gtest/gtest.h>
 #include <ArduinoJson.h>
-#include <limits>

 class JsonVariant_PrintTo_Tests : public testing::Test {
 protected:
@ -16,8 +15,8 @@ class JsonVariant_PrintTo_Tests : public testing::Test {
  void outputMustBe(const char *expected) {
    char buffer[256] = "";
    size_t n = variant.printTo(buffer, sizeof(buffer));
-    ASSERT_STREQ(expected, buffer);
-    ASSERT_EQ(strlen(expected), n);
+    EXPECT_STREQ(expected, buffer);
+    EXPECT_EQ(strlen(expected), n);
  }
 };

@ -48,59 +47,19 @@ TEST_F(JsonVariant_PrintTo_Tests, DoubleFourDigits) {
  outputMustBe("3.1416");
 }

-TEST_F(JsonVariant_PrintTo_Tests, Infinity) {
-  variant = std::numeric_limits<double>::infinity();
-  outputMustBe("Infinity");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, MinusInfinity) {
-  variant = -std::numeric_limits<double>::infinity();
-  outputMustBe("-Infinity");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, SignalingNaN) {
-  variant = std::numeric_limits<double>::signaling_NaN();
-  outputMustBe("NaN");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, QuietNaN) {
-  variant = std::numeric_limits<double>::quiet_NaN();
-  outputMustBe("NaN");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, VeryBigPositiveDouble) {
-  variant = JsonVariant(3.14159265358979323846e42, 4);
-  outputMustBe("3.1416e42");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, VeryBigNegativeDouble) {
-  variant = JsonVariant(-3.14159265358979323846e42, 4);
-  outputMustBe("-3.1416e42");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, VerySmallPositiveDouble) {
-  variant = JsonVariant(3.14159265358979323846e-42, 4);
-  outputMustBe("3.1416e-42");
-}
-
-TEST_F(JsonVariant_PrintTo_Tests, VerySmallNegativeDouble) {
-  variant = JsonVariant(-3.14159265358979323846e-42, 4);
-  outputMustBe("-3.1416e-42");
-}
-
 TEST_F(JsonVariant_PrintTo_Tests, Integer) {
  variant = 42;
  outputMustBe("42");
 }

-TEST_F(JsonVariant_PrintTo_Tests, NegativeLong) {
-  variant = -42;
-  outputMustBe("-42");
+TEST_F(JsonVariant_PrintTo_Tests, Long) {
+  variant = 42L;
+  outputMustBe("42");
 }

-TEST_F(JsonVariant_PrintTo_Tests, UnsignedLong) {
-  variant = 4294967295UL;
-  outputMustBe("4294967295");
+TEST_F(JsonVariant_PrintTo_Tests, Char) {
+  variant = '*';
+  outputMustBe("42");
 }

 TEST_F(JsonVariant_PrintTo_Tests, True) {
@ -113,7 +72,6 @@ TEST_F(JsonVariant_PrintTo_Tests, OneFalse) {
  outputMustBe("false");
 }

-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_PrintTo_Tests, NegativeInt64) {
  variant = -9223372036854775807 - 1;
  outputMustBe("-9223372036854775808");
@ -123,9 +81,3 @@ TEST_F(JsonVariant_PrintTo_Tests, PositiveInt64) {
  variant = 9223372036854775807;
  outputMustBe("9223372036854775807");
 }
-
-TEST_F(JsonVariant_PrintTo_Tests, UInt64) {
-  variant = 18446744073709551615;
-  outputMustBe("18446744073709551615");
-}
-#endif
--- a/test/JsonVariant_Storage_Tests.cpp
+++ b/test/JsonVariant_Storage_Tests.cpp
@ -5,9 +5,9 @@
 // https://github.com/bblanchon/ArduinoJson
 // If you like this project, please add a star!

-#include <gtest/gtest.h>
 #include <stdint.h>
 #include <limits>
+#include <gtest/gtest.h>
 #include <ArduinoJson.h>

 class JsonVariant_Storage_Tests : public ::testing::Test {
@ -37,11 +37,9 @@ class JsonVariant_Storage_Tests : public ::testing::Test {
  }
 };

-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_Storage_Tests, SizeOfJsonInteger) {
  ASSERT_EQ(8, sizeof(Internals::JsonInteger));
 }
-#endif

 TEST_F(JsonVariant_Storage_Tests, Null) { testValue<const char *>(NULL); }
 TEST_F(JsonVariant_Storage_Tests, String) { testValue<const char *>("hello"); }
@ -59,21 +57,15 @@ TEST_F(JsonVariant_Storage_Tests, UChar) { testNumericType<unsigned char>(); }
 TEST_F(JsonVariant_Storage_Tests, UInt) { testNumericType<unsigned int>(); }
 TEST_F(JsonVariant_Storage_Tests, ULong) { testNumericType<unsigned long>(); }
 TEST_F(JsonVariant_Storage_Tests, UShort) { testNumericType<unsigned short>(); }
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
-TEST_F(JsonVariant_Storage_Tests, LongLong) { testNumericType<unsigned long long>(); }
-TEST_F(JsonVariant_Storage_Tests, ULongLong) { testNumericType<unsigned long long>(); }
-#endif

 TEST_F(JsonVariant_Storage_Tests, Int8) { testNumericType<int8_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint8) { testNumericType<uint8_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Int16) { testNumericType<int16_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint16) { testNumericType<uint16_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Int32) { testNumericType<int32_t>(); }
-TEST_F(JsonVariant_Storage_Tests, Uint32) { testNumericType<uint32_t>(); }
-#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
 TEST_F(JsonVariant_Storage_Tests, Int64) { testNumericType<int64_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint8) { testNumericType<uint8_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint16) { testNumericType<uint16_t>(); }
+TEST_F(JsonVariant_Storage_Tests, Uint32) { testNumericType<uint32_t>(); }
 TEST_F(JsonVariant_Storage_Tests, Uint64) { testNumericType<uint64_t>(); }
-#endif

 TEST_F(JsonVariant_Storage_Tests, CanStoreObject) {
  DynamicJsonBuffer jsonBuffer;
--- a/test/JsonVariant_Undefined_Tests.cpp
+++ b/test/JsonVariant_Undefined_Tests.cpp
@ -17,10 +17,6 @@ TEST_F(JsonVariant_Undefined_Tests, AsLongReturns0) {
  EXPECT_EQ(0, variant.as<long>());
 }

-TEST_F(JsonVariant_Undefined_Tests, AsUnsignedReturns0) {
-  EXPECT_EQ(0, variant.as<unsigned>());
-}
-
 TEST_F(JsonVariant_Undefined_Tests, AsStringReturnsNull) {
  EXPECT_EQ(0, variant.asString());
 }
Author	SHA1	Message	Date
Benoit Blanchon	5f589d3836	Set version to 5.1.0-beta.1	2016-02-01 21:26:15 +01:00
Benoit Blanchon	ed4ec6ed2e	Added support of `long long` (issue #171 )	2016-02-01 21:17:32 +01:00