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

Change link() to shallowCopy() (issue #1343)

Browse Source 
Instead of storing a pointer, the function copies the `VariantData`.

Benefits:
* smaller code
* no impact on programs that don't use this feature

Drawbacks:
* changes to the original variant are not always reflected on the copy
* modifying the original from the shallow copy leads to UB
This commit is contained in:
Benoit Blanchon
2022-07-05 17:07:43 +02:00
parent 3b3ab8c4e1
commit cd8373ad32
36 changed files with 78 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
extras/tests/Cpp11/nullptr.cpp
View File

@ -43,13 +43,5 @@ TEST_CASE("nullptr") {
variant.clear();
REQUIRE(variant.is<std::nullptr_t>() == true);
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
variant.link(doc2);
REQUIRE(variant.is<std::nullptr_t>() == false);
doc2.clear();
REQUIRE(variant.is<std::nullptr_t>() == true);
}
}

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

@ -246,10 +246,10 @@ TEST_CASE("ElementProxy cast to JsonVariant") {
CHECK(doc.as<std::string>() == "[\"toto\"]");
}
TEST_CASE("ElementProxy::link()") {
TEST_CASE("ElementProxy::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
doc1[0].link(doc2);
doc2["hello"] = "world";
doc1[0].shallowCopy(doc2);
CHECK(doc1.as<std::string>() == "[{\"hello\":\"world\"}]");
}

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

@ -318,10 +318,10 @@ TEST_CASE("MemberProxy::createNestedObject(key)") {
CHECK(doc["status"]["weather"]["temp"] == 42);
}
TEST_CASE("MemberProxy::link()") {
TEST_CASE("MemberProxy::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
doc1["obj"].link(doc2);
doc2["hello"] = "world";
doc1["obj"].shallowCopy(doc2);
CHECK(doc1.as<std::string>() == "{\"obj\":{\"hello\":\"world\"}}");
}

17
extras/tests/JsonDocument/size.cpp
View File

@ -25,21 +25,4 @@ TEST_CASE("JsonDocument::size()") {
REQUIRE(doc.size() == 2);
}
SECTION("linked array") {
StaticJsonDocument<128> doc2;
doc2.add(1);
doc2.add(2);
doc.as<JsonVariant>().link(doc2);
REQUIRE(doc.size() == 2);
}
SECTION("linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
doc.as<JsonVariant>().link(doc2);
REQUIRE(doc.size() == 1);
}
}

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

@ -13,7 +13,6 @@ add_executable(JsonVariantTests
createNested.cpp
is.cpp
isnull.cpp
link.cpp
memoryUsage.cpp
misc.cpp
nesting.cpp
@ -21,6 +20,7 @@ add_executable(JsonVariantTests
overflow.cpp
remove.cpp
set.cpp
shallowCopy.cpp
size.cpp
subscript.cpp
types.cpp

10
extras/tests/JsonVariant/add.cpp
View File

@ -43,14 +43,4 @@ TEST_CASE("JsonVariant::add()") {
REQUIRE(var.as<std::string>() == "{\"val\":123}");
}
SECTION("add to linked array") {
StaticJsonDocument<1024> doc2;
doc2.add(42);
var.link(doc2);
var.add(666); // no-op
CHECK(var.as<std::string>() == "[42]");
}
}

93
extras/tests/JsonVariant/as.cpp
View File

@ -267,97 +267,4 @@ TEST_CASE("JsonVariant::as()") {
REQUIRE(variant.as<MY_ENUM>() == ONE);
}
SECTION("linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
variant.link(doc2);
SECTION("as<std::string>()") {
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
}
SECTION("as<JsonArray>()") {
JsonArray a = variant.as<JsonArray>();
CHECK(a.isNull() == true);
}
SECTION("as<JsonObject>()") {
JsonObject o = variant.as<JsonObject>();
CHECK(o.isNull() == true);
}
SECTION("as<JsonObjectConst>()") {
JsonObjectConst o = variant.as<JsonObjectConst>();
CHECK(o.isNull() == false);
CHECK(o.size() == 1);
CHECK(o["hello"] == "world");
}
}
SECTION("linked array") {
StaticJsonDocument<128> doc2;
doc2.add("hello");
doc2.add("world");
variant.link(doc2);
SECTION("as<std::string>()") {
CHECK(variant.as<std::string>() == "[\"hello\",\"world\"]");
}
SECTION("as<JsonArray>()") {
JsonArray a = variant.as<JsonArray>();
CHECK(a.isNull() == true);
}
SECTION("as<JsonArrayConst>()") {
JsonArrayConst a = variant.as<JsonArrayConst>();
CHECK(a.isNull() == false);
CHECK(a.size() == 2);
CHECK(a[0] == "hello");
CHECK(a[1] == "world");
}
SECTION("as<JsonObject>()") {
JsonObject o = variant.as<JsonObject>();
CHECK(o.isNull() == true);
}
}
SECTION("linked int") {
StaticJsonDocument<128> doc2;
doc2.set(42);
variant.link(doc2);
CHECK(variant.as<int>() == 42);
CHECK(variant.as<double>() == 42.0);
}
SECTION("linked double") {
StaticJsonDocument<128> doc2;
doc2.set(42.0);
variant.link(doc2);
CHECK(variant.as<int>() == 42);
CHECK(variant.as<double>() == 42.0);
}
SECTION("linked string") {
StaticJsonDocument<128> doc2;
doc2.set("hello");
variant.link(doc2);
CHECK(variant.as<std::string>() == "hello");
}
SECTION("linked bool") {
StaticJsonDocument<128> doc2;
variant.link(doc2);
doc2.set(true);
CHECK(variant.as<bool>() == true);
doc2.set(false);
CHECK(variant.as<bool>() == false);
}
}

11
extras/tests/JsonVariant/clear.cpp
View File

@ -23,15 +23,4 @@ TEST_CASE("JsonVariant::clear()") {
REQUIRE(var.isNull() == true);
}
SECTION("doesn't alter linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
var.link(doc2);
var.clear();
CHECK(var.isNull() == true);
CHECK(doc2.as<std::string>() == "{\"hello\":\"world\"}");
}
}

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

