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

Changed unit testing framework from Google Test to Catch

Browse Source
This commit is contained in:
Benoit Blanchon
2017-04-18 18:22:24 +02:00
parent f2ef338cb8
commit df541a2a22
266 changed files with 15955 additions and 146149 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
test/JsonVariant/CMakeLists.txt
View File

@ -17,5 +17,5 @@ add_executable(JsonVariantTests
undefined.cpp
)
target_link_libraries(JsonVariantTests gtest)
target_link_libraries(JsonVariantTests catch)
add_test(JsonVariant JsonVariantTests)

381
test/JsonVariant/as.cpp
View File

@ -6,229 +6,230 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <stdint.h>
#include <catch.hpp>
static const char* null = 0;
TEST(JsonVariant_As_Tests, DoubleAsBool) {
JsonVariant variant = 4.2;
ASSERT_TRUE(variant.as<bool>());
}
TEST_CASE("JsonVariant::as()") {
SECTION("DoubleAsBool") {
JsonVariant variant = 4.2;
REQUIRE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, DoubleAsCstr) {
JsonVariant variant = 4.2;
ASSERT_FALSE(variant.as<const char*>());
}
SECTION("DoubleAsCstr") {
JsonVariant variant = 4.2;
REQUIRE_FALSE(variant.as<const char*>());
}
TEST(JsonVariant_As_Tests, DoubleAsString) {
JsonVariant variant = 4.2;
ASSERT_EQ(std::string("4.20"), variant.as<std::string>());
}
SECTION("DoubleAsString") {
JsonVariant variant = 4.2;
REQUIRE(std::string("4.20") == variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, DoubleAsLong) {
JsonVariant variant = 4.2;
ASSERT_EQ(4L, variant.as<long>());
}
SECTION("DoubleAsLong") {
JsonVariant variant = 4.2;
REQUIRE(4L == variant.as<long>());
}
TEST(JsonVariant_As_Tests, DoubleAsUnsigned) {
JsonVariant variant = 4.2;
ASSERT_EQ(4U, variant.as<unsigned>());
}
SECTION("DoubleAsUnsigned") {
JsonVariant variant = 4.2;
REQUIRE(4U == variant.as<unsigned>());
}
TEST(JsonVariant_As_Tests, DoubleZeroAsBool) {
JsonVariant variant = 0.0;
ASSERT_FALSE(variant.as<bool>());
}
SECTION("DoubleZeroAsBool") {
JsonVariant variant = 0.0;
REQUIRE_FALSE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, DoubleZeroAsLong) {
JsonVariant variant = 0.0;
ASSERT_EQ(0L, variant.as<long>());
}
SECTION("DoubleZeroAsLong") {
JsonVariant variant = 0.0;
REQUIRE(0L == variant.as<long>());
}
TEST(JsonVariant_As_Tests, FalseAsBool) {
JsonVariant variant = false;
ASSERT_FALSE(variant.as<bool>());
}
SECTION("FalseAsBool") {
JsonVariant variant = false;
REQUIRE_FALSE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, FalseAsDouble) {
JsonVariant variant = false;
ASSERT_EQ(0.0, variant.as<double>());
}
SECTION("FalseAsDouble") {
JsonVariant variant = false;
REQUIRE(0.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, FalseAsLong) {
JsonVariant variant = false;
ASSERT_EQ(0L, variant.as<long>());
}
SECTION("FalseAsLong") {
JsonVariant variant = false;
REQUIRE(0L == variant.as<long>());
}
TEST(JsonVariant_As_Tests, FalseAsString) {
JsonVariant variant = false;
ASSERT_EQ(std::string("false"), variant.as<std::string>());
}
SECTION("FalseAsString") {
JsonVariant variant = false;
REQUIRE(std::string("false") == variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, TrueAsBool) {
JsonVariant variant = true;
ASSERT_TRUE(variant.as<bool>());
}
SECTION("TrueAsBool") {
JsonVariant variant = true;
REQUIRE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, TrueAsDouble) {
JsonVariant variant = true;
ASSERT_EQ(1.0, variant.as<double>());
}
SECTION("TrueAsDouble") {
JsonVariant variant = true;
REQUIRE(1.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, TrueAsLong) {
JsonVariant variant = true;
ASSERT_EQ(1L, variant.as<long>());
}
SECTION("TrueAsLong") {
JsonVariant variant = true;
REQUIRE(1L == variant.as<long>());
}
TEST(JsonVariant_As_Tests, TrueAsString) {
JsonVariant variant = true;
ASSERT_EQ(std::string("true"), variant.as<std::string>());
}
SECTION("TrueAsString") {
JsonVariant variant = true;
REQUIRE(std::string("true") == variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, LongAsBool) {
JsonVariant variant = 42L;
ASSERT_TRUE(variant.as<bool>());
}
SECTION("LongAsBool") {
JsonVariant variant = 42L;
REQUIRE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, LongZeroAsBool) {
JsonVariant variant = 0L;
ASSERT_FALSE(variant.as<bool>());
}
SECTION("LongZeroAsBool") {
JsonVariant variant = 0L;
REQUIRE_FALSE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, PositiveLongAsDouble) {
JsonVariant variant = 42L;
ASSERT_EQ(42.0, variant.as<double>());
}
SECTION("PositiveLongAsDouble") {
JsonVariant variant = 42L;
REQUIRE(42.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, NegativeLongAsDouble) {
JsonVariant variant = -42L;
ASSERT_EQ(-42.0, variant.as<double>());
}
SECTION("NegativeLongAsDouble") {
JsonVariant variant = -42L;
REQUIRE(-42.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, LongAsString) {
JsonVariant variant = 42L;
ASSERT_EQ(std::string("42"), variant.as<std::string>());
}
SECTION("LongAsString") {
JsonVariant variant = 42L;
REQUIRE(std::string("42") == variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, LongZeroAsDouble) {
JsonVariant variant = 0L;
ASSERT_EQ(0.0, variant.as<double>());
}
SECTION("LongZeroAsDouble") {
JsonVariant variant = 0L;
REQUIRE(0.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, NullAsBool) {
JsonVariant variant = null;
ASSERT_FALSE(variant.as<bool>());
}
SECTION("NullAsBool") {
JsonVariant variant = null;
REQUIRE_FALSE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, NullAsDouble) {
JsonVariant variant = null;
ASSERT_EQ(0.0, variant.as<double>());
}
SECTION("NullAsDouble") {
JsonVariant variant = null;
REQUIRE(0.0 == variant.as<double>());
}
TEST(JsonVariant_As_Tests, NullAsLong) {
JsonVariant variant = null;
ASSERT_EQ(0L, variant.as<long>());
}
SECTION("NullAsLong") {
JsonVariant variant = null;
REQUIRE(0L == variant.as<long>());
}
TEST(JsonVariant_As_Tests, NullAsString) {
JsonVariant variant = null;
ASSERT_EQ(std::string("null"), variant.as<std::string>());
}
SECTION("NullAsString") {
JsonVariant variant = null;
REQUIRE(std::string("null") == variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, NumberStringAsBool) {
JsonVariant variant = "42";
ASSERT_TRUE(variant.as<bool>());
}
SECTION("NumberStringAsBool") {
JsonVariant variant = "42";
REQUIRE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, NumberStringAsLong) {
JsonVariant variant = "42";
ASSERT_EQ(42L, variant.as<long>());
}
SECTION("NumberStringAsLong") {
JsonVariant variant = "42";
REQUIRE(42L == variant.as<long>());
}
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
TEST(JsonVariant_As_Tests, NumberStringAsInt64Negative) {
JsonVariant variant = "-9223372036854775808";
ASSERT_EQ(-9223372036854775807 - 1, variant.as<long long>());
}
SECTION("NumberStringAsInt64Negative") {
JsonVariant variant = "-9223372036854775808";
REQUIRE(-9223372036854775807 - 1 == variant.as<long long>());
}
TEST(JsonVariant_As_Tests, NumberStringAsInt64Positive) {
JsonVariant variant = "9223372036854775807";
ASSERT_EQ(9223372036854775807, variant.as<long long>());
}
SECTION("NumberStringAsInt64Positive") {
JsonVariant variant = "9223372036854775807";
REQUIRE(9223372036854775807 == variant.as<long long>());
}
#endif
TEST(JsonVariant_As_Tests, RandomStringAsBool) {
JsonVariant variant = "hello";
ASSERT_FALSE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, RandomStringAsLong) {
JsonVariant variant = "hello";
ASSERT_EQ(0L, variant.as<long>());
}
TEST(JsonVariant_As_Tests, RandomStringAsConstCharPtr) {
JsonVariant variant = "hello";
ASSERT_STREQ("hello", variant.as<const char*>());
}
TEST(JsonVariant_As_Tests, RandomStringAsCharPtr) {
JsonVariant variant = "hello";
ASSERT_STREQ("hello", variant.as<char*>());
}
TEST(JsonVariant_As_Tests, RandomStringAsString) {
JsonVariant variant = "hello";
ASSERT_EQ(std::string("hello"), variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, TrueStringAsBool) {
JsonVariant variant = "true";
ASSERT_TRUE(variant.as<bool>());
}
TEST(JsonVariant_As_Tests, TrueStringAsLong) {
JsonVariant variant = "true";
ASSERT_EQ(1L, variant.as<long>());
}
TEST(JsonVariant_As_Tests, ObjectAsString) {
DynamicJsonBuffer buffer;
JsonObject& obj = buffer.createObject();
obj["key"] = "value";
JsonVariant variant = obj;
ASSERT_EQ(std::string("{\"key\":\"value\"}"), variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, ArrayAsString) {
DynamicJsonBuffer buffer;
JsonArray& arr = buffer.createArray();
arr.add(4);
arr.add(2);
JsonVariant variant = arr;
ASSERT_EQ(std::string("[4,2]"), variant.as<std::string>());
}
TEST(JsonVariant_As_Tests, ArrayAsJsonArray) {
DynamicJsonBuffer buffer;
JsonArray& arr = buffer.createArray();
JsonVariant variant = arr;
ASSERT_EQ(&arr, &variant.as<JsonArray&>());
ASSERT_EQ(&arr, &variant.as<JsonArray>()); // <- shorthand
}
TEST(JsonVariant_As_Tests, ObjectAsJsonObject) {
DynamicJsonBuffer buffer;
JsonObject& arr = buffer.createObject();
JsonVariant variant = arr;
ASSERT_EQ(&arr, &variant.as<JsonObject&>());
ASSERT_EQ(&arr, &variant.as<JsonObject>()); // <- shorthand
SECTION("RandomStringAsBool") {
JsonVariant variant = "hello";
REQUIRE_FALSE(variant.as<bool>());
}
SECTION("RandomStringAsLong") {
JsonVariant variant = "hello";
REQUIRE(0L == variant.as<long>());
}
SECTION("RandomStringAsConstCharPtr") {
JsonVariant variant = "hello";
REQUIRE(std::string("hello") == variant.as<const char*>());
}
SECTION("RandomStringAsCharPtr") {
JsonVariant variant = "hello";
REQUIRE(std::string("hello") == variant.as<char*>());
}
SECTION("RandomStringAsString") {
JsonVariant variant = "hello";
REQUIRE(std::string("hello") == variant.as<std::string>());
}
SECTION("TrueStringAsBool") {
JsonVariant variant = "true";
REQUIRE(variant.as<bool>());
}
SECTION("TrueStringAsLong") {
JsonVariant variant = "true";
REQUIRE(1L == variant.as<long>());
}
SECTION("ObjectAsString") {
DynamicJsonBuffer buffer;
JsonObject& obj = buffer.createObject();
obj["key"] = "value";
JsonVariant variant = obj;
REQUIRE(std::string("{\"key\":\"value\"}") == variant.as<std::string>());
}
SECTION("ArrayAsString") {
DynamicJsonBuffer buffer;
JsonArray& arr = buffer.createArray();
arr.add(4);
arr.add(2);
JsonVariant variant = arr;
REQUIRE(std::string("[4,2]") == variant.as<std::string>());
}
SECTION("ArrayAsJsonArray") {
DynamicJsonBuffer buffer;
JsonArray& arr = buffer.createArray();
JsonVariant variant = arr;
REQUIRE(&arr == &variant.as<JsonArray&>());
REQUIRE(&arr == &variant.as<JsonArray>()); // <- shorthand
}
SECTION("ObjectAsJsonObject") {
DynamicJsonBuffer buffer;
JsonObject& arr = buffer.createObject();
JsonVariant variant = arr;
REQUIRE(&arr == &variant.as<JsonObject&>());
REQUIRE(&arr == &variant.as<JsonObject>()); // <- shorthand
}
}

347
test/JsonVariant/compare.cpp
View File

@ -6,223 +6,230 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
class JsonVariant_Comparison_Tests : public ::testing::Test {
protected:
template <typename T>
void testValue(T low, T mid, T high) {
setValueTo(mid);
mustBeEqualTo(mid);
mustBeGreaterThan(low);
mustBeLessThan(high);
template <typename T>
void checkEquals(JsonVariant a, T b) {
REQUIRE(b == a);
REQUIRE(a == b);
REQUIRE(b <= a);
REQUIRE(a <= b);
REQUIRE(b >= a);
REQUIRE(a >= b);
REQUIRE_FALSE(b != a);
REQUIRE_FALSE(a != b);
REQUIRE_FALSE(b > a);
REQUIRE_FALSE(a > b);
REQUIRE_FALSE(b < a);
REQUIRE_FALSE(a < b);
}
template <typename T>
void checkGreater(JsonVariant a, T b) {
REQUIRE(a > b);
REQUIRE(b < a);
REQUIRE(a != b);
REQUIRE(b != a);
REQUIRE_FALSE(a < b);
REQUIRE_FALSE(b > a);
REQUIRE_FALSE(a == b);
REQUIRE_FALSE(b == a);
}
template <typename T>
void checkLower(JsonVariant a, T b) {
REQUIRE(a < b);
REQUIRE(b > a);
REQUIRE(a != b);
REQUIRE(b != a);
REQUIRE_FALSE(a > b);
REQUIRE_FALSE(b < a);
REQUIRE_FALSE(a == b);
REQUIRE_FALSE(b == a);
}
template <typename T>
void checkComparisons(T low, T mid, T high) {
checkEquals(mid, mid);
checkGreater(mid, low);
checkLower(mid, high);
}
TEST_CASE("JsonVariant comparisons") {
SECTION("Double") {
checkComparisons<double>(123.44, 123.45, 123.46);
}
private:
template <typename T>
void setValueTo(T expected) {
actual = expected;
SECTION("Float") {
checkComparisons<float>(123.44f, 123.45f, 123.46f);
}
template <typename T>
void mustBeEqualTo(T expected) {
EXPECT_EQ(expected, actual); // operator==
EXPECT_EQ(actual, expected); // operator==
EXPECT_LE(expected, actual); // operator<=
EXPECT_LE(actual, expected); // operator<=
EXPECT_GE(expected, actual); // operator>=
EXPECT_GE(actual, expected); // operator>=
SECTION("SChar") {
checkComparisons<signed char>(122, 123, 124);
}
template <typename T>
void mustBeGreaterThan(T expected) {
EXPECT_GT(actual, expected); // operator>
EXPECT_LT(expected, actual); // operator<
EXPECT_NE(actual, expected); // operator!=
EXPECT_NE(expected, actual); // operator!=
SECTION("SInt") {
checkComparisons<signed int>(122, 123, 124);
}
template <typename T>
void mustBeLessThan(T expected) {
EXPECT_LT(actual, expected); // operator<
EXPECT_GT(expected, actual); // operator<
EXPECT_NE(actual, expected); // operator!=
EXPECT_NE(expected, actual); // operator!=
SECTION("SLong") {
checkComparisons<signed long>(122L, 123L, 124L);
}
JsonVariant actual;
};
SECTION("SShort") {
checkComparisons<signed short>(122, 123, 124);
}
TEST_F(JsonVariant_Comparison_Tests, Double) {
testValue<double>(123.44, 123.45, 123.46);
}
SECTION("UChar") {
checkComparisons<unsigned char>(122, 123, 124);
}
TEST_F(JsonVariant_Comparison_Tests, Float) {
testValue<float>(123.44f, 123.45f, 123.46f);
}
SECTION("UInt") {
checkComparisons<unsigned int>(122, 123, 124);
}
TEST_F(JsonVariant_Comparison_Tests, SChar) {
testValue<signed char>(122, 123, 124);
}
SECTION("ULong") {
checkComparisons<unsigned long>(122L, 123L, 124L);
}
TEST_F(JsonVariant_Comparison_Tests, SInt) {
testValue<signed int>(122, 123, 124);
}
SECTION("UShort") {
checkComparisons<unsigned short>(122, 123, 124);
}
TEST_F(JsonVariant_Comparison_Tests, SLong) {
testValue<signed long>(122L, 123L, 124L);
}
SECTION("StringLiteral") {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.parse("\"hello\"");
TEST_F(JsonVariant_Comparison_Tests, SShort) {
testValue<signed short>(122, 123, 124);
}
REQUIRE(variant == "hello");
REQUIRE_FALSE(variant != "hello");
TEST_F(JsonVariant_Comparison_Tests, UChar) {
testValue<unsigned char>(122, 123, 124);
}
REQUIRE(variant != "world");
REQUIRE_FALSE(variant == "world");
TEST_F(JsonVariant_Comparison_Tests, UInt) {
testValue<unsigned int>(122, 123, 124);
}
REQUIRE("hello" == variant);
REQUIRE_FALSE("hello" != variant);
TEST_F(JsonVariant_Comparison_Tests, ULong) {
testValue<unsigned long>(122L, 123L, 124L);
}
REQUIRE("world" != variant);
REQUIRE_FALSE("world" == variant);
}
TEST_F(JsonVariant_Comparison_Tests, UShort) {
testValue<unsigned short>(122, 123, 124);
}
SECTION("String") {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.parse("\"hello\"");
TEST_F(JsonVariant_Comparison_Tests, StringLiteral) {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.parse("\"hello\"");
REQUIRE(variant == std::string("hello"));
REQUIRE_FALSE(variant != std::string("hello"));
ASSERT_TRUE(variant == "hello");
ASSERT_FALSE(variant != "hello");
REQUIRE(variant != std::string("world"));
REQUIRE_FALSE(variant == std::string("world"));
ASSERT_TRUE(variant != "world");
ASSERT_FALSE(variant == "world");
REQUIRE(std::string("hello") == variant);
REQUIRE_FALSE(std::string("hello") != variant);
ASSERT_TRUE("hello" == variant);
ASSERT_FALSE("hello" != variant);
REQUIRE(std::string("world") != variant);
REQUIRE_FALSE(std::string("world") == variant);
}
ASSERT_TRUE("world" != variant);
ASSERT_FALSE("world" == variant);
}
SECTION("IntegerInVariant") {
JsonVariant variant1 = 42;
JsonVariant variant2 = 42;
JsonVariant variant3 = 666;
TEST_F(JsonVariant_Comparison_Tests, String) {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.parse("\"hello\"");
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
ASSERT_TRUE(variant == std::string("hello"));
ASSERT_FALSE(variant != std::string("hello"));
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
ASSERT_TRUE(variant != std::string("world"));
ASSERT_FALSE(variant == std::string("world"));
SECTION("StringInVariant") {
JsonVariant variant1 = "0hello" + 1; // make sure they have
JsonVariant variant2 = "1hello" + 1; // different addresses
JsonVariant variant3 = "world";
ASSERT_TRUE(std::string("hello") == variant);
ASSERT_FALSE(std::string("hello") != variant);
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
ASSERT_TRUE(std::string("world") != variant);
ASSERT_FALSE(std::string("world") == variant);
}
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
TEST_F(JsonVariant_Comparison_Tests, IntegerInVariant) {
JsonVariant variant1 = 42;
JsonVariant variant2 = 42;
JsonVariant variant3 = 666;
SECTION("DoubleInVariant") {
JsonVariant variant1 = 42.0;
JsonVariant variant2 = 42.0;
JsonVariant variant3 = 666.0;
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
TEST_F(JsonVariant_Comparison_Tests, StringInVariant) {
JsonVariant variant1 = "0hello" + 1; // make sure they have
JsonVariant variant2 = "1hello" + 1; // different addresses
JsonVariant variant3 = "world";
SECTION("BoolInVariant") {
JsonVariant variant1 = true;
JsonVariant variant2 = true;
JsonVariant variant3 = false;
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
TEST_F(JsonVariant_Comparison_Tests, DoubleInVariant) {
JsonVariant variant1 = 42.0;
JsonVariant variant2 = 42.0;
JsonVariant variant3 = 666.0;
SECTION("ArrayInVariant") {
DynamicJsonBuffer jsonBuffer;
JsonArray& array1 = jsonBuffer.createArray();
JsonArray& array2 = jsonBuffer.createArray();
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
JsonVariant variant1 = array1;
JsonVariant variant2 = array1;
JsonVariant variant3 = array2;
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
TEST_F(JsonVariant_Comparison_Tests, BoolInVariant) {
JsonVariant variant1 = true;
JsonVariant variant2 = true;
JsonVariant variant3 = false;
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
SECTION("ObjectInVariant") {
DynamicJsonBuffer jsonBuffer;
JsonObject& obj1 = jsonBuffer.createObject();
JsonObject& obj2 = jsonBuffer.createObject();
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
JsonVariant variant1 = obj1;
JsonVariant variant2 = obj1;
JsonVariant variant3 = obj2;
TEST_F(JsonVariant_Comparison_Tests, ArrayInVariant) {
DynamicJsonBuffer jsonBuffer;
JsonArray& array1 = jsonBuffer.createArray();
JsonArray& array2 = jsonBuffer.createArray();
REQUIRE(variant1 == variant2);
REQUIRE_FALSE(variant1 != variant2);
JsonVariant variant1 = array1;
JsonVariant variant2 = array1;
JsonVariant variant3 = array2;
REQUIRE(variant1 != variant3);
REQUIRE_FALSE(variant1 == variant3);
}
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
SECTION("VariantsOfDifferentTypes") {
DynamicJsonBuffer jsonBuffer;
JsonVariant variants[] = {
true,
42,
666.667,
"hello",
jsonBuffer.createArray(),
jsonBuffer.createObject(),
};
size_t n = sizeof(variants) / sizeof(variants[0]);
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
TEST_F(JsonVariant_Comparison_Tests, ObjectInVariant) {
DynamicJsonBuffer jsonBuffer;
JsonObject& obj1 = jsonBuffer.createObject();
JsonObject& obj2 = jsonBuffer.createObject();
JsonVariant variant1 = obj1;
JsonVariant variant2 = obj1;
JsonVariant variant3 = obj2;
ASSERT_TRUE(variant1 == variant2);
ASSERT_FALSE(variant1 != variant2);
ASSERT_TRUE(variant1 != variant3);
ASSERT_FALSE(variant1 == variant3);
}
TEST_F(JsonVariant_Comparison_Tests, VariantsOfDifferentTypes) {
DynamicJsonBuffer jsonBuffer;
JsonVariant variants[] = {
true,
42,
666.667,
"hello",
jsonBuffer.createArray(),
jsonBuffer.createObject(),
};
size_t n = sizeof(variants) / sizeof(variants[0]);
for (size_t i = 0; i < n; i++) {
for (size_t j = i + 1; j < n; j++) {
ASSERT_TRUE(variants[i] != variants[j]);
ASSERT_FALSE(variants[i] == variants[j]);
for (size_t i = 0; i < n; i++) {
for (size_t j = i + 1; j < n; j++) {
REQUIRE(variants[i] != variants[j]);
REQUIRE_FALSE(variants[i] == variants[j]);
}
}
}
}

105
test/JsonVariant/copy.cpp
View File

@ -6,63 +6,62 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
class JsonVariant_Copy_Tests : public ::testing::Test {
protected:
TEST_CASE("JsonVariant copy") {
DynamicJsonBuffer _jsonBuffer;
JsonVariant _variant1;
JsonVariant _variant2;
};
TEST_F(JsonVariant_Copy_Tests, IntegersAreCopiedByValue) {
_variant1 = 123;
_variant2 = _variant1;
_variant1 = 456;
SECTION("IntegersAreCopiedByValue") {
_variant1 = 123;
_variant2 = _variant1;
_variant1 = 456;
EXPECT_EQ(123, _variant2.as<int>());
}
TEST_F(JsonVariant_Copy_Tests, DoublesAreCopiedByValue) {
_variant1 = 123.45;
_variant2 = _variant1;
_variant1 = 456.78;
EXPECT_EQ(123.45, _variant2.as<double>());
}
TEST_F(JsonVariant_Copy_Tests, BooleansAreCopiedByValue) {
_variant1 = true;
_variant2 = _variant1;
_variant1 = false;
EXPECT_TRUE(_variant2.as<bool>());
}
TEST_F(JsonVariant_Copy_Tests, StringsAreCopiedByValue) {
_variant1 = "hello";
_variant2 = _variant1;
_variant1 = "world";
EXPECT_STREQ("hello", _variant2.as<const char *>());
}
TEST_F(JsonVariant_Copy_Tests, ObjectsAreCopiedByReference) {
JsonObject &object = _jsonBuffer.createObject();
_variant1 = object;
object["hello"] = "world";
EXPECT_EQ(1, _variant1.as<JsonObject>().size());
}
TEST_F(JsonVariant_Copy_Tests, ArraysAreCopiedByReference) {
JsonArray &array = _jsonBuffer.createArray();
_variant1 = array;
array.add("world");
EXPECT_EQ(1, _variant1.as<JsonArray>().size());
REQUIRE(123 == _variant2.as<int>());
}
SECTION("DoublesAreCopiedByValue") {
_variant1 = 123.45;
_variant2 = _variant1;
_variant1 = 456.78;
REQUIRE(123.45 == _variant2.as<double>());
}
SECTION("BooleansAreCopiedByValue") {
_variant1 = true;
_variant2 = _variant1;
_variant1 = false;
REQUIRE(_variant2.as<bool>());
}
SECTION("StringsAreCopiedByValue") {
_variant1 = "hello";
_variant2 = _variant1;
_variant1 = "world";
REQUIRE(std::string("hello") == _variant2.as<const char *>());
}
SECTION("ObjectsAreCopiedByReference") {
JsonObject &object = _jsonBuffer.createObject();
_variant1 = object;
object["hello"] = "world";
REQUIRE(1 == _variant1.as<JsonObject>().size());
}
SECTION("ArraysAreCopiedByReference") {
JsonArray &array = _jsonBuffer.createArray();
_variant1 = array;
array.add("world");
REQUIRE(1 == _variant1.as<JsonArray>().size());
}
}

322
test/JsonVariant/is.cpp
View File

@ -6,257 +6,113 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
#define SUITE JsonVariant_Is_Tests
void checkIsArray(JsonVariant var) {
REQUIRE(var.is<JsonArray>());
REQUIRE(var.is<JsonArray&>());
REQUIRE(var.is<const JsonArray>());
REQUIRE(var.is<const JsonArray&>());
template <typename TTo, typename TFrom>
void assertIsNot(TFrom value) {
JsonVariant variant = value;
ASSERT_FALSE(variant.is<TTo>());
REQUIRE_FALSE(var.is<bool>());
REQUIRE_FALSE(var.is<double>());
REQUIRE_FALSE(var.is<float>());
REQUIRE_FALSE(var.is<int>());
REQUIRE_FALSE(var.is<long>());
REQUIRE_FALSE(var.is<const char*>());
REQUIRE_FALSE(var.is<JsonObject>());
}
template <typename TTo>
void assertIsNot(JsonArray& value) {
JsonVariant variant = value;
ASSERT_FALSE(variant.is<TTo>());
void checkIsBool(JsonVariant var) {
REQUIRE(var.is<bool>());
REQUIRE_FALSE(var.is<double>());
REQUIRE_FALSE(var.is<float>());
REQUIRE_FALSE(var.is<int>());
REQUIRE_FALSE(var.is<long>());
REQUIRE_FALSE(var.is<const char*>());
REQUIRE_FALSE(var.is<JsonArray>());
REQUIRE_FALSE(var.is<JsonObject>());
}
template <typename TTo, typename TFrom>
void assertIs(TFrom value) {
JsonVariant variant = value;
ASSERT_TRUE(variant.is<TTo>());
void checkIsFloat(JsonVariant var) {
REQUIRE(var.is<double>());
REQUIRE(var.is<float>());
REQUIRE_FALSE(var.is<bool>());
REQUIRE_FALSE(var.is<int>());
REQUIRE_FALSE(var.is<long>());
REQUIRE_FALSE(var.is<const char*>());
REQUIRE_FALSE(var.is<JsonArray>());
REQUIRE_FALSE(var.is<JsonObject>());
}
template <typename TTo>
void assertIs(JsonArray& value) {
JsonVariant variant = value;
ASSERT_TRUE(variant.is<TTo>());
void checkIsInteger(JsonVariant var) {
REQUIRE(var.is<long>());
REQUIRE(var.is<int>());
REQUIRE_FALSE(var.is<bool>());
REQUIRE_FALSE(var.is<double>());
REQUIRE_FALSE(var.is<float>());
REQUIRE_FALSE(var.is<const char*>());
REQUIRE_FALSE(var.is<JsonArray>());
REQUIRE_FALSE(var.is<JsonObject>());
}
TEST(SUITE, ArrayIsArray) {
void checkIsString(JsonVariant var) {
REQUIRE(var.is<const char*>());
REQUIRE_FALSE(var.is<bool>());
REQUIRE_FALSE(var.is<int>());
REQUIRE_FALSE(var.is<double>());
REQUIRE_FALSE(var.is<float>());
REQUIRE_FALSE(var.is<long>());
REQUIRE_FALSE(var.is<JsonArray>());
REQUIRE_FALSE(var.is<JsonObject>());
}
TEST_CASE("JsonVariant::is()") {
DynamicJsonBuffer jsonBuffer;
assertIs<JsonArray&>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotBool) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<bool>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotDouble) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<double>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotFloat) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<float>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotInt) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<int>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotLong) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<long>(jsonBuffer.createArray());
}
TEST(SUITE, ArrayIsNotString) {
DynamicJsonBuffer jsonBuffer;
assertIsNot<const char*>(jsonBuffer.createArray());
}
TEST(SUITE, BoolIsArray) {
assertIsNot<JsonArray&>(true);
}
TEST(SUITE, BoolIsBool) {
assertIs<bool>(true);
}
TEST(SUITE, BoolIsDouble) {
assertIsNot<double>(true);
}
TEST(SUITE, BoolIsFloat) {
assertIsNot<float>(true);
}
TEST(SUITE, BoolIsInt) {
assertIsNot<int>(true);
}
TEST(SUITE, BoolIsLong) {
assertIsNot<long>(true);
}
TEST(SUITE, BoolIsString) {
assertIsNot<const char*>(true);
}
SECTION("JsonArray") {
checkIsArray(jsonBuffer.createArray());
}
TEST(SUITE, DoubleIsArray) {
assertIsNot<JsonArray&>(4.2);
}
TEST(SUITE, DoubleIsBool) {
assertIsNot<bool>(4.2);
}
TEST(SUITE, DoubleIsDouble) {
assertIs<double>(4.2);
}
TEST(SUITE, DoubleIsFloat) {
assertIs<float>(4.2);
}
TEST(SUITE, DoubleIsInt) {
assertIsNot<int>(4.2);
}
TEST(SUITE, DoubleIsLong) {
assertIsNot<long>(4.2);
}
TEST(SUITE, DoubleIsString) {
assertIsNot<const char*>(4.2);
}
SECTION("bool") {
checkIsBool(true);
checkIsBool(false);
}
TEST(SUITE, LongIsArray) {
assertIsNot<JsonArray&>(42L);
}
TEST(SUITE, LongIsBool) {
assertIsNot<bool>(42L);
}
TEST(SUITE, LongIsDouble) {
assertIsNot<double>(42L);
}
TEST(SUITE, LongIsFloat) {
assertIsNot<float>(42L);
}
TEST(SUITE, LongIsInt) {
assertIs<int>(42L);
}
TEST(SUITE, LongIsLong) {
assertIs<long>(42L);
}
TEST(SUITE, LongIsString) {
assertIsNot<const char*>(42L);
}
SECTION("double") {
checkIsFloat(4.2);
}
TEST(SUITE, StringIsArray) {
assertIsNot<JsonArray&>("42");
}
TEST(SUITE, StringIsBool) {
assertIsNot<bool>("42");
}
TEST(SUITE, StringIsDouble) {
assertIsNot<double>("42");
}
TEST(SUITE, StringIsFloat) {
assertIsNot<float>("42");
}
TEST(SUITE, StringIsInt) {
assertIsNot<int>("42");
}
TEST(SUITE, StringIsLong) {
assertIsNot<long>("42");
}
TEST(SUITE, StringIsString) {
assertIs<const char*>("42");
}
SECTION("int") {
checkIsInteger(42);
}
TEST(SUITE, UnparsedTrueIsArray) {
assertIsNot<JsonArray&>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsBool) {
assertIs<bool>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsDouble) {
assertIsNot<double>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsFloat) {
assertIsNot<float>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsInt) {
assertIsNot<int>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsLong) {
assertIsNot<long>(RawJson("true"));
}
TEST(SUITE, UnparsedTrueIsString) {
assertIsNot<const char*>(RawJson("true"));
}
SECTION("long") {
checkIsInteger(42L);
}
TEST(SUITE, UnparsedFalseIsArray) {
assertIsNot<JsonArray&>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsBool) {
assertIs<bool>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsDouble) {
assertIsNot<double>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsFloat) {
assertIsNot<float>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsInt) {
assertIsNot<int>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsLong) {
assertIsNot<long>(RawJson("false"));
}
TEST(SUITE, UnparsedFalseIsString) {
assertIsNot<const char*>(RawJson("false"));
}
SECTION("string") {
checkIsString("42");
}
TEST(SUITE, UnparsedIntIsArray) {
assertIsNot<JsonArray&>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsBool) {
assertIsNot<bool>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsDouble) {
assertIsNot<double>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsFloat) {
assertIsNot<float>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsInt) {
assertIs<int>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsLong) {
assertIs<long>(RawJson("42"));
}
TEST(SUITE, UnparsedIntIsString) {
assertIsNot<const char*>(RawJson("42"));
}
SECTION("unparsed bool") {
checkIsBool(RawJson("true"));
checkIsBool(RawJson("false"));
}
TEST(SUITE, UnparsedFloatIsBool) {
assertIsNot<bool>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsDouble) {
assertIs<double>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsFloat) {
assertIs<float>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsInt) {
assertIsNot<int>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsLong) {
assertIsNot<long>(RawJson("4.2e-10"));
}
TEST(SUITE, UnparsedFloatIsStr) {
assertIsNot<const char*>(RawJson("4.2"));
}
SECTION("unparsed int") {
checkIsInteger(RawJson("42"));
}
TEST(SUITE, UnparsedNullIsArray) {
assertIsNot<JsonArray&>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsBool) {
assertIsNot<bool>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsDouble) {
assertIsNot<double>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsFloat) {
assertIsNot<float>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsInt) {
assertIsNot<int>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsLong) {
assertIsNot<long>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsConstCharPtr) {
assertIs<const char*>(RawJson("null"));
}
TEST(SUITE, UnparsedNullIsCharPtr) {
assertIs<char*>(RawJson("null"));
SECTION("unparsed float") {
checkIsFloat(RawJson("4.2e-10"));
}
SECTION("unparsed null") {
checkIsString(RawJson("null"));
}
}

172
test/JsonVariant/printTo.cpp
View File

@ -6,128 +6,104 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
#include <limits>
class JsonVariant_PrintTo_Tests : public testing::Test {
protected:
JsonVariant variant;
void check(JsonVariant variant, const std::string &expected) {
char buffer[256] = "";
size_t returnValue = variant.printTo(buffer, sizeof(buffer));
REQUIRE(expected == buffer);
REQUIRE(expected.size() == returnValue);
}
void outputMustBe(const char *expected) {
char buffer[256] = "";
size_t n = variant.printTo(buffer, sizeof(buffer));
ASSERT_STREQ(expected, buffer);
ASSERT_EQ(strlen(expected), n);
TEST_CASE("JsonVariant::printTo()") {
SECTION("Empty") {
check(JsonVariant(), "");
}
};
TEST_F(JsonVariant_PrintTo_Tests, Empty) {
outputMustBe("");
}
SECTION("Null") {
check(static_cast<char *>(0), "null");
}
TEST_F(JsonVariant_PrintTo_Tests, Null) {
variant = static_cast<char *>(0);
outputMustBe("null");
}
SECTION("String") {
check("hello", "\"hello\"");
}
TEST_F(JsonVariant_PrintTo_Tests, String) {
variant = "hello";
outputMustBe("\"hello\"");
}
SECTION("DoubleZero") {
check(0.0, "0.00");
}
TEST_F(JsonVariant_PrintTo_Tests, DoubleZero) {
variant = 0.0;
outputMustBe("0.00");
}
SECTION("DoubleDefaultDigits") {
check(3.14159265358979323846, "3.14");
}
TEST_F(JsonVariant_PrintTo_Tests, DoubleDefaultDigits) {
variant = 3.14159265358979323846;
outputMustBe("3.14");
}
SECTION("DoubleFourDigits") {
check(JsonVariant(3.14159265358979323846, 4), "3.1416");
}
TEST_F(JsonVariant_PrintTo_Tests, DoubleFourDigits) {
variant = JsonVariant(3.14159265358979323846, 4);
outputMustBe("3.1416");
}
SECTION("Infinity") {
check(std::numeric_limits<double>::infinity(), "Infinity");
}
TEST_F(JsonVariant_PrintTo_Tests, Infinity) {
variant = std::numeric_limits<double>::infinity();
outputMustBe("Infinity");
}
SECTION("MinusInfinity") {
check(-std::numeric_limits<double>::infinity(), "-Infinity");
}
TEST_F(JsonVariant_PrintTo_Tests, MinusInfinity) {
variant = -std::numeric_limits<double>::infinity();
outputMustBe("-Infinity");
}
SECTION("SignalingNaN") {
check(std::numeric_limits<double>::signaling_NaN(), "NaN");
}
TEST_F(JsonVariant_PrintTo_Tests, SignalingNaN) {
variant = std::numeric_limits<double>::signaling_NaN();
outputMustBe("NaN");
}
SECTION("QuietNaN") {
check(std::numeric_limits<double>::quiet_NaN(), "NaN");
}
TEST_F(JsonVariant_PrintTo_Tests, QuietNaN) {
variant = std::numeric_limits<double>::quiet_NaN();
outputMustBe("NaN");
}
SECTION("VeryBigPositiveDouble") {
check(JsonVariant(3.14159265358979323846e42, 4), "3.1416e42");
}
TEST_F(JsonVariant_PrintTo_Tests, VeryBigPositiveDouble) {
variant = JsonVariant(3.14159265358979323846e42, 4);
outputMustBe("3.1416e42");
}
SECTION("VeryBigNegativeDouble") {
check(JsonVariant(-3.14159265358979323846e42, 4), "-3.1416e42");
}
TEST_F(JsonVariant_PrintTo_Tests, VeryBigNegativeDouble) {
variant = JsonVariant(-3.14159265358979323846e42, 4);
outputMustBe("-3.1416e42");
}
SECTION("VerySmallPositiveDouble") {
check(JsonVariant(3.14159265358979323846e-42, 4), "3.1416e-42");
}
TEST_F(JsonVariant_PrintTo_Tests, VerySmallPositiveDouble) {
variant = JsonVariant(3.14159265358979323846e-42, 4);
outputMustBe("3.1416e-42");
}
SECTION("VerySmallNegativeDouble") {
check(JsonVariant(-3.14159265358979323846e-42, 4), "-3.1416e-42");
}
TEST_F(JsonVariant_PrintTo_Tests, VerySmallNegativeDouble) {
variant = JsonVariant(-3.14159265358979323846e-42, 4);
outputMustBe("-3.1416e-42");
}
SECTION("Integer") {
check(42, "42");
}
TEST_F(JsonVariant_PrintTo_Tests, Integer) {
variant = 42;
outputMustBe("42");
}
SECTION("NegativeLong") {
check(-42, "-42");
}
TEST_F(JsonVariant_PrintTo_Tests, NegativeLong) {
variant = -42;
outputMustBe("-42");
}
SECTION("UnsignedLong") {
check(4294967295UL, "4294967295");
}
TEST_F(JsonVariant_PrintTo_Tests, UnsignedLong) {
variant = 4294967295UL;
outputMustBe("4294967295");
}
SECTION("True") {
check(true, "true");
}
TEST_F(JsonVariant_PrintTo_Tests, True) {
variant = true;
outputMustBe("true");
}
TEST_F(JsonVariant_PrintTo_Tests, OneFalse) {
variant = false;
outputMustBe("false");
}
SECTION("OneFalse") {
check(false, "false");
}
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
TEST_F(JsonVariant_PrintTo_Tests, NegativeInt64) {
variant = -9223372036854775807 - 1;
outputMustBe("-9223372036854775808");
}
SECTION("NegativeInt64") {
check(-9223372036854775807 - 1, "-9223372036854775808");
}
TEST_F(JsonVariant_PrintTo_Tests, PositiveInt64) {
variant = 9223372036854775807;
outputMustBe("9223372036854775807");
}
SECTION("PositiveInt64") {
check(9223372036854775807, "9223372036854775807");
}
TEST_F(JsonVariant_PrintTo_Tests, UInt64) {
variant = 18446744073709551615;
outputMustBe("18446744073709551615");
}
SECTION("UInt64") {
check(18446744073709551615, "18446744073709551615");
}
#endif
}

219
test/JsonVariant/set_get.cpp
View File

@ -6,129 +6,128 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <stdint.h>
#include <catch.hpp>
#include <limits>
class JsonVariant_Storage_Tests : public ::testing::Test {
protected:
template <typename T>
void testValue(T expected) {
JsonVariant variant = expected;
EXPECT_EQ(expected, variant.as<T>());
}
template <typename T>
void testReference(T &expected) {
JsonVariant variant = expected;
EXPECT_EQ(expected, variant.as<T &>());
}
template <typename T>
void testNumericType() {
T min = std::numeric_limits<T>::min();
T max = std::numeric_limits<T>::max();
JsonVariant variantMin(min);
JsonVariant variantMax(max);
EXPECT_EQ(min, variantMin.as<T>());
EXPECT_EQ(max, variantMax.as<T>());
}
};
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
TEST_F(JsonVariant_Storage_Tests, SizeOfJsonInteger) {
ASSERT_EQ(8, sizeof(Internals::JsonInteger));
template <typename T>
void checkValue(T expected) {
JsonVariant variant = expected;
REQUIRE(expected == variant.as<T>());
}
template <typename T>
void checkReference(T &expected) {
JsonVariant variant = expected;
REQUIRE(expected == variant.as<T &>());
}
template <typename T>
void checkNumericType() {
T min = std::numeric_limits<T>::min();
T max = std::numeric_limits<T>::max();
JsonVariant variantMin(min);
JsonVariant variantMax(max);
REQUIRE(min == variantMin.as<T>());
REQUIRE(max == variantMax.as<T>());
}
TEST_CASE("JsonVariant set()/get()") {
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
SECTION("SizeOfJsonInteger") {
REQUIRE(8 == sizeof(Internals::JsonInteger));
}
#endif
TEST_F(JsonVariant_Storage_Tests, Null) {
testValue<const char *>(NULL);
}
TEST_F(JsonVariant_Storage_Tests, String) {
testValue<const char *>("hello");
}
SECTION("Null") {
checkValue<const char *>(NULL);
}
SECTION("String") {
checkValue<const char *>("hello");
}
TEST_F(JsonVariant_Storage_Tests, False) {
testValue<bool>(false);
}
TEST_F(JsonVariant_Storage_Tests, True) {
testValue<bool>(true);
}
SECTION("False") {
checkValue<bool>(false);
}
SECTION("True") {
checkValue<bool>(true);
}
TEST_F(JsonVariant_Storage_Tests, Double) {
testNumericType<double>();
}
TEST_F(JsonVariant_Storage_Tests, Float) {
testNumericType<float>();
}
TEST_F(JsonVariant_Storage_Tests, Char) {
testNumericType<char>();
}
TEST_F(JsonVariant_Storage_Tests, SChar) {
testNumericType<signed char>();
}
TEST_F(JsonVariant_Storage_Tests, SInt) {
testNumericType<signed int>();
}
TEST_F(JsonVariant_Storage_Tests, SLong) {
testNumericType<signed long>();
}
TEST_F(JsonVariant_Storage_Tests, SShort) {
testNumericType<signed short>();
}
TEST_F(JsonVariant_Storage_Tests, UChar) {
testNumericType<unsigned char>();
}
TEST_F(JsonVariant_Storage_Tests, UInt) {
testNumericType<unsigned int>();
}
TEST_F(JsonVariant_Storage_Tests, ULong) {
testNumericType<unsigned long>();
}
TEST_F(JsonVariant_Storage_Tests, UShort) {
testNumericType<unsigned short>();
}
SECTION("Double") {
checkNumericType<double>();
}
SECTION("Float") {
checkNumericType<float>();
}
SECTION("Char") {
checkNumericType<char>();
}
SECTION("SChar") {
checkNumericType<signed char>();
}
SECTION("SInt") {
checkNumericType<signed int>();
}
SECTION("SLong") {
checkNumericType<signed long>();
}
SECTION("SShort") {
checkNumericType<signed short>();
}
SECTION("UChar") {
checkNumericType<unsigned char>();
}
SECTION("UInt") {
checkNumericType<unsigned int>();
}
SECTION("ULong") {
checkNumericType<unsigned long>();
}
SECTION("UShort") {
checkNumericType<unsigned short>();
}
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
TEST_F(JsonVariant_Storage_Tests, LongLong) {
testNumericType<unsigned long long>();
}
TEST_F(JsonVariant_Storage_Tests, ULongLong) {
testNumericType<unsigned long long>();
}
SECTION("LongLong") {
checkNumericType<unsigned long long>();
}
SECTION("ULongLong") {
checkNumericType<unsigned long long>();
}
#endif
TEST_F(JsonVariant_Storage_Tests, Int8) {
testNumericType<int8_t>();
}
TEST_F(JsonVariant_Storage_Tests, Uint8) {
testNumericType<uint8_t>();
}
TEST_F(JsonVariant_Storage_Tests, Int16) {
testNumericType<int16_t>();
}
TEST_F(JsonVariant_Storage_Tests, Uint16) {
testNumericType<uint16_t>();
}
TEST_F(JsonVariant_Storage_Tests, Int32) {
testNumericType<int32_t>();
}
TEST_F(JsonVariant_Storage_Tests, Uint32) {
testNumericType<uint32_t>();
}
SECTION("Int8") {
checkNumericType<int8_t>();
}
SECTION("Uint8") {
checkNumericType<uint8_t>();
}
SECTION("Int16") {
checkNumericType<int16_t>();
}
SECTION("Uint16") {
checkNumericType<uint16_t>();
}
SECTION("Int32") {
checkNumericType<int32_t>();
}
SECTION("Uint32") {
checkNumericType<uint32_t>();
}
#if ARDUINOJSON_USE_LONG_LONG || ARDUINOJSON_USE_INT64
TEST_F(JsonVariant_Storage_Tests, Int64) {
testNumericType<int64_t>();
}
TEST_F(JsonVariant_Storage_Tests, Uint64) {
testNumericType<uint64_t>();
}
SECTION("Int64") {
checkNumericType<int64_t>();
}
SECTION("Uint64") {
checkNumericType<uint64_t>();
}
#endif
TEST_F(JsonVariant_Storage_Tests, CanStoreObject) {
DynamicJsonBuffer jsonBuffer;
JsonObject &object = jsonBuffer.createObject();
SECTION("CanStoreObject") {
DynamicJsonBuffer jsonBuffer;
JsonObject &object = jsonBuffer.createObject();
testReference(object);
checkReference(object);
}
}

134
test/JsonVariant/subscript.cpp
View File

@ -6,77 +6,75 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
class JsonVariant_Subscript_Tests : public ::testing::Test {
protected:
TEST_CASE("JsonVariant::operator[]") {
DynamicJsonBuffer _jsonBuffer;
JsonVariant _variant;
};
TEST_F(JsonVariant_Subscript_Tests, Array) {
JsonArray &array = _jsonBuffer.createArray();
array.add("element at index 0");
array.add("element at index 1");
SECTION("Array") {
JsonArray &array = _jsonBuffer.createArray();
array.add("element at index 0");
array.add("element at index 1");
_variant = array;
JsonVariant var = array;
EXPECT_EQ(2, _variant.size());
EXPECT_STREQ("element at index 0", _variant[0]);
EXPECT_STREQ("element at index 1", _variant[1]);
EXPECT_STREQ("element at index 0",
_variant[static_cast<unsigned char>(0)]); // issue #381
EXPECT_FALSE(_variant[-1].success());
EXPECT_FALSE(_variant[3].success());
EXPECT_FALSE(_variant["0"].success());
}
TEST_F(JsonVariant_Subscript_Tests, Object) {
JsonObject &object = _jsonBuffer.createObject();
object["a"] = "element at key \"a\"";
object["b"] = "element at key \"b\"";
_variant = object;
EXPECT_EQ(2, _variant.size());
EXPECT_STREQ("element at key \"a\"", _variant["a"]);
EXPECT_STREQ("element at key \"b\"", _variant["b"]);
EXPECT_FALSE(_variant["c"].success());
EXPECT_FALSE(_variant[0].success());
}
TEST_F(JsonVariant_Subscript_Tests, Undefined) {
_variant = JsonVariant();
EXPECT_EQ(0, _variant.size());
EXPECT_FALSE(_variant["0"].success());
EXPECT_FALSE(_variant[0].success());
}
TEST_F(JsonVariant_Subscript_Tests, String) {
_variant = "hello world";
EXPECT_EQ(0, _variant.size());
EXPECT_FALSE(_variant["0"].success());
EXPECT_FALSE(_variant[0].success());
}
TEST_F(JsonVariant_Subscript_Tests, ObjectSetValue) {
_variant = _jsonBuffer.createObject();
_variant["hello"] = "world";
EXPECT_EQ(1, _variant.size());
EXPECT_STREQ("world", _variant["hello"]);
}
TEST_F(JsonVariant_Subscript_Tests, ArraySetValue) {
_variant = _jsonBuffer.parseArray("[\"hello\"]");
_variant[0] = "world";
EXPECT_EQ(1, _variant.size());
EXPECT_STREQ("world", _variant[0]);
}
TEST_F(JsonVariant_Subscript_Tests, NestedObjectSetValue) {
_variant = _jsonBuffer.parseArray("[{}]");
_variant[0]["hello"] = "world";
EXPECT_EQ(1, _variant.size());
EXPECT_EQ(1, _variant[0].size());
EXPECT_STREQ("world", _variant[0]["hello"]);
REQUIRE(2 == var.size());
REQUIRE(std::string("element at index 0") == var[0]);
REQUIRE(std::string("element at index 1") == var[1]);
REQUIRE(std::string("element at index 0") ==
var[static_cast<unsigned char>(0)]); // issue #381
REQUIRE_FALSE(var[-1].success());
REQUIRE_FALSE(var[3].success());
REQUIRE_FALSE(var["0"].success());
}
SECTION("Object") {
JsonObject &object = _jsonBuffer.createObject();
object["a"] = "element at key \"a\"";
object["b"] = "element at key \"b\"";
JsonVariant var = object;
REQUIRE(2 == var.size());
REQUIRE(std::string("element at key \"a\"") == var["a"]);
REQUIRE(std::string("element at key \"b\"") == var["b"]);
REQUIRE_FALSE(var["c"].success());
REQUIRE_FALSE(var[0].success());
}
SECTION("Undefined") {
JsonVariant var = JsonVariant();
REQUIRE(0 == var.size());
REQUIRE_FALSE(var["0"].success());
REQUIRE_FALSE(var[0].success());
}
SECTION("String") {
JsonVariant var = "hello world";
REQUIRE(0 == var.size());
REQUIRE_FALSE(var["0"].success());
REQUIRE_FALSE(var[0].success());
}
SECTION("ObjectSetValue") {
JsonVariant var = _jsonBuffer.createObject();
var["hello"] = "world";
REQUIRE(1 == var.size());
REQUIRE(std::string("world") == var["hello"]);
}
SECTION("ArraySetValue") {
JsonVariant var = _jsonBuffer.parseArray("[\"hello\"]");
var[0] = "world";
REQUIRE(1 == var.size());
REQUIRE(std::string("world") == var[0]);
}
SECTION("NestedObjectSetValue") {
JsonVariant var = _jsonBuffer.parseArray("[{}]");
var[0]["hello"] = "world";
REQUIRE(1 == var.size());
REQUIRE(1 == var[0].size());
REQUIRE(std::string("world") == var[0]["hello"]);
}
}

68
test/JsonVariant/success.cpp
View File

@ -6,38 +6,40 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenUndefined) {
JsonVariant variant;
EXPECT_FALSE(variant.success());
}
TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenInteger) {
JsonVariant variant = 0;
EXPECT_TRUE(variant.success());
}
TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenEmptyArray) {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.createArray();
EXPECT_TRUE(variant.success());
}
TEST(JsonVariant_Success_Tests, ReturnsTrue_WhenEmptyObject) {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.createObject();
EXPECT_TRUE(variant.success());
}
TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenInvalidArray) {
JsonVariant variant = JsonArray::invalid();
EXPECT_FALSE(variant.success());
}
TEST(JsonVariant_Success_Tests, ReturnsFalse_WhenInvalidObject) {
JsonVariant variant = JsonObject::invalid();
EXPECT_FALSE(variant.success());
TEST_CASE("JsonVariant::success()") {
SECTION("ReturnsFalse_WhenUndefined") {
JsonVariant variant;
REQUIRE(false == variant.success());
}
SECTION("ReturnsTrue_WhenInteger") {
JsonVariant variant = 0;
REQUIRE(true == variant.success());
}
SECTION("ReturnsTrue_WhenEmptyArray") {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.createArray();
REQUIRE(true == variant.success());
}
SECTION("ReturnsTrue_WhenEmptyObject") {
DynamicJsonBuffer jsonBuffer;
JsonVariant variant = jsonBuffer.createObject();
REQUIRE(true == variant.success());
}
SECTION("ReturnsFalse_WhenInvalidArray") {
JsonVariant variant = JsonArray::invalid();
REQUIRE(false == variant.success());
}
SECTION("ReturnsFalse_WhenInvalidObject") {
JsonVariant variant = JsonObject::invalid();
REQUIRE(false == variant.success());
}
}

71
test/JsonVariant/undefined.cpp
View File

@ -6,53 +6,52 @@
// If you like this project, please add a star!
#include <ArduinoJson.h>
#include <gtest/gtest.h>
#include <catch.hpp>
class JsonVariant_Undefined_Tests : public ::testing::Test {
protected:
TEST_CASE("JsonVariant undefined") {
JsonVariant variant;
};
TEST_F(JsonVariant_Undefined_Tests, AsLongReturns0) {
EXPECT_EQ(0, variant.as<long>());
}
SECTION("AsLongReturns0") {
REQUIRE(0 == variant.as<long>());
}
TEST_F(JsonVariant_Undefined_Tests, AsUnsignedReturns0) {
EXPECT_EQ(0, variant.as<unsigned>());
}
SECTION("AsUnsignedReturns0") {
REQUIRE(0 == variant.as<unsigned>());
}
TEST_F(JsonVariant_Undefined_Tests, AsStringReturnsNull) {
EXPECT_EQ(0, variant.as<char*>());
}
SECTION("AsStringReturnsNull") {
REQUIRE(0 == variant.as<char*>());
}
TEST_F(JsonVariant_Undefined_Tests, AsDoubleReturns0) {
EXPECT_EQ(0, variant.as<double>());
}
SECTION("AsDoubleReturns0") {
REQUIRE(0 == variant.as<double>());
}
TEST_F(JsonVariant_Undefined_Tests, AsBoolReturnsFalse) {
EXPECT_FALSE(variant.as<bool>());
}
SECTION("AsBoolReturnsFalse") {
REQUIRE(false == variant.as<bool>());
}
TEST_F(JsonVariant_Undefined_Tests, AsArrayReturnInvalid) {
EXPECT_EQ(JsonArray::invalid(), variant.as<JsonArray&>());
}
SECTION("AsArrayReturnInvalid") {
REQUIRE(JsonArray::invalid() == variant.as<JsonArray&>());
}
TEST_F(JsonVariant_Undefined_Tests, AsConstArrayReturnInvalid) {
EXPECT_EQ(JsonArray::invalid(), variant.as<const JsonArray&>());
}
SECTION("AsConstArrayReturnInvalid") {
REQUIRE(JsonArray::invalid() == variant.as<const JsonArray&>());
}
TEST_F(JsonVariant_Undefined_Tests, AsObjectReturnInvalid) {
EXPECT_EQ(JsonObject::invalid(), variant.as<JsonObject&>());
}
SECTION("AsObjectReturnInvalid") {
REQUIRE(JsonObject::invalid() == variant.as<JsonObject&>());
}
TEST_F(JsonVariant_Undefined_Tests, AsConstObjectReturnInvalid) {
EXPECT_EQ(JsonObject::invalid(), variant.as<const JsonObject&>());
}
SECTION("AsConstObjectReturnInvalid") {
REQUIRE(JsonObject::invalid() == variant.as<const JsonObject&>());
}
TEST_F(JsonVariant_Undefined_Tests, AsArrayWrapperReturnInvalid) {
EXPECT_EQ(JsonArray::invalid(), variant.as<JsonArray>());
}
SECTION("AsArrayWrapperReturnInvalid") {
REQUIRE(JsonArray::invalid() == variant.as<JsonArray>());
}
TEST_F(JsonVariant_Undefined_Tests, AsObjectWrapperReturnInvalid) {
EXPECT_EQ(JsonObject::invalid(), variant.as<JsonObject>());
SECTION("AsObjectWrapperReturnInvalid") {
REQUIRE(JsonObject::invalid() == variant.as<JsonObject>());
}
}