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

Remove capacity from JsonDocument's constructor

Browse Source
This commit is contained in:
Benoit Blanchon
2023-07-17 18:15:13 +02:00
parent 42b2840009
commit 0f319e7ca4
162 changed files with 438 additions and 500 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extras/tests/MsgPackDeserializer/deserializeArray.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
TEST_CASE("deserialize MsgPack array") {
JsonDocument doc(4096);
JsonDocument doc;
SECTION("fixarray") {
SECTION("empty") {

2
extras/tests/MsgPackDeserializer/deserializeObject.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
TEST_CASE("deserialize MsgPack object") {
JsonDocument doc(4096);
JsonDocument doc;
SECTION("fixmap") {
SECTION("empty") {

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

@ -7,13 +7,9 @@
#include "Allocators.hpp"
using ArduinoJson::detail::sizeofArray;
using ArduinoJson::detail::sizeofObject;
using ArduinoJson::detail::sizeofString;
template <typename T>
static void checkValue(const char* input, T expected) {
JsonDocument doc(4096);
JsonDocument doc;
DeserializationError error = deserializeMsgPack(doc, input);
@ -22,10 +18,10 @@ static void checkValue(const char* input, T expected) {
REQUIRE(doc.as<T>() == expected);
}
static void checkError(size_t capacity, size_t timebombCountDown,
const char* input, DeserializationError expected) {
static void checkError(size_t timebombCountDown, const char* input,
DeserializationError expected) {
TimebombAllocator timebombAllocator(timebombCountDown);
JsonDocument doc(capacity, &timebombAllocator);
JsonDocument doc(&timebombAllocator);
DeserializationError error = deserializeMsgPack(doc, input);
@ -147,121 +143,102 @@ TEST_CASE("deserialize MsgPack value") {
TEST_CASE("deserializeMsgPack() under memory constaints") {
SECTION("single values always fit") {
checkError(0, 0, "\xc0", DeserializationError::Ok); // nil
checkError(0, 0, "\xc2", DeserializationError::Ok); // false
checkError(0, 0, "\xc3", DeserializationError::Ok); // true
checkError(0, 0, "\xcc\x00", DeserializationError::Ok); // uint 8
checkError(0, 0, "\xcd\x30\x39", DeserializationError::Ok); // uint 16
checkError(0, 0, "\xCE\x12\x34\x56\x78",
checkError(0, "\xc0", DeserializationError::Ok); // nil
checkError(0, "\xc2", DeserializationError::Ok); // false
checkError(0, "\xc3", DeserializationError::Ok); // true
checkError(0, "\xcc\x00", DeserializationError::Ok); // uint 8
checkError(0, "\xcd\x30\x39", DeserializationError::Ok); // uint 16
checkError(0, "\xCE\x12\x34\x56\x78",
DeserializationError::Ok); // uint 32
}
SECTION("fixstr") {
checkError(0, 2, "\xA7ZZZZZZZ", DeserializationError::Ok);
checkError(0, 0, "\xA7ZZZZZZZ", DeserializationError::NoMemory);
checkError(2, "\xA7ZZZZZZZ", DeserializationError::Ok);
checkError(0, "\xA7ZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 8") {
checkError(0, 2, "\xD9\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, 0, "\xD9\x07ZZZZZZZ", DeserializationError::NoMemory);
checkError(2, "\xD9\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, "\xD9\x07ZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 16") {
checkError(0, 2, "\xDA\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, 0, "\xDA\x00\x07ZZZZZZZ", DeserializationError::NoMemory);
checkError(2, "\xDA\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, "\xDA\x00\x07ZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 32") {
checkError(0, 2, "\xDB\x00\x00\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, 0, "\xDB\x00\x00\x00\x07ZZZZZZZ",
checkError(2, "\xDB\x00\x00\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(0, "\xDB\x00\x00\x00\x07ZZZZZZZ",
DeserializationError::NoMemory);
}
SECTION("fixarray") {
checkError(sizeofArray(0), 0, "\x90", DeserializationError::Ok); // []
checkError(sizeofArray(0), 0, "\x91\x01",
checkError(0, "\x90", DeserializationError::Ok); // []
checkError(0, "\x91\x01",
DeserializationError::NoMemory); // [1]
checkError(sizeofArray(0), 1, "\x91\x01",
checkError(1, "\x91\x01",
DeserializationError::NoMemory); // [1]
checkError(sizeofArray(1), 2, "\x91\x01",
checkError(2, "\x91\x01",
DeserializationError::Ok); // [1]
}
SECTION("array 16") {
checkError(sizeofArray(0), 0, "\xDC\x00\x00", DeserializationError::Ok);
checkError(sizeofArray(0), 0, "\xDC\x00\x01\x01",
DeserializationError::NoMemory);
checkError(sizeofArray(0), 1, "\xDC\x00\x01\x01",
DeserializationError::NoMemory);
checkError(sizeofArray(1), 2, "\xDC\x00\x01\x01", DeserializationError::Ok);
checkError(0, "\xDC\x00\x00", DeserializationError::Ok);
checkError(0, "\xDC\x00\x01\x01", DeserializationError::NoMemory);
checkError(1, "\xDC\x00\x01\x01", DeserializationError::NoMemory);
checkError(2, "\xDC\x00\x01\x01", DeserializationError::Ok);
}
SECTION("array 32") {
checkError(sizeofArray(0), 0, "\xDD\x00\x00\x00\x00",
DeserializationError::Ok);
checkError(sizeofArray(0), 0, "\xDD\x00\x00\x00\x01\x01",
DeserializationError::NoMemory);
checkError(sizeofArray(1), 1, "\xDD\x00\x00\x00\x01\x01",
DeserializationError::NoMemory);
checkError(sizeofArray(1), 2, "\xDD\x00\x00\x00\x01\x01",
DeserializationError::Ok);
checkError(0, "\xDD\x00\x00\x00\x00", DeserializationError::Ok);
checkError(0, "\xDD\x00\x00\x00\x01\x01", DeserializationError::NoMemory);
checkError(1, "\xDD\x00\x00\x00\x01\x01", DeserializationError::NoMemory);
checkError(2, "\xDD\x00\x00\x00\x01\x01", DeserializationError::Ok);
}
SECTION("fixmap") {
SECTION("{}") {
checkError(sizeofObject(0), 0, "\x80", DeserializationError::Ok);
checkError(0, "\x80", DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(sizeofObject(0), 0, "\x81\xA1H\x01",
DeserializationError::NoMemory);
checkError(sizeofObject(1) + sizeofString(2), 4, "\x81\xA1H\x01",
DeserializationError::Ok);
checkError(0, "\x81\xA1H\x01", DeserializationError::NoMemory);
checkError(4, "\x81\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(sizeofObject(1) + sizeofString(2), 4, "\x82\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
checkError(sizeofObject(2) + 2 * sizeofString(2), 6,
"\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
checkError(4, "\x82\xA1H\x01\xA1W\x02", DeserializationError::NoMemory);
checkError(6, "\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 16") {
SECTION("{}") {
checkError(sizeofObject(0), 0, "\xDE\x00\x00", DeserializationError::Ok);
checkError(0, "\xDE\x00\x00", DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(sizeofObject(1) + sizeofString(2), 2, "\xDE\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
checkError(sizeofObject(1) + sizeofString(2), 4, "\xDE\x00\x01\xA1H\x01",
DeserializationError::Ok);
checkError(2, "\xDE\x00\x01\xA1H\x01", DeserializationError::NoMemory);
checkError(4, "\xDE\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(sizeofObject(1) + sizeofString(2), 4,
"\xDE\x00\x02\xA1H\x01\xA1W\x02",
checkError(4, "\xDE\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
checkError(sizeofObject(2) + 2 * sizeofObject(1), 6,
"\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
checkError(6, "\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 32") {
SECTION("{}") {
checkError(sizeofObject(0), 0, "\xDF\x00\x00\x00\x00",
DeserializationError::Ok);
checkError(0, "\xDF\x00\x00\x00\x00", DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(sizeofObject(1) + sizeofString(2), 2,
"\xDF\x00\x00\x00\x01\xA1H\x01",
checkError(2, "\xDF\x00\x00\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
checkError(sizeofObject(1) + sizeofString(2), 4,
"\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
checkError(4, "\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(sizeofObject(1) + 2 * sizeofString(2), 4,
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
checkError(4, "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
checkError(sizeofObject(2) + 2 * sizeofObject(1), 6,
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
checkError(6, "\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::Ok);
}
}

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

@ -10,10 +10,10 @@
using namespace ArduinoJson::detail;
TEST_CASE("deserializeMsgPack() filter") {
JsonDocument doc(4096);
JsonDocument doc;
DeserializationError error;
JsonDocument filter(200);
JsonDocument filter;
DeserializationOption::Filter filterOpt(filter);
SECTION("root is fixmap") {
@ -1032,10 +1032,10 @@ TEST_CASE("deserializeMsgPack() filter") {
TEST_CASE("Zero-copy mode") { // issue #1697
char input[] = "\x82\xA7include\x01\xA6ignore\x02";
JsonDocument filter(256);
JsonDocument filter;
filter["include"] = true;
JsonDocument doc(256);
JsonDocument doc;
DeserializationError err =
deserializeMsgPack(doc, input, 18, DeserializationOption::Filter(filter));
@ -1044,8 +1044,8 @@ TEST_CASE("Zero-copy mode") { // issue #1697
}
TEST_CASE("Overloads") {
JsonDocument doc(256);
JsonDocument filter(256);
JsonDocument doc;
JsonDocument filter;
using namespace DeserializationOption;

2
extras/tests/MsgPackDeserializer/incompleteInput.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
DeserializationError deserialize(const char* input, size_t len) {
JsonDocument doc(4096);
JsonDocument doc;
return deserializeMsgPack(doc, input, len);
}

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

@ -10,7 +10,7 @@
using ArduinoJson::detail::sizeofObject;
TEST_CASE("deserializeMsgPack(const std::string&)") {
JsonDocument doc(4096);
JsonDocument doc;
SECTION("should accept const string") {
const std::string input("\x92\x01\x02");
@ -50,7 +50,7 @@ TEST_CASE("deserializeMsgPack(const std::string&)") {
}
TEST_CASE("deserializeMsgPack(std::istream&)") {
JsonDocument doc(4096);
JsonDocument doc;
SECTION("should accept a zero in input") {
std::istringstream input(std::string("\x92\x00\x02", 3));
@ -78,7 +78,7 @@ TEST_CASE("deserializeMsgPack(VLA)") {
char vla[i];
memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15);
JsonDocument doc(sizeofObject(1));
JsonDocument doc;
DeserializationError err = deserializeMsgPack(doc, vla);
REQUIRE(err == DeserializationError::Ok);
@ -86,7 +86,7 @@ TEST_CASE("deserializeMsgPack(VLA)") {
#endif
TEST_CASE("deserializeMsgPack(CustomReader)") {
JsonDocument doc(4096);
JsonDocument doc;
CustomReader reader("\x92\xA5Hello\xA5world");
DeserializationError err = deserializeMsgPack(doc, reader);

2
extras/tests/MsgPackDeserializer/misc.cpp
View File

@ -8,7 +8,7 @@
#include <sstream>
TEST_CASE("deserializeMsgPack() returns EmptyInput") {
JsonDocument doc(100);
JsonDocument doc;
SECTION("from sized buffer") {
DeserializationError err = deserializeMsgPack(doc, "", 0);

2
extras/tests/MsgPackDeserializer/nestingLimit.cpp
View File

@ -12,7 +12,7 @@
REQUIRE(DeserializationError::TooDeep == expression);
TEST_CASE("JsonDeserializer nesting") {
JsonDocument doc(4096);
JsonDocument doc;
SECTION("Input = const char*") {
SECTION("limit = 0") {

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

@ -7,7 +7,7 @@
static void checkMsgPackDocument(const char* input, size_t inputSize,
const char* expectedJson) {
JsonDocument doc(4096);
JsonDocument doc;
DeserializationError error = deserializeMsgPack(doc, input, inputSize);
@ -19,7 +19,7 @@ static void checkMsgPackDocument(const char* input, size_t inputSize,
static void checkMsgPackError(const char* input, size_t inputSize,
DeserializationError expectedError) {
JsonDocument doc(4096);
JsonDocument doc;
DeserializationError error = deserializeMsgPack(doc, input, inputSize);