@ -34,20 +34,6 @@ TEST_CASE("Compare JsonVariant with value") {
CHECK_FALSE(a < b);
CHECK_FALSE(a > b);
}
SECTION("linked 42 vs 42") {
StaticJsonDocument<128> doc2;
doc2.set(42);
a.link(doc2);
int b = 42;
CHECK(a == b);
CHECK(a <= b);
CHECK(a >= b);
CHECK_FALSE(a != b);
CHECK_FALSE(a < b);
CHECK_FALSE(a > b);
}
}
TEST_CASE("Compare JsonVariant with JsonVariant") {
@ -327,19 +313,4 @@ TEST_CASE("Compare JsonVariant with JsonVariant") {
CHECK_FALSE(a > b);
CHECK_FALSE(a >= b);
}
SECTION("linked 42 vs link 42") {
StaticJsonDocument<128> doc2, doc3;
doc2.set(42);
doc3.set(42);
a.link(doc2);
b.link(doc3);
CHECK(a == b);
CHECK(a <= b);
CHECK(a >= b);
CHECK_FALSE(a != b);
CHECK_FALSE(a < b);
CHECK_FALSE(a > b);
}
}

9
extras/tests/JsonVariant/containsKey.cpp
View File

@ -25,15 +25,6 @@ TEST_CASE("JsonVariant::containsKey()") {
REQUIRE(var.containsKey(std::string("hello")) == true);
REQUIRE(var.containsKey(std::string("world")) == false);
}
SECTION("linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
var.link(doc2);
CHECK(var.containsKey("hello") == true);
CHECK(var.containsKey("world") == false);
}
}
TEST_CASE("JsonVariantConst::containsKey()") {

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

@ -84,16 +84,6 @@ TEST_CASE("JsonVariant::set(JsonVariant)") {
REQUIRE(doc2.memoryUsage() == JSON_STRING_SIZE(7));
}
SECTION("stores linked object by pointer") {
StaticJsonDocument<128> doc3;
doc3["hello"] = "world";
var1.link(doc3);
var2.set(var1);
REQUIRE(doc1.memoryUsage() == 0);
REQUIRE(doc2.memoryUsage() == 0);
}
SECTION("destination is unbound") {
JsonVariant unboundVariant;

44
extras/tests/JsonVariant/createNested.cpp
View File

@ -18,17 +18,6 @@ TEST_CASE("JsonVariant::createNestedObject()") {
REQUIRE(variant[0]["value"] == 42);
REQUIRE(obj.isNull() == false);
}
SECTION("does nothing on linked array") {
StaticJsonDocument<128> doc2;
doc2[0] = 42;
variant.link(doc2);
variant.createNestedObject();
CHECK(variant.size() == 1);
CHECK(variant[0] == 42);
}
}
TEST_CASE("JsonVariant::createNestedArray()") {
@ -41,17 +30,6 @@ TEST_CASE("JsonVariant::createNestedArray()") {
REQUIRE(variant.is<JsonArray>() == true);
REQUIRE(arr.isNull() == false);
}
SECTION("does nothing on linked array") {
StaticJsonDocument<128> doc2;
doc2[0] = 42;
variant.link(doc2);
variant.createNestedArray();
CHECK(variant.size() == 1);
CHECK(variant[0] == 42);
}
}
TEST_CASE("JsonVariant::createNestedObject(key)") {
@ -65,17 +43,6 @@ TEST_CASE("JsonVariant::createNestedObject(key)") {
REQUIRE(variant.is<JsonObject>() == true);
REQUIRE(variant["weather"]["temp"] == 42);
}
SECTION("does nothing on linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
variant.link(doc2);
variant.createNestedObject("weather");
CHECK(variant.size() == 1);
CHECK(variant["hello"] == "world");
}
}
TEST_CASE("JsonVariant::createNestedArray(key)") {
@ -88,15 +55,4 @@ TEST_CASE("JsonVariant::createNestedArray(key)") {
REQUIRE(variant.is<JsonObject>() == true);
REQUIRE(arr.isNull() == false);
}
SECTION("does nothing on linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
variant.link(doc2);
variant.createNestedArray("items");
CHECK(variant.size() == 1);
CHECK(variant["hello"] == "world");
}
}

110
extras/tests/JsonVariant/is.cpp
View File

@ -144,24 +144,6 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<MYENUM2>() == false);
}
SECTION("linked array") {
StaticJsonDocument<1024> doc2;
doc2[0] = "world";
variant.link(doc2);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<JsonArrayConst>() == true);
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonVariantConst>() == true);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonObjectConst>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<float>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<MYENUM2>() == false);
}
SECTION("JsonObject") {
variant.to<JsonObject>();
@ -179,44 +161,6 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonVariantConst>() == true);
}
SECTION("linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
variant.link(doc2);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonObjectConst>() == true);
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonVariantConst>() == true);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<JsonArrayConst>() == false);
CHECK(variant.is<int>() == false);
CHECK(variant.is<float>() == false);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<MYENUM2>() == false);
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonVariantConst>() == true);
}
SECTION("linked int") {
StaticJsonDocument<1024> doc2;
doc2.set(42);
variant.link(doc2);
CHECK(variant.is<JsonObjectConst>() == false);
CHECK(variant.is<JsonVariantConst>() == true);
CHECK(variant.is<JsonObject>() == false);
CHECK(variant.is<JsonVariant>() == true);
CHECK(variant.is<JsonArray>() == false);
CHECK(variant.is<JsonArrayConst>() == false);
CHECK(variant.is<int>() == true);
CHECK(variant.is<float>() == true);
CHECK(variant.is<bool>() == false);
CHECK(variant.is<const char *>() == false);
CHECK(variant.is<MYENUM2>() == true);
}
}
TEST_CASE("JsonVariantConst::is<T>()") {
@ -372,58 +316,4 @@ TEST_CASE("JsonVariantConst::is<T>()") {
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("linked array") {
StaticJsonDocument<1024> doc2;
doc2[0] = "world";
variant.link(doc2);
CHECK(cvariant.is<JsonArrayConst>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonObjectConst>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
variant.link(doc2);
CHECK(cvariant.is<JsonObjectConst>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonArrayConst>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("linked int") {
StaticJsonDocument<1024> doc2;
doc2.set(42);
variant.link(doc2);
CHECK(cvariant.is<JsonObjectConst>() == false);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonArrayConst>() == false);
CHECK(cvariant.is<int>() == true);
CHECK(cvariant.is<float>() == true);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char *>() == false);
CHECK(cvariant.is<MYENUM2>() == true);
}
}

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

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

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

@ -38,12 +38,4 @@ TEST_CASE("JsonVariant::memoryUsage()") {
REQUIRE(var.memoryUsage() == 6);
REQUIRE(var.memoryUsage() == doc.memoryUsage());
}
SECTION("ignore size of linked document") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
var.link(doc2);
CHECK(var.memoryUsage() == 0);
CHECK(var.memoryUsage() == doc.memoryUsage());
}
}

