Moved ancillary files to extras/ (fixes #1011)

extras/tests/JsonSerializer/CMakeLists.txt

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

extras/tests/JsonSerializer/JsonArray.cpp

@@ -0,0 +1,129 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// 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)") {
+  StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
+  JsonArray array = doc.to<JsonArray>();
+
+  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("serialized(const char*)") {
+    array.add(serialized("{\"key\":\"value\"}"));
+
+    check(array, "[{\"key\":\"value\"}]");
+  }
+
+  SECTION("serialized(char*)") {
+    char tmp[] = "{\"key\":\"value\"}";
+    array.add(serialized(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, "[{}]");
+  }
+}

extras/tests/JsonSerializer/JsonArrayPretty.cpp

@@ -0,0 +1,75 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// 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)") {
+  DynamicJsonDocument doc(4096);
+  JsonArray array = doc.to<JsonArray>();
+
+  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"
+          "]");
+  }
+}

extras/tests/JsonSerializer/JsonObject.cpp

@@ -0,0 +1,116 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// 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)") {
+  DynamicJsonDocument doc(4096);
+  JsonObject obj = doc.to<JsonObject>();
+
+  SECTION("EmptyObject") {
+    check(obj, "{}");
+  }
+
+  SECTION("TwoStrings") {
+    obj["key1"] = "value1";
+    obj["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["b"] = 2;
+    check(obj, "{\"a\":1,\"b\":2}");
+  }
+
+  SECTION("serialized(const char*)") {
+    obj["a"] = serialized("[1,2]");
+    obj["b"] = serialized("[4,5]");
+    check(obj, "{\"a\":[1,2],\"b\":[4,5]}");
+  }
+
+  SECTION("Two doubles") {
+    obj["a"] = 12.34;
+    obj["b"] = 56.78;
+    check(obj, "{\"a\":12.34,\"b\":56.78}");
+  }
+
+  SECTION("TwoNull") {
+    obj["a"] = static_cast<char *>(0);
+    obj["b"] = static_cast<char *>(0);
+    check(obj, "{\"a\":null,\"b\":null}");
+  }
+
+  SECTION("TwoBooleans") {
+    obj["a"] = true;
+    obj["b"] = false;
+    check(obj, "{\"a\":true,\"b\":false}");
+  }
+
+  SECTION("ThreeNestedArrays") {
+    DynamicJsonDocument b(4096);
+    DynamicJsonDocument c(4096);
+
+    obj.createNestedArray("a");
+    obj["b"] = b.to<JsonArray>();
+    obj["c"] = c.to<JsonArray>();
+
+    check(obj, "{\"a\":[],\"b\":[],\"c\":[]}");
+  }
+
+  SECTION("ThreeNestedObjects") {
+    DynamicJsonDocument b(4096);
+    DynamicJsonDocument c(4096);
+
+    obj.createNestedObject("a");
+    obj["b"] = b.to<JsonObject>();
+    obj["c"] = c.to<JsonObject>();
+
+    check(obj, "{\"a\":{},\"b\":{},\"c\":{}}");
+  }
+}

extras/tests/JsonSerializer/JsonObjectPretty.cpp

@@ -0,0 +1,76 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// 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)") {
+  DynamicJsonDocument doc(4096);
+  JsonObject obj = doc.to<JsonObject>();
+
+  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"
+          "}");
+  }
+}

extras/tests/JsonSerializer/JsonVariant.cpp

@@ -0,0 +1,85 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <limits>
+
+template <typename T>
+void check(T value, const std::string &expected) {
+  DynamicJsonDocument doc(4096);
+  doc.to<JsonVariant>().set(value);
+  char buffer[256] = "";
+  size_t returnValue = serializeJson(doc, buffer, sizeof(buffer));
+  REQUIRE(expected == buffer);
+  REQUIRE(expected.size() == returnValue);
+}
+
+TEST_CASE("serializeJson(JsonVariant)") {
+  SECTION("Undefined") {
+    check(JsonVariant(), "null");
+  }
+
+  SECTION("Null string") {
+    check(static_cast<char *>(0), "null");
+  }
+
+  SECTION("const char*") {
+    check("hello", "\"hello\"");
+  }
+
+  SECTION("string") {
+    check(std::string("hello"), "\"hello\"");
+  }
+
+  SECTION("SerializedValue<const char*>") {
+    check(serialized("[1,2]"), "[1,2]");
+  }
+
+  SECTION("SerializedValue<std::string>") {
+    check(serialized(std::string("[1,2]")), "[1,2]");
+  }
+
+  SECTION("Double") {
+    check(3.1415927, "3.1415927");
+  }
+
+  SECTION("Zero") {
+    check(0, "0");
+  }
+
+  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
+  SECTION("NegativeInt64") {
+    check(-9223372036854775807 - 1, "-9223372036854775808");
+  }
+
+  SECTION("PositiveInt64") {
+    check(9223372036854775807, "9223372036854775807");
+  }
+
+  SECTION("UInt64") {
+    check(18446744073709551615U, "18446744073709551615");
+  }
+#endif
+}

