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

Added support for non zero-terminated strings (fixes #704)

Browse Source
This commit is contained in:
Benoit Blanchon
2018-05-14 17:12:59 +02:00
parent 4c9c047ddf
commit ccb54136a2
54 changed files with 2234 additions and 1401 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
test/Misc/CMakeLists.txt
View File

@ -2,10 +2,8 @@
# Copyright Benoit Blanchon 2014-2018
# MIT License
add_executable(MiscTests
add_executable(MiscTests
FloatParts.cpp
std_stream.cpp
std_string.cpp
StringBuilder.cpp
StringTraits.cpp
TypeTraits.cpp

88
test/Misc/std_stream.cpp
View File

@ -1,88 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
#include <sstream>
TEST_CASE("std::stream") {
SECTION("JsonVariantFalse") {
std::ostringstream os;
JsonVariant variant = false;
os << variant;
REQUIRE("false" == os.str());
}
SECTION("JsonVariantString") {
std::ostringstream os;
JsonVariant variant = "coucou";
os << variant;
REQUIRE("\"coucou\"" == os.str());
}
SECTION("JsonObject") {
std::ostringstream os;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
object["key"] = "value";
os << object;
REQUIRE("{\"key\":\"value\"}" == os.str());
}
SECTION("JsonObjectSubscript") {
std::ostringstream os;
DynamicJsonDocument doc;
JsonObject& object = doc.to<JsonObject>();
object["key"] = "value";
os << object["key"];
REQUIRE("\"value\"" == os.str());
}
SECTION("JsonArray") {
std::ostringstream os;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
array.add("value");
os << array;
REQUIRE("[\"value\"]" == os.str());
}
SECTION("JsonArraySubscript") {
std::ostringstream os;
DynamicJsonDocument doc;
JsonArray& array = doc.to<JsonArray>();
array.add("value");
os << array[0];
REQUIRE("\"value\"" == os.str());
}
SECTION("ParseArray") {
std::istringstream json(" [ 42 /* comment */ ] ");
DynamicJsonDocument doc;
JsonError err = deserializeJson(doc, json);
JsonArray& arr = doc.as<JsonArray>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == arr.size());
REQUIRE(42 == arr[0]);
}
SECTION("ParseObject") {
std::istringstream json(" { hello : world // comment\n }");
DynamicJsonDocument doc;
JsonError err = deserializeJson(doc, json);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(err == JsonError::Ok);
REQUIRE(1 == obj.size());
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("ShouldNotReadPastTheEnd") {
std::istringstream json("{}123");
DynamicJsonDocument doc;
deserializeJson(doc, json);
REQUIRE('1' == json.get());
}
}

259
test/Misc/std_string.cpp
View File

@ -1,259 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
static void eraseString(std::string &str) {
char *p = const_cast<char *>(str.c_str());
while (*p) *p++ = '*';
}
TEST_CASE("std::string") {
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") {
DynamicJsonDocument doc;
JsonArray &array = doc.to<JsonArray>();
SECTION("add()") {
std::string value("hello");
array.add(value);
eraseString(value);
REQUIRE(std::string("hello") == array[0]);
}
SECTION("set()") {
std::string value("world");
array.add("hello");
array.set(0, value);
eraseString(value);
REQUIRE(std::string("world") == array[0]);
}
SECTION("operator[]") {
std::string value("world");
array.add("hello");
array[0] = value;
eraseString(value);
REQUIRE(std::string("world") == array[0]);
}
SECTION("serializeJson()") {
array.add(4);
array.add(2);
std::string json;
serializeJson(array, json);
REQUIRE(std::string("[4,2]") == json);
}
SECTION("serializeJsonPretty()") {
array.add(4);
array.add(2);
std::string json;
serializeJsonPretty(array, json);
REQUIRE(std::string("[\r\n 4,\r\n 2\r\n]") == json);
}
}
SECTION("JsonObject") {
DynamicJsonDocument doc;
SECTION("deserializeJson()") {
std::string json("{\"hello\":\"world\"}");
JsonError err = deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
eraseString(json);
REQUIRE(err == JsonError::Ok);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("operator[]") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(std::string("value") == obj[std::string("key")]);
}
SECTION("operator[] const") {
char json[] = "{\"key\":\"value\"}";
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");
obj.set(key, "world");
eraseString(key);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(value)") {
JsonObject &obj = doc.to<JsonObject>();
std::string value("world");
obj.set("hello", value);
eraseString(value);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(key,value)") {
JsonObject &obj = doc.to<JsonObject>();
std::string key("hello");
std::string value("world");
obj.set(key, value);
eraseString(key);
eraseString(value);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(JsonArraySubscript)") {
JsonObject &obj = doc.to<JsonObject>();
DynamicJsonDocument doc2;
JsonArray &arr = doc2.to<JsonArray>();
arr.add("world");
obj.set(std::string("hello"), arr[0]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set(JsonObjectSubscript)") {
JsonObject &obj = doc.to<JsonObject>();
DynamicJsonDocument doc2;
JsonObject &obj2 = doc2.to<JsonObject>();
obj2.set("x", "world");
obj.set(std::string("hello"), obj2["x"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("get<T>()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(std::string("value") ==
obj.get<const char *>(std::string("key")));
}
SECTION("is<T>()") {
char json[] = "{\"key\":\"value\"}";
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];
obj.createNestedObject(key);
eraseString(key);
serializeJson(doc, json, sizeof(json));
REQUIRE(std::string("{\"key\":{}}") == json);
}
SECTION("createNestedArray()") {
JsonObject &obj = doc.to<JsonObject>();
std::string key = "key";
char json[64];
obj.createNestedArray(key);
eraseString(key);
serializeJson(doc, json, sizeof(json));
REQUIRE(std::string("{\"key\":[]}") == json);
}
SECTION("containsKey()") {
char json[] = "{\"key\":\"value\"}";
deserializeJson(doc, json);
JsonObject &obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(std::string("key")));
}
SECTION("remove()") {
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");
JsonObject &obj = doc.to<JsonObject>();
obj[key] = "world";
eraseString(key);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("operator[], set value") {
std::string value("world");
JsonObject &obj = doc.to<JsonObject>();
obj["hello"] = value;
eraseString(value);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("serializeJson()") {
JsonObject &obj = doc.to<JsonObject>();
obj["key"] = "value";
std::string json;
serializeJson(doc, json);
REQUIRE(std::string("{\"key\":\"value\"}") == json);
}
SECTION("serializeJsonPretty()") {
JsonObject &obj = doc.to<JsonObject>();
obj["key"] = "value";
std::string 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>();
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>();
obj[key] = 1;
size_t sizeBefore = doc.memoryUsage();
obj[key] = 2;
size_t sizeAfter = doc.memoryUsage();
REQUIRE(sizeBefore == sizeAfter);
}
}
}

414
test/Misc/unsigned_char.cpp
View File

@ -9,259 +9,267 @@
#define CONFLICTS_WITH_BUILTIN_OPERATOR
#endif
TEST_CASE("unsigned char string") {
SECTION("JsonBuffer::parseArray") {
unsigned char json[] = "[42]";
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
JsonError err = deserializeJson(doc, json);
REQUIRE(err == JsonError::Ok);
}
SECTION("JsonBuffer::parseObject") {
unsigned char json[] = "{\"a\":42}";
TEST_CASE("unsigned char[]") {
SECTION("deserializeJson()") {
unsigned char input[] = "{\"a\":42}";
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
JsonError err = deserializeJson(doc, json);
JsonError err = deserializeJson(doc, input);
REQUIRE(err == JsonError::Ok);
}
SECTION("JsonVariant constructor") {
unsigned char value[] = "42";
SECTION("deserializeMsgPack()") {
unsigned char input[] = "\xDE\x00\x01\xA5Hello\xA5world";
JsonVariant variant(value);
StaticJsonDocument<JSON_OBJECT_SIZE(2)> doc;
MsgPackError err = deserializeMsgPack(doc, input);
REQUIRE(42 == variant.as<int>());
REQUIRE(err == MsgPackError::Ok);
}
SECTION("JsonVariant assignment operator") {
unsigned char value[] = "42";
SECTION("JsonVariant") {
SECTION("constructor") {
unsigned char value[] = "42";
JsonVariant variant(666);
variant = value;
JsonVariant variant(value);
REQUIRE(42 == variant.as<int>());
}
REQUIRE(42 == variant.as<int>());
}
SECTION("operator=") {
unsigned char value[] = "42";
JsonVariant variant(666);
variant = value;
REQUIRE(42 == variant.as<int>());
}
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonVariant::operator[]") {
unsigned char key[] = "hello";
SECTION("operator[]") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[key]);
}
REQUIRE(std::string("world") == variant[key]);
}
#endif
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonVariant::operator[] const") {
unsigned char key[] = "hello";
SECTION("operator[] const") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[key]);
}
REQUIRE(std::string("world") == variant[key]);
}
#endif
SECTION("JsonVariant::operator==") {
unsigned char comparand[] = "hello";
SECTION("operator==") {
unsigned char comparand[] = "hello";
JsonVariant variant;
variant = "hello";
JsonVariant variant;
variant = "hello";
REQUIRE(comparand == variant);
REQUIRE(variant == comparand);
REQUIRE_FALSE(comparand != variant);
REQUIRE_FALSE(variant != comparand);
}
SECTION("JsonVariant::operator!=") {
unsigned char comparand[] = "hello";
JsonVariant variant;
variant = "world";
REQUIRE(comparand != variant);
REQUIRE(variant != comparand);
REQUIRE_FALSE(comparand == variant);
REQUIRE_FALSE(variant == comparand);
REQUIRE(comparand == variant);
REQUIRE(variant == comparand);
REQUIRE_FALSE(comparand != variant);
REQUIRE_FALSE(variant != comparand);
}
SECTION("operator!=") {
unsigned char comparand[] = "hello";
JsonVariant variant;
variant = "world";
REQUIRE(comparand != variant);
REQUIRE(variant != comparand);
REQUIRE_FALSE(comparand == variant);
REQUIRE_FALSE(variant == comparand);
}
}
SECTION("JsonObject") {
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonObject::operator[]") {
unsigned char key[] = "hello";
SECTION("operator[]") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[key] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[key] = "world";
REQUIRE(std::string("world") == obj["hello"]);
}
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("JsonObject::operator[] const") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[key]);
}
#endif
SECTION("JsonObjectSubscript::operator=") { // issue #416
unsigned char value[] = "world";
SECTION("get()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = value;
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(key));
}
REQUIRE(std::string("world") == obj["hello"]);
SECTION("set() key") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, "world");
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set() value") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", value);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set() key&value") {
unsigned char key[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, key);
REQUIRE(std::string("world") == obj["world"]);
}
SECTION("containsKey()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(key));
}
SECTION("remove()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(key);
REQUIRE(0 == obj.size());
}
SECTION("is()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(key));
}
SECTION("createNestedArray()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(key);
}
SECTION("createNestedObject()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(key);
}
}
SECTION("JsonObjectSubscript::set()") {
unsigned char value[] = "world";
SECTION("JsonObjectSubscript") {
SECTION("operator=") { // issue #416
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(value);
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = value;
REQUIRE(std::string("world") == obj["hello"]);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(value);
REQUIRE(std::string("world") == obj["hello"]);
}
}
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonObject::operator[] const") {
unsigned char key[] = "hello";
SECTION("JsonArray") {
SECTION("add()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(value);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[key]);
}
#endif
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonObject::get()") {
unsigned char key[] = "hello";
SECTION("set()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(key));
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, value);
REQUIRE(std::string("world") == arr[0]);
}
}
SECTION("JsonObject::set() key") {
unsigned char key[] = "hello";
SECTION("JsonArraySubscript") {
SECTION("set()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(value);
REQUIRE(std::string("world") == obj["hello"]);
}
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonObject::set() value") {
unsigned char value[] = "world";
SECTION("operator=") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", value);
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = value;
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("JsonObject::set key&value") {
unsigned char key[] = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(key, key);
REQUIRE(std::string("world") == obj["world"]);
}
SECTION("JsonObject::containsKey()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(key));
}
SECTION("JsonObject::remove()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(key);
REQUIRE(0 == obj.size());
}
SECTION("JsonObject::is()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(key));
}
SECTION("JsonObject::createNestedArray()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(key);
}
SECTION("JsonObject::createNestedObject()") {
unsigned char key[] = "hello";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(key);
}
SECTION("JsonArray::add()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(value);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArray::set()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, value);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArraySubscript::set()") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(value);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArraySubscript::operator=") {
unsigned char value[] = "world";
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = value;
REQUIRE(std::string("world") == arr[0]);
REQUIRE(std::string("world") == arr[0]);
}
}
}

