Moved ancillary files to extras/ (fixes #1011)

extras/tests/MemoryPool/CMakeLists.txt

@@ -0,0 +1,14 @@
+# ArduinoJson - arduinojson.org
+# Copyright Benoit Blanchon 2014-2019
+# MIT License
+
+add_executable(MemoryPoolTests 
+	allocVariant.cpp
+	allocString.cpp
+	clear.cpp
+	size.cpp
+	StringBuilder.cpp
+)
+
+target_link_libraries(MemoryPoolTests catch)
+add_test(MemoryPool MemoryPoolTests)

extras/tests/MemoryPool/StringBuilder.cpp

@@ -0,0 +1,41 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+static char buffer[4096];
+
+TEST_CASE("StringBuilder") {
+  SECTION("Works when buffer is big enough") {
+    MemoryPool pool(buffer, addPadding(JSON_STRING_SIZE(6)));
+
+    StringBuilder str(&pool);
+    str.append("hello");
+
+    REQUIRE(str.complete() == std::string("hello"));
+  }
+
+  SECTION("Returns null when too small") {
+    MemoryPool pool(buffer, sizeof(void*));
+
+    StringBuilder str(&pool);
+    str.append("hello world!");
+
+    REQUIRE(str.complete() == 0);
+  }
+
+  SECTION("Increases size of memory pool") {
+    MemoryPool pool(buffer, addPadding(JSON_STRING_SIZE(6)));
+
+    StringBuilder str(&pool);
+    str.append('h');
+    str.complete();
+
+    REQUIRE(JSON_STRING_SIZE(2) == pool.size());
+  }
+}

extras/tests/MemoryPool/allocString.cpp

@@ -0,0 +1,67 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+TEST_CASE("MemoryPool::allocFrozenString()") {
+  const size_t poolCapacity = 64;
+  const size_t longestString = poolCapacity;
+  char buffer[poolCapacity];
+  MemoryPool pool(buffer, poolCapacity);
+
+  SECTION("Returns different addresses") {
+    char *a = pool.allocFrozenString(1);
+    char *b = pool.allocFrozenString(1);
+    REQUIRE(a != b);
+  }
+
+  SECTION("Returns NULL when full") {
+    void *p1 = pool.allocFrozenString(longestString);
+    REQUIRE(p1 != 0);
+
+    void *p2 = pool.allocFrozenString(1);
+    REQUIRE(p2 == 0);
+  }
+
+  SECTION("Returns NULL when pool is too small") {
+    void *p = pool.allocFrozenString(longestString + 1);
+    REQUIRE(0 == p);
+  }
+
+  SECTION("Returns NULL when buffer is NULL") {
+    MemoryPool pool2(0, poolCapacity);
+    REQUIRE(0 == pool2.allocFrozenString(2));
+  }
+
+  SECTION("Returns NULL when capacity is 0") {
+    MemoryPool pool2(buffer, 0);
+    REQUIRE(0 == pool2.allocFrozenString(2));
+  }
+
+  SECTION("Returns same address after clear()") {
+    void *a = pool.allocFrozenString(1);
+    pool.clear();
+    void *b = pool.allocFrozenString(1);
+
+    REQUIRE(a == b);
+  }
+
+  SECTION("Can use full capacity when fresh") {
+    void *a = pool.allocFrozenString(longestString);
+
+    REQUIRE(a != 0);
+  }
+
+  SECTION("Can use full capacity after clear") {
+    pool.allocFrozenString(longestString);
+    pool.clear();
+
+    void *a = pool.allocFrozenString(longestString);
+
+    REQUIRE(a != 0);
+  }
+}

extras/tests/MemoryPool/allocVariant.cpp

@@ -0,0 +1,50 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+static char buffer[4096];
+
+TEST_CASE("MemoryPool::allocVariant()") {
+  SECTION("Returns different pointer") {
+    MemoryPool pool(buffer, sizeof(buffer));
+
+    VariantSlot* s1 = pool.allocVariant();
+    REQUIRE(s1 != 0);
+    VariantSlot* s2 = pool.allocVariant();
+    REQUIRE(s2 != 0);
+
+    REQUIRE(s1 != s2);
+  }
+
+  SECTION("Returns aligned pointers") {
+    MemoryPool pool(buffer, sizeof(buffer));
+
+    REQUIRE(isAligned(pool.allocVariant()));
+    REQUIRE(isAligned(pool.allocVariant()));
+  }
+
+  SECTION("Returns zero if capacity is 0") {
+    MemoryPool pool(buffer, 0);
+
+    REQUIRE(pool.allocVariant() == 0);
+  }
+
+  SECTION("Returns zero if buffer is null") {
+    MemoryPool pool(0, sizeof(buffer));
+
+    REQUIRE(pool.allocVariant() == 0);
+  }
+
+  SECTION("Returns zero if capacity is insufficient") {
+    MemoryPool pool(buffer, sizeof(VariantSlot));
+
+    pool.allocVariant();
+
+    REQUIRE(pool.allocVariant() == 0);
+  }
+}

extras/tests/MemoryPool/clear.cpp

@@ -0,0 +1,31 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+static const size_t poolCapacity = 512;
+
+TEST_CASE("MemoryPool::clear()") {
+  char buffer[poolCapacity];
+  MemoryPool pool(buffer, sizeof(buffer));
+
+  SECTION("Discards allocated variants") {
+    pool.allocVariant();
+
+    pool.clear();
+    REQUIRE(pool.size() == 0);
+  }
+
+  SECTION("Discards allocated strings") {
+    pool.allocFrozenString(10);
+    REQUIRE(pool.size() > 0);
+
+    pool.clear();
+
+    REQUIRE(pool.size() == 0);
+  }
+}

extras/tests/MemoryPool/size.cpp

@@ -0,0 +1,58 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2019
+// MIT License
+
+#include <ArduinoJson/Memory/MemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+char buffer[4096];
+
+TEST_CASE("MemoryPool::capacity()") {
+  const size_t capacity = 64;
+  MemoryPool pool(buffer, capacity);
+  REQUIRE(capacity == pool.capacity());
+}
+
+TEST_CASE("MemoryPool::size()") {
+  MemoryPool pool(buffer, sizeof(buffer));
+
+  SECTION("Initial size is 0") {
+    REQUIRE(0 == pool.size());
+  }
+
+  SECTION("size() == capacity() after allocExpandableString()") {
+    pool.allocExpandableString();
+    REQUIRE(pool.size() == pool.capacity());
+  }
+
+  SECTION("Decreases after freezeString()") {
+    StringSlot a = pool.allocExpandableString();
+    pool.freezeString(a, 1);
+    REQUIRE(pool.size() == JSON_STRING_SIZE(1));
+
+    StringSlot b = pool.allocExpandableString();
+    pool.freezeString(b, 1);
+    REQUIRE(pool.size() == 2 * JSON_STRING_SIZE(1));
+  }
+
+  SECTION("Increases after allocFrozenString()") {
+    pool.allocFrozenString(0);
+    REQUIRE(pool.size() == JSON_STRING_SIZE(0));
+
+    pool.allocFrozenString(0);
+    REQUIRE(pool.size() == 2 * JSON_STRING_SIZE(0));
+  }
+
+  SECTION("Doesn't grow when memory pool is full") {
+    const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot);
+
+    for (size_t i = 0; i < variantCount; i++) pool.allocVariant();
+    size_t size = pool.size();
+
+    pool.allocVariant();
+
+    REQUIRE(size == pool.size());
+  }
+}