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

Added StaticJsonDocument and DynamicJsonDocument.

Browse Source 
Removed StaticJsonArray and DynamicJsonArray.
Removed StaticJsonObject and DynamicJsonObject.
Removed StaticJsonVariant and DynamicJsonVariant.
This commit is contained in:
Benoit Blanchon
2018-04-17 21:27:45 +02:00
parent a13b9e8bdc
commit 1feb92679d
100 changed files with 1696 additions and 1844 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/CMakeLists.txt
View File

@ -68,7 +68,7 @@ add_subdirectory(DynamicJsonBuffer)
add_subdirectory(IntegrationTests)
add_subdirectory(JsonArray)
add_subdirectory(JsonObject)
add_subdirectory(JsonParser)
add_subdirectory(JsonDeserializer)
add_subdirectory(JsonSerializer)
add_subdirectory(JsonVariant)
add_subdirectory(JsonWriter)

3
test/DynamicJsonBuffer/alloc.cpp
View File

@ -18,8 +18,7 @@ std::stringstream allocatorLog;
struct SpyingAllocator : DefaultAllocator {
void* allocate(size_t n) {
allocatorLog << static_cast<const char*>("A")
<< (n - DynamicJsonBuffer::EmptyBlockSize);
allocatorLog << "A" << (n - DynamicJsonBuffer::EmptyBlockSize);
return DefaultAllocator::allocate(n);
}
void deallocate(void* p) {

14
test/DynamicJsonBuffer/no_memory.cpp
View File

@ -23,19 +23,9 @@ TEST_CASE("DynamicJsonBuffer no memory") {
}
// TODO: uncomment
// SECTION("parseArray()") {
// char json[] = "[{}]";
// DynamicJsonArray arr;
// JsonError err = deserializeJson(arr, json);
// REQUIRE(err != JsonError::Ok);
// }
// TODO: uncomment
// SECTION("parseObject()") {
// SECTION("deserializeJson()") {
// char json[] = "{[]}";
// DynamicJsonObject obj;
// DynamicJsonDocument obj;
// JsonError err = deserializeJson(obj, json);

4
test/DynamicJsonBuffer/size.cpp
View File

@ -2,9 +2,11 @@
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <ArduinoJson/Memory/DynamicJsonBuffer.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
TEST_CASE("DynamicJsonBuffer::size()") {
DynamicJsonBuffer buffer;

4
test/DynamicJsonBuffer/startString.cpp
View File

@ -2,9 +2,11 @@
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <ArduinoJson/Memory/DynamicJsonBuffer.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
TEST_CASE("DynamicJsonBuffer::startString()") {
SECTION("WorksWhenBufferIsBigEnough") {
DynamicJsonBuffer jsonBuffer(6);

2
test/IntegrationTests/CMakeLists.txt
View File

@ -2,7 +2,7 @@
# Copyright Benoit Blanchon 2014-2018
# MIT License
add_executable(IntegrationTests
add_executable(IntegrationTests
gbathree.cpp
round_trip.cpp
)

49
test/IntegrationTests/gbathree.cpp
View File

@ -6,10 +6,10 @@
#include <catch.hpp>
TEST_CASE("Gbathree") {
DynamicJsonObject _object;
DynamicJsonDocument doc;
JsonError error = deserializeJson(
_object,
doc,
"{\"protocol_name\":\"fluorescence\",\"repeats\":1,\"wait\":0,"
"\"averages\":1,\"measurements\":3,\"meas2_light\":15,\"meas1_"
"baseline\":0,\"act_light\":20,\"pulsesize\":25,\"pulsedistance\":"
@ -20,67 +20,68 @@ TEST_CASE("Gbathree") {
"\"measlights\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,"
"15,15]],\"measlights2\":[[15,15,15,15],[15,15,15,15],[15,15,15,15],"
"[15,15,15,15]],\"altc\":[2,2,2,2],\"altd\":[2,2,2,2]}");
JsonObject& root = doc.as<JsonObject>();
SECTION("Success") {
REQUIRE(error == JsonError::Ok);
}
SECTION("ProtocolName") {
REQUIRE("fluorescence" == _object["protocol_name"]);
REQUIRE("fluorescence" == root["protocol_name"]);
}
SECTION("Repeats") {
REQUIRE(1 == _object["repeats"]);
REQUIRE(1 == root["repeats"]);
}
SECTION("Wait") {
REQUIRE(0 == _object["wait"]);
REQUIRE(0 == root["wait"]);
}
SECTION("Measurements") {
REQUIRE(3 == _object["measurements"]);
REQUIRE(3 == root["measurements"]);
}
SECTION("Meas2_Light") {
REQUIRE(15 == _object["meas2_light"]);
REQUIRE(15 == root["meas2_light"]);
}
SECTION("Meas1_Baseline") {
REQUIRE(0 == _object["meas1_baseline"]);
REQUIRE(0 == root["meas1_baseline"]);
}
SECTION("Act_Light") {
REQUIRE(20 == _object["act_light"]);
REQUIRE(20 == root["act_light"]);
}
SECTION("Pulsesize") {
REQUIRE(25 == _object["pulsesize"]);
REQUIRE(25 == root["pulsesize"]);
}
SECTION("Pulsedistance") {
REQUIRE(10000 == _object["pulsedistance"]);
REQUIRE(10000 == root["pulsedistance"]);
}
SECTION("Actintensity1") {
REQUIRE(50 == _object["actintensity1"]);
REQUIRE(50 == root["actintensity1"]);
}
SECTION("Actintensity2") {
REQUIRE(255 == _object["actintensity2"]);
REQUIRE(255 == root["actintensity2"]);
}
SECTION("Measintensity") {
REQUIRE(255 == _object["measintensity"]);
REQUIRE(255 == root["measintensity"]);
}
SECTION("Calintensity") {
REQUIRE(255 == _object["calintensity"]);
REQUIRE(255 == root["calintensity"]);
}
SECTION("Pulses") {
// "pulses":[50,50,50]
JsonArray& array = _object["pulses"];
JsonArray& array = root["pulses"];
REQUIRE(array.success());
REQUIRE(3 == array.size());
@ -93,7 +94,7 @@ TEST_CASE("Gbathree") {
SECTION("Act") {
// "act":[2,1,2,2]
JsonArray& array = _object["act"];
JsonArray& array = root["act"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -106,7 +107,7 @@ TEST_CASE("Gbathree") {
SECTION("Detectors") {
// "detectors":[[34,34,34,34],[34,34,34,34],[34,34,34,34],[34,34,34,34]]
JsonArray& array = _object["detectors"];
JsonArray& array = root["detectors"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -123,7 +124,7 @@ TEST_CASE("Gbathree") {
SECTION("Alta") {
// alta:[2,2,2,2]
JsonArray& array = _object["alta"];
JsonArray& array = root["alta"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -136,7 +137,7 @@ TEST_CASE("Gbathree") {
SECTION("Altb") {
// altb:[2,2,2,2]
JsonArray& array = _object["altb"];
JsonArray& array = root["altb"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -149,7 +150,7 @@ TEST_CASE("Gbathree") {
SECTION("Measlights") {
// "measlights":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
JsonArray& array = _object["measlights"];
JsonArray& array = root["measlights"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -167,7 +168,7 @@ TEST_CASE("Gbathree") {
SECTION("Measlights2") {
// "measlights2":[[15,15,15,15],[15,15,15,15],[15,15,15,15],[15,15,15,15]]
JsonArray& array = _object["measlights2"];
JsonArray& array = root["measlights2"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -184,7 +185,7 @@ TEST_CASE("Gbathree") {
SECTION("Altc") {
// altc:[2,2,2,2]
JsonArray& array = _object["altc"];
JsonArray& array = root["altc"];
REQUIRE(array.success());
REQUIRE(4 == array.size());
@ -197,7 +198,7 @@ TEST_CASE("Gbathree") {
SECTION("Altd") {
// altd:[2,2,2,2]
JsonArray& array = _object["altd"];
JsonArray& array = root["altd"];
REQUIRE(array.success());
REQUIRE(4 == array.size());

10
test/IntegrationTests/round_trip.cpp
View File

@ -6,15 +6,15 @@
#include <catch.hpp>
void check(std::string originalJson) {
DynamicJsonObject obj;
DynamicJsonDocument doc;
std::string prettyJson;
deserializeJson(obj, originalJson);
serializeJsonPretty(obj, prettyJson);
deserializeJson(doc, originalJson);
serializeJsonPretty(doc, prettyJson);
std::string finalJson;
deserializeJson(obj, originalJson);
serializeJson(obj, finalJson);
deserializeJson(doc, originalJson);
serializeJson(doc, finalJson);
REQUIRE(originalJson == finalJson);
}

25
test/JsonArray/add.cpp
View File

@ -6,7 +6,8 @@
#include <catch.hpp>
TEST_CASE("JsonArray::add()") {
DynamicJsonArray _array;
DynamicJsonDocument doc;
JsonArray& _array = doc.to<JsonArray>();
SECTION("int") {
_array.add(123);
@ -38,7 +39,8 @@ TEST_CASE("JsonArray::add()") {
}
SECTION("nested array") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
_array.add(arr);
@ -48,7 +50,8 @@ TEST_CASE("JsonArray::add()") {
}
SECTION("nested object") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
_array.add(obj);
@ -59,7 +62,8 @@ TEST_CASE("JsonArray::add()") {
SECTION("array subscript") {
const char* str = "hello";
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
arr.add(str);
_array.add(arr[0]);
@ -69,7 +73,8 @@ TEST_CASE("JsonArray::add()") {
SECTION("object subscript") {
const char* str = "hello";
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
obj["x"] = str;
_array.add(obj["x"]);
@ -80,30 +85,30 @@ TEST_CASE("JsonArray::add()") {
SECTION("should not duplicate const char*") {
_array.add("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1);
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char*") {
_array.add(const_cast<char*>("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string") {
_array.add(std::string("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should not duplicate RawJson(const char*)") {
_array.add(RawJson("{}"));
const size_t expectedSize = JSON_ARRAY_SIZE(1);
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate RawJson(char*)") {
_array.add(RawJson(const_cast<char*>("{}")));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 3;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
}

3
test/JsonArray/basics.cpp
View File

@ -6,7 +6,8 @@
#include <catch.hpp>
TEST_CASE("JsonArray basics") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
SECTION("SuccessIsTrue") {
REQUIRE(array.success());

12
test/JsonArray/copyFrom.cpp
View File

@ -7,7 +7,8 @@
TEST_CASE("JsonArray::copyFrom()") {
SECTION("OneDimension") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
char json[32];
int source[] = {1, 2, 3};
@ -20,7 +21,8 @@ TEST_CASE("JsonArray::copyFrom()") {
SECTION("OneDimension_JsonBufferTooSmall") {
const size_t SIZE = JSON_ARRAY_SIZE(2);
StaticJsonArray<SIZE> array;
StaticJsonDocument<SIZE> doc;
JsonArray& array = doc.to<JsonArray>();
char json[32];
int source[] = {1, 2, 3};
@ -32,7 +34,8 @@ TEST_CASE("JsonArray::copyFrom()") {
}
SECTION("TwoDimensions") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
char json[32];
int source[][3] = {{1, 2, 3}, {4, 5, 6}};
@ -46,7 +49,8 @@ TEST_CASE("JsonArray::copyFrom()") {
SECTION("TwoDimensions_JsonBufferTooSmall") {
const size_t SIZE =
JSON_ARRAY_SIZE(2) + JSON_ARRAY_SIZE(3) + JSON_ARRAY_SIZE(2);
StaticJsonArray<SIZE> array;
StaticJsonDocument<SIZE> doc;
JsonArray& array = doc.to<JsonArray>();
char json[32];
int source[][3] = {{1, 2, 3}, {4, 5, 6}};

11
test/JsonArray/copyTo.cpp
View File

@ -6,12 +6,13 @@
#include <catch.hpp>
TEST_CASE("JsonArray::copyTo()") {
DynamicJsonArray array;
DynamicJsonDocument doc;
SECTION("BiggerOneDimensionIntegerArray") {
char json[] = "[1,2,3]";
JsonError err = deserializeJson(array, json);
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
JsonArray& array = doc.as<JsonArray>();
int destination[4] = {0};
size_t result = array.copyTo(destination);
@ -25,8 +26,9 @@ TEST_CASE("JsonArray::copyTo()") {
SECTION("SmallerOneDimensionIntegerArray") {
char json[] = "[1,2,3]";
JsonError err = deserializeJson(array, json);
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
JsonArray& array = doc.as<JsonArray>();
int destination[2] = {0};
size_t result = array.copyTo(destination);
@ -39,8 +41,9 @@ TEST_CASE("JsonArray::copyTo()") {
SECTION("TwoOneDimensionIntegerArray") {
char json[] = "[[1,2],[3],[4]]";
JsonError err = deserializeJson(array, json);
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
JsonArray& array = doc.as<JsonArray>();
int destination[3][2] = {{0}};
array.copyTo(destination);

3
test/JsonArray/iterator.cpp
View File

@ -7,7 +7,8 @@
template <typename TIterator>
static void run_iterator_test() {
StaticJsonArray<JSON_ARRAY_SIZE(2)> array;
StaticJsonDocument<JSON_ARRAY_SIZE(2)> doc;
JsonArray& array = doc.to<JsonArray>();
array.add(12);
array.add(34);

3
test/JsonArray/remove.cpp
View File

@ -6,7 +6,8 @@
#include <catch.hpp>
TEST_CASE("JsonArray::remove()") {
DynamicJsonArray _array;
DynamicJsonDocument doc;
JsonArray& _array = doc.to<JsonArray>();
_array.add(1);
_array.add(2);
_array.add(3);

21
test/JsonArray/set.cpp
View File

@ -8,7 +8,8 @@
using namespace Catch::Matchers;
TEST_CASE("JsonArray::set()") {
DynamicJsonArray _array;
DynamicJsonDocument doc;
JsonArray& _array = doc.to<JsonArray>();
_array.add(0);
SECTION("int") {
@ -40,7 +41,8 @@ TEST_CASE("JsonArray::set()") {
}
SECTION("nested array") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
_array.set(0, arr);
@ -50,7 +52,8 @@ TEST_CASE("JsonArray::set()") {
}
SECTION("nested object") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
_array.set(0, obj);
@ -60,7 +63,8 @@ TEST_CASE("JsonArray::set()") {
}
SECTION("array subscript") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
arr.add("hello");
_array.set(0, arr[0]);
@ -69,7 +73,8 @@ TEST_CASE("JsonArray::set()") {
}
SECTION("object subscript") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
obj["x"] = "hello";
_array.set(0, obj["x"]);
@ -80,18 +85,18 @@ TEST_CASE("JsonArray::set()") {
SECTION("should not duplicate const char*") {
_array.set(0, "world");
const size_t expectedSize = JSON_ARRAY_SIZE(1);
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char*") {
_array.set(0, const_cast<char*>("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string") {
_array.set(0, std::string("world"));
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
}

3
test/JsonArray/size.cpp
View File

@ -6,7 +6,8 @@
#include <catch.hpp>
TEST_CASE("JsonArray::size()") {
DynamicJsonArray _array;
DynamicJsonDocument doc;
JsonArray& _array = doc.to<JsonArray>();
SECTION("increases after add()") {
_array.add("hello");

21
test/JsonArray/subscript.cpp
View File

@ -7,7 +7,8 @@
#include <catch.hpp>
TEST_CASE("JsonArray::operator[]") {
DynamicJsonArray _array;
DynamicJsonDocument doc;
JsonArray& _array = doc.to<JsonArray>();
_array.add(0);
SECTION("int") {
@ -51,7 +52,8 @@ TEST_CASE("JsonArray::operator[]") {
}
SECTION("nested array") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
_array[0] = arr;
@ -64,7 +66,8 @@ TEST_CASE("JsonArray::operator[]") {
}
SECTION("nested object") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
_array[0] = obj;
@ -77,7 +80,8 @@ TEST_CASE("JsonArray::operator[]") {
}
SECTION("array subscript") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
const char* str = "hello";
arr.add(str);
@ -88,8 +92,9 @@ TEST_CASE("JsonArray::operator[]") {
}
SECTION("object subscript") {
DynamicJsonObject obj;
const char* str = "hello";
DynamicJsonDocument doc2;
JsonObject& obj = doc2.to<JsonObject>();
obj["x"] = str;
@ -101,18 +106,18 @@ TEST_CASE("JsonArray::operator[]") {
SECTION("should not duplicate const char*") {
_array[0] = "world";
const size_t expectedSize = JSON_ARRAY_SIZE(1);
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char*") {
_array[0] = const_cast<char*>("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string") {
_array[0] = std::string("world");
const size_t expectedSize = JSON_ARRAY_SIZE(1) + 6;
REQUIRE(expectedSize == _array.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
}

16
test/JsonDeserializer/CMakeLists.txt Normal file
View File

@ -0,0 +1,16 @@
# ArduinoJson - arduinojson.org
# Copyright Benoit Blanchon 2014-2018
# MIT License
add_executable(JsonDeserializerTests
deserializeJsonArray.cpp
deserializeJsonArrayStatic.cpp
deserializeJsonObject.cpp
deserializeJsonObjectStatic.cpp
deserializeJsonValue.cpp
JsonError.cpp
nestingLimit.cpp
)
target_link_libraries(JsonDeserializerTests catch)
add_test(JsonDeserializer JsonDeserializerTests)

18
test/JsonParser/JsonError.cpp → test/JsonDeserializer/JsonError.cpp
View File

@ -22,23 +22,21 @@ void testBoolification(JsonError error, bool expected) {
TEST_CASE("JsonError") {
SECTION("c_str()") {
TEST_STRINGIFICATION(Ok);
TEST_STRINGIFICATION(OpeningBraceExpected);
TEST_STRINGIFICATION(ClosingBraceExpected);
TEST_STRINGIFICATION(OpeningBracketExpected);
TEST_STRINGIFICATION(ClosingBracketExpected);
TEST_STRINGIFICATION(ColonExpected);
TEST_STRINGIFICATION(TooDeep);
TEST_STRINGIFICATION(NoMemory);
TEST_STRINGIFICATION(InvalidInput);
}
SECTION("as boolean") {
TEST_BOOLIFICATION(Ok, false);
TEST_BOOLIFICATION(OpeningBraceExpected, true);
TEST_BOOLIFICATION(ClosingBraceExpected, true);
TEST_BOOLIFICATION(OpeningBracketExpected, true);
TEST_BOOLIFICATION(ClosingBracketExpected, true);
TEST_BOOLIFICATION(ColonExpected, true);
TEST_BOOLIFICATION(TooDeep, true);
TEST_BOOLIFICATION(NoMemory, true);
TEST_BOOLIFICATION(InvalidInput, true);
}
SECTION("ostream") {
std::stringstream s;
s << JsonError::InvalidInput;
REQUIRE(s.str() == "InvalidInput");
}
}

161
test/JsonParser/DynamicJsonArray.cpp → test/JsonDeserializer/deserializeJsonArray.cpp
View File

@ -5,11 +5,12 @@
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserializeJson(DynamicJsonArray&)") {
DynamicJsonArray arr;
TEST_CASE("deserialize JSON array") {
DynamicJsonDocument doc;
SECTION("An empty array") {
JsonError err = deserializeJson(arr, "[]");
JsonError err = deserializeJson(doc, "[]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(0 == arr.size());
@ -17,14 +18,16 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
SECTION("Spaces") {
SECTION("Before the opening bracket") {
JsonError err = deserializeJson(arr, " []");
JsonError err = deserializeJson(doc, " []");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(0 == arr.size());
}
SECTION("Before first value") {
JsonError err = deserializeJson(arr, "[ \t\r\n42]");
JsonError err = deserializeJson(doc, "[ \t\r\n42]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -32,7 +35,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After first value") {
JsonError err = deserializeJson(arr, "[42 \t\r\n]");
JsonError err = deserializeJson(doc, "[42 \t\r\n]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -42,7 +46,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
SECTION("Values types") {
SECTION("On integer") {
JsonError err = deserializeJson(arr, "[42]");
JsonError err = deserializeJson(doc, "[42]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -50,7 +55,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Two integers") {
JsonError err = deserializeJson(arr, "[42,84]");
JsonError err = deserializeJson(doc, "[42,84]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -59,7 +65,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Double") {
JsonError err = deserializeJson(arr, "[4.2,1e2]");
JsonError err = deserializeJson(doc, "[4.2,1e2]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -68,7 +75,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Unsigned long") {
JsonError err = deserializeJson(arr, "[4294967295]");
JsonError err = deserializeJson(doc, "[4294967295]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -76,7 +84,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Boolean") {
JsonError err = deserializeJson(arr, "[true,false]");
JsonError err = deserializeJson(doc, "[true,false]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -85,18 +94,20 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Null") {
JsonError err = deserializeJson(arr, "[null,null]");
JsonError err = deserializeJson(doc, "[null,null]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
REQUIRE(arr[0].as<char *>() == 0);
REQUIRE(arr[1].as<char *>() == 0);
REQUIRE(arr[0].as<char*>() == 0);
REQUIRE(arr[1].as<char*>() == 0);
}
}
SECTION("Quotes") {
SECTION("Double quotes") {
JsonError err = deserializeJson(arr, "[ \"hello\" , \"world\" ]");
JsonError err = deserializeJson(doc, "[ \"hello\" , \"world\" ]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -105,7 +116,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Single quotes") {
JsonError err = deserializeJson(arr, "[ 'hello' , 'world' ]");
JsonError err = deserializeJson(doc, "[ 'hello' , 'world' ]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -114,7 +126,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("No quotes") {
JsonError err = deserializeJson(arr, "[ hello , world ]");
JsonError err = deserializeJson(doc, "[ hello , world ]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -123,7 +136,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Double quotes (empty strings)") {
JsonError err = deserializeJson(arr, "[\"\",\"\"]");
JsonError err = deserializeJson(doc, "[\"\",\"\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -132,7 +146,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Single quotes (empty strings)") {
JsonError err = deserializeJson(arr, "[\'\',\'\']");
JsonError err = deserializeJson(doc, "[\'\',\'\']");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -141,30 +156,28 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("No quotes (empty strings)") {
JsonError err = deserializeJson(arr, "[,]");
JsonError err = deserializeJson(doc, "[,]");
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
REQUIRE(arr[0] == "");
REQUIRE(arr[1] == "");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Closing single quotes missing") {
JsonError err = deserializeJson(arr, "[\"]");
JsonError err = deserializeJson(doc, "[\"]");
REQUIRE(err != JsonError::Ok);
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Closing double quotes missing") {
JsonError err = deserializeJson(arr, "[\']");
JsonError err = deserializeJson(doc, "[\']");
REQUIRE(err != JsonError::Ok);
REQUIRE(err == JsonError::InvalidInput);
}
}
SECTION("Block comments") {
SECTION("Before opening bracket") {
JsonError err = deserializeJson(arr, "/*COMMENT*/ [\"hello\"]");
JsonError err = deserializeJson(doc, "/*COMMENT*/ [\"hello\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -172,7 +185,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After opening bracket") {
JsonError err = deserializeJson(arr, "[/*COMMENT*/ \"hello\"]");
JsonError err = deserializeJson(doc, "[/*COMMENT*/ \"hello\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -180,7 +194,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Before closing bracket") {
JsonError err = deserializeJson(arr, "[\"hello\"/*COMMENT*/]");
JsonError err = deserializeJson(doc, "[\"hello\"/*COMMENT*/]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -188,7 +203,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After closing bracket") {
JsonError err = deserializeJson(arr, "[\"hello\"]/*COMMENT*/");
JsonError err = deserializeJson(doc, "[\"hello\"]/*COMMENT*/");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -196,7 +212,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Before comma") {
JsonError err = deserializeJson(arr, "[\"hello\"/*COMMENT*/,\"world\"]");
JsonError err = deserializeJson(doc, "[\"hello\"/*COMMENT*/,\"world\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -205,7 +222,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After comma") {
JsonError err = deserializeJson(arr, "[\"hello\",/*COMMENT*/ \"world\"]");
JsonError err = deserializeJson(doc, "[\"hello\",/*COMMENT*/ \"world\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -214,24 +232,25 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("/*/") {
JsonError err = deserializeJson(arr, "[/*/\n]");
REQUIRE(err != JsonError::Ok);
JsonError err = deserializeJson(doc, "[/*/\n]");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Unfinished comment") {
JsonError err = deserializeJson(arr, "[/*COMMENT]");
REQUIRE(err != JsonError::Ok);
JsonError err = deserializeJson(doc, "[/*COMMENT]");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Final slash missing") {
JsonError err = deserializeJson(arr, "[/*COMMENT*]");
REQUIRE(err != JsonError::Ok);
JsonError err = deserializeJson(doc, "[/*COMMENT*]");
REQUIRE(err == JsonError::InvalidInput);
}
}
SECTION("Line comments") {
SECTION("Before opening bracket") {
JsonError err = deserializeJson(arr, "//COMMENT\n\t[\"hello\"]");
JsonError err = deserializeJson(doc, "//COMMENT\n\t[\"hello\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -239,7 +258,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After opening bracket") {
JsonError err = deserializeJson(arr, "[//COMMENT\n\"hello\"]");
JsonError err = deserializeJson(doc, "[//COMMENT\n\"hello\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -247,7 +267,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Before closing bracket") {
JsonError err = deserializeJson(arr, "[\"hello\"//COMMENT\r\n]");
JsonError err = deserializeJson(doc, "[\"hello\"//COMMENT\r\n]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -255,7 +276,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After closing bracket") {
JsonError err = deserializeJson(arr, "[\"hello\"]//COMMENT\n");
JsonError err = deserializeJson(doc, "[\"hello\"]//COMMENT\n");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -263,7 +285,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Before comma") {
JsonError err = deserializeJson(arr, "[\"hello\"//COMMENT\n,\"world\"]");
JsonError err = deserializeJson(doc, "[\"hello\"//COMMENT\n,\"world\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -272,7 +295,8 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("After comma") {
JsonError err = deserializeJson(arr, "[\"hello\",//COMMENT\n\"world\"]");
JsonError err = deserializeJson(doc, "[\"hello\",//COMMENT\n\"world\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(2 == arr.size());
@ -281,57 +305,55 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Invalid comment") {
JsonError err = deserializeJson(arr, "[/COMMENT\n]");
REQUIRE(err != JsonError::Ok);
JsonError err = deserializeJson(doc, "[/COMMENT\n]");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("End document with comment") {
JsonError err = deserializeJson(arr, "[//COMMENT");
REQUIRE(err != JsonError::Ok);
JsonError err = deserializeJson(doc, "[//COMMENT");
REQUIRE(err == JsonError::InvalidInput);
}
}
SECTION("Misc") {
SECTION("Garbage") {
JsonError err = deserializeJson(arr, "%*$£¤");
JsonError err = deserializeJson(doc, "%*$£¤");
REQUIRE(err != JsonError::Ok);
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("The opening bracket is missing") {
JsonError err = deserializeJson(arr, "]");
JsonError err = deserializeJson(doc, "]");
REQUIRE(err != JsonError::Ok); // TODO
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("The closing bracket is missing") {
JsonError err = deserializeJson(arr, "[");
REQUIRE(err != JsonError::Ok); // TODO
JsonError err = deserializeJson(doc, "[");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Escape sequences") {
JsonError err =
deserializeJson(arr, "[\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"]");
deserializeJson(doc, "[\"1\\\"2\\\\3\\/4\\b5\\f6\\n7\\r8\\t9\"]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
REQUIRE(arr[0] == "1\"2\\3/4\b5\f6\n7\r8\t9");
}
SECTION("Unterminated escape sequence") {
JsonError err = deserializeJson(arr, "\"\\\0\"", 4);
REQUIRE(err != JsonError::Ok);
}
SECTION("Nested objects") {
char jsonString[] =
" [ { \"a\" : 1 , \"b\" : 2 } , { \"c\" : 3 , \"d\" : 4 } ] ";
JsonError err = deserializeJson(arr, jsonString);
JsonError err = deserializeJson(doc, jsonString);
JsonArray& arr = doc.as<JsonArray>();
JsonObject &object1 = arr[0];
const JsonObject &object2 = arr[1];
JsonObject &object3 = arr[2];
JsonObject& object1 = arr[0];
const JsonObject& object2 = arr[1];
JsonObject& object3 = arr[2];
REQUIRE(err == JsonError::Ok);
@ -352,10 +374,11 @@ TEST_CASE("deserializeJson(DynamicJsonArray&)") {
}
SECTION("Should clear the JsonArray") {
deserializeJson(arr, "[1,2,3,4]");
deserializeJson(arr, "[]");
deserializeJson(doc, "[1,2,3,4]");
deserializeJson(doc, "[]");
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(arr.size() == 0);
REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0));
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(0));
}
}

105
test/JsonDeserializer/deserializeJsonArrayStatic.cpp Normal file
View File

@ -0,0 +1,105 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// 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[] = "[]";
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForArrayWithOneValue") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) - 1> doc;
char input[] = "[1]";
JsonError err = deserializeJson(doc, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForArrayWithOneValue") {
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
char input[] = "[1]";
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForArrayWithNestedObject") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0) - 1> doc;
char input[] = "[{}]";
JsonError err = deserializeJson(doc, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForArrayWithNestedObject") {
StaticJsonDocument<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)> doc;
char input[] = "[{}]";
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("CharPtrNull") {
StaticJsonDocument<100> doc;
JsonError err = deserializeJson(doc, static_cast<char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("ConstCharPtrNull") {
StaticJsonDocument<100> doc;
JsonError err = deserializeJson(doc, static_cast<const char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("CopyStringNotSpaces") {
StaticJsonDocument<100> doc;
deserializeJson(doc, " [ \"1234567\" ] ");
REQUIRE(JSON_ARRAY_SIZE(1) + sizeof("1234567") == doc.memoryUsage());
// note: we use a string of 8 bytes to be sure that the StaticJsonBuffer
// 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]";
JsonError err = deserializeJson(doc, input);
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonArray>());
REQUIRE(doc.memoryUsage() == JSON_ARRAY_SIZE(2));
REQUIRE(arr[0] == 1);
REQUIRE(arr[1] == 2);
}
}

134
test/JsonParser/DynamicJsonObject.cpp → test/JsonDeserializer/deserializeJsonObject.cpp
View File

@ -5,40 +5,55 @@
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserializeJson(DynamicJsonObject&)") {
DynamicJsonObject obj;
TEST_CASE("deserialize JSON object") {
DynamicJsonDocument doc;
SECTION("An empty object") {
JsonError err = deserializeJson(obj, "{}");
JsonError err = deserializeJson(doc, "{}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0);
}
SECTION("Quotes") {
SECTION("Double quotes") {
JsonError err = deserializeJson(obj, "{\"key\":\"value\"}");
JsonError err = deserializeJson(doc, "{\"key\":\"value\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("Single quotes") {
JsonError err = deserializeJson(obj, "{'key':'value'}");
JsonError err = deserializeJson(doc, "{'key':'value'}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("No quotes") {
JsonError err = deserializeJson(obj, "{key:value}");
JsonError err = deserializeJson(doc, "{key:value}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("No quotes, allow underscore in key") {
JsonError err = deserializeJson(obj, "{_k_e_y_:42}");
JsonError err = deserializeJson(doc, "{_k_e_y_:42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["_k_e_y_"] == 42);
}
@ -46,37 +61,52 @@ TEST_CASE("deserializeJson(DynamicJsonObject&)") {
SECTION("Spaces") {
SECTION("Before the key") {
JsonError err = deserializeJson(obj, "{ \"key\":\"value\"}");
JsonError err = deserializeJson(doc, "{ \"key\":\"value\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("After the key") {
JsonError err = deserializeJson(obj, "{\"key\" :\"value\"}");
JsonError err = deserializeJson(doc, "{\"key\" :\"value\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("Before the value") {
JsonError err = deserializeJson(obj, "{\"key\": \"value\"}");
JsonError err = deserializeJson(doc, "{\"key\": \"value\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("After the value") {
JsonError err = deserializeJson(obj, "{\"key\":\"value\" }");
JsonError err = deserializeJson(doc, "{\"key\":\"value\" }");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 1);
REQUIRE(obj["key"] == "value");
}
SECTION("Before the colon") {
JsonError err =
deserializeJson(obj, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
deserializeJson(doc, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == "value1");
REQUIRE(obj["key2"] == "value2");
@ -84,8 +114,11 @@ TEST_CASE("deserializeJson(DynamicJsonObject&)") {
SECTION("After the colon") {
JsonError err =
deserializeJson(obj, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
deserializeJson(doc, "{\"key1\":\"value1\" ,\"key2\":\"value2\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == "value1");
REQUIRE(obj["key2"] == "value2");
@ -95,53 +128,69 @@ TEST_CASE("deserializeJson(DynamicJsonObject&)") {
SECTION("Values types") {
SECTION("String") {
JsonError err =
deserializeJson(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}");
deserializeJson(doc, "{\"key1\":\"value1\",\"key2\":\"value2\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == "value1");
REQUIRE(obj["key2"] == "value2");
}
SECTION("Integer") {
JsonError err = deserializeJson(obj, "{\"key1\":42,\"key2\":-42}");
JsonError err = deserializeJson(doc, "{\"key1\":42,\"key2\":-42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == 42);
REQUIRE(obj["key2"] == -42);
}
SECTION("Double") {
JsonError err = deserializeJson(obj, "{\"key1\":12.345,\"key2\":-7E89}");
JsonError err = deserializeJson(doc, "{\"key1\":12.345,\"key2\":-7E89}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == 12.345);
REQUIRE(obj["key2"] == -7E89);
}
SECTION("Booleans") {
JsonError err = deserializeJson(obj, "{\"key1\":true,\"key2\":false}");
JsonError err = deserializeJson(doc, "{\"key1\":true,\"key2\":false}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"] == true);
REQUIRE(obj["key2"] == false);
}
SECTION("Null") {
JsonError err = deserializeJson(obj, "{\"key1\":null,\"key2\":null}");
JsonError err = deserializeJson(doc, "{\"key1\":null,\"key2\":null}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["key1"].as<char *>() == 0);
REQUIRE(obj["key2"].as<char *>() == 0);
REQUIRE(obj["key1"].as<char*>() == 0);
REQUIRE(obj["key2"].as<char*>() == 0);
}
SECTION("Array") {
char jsonString[] = " { \"ab\" : [ 1 , 2 ] , \"cd\" : [ 3 , 4 ] } ";
JsonError err = deserializeJson(obj, jsonString);
JsonError err = deserializeJson(doc, jsonString);
JsonObject& obj = doc.as<JsonObject>();
JsonArray &array1 = obj["ab"];
const JsonArray &array2 = obj["cd"];
JsonArray &array3 = obj["ef"];
JsonArray& array1 = obj["ab"];
const JsonArray& array2 = obj["cd"];
JsonArray& array3 = obj["ef"];
REQUIRE(err == JsonError::Ok);
@ -165,40 +214,49 @@ TEST_CASE("deserializeJson(DynamicJsonObject&)") {
SECTION("Misc") {
SECTION("The opening brace is missing") {
JsonError err = deserializeJson(obj, "}");
REQUIRE(err == JsonError::OpeningBraceExpected);
JsonError err = deserializeJson(doc, "}");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("The closing brace is missing") {
JsonError err = deserializeJson(obj, "{\"hello\":\"world\"");
REQUIRE(err == JsonError::ClosingBraceExpected);
JsonError err = deserializeJson(doc, "{\"hello\":\"world\"");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("A quoted key without value") {
JsonError err = deserializeJson(obj, "{\"key\"}");
REQUIRE(err == JsonError::ColonExpected);
JsonError err = deserializeJson(doc, "{\"key\"}");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("A non-quoted key without value") {
JsonError err = deserializeJson(obj, "{key}");
REQUIRE(err == JsonError::ColonExpected);
JsonError err = deserializeJson(doc, "{key}");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("A dangling comma") {
JsonError err = deserializeJson(obj, "{\"key1\":\"value1\",}");
REQUIRE(err == JsonError::ColonExpected);
JsonError err = deserializeJson(doc, "{\"key1\":\"value1\",}");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("null as a key") {
JsonError err = deserializeJson(obj, "{null:\"value\"}");
JsonError err = deserializeJson(doc, "{null:\"value\"}");
REQUIRE(err == JsonError::Ok);
}
}
SECTION("Should clear the JsonObject") {
deserializeJson(obj, "{\"hello\":\"world\"}");
deserializeJson(obj, "{}");
deserializeJson(doc, "{\"hello\":\"world\"}");
deserializeJson(doc, "{}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0);
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(0));
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

40
test/JsonParser/StaticJsonObject.cpp → test/JsonDeserializer/deserializeJsonObjectStatic.cpp
View File

@ -5,76 +5,76 @@
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserializeJson(StaticJsonObject&)") {
TEST_CASE("deserialize JSON object with StaticJsonDocument") {
SECTION("BufferOfTheRightSizeForEmptyObject") {
StaticJsonObject<JSON_OBJECT_SIZE(0)> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(0)> doc;
char input[] = "{}";
JsonError err = deserializeJson(obj, input);
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForObjectWithOneValue") {
StaticJsonObject<JSON_OBJECT_SIZE(1) - 1> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1) - 1> doc;
char input[] = "{\"a\":1}";
JsonError err = deserializeJson(obj, input);
JsonError err = deserializeJson(doc, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForObjectWithOneValue") {
StaticJsonObject<JSON_OBJECT_SIZE(1)> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
char input[] = "{\"a\":1}";
JsonError err = deserializeJson(obj, input);
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForObjectWithNestedObject") {
StaticJsonObject<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0) - 1> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0) - 1> doc;
char input[] = "{\"a\":[]}";
JsonError err = deserializeJson(obj, input);
JsonError err = deserializeJson(doc, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForObjectWithNestedObject") {
StaticJsonObject<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1) + JSON_ARRAY_SIZE(0)> doc;
char input[] = "{\"a\":[]}";
JsonError err = deserializeJson(obj, input);
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("CharPtrNull") {
StaticJsonObject<100> obj;
StaticJsonDocument<100> doc;
JsonError err = deserializeJson(obj, static_cast<char*>(0));
JsonError err = deserializeJson(doc, static_cast<char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("ConstCharPtrNull") {
StaticJsonObject<100> obj;
StaticJsonDocument<100> doc;
JsonError err = deserializeJson(obj, static_cast<const char*>(0));
JsonError err = deserializeJson(doc, static_cast<const char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("Should clear the JsonObject") {
StaticJsonObject<JSON_OBJECT_SIZE(1)> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
char input[] = "{\"hello\":\"world\"}";
deserializeJson(obj, input);
deserializeJson(obj, "{}");
deserializeJson(doc, input);
deserializeJson(doc, "{}");
REQUIRE(obj.size() == 0);
REQUIRE(obj.memoryUsage() == JSON_OBJECT_SIZE(0));
REQUIRE(doc.as<JsonObject>().size() == 0);
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

103
test/JsonDeserializer/deserializeJsonValue.cpp Normal file
View File

@ -0,0 +1,103 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace Catch::Matchers;
TEST_CASE("deserializeJson(DynamicJsonDocument&)") {
DynamicJsonDocument doc;
SECTION("EmptyObject") {
JsonError err = deserializeJson(doc, "{}");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonObject>());
}
SECTION("EmptyArray") {
JsonError err = deserializeJson(doc, "[]");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<JsonArray>());
}
SECTION("Integer") {
JsonError err = deserializeJson(doc, "-42");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<int>());
REQUIRE_FALSE(doc.is<bool>());
REQUIRE(doc.as<int>() == -42);
}
SECTION("Double") {
JsonError err = deserializeJson(doc, "-1.23e+4");
REQUIRE(err == JsonError::Ok);
REQUIRE_FALSE(doc.is<int>());
REQUIRE(doc.is<double>());
REQUIRE(doc.as<double>() == Approx(-1.23e+4));
}
SECTION("Double quoted string") {
JsonError err = deserializeJson(doc, "\"hello world\"");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<char*>());
REQUIRE_THAT(doc.as<char*>(), Equals("hello world"));
}
SECTION("Single quoted string") {
JsonError err = deserializeJson(doc, "\'hello world\'");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<char*>());
REQUIRE_THAT(doc.as<char*>(), Equals("hello world"));
}
SECTION("True") {
JsonError err = deserializeJson(doc, "true");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<bool>());
REQUIRE(doc.as<bool>() == true);
}
SECTION("False") {
JsonError err = deserializeJson(doc, "false");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<bool>());
REQUIRE(doc.as<bool>() == false);
}
SECTION("OpenBrace") {
JsonError err = deserializeJson(doc, "{");
REQUIRE(err != JsonError::Ok);
}
SECTION("Incomplete string") {
JsonError err = deserializeJson(doc, "\"hello");
REQUIRE(err == JsonError::Ok);
REQUIRE(doc.is<char*>());
REQUIRE_THAT(doc.as<char*>(), Equals("hello"));
}
SECTION("Unterminated escape sequence") {
JsonError err = deserializeJson(doc, "\"\\\0\"");
REQUIRE(err == JsonError::InvalidInput);
}
SECTION("Should clear the JsonVariant") {
deserializeJson(doc, "[1,2,3]");
deserializeJson(doc, "{}");
REQUIRE(doc.is<JsonObject>());
REQUIRE(doc.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

32
test/JsonDeserializer/nestingLimit.cpp Normal file
View File

@ -0,0 +1,32 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
#define SHOULD_WORK(expression) REQUIRE(JsonError::Ok == expression);
#define SHOULD_FAIL(expression) REQUIRE(JsonError::TooDeep == expression);
TEST_CASE("JsonDeserializer nestingLimit") {
DynamicJsonDocument doc;
SECTION("limit = 0") {
SHOULD_WORK(deserializeJson(doc, "\"toto\"", 0));
SHOULD_WORK(deserializeJson(doc, "123", 0));
SHOULD_WORK(deserializeJson(doc, "true", 0));
SHOULD_FAIL(deserializeJson(doc, "[]", 0));
SHOULD_FAIL(deserializeJson(doc, "{}", 0));
SHOULD_FAIL(deserializeJson(doc, "[\"toto\"]", 0));
SHOULD_FAIL(deserializeJson(doc, "{\"toto\":1}", 0));
}
SECTION("limit = 1") {
SHOULD_WORK(deserializeJson(doc, "[\"toto\"]", 1));
SHOULD_WORK(deserializeJson(doc, "{\"toto\":1}", 1));
SHOULD_FAIL(deserializeJson(doc, "{\"toto\":{}}", 1));
SHOULD_FAIL(deserializeJson(doc, "{\"toto\":[]}", 1));
SHOULD_FAIL(deserializeJson(doc, "[[\"toto\"]]", 1));
SHOULD_FAIL(deserializeJson(doc, "[{\"toto\":1}]", 1));
}
}

9
test/JsonObject/basics.cpp
View File

@ -6,13 +6,10 @@
#include <catch.hpp>
TEST_CASE("JsonObject basics") {
DynamicJsonObject _object;
SECTION("InitialSizeIsZero") {
REQUIRE(0 == _object.size());
}
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("SuccessIsTrue") {
REQUIRE(_object.success());
REQUIRE(obj.success());
}
}

17
test/JsonObject/containsKey.cpp
View File

@ -6,24 +6,25 @@
#include <catch.hpp>
TEST_CASE("JsonObject::containsKey()") {
DynamicJsonObject _object;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("ContainsKeyReturnsFalseForNonExistingKey") {
_object.set("hello", 42);
obj.set("hello", 42);
REQUIRE(false == _object.containsKey("world"));
REQUIRE(false == obj.containsKey("world"));
}
SECTION("ContainsKeyReturnsTrueForDefinedValue") {
_object.set("hello", 42);
obj.set("hello", 42);
REQUIRE(true == _object.containsKey("hello"));
REQUIRE(true == obj.containsKey("hello"));
}
SECTION("ContainsKeyReturnsFalseAfterRemove") {
_object.set("hello", 42);
_object.remove("hello");
obj.set("hello", 42);
obj.remove("hello");
REQUIRE(false == _object.containsKey("hello"));
REQUIRE(false == obj.containsKey("hello"));
}
}

3
test/JsonObject/get.cpp
View File

@ -8,7 +8,8 @@
using namespace Catch::Matchers;
TEST_CASE("JsonObject::get()") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("GetConstCharPointer_GivenStringLiteral") {
obj.set("hello", "world");

3
test/JsonObject/iterator.cpp
View File

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

7
test/JsonObject/remove.cpp
View File

@ -7,7 +7,8 @@
#include <string>
TEST_CASE("JsonObject::remove()") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("SizeDecreased_WhenValuesAreRemoved") {
obj["hello"] = 1;
@ -26,7 +27,9 @@ TEST_CASE("JsonObject::remove()") {
}
SECTION("RemoveByIterator") {
deserializeJson(obj, "{\"a\":0,\"b\":1,\"c\":2}");
obj["a"] = 0;
obj["b"] = 1;
obj["c"] = 2;
for (JsonObject::iterator it = obj.begin(); it != obj.end(); ++it) {
if (it->value == 1) obj.remove(it);

111
test/JsonObject/set.cpp
View File

@ -7,129 +7,136 @@
#include <string>
TEST_CASE("JsonObject::set()") {
DynamicJsonObject _object;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("int") {
_object.set("hello", 123);
obj.set("hello", 123);
REQUIRE(123 == _object["hello"].as<int>());
REQUIRE(_object["hello"].is<int>());
REQUIRE_FALSE(_object["hello"].is<bool>());
REQUIRE(123 == obj["hello"].as<int>());
REQUIRE(obj["hello"].is<int>());
REQUIRE_FALSE(obj["hello"].is<bool>());
}
SECTION("double") {
_object.set("hello", 123.45);
obj.set("hello", 123.45);
REQUIRE(123.45 == _object["hello"].as<double>());
REQUIRE(_object["hello"].is<double>());
REQUIRE_FALSE(_object["hello"].is<bool>());
REQUIRE(123.45 == obj["hello"].as<double>());
REQUIRE(obj["hello"].is<double>());
REQUIRE_FALSE(obj["hello"].is<bool>());
}
SECTION("bool") {
_object.set("hello", true);
obj.set("hello", true);
REQUIRE(_object["hello"].as<bool>());
REQUIRE(_object["hello"].is<bool>());
REQUIRE_FALSE(_object["hello"].is<long>());
REQUIRE(obj["hello"].as<bool>());
REQUIRE(obj["hello"].is<bool>());
REQUIRE_FALSE(obj["hello"].is<long>());
}
SECTION("const char*") {
_object.set("hello", "h3110");
obj.set("hello", "h3110");
REQUIRE(std::string("h3110") == _object["hello"].as<const char*>());
REQUIRE(_object["hello"].is<const char*>());
REQUIRE_FALSE(_object["hello"].is<long>());
REQUIRE(std::string("h3110") == obj["hello"].as<const char*>());
REQUIRE(obj["hello"].is<const char*>());
REQUIRE_FALSE(obj["hello"].is<long>());
}
SECTION("nested array") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
_object.set("hello", arr);
obj.set("hello", arr);
REQUIRE(&arr == &_object["hello"].as<JsonArray>());
REQUIRE(_object["hello"].is<JsonArray&>());
REQUIRE_FALSE(_object["hello"].is<JsonObject&>());
REQUIRE(&arr == &obj["hello"].as<JsonArray>());
REQUIRE(obj["hello"].is<JsonArray&>());
REQUIRE_FALSE(obj["hello"].is<JsonObject&>());
}
SECTION("nested object") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
_object.set("hello", obj);
obj.set("hello", obj2);
REQUIRE(&obj == &_object["hello"].as<JsonObject>());
REQUIRE(_object["hello"].is<JsonObject&>());
REQUIRE_FALSE(_object["hello"].is<JsonArray&>());
REQUIRE(&obj2 == &obj["hello"].as<JsonObject>());
REQUIRE(obj["hello"].is<JsonObject&>());
REQUIRE_FALSE(obj["hello"].is<JsonArray&>());
}
SECTION("array subscript") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
arr.add(42);
_object.set("a", arr[0]);
obj.set("a", arr[0]);
REQUIRE(42 == _object["a"]);
REQUIRE(42 == obj["a"]);
}
SECTION("object subscript") {
DynamicJsonObject obj;
obj.set("x", 42);
DynamicJsonDocument doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
obj2.set("x", 42);
_object.set("a", obj["x"]);
obj.set("a", obj2["x"]);
REQUIRE(42 == _object["a"]);
REQUIRE(42 == obj["a"]);
}
SECTION("returns true when allocation succeeds") {
StaticJsonObject<JSON_OBJECT_SIZE(1) + 15> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1) + 15> doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
REQUIRE(true == obj.set(std::string("hello"), std::string("world")));
REQUIRE(true == obj2.set(std::string("hello"), std::string("world")));
}
SECTION("returns false when allocation fails") {
StaticJsonObject<JSON_OBJECT_SIZE(1) + 10> obj;
StaticJsonDocument<JSON_OBJECT_SIZE(1) + 10> doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
REQUIRE(false == obj.set(std::string("hello"), std::string("world")));
REQUIRE(false == obj2.set(std::string("hello"), std::string("world")));
}
SECTION("should not duplicate const char*") {
_object.set("hello", "world");
obj.set("hello", "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1);
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* value") {
_object.set("hello", const_cast<char*>("world"));
obj.set("hello", const_cast<char*>("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key") {
_object.set(const_cast<char*>("hello"), "world");
obj.set(const_cast<char*>("hello"), "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key&value") {
_object.set(const_cast<char*>("hello"), const_cast<char*>("world"));
obj.set(const_cast<char*>("hello"), const_cast<char*>("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 12;
REQUIRE(expectedSize <= _object.memoryUsage());
REQUIRE(expectedSize <= doc.memoryUsage());
}
SECTION("should duplicate std::string value") {
_object.set("hello", std::string("world"));
obj.set("hello", std::string("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key") {
_object.set(std::string("hello"), "world");
obj.set(std::string("hello"), "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key&value") {
_object.set(std::string("hello"), std::string("world"));
obj.set(std::string("hello"), std::string("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 12;
REQUIRE(expectedSize <= _object.memoryUsage());
REQUIRE(expectedSize <= doc.memoryUsage());
}
}

17
test/JsonObject/size.cpp
View File

@ -7,16 +7,21 @@
#include <string>
TEST_CASE("JsonObject::size()") {
DynamicJsonObject _object;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("initial size is zero") {
REQUIRE(0 == obj.size());
}
SECTION("increases when values are added") {
_object.set("hello", 42);
REQUIRE(1 == _object.size());
obj.set("hello", 42);
REQUIRE(1 == obj.size());
}
SECTION("doesn't increase when the smae key is added twice") {
_object["hello"] = 1;
_object["hello"] = 2;
REQUIRE(1 == _object.size());
obj["hello"] = 1;
obj["hello"] = 2;
REQUIRE(1 == obj.size());
}
}

140
test/JsonObject/subscript.cpp
View File

@ -6,146 +6,150 @@
#include <catch.hpp>
TEST_CASE("JsonObject::operator[]") {
DynamicJsonObject _object;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
SECTION("int") {
_object["hello"] = 123;
obj["hello"] = 123;
REQUIRE(123 == _object["hello"].as<int>());
REQUIRE(true == _object["hello"].is<int>());
REQUIRE(false == _object["hello"].is<bool>());
REQUIRE(123 == obj["hello"].as<int>());
REQUIRE(true == obj["hello"].is<int>());
REQUIRE(false == obj["hello"].is<bool>());
}
SECTION("volatile int") { // issue #415
volatile int i = 123;
_object["hello"] = i;
obj["hello"] = i;
REQUIRE(123 == _object["hello"].as<int>());
REQUIRE(true == _object["hello"].is<int>());
REQUIRE(false == _object["hello"].is<bool>());
REQUIRE(123 == obj["hello"].as<int>());
REQUIRE(true == obj["hello"].is<int>());
REQUIRE(false == obj["hello"].is<bool>());
}
SECTION("double") {
_object["hello"] = 123.45;
obj["hello"] = 123.45;
REQUIRE(true == _object["hello"].is<double>());
REQUIRE(false == _object["hello"].is<long>());
REQUIRE(123.45 == _object["hello"].as<double>());
REQUIRE(true == obj["hello"].is<double>());
REQUIRE(false == obj["hello"].is<long>());
REQUIRE(123.45 == obj["hello"].as<double>());
}
SECTION("bool") {
_object["hello"] = true;
obj["hello"] = true;
REQUIRE(true == _object["hello"].is<bool>());
REQUIRE(false == _object["hello"].is<long>());
REQUIRE(true == _object["hello"].as<bool>());
REQUIRE(true == obj["hello"].is<bool>());
REQUIRE(false == obj["hello"].is<long>());
REQUIRE(true == obj["hello"].as<bool>());
}
SECTION("const char*") {
_object["hello"] = "h3110";
obj["hello"] = "h3110";
REQUIRE(true == _object["hello"].is<const char*>());
REQUIRE(false == _object["hello"].is<long>());
REQUIRE(std::string("h3110") == _object["hello"].as<const char*>());
REQUIRE(std::string("h3110") ==
_object["hello"].as<char*>()); // <- short hand
REQUIRE(true == obj["hello"].is<const char*>());
REQUIRE(false == obj["hello"].is<long>());
REQUIRE(std::string("h3110") == obj["hello"].as<const char*>());
REQUIRE(std::string("h3110") == obj["hello"].as<char*>()); // <- short hand
}
SECTION("array") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
_object["hello"] = arr;
obj["hello"] = arr;
REQUIRE(&arr == &_object["hello"].as<JsonArray&>());
REQUIRE(&arr == &_object["hello"].as<JsonArray>()); // <- short hand
REQUIRE(&arr == &_object["hello"].as<const JsonArray&>());
REQUIRE(&arr == &_object["hello"].as<const JsonArray>()); // <- short hand
REQUIRE(true == _object["hello"].is<JsonArray&>());
REQUIRE(true == _object["hello"].is<JsonArray>());
REQUIRE(true == _object["hello"].is<const JsonArray&>());
REQUIRE(true == _object["hello"].is<const JsonArray>());
REQUIRE(false == _object["hello"].is<JsonObject&>());
REQUIRE(&arr == &obj["hello"].as<JsonArray&>());
REQUIRE(&arr == &obj["hello"].as<JsonArray>()); // <- short hand
REQUIRE(&arr == &obj["hello"].as<const JsonArray&>());
REQUIRE(&arr == &obj["hello"].as<const JsonArray>()); // <- short hand
REQUIRE(true == obj["hello"].is<JsonArray&>());
REQUIRE(true == obj["hello"].is<JsonArray>());
REQUIRE(true == obj["hello"].is<const JsonArray&>());
REQUIRE(true == obj["hello"].is<const JsonArray>());
REQUIRE(false == obj["hello"].is<JsonObject&>());
}
SECTION("object") {
DynamicJsonObject obj;
DynamicJsonDocument doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
_object["hello"] = obj;
obj["hello"] = obj2;
REQUIRE(&obj == &_object["hello"].as<JsonObject&>());
REQUIRE(&obj == &_object["hello"].as<JsonObject>()); // <- short hand
REQUIRE(&obj == &_object["hello"].as<const JsonObject&>());
REQUIRE(&obj == &_object["hello"].as<const JsonObject>()); // <- short hand
REQUIRE(true == _object["hello"].is<JsonObject&>());
REQUIRE(true == _object["hello"].is<JsonObject>());
REQUIRE(true == _object["hello"].is<const JsonObject&>());
REQUIRE(true == _object["hello"].is<const JsonObject>());
REQUIRE(false == _object["hello"].is<JsonArray&>());
REQUIRE(&obj2 == &obj["hello"].as<JsonObject&>());
REQUIRE(&obj2 == &obj["hello"].as<JsonObject>()); // <- short hand
REQUIRE(&obj2 == &obj["hello"].as<const JsonObject&>());
REQUIRE(&obj2 == &obj["hello"].as<const JsonObject>()); // <- short hand
REQUIRE(true == obj["hello"].is<JsonObject&>());
REQUIRE(true == obj["hello"].is<JsonObject>());
REQUIRE(true == obj["hello"].is<const JsonObject&>());
REQUIRE(true == obj["hello"].is<const JsonObject>());
REQUIRE(false == obj["hello"].is<JsonArray&>());
}
SECTION("array subscript") {
DynamicJsonArray arr;
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
arr.add(42);
_object["a"] = arr[0];
obj["a"] = arr[0];
REQUIRE(42 == _object["a"]);
REQUIRE(42 == obj["a"]);
}
SECTION("object subscript") {
DynamicJsonObject obj;
obj.set("x", 42);
DynamicJsonDocument doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
obj2.set("x", 42);
_object["a"] = obj["x"];
obj["a"] = obj2["x"];
REQUIRE(42 == _object["a"]);
REQUIRE(42 == obj["a"]);
}
SECTION("char key[]") { // issue #423
char key[] = "hello";
_object[key] = 42;
REQUIRE(42 == _object[key]);
obj[key] = 42;
REQUIRE(42 == obj[key]);
}
SECTION("should not duplicate const char*") {
_object["hello"] = "world";
obj["hello"] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1);
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* value") {
_object["hello"] = const_cast<char*>("world");
obj["hello"] = const_cast<char*>("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key") {
_object[const_cast<char*>("hello")] = "world";
obj[const_cast<char*>("hello")] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key&value") {
_object[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) + 12;
REQUIRE(expectedSize <= _object.memoryUsage());
REQUIRE(expectedSize <= doc.memoryUsage());
}
SECTION("should duplicate std::string value") {
_object["hello"] = std::string("world");
obj["hello"] = std::string("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key") {
_object[std::string("hello")] = "world";
obj[std::string("hello")] = "world";
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == _object.memoryUsage());
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key&value") {
_object[std::string("hello")] = std::string("world");
obj[std::string("hello")] = std::string("world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 12;
REQUIRE(expectedSize <= _object.memoryUsage());
REQUIRE(expectedSize <= doc.memoryUsage());
}
}

17
test/JsonParser/CMakeLists.txt
View File

@ -1,17 +0,0 @@
# ArduinoJson - arduinojson.org
# Copyright Benoit Blanchon 2014-2018
# MIT License
add_executable(JsonParserTests
DynamicJsonArray.cpp
DynamicJsonObject.cpp
DynamicJsonVariant.cpp
JsonError.cpp
nestingLimit.cpp
StaticJsonArray.cpp
StaticJsonObject.cpp
StaticJsonVariant.cpp
)
target_link_libraries(JsonParserTests catch)
add_test(JsonParser JsonParserTests)

98
test/JsonParser/DynamicJsonVariant.cpp
View File

@ -1,98 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace Catch::Matchers;
TEST_CASE("deserializeJson(DynamicJsonVariant&)") {
DynamicJsonVariant variant;
SECTION("EmptyObject") {
JsonError err = deserializeJson(variant, "{}");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<JsonObject>());
}
SECTION("EmptyArray") {
JsonError err = deserializeJson(variant, "[]");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<JsonArray>());
}
SECTION("Integer") {
JsonError err = deserializeJson(variant, "-42");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<int>());
REQUIRE_FALSE(variant.is<bool>());
REQUIRE(variant == -42);
}
SECTION("Double") {
JsonError err = deserializeJson(variant, "-1.23e+4");
REQUIRE(err == JsonError::Ok);
REQUIRE_FALSE(variant.is<int>());
REQUIRE(variant.is<double>());
REQUIRE(variant.as<double>() == Approx(-1.23e+4));
}
SECTION("Double quoted string") {
JsonError err = deserializeJson(variant, "\"hello world\"");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<char*>());
REQUIRE_THAT(variant.as<char*>(), Equals("hello world"));
}
SECTION("Single quoted string") {
JsonError err = deserializeJson(variant, "\'hello world\'");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<char*>());
REQUIRE_THAT(variant.as<char*>(), Equals("hello world"));
}
SECTION("True") {
JsonError err = deserializeJson(variant, "true");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<bool>());
REQUIRE(variant == true);
}
SECTION("False") {
JsonError err = deserializeJson(variant, "false");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<bool>());
REQUIRE(variant == false);
}
SECTION("OpenBrace") {
JsonError err = deserializeJson(variant, "{");
REQUIRE(err != JsonError::Ok);
}
SECTION("Incomplete string") {
JsonError err = deserializeJson(variant, "\"hello");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<char*>());
REQUIRE_THAT(variant.as<char*>(), Equals("hello"));
}
SECTION("Should clear the JsonVariant") {
deserializeJson(variant, "[1,2,3]");
deserializeJson(variant, "{}");
REQUIRE(variant.is<JsonObject>());
REQUIRE(variant.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

90
test/JsonParser/StaticJsonArray.cpp
View File

@ -1,90 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserializeJson(StaticJsonArray&)") {
SECTION("BufferOfTheRightSizeForEmptyArray") {
StaticJsonArray<JSON_ARRAY_SIZE(0)> arr;
char input[] = "[]";
JsonError err = deserializeJson(arr, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForArrayWithOneValue") {
StaticJsonArray<JSON_ARRAY_SIZE(1) - 1> arr;
char input[] = "[1]";
JsonError err = deserializeJson(arr, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForArrayWithOneValue") {
StaticJsonArray<JSON_ARRAY_SIZE(1)> arr;
char input[] = "[1]";
JsonError err = deserializeJson(arr, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("TooSmallBufferForArrayWithNestedObject") {
StaticJsonArray<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0) - 1> arr;
char input[] = "[{}]";
JsonError err = deserializeJson(arr, input);
REQUIRE(err != JsonError::Ok);
}
SECTION("BufferOfTheRightSizeForArrayWithNestedObject") {
StaticJsonArray<JSON_ARRAY_SIZE(1) + JSON_OBJECT_SIZE(0)> arr;
char input[] = "[{}]";
JsonError err = deserializeJson(arr, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("CharPtrNull") {
StaticJsonArray<100> arr;
JsonError err = deserializeJson(arr, static_cast<char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("ConstCharPtrNull") {
StaticJsonArray<100> arr;
JsonError err = deserializeJson(arr, static_cast<const char*>(0));
REQUIRE(err != JsonError::Ok);
}
SECTION("CopyStringNotSpaces") {
StaticJsonArray<100> arr;
deserializeJson(arr, " [ \"1234567\" ] ");
REQUIRE(JSON_ARRAY_SIZE(1) + sizeof("1234567") == arr.memoryUsage());
// note: we use a string of 8 bytes to be sure that the StaticJsonBuffer
// will not insert bytes to enforce alignement
}
SECTION("Should clear the JsonArray") {
StaticJsonArray<JSON_ARRAY_SIZE(4)> arr;
char input[] = "[1,2,3,4]";
deserializeJson(arr, input);
deserializeJson(arr, "[]");
REQUIRE(arr.size() == 0);
REQUIRE(arr.memoryUsage() == JSON_ARRAY_SIZE(0));
}
}

35
test/JsonParser/StaticJsonVariant.cpp
View File

@ -1,35 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace Catch::Matchers;
TEST_CASE("deserializeJson(StaticJsonVariant&)") {
SECTION("Array") {
StaticJsonVariant<JSON_ARRAY_SIZE(2)> variant;
char input[] = "[1,2]";
JsonError err = deserializeJson(variant, input);
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<JsonArray>());
REQUIRE(variant[0] == 1);
REQUIRE(variant[1] == 2);
REQUIRE(variant.memoryUsage() == JSON_ARRAY_SIZE(2));
}
SECTION("Should clear the JsonVariant") {
StaticJsonVariant<JSON_ARRAY_SIZE(2)> variant;
char input[] = "[1,2]";
deserializeJson(variant, input);
JsonError err = deserializeJson(variant, "{}");
REQUIRE(err == JsonError::Ok);
REQUIRE(variant.is<JsonObject>());
REQUIRE(variant.memoryUsage() == JSON_OBJECT_SIZE(0));
}
}

70
test/JsonParser/nestingLimit.cpp
View File

@ -1,70 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
#define SHOULD_WORK(expression) REQUIRE(JsonError::Ok == expression);
#define SHOULD_FAIL(expression) REQUIRE(JsonError::TooDeep == expression);
TEST_CASE("JsonParser nestingLimit") {
SECTION("deserializeJson(JsonArray&)") {
DynamicJsonArray arr;
SECTION("limit = 0") {
SHOULD_FAIL(deserializeJson(arr, "[]", 0));
}
SECTION("limit = 1") {
SHOULD_WORK(deserializeJson(arr, "[]", 1));
SHOULD_FAIL(deserializeJson(arr, "[[]]", 1));
}
SECTION("limit = 2") {
SHOULD_WORK(deserializeJson(arr, "[[]]", 2));
SHOULD_FAIL(deserializeJson(arr, "[[[]]]", 2));
}
}
SECTION("deserializeJson(JsonObject&)") {
DynamicJsonObject obj;
SECTION("limit = 0") {
SHOULD_FAIL(deserializeJson(obj, "{}", 0));
}
SECTION("limit = 1") {
SHOULD_WORK(deserializeJson(obj, "{\"key\":42}", 1));
SHOULD_FAIL(deserializeJson(obj, "{\"key\":{\"key\":42}}", 1));
}
SECTION("limit = 2") {
SHOULD_WORK(deserializeJson(obj, "{\"key\":{\"key\":42}}", 2));
SHOULD_FAIL(deserializeJson(obj, "{\"key\":{\"key\":{\"key\":42}}}", 2));
}
}
SECTION("deserializeJson(JsonVariant&)") {
DynamicJsonVariant var;
SECTION("limit = 0") {
SHOULD_WORK(deserializeJson(var, "\"toto\"", 0));
SHOULD_WORK(deserializeJson(var, "123", 0));
SHOULD_WORK(deserializeJson(var, "true", 0));
SHOULD_FAIL(deserializeJson(var, "[]", 0));
SHOULD_FAIL(deserializeJson(var, "{}", 0));
SHOULD_FAIL(deserializeJson(var, "[\"toto\"]", 0));
SHOULD_FAIL(deserializeJson(var, "{\"toto\":1}", 0));
}
SECTION("limit = 1") {
SHOULD_WORK(deserializeJson(var, "[\"toto\"]", 1));
SHOULD_WORK(deserializeJson(var, "{\"toto\":1}", 1));
SHOULD_FAIL(deserializeJson(var, "{\"toto\":{}}", 1));
SHOULD_FAIL(deserializeJson(var, "{\"toto\":[]}", 1));
SHOULD_FAIL(deserializeJson(var, "[[\"toto\"]]", 1));
SHOULD_FAIL(deserializeJson(var, "[{\"toto\":1}]", 1));
}
}
}

3
test/JsonSerializer/JsonArray.cpp
View File

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

3
test/JsonSerializer/JsonArrayPretty.cpp
View File

@ -15,7 +15,8 @@ static void check(JsonArray& array, std::string expected) {
}
TEST_CASE("serializeJsonPretty(JsonArray)") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
SECTION("Empty") {
check(array, "[]");

18
test/JsonSerializer/JsonObject.cpp
View File

@ -17,7 +17,8 @@ void check(const JsonObject &obj, const std::string &expected) {
}
TEST_CASE("serializeJson(JsonObject)") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject &obj = doc.to<JsonObject>();
SECTION("EmptyObject") {
check(obj, "{}");
@ -92,22 +93,23 @@ TEST_CASE("serializeJson(JsonObject)") {
}
SECTION("ThreeNestedArrays") {
DynamicJsonArray b, c;
DynamicJsonDocument b;
DynamicJsonDocument c;
obj.createNestedArray("a");
obj["b"] = b;
obj.set("c", c);
obj["b"] = b.to<JsonArray>();
obj.set("c", c.to<JsonArray>());
check(obj, "{\"a\":[],\"b\":[],\"c\":[]}");
}
SECTION("ThreeNestedObjects") {
DynamicJsonObject b;
DynamicJsonObject c;
DynamicJsonDocument b;
DynamicJsonDocument c;
obj.createNestedObject("a");
obj["b"] = b;
obj.set("c", c);
obj["b"] = b.to<JsonObject>();
obj.set("c", c.to<JsonObject>());
check(obj, "{\"a\":{},\"b\":{},\"c\":{}}");
}

3
test/JsonSerializer/JsonObjectPretty.cpp
View File

@ -18,7 +18,8 @@ void check(const JsonObject &obj, const std::string expected) {
}
TEST_CASE("serializeJsonPretty(JsonObject)") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject &obj = doc.to<JsonObject>();
SECTION("EmptyObject") {
check(obj, "{}");

12
test/JsonVariant/as.cpp
View File

@ -192,7 +192,8 @@ TEST_CASE("JsonVariant::as()") {
}
SECTION("ObjectAsString") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["key"] = "value";
@ -201,7 +202,8 @@ TEST_CASE("JsonVariant::as()") {
}
SECTION("ArrayAsString") {
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(4);
arr.add(2);
@ -210,7 +212,8 @@ TEST_CASE("JsonVariant::as()") {
}
SECTION("ArrayAsJsonArray") {
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
JsonVariant variant = arr;
REQUIRE(&arr == &variant.as<JsonArray&>());
@ -218,7 +221,8 @@ TEST_CASE("JsonVariant::as()") {
}
SECTION("ObjectAsJsonObject") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
JsonVariant variant = obj;
REQUIRE(&obj == &variant.as<JsonObject&>());

26
test/JsonVariant/compare.cpp
View File

@ -97,8 +97,9 @@ TEST_CASE("JsonVariant comparisons") {
}
SECTION("StringLiteral") {
DynamicJsonVariant variant;
deserializeJson(variant, "\"hello\"");
DynamicJsonDocument doc;
deserializeJson(doc, "\"hello\"");
JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(variant == "hello");
REQUIRE_FALSE(variant != "hello");
@ -114,8 +115,7 @@ TEST_CASE("JsonVariant comparisons") {
}
SECTION("String") {
DynamicJsonVariant variant;
deserializeJson(variant, "\"hello\"");
JsonVariant variant = "hello";
REQUIRE(variant == std::string("hello"));
REQUIRE_FALSE(variant != std::string("hello"));
@ -179,7 +179,10 @@ TEST_CASE("JsonVariant comparisons") {
}
SECTION("ArrayInVariant") {
DynamicJsonArray array1, array2;
DynamicJsonDocument doc1;
JsonArray& array1 = doc1.to<JsonArray>();
DynamicJsonDocument doc2;
JsonArray& array2 = doc2.to<JsonArray>();
JsonVariant variant1 = array1;
JsonVariant variant2 = array1;
@ -193,8 +196,10 @@ TEST_CASE("JsonVariant comparisons") {
}
SECTION("ObjectInVariant") {
DynamicJsonObject obj1;
DynamicJsonObject obj2;
DynamicJsonDocument doc1;
JsonObject& obj1 = doc1.to<JsonObject>();
DynamicJsonDocument doc2;
JsonObject& obj2 = doc2.to<JsonObject>();
JsonVariant variant1 = obj1;
JsonVariant variant2 = obj1;
@ -208,8 +213,11 @@ TEST_CASE("JsonVariant comparisons") {
}
SECTION("VariantsOfDifferentTypes") {
DynamicJsonObject obj;
DynamicJsonArray arr;
DynamicJsonDocument doc1;
JsonObject& obj = doc1.to<JsonObject>();
DynamicJsonDocument doc2;
JsonArray& arr = doc2.to<JsonArray>();
JsonVariant variants[] = {
true, 42, 666.667, "hello", arr, obj,
};

8
test/JsonVariant/copy.cpp
View File

@ -38,11 +38,12 @@ TEST_CASE("JsonVariant copy") {
_variant2 = _variant1;
_variant1 = "world";
REQUIRE(std::string("hello") == _variant2.as<const char *>());
REQUIRE(std::string("hello") == _variant2.as<const char*>());
}
SECTION("ObjectsAreCopiedByReference") {
DynamicJsonObject object;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
_variant1 = object;
@ -52,7 +53,8 @@ TEST_CASE("JsonVariant copy") {
}
SECTION("ArraysAreCopiedByReference") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
_variant1 = array;

5
test/JsonVariant/is.cpp
View File

@ -69,10 +69,9 @@ void checkIsString(JsonVariant var) {
}
TEST_CASE("JsonVariant::is()") {
DynamicJsonBuffer jsonBuffer;
SECTION("JsonArray") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
checkIsArray(array);
}

3
test/JsonVariant/set_get.cpp
View File

@ -122,7 +122,8 @@ TEST_CASE("JsonVariant set()/get()") {
#endif
SECTION("CanStoreObject") {
DynamicJsonObject object;
DynamicJsonDocument doc;
JsonObject &object = doc.to<JsonObject>();
checkReference<JsonObject>(object);
}

20
test/JsonVariant/subscript.cpp
View File

@ -7,7 +7,8 @@
TEST_CASE("JsonVariant::operator[]") {
SECTION("Array") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
array.add("element at index 0");
array.add("element at index 1");
@ -24,7 +25,8 @@ TEST_CASE("JsonVariant::operator[]") {
}
SECTION("Object") {
DynamicJsonObject object;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
object["a"] = "element at key \"a\"";
object["b"] = "element at key \"b\"";
@ -52,7 +54,8 @@ TEST_CASE("JsonVariant::operator[]") {
}
SECTION("ObjectSetValue") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
JsonVariant var = obj;
var["hello"] = "world";
REQUIRE(1 == var.size());
@ -60,16 +63,19 @@ TEST_CASE("JsonVariant::operator[]") {
}
SECTION("ArraySetValue") {
DynamicJsonVariant var;
deserializeJson(var, "[\"hello\"]");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
JsonVariant var = arr;
var[0] = "world";
REQUIRE(1 == var.size());
REQUIRE(std::string("world") == var[0]);
}
SECTION("NestedObjectSetValue") {
DynamicJsonVariant var;
deserializeJson(var, "[{}]");
DynamicJsonDocument doc;
deserializeJson(doc, "[{}]");
JsonVariant var = doc.as<JsonVariant>();
var[0]["hello"] = "world";
REQUIRE(1 == var.size());
REQUIRE(1 == var[0].size());

6
test/JsonVariant/success.cpp
View File

@ -17,14 +17,16 @@ TEST_CASE("JsonVariant::success()") {
}
SECTION("ReturnsTrue_WhenEmptyArray") {
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
JsonVariant variant = array;
REQUIRE(true == variant.success());
}
SECTION("ReturnsTrue_WhenEmptyObject") {
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
JsonVariant variant = obj;
REQUIRE(true == variant.success());

26
test/Misc/std_stream.cpp
View File

@ -23,7 +23,8 @@ TEST_CASE("std::stream") {
SECTION("JsonObject") {
std::ostringstream os;
DynamicJsonObject object;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
object["key"] = "value";
os << object;
REQUIRE("{\"key\":\"value\"}" == os.str());
@ -31,7 +32,8 @@ TEST_CASE("std::stream") {
SECTION("JsonObjectSubscript") {
std::ostringstream os;
DynamicJsonObject object;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
object["key"] = "value";
os << object["key"];
REQUIRE("\"value\"" == os.str());
@ -39,7 +41,8 @@ TEST_CASE("std::stream") {
SECTION("JsonArray") {
std::ostringstream os;
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
array.add("value");
os << array;
REQUIRE("[\"value\"]" == os.str());
@ -47,7 +50,8 @@ TEST_CASE("std::stream") {
SECTION("JsonArraySubscript") {
std::ostringstream os;
DynamicJsonArray array;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
array.add("value");
os << array[0];
REQUIRE("\"value\"" == os.str());
@ -55,8 +59,9 @@ TEST_CASE("std::stream") {
SECTION("ParseArray") {
std::istringstream json(" [ 42 /* comment */ ] ");
DynamicJsonArray arr;
JsonError err = deserializeJson(arr, json);
DynamicJsonDocument doc;
JsonError err = deserializeJson(doc, json);
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
@ -65,8 +70,9 @@ TEST_CASE("std::stream") {
SECTION("ParseObject") {
std::istringstream json(" { hello : world // comment\n }");
DynamicJsonObject obj;
JsonError err = deserializeJson(obj, json);
DynamicJsonDocument doc;
JsonError err = deserializeJson(doc, json);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == obj.size());
@ -75,8 +81,8 @@ TEST_CASE("std::stream") {
SECTION("ShouldNotReadPastTheEnd") {
std::istringstream json("{}123");
DynamicJsonObject obj;
deserializeJson(obj, json);
DynamicJsonDocument doc;
deserializeJson(doc, json);
REQUIRE('1' == json.get());
}
}

149
test/Misc/std_string.cpp
View File

@ -11,20 +11,21 @@ static void eraseString(std::string &str) {
}
TEST_CASE("std::string") {
DynamicJsonBuffer jb;
SECTION("deserializeJson duplicates content") {
std::string json("[\"hello\"]");
DynamicJsonDocument doc;
JsonError err = deserializeJson(doc, json);
eraseString(json);
JsonArray &array = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(std::string("hello") == array[0]);
}
SECTION("JsonArray") {
DynamicJsonArray array;
SECTION("deserializeJson") {
std::string json("[\"hello\"]");
JsonError err = deserializeJson(array, json);
eraseString(json);
REQUIRE(err == JsonError::Ok);
REQUIRE(std::string("hello") == array[0]);
}
DynamicJsonDocument doc;
JsonArray &array = doc.to<JsonArray>();
SECTION("add()") {
std::string value("hello");
@ -67,168 +68,190 @@ TEST_CASE("std::string") {
}
SECTION("JsonObject") {
DynamicJsonObject object;
DynamicJsonDocument doc;
SECTION("deserializeJson()") {
std::string json("{\"hello\":\"world\"}");
JsonError err = deserializeJson(object, json);
JsonError err = deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
eraseString(json);
REQUIRE(err == JsonError::Ok);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("operator[]") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(std::string("value") == object[std::string("key")]);
REQUIRE(std::string("value") == obj[std::string("key")]);
}
SECTION("operator[] const") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
const JsonObject &obj = object;
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(std::string("value") == obj[std::string("key")]);
}
SECTION("set(key)") {
JsonObject &obj = doc.to<JsonObject>();
std::string key("hello");
object.set(key, "world");
obj.set(key, "world");
eraseString(key);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(value)") {
JsonObject &obj = doc.to<JsonObject>();
std::string value("world");
object.set("hello", value);
obj.set("hello", value);
eraseString(value);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(key,value)") {
JsonObject &obj = doc.to<JsonObject>();
std::string key("hello");
std::string value("world");
object.set(key, value);
obj.set(key, value);
eraseString(key);
eraseString(value);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(JsonArraySubscript)") {
DynamicJsonArray arr;
JsonObject &obj = doc.to<JsonObject>();
DynamicJsonDocument doc2;
JsonArray &arr = doc2.to<JsonArray>();
arr.add("world");
object.set(std::string("hello"), arr[0]);
obj.set(std::string("hello"), arr[0]);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(JsonObjectSubscript)") {
DynamicJsonObject obj;
obj.set("x", "world");
JsonObject &obj = doc.to<JsonObject>();
DynamicJsonDocument doc2;
JsonObject &obj2 = doc2.to<JsonObject>();
obj2.set("x", "world");
object.set(std::string("hello"), obj["x"]);
obj.set(std::string("hello"), obj2["x"]);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("get<T>()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(std::string("value") ==
object.get<const char *>(std::string("key")));
obj.get<const char *>(std::string("key")));
}
SECTION("is<T>()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
REQUIRE(true == object.is<const char *>(std::string("key")));
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<const char *>(std::string("key")));
}
SECTION("createNestedObject()") {
JsonObject &obj = doc.to<JsonObject>();
std::string key = "key";
char json[64];
object.createNestedObject(key);
obj.createNestedObject(key);
eraseString(key);
serializeJson(object, json, sizeof(json));
serializeJson(doc, json, sizeof(json));
REQUIRE(std::string("{\"key\":{}}") == json);
}
SECTION("createNestedArray()") {
JsonObject &obj = doc.to<JsonObject>();
std::string key = "key";
char json[64];
object.createNestedArray(key);
obj.createNestedArray(key);
eraseString(key);
serializeJson(object, json, sizeof(json));
serializeJson(doc, json, sizeof(json));
REQUIRE(std::string("{\"key\":[]}") == json);
}
SECTION("containsKey()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
REQUIRE(true == object.containsKey(std::string("key")));
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(std::string("key")));
}
SECTION("remove()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(object, json);
REQUIRE(1 == object.size());
object.remove(std::string("key"));
REQUIRE(0 == object.size());
JsonObject &obj = doc.to<JsonObject>();
obj["key"] = "value";
obj.remove(std::string("key"));
REQUIRE(0 == obj.size());
}
SECTION("operator[], set key") {
std::string key("hello");
object[key] = "world";
JsonObject &obj = doc.to<JsonObject>();
obj[key] = "world";
eraseString(key);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("operator[], set value") {
std::string value("world");
object["hello"] = value;
JsonObject &obj = doc.to<JsonObject>();
obj["hello"] = value;
eraseString(value);
REQUIRE(std::string("world") == object["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("serializeJson()") {
object["key"] = "value";
JsonObject &obj = doc.to<JsonObject>();
obj["key"] = "value";
std::string json;
serializeJson(object, json);
serializeJson(doc, json);
REQUIRE(std::string("{\"key\":\"value\"}") == json);
}
SECTION("serializeJsonPretty()") {
object["key"] = "value";
JsonObject &obj = doc.to<JsonObject>();
obj["key"] = "value";
std::string json;
serializeJsonPretty(object, json);
serializeJsonPretty(doc, json);
REQUIRE(std::string("{\r\n \"key\": \"value\"\r\n}") == json);
}
SECTION("memoryUsage() increases when adding a new key") {
std::string key1("hello"), key2("world");
JsonObject &obj = doc.to<JsonObject>();
object[key1] = 1;
size_t sizeBefore = object.memoryUsage();
object[key2] = 2;
size_t sizeAfter = object.memoryUsage();
obj[key1] = 1;
size_t sizeBefore = doc.memoryUsage();
obj[key2] = 2;
size_t sizeAfter = doc.memoryUsage();
REQUIRE(sizeAfter - sizeBefore >= key2.size());
}
SECTION("memoryUsage() remains when adding the same key") {
std::string key("hello");
JsonObject &obj = doc.to<JsonObject>();
object[key] = 1;
size_t sizeBefore = object.memoryUsage();
object[key] = 2;
size_t sizeAfter = object.memoryUsage();
obj[key] = 1;
size_t sizeBefore = doc.memoryUsage();
obj[key] = 2;
size_t sizeAfter = doc.memoryUsage();
REQUIRE(sizeBefore == sizeAfter);
}

85
test/Misc/unsigned_char.cpp
View File

@ -13,8 +13,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonBuffer::parseArray") {
unsigned char json[] = "[42]";
StaticJsonArray<JSON_ARRAY_SIZE(1)> arr;
JsonError err = deserializeJson(arr, json);
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
}
@ -22,8 +22,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonBuffer::parseObject") {
unsigned char json[] = "{\"a\":42}";
StaticJsonObject<JSON_OBJECT_SIZE(1)> obj;
JsonError err = deserializeJson(obj, json);
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
}
@ -49,8 +49,9 @@ TEST_CASE("unsigned char string") {
SECTION("JsonVariant::operator[]") {
unsigned char key[] = "hello";
DynamicJsonVariant variant;
deserializeJson(variant, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[key]);
}
@ -60,8 +61,9 @@ TEST_CASE("unsigned char string") {
SECTION("JsonVariant::operator[] const") {
unsigned char key[] = "hello";
DynamicJsonVariant variant;
deserializeJson(variant, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[key]);
}
@ -70,7 +72,7 @@ TEST_CASE("unsigned char string") {
SECTION("JsonVariant::operator==") {
unsigned char comparand[] = "hello";
DynamicJsonVariant variant;
JsonVariant variant;
variant = "hello";
REQUIRE(comparand == variant);
@ -82,7 +84,7 @@ TEST_CASE("unsigned char string") {
SECTION("JsonVariant::operator!=") {
unsigned char comparand[] = "hello";
DynamicJsonVariant variant;
JsonVariant variant;
variant = "world";
REQUIRE(comparand != variant);
@ -95,7 +97,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::operator[]") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[key] = "world";
REQUIRE(std::string("world") == obj["hello"]);
@ -105,7 +108,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObjectSubscript::operator=") { // issue #416
unsigned char value[] = "world";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = value;
REQUIRE(std::string("world") == obj["hello"]);
@ -114,7 +118,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObjectSubscript::set()") {
unsigned char value[] = "world";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(value);
REQUIRE(std::string("world") == obj["hello"]);
@ -124,9 +129,10 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::operator[] const") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[key]);
}
#endif
@ -134,16 +140,17 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::get()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(key));
}
SECTION("JsonObject::set() key") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, "world");
REQUIRE(std::string("world") == obj["hello"]);
@ -152,7 +159,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::set() value") {
unsigned char value[] = "world";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", value);
REQUIRE(std::string("world") == obj["hello"]);
@ -161,7 +169,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::set key&value") {
unsigned char key[] = "world";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, key);
REQUIRE(std::string("world") == obj["world"]);
@ -170,17 +179,18 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::containsKey()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(key));
}
SECTION("JsonObject::remove()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(key);
REQUIRE(0 == obj.size());
@ -189,8 +199,9 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::is()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":42}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(key));
}
@ -198,21 +209,24 @@ TEST_CASE("unsigned char string") {
SECTION("JsonObject::createNestedArray()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(key);
}
SECTION("JsonObject::createNestedObject()") {
unsigned char key[] = "hello";
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(key);
}
SECTION("JsonArray::add()") {
unsigned char value[] = "world";
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(value);
REQUIRE(std::string("world") == arr[0]);
@ -221,7 +235,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonArray::set()") {
unsigned char value[] = "world";
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, value);
@ -231,7 +246,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonArraySubscript::set()") {
unsigned char value[] = "world";
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(value);
@ -241,7 +257,8 @@ TEST_CASE("unsigned char string") {
SECTION("JsonArraySubscript::operator=") {
unsigned char value[] = "world";
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = value;

87
test/Misc/vla.cpp
View File

@ -22,8 +22,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "[42]");
StaticJsonArray<JSON_ARRAY_SIZE(1)> arr;
JsonError err = deserializeJson(arr, vla);
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
JsonError err = deserializeJson(doc, vla);
REQUIRE(err == JsonError::Ok);
}
@ -33,10 +33,10 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "{\"a\":42}");
StaticJsonObject<JSON_OBJECT_SIZE(1)> obj;
deserializeJson(obj, vla);
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
JsonError error = deserializeJson(doc, vla);
REQUIRE(true == obj.success());
REQUIRE(error == JsonError::Ok);
}
SECTION("Parse") {
@ -44,7 +44,7 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "42");
StaticJsonVariant<> variant;
StaticJsonDocument<> variant;
deserializeJson(variant, vla);
REQUIRE(42 == variant.as<int>());
@ -77,8 +77,9 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonVariant variant;
deserializeJson(variant, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[vla]);
}
@ -90,8 +91,9 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonVariant variant;
deserializeJson(variant, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[vla]);
}
@ -102,7 +104,7 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonVariant variant;
JsonVariant variant;
variant = "hello";
REQUIRE((vla == variant));
@ -116,7 +118,7 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonVariant variant;
JsonVariant variant;
variant = "world";
REQUIRE((vla != variant));
@ -131,7 +133,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[vla] = "world";
REQUIRE(std::string("world") == obj["hello"]);
@ -143,7 +146,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = vla;
REQUIRE(std::string("world") == obj["hello"].as<char*>());
@ -154,7 +158,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(vla);
REQUIRE(std::string("world") == obj["hello"].as<char*>());
@ -166,9 +171,10 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[vla]);
}
#endif
@ -178,9 +184,10 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(vla));
}
@ -189,7 +196,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, "world");
REQUIRE(std::string("world") == obj["hello"]);
@ -200,7 +208,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", vla);
REQUIRE(std::string("world") == obj["hello"]);
@ -211,7 +220,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, vla);
REQUIRE(std::string("world") == obj["world"]);
@ -222,9 +232,10 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(vla));
}
@ -233,8 +244,9 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(vla);
REQUIRE(0 == obj.size());
@ -245,8 +257,9 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
deserializeJson(obj, "{\"hello\":42}");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(vla));
}
@ -256,7 +269,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(vla);
}
@ -265,7 +279,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "hello");
DynamicJsonObject obj;
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(vla);
}
@ -274,7 +289,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(vla);
REQUIRE(std::string("world") == arr[0]);
@ -285,7 +301,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, vla);
@ -297,7 +314,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(vla);
@ -309,7 +327,8 @@ TEST_CASE("Variable Length Array") {
char vla[i];
strcpy(vla, "world");
DynamicJsonArray arr;
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = vla;

10
test/MsgPack/MsgPackError.cpp
View File

@ -24,8 +24,6 @@ TEST_CASE("MsgPackError") {
TEST_STRINGIFICATION(Ok);
TEST_STRINGIFICATION(NotSupported);
TEST_STRINGIFICATION(NoMemory);
TEST_STRINGIFICATION(NotAnArray);
TEST_STRINGIFICATION(NotAnObject);
TEST_STRINGIFICATION(TooDeep);
}
@ -33,8 +31,12 @@ TEST_CASE("MsgPackError") {
TEST_BOOLIFICATION(Ok, false);
TEST_BOOLIFICATION(NotSupported, true);
TEST_BOOLIFICATION(NoMemory, true);
TEST_BOOLIFICATION(NotAnArray, true);
TEST_BOOLIFICATION(NotAnObject, true);
TEST_BOOLIFICATION(TooDeep, true);
}
SECTION("ostream") {
std::stringstream s;
s << MsgPackError::NotSupported;
REQUIRE(s.str() == "NotSupported");
}
}

2
test/MsgPack/deserializationErrors.cpp
View File

@ -7,7 +7,7 @@
static void check(const char* input, MsgPackError expected,
uint8_t nestingLimit = 10) {
DynamicJsonVariant variant;
DynamicJsonDocument variant;
MsgPackError error = deserializeMsgPack(variant, input, nestingLimit);

28
test/MsgPack/deserializeArray.cpp
View File

@ -6,21 +6,14 @@
#include <catch.hpp>
TEST_CASE("deserializeMsgPack(JsonArray&)") {
DynamicJsonArray array;
SECTION("not an array") {
const char* input = "\xA0";
MsgPackError error = deserializeMsgPack(array, input);
REQUIRE(error == MsgPackError::NotAnArray);
}
DynamicJsonDocument doc;
SECTION("fixarray") {
SECTION("empty") {
const char* input = "\x90";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 0);
@ -29,7 +22,8 @@ TEST_CASE("deserializeMsgPack(JsonArray&)") {
SECTION("two integers") {
const char* input = "\x92\x01\x02";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 2);
@ -42,7 +36,8 @@ TEST_CASE("deserializeMsgPack(JsonArray&)") {
SECTION("empty") {
const char* input = "\xDC\x00\x00";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 0);
@ -51,7 +46,8 @@ TEST_CASE("deserializeMsgPack(JsonArray&)") {
SECTION("two strings") {
const char* input = "\xDC\x00\x02\xA5hello\xA5world";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 2);
@ -64,7 +60,8 @@ TEST_CASE("deserializeMsgPack(JsonArray&)") {
SECTION("empty") {
const char* input = "\xDD\x00\x00\x00\x00";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 0);
@ -74,7 +71,8 @@ TEST_CASE("deserializeMsgPack(JsonArray&)") {
const char* input =
"\xDD\x00\x00\x00\x02\xCA\x00\x00\x00\x00\xCA\x40\x48\xF5\xC3";
MsgPackError error = deserializeMsgPack(array, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonArray& array = doc.as<JsonArray>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(array.size() == 2);

60
test/MsgPack/deserializeObject.cpp
View File

@ -5,36 +5,32 @@
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("deserializeMsgPack(JsonObject&)") {
DynamicJsonObject object;
SECTION("not an object") {
const char* input = "\xA0";
MsgPackError error = deserializeMsgPack(object, input);
REQUIRE(error == MsgPackError::NotAnObject);
}
TEST_CASE("deserialize MsgPack object") {
DynamicJsonDocument doc;
SECTION("fixmap") {
SECTION("empty") {
const char* input = "\x80";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 0);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0);
}
SECTION("two integers") {
const char* input = "\x82\xA3one\x01\xA3two\x02";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 2);
REQUIRE(object["one"] == 1);
REQUIRE(object["two"] == 2);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["one"] == 1);
REQUIRE(obj["two"] == 2);
}
}
@ -42,21 +38,25 @@ TEST_CASE("deserializeMsgPack(JsonObject&)") {
SECTION("empty") {
const char* input = "\xDE\x00\x00";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 0);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0);
}
SECTION("two strings") {
const char* input = "\xDE\x00\x02\xA1H\xA5hello\xA1W\xA5world";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 2);
REQUIRE(object["H"] == "hello");
REQUIRE(object["W"] == "world");
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["H"] == "hello");
REQUIRE(obj["W"] == "world");
}
}
@ -64,10 +64,12 @@ TEST_CASE("deserializeMsgPack(JsonObject&)") {
SECTION("empty") {
const char* input = "\xDF\x00\x00\x00\x00";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 0);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 0);
}
SECTION("two floats") {
@ -75,12 +77,14 @@ TEST_CASE("deserializeMsgPack(JsonObject&)") {
"\xDF\x00\x00\x00\x02\xA4zero\xCA\x00\x00\x00\x00\xA2pi\xCA\x40\x48"
"\xF5\xC3";
MsgPackError error = deserializeMsgPack(object, input);
MsgPackError error = deserializeMsgPack(doc, input);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(error == MsgPackError::Ok);
REQUIRE(object.size() == 2);
REQUIRE(object["zero"] == 0.0f);
REQUIRE(object["pi"] == 3.14f);
REQUIRE(doc.is<JsonObject>());
REQUIRE(obj.size() == 2);
REQUIRE(obj["zero"] == 0.0f);
REQUIRE(obj["pi"] == 3.14f);
}
}
}

32
test/MsgPack/deserializeStaticVariant.cpp
View File

@ -9,14 +9,14 @@ static const size_t epsilon = sizeof(void*);
template <size_t Capacity>
static void check(const char* input, MsgPackError expected) {
StaticJsonVariant<Capacity> variant;
StaticJsonDocument<Capacity> variant;
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == expected);
}
TEST_CASE("deserializeMsgPack(StaticJsonVariant&)") {
TEST_CASE("deserializeMsgPack(StaticJsonDocument&)") {
SECTION("single values always fit") {
check<0>("\xc0", MsgPackError::Ok); // nil
check<0>("\xc2", MsgPackError::Ok); // false
@ -82,15 +82,14 @@ TEST_CASE("deserializeMsgPack(StaticJsonVariant&)") {
check<JSON_OBJECT_SIZE(0)>("\x80", MsgPackError::Ok);
}
SECTION("{H:1}") {
check<JSON_OBJECT_SIZE(0)>("\x81\xA1H\x01",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(0)>("\x81\xA1H\x01", MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(1) + epsilon>("\x81\xA1H\x01", MsgPackError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + epsilon>("\x82\xA1H\x01\xA1W\x02",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2*epsilon>("\x82\xA1H\x01\xA1W\x02",
MsgPackError::Ok);
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * epsilon>("\x82\xA1H\x01\xA1W\x02",
MsgPackError::Ok);
}
}
@ -101,13 +100,14 @@ TEST_CASE("deserializeMsgPack(StaticJsonVariant&)") {
SECTION("{H:1}") {
check<JSON_OBJECT_SIZE(0)>("\xDE\x00\x01\xA1H\x01",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(1) + epsilon>("\xDE\x00\x01\xA1H\x01", MsgPackError::Ok);
check<JSON_OBJECT_SIZE(1) + epsilon>("\xDE\x00\x01\xA1H\x01",
MsgPackError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + epsilon>("\xDE\x00\x02\xA1H\x01\xA1W\x02",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2*epsilon>("\xDE\x00\x02\xA1H\x01\xA1W\x02",
MsgPackError::Ok);
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * epsilon>("\xDE\x00\x02\xA1H\x01\xA1W\x02",
MsgPackError::Ok);
}
}
@ -119,13 +119,13 @@ TEST_CASE("deserializeMsgPack(StaticJsonVariant&)") {
check<JSON_OBJECT_SIZE(0)>("\xDF\x00\x00\x00\x01\xA1H\x01",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(1) + epsilon>("\xDF\x00\x00\x00\x01\xA1H\x01",
MsgPackError::Ok);
MsgPackError::Ok);
}
SECTION("{H:1,W:2}") {
check<JSON_OBJECT_SIZE(1) + epsilon>("\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2*epsilon>("\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02",
MsgPackError::Ok);
check<JSON_OBJECT_SIZE(1) + epsilon>(
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02", MsgPackError::NoMemory);
check<JSON_OBJECT_SIZE(2) + 2 * epsilon>(
"\xDF\x00\x00\x00\x02\xA1H\x01\xA1W\x02", MsgPackError::Ok);
}
}
}

149
test/MsgPack/deserializeVariant.cpp
View File

@ -7,7 +7,7 @@
template <typename T, typename U>
static void check(const char* input, U expected) {
DynamicJsonVariant variant;
DynamicJsonDocument variant;
MsgPackError error = deserializeMsgPack(variant, input);
@ -127,151 +127,4 @@ TEST_CASE("deserializeMsgPack(JsonVariant&)") {
SECTION("str 32") {
check<const char*>("\xdb\x00\x00\x00\x05hello", std::string("hello"));
}
SECTION("fixarray") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\x90";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two integers") {
const char* input = "\x92\x01\x02";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant[0] == 1);
REQUIRE(variant[1] == 2);
}
}
SECTION("array 16") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\xDC\x00\x00";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two strings") {
const char* input = "\xDC\x00\x02\xA5hello\xA5world";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant[0] == "hello");
REQUIRE(variant[1] == "world");
}
}
SECTION("array 32") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\xDD\x00\x00\x00\x00";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two floats") {
const char* input =
"\xDD\x00\x00\x00\x02\xCA\x00\x00\x00\x00\xCA\x40\x48\xF5\xC3";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant[0] == 0.0f);
REQUIRE(variant[1] == 3.14f);
}
}
SECTION("fixmap") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\x80";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two integers") {
const char* input = "\x82\xA3one\x01\xA3two\x02";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant["one"] == 1);
REQUIRE(variant["two"] == 2);
}
}
SECTION("map 16") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\xDE\x00\x00";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two strings") {
const char* input = "\xDE\x00\x02\xA1H\xA5hello\xA1W\xA5world";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant["H"] == "hello");
REQUIRE(variant["W"] == "world");
}
}
SECTION("map 32") {
DynamicJsonVariant variant;
SECTION("empty") {
const char* input = "\xDF\x00\x00\x00\x00";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 0);
}
SECTION("two floats") {
const char* input =
"\xDF\x00\x00\x00\x02\xA4zero\xCA\x00\x00\x00\x00\xA2pi\xCA\x40\x48"
"\xF5\xC3";
MsgPackError error = deserializeMsgPack(variant, input);
REQUIRE(error == MsgPackError::Ok);
REQUIRE(variant.size() == 2);
REQUIRE(variant["zero"] == 0.0f);
REQUIRE(variant["pi"] == 3.14f);
}
}
}

4
test/StaticJsonBuffer/alloc.cpp
View File

@ -2,9 +2,11 @@
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <ArduinoJson/Memory/StaticJsonBuffer.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
static bool isAligned(void *ptr) {
const size_t mask = sizeof(void *) - 1;
size_t addr = reinterpret_cast<size_t>(ptr);

4
test/StaticJsonBuffer/size.cpp
View File

@ -2,9 +2,11 @@
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <ArduinoJson/Memory/StaticJsonBuffer.hpp>
#include <catch.hpp>
using namespace ArduinoJson::Internals;
TEST_CASE("StaticJsonBuffer::size()") {
StaticJsonBuffer<64> buffer;