JsonArray::remove() and JsonObject::remove() now release the memory of strings

test/DynamicMemoryPool/CMakeLists.txt

@@ -2,12 +2,14 @@
 # Copyright Benoit Blanchon 2014-2018
 # MIT License
 
-add_executable(DynamicMemoryPoolTests 
-	alloc.cpp
-	allocSlot.cpp
+add_executable(DynamicMemoryPoolTests
+	allocString.cpp
+	allocVariant.cpp
+	blocks.cpp
+	clear.cpp
 	no_memory.cpp
 	size.cpp
-	startString.cpp
+	StringBuilder.cpp
 )
 
 target_link_libraries(DynamicMemoryPoolTests catch)

test/DynamicMemoryPool/StringBuilder.cpp

@@ -0,0 +1,41 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+TEST_CASE("DynamicMemoryPool::startString()") {
+  SECTION("WorksWhenBufferIsBigEnough") {
+    DynamicMemoryPool memoryPool(JSON_STRING_SIZE(8));
+
+    StringBuilder str(&memoryPool);
+    str.append("abcdefg");
+
+    REQUIRE(memoryPool.blockCount() == 1);
+    REQUIRE(str.complete().equals("abcdefg"));
+  }
+
+  SECTION("GrowsWhenBufferIsTooSmall") {
+    DynamicMemoryPool memoryPool(JSON_STRING_SIZE(8));
+
+    StringBuilder str(&memoryPool);
+    str.append("abcdefghABC");
+
+    REQUIRE(memoryPool.blockCount() == 2);
+    REQUIRE(str.complete().equals("abcdefghABC"));
+  }
+
+  SECTION("SizeIncreases") {
+    DynamicMemoryPool memoryPool(JSON_STRING_SIZE(5));
+
+    StringBuilder str(&memoryPool);
+    str.append('h');
+    str.complete();
+
+    REQUIRE(JSON_STRING_SIZE(2) == memoryPool.size());
+  }
+}

test/DynamicMemoryPool/alloc.cpp

@@ -1,77 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#include <ArduinoJson.h>
-#include <catch.hpp>
-#include <sstream>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-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 - DynamicMemoryPool::EmptyBlockSize);
-    return DefaultAllocator::allocate(n);
-  }
-  void deallocate(void* p) {
-    allocatorLog << "F";
-    return DefaultAllocator::deallocate(p);
-  }
-};
-
-TEST_CASE("DynamicMemoryPool::alloc()") {
-  SECTION("Returns different pointers") {
-    DynamicMemoryPool memoryPool;
-    void* p1 = memoryPool.alloc(1);
-    void* p2 = memoryPool.alloc(2);
-    REQUIRE(p1 != p2);
-  }
-
-  SECTION("Doubles allocation size when full") {
-    allocatorLog.str("");
-    {
-      DynamicMemoryPoolBase<SpyingAllocator> memoryPool(1);
-      memoryPool.alloc(1);
-      memoryPool.alloc(1);
-    }
-    REQUIRE(allocatorLog.str() == "A1A2FF");
-  }
-
-  SECTION("Resets allocation size after clear()") {
-    allocatorLog.str("");
-    {
-      DynamicMemoryPoolBase<SpyingAllocator> memoryPool(1);
-      memoryPool.alloc(1);
-      memoryPool.alloc(1);
-      memoryPool.clear();
-      memoryPool.alloc(1);
-    }
-    REQUIRE(allocatorLog.str() == "A1A2FFA1F");
-  }
-
-  SECTION("Makes a big allocation when needed") {
-    allocatorLog.str("");
-    {
-      DynamicMemoryPoolBase<SpyingAllocator> memoryPool(1);
-      memoryPool.alloc(42);
-    }
-    REQUIRE(allocatorLog.str() == "A42F");
-  }
-
-  SECTION("Alignment") {
-    // make room for two but not three
-    DynamicMemoryPool 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
-  }
-}

test/DynamicMemoryPool/allocSlot.cpp