8
extras/tests/JsonVariant/nesting.cpp
View File

@ -28,12 +28,4 @@ TEST_CASE("JsonVariant::nesting()") {
var.to<JsonArray>();
REQUIRE(var.nesting() == 1);
}
SECTION("returns depth of linked array") {
StaticJsonDocument<128> doc2;
doc2[0][0] = 42;
var.link(doc2);
CHECK(var.nesting() == 2);
}
}

8
extras/tests/JsonVariant/or.cpp
View File

@ -156,12 +156,4 @@ TEST_CASE("JsonVariant::operator|()") {
int result = variant | 42;
REQUIRE(result == 42);
}
SECTION("linked int | int") {
StaticJsonDocument<128> doc2;
doc2.set(42);
variant.link(doc2);
int result = variant | 666;
CHECK(result == 42);
}
}

20
extras/tests/JsonVariant/remove.cpp
View File

@ -39,24 +39,4 @@ TEST_CASE("JsonVariant::remove()") {
REQUIRE(var.as<std::string>() == "{\"a\":1}");
}
SECTION("linked array") {
StaticJsonDocument<128> doc2;
doc2[0] = 42;
var.link(doc2);
var.remove(0);
CHECK(var.as<std::string>() == "[42]");
}
SECTION("linked object") {
StaticJsonDocument<128> doc2;
doc2["hello"] = "world";
var.link(doc2);
var.remove("hello");
CHECK(var.as<std::string>() == "{\"hello\":\"world\"}");
}
}