extras/tests/JsonSerializer/misc.cpp

@@ -0,0 +1,46 @@
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <limits>
+
+template <typename T>
+void check(T value, const std::string &expected) {
+  DynamicJsonDocument doc(4096);
+  doc.to<JsonVariant>().set(value);
+  char buffer[256] = "";
+  size_t returnValue = serializeJson(doc, buffer, sizeof(buffer));
+  REQUIRE(expected == buffer);
+  REQUIRE(expected.size() == returnValue);
+}
+
+TEST_CASE("serializeJson(MemberProxy)") {
+  DynamicJsonDocument doc(4096);
+  deserializeJson(doc, "{\"hello\":42}");
+  JsonObject obj = doc.as<JsonObject>();
+  std::string result;
+
+  serializeJson(obj["hello"], result);
+
+  REQUIRE(result == "42");
+}
+
+TEST_CASE("serializeJson(ElementProxy)") {
+  DynamicJsonDocument doc(4096);
+  deserializeJson(doc, "[42]");
+  JsonArray arr = doc.as<JsonArray>();
+  std::string result;
+
+  serializeJson(arr[0], result);
+
+  REQUIRE(result == "42");
+}
+
+TEST_CASE("serializeJson(JsonVariantSubscript)") {
+  DynamicJsonDocument doc(4096);
+  deserializeJson(doc, "[42]");
+  JsonVariant var = doc.as<JsonVariant>();
+  std::string result;
+
+  serializeJson(var[0], result);
+
+  REQUIRE(result == "42");
+}

extras/tests/JsonSerializer/std_stream.cpp

@@ -0,0 +1,66 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <sstream>
+
+TEST_CASE("operator<<(std::ostream)") {
+  DynamicJsonDocument doc(4096);
+  std::ostringstream os;
+
+  SECTION("JsonVariant containing false") {
+    JsonVariant variant = doc.to<JsonVariant>();
+
+    variant.set(false);
+    os << variant;
+
+    REQUIRE("false" == os.str());
+  }
+
+  SECTION("JsonVariant containing string") {
+    JsonVariant variant = doc.to<JsonVariant>();
+
+    variant.set("coucou");
+    os << variant;
+
+    REQUIRE("\"coucou\"" == os.str());
+  }
+
+  SECTION("JsonObject") {
+    JsonObject object = doc.to<JsonObject>();
+    object["key"] = "value";
+
+    os << object;
+
+    REQUIRE("{\"key\":\"value\"}" == os.str());
+  }
+
+  SECTION("MemberProxy") {
+    JsonObject object = doc.to<JsonObject>();
+    object["key"] = "value";
+
+    os << object["key"];
+
+    REQUIRE("\"value\"" == os.str());
+  }
+
+  SECTION("JsonArray") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add("value");
+
+    os << array;
+
+    REQUIRE("[\"value\"]" == os.str());
+  }
+
+  SECTION("ElementProxy") {
+    JsonArray array = doc.to<JsonArray>();
+    array.add("value");
+
+    os << array[0];
+
+    REQUIRE("\"value\"" == os.str());
+  }
+}

extras/tests/JsonSerializer/std_string.cpp

@@ -0,0 +1,47 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("serialize JsonArray to std::string") {
+  DynamicJsonDocument doc(4096);
+  JsonArray array = doc.to<JsonArray>();
+  array.add(4);
+  array.add(2);
+
+  SECTION("serializeJson()") {
+    std::string json;
+    serializeJson(array, json);
+
+    REQUIRE("[4,2]" == json);
+  }
+
+  SECTION("serializeJsonPretty") {
+    std::string json;
+    serializeJsonPretty(array, json);
+
+    REQUIRE("[\r\n  4,\r\n  2\r\n]" == json);
+  }
+}
+
+TEST_CASE("serialize JsonObject to std::string") {
+  DynamicJsonDocument doc(4096);
+  JsonObject obj = doc.to<JsonObject>();
+  obj["key"] = "value";
+
+  SECTION("object") {
+    std::string json;
+    serializeJson(doc, json);
+
+    REQUIRE("{\"key\":\"value\"}" == json);
+  }
+
+  SECTION("serializeJsonPretty") {
+    std::string json;
+    serializeJsonPretty(doc, json);
+
+    REQUIRE("{\r\n  \"key\": \"value\"\r\n}" == json);
+  }
+}