add arduino json lib

#182

lib/ArduinoJson/test/DynamicJsonBuffer/CMakeLists.txt

@@ -0,0 +1,15 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2018
+# MIT License
+
+add_executable(DynamicJsonBufferTests 
+	alloc.cpp
+	createArray.cpp
+	createObject.cpp
+	no_memory.cpp
+	size.cpp
+	startString.cpp
+)
+
+target_link_libraries(DynamicJsonBufferTests catch)
+add_test(DynamicJsonBuffer DynamicJsonBufferTests)

lib/ArduinoJson/test/DynamicJsonBuffer/alloc.cpp

@@ -0,0 +1,77 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+#include <sstream>
+
+using namespace ArduinoJson::Internals;
+
+static bool isAligned(void* ptr) {
+  const size_t mask = sizeof(void*) - 1;
+  size_t addr = reinterpret_cast<size_t>(ptr);
+  return (addr & mask) == 0;
+}
+
+std::stringstream allocatorLog;
+
+struct SpyingAllocator : DefaultAllocator {
+  void* allocate(size_t n) {
+    allocatorLog << "A" << (n - DynamicJsonBuffer::EmptyBlockSize);
+    return DefaultAllocator::allocate(n);
+  }
+  void deallocate(void* p) {
+    allocatorLog << "F";
+    return DefaultAllocator::deallocate(p);
+  }
+};
+
+TEST_CASE("DynamicJsonBuffer::alloc()") {
+  SECTION("Returns different pointers") {
+    DynamicJsonBuffer buffer;
+    void* p1 = buffer.alloc(1);
+    void* p2 = buffer.alloc(2);
+    REQUIRE(p1 != p2);
+  }
+
+  SECTION("Doubles allocation size when full") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(1);
+      buffer.alloc(1);
+    }
+    REQUIRE(allocatorLog.str() == "A1A2FF");
+  }
+
+  SECTION("Resets allocation size after clear()") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(1);
+      buffer.alloc(1);
+      buffer.clear();
+      buffer.alloc(1);
+    }
+    REQUIRE(allocatorLog.str() == "A1A2FFA1F");
+  }
+
+  SECTION("Makes a big allocation when needed") {
+    allocatorLog.str("");
+    {
+      DynamicJsonBufferBase<SpyingAllocator> buffer(1);
+      buffer.alloc(42);
+    }
+    REQUIRE(allocatorLog.str() == "A42F");
+  }
+
+  SECTION("Alignment") {
+    // make room for two but not three
+    DynamicJsonBuffer tinyBuf(2 * sizeof(void*) + 1);
+
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this on is aligned by design
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this one fits in the first block
+    REQUIRE(isAligned(tinyBuf.alloc(1)));  // this one requires a new block
+  }
+}

lib/ArduinoJson/test/DynamicJsonBuffer/createArray.cpp

@@ -0,0 +1,28 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("DynamicJsonBuffer::createArray()") {
+  DynamicJsonBuffer jsonBuffer;
+  JsonArray &array = jsonBuffer.createArray();
+
+  SECTION("GrowsWithArray") {
+    REQUIRE(JSON_ARRAY_SIZE(0) == jsonBuffer.size());
+
+    array.add("hello");
+    REQUIRE(JSON_ARRAY_SIZE(1) == jsonBuffer.size());
+
+    array.add("world");
+    REQUIRE(JSON_ARRAY_SIZE(2) == jsonBuffer.size());
+  }
+
+  SECTION("CanAdd1000Values") {
+    for (size_t i = 1; i <= 1000; i++) {
+      array.add("hello");
+      REQUIRE(array.size() == i);
+    }
+  }
+}

lib/ArduinoJson/test/DynamicJsonBuffer/createObject.cpp