@@ -1,27 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("DynamicMemoryPool::allocSlot()") {
-  DynamicMemoryPool memoryPool;
-
-  SECTION("Returns different pointer") {
-    Slot* s1 = memoryPool.allocSlot();
-    Slot* s2 = memoryPool.allocSlot();
-
-    REQUIRE(s1 != s2);
-  }
-
-  SECTION("Returns same pointer after freeSlot()") {
-    Slot* s1 = memoryPool.allocSlot();
-    memoryPool.freeSlot(s1);
-    Slot* s2 = memoryPool.allocSlot();
-
-    REQUIRE(s1 == s2);
-  }
-}

test/DynamicMemoryPool/allocString.cpp

@@ -0,0 +1,28 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <catch.hpp>
+#include <sstream>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+TEST_CASE("DynamicMemoryPool::allocFrozenString()") {
+  DynamicMemoryPool pool;
+
+  SECTION("Returns different pointers") {
+    StringSlot* a = pool.allocFrozenString(1);
+    StringSlot* b = pool.allocFrozenString(2);
+    REQUIRE(a != b);
+    REQUIRE(a->value != b->value);
+  }
+
+  SECTION("Returns same slot after freeString") {
+    StringSlot* a = pool.allocFrozenString(1);
+    pool.freeString(a);
+    StringSlot* b = pool.allocFrozenString(2);
+    REQUIRE(a == b);
+    REQUIRE(a->value == b->value);
+  }
+}

test/DynamicMemoryPool/allocVariant.cpp

@@ -0,0 +1,41 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+TEST_CASE("DynamicMemoryPool::allocVariant()") {
+  DynamicMemoryPool memoryPool;
+
+  SECTION("Returns different pointer") {
+    VariantSlot* s1 = memoryPool.allocVariant();
+    VariantSlot* s2 = memoryPool.allocVariant();
+
+    REQUIRE(s1 != s2);
+  }
+
+  SECTION("Returns same pointer after freeSlot()") {
+    VariantSlot* s1 = memoryPool.allocVariant();
+    memoryPool.freeVariant(s1);
+    VariantSlot* s2 = memoryPool.allocVariant();
+
+    REQUIRE(s1 == s2);
+  }
+
+  SECTION("Returns aligned pointers") {
+    // make room for two but not three
+    // pass an uneven capacity
+    DynamicMemoryPool pool(2 * sizeof(VariantSlot) + 1);
+
+    REQUIRE(isAligned(pool.allocVariant()));
+    REQUIRE(isAligned(pool.allocVariant()));
+    REQUIRE(pool.blockCount() == 1);
+
+    REQUIRE(isAligned(pool.allocVariant()));
+    REQUIRE(isAligned(pool.allocVariant()));
+    REQUIRE(pool.blockCount() == 2);
+  }
+}

test/DynamicMemoryPool/blocks.cpp

