bblanchon/ArduinoJson
1
0
Fork 1
mirror of https://github.com/bblanchon/ArduinoJson.git synced 2025-07-16 20:12:16 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove JSON_ARRAY_SIZE(), JSON_OBJECT_SIZE(), and JSON_STRING_SIZE()

Browse Source
This commit is contained in:
Benoit Blanchon
2023-03-29 19:18:06 +02:00
parent 0328f66340
commit 3f43c2b816
36 changed files with 395 additions and 340 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
CHANGELOG.md
View File

@ -8,3 +8,4 @@ HEAD
* Remove `StaticJsonDocument` * Remove `StaticJsonDocument`
* Add abstract `Allocator` class * Add abstract `Allocator` class
* Merge `DynamicJsonDocument` with `JsonDocument` * Merge `DynamicJsonDocument` with `JsonDocument`
* Remove `JSON_ARRAY_SIZE()`, `JSON_OBJECT_SIZE()`, and `JSON_STRING_SIZE()`

3
examples/JsonHttpClient/JsonHttpClient.ino
View File

@ -78,8 +78,7 @@ void setup() {
// Allocate the JSON document // Allocate the JSON document
// Use https://arduinojson.org/v6/assistant to compute the capacity. // Use https://arduinojson.org/v6/assistant to compute the capacity.
const size_t capacity = JSON_OBJECT_SIZE(3) + JSON_ARRAY_SIZE(2) + 60; JsonDocument doc(256);
JsonDocument doc(capacity);
// Parse JSON object // Parse JSON object
DeserializationError error = deserializeJson(doc, client); DeserializationError error = deserializeJson(doc, client);

10
extras/tests/Cpp17/string_view.cpp
View File

@ -7,6 +7,8 @@
# error ARDUINOJSON_ENABLE_STRING_VIEW must be set to 1 # error ARDUINOJSON_ENABLE_STRING_VIEW must be set to 1
#endif #endif
using ArduinoJson::detail::sizeofArray;
TEST_CASE("string_view") { TEST_CASE("string_view") {
JsonDocument doc(256); JsonDocument doc(256);
JsonVariant variant = doc.to<JsonVariant>(); JsonVariant variant = doc.to<JsonVariant>();
@ -53,16 +55,16 @@ TEST_CASE("string_view") {
SECTION("String deduplication") { SECTION("String deduplication") {
doc.add(std::string_view("example one", 7)); doc.add(std::string_view("example one", 7));
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + 8); REQUIRE(doc.memoryUsage() == sizeofArray(1) + 8);
doc.add(std::string_view("example two", 7)); doc.add(std::string_view("example two", 7));
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); REQUIRE(doc.memoryUsage() == sizeofArray(2) + 8);
doc.add(std::string_view("example\0tree", 12)); doc.add(std::string_view("example\0tree", 12));
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(3) + 21); REQUIRE(doc.memoryUsage() == sizeofArray(3) + 21);
doc.add(std::string_view("example\0tree and a half", 12)); doc.add(std::string_view("example\0tree and a half", 12));
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(4) + 21); REQUIRE(doc.memoryUsage() == sizeofArray(4) + 21);
} }
SECTION("as<std::string_view>()") { SECTION("as<std::string_view>()") {

17
extras/tests/JsonArray/add.cpp
View File

@ -5,6 +5,9 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofString;
TEST_CASE("JsonArray::add()") { TEST_CASE("JsonArray::add()") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
@ -96,43 +99,43 @@ TEST_CASE("JsonArray::add()") {
SECTION("should not duplicate const char*") { SECTION("should not duplicate const char*") {
array.add("world"); array.add("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1); const size_t expectedSize = sizeofArray(1);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate char*") { SECTION("should duplicate char*") {
array.add(const_cast<char*>("world")); array.add(const_cast<char*>("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofArray(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate std::string") { SECTION("should duplicate std::string") {
array.add(std::string("world")); array.add(std::string("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofArray(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should not duplicate serialized(const char*)") { SECTION("should not duplicate serialized(const char*)") {
array.add(serialized("{}")); array.add(serialized("{}"));
const size_t expectedSize = JSON_ARRAY_SIZE(1); const size_t expectedSize = sizeofArray(1);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate serialized(char*)") { SECTION("should duplicate serialized(char*)") {
array.add(serialized(const_cast<char*>("{}"))); array.add(serialized(const_cast<char*>("{}")));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2); const size_t expectedSize = sizeofArray(1) + sizeofString(2);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate serialized(std::string)") { SECTION("should duplicate serialized(std::string)") {
array.add(serialized(std::string("{}"))); array.add(serialized(std::string("{}")));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(2); const size_t expectedSize = sizeofArray(1) + sizeofString(2);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate serialized(std::string)") { SECTION("should duplicate serialized(std::string)") {
array.add(serialized(std::string("\0XX", 3))); array.add(serialized(std::string("\0XX", 3)));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(3); const size_t expectedSize = sizeofArray(1) + sizeofString(3);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
} }

7
extras/tests/JsonArray/copyArray.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
TEST_CASE("copyArray()") { TEST_CASE("copyArray()") {
SECTION("int[] -> JsonArray") { SECTION("int[] -> JsonArray") {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -107,7 +109,7 @@ TEST_CASE("copyArray()") {
} }
SECTION("int[] -> JsonArray, but not enough memory") { SECTION("int[] -> JsonArray, but not enough memory") {
const size_t SIZE = JSON_ARRAY_SIZE(2); const size_t SIZE = sizeofArray(2);
JsonDocument doc(SIZE); JsonDocument doc(SIZE);
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
char json[32]; char json[32];
@ -158,8 +160,7 @@ TEST_CASE("copyArray()") {
} }
SECTION("int[][] -> JsonArray, but not enough memory") { SECTION("int[][] -> JsonArray, but not enough memory") {
const size_t SIZE = const size_t SIZE = sizeofArray(2) + sizeofArray(3) + sizeofArray(2);
JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
JsonDocument doc(SIZE); JsonDocument doc(SIZE);
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
char json[32] = ""; char json[32] = "";

4
extras/tests/JsonArray/iterator.cpp
View File

@ -5,9 +5,11 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
template <typename TArray> template <typename TArray>
static void run_iterator_test() { static void run_iterator_test() {
JsonDocument doc(JSON_ARRAY_SIZE(2)); JsonDocument doc(sizeofArray(2));
JsonArray tmp = doc.to<JsonArray>(); JsonArray tmp = doc.to<JsonArray>();
tmp.add(12); tmp.add(12);
tmp.add(34); tmp.add(34);

17
extras/tests/JsonArray/memoryUsage.cpp
View File

@ -5,6 +5,9 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("JsonArray::memoryUsage()") { TEST_CASE("JsonArray::memoryUsage()") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonArray arr = doc.to<JsonArray>(); JsonArray arr = doc.to<JsonArray>();
@ -14,29 +17,29 @@ TEST_CASE("JsonArray::memoryUsage()") {
REQUIRE(unitialized.memoryUsage() == 0); REQUIRE(unitialized.memoryUsage() == 0);
} }
SECTION("JSON_ARRAY_SIZE(0) if empty") { SECTION("sizeofArray(0) if empty") {
REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0)); REQUIRE(arr.memoryUsage() == sizeofArray(0));
} }
SECTION("JSON_ARRAY_SIZE(1) after add") { SECTION("sizeofArray(1) after add") {
arr.add("hello"); arr.add("hello");
REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1)); REQUIRE(arr.memoryUsage() == sizeofArray(1));
} }
SECTION("includes the size of the string") { SECTION("includes the size of the string") {
arr.add(std::string("hello")); arr.add(std::string("hello"));
REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(1) + 6); REQUIRE(arr.memoryUsage() == sizeofArray(1) + 6);
} }
SECTION("includes the size of the nested array") { SECTION("includes the size of the nested array") {
JsonArray nested = arr.createNestedArray(); JsonArray nested = arr.createNestedArray();
nested.add(42); nested.add(42);
REQUIRE(arr.memoryUsage() == 2 * JSON_ARRAY_SIZE(1)); REQUIRE(arr.memoryUsage() == 2 * sizeofArray(1));
} }
SECTION("includes the size of the nested arrect") { SECTION("includes the size of the nested arrect") {
JsonObject nested = arr.createNestedObject(); JsonObject nested = arr.createNestedObject();
nested["hello"] = "world"; nested["hello"] = "world";
REQUIRE(arr.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1)); REQUIRE(arr.memoryUsage() == sizeofObject(1) + sizeofArray(1));
} }
} }

9
extras/tests/JsonArray/subscript.cpp
View File

@ -6,6 +6,9 @@
#include <stdint.h> #include <stdint.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofString;
TEST_CASE("JsonArray::operator[]") { TEST_CASE("JsonArray::operator[]") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
@ -112,19 +115,19 @@ TEST_CASE("JsonArray::operator[]") {
SECTION("should not duplicate const char*") { SECTION("should not duplicate const char*") {
array[0] = "world"; array[0] = "world";
const size_t expectedSize = JSON_ARRAY_SIZE(1); const size_t expectedSize = sizeofArray(1);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate char*") { SECTION("should duplicate char*") {
array[0] = const_cast<char*>("world"); array[0] = const_cast<char*>("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofArray(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate std::string") { SECTION("should duplicate std::string") {
array[0] = std::string("world"); array[0] = std::string("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofArray(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }

26
extras/tests/JsonDeserializer/array.cpp
View File

@ -5,6 +5,10 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
using ArduinoJson::detail::sizeofString;
TEST_CASE("deserialize JSON array") { TEST_CASE("deserialize JSON array") {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -248,13 +252,13 @@ TEST_CASE("deserialize JSON array") {
JsonArray arr = doc.as<JsonArray>(); JsonArray arr = doc.as<JsonArray>();
REQUIRE(arr.size() == 0); REQUIRE(arr.size() == 0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofArray(0));
} }
} }
TEST_CASE("deserialize JSON array under memory constraints") { TEST_CASE("deserialize JSON array under memory constraints") {
SECTION("buffer of the right size for an empty array") { SECTION("buffer of the right size for an empty array") {
JsonDocument doc(JSON_ARRAY_SIZE(0)); JsonDocument doc(sizeofArray(0));
char input[] = "[]"; char input[] = "[]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -263,7 +267,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
} }
SECTION("buffer too small for an array with one element") { SECTION("buffer too small for an array with one element") {
JsonDocument doc(JSON_ARRAY_SIZE(0)); JsonDocument doc(sizeofArray(0));
char input[] = "[1]"; char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -272,7 +276,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
} }
SECTION("buffer of the right size for an array with one element") { SECTION("buffer of the right size for an array with one element") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
char input[] = "[1]"; char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -281,7 +285,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
} }
SECTION("buffer too small for an array with a nested object") { SECTION("buffer too small for an array with a nested object") {
JsonDocument doc(JSON_ARRAY_SIZE(0) + JSON_OBJECT_SIZE(0)); JsonDocument doc(sizeofArray(0) + sizeofObject(0));
char input[] = "[{}]"; char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -290,7 +294,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
} }
SECTION("buffer of the right size for an array with a nested object") { SECTION("buffer of the right size for an array with a nested object") {
JsonDocument doc(JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)); JsonDocument doc(sizeofArray(1) + sizeofObject(0));
char input[] = "[{}]"; char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -303,13 +307,13 @@ TEST_CASE("deserialize JSON array under memory constraints") {
deserializeJson(doc, " [ \"1234567\" ] "); deserializeJson(doc, " [ \"1234567\" ] ");
REQUIRE(JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(7) == doc.memoryUsage()); REQUIRE(sizeofArray(1) + sizeofString(7) == doc.memoryUsage());
// note: we use a string of 8 bytes to be sure that the MemoryPool // note: we use a string of 8 bytes to be sure that the MemoryPool
// will not insert bytes to enforce alignement // will not insert bytes to enforce alignement
} }
SECTION("Should clear the JsonArray") { SECTION("Should clear the JsonArray") {
JsonDocument doc(JSON_ARRAY_SIZE(4)); JsonDocument doc(sizeofArray(4));
char input[] = "[1,2,3,4]"; char input[] = "[1,2,3,4]";
deserializeJson(doc, input); deserializeJson(doc, input);
@ -317,11 +321,11 @@ TEST_CASE("deserialize JSON array under memory constraints") {
JsonArray arr = doc.as<JsonArray>(); JsonArray arr = doc.as<JsonArray>();
REQUIRE(arr.size() == 0); REQUIRE(arr.size() == 0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofArray(0));
} }
SECTION("buffer of the right size for an array with two element") { SECTION("buffer of the right size for an array with two element") {
JsonDocument doc(JSON_ARRAY_SIZE(2)); JsonDocument doc(sizeofArray(2));
char input[] = "[1,2]"; char input[] = "[1,2]";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -329,7 +333,7 @@ TEST_CASE("deserialize JSON array under memory constraints") {
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);
REQUIRE(doc.is<JsonArray>()); REQUIRE(doc.is<JsonArray>());
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2)); REQUIRE(doc.memoryUsage() == sizeofArray(2));
REQUIRE(arr[0] == 1); REQUIRE(arr[0] == 1);
REQUIRE(arr[1] == 2); REQUIRE(arr[1] == 2);
} }

81
extras/tests/JsonDeserializer/filter.cpp
View File

@ -9,6 +9,9 @@
#include <sstream> #include <sstream>
#include <string> #include <string>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("Filtering") { TEST_CASE("Filtering") {
struct TestCase { struct TestCase {
const char* input; const char* input;
@ -43,7 +46,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"abcdefg\":\"hijklmn\"}", "{\"abcdefg\":\"hijklmn\"}",
JSON_OBJECT_SIZE(1) + 16 sizeofObject(1) + 16
}, },
{ {
"{\"hello\":\"world\"}", "{\"hello\":\"world\"}",
@ -51,7 +54,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// Input in an object, but filter wants an array // Input in an object, but filter wants an array
@ -69,7 +72,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":null}", "{\"example\":null}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// Member is a number, but filter wants an array // Member is a number, but filter wants an array
@ -78,7 +81,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":null}", "{\"example\":null}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// Input is an array, but filter wants an object // Input is an array, but filter wants an object
@ -114,7 +117,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// skip a float // skip a float
@ -123,7 +126,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// skip false // skip false
@ -132,7 +135,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// skip true // skip true
@ -141,7 +144,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// skip null // skip null
@ -150,7 +153,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip a double-quoted string // can skip a double-quoted string
@ -159,7 +162,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip a single-quoted string // can skip a single-quoted string
@ -168,7 +171,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an empty array // can skip an empty array
@ -177,7 +180,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an empty array with spaces in it // can skip an empty array with spaces in it
@ -186,7 +189,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an array // can skip an array
@ -195,7 +198,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an array with spaces in it // can skip an array with spaces in it
@ -204,7 +207,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an empty object // can skip an empty object
@ -213,7 +216,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an empty object with spaces in it // can skip an empty object with spaces in it
@ -222,7 +225,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// can skip an object // can skip an object
@ -231,7 +234,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// skip an object with spaces in it // skip an object with spaces in it
@ -240,7 +243,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":42}", "{\"example\":42}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
"{\"an_integer\": 0,\"example\":{\"type\":\"int\",\"outcome\":42}}", "{\"an_integer\": 0,\"example\":{\"type\":\"int\",\"outcome\":42}}",
@ -248,7 +251,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":{\"outcome\":42}}", "{\"example\":{\"outcome\":42}}",
2 * JSON_OBJECT_SIZE(1) + 16 2 * sizeofObject(1) + 16
}, },
{ {
// wildcard // wildcard
@ -257,7 +260,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":{\"outcome\":42}}", "{\"example\":{\"outcome\":42}}",
2 * JSON_OBJECT_SIZE(1) + 16 2 * sizeofObject(1) + 16
}, },
{ {
// exclusion filter (issue #1628) // exclusion filter (issue #1628)
@ -266,7 +269,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{\"example\":1}", "{\"example\":1}",
JSON_OBJECT_SIZE(1) + 8 sizeofObject(1) + 8
}, },
{ {
// only the first element of array counts // only the first element of array counts
@ -275,7 +278,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"[1,2,3]", "[1,2,3]",
JSON_ARRAY_SIZE(3) sizeofArray(3)
}, },
{ {
// only the first element of array counts // only the first element of array counts
@ -284,7 +287,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// filter members of object in array // filter members of object in array
@ -293,7 +296,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"[{\"example\":1},{\"example\":3}]", "[{\"example\":1},{\"example\":3}]",
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8 sizeofArray(2) + 2 * sizeofObject(1) + 8
}, },
{ {
"[',2,3]", "[',2,3]",
@ -301,7 +304,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
"[\",2,3]", "[\",2,3]",
@ -309,7 +312,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// detect errors in skipped value // detect errors in skipped value
@ -318,7 +321,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::InvalidInput, DeserializationError::InvalidInput,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// detect incomplete string event if it's skipped // detect incomplete string event if it's skipped
@ -471,7 +474,7 @@ TEST_CASE("Filtering") {
1, 1,
DeserializationError::TooDeep, DeserializationError::TooDeep,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// check nesting limit even for ignored arrays // check nesting limit even for ignored arrays
@ -498,7 +501,7 @@ TEST_CASE("Filtering") {
1, 1,
DeserializationError::TooDeep, DeserializationError::TooDeep,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// supports back-slash at the end of skipped string // supports back-slash at the end of skipped string
@ -543,7 +546,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::InvalidInput, DeserializationError::InvalidInput,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// incomplete comment at the begining of an array // incomplete comment at the begining of an array
@ -552,7 +555,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"[]", "[]",
JSON_ARRAY_SIZE(0) sizeofArray(0)
}, },
{ {
// invalid comment before key // invalid comment before key
@ -561,7 +564,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::InvalidInput, DeserializationError::InvalidInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// incomplete comment before key // incomplete comment before key
@ -570,7 +573,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// invalid comment after key // invalid comment after key
@ -579,7 +582,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::InvalidInput, DeserializationError::InvalidInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// incomplete comment after key // incomplete comment after key
@ -588,7 +591,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// invalid comment after colon // invalid comment after colon
@ -597,7 +600,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::InvalidInput, DeserializationError::InvalidInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// incomplete comment after colon // incomplete comment after colon
@ -606,7 +609,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::IncompleteInput, DeserializationError::IncompleteInput,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// comment next to an integer // comment next to an integer
@ -615,7 +618,7 @@ TEST_CASE("Filtering") {
10, 10,
DeserializationError::Ok, DeserializationError::Ok,
"{}", "{}",
JSON_OBJECT_SIZE(0) sizeofObject(0)
}, },
{ {
// invalid comment after opening brace of a skipped object // invalid comment after opening brace of a skipped object

8
extras/tests/JsonDeserializer/input_types.cpp
View File

@ -9,6 +9,8 @@
#include "CustomReader.hpp" #include "CustomReader.hpp"
using ArduinoJson::detail::sizeofObject;
TEST_CASE("deserializeJson(char*)") { TEST_CASE("deserializeJson(char*)") {
JsonDocument doc(1024); JsonDocument doc(1024);
@ -18,9 +20,9 @@ TEST_CASE("deserializeJson(char*)") {
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1)); CHECK(doc.memoryUsage() == sizeofObject(1));
CHECK(doc.as<JsonVariant>().memoryUsage() == CHECK(doc.as<JsonVariant>().memoryUsage() ==
JSON_OBJECT_SIZE(1)); // issue #1318 sizeofObject(1)); // issue #1318
} }
} }
@ -149,7 +151,7 @@ TEST_CASE("deserializeJson(VLA)") {
char vla[i]; char vla[i];
strcpy(vla, "{\"a\":42}"); strcpy(vla, "{\"a\":42}");
JsonDocument doc(JSON_OBJECT_SIZE(1)); JsonDocument doc(sizeofObject(1));
DeserializationError err = deserializeJson(doc, vla); DeserializationError err = deserializeJson(doc, vla);
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);

4
extras/tests/JsonDeserializer/misc.cpp
View File

@ -7,6 +7,8 @@
using namespace Catch::Matchers; using namespace Catch::Matchers;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("deserializeJson(JsonDocument&)") { TEST_CASE("deserializeJson(JsonDocument&)") {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -112,6 +114,6 @@ TEST_CASE("deserializeJson(JsonDocument&)") {
deserializeJson(doc, "{}"); deserializeJson(doc, "{}");
REQUIRE(doc.is<JsonObject>()); REQUIRE(doc.is<JsonObject>());
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofObject(0));
} }
} }

19
extras/tests/JsonDeserializer/object.cpp
View File

@ -5,6 +5,9 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("deserialize JSON object") { TEST_CASE("deserialize JSON object") {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -304,7 +307,7 @@ TEST_CASE("deserialize JSON object") {
REQUIRE(doc.is<JsonObject>()); REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0); REQUIRE(obj.size() == 0);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofObject(0));
} }
SECTION("Issue #1335") { SECTION("Issue #1335") {
@ -316,7 +319,7 @@ TEST_CASE("deserialize JSON object") {
TEST_CASE("deserialize JSON object under memory constraints") { TEST_CASE("deserialize JSON object under memory constraints") {
SECTION("buffer for the right size for an empty object") { SECTION("buffer for the right size for an empty object") {
JsonDocument doc(JSON_OBJECT_SIZE(0)); JsonDocument doc(sizeofObject(0));
char input[] = "{}"; char input[] = "{}";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -325,7 +328,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
} }
SECTION("buffer too small for an empty object") { SECTION("buffer too small for an empty object") {
JsonDocument doc(JSON_OBJECT_SIZE(0)); JsonDocument doc(sizeofObject(0));
char input[] = "{\"a\":1}"; char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -334,7 +337,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
} }
SECTION("buffer of the right size for an object with one member") { SECTION("buffer of the right size for an object with one member") {
JsonDocument doc(JSON_OBJECT_SIZE(1)); JsonDocument doc(sizeofObject(1));
char input[] = "{\"a\":1}"; char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -343,7 +346,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
} }
SECTION("buffer too small for an object with a nested array") { SECTION("buffer too small for an object with a nested array") {
JsonDocument doc(JSON_OBJECT_SIZE(0) + JSON_ARRAY_SIZE(0)); JsonDocument doc(sizeofObject(0) + sizeofArray(0));
char input[] = "{\"a\":[]}"; char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -352,7 +355,7 @@ TEST_CASE("deserialize JSON object under memory constraints") {
} }
SECTION("buffer of the right size for an object with a nested array") { SECTION("buffer of the right size for an object with a nested array") {
JsonDocument doc(JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)); JsonDocument doc(sizeofObject(1) + sizeofArray(0));
char input[] = "{\"a\":[]}"; char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
@ -361,13 +364,13 @@ TEST_CASE("deserialize JSON object under memory constraints") {
} }
SECTION("Should clear the JsonObject") { SECTION("Should clear the JsonObject") {
JsonDocument doc(JSON_OBJECT_SIZE(1)); JsonDocument doc(sizeofObject(1));
char input[] = "{\"hello\":\"world\"}"; char input[] = "{\"hello\":\"world\"}";
deserializeJson(doc, input); deserializeJson(doc, input);
deserializeJson(doc, "{}"); deserializeJson(doc, "{}");
REQUIRE(doc.as<JsonObject>().size() == 0); REQUIRE(doc.as<JsonObject>().size() == 0);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofObject(0));
} }
} }

5
extras/tests/JsonDeserializer/string.cpp
View File

@ -6,6 +6,9 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofObject;
using ArduinoJson::detail::sizeofString;
TEST_CASE("Valid JSON strings value") { TEST_CASE("Valid JSON strings value") {
struct TestCase { struct TestCase {
const char* input; const char* input;
@ -93,7 +96,7 @@ TEST_CASE("Invalid JSON string") {
} }
TEST_CASE("Not enough room to save the key") { TEST_CASE("Not enough room to save the key") {
JsonDocument doc(JSON_OBJECT_SIZE(1) + 8); JsonDocument doc(sizeofObject(1) + 8);
SECTION("Quoted string") { SECTION("Quoted string") {
REQUIRE(deserializeJson(doc, "{\"example\":1}") == REQUIRE(deserializeJson(doc, "{\"example\":1}") ==

26
extras/tests/JsonDocument/JsonDocument.cpp
View File

@ -6,6 +6,8 @@
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::addPadding; using ArduinoJson::detail::addPadding;
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) { static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) {
std::string json; std::string json;
@ -31,19 +33,19 @@ TEST_CASE("JsonDocument") {
REQUIRE(doc.memoryUsage() == 0); REQUIRE(doc.memoryUsage() == 0);
} }
SECTION("JSON_ARRAY_SIZE(0)") { SECTION("sizeofArray(0)") {
doc.to<JsonArray>(); doc.to<JsonArray>();
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofArray(0));
} }
SECTION("JSON_ARRAY_SIZE(1)") { SECTION("sizeofArray(1)") {
doc.to<JsonArray>().add(42); doc.to<JsonArray>().add(42);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1)); REQUIRE(doc.memoryUsage() == sizeofArray(1));
} }
SECTION("JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0)") { SECTION("sizeofArray(1) + sizeofArray(0)") {
doc.to<JsonArray>().createNestedArray(); doc.to<JsonArray>().createNestedArray();
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1) + JSON_ARRAY_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofArray(1) + sizeofArray(0));
} }
} }
@ -63,21 +65,21 @@ TEST_CASE("JsonDocument") {
SECTION("Increases after adding value to array") { SECTION("Increases after adding value to array") {
JsonArray arr = doc.to<JsonArray>(); JsonArray arr = doc.to<JsonArray>();
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofArray(0));
arr.add(42); arr.add(42);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(1)); REQUIRE(doc.memoryUsage() == sizeofArray(1));
arr.add(43); arr.add(43);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2)); REQUIRE(doc.memoryUsage() == sizeofArray(2));
} }
SECTION("Increases after adding value to object") { SECTION("Increases after adding value to object") {
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); REQUIRE(doc.memoryUsage() == sizeofObject(0));
obj["a"] = 1; obj["a"] = 1;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1)); REQUIRE(doc.memoryUsage() == sizeofObject(1));
obj["b"] = 2; obj["b"] = 2;
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2)); REQUIRE(doc.memoryUsage() == sizeofObject(2));
} }
} }
} }

10
extras/tests/JsonDocument/allocator.cpp
View File

@ -8,6 +8,8 @@
#include <sstream> #include <sstream>
#include <utility> #include <utility>
using ArduinoJson::detail::sizeofObject;
class SpyingAllocator : public Allocator { class SpyingAllocator : public Allocator {
public: public:
virtual ~SpyingAllocator() {} virtual ~SpyingAllocator() {}
@ -165,13 +167,13 @@ TEST_CASE("JsonDocument's allocator") {
SECTION("when allocation succeeds") { SECTION("when allocation succeeds") {
deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}"); deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
REQUIRE(doc.capacity() == 4096); REQUIRE(doc.capacity() == 4096);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
doc.remove("blanket"); doc.remove("blanket");
bool result = doc.garbageCollect(); bool result = doc.garbageCollect();
REQUIRE(result == true); REQUIRE(result == true);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); REQUIRE(doc.memoryUsage() == sizeofObject(1) + 8);
REQUIRE(doc.capacity() == 4096); REQUIRE(doc.capacity() == 4096);
REQUIRE(doc.as<std::string>() == "{\"dancing\":2}"); REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
} }
@ -179,14 +181,14 @@ TEST_CASE("JsonDocument's allocator") {
SECTION("when allocation fails") { SECTION("when allocation fails") {
deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}"); deserializeJson(doc, "{\"blanket\":1,\"dancing\":2}");
REQUIRE(doc.capacity() == 4096); REQUIRE(doc.capacity() == 4096);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
doc.remove("blanket"); doc.remove("blanket");
controllableAllocator.disable(); controllableAllocator.disable();
bool result = doc.garbageCollect(); bool result = doc.garbageCollect();
REQUIRE(result == false); REQUIRE(result == false);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); REQUIRE(doc.memoryUsage() == sizeofObject(2) + 16);
REQUIRE(doc.capacity() == 4096); REQUIRE(doc.capacity() == 4096);
REQUIRE(doc.as<std::string>() == "{\"dancing\":2}"); REQUIRE(doc.as<std::string>() == "{\"dancing\":2}");
} }

18
extras/tests/JsonDocument/overflowed.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
TEST_CASE("JsonDocument::overflowed()") { TEST_CASE("JsonDocument::overflowed()") {
SECTION("returns false on a fresh object") { SECTION("returns false on a fresh object") {
JsonDocument doc(0); JsonDocument doc(0);
@ -18,19 +20,19 @@ TEST_CASE("JsonDocument::overflowed()") {
} }
SECTION("returns false after successful insertion") { SECTION("returns false after successful insertion") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
doc.add(0); doc.add(0);
CHECK(doc.overflowed() == false); CHECK(doc.overflowed() == false);
} }
SECTION("returns true after a failed string copy") { SECTION("returns true after a failed string copy") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
doc.add(std::string("example")); doc.add(std::string("example"));
CHECK(doc.overflowed() == true); CHECK(doc.overflowed() == true);
} }
SECTION("returns false after a successful string copy") { SECTION("returns false after a successful string copy") {
JsonDocument doc(JSON_ARRAY_SIZE(1) + 8); JsonDocument doc(sizeofArray(1) + 8);
doc.add(std::string("example")); doc.add(std::string("example"));
CHECK(doc.overflowed() == false); CHECK(doc.overflowed() == false);
} }
@ -42,13 +44,13 @@ TEST_CASE("JsonDocument::overflowed()") {
} }
SECTION("returns true after a failed deserialization") { SECTION("returns true after a failed deserialization") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
deserializeJson(doc, "[\"example\"]"); deserializeJson(doc, "[\"example\"]");
CHECK(doc.overflowed() == true); CHECK(doc.overflowed() == true);
} }
SECTION("returns false after a successful deserialization") { SECTION("returns false after a successful deserialization") {
JsonDocument doc(JSON_ARRAY_SIZE(1) + 8); JsonDocument doc(sizeofArray(1) + 8);
deserializeJson(doc, "[\"example\"]"); deserializeJson(doc, "[\"example\"]");
CHECK(doc.overflowed() == false); CHECK(doc.overflowed() == false);
} }
@ -61,14 +63,14 @@ TEST_CASE("JsonDocument::overflowed()") {
} }
SECTION("remains false after shrinkToFit()") { SECTION("remains false after shrinkToFit()") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
doc.add(0); doc.add(0);
doc.shrinkToFit(); doc.shrinkToFit();
CHECK(doc.overflowed() == false); CHECK(doc.overflowed() == false);
} }
SECTION("remains true after shrinkToFit()") { SECTION("remains true after shrinkToFit()") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
doc.add(0); doc.add(0);
doc.add(0); doc.add(0);
doc.shrinkToFit(); doc.shrinkToFit();
@ -76,7 +78,7 @@ TEST_CASE("JsonDocument::overflowed()") {
} }
SECTION("return false after garbageCollect()") { SECTION("return false after garbageCollect()") {
JsonDocument doc(JSON_ARRAY_SIZE(1)); JsonDocument doc(sizeofArray(1));
doc.add(0); doc.add(0);
doc.add(0); doc.add(0);
doc.garbageCollect(); doc.garbageCollect();

25
extras/tests/JsonDocument/shrinkToFit.cpp
View File

@ -8,6 +8,9 @@
#include <stdlib.h> // malloc, free #include <stdlib.h> // malloc, free
#include <string> #include <string>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
class ArmoredAllocator : public Allocator { class ArmoredAllocator : public Allocator {
public: public:
ArmoredAllocator() : _ptr(0), _size(0) {} ArmoredAllocator() : _ptr(0), _size(0) {}
@ -68,12 +71,12 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
SECTION("empty object") { SECTION("empty object") {
deserializeJson(doc, "{}"); deserializeJson(doc, "{}");
testShrinkToFit(doc, "{}", JSON_OBJECT_SIZE(0)); testShrinkToFit(doc, "{}", sizeofObject(0));
} }
SECTION("empty array") { SECTION("empty array") {
deserializeJson(doc, "[]"); deserializeJson(doc, "[]");
testShrinkToFit(doc, "[]", JSON_ARRAY_SIZE(0)); testShrinkToFit(doc, "[]", sizeofArray(0));
} }
SECTION("linked string") { SECTION("linked string") {
@ -98,43 +101,43 @@ TEST_CASE("JsonDocument::shrinkToFit()") {
SECTION("linked key") { SECTION("linked key") {
doc["key"] = 42; doc["key"] = 42;
testShrinkToFit(doc, "{\"key\":42}", JSON_OBJECT_SIZE(1)); testShrinkToFit(doc, "{\"key\":42}", sizeofObject(1));
} }
SECTION("owned key") { SECTION("owned key") {
doc[std::string("abcdefg")] = 42; doc[std::string("abcdefg")] = 42;
testShrinkToFit(doc, "{\"abcdefg\":42}", JSON_OBJECT_SIZE(1) + 8); testShrinkToFit(doc, "{\"abcdefg\":42}", sizeofObject(1) + 8);
} }
SECTION("linked string in array") { SECTION("linked string in array") {
doc.add("hello"); doc.add("hello");
testShrinkToFit(doc, "[\"hello\"]", JSON_ARRAY_SIZE(1)); testShrinkToFit(doc, "[\"hello\"]", sizeofArray(1));
} }
SECTION("owned string in array") { SECTION("owned string in array") {
doc.add(std::string("abcdefg")); doc.add(std::string("abcdefg"));
testShrinkToFit(doc, "[\"abcdefg\"]", JSON_ARRAY_SIZE(1) + 8); testShrinkToFit(doc, "[\"abcdefg\"]", sizeofArray(1) + 8);
} }
SECTION("linked string in object") { SECTION("linked string in object") {
doc["key"] = "hello"; doc["key"] = "hello";
testShrinkToFit(doc, "{\"key\":\"hello\"}", JSON_OBJECT_SIZE(1)); testShrinkToFit(doc, "{\"key\":\"hello\"}", sizeofObject(1));
} }
SECTION("owned string in object") { SECTION("owned string in object") {
doc["key"] = std::string("abcdefg"); doc["key"] = std::string("abcdefg");
testShrinkToFit(doc, "{\"key\":\"abcdefg\"}", JSON_ARRAY_SIZE(1) + 8); testShrinkToFit(doc, "{\"key\":\"abcdefg\"}", sizeofArray(1) + 8);
} }
SECTION("unaligned") { SECTION("unaligned") {
doc.add(std::string("?")); // two bytes in the string pool doc.add(std::string("?")); // two bytes in the string pool
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2); REQUIRE(doc.memoryUsage() == sizeofObject(1) + 2);
doc.shrinkToFit(); doc.shrinkToFit();
// the new capacity should be padded to align the pointers // the new capacity should be padded to align the pointers
REQUIRE(doc.capacity() == JSON_OBJECT_SIZE(1) + sizeof(void*)); REQUIRE(doc.capacity() == sizeofObject(1) + sizeof(void*));
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 2); REQUIRE(doc.memoryUsage() == sizeofObject(1) + 2);
REQUIRE(doc[0] == "?"); REQUIRE(doc[0] == "?");
} }
} }

6
extras/tests/JsonObject/copy.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofObject;
TEST_CASE("JsonObject::set()") { TEST_CASE("JsonObject::set()") {
JsonDocument doc1(4096); JsonDocument doc1(4096);
JsonDocument doc2(4096); JsonDocument doc2(4096);
@ -72,7 +74,7 @@ TEST_CASE("JsonObject::set()") {
} }
SECTION("destination too small to store the key") { SECTION("destination too small to store the key") {
JsonDocument doc3(JSON_OBJECT_SIZE(1)); JsonDocument doc3(sizeofObject(1));
JsonObject obj3 = doc3.to<JsonObject>(); JsonObject obj3 = doc3.to<JsonObject>();
obj1[std::string("hello")] = "world"; obj1[std::string("hello")] = "world";
@ -84,7 +86,7 @@ TEST_CASE("JsonObject::set()") {
} }
SECTION("destination too small to store the value") { SECTION("destination too small to store the value") {
JsonDocument doc3(JSON_OBJECT_SIZE(1)); JsonDocument doc3(sizeofObject(1));
JsonObject obj3 = doc3.to<JsonObject>(); JsonObject obj3 = doc3.to<JsonObject>();
obj1["hello"] = std::string("world"); obj1["hello"] = std::string("world");

5
extras/tests/JsonObject/iterator.cpp
View File

@ -6,9 +6,10 @@
#include <catch.hpp> #include <catch.hpp>
using namespace Catch::Matchers; using namespace Catch::Matchers;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("JsonObject::begin()/end()") { TEST_CASE("JsonObject::begin()/end()") {
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
obj["ab"] = 12; obj["ab"] = 12;
obj["cd"] = 34; obj["cd"] = 34;
@ -38,7 +39,7 @@ TEST_CASE("JsonObject::begin()/end()") {
} }
TEST_CASE("JsonObjectConst::begin()/end()") { TEST_CASE("JsonObjectConst::begin()/end()") {
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
obj["ab"] = 12; obj["ab"] = 12;
obj["cd"] = 34; obj["cd"] = 34;

17
extras/tests/JsonObject/memoryUsage.cpp
View File

@ -6,6 +6,9 @@
#include <catch.hpp> #include <catch.hpp>
#include <string> #include <string>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("JsonObject::memoryUsage()") { TEST_CASE("JsonObject::memoryUsage()") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
@ -15,29 +18,29 @@ TEST_CASE("JsonObject::memoryUsage()") {
REQUIRE(unitialized.memoryUsage() == 0); REQUIRE(unitialized.memoryUsage() == 0);
} }
SECTION("JSON_OBJECT_SIZE(0) for empty object") { SECTION("sizeofObject(0) for empty object") {
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(0)); REQUIRE(obj.memoryUsage() == sizeofObject(0));
} }
SECTION("JSON_OBJECT_SIZE(1) after add") { SECTION("sizeofObject(1) after add") {
obj["hello"] = 42; obj["hello"] = 42;
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1)); REQUIRE(obj.memoryUsage() == sizeofObject(1));
} }
SECTION("includes the size of the key") { SECTION("includes the size of the key") {
obj[std::string("hello")] = 42; obj[std::string("hello")] = 42;
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + 6); REQUIRE(obj.memoryUsage() == sizeofObject(1) + 6);
} }
SECTION("includes the size of the nested array") { SECTION("includes the size of the nested array") {
JsonArray nested = obj.createNestedArray("nested"); JsonArray nested = obj.createNestedArray("nested");
nested.add(42); nested.add(42);
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(1)); REQUIRE(obj.memoryUsage() == sizeofObject(1) + sizeofArray(1));
} }
SECTION("includes the size of the nested object") { SECTION("includes the size of the nested object") {
JsonObject nested = obj.createNestedObject("nested"); JsonObject nested = obj.createNestedObject("nested");
nested["hello"] = "world"; nested["hello"] = "world";
REQUIRE(obj.memoryUsage() == 2 * JSON_OBJECT_SIZE(1)); REQUIRE(obj.memoryUsage() == 2 * sizeofObject(1));
} }
} }

21
extras/tests/JsonObject/subscript.cpp
View File

@ -5,6 +5,9 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofObject;
using ArduinoJson::detail::sizeofString;
TEST_CASE("JsonObject::operator[]") { TEST_CASE("JsonObject::operator[]") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonObject obj = doc.to<JsonObject>(); JsonObject obj = doc.to<JsonObject>();
@ -100,55 +103,55 @@ TEST_CASE("JsonObject::operator[]") {
SECTION("should not duplicate const char*") { SECTION("should not duplicate const char*") {
obj["hello"] = "world"; obj["hello"] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1); const size_t expectedSize = sizeofObject(1);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate char* value") { SECTION("should duplicate char* value") {
obj["hello"] = const_cast<char*>("world"); obj["hello"] = const_cast<char*>("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate char* key") { SECTION("should duplicate char* key") {
obj[const_cast<char*>("hello")] = "world"; obj[const_cast<char*>("hello")] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate char* key&value") { SECTION("should duplicate char* key&value") {
obj[const_cast<char*>("hello")] = const_cast<char*>("world"); obj[const_cast<char*>("hello")] = const_cast<char*>("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 2 * JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + 2 * sizeofString(5);
REQUIRE(expectedSize <= doc.memoryUsage()); REQUIRE(expectedSize <= doc.memoryUsage());
} }
SECTION("should duplicate std::string value") { SECTION("should duplicate std::string value") {
obj["hello"] = std::string("world"); obj["hello"] = std::string("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate std::string key") { SECTION("should duplicate std::string key") {
obj[std::string("hello")] = "world"; obj[std::string("hello")] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should duplicate std::string key&value") { SECTION("should duplicate std::string key&value") {
obj[std::string("hello")] = std::string("world"); obj[std::string("hello")] = std::string("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 2 * JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + 2 * sizeofString(5);
REQUIRE(expectedSize <= doc.memoryUsage()); REQUIRE(expectedSize <= doc.memoryUsage());
} }
SECTION("should duplicate a non-static JsonString key") { SECTION("should duplicate a non-static JsonString key") {
obj[JsonString("hello", JsonString::Copied)] = "world"; obj[JsonString("hello", JsonString::Copied)] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(5); const size_t expectedSize = sizeofObject(1) + sizeofString(5);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }
SECTION("should not duplicate a static JsonString key") { SECTION("should not duplicate a static JsonString key") {
obj[JsonString("hello", JsonString::Linked)] = "world"; obj[JsonString("hello", JsonString::Linked)] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1); const size_t expectedSize = sizeofObject(1);
REQUIRE(expectedSize == doc.memoryUsage()); REQUIRE(expectedSize == doc.memoryUsage());
} }

4
extras/tests/JsonSerializer/JsonArray.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
static void check(JsonArray array, std::string expected) { static void check(JsonArray array, std::string expected) {
std::string actual; std::string actual;
size_t actualLen = serializeJson(array, actual); size_t actualLen = serializeJson(array, actual);
@ -15,7 +17,7 @@ static void check(JsonArray array, std::string expected) {
} }
TEST_CASE("serializeJson(JsonArray)") { TEST_CASE("serializeJson(JsonArray)") {
JsonDocument doc(JSON_ARRAY_SIZE(2)); JsonDocument doc(sizeofArray(2));
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
SECTION("Empty") { SECTION("Empty") {

18
extras/tests/JsonVariant/copy.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofString;
TEST_CASE("JsonVariant::set(JsonVariant)") { TEST_CASE("JsonVariant::set(JsonVariant)") {
JsonDocument doc1(4096); JsonDocument doc1(4096);
JsonDocument doc2(4096); JsonDocument doc2(4096);
@ -47,16 +49,16 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
var1.set(str); var1.set(str);
var2.set(var1); var2.set(var1);
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc1.memoryUsage() == sizeofString(7));
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc2.memoryUsage() == sizeofString(7));
} }
SECTION("stores std::string by copy") { SECTION("stores std::string by copy") {
var1.set(std::string("hello!!")); var1.set(std::string("hello!!"));
var2.set(var1); var2.set(var1);
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc1.memoryUsage() == sizeofString(7));
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc2.memoryUsage() == sizeofString(7));
} }
SECTION("stores Serialized<const char*> by reference") { SECTION("stores Serialized<const char*> by reference") {
@ -72,16 +74,16 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
var1.set(serialized(str, 7)); var1.set(serialized(str, 7));
var2.set(var1); var2.set(var1);
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc1.memoryUsage() == sizeofString(7));
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc2.memoryUsage() == sizeofString(7));
} }
SECTION("stores Serialized<std::string> by copy") { SECTION("stores Serialized<std::string> by copy") {
var1.set(serialized(std::string("hello!!"))); var1.set(serialized(std::string("hello!!")));
var2.set(var1); var2.set(var1);
REQUIRE(doc1.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc1.memoryUsage() == sizeofString(7));
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7)); REQUIRE(doc2.memoryUsage() == sizeofString(7));
} }
SECTION("destination is unbound") { SECTION("destination is unbound") {

7
extras/tests/JsonVariant/memoryUsage.cpp
View File

@ -6,6 +6,9 @@
#include <catch.hpp> #include <catch.hpp>
#include <string> #include <string>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("JsonVariant::memoryUsage()") { TEST_CASE("JsonVariant::memoryUsage()") {
JsonDocument doc(4096); JsonDocument doc(4096);
JsonVariant var = doc.to<JsonVariant>(); JsonVariant var = doc.to<JsonVariant>();
@ -18,13 +21,13 @@ TEST_CASE("JsonVariant::memoryUsage()") {
SECTION("returns size of object") { SECTION("returns size of object") {
JsonObject obj = var.to<JsonObject>(); JsonObject obj = var.to<JsonObject>();
obj["hello"] = 42; obj["hello"] = 42;
REQUIRE(var.memoryUsage() == JSON_OBJECT_SIZE(1)); REQUIRE(var.memoryUsage() == sizeofObject(1));
} }
SECTION("returns size of array") { SECTION("returns size of array") {
JsonArray arr = var.to<JsonArray>(); JsonArray arr = var.to<JsonArray>();
arr.add(42); arr.add(42);
REQUIRE(var.memoryUsage() == JSON_ARRAY_SIZE(1)); REQUIRE(var.memoryUsage() == sizeofArray(1));
} }
SECTION("returns size of owned string") { SECTION("returns size of owned string") {

4
extras/tests/MemoryPool/StringCopier.cpp
View File

@ -9,7 +9,7 @@ using namespace ArduinoJson::detail;
TEST_CASE("StringCopier") { TEST_CASE("StringCopier") {
SECTION("Works when buffer is big enough") { SECTION("Works when buffer is big enough") {
MemoryPool pool(addPadding(JSON_STRING_SIZE(5))); MemoryPool pool(addPadding(sizeofString(5)));
StringCopier str(&pool); StringCopier str(&pool);
str.startString(); str.startString();
@ -32,7 +32,7 @@ TEST_CASE("StringCopier") {
} }
SECTION("Increases size of memory pool") { SECTION("Increases size of memory pool") {
MemoryPool pool(addPadding(JSON_STRING_SIZE(6))); MemoryPool pool(addPadding(sizeofString(6)));
StringCopier str(&pool); StringCopier str(&pool);
str.startString(); str.startString();

4
extras/tests/Misc/printable.cpp
View File

@ -8,6 +8,8 @@
#define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1 #define ARDUINOJSON_ENABLE_ARDUINO_STREAM 1
#include <ArduinoJson.h> #include <ArduinoJson.h>
using ArduinoJson::detail::sizeofArray;
struct PrintOneCharacterAtATime { struct PrintOneCharacterAtATime {
static size_t printStringTo(const std::string& s, Print& p) { static size_t printStringTo(const std::string& s, Print& p) {
size_t result = 0; size_t result = 0;
@ -139,6 +141,6 @@ TEST_CASE("Printable") {
REQUIRE(doc.size() == 2); REQUIRE(doc.size() == 2);
CHECK(doc[0] == "Hello World!"); CHECK(doc[0] == "Hello World!");
CHECK(doc[1] == "Hello World!"); CHECK(doc[1] == "Hello World!");
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 13); CHECK(doc.memoryUsage() == sizeofArray(2) + 13);
} }
} }

18
extras/tests/Misc/unsigned_char.cpp
View File

@ -9,11 +9,13 @@
# define CONFLICTS_WITH_BUILTIN_OPERATOR # define CONFLICTS_WITH_BUILTIN_OPERATOR
#endif #endif
using ArduinoJson::detail::sizeofObject;
TEST_CASE("unsigned char[]") { TEST_CASE("unsigned char[]") {
SECTION("deserializeJson()") { SECTION("deserializeJson()") {
unsigned char input[] = "{\"a\":42}"; unsigned char input[] = "{\"a\":42}";
JsonDocument doc(JSON_OBJECT_SIZE(1)); JsonDocument doc(sizeofObject(1));
DeserializationError err = deserializeJson(doc, input); DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);
@ -22,7 +24,7 @@ TEST_CASE("unsigned char[]") {
SECTION("deserializeMsgPack()") { SECTION("deserializeMsgPack()") {
unsigned char input[] = "\xDE\x00\x01\xA5Hello\xA5world"; unsigned char input[] = "\xDE\x00\x01\xA5Hello\xA5world";
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
DeserializationError err = deserializeMsgPack(doc, input); DeserializationError err = deserializeMsgPack(doc, input);
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);
@ -30,7 +32,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeMsgPack(unsigned char[])") { SECTION("serializeMsgPack(unsigned char[])") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeMsgPack(doc, buffer); size_t n = serializeMsgPack(doc, buffer);
@ -41,7 +43,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeMsgPack(unsigned char*)") { SECTION("serializeMsgPack(unsigned char*)") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeMsgPack(doc, buffer, sizeof(buffer)); size_t n = serializeMsgPack(doc, buffer, sizeof(buffer));
@ -52,7 +54,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJson(unsigned char[])") { SECTION("serializeJson(unsigned char[])") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeJson(doc, buffer); size_t n = serializeJson(doc, buffer);
@ -63,7 +65,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJson(unsigned char*)") { SECTION("serializeJson(unsigned char*)") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeJson(doc, buffer, sizeof(buffer)); size_t n = serializeJson(doc, buffer, sizeof(buffer));
@ -74,7 +76,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJsonPretty(unsigned char[])") { SECTION("serializeJsonPretty(unsigned char[])") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeJsonPretty(doc, buffer); size_t n = serializeJsonPretty(doc, buffer);
@ -84,7 +86,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJsonPretty(unsigned char*)") { SECTION("serializeJsonPretty(unsigned char*)") {
unsigned char buffer[32]; unsigned char buffer[32];
JsonDocument doc(JSON_OBJECT_SIZE(2)); JsonDocument doc(sizeofObject(2));
doc["hello"] = "world"; doc["hello"] = "world";
size_t n = serializeJsonPretty(doc, buffer, sizeof(buffer)); size_t n = serializeJsonPretty(doc, buffer, sizeof(buffer));

28
extras/tests/MixedConfiguration/enable_string_deduplication_0.cpp
View File

@ -11,6 +11,9 @@
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") { TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
JsonDocument doc(1024); JsonDocument doc(1024);
@ -18,15 +21,14 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
SECTION("Deduplicate values") { SECTION("Deduplicate values") {
deserializeJson(doc, "[\"example\",\"example\"]"); deserializeJson(doc, "[\"example\",\"example\"]");
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
CHECK(doc[0].as<const char*>() != doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
} }
SECTION("Deduplicate keys") { SECTION("Deduplicate keys") {
deserializeJson(doc, "[{\"example\":1},{\"example\":2}]"); deserializeJson(doc, "[{\"example\":1},{\"example\":2}]");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == 2 * sizeofObject(1) + sizeofArray(2) + 16);
2 * JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(2) + 16);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -41,7 +43,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc.add(std::string("example")); doc.add(std::string("example"));
doc.add(std::string("example")); doc.add(std::string("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
CHECK(doc[0].as<const char*>() != doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
} }
@ -50,7 +52,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc.add(value); doc.add(value);
doc.add(value); doc.add(value);
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
CHECK(doc[0].as<const char*>() != doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
} }
@ -58,7 +60,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc.add(String("example")); doc.add(String("example"));
doc.add(String("example")); doc.add(String("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
CHECK(doc[0].as<const char*>() != doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
} }
@ -66,7 +68,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc.add(F("example")); doc.add(F("example"));
doc.add(F("example")); doc.add(F("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofArray(2) + 16);
CHECK(doc[0].as<const char*>() != doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() != doc[1].as<const char*>());
} }
} }
@ -76,8 +78,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc[0][std::string("example")] = 1; doc[0][std::string("example")] = 1;
doc[1][std::string("example")] = 2; doc[1][std::string("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -89,8 +90,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc[0][key] = 1; doc[0][key] = 1;
doc[1][key] = 2; doc[1][key] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -101,8 +101,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc[0][String("example")] = 1; doc[0][String("example")] = 1;
doc[1][String("example")] = 2; doc[1][String("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -113,8 +112,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
doc[0][F("example")] = 1; doc[0][F("example")] = 1;
doc[1][F("example")] = 2; doc[1][F("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 16);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 16);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();

28
extras/tests/MixedConfiguration/enable_string_deduplication_1.cpp
View File

@ -11,6 +11,9 @@
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") { TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
JsonDocument doc(1024); JsonDocument doc(1024);
@ -18,15 +21,14 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
SECTION("Deduplicate values") { SECTION("Deduplicate values") {
deserializeJson(doc, "[\"example\",\"example\"]"); deserializeJson(doc, "[\"example\",\"example\"]");
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
CHECK(doc[0].as<const char*>() == doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
} }
SECTION("Deduplicate keys") { SECTION("Deduplicate keys") {
deserializeJson(doc, "[{\"example\":1},{\"example\":2}]"); deserializeJson(doc, "[{\"example\":1},{\"example\":2}]");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == 2 * sizeofObject(1) + sizeofArray(2) + 8);
2 * JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(2) + 8);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -40,7 +42,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc.add(std::string("example")); doc.add(std::string("example"));
doc.add(std::string("example")); doc.add(std::string("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
CHECK(doc[0].as<const char*>() == doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
} }
@ -49,7 +51,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc.add(value); doc.add(value);
doc.add(value); doc.add(value);
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
CHECK(doc[0].as<const char*>() == doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
} }
@ -57,7 +59,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc.add(String("example")); doc.add(String("example"));
doc.add(String("example")); doc.add(String("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
CHECK(doc[0].as<const char*>() == doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
} }
@ -65,7 +67,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc.add(F("example")); doc.add(F("example"));
doc.add(F("example")); doc.add(F("example"));
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(2) + 8); CHECK(doc.memoryUsage() == sizeofArray(2) + 8);
CHECK(doc[0].as<const char*>() == doc[1].as<const char*>()); CHECK(doc[0].as<const char*>() == doc[1].as<const char*>());
} }
} }
@ -75,8 +77,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc[0][std::string("example")] = 1; doc[0][std::string("example")] = 1;
doc[1][std::string("example")] = 2; doc[1][std::string("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -88,8 +89,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc[0][key] = 1; doc[0][key] = 1;
doc[1][key] = 2; doc[1][key] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -100,8 +100,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc[0][String("example")] = 1; doc[0][String("example")] = 1;
doc[1][String("example")] = 2; doc[1][String("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();
@ -112,8 +111,7 @@ TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
doc[0][F("example")] = 1; doc[0][F("example")] = 1;
doc[1][F("example")] = 2; doc[1][F("example")] = 2;
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(1) + 8);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(1) + 8);
const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str(); const char* key1 = doc[0].as<JsonObject>().begin()->key().c_str();
const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str(); const char* key2 = doc[1].as<JsonObject>().begin()->key().c_str();

63
extras/tests/MsgPackDeserializer/deserializeVariant.cpp
View File

@ -5,6 +5,10 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
using ArduinoJson::detail::sizeofString;
template <typename T> template <typename T>
static void checkValue(const char* input, T expected) { static void checkValue(const char* input, T expected) {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -185,89 +189,88 @@ TEST_CASE("deserializeMsgPack() under memory constaints") {
} }
SECTION("fixarray") { SECTION("fixarray") {
checkError(JSON_ARRAY_SIZE(0), "\x90", DeserializationError::Ok); // [] checkError(sizeofArray(0), "\x90", DeserializationError::Ok); // []
checkError(JSON_ARRAY_SIZE(0), "\x91\x01", checkError(sizeofArray(0), "\x91\x01",
DeserializationError::NoMemory); // [1] DeserializationError::NoMemory); // [1]
checkError(JSON_ARRAY_SIZE(1), "\x91\x01", checkError(sizeofArray(1), "\x91\x01",
DeserializationError::Ok); // [1] DeserializationError::Ok); // [1]
checkError(JSON_ARRAY_SIZE(1), "\x92\x01\x02", checkError(sizeofArray(1), "\x92\x01\x02",
DeserializationError::NoMemory); // [1,2] DeserializationError::NoMemory); // [1,2]
} }
SECTION("array 16") { SECTION("array 16") {
checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x00", DeserializationError::Ok); checkError(sizeofArray(0), "\xDC\x00\x00", DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x01\x01", checkError(sizeofArray(0), "\xDC\x00\x01\x01",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x01\x01", checkError(sizeofArray(1), "\xDC\x00\x01\x01", DeserializationError::Ok);
DeserializationError::Ok); checkError(sizeofArray(1), "\xDC\x00\x02\x01\x02",
checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x02\x01\x02",
DeserializationError::NoMemory); DeserializationError::NoMemory);
} }
SECTION("array 32") { SECTION("array 32") {
checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x00", checkError(sizeofArray(0), "\xDD\x00\x00\x00\x00",
DeserializationError::Ok); DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x01\x01", checkError(sizeofArray(0), "\xDD\x00\x00\x00\x01\x01",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x01\x01", checkError(sizeofArray(1), "\xDD\x00\x00\x00\x01\x01",
DeserializationError::Ok); DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x02\x01\x02", checkError(sizeofArray(1), "\xDD\x00\x00\x00\x02\x01\x02",
DeserializationError::NoMemory); DeserializationError::NoMemory);
} }
SECTION("fixmap") { SECTION("fixmap") {
SECTION("{}") { SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\x80", DeserializationError::Ok); checkError(sizeofObject(0), "\x80", DeserializationError::Ok);
} }
SECTION("{H:1}") { SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\x81\xA1H\x01", checkError(sizeofObject(0), "\x81\xA1H\x01",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), "\x81\xA1H\x01", checkError(sizeofObject(1) + sizeofString(2), "\x81\xA1H\x01",
DeserializationError::Ok); DeserializationError::Ok);
} }
SECTION("{H:1,W:2}") { SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), checkError(sizeofObject(1) + sizeofString(2), "\x82\xA1H\x01\xA1W\x02",
"\x82\xA1H\x01\xA1W\x02", DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_STRING_SIZE(2), checkError(sizeofObject(2) + 2 * sizeofString(2),
"\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok); "\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
} }
} }
SECTION("map 16") { SECTION("map 16") {
SECTION("{}") { SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x00", DeserializationError::Ok); checkError(sizeofObject(0), "\xDE\x00\x00", DeserializationError::Ok);
} }
SECTION("{H:1}") { SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x01\xA1H\x01", checkError(sizeofObject(0), "\xDE\x00\x01\xA1H\x01",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), checkError(sizeofObject(1) + sizeofString(2), "\xDE\x00\x01\xA1H\x01",
"\xDE\x00\x01\xA1H\x01", DeserializationError::Ok); DeserializationError::Ok);
} }
SECTION("{H:1,W:2}") { SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), checkError(sizeofObject(1) + sizeofString(2),
"\xDE\x00\x02\xA1H\x01\xA1W\x02", "\xDE\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1), checkError(sizeofObject(2) + 2 * sizeofObject(1),
"\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok); "\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
} }
} }
SECTION("map 32") { SECTION("map 32") {
SECTION("{}") { SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x00", checkError(sizeofObject(0), "\xDF\x00\x00\x00\x00",
DeserializationError::Ok); DeserializationError::Ok);
} }
SECTION("{H:1}") { SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x01\xA1H\x01", checkError(sizeofObject(0), "\xDF\x00\x00\x00\x01\xA1H\x01",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), checkError(sizeofObject(1) + sizeofString(2),
"\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok); "\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
} }
SECTION("{H:1,W:2}") { SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), checkError(sizeofObject(1) + sizeofString(2),
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02", "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory); DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1), checkError(sizeofObject(2) + 2 * sizeofObject(1),
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02", "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::Ok); DeserializationError::Ok);
} }

182
extras/tests/MsgPackDeserializer/filter.cpp
View File

@ -26,7 +26,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::IncompleteInput); CHECK(error == DeserializationError::IncompleteInput);
CHECK(doc.as<std::string>() == "{}"); CHECK(doc.as<std::string>() == "{}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); CHECK(doc.memoryUsage() == sizeofObject(0));
} }
SECTION("input truncated after inside skipped uint 8") { SECTION("input truncated after inside skipped uint 8") {
@ -35,7 +35,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::IncompleteInput); CHECK(error == DeserializationError::IncompleteInput);
CHECK(doc.as<std::string>() == "{}"); CHECK(doc.as<std::string>() == "{}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); CHECK(doc.memoryUsage() == sizeofObject(0));
} }
SECTION("input truncated after before skipped string size") { SECTION("input truncated after before skipped string size") {
@ -43,7 +43,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::IncompleteInput); CHECK(error == DeserializationError::IncompleteInput);
CHECK(doc.as<std::string>() == "{}"); CHECK(doc.as<std::string>() == "{}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); CHECK(doc.memoryUsage() == sizeofObject(0));
} }
SECTION("input truncated after before skipped ext size") { SECTION("input truncated after before skipped ext size") {
@ -51,7 +51,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::IncompleteInput); CHECK(error == DeserializationError::IncompleteInput);
CHECK(doc.as<std::string>() == "{}"); CHECK(doc.as<std::string>() == "{}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(0)); CHECK(doc.memoryUsage() == sizeofObject(0));
} }
SECTION("skip nil") { SECTION("skip nil") {
@ -60,7 +60,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("reject 0xc1") { SECTION("reject 0xc1") {
@ -76,7 +76,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip true") { SECTION("skip true") {
@ -85,7 +85,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip positive fixint") { SECTION("skip positive fixint") {
@ -94,7 +94,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip negative fixint") { SECTION("skip negative fixint") {
@ -103,7 +103,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip uint 8") { SECTION("skip uint 8") {
@ -112,7 +112,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip int 8") { SECTION("skip int 8") {
@ -121,7 +121,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip uint 16") { SECTION("skip uint 16") {
@ -130,7 +130,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip int 16") { SECTION("skip int 16") {
@ -139,7 +139,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip uint 32") { SECTION("skip uint 32") {
@ -149,7 +149,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip int 32") { SECTION("skip int 32") {
@ -159,7 +159,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip uint 64") { SECTION("skip uint 64") {
@ -170,7 +170,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip int 64") { SECTION("skip int 64") {
@ -181,7 +181,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip float 32") { SECTION("skip float 32") {
@ -191,7 +191,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip float 64") { SECTION("skip float 64") {
@ -202,7 +202,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixstr") { SECTION("skip fixstr") {
@ -211,7 +211,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip str 8") { SECTION("skip str 8") {
@ -220,7 +220,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip str 16") { SECTION("skip str 16") {
@ -229,7 +229,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip str 32") { SECTION("skip str 32") {
@ -239,7 +239,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip bin 8") { SECTION("skip bin 8") {
@ -248,7 +248,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip bin 16") { SECTION("skip bin 16") {
@ -257,7 +257,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip bin 32") { SECTION("skip bin 32") {
@ -267,7 +267,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixarray") { SECTION("skip fixarray") {
@ -276,7 +276,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip array 16") { SECTION("skip array 16") {
@ -286,7 +286,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip array 32") { SECTION("skip array 32") {
@ -299,7 +299,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixmap") { SECTION("skip fixmap") {
@ -309,7 +309,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip map 16") { SECTION("skip map 16") {
@ -321,7 +321,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip map 32") { SECTION("skip map 32") {
@ -335,7 +335,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixext 1") { SECTION("skip fixext 1") {
@ -347,7 +347,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixext 2") { SECTION("skip fixext 2") {
@ -359,7 +359,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixext 4") { SECTION("skip fixext 4") {
@ -371,7 +371,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixext 8") { SECTION("skip fixext 8") {
@ -383,7 +383,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip fixext 16") { SECTION("skip fixext 16") {
@ -397,7 +397,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip ext 8") { SECTION("skip ext 8") {
@ -409,7 +409,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip ext 16") { SECTION("skip ext 16") {
@ -421,7 +421,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
SECTION("skip ext 32") { SECTION("skip ext 32") {
@ -433,7 +433,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"include\":42}"); CHECK(doc.as<std::string>() == "{\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 8); CHECK(doc.memoryUsage() == sizeofObject(1) + 8);
} }
} }
@ -454,8 +454,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}"); "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
} }
SECTION("include array 16") { SECTION("include array 16") {
@ -470,8 +469,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}"); "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
} }
SECTION("include array 32") { SECTION("include array 32") {
@ -486,8 +484,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}"); "{\"onlyarr\":[{\"measure\":2},{\"measure\":4}],\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofArray(2) + 2 * sizeofObject(2) + 24);
JSON_ARRAY_SIZE(2) + 2 * JSON_OBJECT_SIZE(2) + 24);
} }
SECTION("skip null") { SECTION("skip null") {
@ -496,7 +493,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip false") { SECTION("skip false") {
@ -505,7 +502,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip true") { SECTION("skip true") {
@ -514,7 +511,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip positive fixint") { SECTION("skip positive fixint") {
@ -523,7 +520,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip negative fixint") { SECTION("skip negative fixint") {
@ -532,7 +529,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 8") { SECTION("skip uint 8") {
@ -541,7 +538,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 16") { SECTION("skip uint 16") {
@ -550,7 +547,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 32") { SECTION("skip uint 32") {
@ -560,7 +557,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 64") { SECTION("skip uint 64") {
@ -571,7 +568,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 8") { SECTION("skip int 8") {
@ -580,7 +577,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 16") { SECTION("skip int 16") {
@ -589,7 +586,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 32") { SECTION("skip int 32") {
@ -599,7 +596,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 64") { SECTION("skip int 64") {
@ -610,7 +607,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip float 32") { SECTION("skip float 32") {
@ -620,7 +617,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip float 64") { SECTION("skip float 64") {
@ -631,7 +628,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip fixstr") { SECTION("skip fixstr") {
@ -640,7 +637,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip str 8") { SECTION("skip str 8") {
@ -662,7 +659,7 @@ TEST_CASE("deserializeMsgPack() filter") {
doc, "\x82\xA7onlyarr\xdb\x00\x00\x00\x05hello\xA7include\x2A", doc, "\x82\xA7onlyarr\xdb\x00\x00\x00\x05hello\xA7include\x2A",
filterOpt); filterOpt);
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip fixmap") { SECTION("skip fixmap") {
@ -672,7 +669,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip map 16") { SECTION("skip map 16") {
@ -684,7 +681,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip map 32") { SECTION("skip map 32") {
@ -698,7 +695,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyarr\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
} }
} }
@ -713,7 +710,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "[]"); CHECK(doc.as<std::string>() == "[]");
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(0)); CHECK(doc.memoryUsage() == sizeofArray(0));
} }
} }
@ -726,7 +723,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "[1,2,3]"); CHECK(doc.as<std::string>() == "[1,2,3]");
CHECK(doc.memoryUsage() == JSON_ARRAY_SIZE(3)); CHECK(doc.memoryUsage() == sizeofArray(3));
} }
} }
} }
@ -747,8 +744,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyobj\":{\"measure\":2},\"include\":42}"); "{\"onlyobj\":{\"measure\":2},\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
} }
SECTION("include map 16") { SECTION("include map 16") {
@ -761,8 +757,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyobj\":{\"measure\":2},\"include\":42}"); "{\"onlyobj\":{\"measure\":2},\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
} }
SECTION("include map 32") { SECTION("include map 32") {
@ -776,8 +771,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == CHECK(doc.as<std::string>() ==
"{\"onlyobj\":{\"measure\":2},\"include\":42}"); "{\"onlyobj\":{\"measure\":2},\"include\":42}");
CHECK(doc.memoryUsage() == CHECK(doc.memoryUsage() == sizeofObject(2) + sizeofObject(1) + 24);
JSON_OBJECT_SIZE(2) + JSON_OBJECT_SIZE(1) + 24);
} }
SECTION("skip null") { SECTION("skip null") {
@ -786,7 +780,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip false") { SECTION("skip false") {
@ -795,7 +789,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip true") { SECTION("skip true") {
@ -804,7 +798,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip positive fixint") { SECTION("skip positive fixint") {
@ -813,7 +807,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip negative fixint") { SECTION("skip negative fixint") {
@ -822,7 +816,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 8") { SECTION("skip uint 8") {
@ -831,7 +825,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 16") { SECTION("skip uint 16") {
@ -840,7 +834,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 32") { SECTION("skip uint 32") {
@ -849,7 +843,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip uint 64") { SECTION("skip uint 64") {
@ -860,7 +854,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 8") { SECTION("skip int 8") {
@ -869,7 +863,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 16") { SECTION("skip int 16") {
@ -878,7 +872,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 32") { SECTION("skip int 32") {
@ -887,7 +881,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip int 64") { SECTION("skip int 64") {
@ -898,7 +892,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip float 32") { SECTION("skip float 32") {
@ -907,7 +901,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip float 64") { SECTION("skip float 64") {
@ -918,7 +912,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip fixstr") { SECTION("skip fixstr") {
@ -927,7 +921,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip str 8") { SECTION("skip str 8") {
@ -949,7 +943,7 @@ TEST_CASE("deserializeMsgPack() filter") {
doc, "\x82\xA7onlyobj\xdb\x00\x00\x00\x05hello\xA7include\x2A", doc, "\x82\xA7onlyobj\xdb\x00\x00\x00\x05hello\xA7include\x2A",
filterOpt); filterOpt);
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip fixarray") { SECTION("skip fixarray") {
@ -958,7 +952,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip array 16") { SECTION("skip array 16") {
@ -969,7 +963,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
SECTION("skip array 32") { SECTION("skip array 32") {
@ -981,7 +975,7 @@ TEST_CASE("deserializeMsgPack() filter") {
CHECK(error == DeserializationError::Ok); CHECK(error == DeserializationError::Ok);
CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}"); CHECK(doc.as<std::string>() == "{\"onlyobj\":null,\"include\":42}");
CHECK(doc.memoryUsage() == JSON_OBJECT_SIZE(2) + 16); CHECK(doc.memoryUsage() == sizeofObject(2) + 16);
} }
} }

