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

Removed JsonArray::is<T>(i) and JsonArray::set(i,v)

Browse Source 
Removed `JsonObject::is<T>(k)` and `JsonObject::set(k,v)`
Replaced `T JsonArray::get<T>(i)` with `JsonVariant JsonArray::get(i)`
Replaced `T JsonObject::get<T>(k)` with `JsonVariant JsonObject::get(k)`
This commit is contained in:
Benoit Blanchon
2018-10-18 14:51:02 +02:00
parent 4eee8e8bdf
commit 1a4515c0b9
20 changed files with 38 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
test/JsonObject/CMakeLists.txt
View File

@ -8,13 +8,10 @@ add_executable(JsonObjectTests
createNestedArray.cpp
createNestedObject.cpp
equals.cpp
get.cpp
invalid.cpp
is.cpp
isNull.cpp
iterator.cpp
remove.cpp
set.cpp
size.cpp
std_string.cpp
subscript.cpp

2
test/JsonObject/containsKey.cpp
View File

@ -8,7 +8,7 @@
TEST_CASE("JsonObject::containsKey()") {
DynamicJsonDocument doc;
JsonObject obj = doc.to<JsonObject>();
obj.set("hello", 42);
obj["hello"] = 42;
SECTION("returns true only if key is present") {
REQUIRE(false == obj.containsKey("world"));

37
test/JsonObject/get.cpp
View File

@ -1,37 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
using namespace Catch::Matchers;
TEST_CASE("JsonObject::get()") {
DynamicJsonDocument doc;
JsonObject obj = doc.to<JsonObject>();
SECTION("get<const char*>(const char*)") {
obj.set("hello", "world");
const char* value = obj.get<const char*>("hello");
REQUIRE_THAT(value, Equals("world"));
}
#ifdef HAS_VARIABLE_LENGTH_ARRAY
SECTION("get<const char*>(VLA)") {
obj.set("hello", "world");
int i = 16;
char vla[i];
strcpy(vla, "hello");
REQUIRE(std::string("world") == obj.get<char*>(vla));
}
#endif
SECTION("works on JsonObjectConst") {
obj.set("hello", "world");
const char* value =
static_cast<JsonObjectConst>(obj).get<const char*>("hello");
REQUIRE_THAT(value, Equals("world"));
}
}

2
test/JsonObject/invalid.cpp
View File

@ -15,7 +15,7 @@ TEST_CASE("JsonObject::invalid()") {
}
SECTION("AddFails") {
obj.set("hello", "world");
obj["hello"] = "world";
REQUIRE(0 == obj.size());
}

28
test/JsonObject/is.cpp
View File

@ -1,28 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonObject::is<T>()") {
DynamicJsonDocument doc;
JsonObject obj = doc.to<JsonObject>();
obj["int"] = 42;
obj["str"] = "hello";
SECTION("is<int>(const char*)") {
REQUIRE(true == obj.is<int>("int"));
REQUIRE(false == obj.is<int>("str"));
}
#if HAS_VARIABLE_LENGTH_ARRAY
SECTION("is<T>(VLA)") {
int i = 16;
char vla[i];
strcpy(vla, "int");
REQUIRE(true == obj.is<int>(vla));
}
#endif
}

174
test/JsonObject/set.cpp
View File

@ -1,174 +0,0 @@
// ArduinoJson - arduinojson.org
// Copyright Benoit Blanchon 2014-2018
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
#include <string>
TEST_CASE("JsonObject::set()") {
DynamicJsonDocument doc;
JsonObject obj = doc.to<JsonObject>();
SECTION("int") {
obj.set("hello", 123);
REQUIRE(123 == obj["hello"].as<int>());
REQUIRE(obj["hello"].is<int>());
REQUIRE_FALSE(obj["hello"].is<bool>());
}
SECTION("double") {
obj.set("hello", 123.45);
REQUIRE(123.45 == obj["hello"].as<double>());
REQUIRE(obj["hello"].is<double>());
REQUIRE_FALSE(obj["hello"].is<bool>());
}
SECTION("bool") {
obj.set("hello", true);
REQUIRE(obj["hello"].as<bool>());
REQUIRE(obj["hello"].is<bool>());
REQUIRE_FALSE(obj["hello"].is<long>());
}
SECTION("const char*") {
obj.set("hello", "h3110");
REQUIRE(std::string("h3110") == obj["hello"].as<const char*>());
REQUIRE(obj["hello"].is<const char*>());
REQUIRE_FALSE(obj["hello"].is<long>());
}
#ifdef HAS_VARIABLE_LENGTH_ARRAY
SECTION("key is a VLA") {
int i = 16;
char vla[i];
strcpy(vla, "hello");
obj.set(vla, "world");
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("value is a VLA") {
int i = 16;
char vla[i];
strcpy(vla, "world");
obj.set("hello", vla);
REQUIRE(std::string("world") == obj["hello"]);
}
SECTION("key and value are VLAs") {
int i = 16;
char vla[i];
strcpy(vla, "world");
obj.set(vla, vla);
REQUIRE(std::string("world") == obj["world"]);
}
#endif
SECTION("nested array") {
DynamicJsonDocument doc2;
JsonArray arr = doc2.to<JsonArray>();
obj.set("hello", arr);
REQUIRE(arr == obj["hello"].as<JsonArray>());
REQUIRE(obj["hello"].is<JsonArray>());
REQUIRE_FALSE(obj["hello"].is<JsonObject>());
}
SECTION("nested object") {
DynamicJsonDocument doc2;
JsonObject obj2 = doc2.to<JsonObject>();
obj.set("hello", obj2);
REQUIRE(obj2 == obj["hello"].as<JsonObject>());
REQUIRE(obj["hello"].is<JsonObject>());
REQUIRE_FALSE(obj["hello"].is<JsonArray>());
}
SECTION("array subscript") {
DynamicJsonDocument doc2;
JsonArray arr = doc2.to<JsonArray>();
arr.add(42);
obj.set("a", arr[0]);
REQUIRE(42 == obj["a"]);
}
SECTION("object subscript") {
DynamicJsonDocument doc2;
JsonObject obj2 = doc2.to<JsonObject>();
obj2.set("x", 42);
obj.set("a", obj2["x"]);
REQUIRE(42 == obj["a"]);
}
SECTION("returns true when allocation succeeds") {
StaticJsonDocument<JSON_OBJECT_SIZE(1) + 15> doc2;
JsonObject obj2 = doc2.to<JsonObject>();
REQUIRE(true == obj2.set(std::string("hello"), std::string("world")));
}
SECTION("returns false when allocation fails") {
StaticJsonDocument<JSON_OBJECT_SIZE(1) + 10> doc2;
JsonObject obj2 = doc2.to<JsonObject>();
REQUIRE(false == obj2.set(std::string("hello"), std::string("world")));
}
SECTION("should not duplicate const char*") {
obj.set("hello", "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1);
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* value") {
obj.set("hello", const_cast<char*>("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key") {
obj.set(const_cast<char*>("hello"), "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate char* key&value") {
obj.set(const_cast<char*>("hello"), const_cast<char*>("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 12;
REQUIRE(expectedSize <= doc.memoryUsage());
}
SECTION("should duplicate std::string value") {
obj.set("hello", std::string("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key") {
obj.set(std::string("hello"), "world");
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 6;
REQUIRE(expectedSize == doc.memoryUsage());
}
SECTION("should duplicate std::string key&value") {
obj.set(std::string("hello"), std::string("world"));
const size_t expectedSize = JSON_OBJECT_SIZE(1) + 12;
REQUIRE(expectedSize <= doc.memoryUsage());
}
}

4
test/JsonObject/size.cpp
View File

@ -15,12 +15,12 @@ TEST_CASE("JsonObject::size()") {
}
SECTION("increases when values are added") {
obj.set("hello", 42);
obj["hello"] = 42;
REQUIRE(1 == obj.size());
}
SECTION("decreases when values are removed") {
obj.set("hello", 42);
obj["hello"] = 42;
obj.remove("hello");
REQUIRE(0 == obj.size());
}

64
test/JsonObject/std_string.cpp
View File

@ -31,70 +31,6 @@ TEST_CASE("std::string") {
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";

2
test/JsonObject/subscript.cpp
View File

@ -86,7 +86,7 @@ TEST_CASE("JsonObject::operator[]") {
SECTION("object subscript") {
DynamicJsonDocument doc2;
JsonObject obj2 = doc2.to<JsonObject>();
obj2.set("x", 42);
obj2["x"] = 42;
obj["a"] = obj2["x"];