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

Add more tests for JsonVariantConst

Browse Source
This commit is contained in:
Benoit Blanchon
2024-01-08 19:31:29 +01:00
parent ca0dda7ac1
commit 315cc722e9
14 changed files with 391 additions and 262 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
extras/tests/CMakeLists.txt
View File

@ -23,6 +23,7 @@ add_subdirectory(JsonObject)
add_subdirectory(JsonObjectConst)
add_subdirectory(JsonSerializer)
add_subdirectory(JsonVariant)
add_subdirectory(JsonVariantConst)
add_subdirectory(ResourceManager)
add_subdirectory(Misc)
add_subdirectory(MixedConfiguration)

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

@ -251,17 +251,6 @@ TEST_CASE("JsonVariant::as()") {
}
#endif
SECTION("should work on JsonVariantConst") {
variant.set("hello");
JsonVariantConst cvar = variant;
REQUIRE(cvar.as<bool>() == true);
REQUIRE(cvar.as<long>() == 0L);
REQUIRE(cvar.as<const char*>() == std::string("hello"));
REQUIRE(cvar.as<std::string>() == std::string("hello"));
}
SECTION("as<enum>()") {
variant.set(1);

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

@ -24,19 +24,3 @@ TEST_CASE("JsonVariant::containsKey()") {
REQUIRE(var.containsKey(std::string("world")) == false);
}
}
TEST_CASE("JsonVariantConst::containsKey()") {
JsonDocument doc;
doc["hello"] = "world";
JsonVariantConst cvar = doc.as<JsonVariant>();
SECTION("containsKey(const char*) returns true") {
REQUIRE(cvar.containsKey("hello") == true);
REQUIRE(cvar.containsKey("world") == false);
}
SECTION("containsKey(std::string) returns true") {
REQUIRE(cvar.containsKey(std::string("hello")) == true);
REQUIRE(cvar.containsKey(std::string("world")) == false);
}
}

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