@@ -0,0 +1,22 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("DynamicJsonBuffer::createObject()") {
+  DynamicJsonBuffer json;
+
+  JsonObject &obj = json.createObject();
+  REQUIRE(JSON_OBJECT_SIZE(0) == json.size());
+
+  obj["hello"] = 1;
+  REQUIRE(JSON_OBJECT_SIZE(1) == json.size());
+
+  obj["world"] = 2;
+  REQUIRE(JSON_OBJECT_SIZE(2) == json.size());
+
+  obj["world"] = 3;  // <- same key, should not grow
+  REQUIRE(JSON_OBJECT_SIZE(2) == json.size());
+}

lib/ArduinoJson/test/DynamicJsonBuffer/no_memory.cpp

@@ -0,0 +1,49 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+using namespace ArduinoJson::Internals;
+
+struct NoMemoryAllocator {
+  void* allocate(size_t) {
+    return NULL;
+  }
+  void deallocate(void*) {}
+};
+
+TEST_CASE("DynamicJsonBuffer no memory") {
+  DynamicJsonBufferBase<NoMemoryAllocator> _jsonBuffer;
+
+  SECTION("FixCodeCoverage") {
+    // call this function to fix code coverage
+    NoMemoryAllocator().deallocate(NULL);
+  }
+
+  SECTION("createArray()") {
+    REQUIRE_FALSE(_jsonBuffer.createArray().success());
+  }
+
+  SECTION("createObject()") {
+    REQUIRE_FALSE(_jsonBuffer.createObject().success());
+  }
+
+  SECTION("parseArray()") {
+    char json[] = "[]";
+    REQUIRE_FALSE(_jsonBuffer.parseArray(json).success());
+  }
+
+  SECTION("parseObject()") {
+    char json[] = "{}";
+    REQUIRE_FALSE(_jsonBuffer.parseObject(json).success());
+  }
+
+  SECTION("startString()") {
+    DynamicJsonBufferBase<NoMemoryAllocator>::String str =
+        _jsonBuffer.startString();
+    str.append('!');
+    REQUIRE(0 == str.c_str());
+  }
+}

lib/ArduinoJson/test/DynamicJsonBuffer/size.cpp

@@ -0,0 +1,27 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("DynamicJsonBuffer::size()") {
+  DynamicJsonBuffer buffer;
+
+  SECTION("Initial size is 0") {
+    REQUIRE(0 == buffer.size());
+  }
+
+  SECTION("Increases after alloc()") {
+    buffer.alloc(1);
+    REQUIRE(1U <= buffer.size());
+    buffer.alloc(1);
+    REQUIRE(2U <= buffer.size());
+  }
+
+  SECTION("Goes back to 0 after clear()") {
+    buffer.alloc(1);
+    buffer.clear();
+    REQUIRE(0 == buffer.size());
+  }
+}

lib/ArduinoJson/test/DynamicJsonBuffer/startString.cpp

@@ -0,0 +1,47 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson.h>
+#include <catch.hpp>
+
+TEST_CASE("DynamicJsonBuffer::startString()") {
+  SECTION("WorksWhenBufferIsBigEnough") {
+    DynamicJsonBuffer jsonBuffer(6);
+
+    DynamicJsonBuffer::String str = jsonBuffer.startString();
+    str.append('h');
+    str.append('e');
+    str.append('l');
+    str.append('l');
+    str.append('o');
+
+    REQUIRE(std::string("hello") == str.c_str());
+  }
+
+  SECTION("GrowsWhenBufferIsTooSmall") {
+    DynamicJsonBuffer jsonBuffer(5);
+
+    DynamicJsonBuffer::String str = jsonBuffer.startString();
+    str.append('h');
+    str.append('e');
+    str.append('l');
+    str.append('l');
+    str.append('o');
+
+    REQUIRE(std::string("hello") == str.c_str());
+  }
+
+  SECTION("SizeIncreases") {
+    DynamicJsonBuffer jsonBuffer(5);
+
+    DynamicJsonBuffer::String str = jsonBuffer.startString();
+    REQUIRE(0 == jsonBuffer.size());
+
+    str.append('h');
+    REQUIRE(1 == jsonBuffer.size());
+
+    str.c_str();
+    REQUIRE(2 == jsonBuffer.size());
+  }
+}