feedc0de/ArduinoJson
1
0
Fork 0
forked from bblanchon/ArduinoJson
Code Pull Requests Activity

Restored the monotonic allocator

Browse Source
This commit is contained in:
Benoit Blanchon
2018-11-30 14:27:33 +01:00
parent 637f7a5bfa
commit 45f4e5ac20
23 changed files with 35 additions and 609 deletions
Download Patch File Download Diff File Expand all files Collapse all files

44
test/JsonDocument/DynamicJsonDocument.cpp
View File

@ -116,18 +116,6 @@ TEST_CASE("DynamicJsonDocument") {
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
}
SECTION("Decreases after removing value from array") {
JsonArray arr = doc.to<JsonArray>();
arr.add(42);
arr.add(43);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
arr.remove(1);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1));
arr.remove(0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
SECTION("Increases after adding value to object") {
JsonObject obj = doc.to<JsonObject>();
@ -137,37 +125,5 @@ TEST_CASE("DynamicJsonDocument") {
obj["b"] = 2;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
SECTION("Decreases after removing value from object") {
JsonObject obj = doc.to<JsonObject>();
obj["a"] = 1;
obj["b"] = 2;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
obj.remove("a");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
obj.remove("b");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
SECTION("Decreases after removing nested object from array") {
JsonArray arr = doc.to<JsonArray>();
JsonObject obj = arr.createNestedObject();
obj["hello"] = "world";
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(1));
arr.remove(0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
SECTION("Decreases after removing nested array from object") {
JsonObject obj = doc.to<JsonObject>();
JsonArray arr = obj.createNestedArray("hello");
arr.add("world");
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(1));
obj.remove("hello");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}
}

13
test/JsonObject/createNestedObject.cpp
View File

@ -22,17 +22,4 @@ TEST_CASE("JsonObject::createNestedObject()") {
obj.createNestedObject(vla);
}
#endif
SECTION("releases memory from nested object") {
obj.createNestedObject(std::string("a"))
.createNestedObject(std::string("b"))
.set(std::string("c"))
.set(1);
// {"a":{"b":{"c":1}}}
REQUIRE(doc.memoryUsage() ==
3 * JSON_OBJECT_SIZE(1) + 3 * JSON_STRING_SIZE(2));
obj.createNestedObject(std::string("a"));
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2));
}
}

29
test/JsonObject/remove.cpp
View File

@ -19,47 +19,18 @@ TEST_CASE("JsonObject::remove()") {
obj.remove("a");
serializeJson(obj, result);
REQUIRE("{\"b\":1,\"c\":2}" == result);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
SECTION("Remove middle") {
obj.remove("b");
serializeJson(obj, result);
REQUIRE("{\"a\":0,\"c\":2}" == result);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
SECTION("Remove last") {
obj.remove("c");
serializeJson(obj, result);
REQUIRE("{\"a\":0,\"b\":1}" == result);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
SECTION("Release value string memory") {
obj["c"] = std::string("Copy me!");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(3) + JSON_STRING_SIZE(9));
obj.remove("c");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
SECTION("Release key string memory") {
obj[std::string("Copy me!")] = 42;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(4) + JSON_STRING_SIZE(9));
obj.remove("Copy me!");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(3));
}
SECTION("Release raw string memory") {
obj["c"] = serialized(std::string("Copy me!"));
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(3) + JSON_STRING_SIZE(8));
obj.remove("c");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2));
}
}

16
test/JsonObject/subscript.cpp
View File

@ -141,22 +141,6 @@ TEST_CASE("JsonObject::operator[]") {
REQUIRE(expectedSize <= doc.memoryUsage());
}
SECTION("should release string memory when overiding value") {
obj["hello"] = std::string("world");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(6));
obj["hello"] = 42;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
}
SECTION("should release nested array memory when overiding value") {
obj.createNestedArray("hello").add("world");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1));
obj["hello"] = 42;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1));
}
SECTION("should ignore null key") {
// object must have a value to make a call to strcmp()
obj["dummy"] = 42;

1
test/JsonVariant/CMakeLists.txt
View File

@ -13,7 +13,6 @@ add_executable(JsonVariantTests
or.cpp
set.cpp
subscript.cpp
to.cpp
undefined.cpp
)

19
test/JsonVariant/copy.cpp
View File

@ -83,23 +83,4 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(8));
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(8));
}
SECTION("releases string memory when replacing with null") {
var1.set(std::string("hello"));
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(6));
var1.set(JsonVariant());
REQUIRE(doc1.memoryUsage() == 0);
}
SECTION("releases string memory when replacing with iteger") {
var1.set(std::string("hello"));
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(6));
var2.set(42);
var1.set(var2);
REQUIRE(doc1.memoryUsage() == 0);
}
}