@@ -0,0 +1,69 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <catch.hpp>
+#include <sstream>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+std::stringstream allocatorLog;
+
+struct SpyingAllocator : DefaultAllocator {
+  void* allocate(size_t n) {
+    allocatorLog << "A" << (n - DynamicMemoryPool::EmptyBlockSize);
+    return DefaultAllocator::allocate(n);
+  }
+  void deallocate(void* p) {
+    allocatorLog << "F";
+    return DefaultAllocator::deallocate(p);
+  }
+};
+
+TEST_CASE("DynamicMemoryPool blocks") {
+  SECTION("Doubles allocation size when full") {
+    allocatorLog.str("");
+    {
+      DynamicMemoryPoolBase<SpyingAllocator> memoryPool(sizeof(VariantSlot));
+      memoryPool.allocVariant();
+      memoryPool.allocVariant();
+    }
+    std::stringstream expected;
+    expected << "A" << sizeof(VariantSlot)      // block 1
+             << "A" << 2 * sizeof(VariantSlot)  // block 2, twice bigger
+             << "FF";
+
+    REQUIRE(allocatorLog.str() == expected.str());
+  }
+
+  SECTION("Resets allocation size after clear()") {
+    allocatorLog.str("");
+    {
+      DynamicMemoryPoolBase<SpyingAllocator> memoryPool(sizeof(VariantSlot));
+      memoryPool.allocVariant();
+      memoryPool.allocVariant();
+      memoryPool.clear();
+      memoryPool.allocVariant();
+    }
+    std::stringstream expected;
+    expected << "A" << sizeof(VariantSlot)      // block 1
+             << "A" << 2 * sizeof(VariantSlot)  // block 2, twice bigger
+             << "FF"                            // clear
+             << "A" << sizeof(VariantSlot)      // block 1
+             << "F";
+    REQUIRE(allocatorLog.str() == expected.str());
+  }
+
+  /* SECTION("Alloc big block for large string") {
+     allocatorLog.str("");
+     {
+       DynamicMemoryPoolBase<SpyingAllocator> memoryPool(1);
+       memoryPool.allocString(42);
+     }
+     std::stringstream expected;
+     expected << "A" << JSON_STRING_SIZE(42)  // block 1
+              << "F";
+     REQUIRE(allocatorLog.str() == expected.str());
+   }*/
+}

test/DynamicMemoryPool/clear.cpp

@@ -0,0 +1,47 @@
+// ArduinoJson - arduinojson.org
+// Copyright Benoit Blanchon 2014-2018
+// MIT License
+
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <catch.hpp>
+
+using namespace ARDUINOJSON_NAMESPACE;
+
+TEST_CASE("StaticMemoryPool::clear()") {
+  DynamicMemoryPool memoryPool;
+
+  SECTION("Discards allocated variants") {
+    memoryPool.allocVariant();
+    REQUIRE(memoryPool.size() > 0);
+
+    memoryPool.clear();
+    CHECK(memoryPool.size() == 0);
+  }
+
+  SECTION("Discards allocated strings") {
+    memoryPool.allocFrozenString(10);
+    REQUIRE(memoryPool.size() > 0);
+
+    memoryPool.clear();
+
+    CHECK(memoryPool.size() == 0);
+  }
+
+  SECTION("Purges variant cache") {
+    memoryPool.freeVariant(memoryPool.allocVariant());
+    REQUIRE(memoryPool.size() == 0);
+
+    memoryPool.clear();
+
+    CHECK(memoryPool.size() == 0);
+  }
+
+  SECTION("Purges string cache") {
+    memoryPool.freeString(memoryPool.allocFrozenString(10));
+    // REQUIRE(memoryPool.size() == 0);
+
+    memoryPool.clear();
+
+    CHECK(memoryPool.size() == 0);
+  }
+}

test/DynamicMemoryPool/no_memory.cpp

@@ -2,7 +2,8 @@
 // Copyright Benoit Blanchon 2014-2018
 // MIT License
 
-#include <ArduinoJson.h>
+#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
+#include <ArduinoJson/Memory/StringBuilder.hpp>
 #include <catch.hpp>
 
 using namespace ARDUINOJSON_NAMESPACE;
