Replaced printTo() with serializeJson()

* Added `serializeJson()` and `serializeJsonPretty()`
* Added `measureJson()` and `measureJsonPretty()`
* Removed `printTo()` and `prettyPrintTo()`
* Removed `measureLength()` and `measurePrettyLength()`

test/JsonSerializer/CMakeLists.txt

@@ -0,0 +1,14 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
+# MIT License
+
+add_executable(JsonSerializerTests
+	JsonArray.cpp
+	JsonArrayPretty.cpp
+	JsonObject.cpp
+	JsonObjectPretty.cpp
+	JsonVariant.cpp
+)
+
+target_link_libraries(JsonSerializerTests catch)
+add_test(JsonSerializer JsonSerializerTests)

test/JsonSerializer/JsonArray.cpp

@@ -0,0 +1,128 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+static void check(JsonArray &array, std::string expected) {
+  std::string actual;
+  size_t actualLen = serializeJson(array, actual);
+  REQUIRE(expected == actual);
+  REQUIRE(actualLen == expected.size());
+  size_t measuredLen = measureJson(array);
+  REQUIRE(measuredLen == expected.size());
+}
+
+TEST_CASE("serializeJson(JsonArray)") {
+  StaticJsonArray<JSON_ARRAY_SIZE(2)> array;
+
+  SECTION("Empty") {
+    check(array, "[]");
+  }
+
+  SECTION("Null") {
+    array.add(static_cast<char *>(0));
+
+    check(array, "[null]");
+  }
+
+  SECTION("OneString") {
+    array.add("hello");
+
+    check(array, "[\"hello\"]");
+  }
+
+  SECTION("TwoStrings") {
+    array.add("hello");
+    array.add("world");
+
+    check(array, "[\"hello\",\"world\"]");
+  }
+
+  SECTION("OneStringOverCapacity") {
+    array.add("hello");
+    array.add("world");
+    array.add("lost");
+
+    check(array, "[\"hello\",\"world\"]");
+  }
+
+  SECTION("One double") {
+    array.add(3.1415927);
+    check(array, "[3.1415927]");
+  }
+
+  SECTION("OneInteger") {
+    array.add(1);
+
+    check(array, "[1]");
+  }
+
+  SECTION("TwoIntegers") {
+    array.add(1);
+    array.add(2);
+
+    check(array, "[1,2]");
+  }
+
+  SECTION("RawJson(const char*)") {
+    array.add(RawJson("{\"key\":\"value\"}"));
+
+    check(array, "[{\"key\":\"value\"}]");
+  }
+
+  SECTION("RawJson(char*)") {
+    char tmp[] = "{\"key\":\"value\"}";
+    array.add(RawJson(tmp));
+
+    check(array, "[{\"key\":\"value\"}]");
+  }
+
+  SECTION("OneIntegerOverCapacity") {
+    array.add(1);
+    array.add(2);
+    array.add(3);
+
+    check(array, "[1,2]");
+  }
+
+  SECTION("OneTrue") {
+    array.add(true);
+
+    check(array, "[true]");
+  }
+
+  SECTION("OneFalse") {
+    array.add(false);
+
+    check(array, "[false]");
+  }
+
+  SECTION("TwoBooleans") {
+    array.add(false);
+    array.add(true);
+
+    check(array, "[false,true]");
+  }
+
+  SECTION("OneBooleanOverCapacity") {
+    array.add(false);
+    array.add(true);
+    array.add(false);
+
+    check(array, "[false,true]");
+  }
+
+  SECTION("OneEmptyNestedArray") {
+    array.createNestedArray();
+
+    check(array, "[[]]");
+  }
+
+  SECTION("OneEmptyNestedHash") {
+    array.createNestedObject();
+
+    check(array, "[{}]");
+  }
+}

test/JsonSerializer/JsonArrayPretty.cpp