@ -162,158 +162,3 @@ TEST_CASE("JsonVariant::is<T>()") {
CHECK(variant.is<JsonVariantConst>() == true);
}
}
TEST_CASE("JsonVariantConst::is<T>()") {
JsonDocument doc;
JsonVariant variant = doc.to<JsonVariant>();
JsonVariantConst cvariant = variant;
SECTION("unbound") {
cvariant = JsonVariantConst();
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonArrayConst>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonObjectConst>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonVariantConst>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("null") {
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("true") {
variant.set(true);
CHECK(cvariant.is<bool>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("false") {
variant.set(false);
CHECK(cvariant.is<bool>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("int") {
variant.set(42);
CHECK(cvariant.is<int>() == true);
CHECK(cvariant.is<short>() == true);
CHECK(cvariant.is<long>() == true);
CHECK(cvariant.is<double>() == true);
CHECK(cvariant.is<float>() == true);
CHECK(cvariant.is<MYENUM2>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
}
SECTION("double") {
variant.set(4.2);
CHECK(cvariant.is<double>() == true);
CHECK(cvariant.is<float>() == true);
CHECK(cvariant.is<JsonVariantConst>() == true);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<const char*>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<std::string>() == false);
CHECK(cvariant.is<JsonString>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("const char*") {
variant.set("4.2");
CHECK(cvariant.is<const char*>() == true);
CHECK(cvariant.is<const char*>() == true);
CHECK(cvariant.is<std::string>() == true);
CHECK(cvariant.is<JsonString>() == true);
CHECK(cvariant.is<double>() == false);
CHECK(cvariant.is<float>() == false);
CHECK(cvariant.is<bool>() == false);
CHECK(cvariant.is<JsonObject>() == false);
CHECK(cvariant.is<JsonArray>() == false);
CHECK(cvariant.is<JsonVariant>() == false);
CHECK(cvariant.is<int>() == false);
CHECK(cvariant.is<MYENUM2>() == false);
}
SECTION("JsonArray") {
variant.to<JsonArray>();
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("JsonObject") {
variant.to<JsonObject>();
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);
}
}

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

@ -69,12 +69,4 @@ TEST_CASE("JsonVariant::isNull()") {
variant.set(serialized(static_cast<const char*>(0)));
REQUIRE(variant.isNull() == true);
}
SECTION("works with JsonVariantConst") {
variant.set(42);
JsonVariantConst cvar = variant;
REQUIRE(cvar.isNull() == false);
}
}

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

@ -130,75 +130,3 @@ TEST_CASE("JsonVariant::operator[]") {
}
#endif
}
TEST_CASE("JsonVariantConst::operator[]") {
JsonDocument doc;
JsonVariant var = doc.to<JsonVariant>();
JsonVariantConst cvar = var;
SECTION("The JsonVariant is null") {
REQUIRE(0 == cvar.size());
REQUIRE(cvar["0"].isNull());
REQUIRE(cvar[0].isNull());
}
SECTION("The JsonVariant is a string") {
var.set("hello world");
REQUIRE(0 == cvar.size());
REQUIRE(cvar["0"].isNull());
REQUIRE(cvar[0].isNull());
}
SECTION("The JsonVariant is a JsonArray") {
JsonArray array = var.to<JsonArray>();
SECTION("get value") {
array.add("element at index 0");
array.add("element at index 1");
REQUIRE(2 == cvar.size());
REQUIRE(std::string("element at index 0") == cvar[0]);
REQUIRE(std::string("element at index 1") == cvar[1]);
REQUIRE(std::string("element at index 0") ==
var[static_cast<unsigned char>(0)]); // issue #381
REQUIRE(cvar[666].isNull());
REQUIRE(cvar[3].isNull());
REQUIRE(cvar["0"].isNull());
}
}
SECTION("The JsonVariant is a JsonObject") {
JsonObject object = var.to<JsonObject>();
SECTION("get value") {
object["a"] = "element at key \"a\"";
object["b"] = "element at key \"b\"";
REQUIRE(2 == cvar.size());
REQUIRE(std::string("element at key \"a\"") == cvar["a"]);
REQUIRE(std::string("element at key \"b\"") == cvar["b"]);
REQUIRE(cvar["c"].isNull());
REQUIRE(cvar[0].isNull());
}
}
SECTION("Auto promote null JsonVariant to JsonObject") {
var["hello"] = "world";
REQUIRE(var.is<JsonObject>() == true);
}
SECTION("Don't auto promote non-null JsonVariant to JsonObject") {
var.set(42);
var["hello"] = "world";
REQUIRE(var.is<JsonObject>() == false);
}
SECTION("Don't auto promote null JsonVariant to JsonObject when reading") {
const char* value = var["hello"];
REQUIRE(var.is<JsonObject>() == false);
REQUIRE(value == 0);
}
}

20
extras/tests/JsonVariantConst/CMakeLists.txt Normal file
View File

@ -0,0 +1,20 @@
# ArduinoJson - https://arduinojson.org
# Copyright © 2014-2024, Benoit BLANCHON
# MIT License
add_executable(JsonVariantConstTests
as.cpp
containsKey.cpp
is.cpp
isnull.cpp
nesting.cpp
size.cpp
subscript.cpp
)
add_test(JsonVariantConst JsonVariantConstTests)
set_tests_properties(JsonVariantConst
PROPERTIES
LABELS "Catch"
)

19
extras/tests/JsonVariantConst/as.cpp Normal file
View File

@ -0,0 +1,19 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <stdint.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::as<T>()") {
JsonDocument doc;
JsonVariantConst var = doc.to<JsonVariant>();
doc.set("hello");
REQUIRE(var.as<bool>() == true);
REQUIRE(var.as<long>() == 0L);
REQUIRE(var.as<const char*>() == std::string("hello"));
REQUIRE(var.as<std::string>() == std::string("hello"));
}

33
extras/tests/JsonVariantConst/containsKey.cpp Normal file
View File

@ -0,0 +1,33 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <stdint.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::containsKey()") {
JsonDocument doc;
doc["hello"] = "world";
JsonVariantConst var = doc.as<JsonVariant>();
SECTION("support const char*") {
REQUIRE(var.containsKey("hello") == true);
REQUIRE(var.containsKey("world") == false);
}
SECTION("support std::string") {
REQUIRE(var.containsKey(std::string("hello")) == true);
REQUIRE(var.containsKey(std::string("world")) == false);
}
#ifdef HAS_VARIABLE_LENGTH_ARRAY
SECTION("supports VLA") {
size_t i = 16;
char vla[i];
strcpy(vla, "hello");
REQUIRE(true == var.containsKey(vla));
}
#endif
}

162
extras/tests/JsonVariantConst/is.cpp Normal file
View File

@ -0,0 +1,162 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
enum MYENUM2 { ONE = 1, TWO = 2 };
TEST_CASE("JsonVariantConst::is<T>()") {
JsonDocument doc;
JsonVariantConst var = doc.to<JsonVariant>();
SECTION("unbound") {
var = JsonVariantConst();
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonArrayConst>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonObjectConst>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<JsonVariantConst>() == false);
CHECK(var.is<bool>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("null") {
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<bool>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("true") {
doc.set(true);
CHECK(var.is<bool>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("false") {
doc.set(false);
CHECK(var.is<bool>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("int") {
doc.set(42);
CHECK(var.is<int>() == true);
CHECK(var.is<short>() == true);
CHECK(var.is<long>() == true);
CHECK(var.is<double>() == true);
CHECK(var.is<float>() == true);
CHECK(var.is<MYENUM2>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<bool>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
}
SECTION("double") {
doc.set(4.2);
CHECK(var.is<double>() == true);
CHECK(var.is<float>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<bool>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<std::string>() == false);
CHECK(var.is<JsonString>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("const char*") {
doc.set("4.2");
CHECK(var.is<const char*>() == true);
CHECK(var.is<const char*>() == true);
CHECK(var.is<std::string>() == true);
CHECK(var.is<JsonString>() == true);
CHECK(var.is<double>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<bool>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("JsonArray") {
doc.to<JsonArray>();
CHECK(var.is<JsonArrayConst>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonObjectConst>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<bool>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<MYENUM2>() == false);
}
SECTION("JsonObject") {
doc.to<JsonObject>();
CHECK(var.is<JsonObjectConst>() == true);
CHECK(var.is<JsonVariantConst>() == true);
CHECK(var.is<JsonObject>() == false);
CHECK(var.is<JsonVariant>() == false);
CHECK(var.is<JsonArray>() == false);
CHECK(var.is<JsonArrayConst>() == false);
CHECK(var.is<int>() == false);
CHECK(var.is<float>() == false);
CHECK(var.is<bool>() == false);
CHECK(var.is<const char*>() == false);
CHECK(var.is<MYENUM2>() == false);
}
}

21
extras/tests/JsonVariantConst/isnull.cpp Normal file
View File

@ -0,0 +1,21 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::isNull()") {
JsonDocument doc;
JsonVariantConst variant = doc.to<JsonVariant>();
SECTION("returns true when undefined") {
REQUIRE(variant.isNull() == true);
}
SECTION("returns false if value is integer") {
doc.set(42);
REQUIRE(variant.isNull() == false);
}
}

31
extras/tests/JsonVariantConst/nesting.cpp Normal file
View File

@ -0,0 +1,31 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::nesting()") {
JsonDocument doc;
JsonVariantConst var = doc.to<JsonVariant>();
SECTION("return 0 if unbound") {
JsonVariantConst unbound;
REQUIRE(unbound.nesting() == 0);
}
SECTION("returns 0 for string") {
doc.set("hello");
REQUIRE(var.nesting() == 0);
}
SECTION("returns 1 for empty object") {
doc.to<JsonObject>();
REQUIRE(var.nesting() == 1);
}
SECTION("returns 1 for empty array") {
doc.to<JsonArray>();
REQUIRE(var.nesting() == 1);
}
}

36
extras/tests/JsonVariantConst/size.cpp Normal file
View File

@ -0,0 +1,36 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::size()") {
JsonDocument doc;
JsonVariantConst variant = doc.to<JsonVariant>();
SECTION("unbound reference") {
JsonVariantConst unbound;
CHECK(unbound.size() == 0);
}
SECTION("int") {
doc.set(42);
CHECK(variant.size() == 0);
}
SECTION("string") {
doc.set("hello");
CHECK(variant.size() == 0);
}
SECTION("object") {
doc["a"] = 1;
doc["b"] = 2;
CHECK(variant.size() == 2);
}
}

68
extras/tests/JsonVariantConst/subscript.cpp Normal file
View File

@ -0,0 +1,68 @@
// ArduinoJson - https://arduinojson.org
// Copyright © 2014-2024, Benoit BLANCHON
// MIT License
#include <ArduinoJson.h>
#include <catch.hpp>
TEST_CASE("JsonVariantConst::operator[]") {
JsonDocument doc;
JsonVariantConst var = doc.to<JsonVariant>();
SECTION("null") {
REQUIRE(0 == var.size());
REQUIRE(var["0"].isNull());
REQUIRE(var[0].isNull());
}
SECTION("string") {
doc.set("hello world");
REQUIRE(0 == var.size());
REQUIRE(var["0"].isNull());
REQUIRE(var[0].isNull());
}
SECTION("array") {
JsonArray array = doc.to<JsonArray>();
array.add("A");
array.add("B");
REQUIRE(std::string("A") == var[0]);
REQUIRE(std::string("B") == var[1]);
REQUIRE(std::string("A") ==
var[static_cast<unsigned char>(0)]); // issue #381
REQUIRE(var[666].isNull());
REQUIRE(var[3].isNull());
REQUIRE(var["0"].isNull());
}
SECTION("object") {
JsonObject object = doc.to<JsonObject>();
object["a"] = "A";
object["b"] = "B";
SECTION("supports const char*") {
REQUIRE(std::string("A") == var["a"]);
REQUIRE(std::string("B") == var["b"]);
REQUIRE(var["c"].isNull());
REQUIRE(var[0].isNull());
}
SECTION("supports std::string") {
REQUIRE(std::string("A") == var[std::string("a")]);
REQUIRE(std::string("B") == var[std::string("b")]);
REQUIRE(var[std::string("c")].isNull());
}
#if defined(HAS_VARIABLE_LENGTH_ARRAY) && \
!defined(SUBSCRIPT_CONFLICTS_WITH_BUILTIN_OPERATOR)
SECTION("supports VLA") {
size_t i = 16;
char vla[i];
strcpy(vla, "a");
REQUIRE(std::string("A") == var[vla]);
}
#endif
}
}