34
extras/tests/JsonVariant/link.cpp → extras/tests/JsonVariant/shallowCopy.cpp
View File

@ -5,17 +5,16 @@
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonVariant::link()") {
TEST_CASE("JsonVariant::shallowCopy()") {
StaticJsonDocument<1024> doc1, doc2;
JsonVariant variant = doc1.to<JsonVariant>();
SECTION("JsonVariant::link(JsonDocument&)") {
SECTION("JsonVariant::shallowCopy(JsonDocument&)") {
doc2["hello"] = "world";
variant.link(doc2);
variant.shallowCopy(doc2);
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
CHECK(variant.memoryUsage() == 0);
// altering the linked document should change the result
doc2["hello"] = "WORLD!";
@ -23,13 +22,12 @@ TEST_CASE("JsonVariant::link()") {
CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}");
}
SECTION("JsonVariant::link(MemberProxy)") {
SECTION("JsonVariant::shallowCopy(MemberProxy)") {
doc2["obj"]["hello"] = "world";
variant.link(doc2["obj"]);
variant.shallowCopy(doc2["obj"]);
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
CHECK(variant.memoryUsage() == 0);
// altering the linked document should change the result
doc2["obj"]["hello"] = "WORLD!";
@ -37,13 +35,12 @@ TEST_CASE("JsonVariant::link()") {
CHECK(variant.as<std::string>() == "{\"hello\":\"WORLD!\"}");
}
SECTION("JsonVariant::link(ElementProxy)") {
SECTION("JsonVariant::shallowCopy(ElementProxy)") {
doc2[0]["hello"] = "world";
variant.link(doc2[0]);
variant.shallowCopy(doc2[0]);
CHECK(variant.as<std::string>() == "{\"hello\":\"world\"}");
CHECK(variant.memoryUsage() == 0);
// altering the linked document should change the result
doc2[0]["hello"] = "WORLD!";
@ -55,7 +52,7 @@ TEST_CASE("JsonVariant::link()") {
JsonVariant unbound;
variant["hello"] = "world";
variant.link(unbound);
variant.shallowCopy(unbound);
CHECK(variant.isUnbound() == false);
CHECK(variant.isNull() == true);
@ -67,11 +64,24 @@ TEST_CASE("JsonVariant::link()") {
JsonVariant unbound;
doc2["hello"] = "world";
unbound.link(doc2);
unbound.shallowCopy(doc2);
CHECK(unbound.isUnbound() == true);
CHECK(unbound.isNull() == true);
CHECK(unbound.memoryUsage() == 0);
CHECK(unbound.size() == 0);
}
SECTION("preserves owned key bit") {
doc2.set(42);
doc1["a"].shallowCopy(doc2);
doc1[std::string("b")].shallowCopy(doc2);
JsonObject::iterator it = doc1.as<JsonObject>().begin();
CHECK(it->key().isLinked() == true);
++it;
CHECK(it->key().isLinked() == false);
}
}

17
extras/tests/JsonVariant/size.cpp
View File

@ -33,21 +33,4 @@ TEST_CASE("JsonVariant::size()") {
CHECK(variant.size() == 2);
}
SECTION("linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
variant.link(doc2);
CHECK(variant.size() == 1);
}
SECTION("linked array") {
StaticJsonDocument<1024> doc2;
doc2.add(1);
doc2.add(2);
variant.link(doc2);
CHECK(variant.size() == 2);
}
}

54
extras/tests/JsonVariant/subscript.cpp
View File

@ -129,44 +129,6 @@ TEST_CASE("JsonVariant::operator[]") {
REQUIRE(std::string("world") == variant[vla]);
}
#endif
SECTION("get value from linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
var.link(doc2);
CHECK(var["hello"].as<std::string>() == "world");
}
SECTION("set value to linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
var.link(doc2);
var["tutu"] = "toto"; // no-op
CHECK(doc.as<std::string>() == "{\"hello\":\"world\"}");
CHECK(doc2.as<std::string>() == "{\"hello\":\"world\"}");
}
SECTION("get value from linked array") {
StaticJsonDocument<1024> doc2;
doc2.add(42);
var.link(doc2);
CHECK(var[0].as<int>() == 42);
}
SECTION("set value to linked array") {
StaticJsonDocument<1024> doc2;
doc2.add(42);
var.link(doc2);
var[0] = 666; // no-op
CHECK(doc.as<std::string>() == "[42]");
CHECK(doc2.as<std::string>() == "[42]");
}
}
TEST_CASE("JsonVariantConst::operator[]") {
@ -239,20 +201,4 @@ TEST_CASE("JsonVariantConst::operator[]") {
REQUIRE(var.is<JsonObject>() == false);
REQUIRE(value == 0);
}
SECTION("get value from linked object") {
StaticJsonDocument<1024> doc2;
doc2["hello"] = "world";
var.link(doc2);
CHECK(cvar["hello"].as<std::string>() == "world");
}
SECTION("get value from linked array") {
StaticJsonDocument<1024> doc2;
doc2.add(42);
var.link(doc2);
CHECK(cvar[0].as<int>() == 42);
}
}