@@ -0,0 +1,74 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+static void check(JsonArray& array, std::string expected) {
+  std::string actual;
+  size_t actualLen = serializeJsonPretty(array, actual);
+  size_t measuredLen = measureJsonPretty(array);
+  CHECK(actualLen == expected.size());
+  CHECK(measuredLen == expected.size());
+  REQUIRE(expected == actual);
+}
+
+TEST_CASE("serializeJsonPretty(JsonArray)") {
+  DynamicJsonArray array;
+
+  SECTION("Empty") {
+    check(array, "[]");
+  }
+
+  SECTION("OneElement") {
+    array.add(1);
+
+    check(array,
+          "[\r\n"
+          "  1\r\n"
+          "]");
+  }
+
+  SECTION("TwoElements") {
+    array.add(1);
+    array.add(2);
+
+    check(array,
+          "[\r\n"
+          "  1,\r\n"
+          "  2\r\n"
+          "]");
+  }
+
+  SECTION("EmptyNestedArrays") {
+    array.createNestedArray();
+    array.createNestedArray();
+
+    check(array,
+          "[\r\n"
+          "  [],\r\n"
+          "  []\r\n"
+          "]");
+  }
+
+  SECTION("NestedArrays") {
+    JsonArray& nested1 = array.createNestedArray();
+    nested1.add(1);
+    nested1.add(2);
+
+    JsonObject& nested2 = array.createNestedObject();
+    nested2["key"] = 3;
+
+    check(array,
+          "[\r\n"
+          "  [\r\n"
+          "    1,\r\n"
+          "    2\r\n"
+          "  ],\r\n"
+          "  {\r\n"
+          "    \"key\": 3\r\n"
+          "  }\r\n"
+          "]");
+  }
+}

test/JsonSerializer/JsonObject.cpp

@@ -0,0 +1,114 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <string>
+
+void check(const JsonObject &obj, const std::string &expected) {
+  char actual[256];
+  size_t actualLen = serializeJson(obj, actual);
+  size_t measuredLen = measureJson(obj);
+
+  REQUIRE(expected == actual);
+  REQUIRE(expected.size() == actualLen);
+  REQUIRE(expected.size() == measuredLen);
+}
+
+TEST_CASE("serializeJson(JsonObject)") {
+  DynamicJsonObject obj;
+
+  SECTION("EmptyObject") {
+    check(obj, "{}");
+  }
+
+  SECTION("TwoStrings") {
+    obj["key1"] = "value1";
+    obj.set("key2", "value2");
+
+    check(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}");
+  }
+
+  SECTION("RemoveFirst") {
+    obj["key1"] = "value1";
+    obj["key2"] = "value2";
+    obj.remove("key1");
+
+    check(obj, "{\"key2\":\"value2\"}");
+  }
+
+  SECTION("RemoveLast") {
+    obj["key1"] = "value1";
+    obj["key2"] = "value2";
+    obj.remove("key2");
+
+    check(obj, "{\"key1\":\"value1\"}");
+  }
+
+  SECTION("RemoveUnexistingKey") {
+    obj["key1"] = "value1";
+    obj["key2"] = "value2";
+    obj.remove("key3");
+
+    check(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}");
+  }
+
+  SECTION("ReplaceExistingKey") {
+    obj["key"] = "value1";
+    obj["key"] = "value2";
+
+    check(obj, "{\"key\":\"value2\"}");
+  }
+
+  SECTION("TwoIntegers") {
+    obj["a"] = 1;
+    obj.set("b", 2);
+    check(obj, "{\"a\":1,\"b\":2}");
+  }
+
+  SECTION("RawJson") {
+    obj["a"] = RawJson("[1,2]");
+    obj.set("b", RawJson("[4,5]"));
+    check(obj, "{\"a\":[1,2],\"b\":[4,5]}");
+  }
+
+  SECTION("Two doubles") {
+    obj["a"] = 12.34;
+    obj.set("b", 56.78);
+    check(obj, "{\"a\":12.34,\"b\":56.78}");
+  }
+
+  SECTION("TwoNull") {
+    obj["a"] = static_cast<char *>(0);
+    obj.set("b", static_cast<char *>(0));
+    check(obj, "{\"a\":null,\"b\":null}");
+  }
+
+  SECTION("TwoBooleans") {
+    obj["a"] = true;
+    obj.set("b", false);
+    check(obj, "{\"a\":true,\"b\":false}");
+  }
+
+  SECTION("ThreeNestedArrays") {
+    DynamicJsonArray b, c;
+
+    obj.createNestedArray("a");
+    obj["b"] = b;
+    obj.set("c", c);
+
+    check(obj, "{\"a\":[],\"b\":[],\"c\":[]}");
+  }
+
+  SECTION("ThreeNestedObjects") {
+    DynamicJsonObject b;
+    DynamicJsonObject c;
+
+    obj.createNestedObject("a");
+    obj["b"] = b;
+    obj.set("c", c);
+
+    check(obj, "{\"a\":{},\"b\":{},\"c\":{}}");
+  }
+}