4
extras/tests/MsgPackDeserializer/input_types.cpp
View File

@ -7,6 +7,8 @@
#include "CustomReader.hpp" #include "CustomReader.hpp"
using ArduinoJson::detail::sizeofObject;
TEST_CASE("deserializeMsgPack(const std::string&)") { TEST_CASE("deserializeMsgPack(const std::string&)") {
JsonDocument doc(4096); JsonDocument doc(4096);
@ -76,7 +78,7 @@ TEST_CASE("deserializeMsgPack(VLA)") {
char vla[i]; char vla[i];
memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15); memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15);
JsonDocument doc(JSON_OBJECT_SIZE(1)); JsonDocument doc(sizeofObject(1));
DeserializationError err = deserializeMsgPack(doc, vla); DeserializationError err = deserializeMsgPack(doc, vla);
REQUIRE(err == DeserializationError::Ok); REQUIRE(err == DeserializationError::Ok);

4
extras/tests/MsgPackSerializer/serializeArray.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
using ArduinoJson::detail::sizeofArray;
static void check(const JsonArray array, const char* expected_data, static void check(const JsonArray array, const char* expected_data,
size_t expected_len) { size_t expected_len) {
std::string expected(expected_data, expected_data + expected_len); std::string expected(expected_data, expected_data + expected_len);
@ -26,7 +28,7 @@ static void check(const JsonArray array, const std::string& expected) {
} }
TEST_CASE("serialize MsgPack array") { TEST_CASE("serialize MsgPack array") {
JsonDocument doc(JSON_ARRAY_SIZE(65536)); JsonDocument doc(sizeofArray(65536));
JsonArray array = doc.to<JsonArray>(); JsonArray array = doc.to<JsonArray>();
SECTION("empty") { SECTION("empty") {

5
keywords.txt
View File

@ -1,8 +1,3 @@
# Macros
JSON_ARRAY_SIZE KEYWORD2
JSON_OBJECT_SIZE KEYWORD2
JSON_STRING_SIZE KEYWORD2
# Free functions # Free functions
deserializeJson KEYWORD2 deserializeJson KEYWORD2
deserializeMsgPack KEYWORD2 deserializeMsgPack KEYWORD2

27
src/ArduinoJson/Memory/MemoryPool.hpp
View File

@ -13,20 +13,23 @@
#include <string.h> // memmove #include <string.h> // memmove
#define JSON_STRING_SIZE(SIZE) (SIZE + 1)
// Computes the size required to store an array in a JsonDocument.
// https://arduinojson.org/v6/how-to/determine-the-capacity-of-the-jsondocument/
#define JSON_ARRAY_SIZE(NUMBER_OF_ELEMENTS) \
((NUMBER_OF_ELEMENTS) * sizeof(ArduinoJson::detail::VariantSlot))
// Returns the size (in bytes) of an object with n elements.
// Can be very handy to determine the size of a StaticMemoryPool.
#define JSON_OBJECT_SIZE(NUMBER_OF_ELEMENTS) \
((NUMBER_OF_ELEMENTS) * sizeof(ArduinoJson::detail::VariantSlot))
ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE ARDUINOJSON_BEGIN_PRIVATE_NAMESPACE
// Returns the size (in bytes) of an array with n elements.
constexpr size_t sizeofArray(size_t n) {
return n * sizeof(VariantSlot);
}
// Returns the size (in bytes) of an object with n members.
constexpr size_t sizeofObject(size_t n) {
return n * sizeof(VariantSlot);
}
// Returns the size (in bytes) of an string with n characters.
constexpr size_t sizeofString(size_t n) {
return n + 1;
}
// _begin _end // _begin _end
// v v // v v
// +-------------+--------------+--------------+ // +-------------+--------------+--------------+