507
test/Misc/vla.cpp
View File

@ -17,322 +17,321 @@
#ifndef VLA_NOT_SUPPORTED
TEST_CASE("Variable Length Array") {
SECTION("ParseArray") {
int i = 8;
SECTION("deserializeJson()") {
int i = 9;
char vla[i];
strcpy(vla, "[42]");
strcpy(vla, "{\"a\":42}");
StaticJsonDocument<JSON_ARRAY_SIZE(1)> doc;
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
JsonError err = deserializeJson(doc, vla);
REQUIRE(err == JsonError::Ok);
}
SECTION("ParseObject") {
SECTION("deserializeMsgPack()") {
int i = 16;
char vla[i];
strcpy(vla, "{\"a\":42}");
memcpy(vla, "\xDE\x00\x01\xA5Hello\xA5world", 15);
StaticJsonDocument<JSON_OBJECT_SIZE(1)> doc;
JsonError error = deserializeJson(doc, vla);
MsgPackError err = deserializeMsgPack(doc, vla);
REQUIRE(error == JsonError::Ok);
REQUIRE(err == MsgPackError::Ok);
}
SECTION("Parse") {
int i = 16;
char vla[i];
strcpy(vla, "42");
SECTION("JsonVariant") {
SECTION("constructor") {
int i = 16;
char vla[i];
strcpy(vla, "42");
StaticJsonDocument<> variant;
deserializeJson(variant, vla);
JsonVariant variant(vla);
REQUIRE(42 == variant.as<int>());
}
REQUIRE(42 == variant.as<int>());
}
SECTION("JsonVariant_Constructor") {
int i = 16;
char vla[i];
strcpy(vla, "42");
SECTION("operator=") {
int i = 16;
char vla[i];
strcpy(vla, "42");
JsonVariant variant(vla);
JsonVariant variant(666);
variant = vla;
REQUIRE(42 == variant.as<int>());
}
SECTION("JsonVariant_Assign") {
int i = 16;
char vla[i];
strcpy(vla, "42");
JsonVariant variant(666);
variant = vla;
REQUIRE(42 == variant.as<int>());
}
REQUIRE(42 == variant.as<int>());
}
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonVariant_Subscript") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("operator[]") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[vla]);
}
REQUIRE(std::string("world") == variant[vla]);
}
#endif
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonVariant_Subscript_Const") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("operator[] const") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
const JsonVariant variant = doc.as<JsonVariant>();
REQUIRE(std::string("world") == variant[vla]);
}
REQUIRE(std::string("world") == variant[vla]);
}
#endif
SECTION("JsonVariant_Equals") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("operator==") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
JsonVariant variant;
variant = "hello";
JsonVariant variant;
variant = "hello";
REQUIRE((vla == variant));
REQUIRE((variant == vla));
REQUIRE_FALSE((vla != variant));
REQUIRE_FALSE((variant != vla));
REQUIRE((vla == variant));
REQUIRE((variant == vla));
REQUIRE_FALSE((vla != variant));
REQUIRE_FALSE((variant != vla));
}
SECTION("operator!=") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
JsonVariant variant;
variant = "world";
REQUIRE((vla != variant));
REQUIRE((variant != vla));
REQUIRE_FALSE((vla == variant));
REQUIRE_FALSE((variant == vla));
}
}
SECTION("JsonVariant_Differs") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("JsonObject") {
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("operator[]") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
JsonVariant variant;
variant = "world";
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[vla] = "world";
REQUIRE((vla != variant));
REQUIRE((variant != vla));
REQUIRE_FALSE((vla == variant));
REQUIRE_FALSE((variant == vla));
}
REQUIRE(std::string("world") == obj["hello"]);
}
#endif
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonObject_Subscript") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("operator[] const") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj[vla] = "world";
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
REQUIRE(std::string("world") == obj["hello"]);
}
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[vla]);
}
#endif
SECTION("JsonObject_Subscript_Assign") { // issue #416
int i = 32;
char vla[i];
strcpy(vla, "world");
SECTION("get()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = vla;
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
REQUIRE(std::string("world") == obj["hello"].as<char*>());
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(vla));
}
SECTION("set() key") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, "world");
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set() value") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", vla);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("set() key&value") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, vla);
REQUIRE(std::string("world") == obj["world"]);
}
SECTION("containsKey()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(vla));
}
SECTION("remove()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(vla);
REQUIRE(0 == obj.size());
}
SECTION("is<T>()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(vla));
}
SECTION("createNestedArray()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(vla);
}
SECTION("createNestedObject()") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(vla);
}
}
SECTION("JsonObject_Subscript_Set") {
int i = 32;
char vla[i];
strcpy(vla, "world");
SECTION("JsonObjectSubscript") {
SECTION("operator=") { // issue #416
int i = 32;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(vla);
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"] = vla;
REQUIRE(std::string("world") == obj["hello"].as<char*>());
REQUIRE(std::string("world") == obj["hello"].as<char*>());
}
SECTION("set()") {
int i = 32;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj["hello"].set(vla);
REQUIRE(std::string("world") == obj["hello"].as<char*>());
}
}
#ifndef CONFLICTS_WITH_BUILTIN_OPERATOR
SECTION("JsonObject_Subscript_Const") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("JsonArray") {
SECTION("add()") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(vla);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj[vla]);
}
#endif
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonObject_Get") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("set()") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, vla);
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(std::string("world") == obj.get<char*>(vla));
REQUIRE(std::string("world") == arr[0]);
}
}
SECTION("JsonObject_Set_Key") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
SECTION("JsonArraySubscript") {
SECTION("set()") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(vla);
REQUIRE(std::string("world") == obj["hello"]);
}
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonObject_Set_Value") {
int i = 16;
char vla[i];
strcpy(vla, "world");
SECTION("operator=") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set("hello", vla);
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = vla;
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("JsonObject_Set_KeyAndValue") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.set(vla, vla);
REQUIRE(std::string("world") == obj["world"]);
}
SECTION("JsonObject_ContainsKey") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.containsKey(vla));
}
SECTION("JsonObject_Remove") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":\"world\"}");
JsonObject& obj = doc.as<JsonObject>();
obj.remove(vla);
REQUIRE(0 == obj.size());
}
SECTION("JsonObject_Is") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
deserializeJson(doc, "{\"hello\":42}");
JsonObject& obj = doc.as<JsonObject>();
REQUIRE(true == obj.is<int>(vla));
}
SECTION("JsonObject_CreateNestedArray") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedArray(vla);
}
SECTION("JsonObject_CreateNestedObject") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
DynamicJsonDocument doc;
JsonObject& obj = doc.to<JsonObject>();
obj.createNestedObject(vla);
}
SECTION("JsonArray_Add") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add(vla);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArray_Set") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr.set(0, vla);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArraySubscript_Set") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0].set(vla);
REQUIRE(std::string("world") == arr[0]);
}
SECTION("JsonArraySubscript_Assign") {
int i = 16;
char vla[i];
strcpy(vla, "world");
DynamicJsonDocument doc;
JsonArray& arr = doc.to<JsonArray>();
arr.add("hello");
arr[0] = vla;
REQUIRE(std::string("world") == arr[0]);
REQUIRE(std::string("world") == arr[0]);
}
}
}
#endif