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

Remove StaticJsonDocument

Browse Source
This commit is contained in:
Benoit Blanchon
2023-03-15 14:54:55 +01:00
parent 5edd435fe9
commit 17a482a9b1
66 changed files with 477 additions and 1728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@ -8,7 +8,7 @@
#endif
TEST_CASE("string_view") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
JsonVariant variant = doc.to<JsonVariant>();
SECTION("deserializeJson()") {

2
extras/tests/Cpp20/smoke_test.cpp
View File

@ -4,7 +4,7 @@
#include <string>
TEST_CASE("C++20 smoke test") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
deserializeJson(doc, "{\"hello\":\"world\"}");
REQUIRE(doc["hello"] == "world");

2
extras/tests/IntegrationTests/openweathermap.cpp
View File

@ -53,7 +53,7 @@ TEST_CASE("OpenWeatherMap") {
"]}";
// clang-format on
StaticJsonDocument<512> filter;
DynamicJsonDocument filter(512);
filter["list"][0]["dt"] = true;
filter["list"][0]["main"]["temp"] = true;
filter["list"][0]["weather"][0]["description"] = true;

2
extras/tests/JsonArray/clear.cpp
View File

@ -14,7 +14,7 @@ TEST_CASE("JsonArray::clear()") {
}
SECTION("Removes all elements") {
StaticJsonDocument<64> doc;
DynamicJsonDocument doc(64);
JsonArray array = doc.to<JsonArray>();
array.add(1);
array.add(2);

12
extras/tests/JsonArray/compare.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
TEST_CASE("Compare JsonArray with JsonArray") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with unbound") {
JsonArray array = doc.to<JsonArray>();
@ -82,7 +82,7 @@ TEST_CASE("Compare JsonArray with JsonArray") {
}
TEST_CASE("Compare JsonArray with JsonVariant") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with self") {
JsonArray array = doc.to<JsonArray>();
@ -153,7 +153,7 @@ TEST_CASE("Compare JsonArray with JsonVariant") {
}
TEST_CASE("Compare JsonArray with JsonVariantConst") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with unbound") {
JsonArray array = doc.to<JsonArray>();
@ -247,7 +247,7 @@ TEST_CASE("Compare JsonArray with JsonVariantConst") {
}
TEST_CASE("Compare JsonArray with JsonArrayConst") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with unbound") {
JsonArray array = doc.to<JsonArray>();
@ -347,7 +347,7 @@ TEST_CASE("Compare JsonArray with JsonArrayConst") {
}
TEST_CASE("Compare JsonArrayConst with JsonArrayConst") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with unbound") {
JsonArray array = doc.to<JsonArray>();
@ -430,7 +430,7 @@ TEST_CASE("Compare JsonArrayConst with JsonArrayConst") {
}
TEST_CASE("Compare JsonArrayConst with JsonVariant") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
SECTION("Compare with self") {
JsonArray array = doc.to<JsonArray>();

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

@ -108,7 +108,7 @@ TEST_CASE("copyArray()") {
SECTION("int[] -> JsonArray, but not enough memory") {
const size_t SIZE = JSON_ARRAY_SIZE(2);
StaticJsonDocument<SIZE> doc;
DynamicJsonDocument doc(SIZE);
JsonArray array = doc.to<JsonArray>();
char json[32];
int source[] = {1, 2, 3};
@ -160,7 +160,7 @@ TEST_CASE("copyArray()") {
SECTION("int[][] -> JsonArray, but not enough memory") {
const size_t SIZE =
JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
StaticJsonDocument<SIZE> doc;
DynamicJsonDocument doc(SIZE);
JsonArray array = doc.to<JsonArray>();
char json[32] = "";
int source[][3] = {{1, 2, 3}, {4, 5, 6}};

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

@ -7,7 +7,7 @@
template <typename TArray>
static void run_iterator_test() {
StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(2));
JsonArray tmp = doc.to<JsonArray>();
tmp.add(12);
tmp.add(34);

2
extras/tests/JsonDeserializer/CMakeLists.txt
View File

@ -4,7 +4,6 @@
add_executable(JsonDeserializerTests
array.cpp
array_static.cpp
DeserializationError.cpp
filter.cpp
incomplete_input.cpp
@ -14,7 +13,6 @@ add_executable(JsonDeserializerTests
nestingLimit.cpp
number.cpp
object.cpp
object_static.cpp
string.cpp
)

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

@ -251,3 +251,86 @@ TEST_CASE("deserialize JSON array") {
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
}
TEST_CASE("deserialize JSON array under memory constraints") {
SECTION("buffer of the right size for an empty array") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(0));
char input[] = "[]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("buffer too small for an array with one element") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(0));
char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("buffer of the right size for an array with one element") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("buffer too small for an array with a nested object") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(0) + JSON_OBJECT_SIZE(0));
char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("buffer of the right size for an array with a nested object") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0));
char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("don't store space characters") {
DynamicJsonDocument doc(100);
deserializeJson(doc, " [ \"1234567\" ] ");
REQUIRE(JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(7) == doc.memoryUsage());
// note: we use a string of 8 bytes to be sure that the MemoryPool
// will not insert bytes to enforce alignement
}
SECTION("Should clear the JsonArray") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(4));
char input[] = "[1,2,3,4]";
deserializeJson(doc, input);
deserializeJson(doc, "[]");
JsonArray arr = doc.as<JsonArray>();
REQUIRE(arr.size() == 0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
SECTION("buffer of the right size for an array with two element") {
DynamicJsonDocument doc(JSON_ARRAY_SIZE(2));
char input[] = "[1,2]";
DeserializationError err = deserializeJson(doc, input);
JsonArray arr = doc.as<JsonArray>();
REQUIRE(err == DeserializationError::Ok);
REQUIRE(doc.is<JsonArray>());
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
REQUIRE(arr[0] == 1);
REQUIRE(arr[1] == 2);
}
}

89
extras/tests/JsonDeserializer/array_static.cpp
View File

@ -1,89 +0,0 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserialize JSON array with a StaticJsonDocument") {
SECTION("BufferOfTheRightSizeForEmptyArray") {
StaticJsonDocument<JSON_ARRAY_SIZE(0)> doc;
char input[] = "[]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("TooSmallBufferForArrayWithOneValue") {
StaticJsonDocument<JSON_ARRAY_SIZE(0)> doc;
char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("BufferOfTheRightSizeForArrayWithOneValue") {
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
char input[] = "[1]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("TooSmallBufferForArrayWithNestedObject") {
StaticJsonDocument<JSON_ARRAY_SIZE(0) + JSON_OBJECT_SIZE(0)> doc;
char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("BufferOfTheRightSizeForArrayWithNestedObject") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)> doc;
char input[] = "[{}]";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("CopyStringNotSpaces") {
StaticJsonDocument<100> doc;
deserializeJson(doc, " [ \"1234567\" ] ");
REQUIRE(JSON_ARRAY_SIZE(1) + JSON_STRING_SIZE(7) == doc.memoryUsage());
// note: we use a string of 8 bytes to be sure that the StaticMemoryPool
// will not insert bytes to enforce alignement
}
SECTION("Should clear the JsonArray") {
StaticJsonDocument<JSON_ARRAY_SIZE(4)> doc;
char input[] = "[1,2,3,4]";
deserializeJson(doc, input);
deserializeJson(doc, "[]");
JsonArray arr = doc.as<JsonArray>();
REQUIRE(arr.size() == 0);
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
SECTION("Array") {
StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
char input[] = "[1,2]";
DeserializationError err = deserializeJson(doc, input);
JsonArray arr = doc.as<JsonArray>();
REQUIRE(err == DeserializationError::Ok);
REQUIRE(doc.is<JsonArray>());
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
REQUIRE(arr[0] == 1);
REQUIRE(arr[1] == 2);
}
}

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

@ -706,10 +706,10 @@ TEST_CASE("Filtering") {
TEST_CASE("Zero-copy mode") { // issue #1697
char input[] = "{\"include\":42,\"exclude\":666}";
StaticJsonDocument<256> filter;
DynamicJsonDocument filter(256);
filter["include"] = true;
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
DeserializationError err =
deserializeJson(doc, input, DeserializationOption::Filter(filter));
@ -718,8 +718,8 @@ TEST_CASE("Zero-copy mode") { // issue #1697
}
TEST_CASE("Overloads") {
StaticJsonDocument<256> doc;
StaticJsonDocument<256> filter;
DynamicJsonDocument doc(256);
DynamicJsonDocument filter(256);
using namespace DeserializationOption;

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

@ -10,7 +10,7 @@
#include "CustomReader.hpp"
TEST_CASE("deserializeJson(char*)") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
SECTION("should not duplicate strings") {
char input[] = "{\"hello\":\"world\"}";
@ -125,7 +125,7 @@ TEST_CASE("deserializeJson(VLA)") {
char vla[i];
strcpy(vla, "{\"a\":42}");
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1));
DeserializationError err = deserializeJson(doc, vla);
REQUIRE(err == DeserializationError::Ok);

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

@ -313,3 +313,61 @@ TEST_CASE("deserialize JSON object") {
CHECK(doc.as<std::string>() == json);
}
}
TEST_CASE("deserialize JSON object under memory constraints") {
SECTION("buffer for the right size for an empty object") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(0));
char input[] = "{}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("buffer too small for an empty object") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(0));
char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("buffer of the right size for an object with one member") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1));
char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("buffer too small for an object with a nested array") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(0) + JSON_ARRAY_SIZE(0));
char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("buffer of the right size for an object with a nested array") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0));
char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("Should clear the JsonObject") {
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1));
char input[] = "{\"hello\":\"world\"}";
deserializeJson(doc, input);
deserializeJson(doc, "{}");
REQUIRE(doc.as<JsonObject>().size() == 0);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

64
extras/tests/JsonDeserializer/object_static.cpp
View File

@ -1,64 +0,0 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserialize JSON object with StaticJsonDocument") {
SECTION("BufferOfTheRightSizeForEmptyObject") {
StaticJsonDocument<JSON_OBJECT_SIZE(0)> doc;
char input[] = "{}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("TooSmallBufferForObjectWithOneValue") {
StaticJsonDocument<JSON_OBJECT_SIZE(0)> doc;
char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("BufferOfTheRightSizeForObjectWithOneValue") {
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
char input[] = "{\"a\":1}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("TooSmallBufferForObjectWithNestedObject") {
StaticJsonDocument<JSON_OBJECT_SIZE(0) + JSON_ARRAY_SIZE(0)> doc;
char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::NoMemory);
}
SECTION("BufferOfTheRightSizeForObjectWithNestedObject") {
StaticJsonDocument<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)> doc;
char input[] = "{\"a\":[]}";
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
}
SECTION("Should clear the JsonObject") {
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
char input[] = "{\"hello\":\"world\"}";
deserializeJson(doc, input);
deserializeJson(doc, "{}");
REQUIRE(doc.as<JsonObject>().size() == 0);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

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

@ -47,7 +47,7 @@ TEST_CASE("Valid JSON strings value") {
}
TEST_CASE("\\u0000") {
StaticJsonDocument<200> doc;
DynamicJsonDocument doc(200);
DeserializationError err = deserializeJson(doc, "\"wx\\u0000yz\"");
REQUIRE(err == DeserializationError::Ok);

1
extras/tests/JsonDocument/CMakeLists.txt
View File

@ -19,7 +19,6 @@ add_executable(JsonDocumentTests
remove.cpp
shrinkToFit.cpp
size.cpp
StaticJsonDocument.cpp
subscript.cpp
swap.cpp
)

37
extras/tests/JsonDocument/DynamicJsonDocument.cpp
View File

@ -94,18 +94,8 @@ TEST_CASE("DynamicJsonDocument constructor") {
REQUIRE(doc2.capacity() == doc1.capacity());
}
SECTION("Construct from StaticJsonDocument") {
StaticJsonDocument<200> doc1;
deserializeJson(doc1, "{\"hello\":\"world\"}");
DynamicJsonDocument doc2 = doc1;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
REQUIRE(doc2.capacity() == doc1.capacity());
}
SECTION("Construct from JsonObject") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
JsonObject obj = doc1.to<JsonObject>();
obj["hello"] = "world";
@ -116,7 +106,7 @@ TEST_CASE("DynamicJsonDocument constructor") {
}
SECTION("Construct from JsonArray") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
JsonArray arr = doc1.to<JsonArray>();
arr.add("hello");
@ -127,7 +117,7 @@ TEST_CASE("DynamicJsonDocument constructor") {
}
SECTION("Construct from JsonVariant") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
deserializeJson(doc1, "42");
DynamicJsonDocument doc2 = doc1.as<JsonVariant>();
@ -160,19 +150,8 @@ TEST_CASE("DynamicJsonDocument assignment") {
REQUIRE(doc2.capacity() == doc1.capacity());
}
SECTION("Assign from StaticJsonDocument") {
StaticJsonDocument<200> doc1;
deserializeJson(doc1, "{\"hello\":\"world\"}");
DynamicJsonDocument doc2(4096);
doc2.to<JsonVariant>().set(666);
doc2 = doc1;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from JsonObject") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
JsonObject obj = doc1.to<JsonObject>();
obj["hello"] = "world";
@ -184,7 +163,7 @@ TEST_CASE("DynamicJsonDocument assignment") {
}
SECTION("Assign from JsonArray") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
JsonArray arr = doc1.to<JsonArray>();
arr.add("hello");
@ -196,7 +175,7 @@ TEST_CASE("DynamicJsonDocument assignment") {
}
SECTION("Assign from JsonVariant") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
deserializeJson(doc1, "42");
DynamicJsonDocument doc2(4096);
@ -207,7 +186,7 @@ TEST_CASE("DynamicJsonDocument assignment") {
}
SECTION("Assign from MemberProxy") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
doc1["value"] = 42;
DynamicJsonDocument doc2(4096);
@ -218,7 +197,7 @@ TEST_CASE("DynamicJsonDocument assignment") {
}
SECTION("Assign from ElementProxy") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc1(200);
doc1[0] = 42;
DynamicJsonDocument doc2(4096);

2
extras/tests/JsonDocument/ElementProxy.cpp
View File

@ -247,7 +247,7 @@ TEST_CASE("ElementProxy cast to JsonVariant") {
}
TEST_CASE("ElementProxy::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
DynamicJsonDocument doc1(1024), doc2(1024);
doc2["hello"] = "world";
doc1[0].shallowCopy(doc2);

12
extras/tests/JsonDocument/MemberProxy.cpp
View File

@ -127,7 +127,7 @@ TEST_CASE("MemberProxy::operator|()") {
JsonObject object = doc.to<JsonObject>();
object["hello"] = "world";
StaticJsonDocument<0> emptyDoc;
DynamicJsonDocument emptyDoc(0);
JsonObject anotherObject = object["hello"] | emptyDoc.to<JsonObject>();
REQUIRE(anotherObject.isNull() == false);
@ -288,7 +288,7 @@ TEST_CASE("MemberProxy cast to JsonVariant") {
}
TEST_CASE("MemberProxy::createNestedArray()") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
JsonArray arr = doc["items"].createNestedArray();
arr.add(42);
@ -296,7 +296,7 @@ TEST_CASE("MemberProxy::createNestedArray()") {
}
TEST_CASE("MemberProxy::createNestedArray(key)") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
JsonArray arr = doc["weather"].createNestedArray("temp");
arr.add(42);
@ -304,7 +304,7 @@ TEST_CASE("MemberProxy::createNestedArray(key)") {
}
TEST_CASE("MemberProxy::createNestedObject()") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
JsonObject obj = doc["items"].createNestedObject();
obj["value"] = 42;
@ -312,7 +312,7 @@ TEST_CASE("MemberProxy::createNestedObject()") {
}
TEST_CASE("MemberProxy::createNestedObject(key)") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
JsonObject obj = doc["status"].createNestedObject("weather");
obj["temp"] = 42;
@ -320,7 +320,7 @@ TEST_CASE("MemberProxy::createNestedObject(key)") {
}
TEST_CASE("MemberProxy::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
DynamicJsonDocument doc1(1024), doc2(1024);
doc2["hello"] = "world";
doc1["obj"].shallowCopy(doc2);

224
extras/tests/JsonDocument/StaticJsonDocument.cpp
View File

@ -1,224 +0,0 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
static void REQUIRE_JSON(JsonDocument& doc, const std::string& expected) {
std::string json;
serializeJson(doc, json);
REQUIRE(json == expected);
}
TEST_CASE("StaticJsonDocument") {
SECTION("capacity()") {
SECTION("matches template argument") {
StaticJsonDocument<256> doc;
REQUIRE(doc.capacity() == 256);
}
SECTION("rounds up template argument") {
StaticJsonDocument<253> doc;
REQUIRE(doc.capacity() == 256);
}
}
SECTION("serializeJson()") {
StaticJsonDocument<200> doc;
JsonObject obj = doc.to<JsonObject>();
obj["hello"] = "world";
std::string json;
serializeJson(doc, json);
REQUIRE(json == "{\"hello\":\"world\"}");
}
SECTION("Copy assignment") {
StaticJsonDocument<200> doc1, doc2;
doc1.to<JsonVariant>().set(666);
deserializeJson(doc2, "{\"hello\":\"world\"}");
doc1 = doc2;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Contructor") {
SECTION("Copy constructor") {
StaticJsonDocument<200> doc1;
deserializeJson(doc1, "{\"hello\":\"world\"}");
StaticJsonDocument<200> doc2 = doc1;
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Construct from StaticJsonDocument of different size") {
StaticJsonDocument<300> doc1;
deserializeJson(doc1, "{\"hello\":\"world\"}");
StaticJsonDocument<200> doc2 = doc1;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Construct from DynamicJsonDocument") {
DynamicJsonDocument doc1(4096);
deserializeJson(doc1, "{\"hello\":\"world\"}");
StaticJsonDocument<200> doc2 = doc1;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Construct from JsonObject") {
DynamicJsonDocument doc1(4096);
deserializeJson(doc1, "{\"hello\":\"world\"}");
StaticJsonDocument<200> doc2 = doc1.as<JsonObject>();
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Construct from JsonArray") {
DynamicJsonDocument doc1(4096);
deserializeJson(doc1, "[\"hello\",\"world\"]");
StaticJsonDocument<200> doc2 = doc1.as<JsonArray>();
deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
}
SECTION("Construct from JsonVariant") {
DynamicJsonDocument doc1(4096);
deserializeJson(doc1, "42");
StaticJsonDocument<200> doc2 = doc1.as<JsonVariant>();
REQUIRE_JSON(doc2, "42");
}
}
SECTION("Assignment") {
SECTION("Copy assignment") {
StaticJsonDocument<200> doc1, doc2;
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "{\"hello\":\"world\"}");
doc2 = doc1;
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from StaticJsonDocument of different capacity") {
StaticJsonDocument<200> doc1;
StaticJsonDocument<300> doc2;
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "{\"hello\":\"world\"}");
doc2 = doc1;
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from DynamicJsonDocument") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc2(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "{\"hello\":\"world\"}");
doc2 = doc1;
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from JsonArray") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc2(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "[\"hello\",\"world\"]");
doc2 = doc1.as<JsonArray>();
deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
}
SECTION("Assign from JsonArrayConst") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc2(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "[\"hello\",\"world\"]");
doc2 = doc1.as<JsonArrayConst>();
deserializeJson(doc1, "[\"HELLO\",\"WORLD\"]");
REQUIRE_JSON(doc2, "[\"hello\",\"world\"]");
}
SECTION("Assign from JsonObject") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc2(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "{\"hello\":\"world\"}");
doc2 = doc1.as<JsonObject>();
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from JsonObjectConst") {
StaticJsonDocument<200> doc1;
DynamicJsonDocument doc2(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "{\"hello\":\"world\"}");
doc2 = doc1.as<JsonObjectConst>();
deserializeJson(doc1, "{\"HELLO\":\"WORLD\"}");
REQUIRE_JSON(doc2, "{\"hello\":\"world\"}");
}
SECTION("Assign from JsonVariant") {
DynamicJsonDocument doc1(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "42");
StaticJsonDocument<200> doc2;
doc2 = doc1.as<JsonVariant>();
REQUIRE_JSON(doc2, "42");
}
SECTION("Assign from JsonVariantConst") {
DynamicJsonDocument doc1(4096);
doc1.to<JsonVariant>().set(666);
deserializeJson(doc1, "42");
StaticJsonDocument<200> doc2;
doc2 = doc1.as<JsonVariantConst>();
REQUIRE_JSON(doc2, "42");
}
}
SECTION("garbageCollect()") {
StaticJsonDocument<256> doc;
doc[std::string("example")] = std::string("jukebox");
doc.remove("example");
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(1) + 16);
doc.garbageCollect();
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
REQUIRE_JSON(doc, "{}");
}
}

2
extras/tests/JsonDocument/cast.cpp
View File

@ -8,7 +8,7 @@
#include <string>
TEST_CASE("Implicit cast to JsonVariant") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc["hello"] = "world";

52
extras/tests/JsonDocument/compare.cpp
View File

@ -28,57 +28,9 @@ TEST_CASE("DynamicJsonDocument::operator==(const DynamicJsonDocument&)") {
}
}
TEST_CASE("DynamicJsonDocument::operator==(const StaticJsonDocument&)") {
DynamicJsonDocument doc1(4096);
StaticJsonDocument<256> doc2;
SECTION("Empty") {
REQUIRE(doc1 == doc2);
REQUIRE_FALSE(doc1 != doc2);
}
SECTION("With same object") {
doc1["hello"] = "world";
doc2["hello"] = "world";
REQUIRE(doc1 == doc2);
REQUIRE_FALSE(doc1 != doc2);
}
SECTION("With different object") {
doc1["hello"] = "world";
doc2["world"] = "hello";
REQUIRE_FALSE(doc1 == doc2);
REQUIRE(doc1 != doc2);
}
}
TEST_CASE("StaticJsonDocument::operator==(const DynamicJsonDocument&)") {
StaticJsonDocument<256> doc1;
DynamicJsonDocument doc2(4096);
SECTION("Empty") {
REQUIRE(doc1 == doc2);
REQUIRE_FALSE(doc1 != doc2);
}
SECTION("With same object") {
doc1["hello"] = "world";
doc2["hello"] = "world";
REQUIRE(doc1 == doc2);
REQUIRE_FALSE(doc1 != doc2);
}
SECTION("With different object") {
doc1["hello"] = "world";
doc2["world"] = "hello";
REQUIRE_FALSE(doc1 == doc2);
REQUIRE(doc1 != doc2);
}
}
TEST_CASE("JsonDocument::operator==(const JsonDocument&)") {
StaticJsonDocument<256> doc1;
StaticJsonDocument<256> doc2;
DynamicJsonDocument doc1(256);
DynamicJsonDocument doc2(256);
const JsonDocument& ref1 = doc1;
const JsonDocument& ref2 = doc2;

2
extras/tests/JsonDocument/issue1120.cpp
View File

@ -3,7 +3,7 @@
#include <catch.hpp>
TEST_CASE("Issue #1120") {
StaticJsonDocument<500> doc;
DynamicJsonDocument doc(500);
constexpr char str[] =
"{\"contents\":[{\"module\":\"Packet\"},{\"module\":\"Analog\"}]}";
deserializeJson(doc, str);

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

@ -7,54 +7,54 @@
TEST_CASE("JsonDocument::overflowed()") {
SECTION("returns false on a fresh object") {
StaticJsonDocument<0> doc;
DynamicJsonDocument doc(0);
CHECK(doc.overflowed() == false);
}
SECTION("returns true after a failed insertion") {
StaticJsonDocument<0> doc;
DynamicJsonDocument doc(0);
doc.add(0);
CHECK(doc.overflowed() == true);
}
SECTION("returns false after successful insertion") {
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
doc.add(0);
CHECK(doc.overflowed() == false);
}
SECTION("returns true after a failed string copy") {
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
doc.add(std::string("example"));
CHECK(doc.overflowed() == true);
}
SECTION("returns false after a successful string copy") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) + 8> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1) + 8);
doc.add(std::string("example"));
CHECK(doc.overflowed() == false);
}
SECTION("returns true after a failed member add") {
StaticJsonDocument<1> doc;
DynamicJsonDocument doc(1);
doc["example"] = true;
CHECK(doc.overflowed() == true);
}
SECTION("returns true after a failed deserialization") {
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1));
deserializeJson(doc, "[\"example\"]");
CHECK(doc.overflowed() == true);
}
SECTION("returns false after a successful deserialization") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) + 8> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(1) + 8);
deserializeJson(doc, "[\"example\"]");
CHECK(doc.overflowed() == false);
}
SECTION("returns false after clear()") {
StaticJsonDocument<0> doc;
DynamicJsonDocument doc(0);
doc.add(0);
doc.clear();
CHECK(doc.overflowed() == false);

2
extras/tests/JsonObject/clear.cpp
View File

@ -14,7 +14,7 @@ TEST_CASE("JsonObject::clear()") {
}
SECTION("Removes all elements") {
StaticJsonDocument<64> doc;
DynamicJsonDocument doc(64);
JsonObject obj = doc.to<JsonObject>();
obj["hello"] = 1;
obj["world"] = 2;

12
extras/tests/JsonObject/compare.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
TEST_CASE("Compare JsonObject with JsonObject") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with unbound") {
JsonObject object = doc.to<JsonObject>();
@ -82,7 +82,7 @@ TEST_CASE("Compare JsonObject with JsonObject") {
}
TEST_CASE("Compare JsonObject with JsonVariant") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with self") {
JsonObject object = doc.to<JsonObject>();
@ -153,7 +153,7 @@ TEST_CASE("Compare JsonObject with JsonVariant") {
}
TEST_CASE("Compare JsonObject with JsonVariantConst") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with unbound") {
JsonObject object = doc.to<JsonObject>();
@ -247,7 +247,7 @@ TEST_CASE("Compare JsonObject with JsonVariantConst") {
}
TEST_CASE("Compare JsonObject with JsonObjectConst") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with unbound") {
JsonObject object = doc.to<JsonObject>();
@ -347,7 +347,7 @@ TEST_CASE("Compare JsonObject with JsonObjectConst") {
}
TEST_CASE("Compare JsonObjectConst with JsonObjectConst") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with unbound") {
JsonObject object = doc.to<JsonObject>();
@ -430,7 +430,7 @@ TEST_CASE("Compare JsonObjectConst with JsonObjectConst") {
}
TEST_CASE("Compare JsonObjectConst with JsonVariant") {
StaticJsonDocument<512> doc;
DynamicJsonDocument doc(512);
SECTION("Compare with self") {
JsonObject object = doc.to<JsonObject>();

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

@ -72,7 +72,7 @@ TEST_CASE("JsonObject::set()") {
}
SECTION("destination too small to store the key") {
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc3;
DynamicJsonDocument doc3(JSON_OBJECT_SIZE(1));
JsonObject obj3 = doc3.to<JsonObject>();
obj1[std::string("hello")] = "world";
@ -84,7 +84,7 @@ TEST_CASE("JsonObject::set()") {
}
SECTION("destination too small to store the value") {
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc3;
DynamicJsonDocument doc3(JSON_OBJECT_SIZE(1));
JsonObject obj3 = doc3.to<JsonObject>();
obj1["hello"] = std::string("world");

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

@ -8,7 +8,7 @@
using namespace Catch::Matchers;
TEST_CASE("JsonObject::begin()/end()") {
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
JsonObject obj = doc.to<JsonObject>();
obj["ab"] = 12;
obj["cd"] = 34;
@ -38,7 +38,7 @@ TEST_CASE("JsonObject::begin()/end()") {
}
TEST_CASE("JsonObjectConst::begin()/end()") {
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
JsonObject obj = doc.to<JsonObject>();
obj["ab"] = 12;
obj["cd"] = 34;

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

@ -15,7 +15,7 @@ static void check(JsonArray array, std::string expected) {
}
TEST_CASE("serializeJson(JsonArray)") {
StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_ARRAY_SIZE(2));
JsonArray array = doc.to<JsonArray>();
SECTION("Empty") {

2
extras/tests/JsonSerializer/std_string.cpp
View File

@ -47,7 +47,7 @@ TEST_CASE("serialize JsonObject to std::string") {
}
TEST_CASE("serialize an std::string containing a NUL") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
doc.set(std::string("hello\0world", 11));
CHECK(doc.memoryUsage() == 12);

4
extras/tests/JsonVariant/compare.cpp
View File

@ -9,7 +9,7 @@
// Here, we're just filling the holes
TEST_CASE("Compare JsonVariant with value") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
JsonVariant a = doc.add();
SECTION("null vs (char*)0") {
@ -37,7 +37,7 @@ TEST_CASE("Compare JsonVariant with value") {
}
TEST_CASE("Compare JsonVariant with JsonVariant") {
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
JsonVariant a = doc.add();
JsonVariant b = doc.add();

4
extras/tests/JsonVariant/isnull.cpp
View File

@ -71,13 +71,13 @@ TEST_CASE("JsonVariant::isNull()") {
}
SECTION("returns true for a shallow null copy") {
StaticJsonDocument<128> doc2;
DynamicJsonDocument doc2(128);
variant.shallowCopy(doc2);
CHECK(variant.isNull() == true);
}
SECTION("returns false for a shallow array copy") {
StaticJsonDocument<128> doc2;
DynamicJsonDocument doc2(128);
doc2[0] = 42;
variant.shallowCopy(doc2);
CHECK(variant.isNull() == false);

4
extras/tests/JsonVariant/overflow.cpp
View File

@ -7,7 +7,7 @@
template <typename TOut, typename TIn>
void shouldBeOk(TIn value) {
StaticJsonDocument<1> doc;
DynamicJsonDocument doc(1);
JsonVariant var = doc.to<JsonVariant>();
var.set(value);
REQUIRE(var.as<TOut>() == TOut(value));
@ -15,7 +15,7 @@ void shouldBeOk(TIn value) {
template <typename TOut, typename TIn>
void shouldOverflow(TIn value) {
StaticJsonDocument<1> doc;
DynamicJsonDocument doc(1);
JsonVariant var = doc.to<JsonVariant>();
var.set(value);
REQUIRE(var.as<TOut>() == 0);

2
extras/tests/JsonVariant/set.cpp
View File

@ -128,7 +128,7 @@ TEST_CASE("JsonVariant::set() when there is enough memory") {
}
TEST_CASE("JsonVariant::set() with not enough memory") {
StaticJsonDocument<1> doc;
DynamicJsonDocument doc(1);
JsonVariant v = doc.to<JsonVariant>();

2
extras/tests/JsonVariant/shallowCopy.cpp
View File

@ -6,7 +6,7 @@
#include <catch.hpp>
TEST_CASE("JsonVariant::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
DynamicJsonDocument doc1(1024), doc2(1024);
JsonVariant variant = doc1.to<JsonVariant>();
SECTION("JsonVariant::shallowCopy(JsonDocument&)") {

12
extras/tests/JsonVariant/stl_containers.cpp
View File

@ -69,13 +69,13 @@ TEST_CASE("vector<int>") {
SECTION("toJson") {
std::vector<int> v = {1, 2};
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc.set(v);
REQUIRE(doc.as<std::string>() == "[1,2]");
}
SECTION("fromJson") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc.add(1);
doc.add(2);
@ -86,7 +86,7 @@ TEST_CASE("vector<int>") {
}
SECTION("checkJson") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
CHECK(doc.is<std::vector<int>>() == false);
doc.add(1);
@ -106,13 +106,13 @@ TEST_CASE("array<int, 2>") {
v[0] = 1;
v[1] = 2;
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc.set(v);
REQUIRE(doc.as<std::string>() == "[1,2]");
}
SECTION("fromJson") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc.add(1);
doc.add(2);
@ -123,7 +123,7 @@ TEST_CASE("array<int, 2>") {
}
SECTION("checkJson") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
CHECK(doc.is<array_type>() == false);
doc.add(1);

2
extras/tests/Misc/StringWriter.cpp
View File

@ -136,7 +136,7 @@ TEST_CASE("Writer<custom_string>") {
}
TEST_CASE("serializeJson(doc, String)") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
doc["hello"] = "world";
::String output;

2
extras/tests/Misc/TypeTraits.cpp
View File

@ -194,8 +194,6 @@ TEST_CASE("Polyfills/type_traits") {
JsonVariantConst>::value == true);
CHECK(is_convertible<JsonObjectConst, JsonVariantConst>::value == true);
CHECK(is_convertible<DynamicJsonDocument, JsonVariantConst>::value == true);
CHECK(is_convertible<StaticJsonDocument<10>, JsonVariantConst>::value ==
true);
}
SECTION("is_class") {

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

@ -48,7 +48,7 @@ struct PrintableString : public Printable {
TEST_CASE("Printable") {
SECTION("Doesn't overflow") {
StaticJsonDocument<8> doc;
DynamicJsonDocument doc(8);
const char* value = "example"; // == 7 chars
doc.set(666); // to make sure we override the value
@ -75,7 +75,7 @@ TEST_CASE("Printable") {
}
SECTION("Overflows early") {
StaticJsonDocument<8> doc;
DynamicJsonDocument doc(8);
const char* value = "hello world"; // > 8 chars
doc.set(666); // to make sure we override the value
@ -100,7 +100,7 @@ TEST_CASE("Printable") {
}
SECTION("Overflows adding terminator") {
StaticJsonDocument<8> doc;
DynamicJsonDocument doc(8);
const char* value = "overflow"; // == 8 chars
doc.set(666); // to make sure we override the value
@ -133,7 +133,7 @@ TEST_CASE("Printable") {
}
SECTION("String deduplication") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
doc.add(PrintableString<PrintOneCharacterAtATime>("Hello World!"));
doc.add(PrintableString<PrintAllAtOnce>("Hello World!"));
REQUIRE(doc.size() == 2);

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

@ -13,7 +13,7 @@ TEST_CASE("unsigned char[]") {
SECTION("deserializeJson()") {
unsigned char input[] = "{\"a\":42}";
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1));
DeserializationError err = deserializeJson(doc, input);
REQUIRE(err == DeserializationError::Ok);
@ -22,7 +22,7 @@ TEST_CASE("unsigned char[]") {
SECTION("deserializeMsgPack()") {
unsigned char input[] = "\xDE\x00\x01\xA5Hello\xA5world";
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
DeserializationError err = deserializeMsgPack(doc, input);
REQUIRE(err == DeserializationError::Ok);
@ -30,7 +30,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeMsgPack(unsigned char[])") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeMsgPack(doc, buffer);
@ -41,7 +41,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeMsgPack(unsigned char*)") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeMsgPack(doc, buffer, sizeof(buffer));
@ -52,7 +52,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJson(unsigned char[])") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeJson(doc, buffer);
@ -63,7 +63,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJson(unsigned char*)") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeJson(doc, buffer, sizeof(buffer));
@ -74,7 +74,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJsonPretty(unsigned char[])") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeJsonPretty(doc, buffer);
@ -84,7 +84,7 @@ TEST_CASE("unsigned char[]") {
SECTION("serializeJsonPretty(unsigned char*)") {
unsigned char buffer[32];
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(2));
doc["hello"] = "world";
size_t n = serializeJsonPretty(doc, buffer, sizeof(buffer));

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

@ -12,7 +12,7 @@
#include <catch.hpp>
TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 0") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
SECTION("deserializeJson()") {
SECTION("Deduplicate values") {

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

@ -12,7 +12,7 @@
#include <catch.hpp>
TEST_CASE("ARDUINOJSON_ENABLE_STRING_DEDUPLICATION = 1") {
StaticJsonDocument<1024> doc;
DynamicJsonDocument doc(1024);
SECTION("deserializeJson()") {
SECTION("Deduplicate values") {

2
extras/tests/MixedConfiguration/issue1707.cpp
View File

@ -12,7 +12,7 @@
#include <catch.hpp>
TEST_CASE("Issue1707") {
StaticJsonDocument<128> doc;
DynamicJsonDocument doc(128);
DeserializationError err = deserializeJson(doc, F("{\"hello\":12}"));
REQUIRE(err == DeserializationError::Ok);

1
extras/tests/MsgPackDeserializer/CMakeLists.txt
View File

@ -5,7 +5,6 @@
add_executable(MsgPackDeserializerTests
deserializeArray.cpp
deserializeObject.cpp
deserializeStaticVariant.cpp
deserializeVariant.cpp
doubleToFloat.cpp
filter.cpp

152
extras/tests/MsgPackDeserializer/deserializeStaticVariant.cpp
View File

@ -1,152 +0,0 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2023, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
template <size_t Capacity>
static void check(const char* input, DeserializationError expected) {
StaticJsonDocument<Capacity> doc;
DeserializationError error = deserializeMsgPack(doc, input);
CAPTURE(input);
REQUIRE(error == expected);
}
template <size_t Size>
static void checkString(const char* input, DeserializationError expected) {
check<Size>(input, expected);
}
TEST_CASE("deserializeMsgPack(StaticJsonDocument&)") {
SECTION("single values always fit") {
check<0>("\xc0", DeserializationError::Ok); // nil
check<0>("\xc2", DeserializationError::Ok); // false
check<0>("\xc3", DeserializationError::Ok); // true
check<0>("\xcc\x00", DeserializationError::Ok); // uint 8
check<0>("\xcd\x30\x39", DeserializationError::Ok); // uint 16
check<0>("\xCE\x12\x34\x56\x78", DeserializationError::Ok); // uint 32
}
SECTION("fixstr") {
checkString<8>("\xA0", DeserializationError::Ok);
checkString<8>("\xA7ZZZZZZZ", DeserializationError::Ok);
checkString<8>("\xA8ZZZZZZZZ", DeserializationError::NoMemory);
checkString<16>("\xAFZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkString<16>("\xB0ZZZZZZZZZZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 8") {
checkString<8>("\xD9\x00", DeserializationError::Ok);
checkString<8>("\xD9\x07ZZZZZZZ", DeserializationError::Ok);
checkString<8>("\xD9\x08ZZZZZZZZ", DeserializationError::NoMemory);
checkString<16>("\xD9\x0FZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkString<16>("\xD9\x10ZZZZZZZZZZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 16") {
checkString<8>("\xDA\x00\x00", DeserializationError::Ok);
checkString<8>("\xDA\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkString<8>("\xDA\x00\x08ZZZZZZZZ", DeserializationError::NoMemory);
checkString<16>("\xDA\x00\x0FZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkString<16>("\xDA\x00\x10ZZZZZZZZZZZZZZZZ",
DeserializationError::NoMemory);
}
SECTION("str 32") {
checkString<8>("\xDB\x00\x00\x00\x00", DeserializationError::Ok);
checkString<8>("\xDB\x00\x00\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkString<8>("\xDB\x00\x00\x00\x08ZZZZZZZZ",
DeserializationError::NoMemory);
checkString<16>("\xDB\x00\x00\x00\x0FZZZZZZZZZZZZZZZ",
DeserializationError::Ok);
checkString<16>("\xDB\x00\x00\x00\x10ZZZZZZZZZZZZZZZZ",
DeserializationError::NoMemory);
}
SECTION("fixarray") {
check<JSON_ARRAY_SIZE(0)>("\x90", DeserializationError::Ok); // []
check<JSON_ARRAY_SIZE(0)>("\x91\x01",
DeserializationError::NoMemory); // [1]
check<JSON_ARRAY_SIZE(1)>("\x91\x01", DeserializationError::Ok); // [1]
check<JSON_ARRAY_SIZE(1)>("\x92\x01\x02",
DeserializationError::NoMemory); // [1,2]
}
SECTION("array 16") {
check<JSON_ARRAY_SIZE(0)>("\xDC\x00\x00", DeserializationError::Ok);
check<JSON_ARRAY_SIZE(0)>("\xDC\x00\x01\x01",
DeserializationError::NoMemory);
check<JSON_ARRAY_SIZE(1)>("\xDC\x00\x01\x01", DeserializationError::Ok);
check<JSON_ARRAY_SIZE(1)>("\xDC\x00\x02\x01\x02",
DeserializationError::NoMemory);
}
SECTION("array 32") {
check<JSON_ARRAY_SIZE(0)>("\xDD\x00\x00\x00\x00", DeserializationError::Ok);
check<JSON_ARRAY_SIZE(0)>("\xDD\x00\x00\x00\x01\x01",
DeserializationError::NoMemory);
check<JSON_ARRAY_SIZE(1)>("\xDD\x00\x00\x00\x01\x01",
DeserializationError::Ok);
check<JSON_ARRAY_SIZE(1)>("\xDD\x00\x00\x00\x02\x01\x02",
DeserializationError::NoMemory);
}
SECTION("fixmap") {
SECTION("{}") {
check<JSON_OBJECT_SIZE(0)>("\x80", DeserializationError::Ok);
}
SECTION("{H:1}") {
check<JSON_OBJECT_SIZE(0)>("\x81\xA1H\x01",
DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\x81\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\x82\xA1H\x01\xA1W\x02", DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * JSON_STRING_SIZE(2)>(
"\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 16") {
SECTION("{}") {
check<JSON_OBJECT_SIZE(0)>("\xDE\x00\x00", DeserializationError::Ok);
}
SECTION("{H:1}") {
check<JSON_OBJECT_SIZE(0)>("\xDE\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\xDE\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1)>(
"\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 32") {
SECTION("{}") {
check<JSON_OBJECT_SIZE(0)>("\xDF\x00\x00\x00\x00",
DeserializationError::Ok);
}
SECTION("{H:1}") {
check<JSON_OBJECT_SIZE(0)>("\xDF\x00\x00\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2)>(
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1)>(
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
}

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

@ -5,8 +5,8 @@
#include <ArduinoJson.h>
#include <catch.hpp>
template <typename T, typename U>
static void check(const char* input, U expected) {
template <typename T>
static void checkValue(const char* input, T expected) {
DynamicJsonDocument doc(4096);
DeserializationError error = deserializeMsgPack(doc, input);
@ -16,132 +16,260 @@ static void check(const char* input, U expected) {
REQUIRE(doc.as<T>() == expected);
}
#if ARDUINOJSON_USE_LONG_LONG == 0
static void checkNotSupported(const char* input) {
DynamicJsonDocument doc(4096);
DeserializationError error = deserializeMsgPack(doc, input);
REQUIRE(error == DeserializationError::Ok);
REQUIRE(doc.isNull());
}
#endif
static void checkIsNull(const char* input) {
DynamicJsonDocument doc(4096);
static void checkError(size_t capacity, const char* input,
DeserializationError expected) {
DynamicJsonDocument doc(capacity);
DeserializationError error = deserializeMsgPack(doc, input);
REQUIRE(error == DeserializationError::Ok);
REQUIRE(doc.as<JsonVariant>().isNull());
CAPTURE(input);
REQUIRE(error == expected);
}
TEST_CASE("deserialize MsgPack value") {
SECTION("nil") {
checkIsNull("\xc0");
checkValue("\xc0", nullptr);
}
SECTION("bool") {
check<bool>("\xc2", false);
check<bool>("\xc3", true);
checkValue<bool>("\xc2", false);
checkValue<bool>("\xc3", true);
}
SECTION("positive fixint") {
check<int>("\x00", 0);
check<int>("\x7F", 127);
checkValue<int>("\x00", 0);
checkValue<int>("\x7F", 127);
}
SECTION("negative fixint") {
check<int>("\xe0", -32);
check<int>("\xff", -1);
checkValue<int>("\xe0", -32);
checkValue<int>("\xff", -1);
}
SECTION("uint 8") {
check<int>("\xcc\x00", 0);
check<int>("\xcc\xff", 255);
checkValue<int>("\xcc\x00", 0);
checkValue<int>("\xcc\xff", 255);
}
SECTION("uint 16") {
check<int>("\xcd\x00\x00", 0);
check<int>("\xcd\xFF\xFF", 65535);
check<int>("\xcd\x30\x39", 12345);
checkValue<int>("\xcd\x00\x00", 0);
checkValue<int>("\xcd\xFF\xFF", 65535);
checkValue<int>("\xcd\x30\x39", 12345);
}
SECTION("uint 32") {
check<uint32_t>("\xCE\x00\x00\x00\x00", 0x00000000U);
check<uint32_t>("\xCE\xFF\xFF\xFF\xFF", 0xFFFFFFFFU);
check<uint32_t>("\xCE\x12\x34\x56\x78", 0x12345678U);
checkValue<uint32_t>("\xCE\x00\x00\x00\x00", 0x00000000U);
checkValue<uint32_t>("\xCE\xFF\xFF\xFF\xFF", 0xFFFFFFFFU);
checkValue<uint32_t>("\xCE\x12\x34\x56\x78", 0x12345678U);
}
SECTION("uint 64") {
#if ARDUINOJSON_USE_LONG_LONG
check<uint64_t>("\xCF\x00\x00\x00\x00\x00\x00\x00\x00", 0U);
check<uint64_t>("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
0xFFFFFFFFFFFFFFFFU);
check<uint64_t>("\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0",
0x123456789ABCDEF0U);
checkValue<uint64_t>("\xCF\x00\x00\x00\x00\x00\x00\x00\x00", 0U);
checkValue<uint64_t>("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
0xFFFFFFFFFFFFFFFFU);
checkValue<uint64_t>("\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0",
0x123456789ABCDEF0U);
#else
checkNotSupported("\xCF\x00\x00\x00\x00\x00\x00\x00\x00");
checkNotSupported("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
checkNotSupported("\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0");
checkValue("\xCF\x00\x00\x00\x00\x00\x00\x00\x00", nullptr);
checkValue("\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", nullptr);
checkValue("\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0", nullptr);
#endif
}
SECTION("int 8") {
check<int>("\xd0\x00", 0);
check<int>("\xd0\xff", -1);
checkValue<int>("\xd0\x00", 0);
checkValue<int>("\xd0\xff", -1);
}
SECTION("int 16") {
check<int>("\xD1\x00\x00", 0);
check<int>("\xD1\xFF\xFF", -1);
check<int>("\xD1\xCF\xC7", -12345);
checkValue<int>("\xD1\x00\x00", 0);
checkValue<int>("\xD1\xFF\xFF", -1);
checkValue<int>("\xD1\xCF\xC7", -12345);
}
SECTION("int 32") {
check<int>("\xD2\x00\x00\x00\x00", 0);
check<int>("\xD2\xFF\xFF\xFF\xFF", -1);
check<int>("\xD2\xB6\x69\xFD\x2E", -1234567890);
checkValue<int>("\xD2\x00\x00\x00\x00", 0);
checkValue<int>("\xD2\xFF\xFF\xFF\xFF", -1);
checkValue<int>("\xD2\xB6\x69\xFD\x2E", -1234567890);
}
SECTION("int 64") {
#if ARDUINOJSON_USE_LONG_LONG
check<int64_t>("\xD3\x00\x00\x00\x00\x00\x00\x00\x00", int64_t(0U));
check<int64_t>("\xD3\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
int64_t(0xFFFFFFFFFFFFFFFFU));
check<int64_t>("\xD3\x12\x34\x56\x78\x9A\xBC\xDE\xF0",
int64_t(0x123456789ABCDEF0));
checkValue<int64_t>("\xD3\x00\x00\x00\x00\x00\x00\x00\x00", int64_t(0U));
checkValue<int64_t>("\xD3\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF",
int64_t(0xFFFFFFFFFFFFFFFFU));
checkValue<int64_t>("\xD3\x12\x34\x56\x78\x9A\xBC\xDE\xF0",
int64_t(0x123456789ABCDEF0));
#else
checkNotSupported("\xD3\x00\x00\x00\x00\x00\x00\x00\x00");
checkNotSupported("\xD3\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
checkNotSupported("\xD3\x12\x34\x56\x78\x9A\xBC\xDE\xF0");
checkValue("\xD3\x00\x00\x00\x00\x00\x00\x00\x00", nullptr);
checkValue("\xD3\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF", nullptr);
checkValue("\xD3\x12\x34\x56\x78\x9A\xBC\xDE\xF0", nullptr);
#endif
}
SECTION("float 32") {
check<double>("\xCA\x00\x00\x00\x00", 0.0f);
check<double>("\xCA\x40\x48\xF5\xC3", 3.14f);
checkValue<double>("\xCA\x00\x00\x00\x00", 0.0f);
checkValue<double>("\xCA\x40\x48\xF5\xC3", 3.14f);
}
SECTION("float 64") {
check<double>("\xCB\x00\x00\x00\x00\x00\x00\x00\x00", 0.0);
check<double>("\xCB\x40\x09\x21\xCA\xC0\x83\x12\x6F", 3.1415);
checkValue<double>("\xCB\x00\x00\x00\x00\x00\x00\x00\x00", 0.0);
checkValue<double>("\xCB\x40\x09\x21\xCA\xC0\x83\x12\x6F", 3.1415);
}
SECTION("fixstr") {
check<const char*>("\xA0", std::string(""));
check<const char*>("\xABhello world", std::string("hello world"));
check<const char*>("\xBFhello world hello world hello !",
std::string("hello world hello world hello !"));
checkValue<std::string>("\xA0", std::string(""));
checkValue<std::string>("\xABhello world", std::string("hello world"));
checkValue<std::string>("\xBFhello world hello world hello !",
std::string("hello world hello world hello !"));
}
SECTION("str 8") {
check<const char*>("\xd9\x05hello", std::string("hello"));
checkValue<std::string>("\xd9\x05hello", std::string("hello"));
}
SECTION("str 16") {
check<const char*>("\xda\x00\x05hello", std::string("hello"));
checkValue<std::string>("\xda\x00\x05hello", std::string("hello"));
}
SECTION("str 32") {
check<const char*>("\xdb\x00\x00\x00\x05hello", std::string("hello"));
checkValue<std::string>("\xdb\x00\x00\x00\x05hello", std::string("hello"));
}
}
TEST_CASE("deserializeMsgPack() under memory constaints") {
SECTION("single values always fit") {
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(8, "\xA0", DeserializationError::Ok);
checkError(8, "\xA7ZZZZZZZ", DeserializationError::Ok);
checkError(8, "\xA8ZZZZZZZZ", DeserializationError::NoMemory);
checkError(16, "\xAFZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkError(16, "\xB0ZZZZZZZZZZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 8") {
checkError(8, "\xD9\x00", DeserializationError::Ok);
checkError(8, "\xD9\x07ZZZZZZZ", DeserializationError::Ok);
checkError(8, "\xD9\x08ZZZZZZZZ", DeserializationError::NoMemory);
checkError(16, "\xD9\x0FZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkError(16, "\xD9\x10ZZZZZZZZZZZZZZZZ", DeserializationError::NoMemory);
}
SECTION("str 16") {
checkError(8, "\xDA\x00\x00", DeserializationError::Ok);
checkError(8, "\xDA\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(8, "\xDA\x00\x08ZZZZZZZZ", DeserializationError::NoMemory);
checkError(16, "\xDA\x00\x0FZZZZZZZZZZZZZZZ", DeserializationError::Ok);
checkError(16, "\xDA\x00\x10ZZZZZZZZZZZZZZZZ",
DeserializationError::NoMemory);
}
SECTION("str 32") {
checkError(8, "\xDB\x00\x00\x00\x00", DeserializationError::Ok);
checkError(8, "\xDB\x00\x00\x00\x07ZZZZZZZ", DeserializationError::Ok);
checkError(8, "\xDB\x00\x00\x00\x08ZZZZZZZZ",
DeserializationError::NoMemory);
checkError(16, "\xDB\x00\x00\x00\x0FZZZZZZZZZZZZZZZ",
DeserializationError::Ok);
checkError(16, "\xDB\x00\x00\x00\x10ZZZZZZZZZZZZZZZZ",
DeserializationError::NoMemory);
}
SECTION("fixarray") {
checkError(JSON_ARRAY_SIZE(0), "\x90", DeserializationError::Ok); // []
checkError(JSON_ARRAY_SIZE(0), "\x91\x01",
DeserializationError::NoMemory); // [1]
checkError(JSON_ARRAY_SIZE(1), "\x91\x01",
DeserializationError::Ok); // [1]
checkError(JSON_ARRAY_SIZE(1), "\x92\x01\x02",
DeserializationError::NoMemory); // [1,2]
}
SECTION("array 16") {
checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x00", DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(0), "\xDC\x00\x01\x01",
DeserializationError::NoMemory);
checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x01\x01",
DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(1), "\xDC\x00\x02\x01\x02",
DeserializationError::NoMemory);
}
SECTION("array 32") {
checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x00",
DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(0), "\xDD\x00\x00\x00\x01\x01",
DeserializationError::NoMemory);
checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x01\x01",
DeserializationError::Ok);
checkError(JSON_ARRAY_SIZE(1), "\xDD\x00\x00\x00\x02\x01\x02",
DeserializationError::NoMemory);
}
SECTION("fixmap") {
SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\x80", DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\x81\xA1H\x01",
DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2), "\x81\xA1H\x01",
DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
"\x82\xA1H\x01\xA1W\x02", DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_STRING_SIZE(2),
"\x82\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 16") {
SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x00", DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\xDE\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
"\xDE\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
"\xDE\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1),
"\xDE\x00\x02\xA1H\x01\xA1W\x02", DeserializationError::Ok);
}
}
SECTION("map 32") {
SECTION("{}") {
checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x00",
DeserializationError::Ok);
}
SECTION("{H:1}") {
checkError(JSON_OBJECT_SIZE(0), "\xDF\x00\x00\x00\x01\xA1H\x01",
DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
"\xDF\x00\x00\x00\x01\xA1H\x01", DeserializationError::Ok);
}
SECTION("{H:1,W:2}") {
checkError(JSON_OBJECT_SIZE(1) + JSON_STRING_SIZE(2),
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
DeserializationError::NoMemory);
checkError(JSON_OBJECT_SIZE(2) + 2 * JSON_OBJECT_SIZE(1),
"\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") {
StaticJsonDocument<4096> doc;
DynamicJsonDocument doc(4096);
DeserializationError error;
StaticJsonDocument<200> filter;
DynamicJsonDocument filter(200);
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";
StaticJsonDocument<256> filter;
DynamicJsonDocument filter(256);
filter["include"] = true;
StaticJsonDocument<256> doc;
DynamicJsonDocument doc(256);
DeserializationError err =
deserializeMsgPack(doc, input, 18, DeserializationOption::Filter(filter));
@ -1044,8 +1044,8 @@ TEST_CASE("Zero-copy mode") { // issue #1697
}
TEST_CASE("Overloads") {
StaticJsonDocument<256> doc;
StaticJsonDocument<256> filter;
DynamicJsonDocument doc(256);
DynamicJsonDocument filter(256);
using namespace DeserializationOption;

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

@ -76,7 +76,7 @@ TEST_CASE("deserializeMsgPack(VLA)") {
char vla[i];
memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15);
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
DynamicJsonDocument doc(JSON_OBJECT_SIZE(1));
DeserializationError err = deserializeMsgPack(doc, vla);
REQUIRE(err == DeserializationError::Ok);

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

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