test/JsonSerializer/JsonObjectPretty.cpp

@@ -0,0 +1,75 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <string>
+
+void check(const JsonObject &obj, const std::string expected) {
+  char json[256];
+
+  size_t actualLen = serializeJsonPretty(obj, json);
+  size_t measuredLen = measureJsonPretty(obj);
+
+  REQUIRE(json == expected);
+  REQUIRE(expected.size() == actualLen);
+  REQUIRE(expected.size() == measuredLen);
+}
+
+TEST_CASE("serializeJsonPretty(JsonObject)") {
+  DynamicJsonObject obj;
+
+  SECTION("EmptyObject") {
+    check(obj, "{}");
+  }
+
+  SECTION("OneMember") {
+    obj["key"] = "value";
+
+    check(obj,
+          "{\r\n"
+          "  \"key\": \"value\"\r\n"
+          "}");
+  }
+
+  SECTION("TwoMembers") {
+    obj["key1"] = "value1";
+    obj["key2"] = "value2";
+
+    check(obj,
+          "{\r\n"
+          "  \"key1\": \"value1\",\r\n"
+          "  \"key2\": \"value2\"\r\n"
+          "}");
+  }
+
+  SECTION("EmptyNestedContainers") {
+    obj.createNestedObject("key1");
+    obj.createNestedArray("key2");
+
+    check(obj,
+          "{\r\n"
+          "  \"key1\": {},\r\n"
+          "  \"key2\": []\r\n"
+          "}");
+  }
+
+  SECTION("NestedContainers") {
+    JsonObject &nested1 = obj.createNestedObject("key1");
+    nested1["a"] = 1;
+
+    JsonArray &nested2 = obj.createNestedArray("key2");
+    nested2.add(2);
+
+    check(obj,
+          "{\r\n"
+          "  \"key1\": {\r\n"
+          "    \"a\": 1\r\n"
+          "  },\r\n"
+          "  \"key2\": [\r\n"
+          "    2\r\n"
+          "  ]\r\n"
+          "}");
+  }
+}

test/JsonSerializer/JsonVariant.cpp

@@ -0,0 +1,66 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <limits>
+
+void check(JsonVariant variant, const std::string &expected) {
+  char buffer[256] = "";
+  size_t returnValue = serializeJson(variant, buffer, sizeof(buffer));
+  REQUIRE(expected == buffer);
+  REQUIRE(expected.size() == returnValue);
+}
+
+TEST_CASE("serializeJson(JsonVariant)") {
+  SECTION("Empty") {
+    check(JsonVariant(), "");
+  }
+
+  SECTION("Null") {
+    check(static_cast<char *>(0), "null");
+  }
+
+  SECTION("String") {
+    check("hello", "\"hello\"");
+  }
+
+  SECTION("Double") {
+    check(3.1415927, "3.1415927");
+  }
+
+  SECTION("Integer") {
+    check(42, "42");
+  }
+
+  SECTION("NegativeLong") {
+    check(-42, "-42");
+  }
+
+  SECTION("UnsignedLong") {
+    check(4294967295UL, "4294967295");
+  }
+
+  SECTION("True") {
+    check(true, "true");
+  }
+
+  SECTION("OneFalse") {
+    check(false, "false");
+  }
+
+#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
+  SECTION("NegativeInt64") {
+    check(-9223372036854775807 - 1, "-9223372036854775808");
+  }
+
+  SECTION("PositiveInt64") {
+    check(9223372036854775807, "9223372036854775807");
+  }
+
+  SECTION("UInt64") {
+    check(18446744073709551615U, "18446744073709551615");
+  }
+#endif
+}