@@ -32,8 +33,8 @@ TEST_CASE("DynamicMemoryPool no memory") {
   //   REQUIRE(err != DeserializationError::Ok);
   // }
 
-  SECTION("startString()") {
-    StringBuilder str = _memoryPool.startString();
+  SECTION("StringBuilder returns null") {
+    StringBuilder str(&_memoryPool);
     str.append('!');
     REQUIRE(str.complete().isNull());
   }

test/DynamicMemoryPool/size.cpp

@@ -14,35 +14,43 @@ TEST_CASE("DynamicMemoryPool::size()") {
     REQUIRE(0 == memoryPool.size());
   }
 
-  SECTION("Increases after alloc()") {
-    memoryPool.alloc(1);
-    REQUIRE(1U <= memoryPool.size());
-    memoryPool.alloc(1);
-    REQUIRE(2U <= memoryPool.size());
+  SECTION("Increases after allocExpandableString()") {
+    StringSlot* a = memoryPool.allocExpandableString();
+    memoryPool.freezeString(a, 1);
+    REQUIRE(memoryPool.size() == JSON_STRING_SIZE(1));
+
+    StringSlot* b = memoryPool.allocExpandableString();
+    memoryPool.freezeString(b, 1);
+    REQUIRE(memoryPool.size() == 2 * JSON_STRING_SIZE(1));
   }
 
-  SECTION("Goes back to 0 after clear()") {
-    memoryPool.alloc(1);
-    memoryPool.clear();
+  SECTION("Increases after allocVariant()") {
+    memoryPool.allocVariant();
+    REQUIRE(sizeof(VariantSlot) == memoryPool.size());
+
+    memoryPool.allocVariant();
+    REQUIRE(2 * sizeof(VariantSlot) == memoryPool.size());
+  }
+
+  SECTION("Decreases after freeVariant()") {
+    VariantSlot* a = memoryPool.allocVariant();
+    VariantSlot* b = memoryPool.allocVariant();
+
+    memoryPool.freeVariant(b);
+    REQUIRE(sizeof(VariantSlot) == memoryPool.size());
+
+    memoryPool.freeVariant(a);
     REQUIRE(0 == memoryPool.size());
   }
 
-  SECTION("Increases after allocSlot()") {
-    memoryPool.allocSlot();
-    REQUIRE(sizeof(Slot) == memoryPool.size());
+  SECTION("Decreases after freeString()") {
+    StringSlot* a = memoryPool.allocFrozenString(5);
+    StringSlot* b = memoryPool.allocFrozenString(6);
 
-    memoryPool.allocSlot();
-    REQUIRE(2 * sizeof(Slot) == memoryPool.size());
-  }
+    memoryPool.freeString(b);
+    REQUIRE(memoryPool.size() == JSON_STRING_SIZE(5));
 
-  SECTION("Decreases after freeSlot()") {
-    Slot* s1 = memoryPool.allocSlot();
-    Slot* s2 = memoryPool.allocSlot();
-
-    memoryPool.freeSlot(s1);
-    REQUIRE(sizeof(Slot) == memoryPool.size());
-
-    memoryPool.freeSlot(s2);
-    REQUIRE(0 == memoryPool.size());
+    memoryPool.freeString(a);
+    REQUIRE(memoryPool.size() == 0);
   }
 }

test/DynamicMemoryPool/startString.cpp

@@ -1,46 +0,0 @@
-// ArduinoJson - arduinojson.org
-// Copyright Benoit Blanchon 2014-2018
-// MIT License
-
-#include <ArduinoJson/Memory/DynamicMemoryPool.hpp>
-#include <catch.hpp>
-
-using namespace ARDUINOJSON_NAMESPACE;
-
-TEST_CASE("DynamicMemoryPool::startString()") {
-  SECTION("WorksWhenBufferIsBigEnough") {
-    DynamicMemoryPool memoryPool(6);
-
-    StringBuilder str = memoryPool.startString();
-    str.append('h');
-    str.append('e');
-    str.append('l');
-    str.append('l');
-    str.append('o');
-
-    REQUIRE(str.complete().equals("hello"));
-  }
-
-  SECTION("GrowsWhenBufferIsTooSmall") {
-    DynamicMemoryPool memoryPool(5);
-
-    StringBuilder str = memoryPool.startString();
-    str.append('h');
-    str.append('e');
-    str.append('l');
-    str.append('l');
-    str.append('o');
-
-    REQUIRE(str.complete().equals("hello"));
-  }
-
-  SECTION("SizeIncreases") {
-    DynamicMemoryPool memoryPool(5);
-
-    StringBuilder str = memoryPool.startString();
-    str.append('h');
-    str.complete();
-
-    REQUIRE(2 == memoryPool.size());
-  }
-}