56
test/JsonVariant/set.cpp
View File

@ -73,62 +73,6 @@ TEST_CASE("JsonVariant and strings") {
}
}
TEST_CASE("JsonVariant::set() should release string memory") {
DynamicJsonDocument doc;
JsonVariant variant = doc.to<JsonVariant>();
variant.set(std::string("hello"));
REQUIRE(doc.memoryUsage() == JSON_STRING_SIZE(6));
SECTION("int") {
variant.set(-42);
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("unsigned int") {
variant.set(42U);
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("bool") {
variant.set(true);
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("float") {
variant.set(3.14);
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("const char*") {
variant.set("hello");
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("std::string") {
variant.set(std::string("X"));
REQUIRE(doc.memoryUsage() == JSON_STRING_SIZE(2));
}
SECTION("SerializedValue<const char*>") {
variant.set(serialized("[42]"));
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("SerializedValue<std::string>") {
variant.set(serialized(std::string("42")));
REQUIRE(doc.memoryUsage() == JSON_STRING_SIZE(2));
}
SECTION("StringInMemoryPool") {
DeserializationError err =
deserializeJson(doc, std::string("{\"A\":\"hello\",\"A\":\"B\"}"));
REQUIRE(err == DeserializationError::Ok);
// it stores the key twice, but should release "hello"
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 3 * JSON_STRING_SIZE(2));
}
}
TEST_CASE("JsonVariant with not enough memory") {
StaticJsonDocument<1> doc;

32
test/JsonVariant/to.cpp
View File

@ -1,32 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <stdint.h>
#include <catch.hpp>
static const char* null = 0;
TEST_CASE("JsonVariant::to<T>() releases string memory") {
DynamicJsonDocument doc;
JsonVariant variant = doc.to<JsonVariant>();
variant.set(std::string("hello"));
REQUIRE(doc.memoryUsage() == JSON_STRING_SIZE(6));
SECTION("JsonVariant") {
variant.to<JsonVariant>();
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("JsonArray") {
variant.to<JsonArray>();
REQUIRE(doc.memoryUsage() == 0);
}
SECTION("JsonObject") {
variant.to<JsonObject>();
REQUIRE(doc.memoryUsage() == 0);
}
}

66
test/MemoryPool/allocString.cpp
View File

@ -60,15 +60,6 @@ TEST_CASE("MemoryPool::allocFrozenString()") {
REQUIRE(a->value == b->value);
}
SECTION("Returns same address after freeString()") {
StringSlot *a = pool.allocFrozenString(1);
pool.freeString(a);
StringSlot *b = pool.allocFrozenString(1);
REQUIRE(a == b);
REQUIRE(a->value == b->value);
}
SECTION("Can use full capacity when fresh") {
StringSlot *a = pool.allocFrozenString(longestString);
@ -84,60 +75,3 @@ TEST_CASE("MemoryPool::allocFrozenString()") {
REQUIRE(a != 0);
}
}
TEST_CASE("MemoryPool::freeString()") {
const size_t poolCapacity = 512;
const size_t longestString = poolCapacity - sizeof(StringSlot);
char buffer[poolCapacity];
MemoryPool pool(buffer, poolCapacity);
static const size_t testStringSize =
(poolCapacity - sizeof(StringSlot) * 4 - sizeof(VariantSlot) * 4) / 4;
SECTION("Restores full capacity") {
StringSlot *strings[4];
VariantSlot *variants[4];
for (int i = 0; i < 4; i++) {
strings[i] = pool.allocFrozenString(testStringSize);
REQUIRE(strings[i] != 0);
variants[i] = pool.allocVariant();
REQUIRE(variants[i] != 0);
}
// In random order
pool.freeString(strings[2]);
pool.freeVariant(variants[3]);
pool.freeVariant(variants[0]);
pool.freeString(strings[0]);
pool.freeVariant(variants[1]);
pool.freeString(strings[1]);
pool.freeVariant(variants[2]);
pool.freeString(strings[3]);
StringSlot *b = pool.allocFrozenString(longestString);
REQUIRE(b != 0);
REQUIRE(b->size == longestString);
}
SECTION("Move strings") {
StringSlot *a = pool.allocFrozenString(6);
strcpy(a->value, "hello");
StringSlot *b = pool.allocFrozenString(7);
strcpy(b->value, "world!");
pool.freeString(a);
REQUIRE(b->size == 7);
REQUIRE(b->value == std::string("world!"));
REQUIRE(a->value == b->value);
}
SECTION("Accepts non-frozen string") {
StringSlot *a = pool.allocExpandableString();
pool.freeString(a);
REQUIRE(pool.size() == 0);
}
}

10
test/MemoryPool/allocVariant.cpp
View File

@ -21,16 +21,6 @@ TEST_CASE("MemoryPool::allocVariant()") {
REQUIRE(s1 != s2);
}
SECTION("Returns same pointer after freeSlot()") {
MemoryPool pool(buffer, sizeof(buffer));
VariantSlot* s1 = pool.allocVariant();
pool.freeVariant(s1);
VariantSlot* s2 = pool.allocVariant();
REQUIRE(s1 == s2);
}
SECTION("Returns aligned pointers") {
MemoryPool pool(buffer, sizeof(buffer));

52
test/MemoryPool/clear.cpp
View File

@ -28,56 +28,4 @@ TEST_CASE("MemoryPool::clear()") {
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges variant cache") {
VariantSlot* a = memoryPool.allocVariant();
REQUIRE(a != 0);
VariantSlot* b = memoryPool.allocVariant();
REQUIRE(b != 0);
// place slot a in the pool of free slots
memoryPool.freeVariant(a);
memoryPool.clear();
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges string cache") {
StringSlot* a = memoryPool.allocFrozenString(10);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(10);
REQUIRE(b != 0);
// place slot a in the pool of free slots
memoryPool.freeString(a);
memoryPool.clear();
REQUIRE(memoryPool.size() == 0);
}
SECTION("Purges list of string") {
StringSlot* a = memoryPool.allocFrozenString(6);
REQUIRE(a != 0);
strcpy(a->value, "hello");
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
strcpy(b->value, "world");
memoryPool.clear(); // ACT!
StringSlot* c = memoryPool.allocFrozenString(2);
REQUIRE(c != 0);
strcpy(c->value, "H");
StringSlot* d = memoryPool.allocFrozenString(2);
REQUIRE(d != 0);
strcpy(d->value, "W");
// if the memory pool keeps pointer to the old strings
// it will try to compact the strings
memoryPool.freeString(c);
REQUIRE(d->value == std::string("W"));
}
}

35
test/MemoryPool/size.cpp
View File

@ -45,41 +45,6 @@ TEST_CASE("MemoryPool::size()") {
REQUIRE(memoryPool.size() == 2 * JSON_STRING_SIZE(0));
}
SECTION("Decreases after freeVariant()") {
VariantSlot* a = memoryPool.allocVariant();
VariantSlot* b = memoryPool.allocVariant();
memoryPool.freeVariant(b);
REQUIRE(memoryPool.size() == sizeof(VariantSlot));
memoryPool.freeVariant(a);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Decreases after calling freeString() in order") {
StringSlot* a = memoryPool.allocFrozenString(5);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
memoryPool.freeString(b);
REQUIRE(memoryPool.size() == JSON_STRING_SIZE(5));
memoryPool.freeString(a);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Decreases after calling freeString() in reverse order") {
StringSlot* a = memoryPool.allocFrozenString(5);
REQUIRE(a != 0);
StringSlot* b = memoryPool.allocFrozenString(6);
REQUIRE(b != 0);
memoryPool.freeString(a);
REQUIRE(memoryPool.size() == JSON_STRING_SIZE(6));
memoryPool.freeString(b);
REQUIRE(memoryPool.size() == 0);
}
SECTION("Doesn't grow when memory pool is full") {
const size_t variantCount = sizeof(buffer) / sizeof(VariantSlot);