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

Update Catch library to 2.13.10 (#1820)

Browse Source
This commit is contained in:
Benoit Blanchon
2023-02-09 18:56:14 +01:00
parent 94b2b3f9ce
commit 007b4f3362
13 changed files with 15894 additions and 9740 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
extras/tests/Cpp17/string_view.cpp
View File

@ -1,6 +1,6 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <string_view> #include <string_view>
#if !ARDUINOJSON_ENABLE_STRING_VIEW #if !ARDUINOJSON_ENABLE_STRING_VIEW

2
extras/tests/JsonDeserializer/DeserializationError.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
void testStringification(DeserializationError error, std::string expected) { void testStringification(DeserializationError error, std::string expected) {
REQUIRE(error.c_str() == expected); REQUIRE(error.c_str() == expected);
} }

2
extras/tests/JsonDeserializer/nestingLimit.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
#define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression); #define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression);
#define SHOULD_FAIL(expression) \ #define SHOULD_FAIL(expression) \
REQUIRE(DeserializationError::TooDeep == expression); REQUIRE(DeserializationError::TooDeep == expression);

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

@ -11,15 +11,15 @@ TEST_CASE("nullptr") {
JsonVariant variant = doc.to<JsonVariant>(); JsonVariant variant = doc.to<JsonVariant>();
SECTION("JsonVariant == nullptr") { SECTION("JsonVariant == nullptr") {
REQUIRE((variant == nullptr)); REQUIRE(variant == nullptr);
REQUIRE_FALSE((variant != nullptr)); REQUIRE_FALSE(variant != nullptr);
} }
SECTION("JsonVariant != nullptr") { SECTION("JsonVariant != nullptr") {
variant.set(42); variant.set(42);
REQUIRE_FALSE((variant == nullptr)); REQUIRE_FALSE(variant == nullptr);
REQUIRE((variant != nullptr)); REQUIRE(variant != nullptr);
} }
SECTION("JsonVariant.set(nullptr)") { SECTION("JsonVariant.set(nullptr)") {

2
extras/tests/Misc/Readers.cpp
View File

@ -6,6 +6,8 @@
#include <ArduinoJson.hpp> #include <ArduinoJson.hpp>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
using namespace ARDUINOJSON_NAMESPACE; using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("Reader<std::istringstream>") { TEST_CASE("Reader<std::istringstream>") {

59
extras/tests/Misc/TypeTraits.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
using namespace ARDUINOJSON_NAMESPACE; using namespace ARDUINOJSON_NAMESPACE;
class EmptyClass {}; class EmptyClass {};
@ -19,9 +21,9 @@ TEST_CASE("Polyfills/type_traits") {
} }
SECTION("is_array") { SECTION("is_array") {
REQUIRE_FALSE((is_array<const char*>::value)); REQUIRE_FALSE(is_array<const char*>::value);
REQUIRE((is_array<const char[]>::value)); REQUIRE(is_array<const char[]>::value);
REQUIRE((is_array<const char[10]>::value)); REQUIRE(is_array<const char[10]>::value);
} }
SECTION("is_const") { SECTION("is_const") {
@ -172,36 +174,35 @@ TEST_CASE("Polyfills/type_traits") {
} }
SECTION("is_convertible") { SECTION("is_convertible") {
CHECK((is_convertible<short, int>::value == true)); CHECK(is_convertible<short, int>::value == true);
CHECK((is_convertible<int, int>::value == true)); CHECK(is_convertible<int, int>::value == true);
CHECK((is_convertible<EmptyEnum, int>::value == true)); CHECK(is_convertible<EmptyEnum, int>::value == true);
CHECK((is_convertible<int*, int>::value == false)); CHECK(is_convertible<int*, int>::value == false);
CHECK((is_convertible<EmptyClass, int>::value == false)); CHECK(is_convertible<EmptyClass, int>::value == false);
CHECK((is_convertible<DeserializationError, JsonVariantConst>::value == CHECK(is_convertible<DeserializationError, JsonVariantConst>::value ==
false)); false);
CHECK((is_convertible<JsonPair, JsonVariantConst>::value == false)); CHECK(is_convertible<JsonPair, JsonVariantConst>::value == false);
CHECK((is_convertible<JsonVariant, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonVariant, JsonVariantConst>::value == true);
CHECK((is_convertible<JsonVariantConst, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonVariantConst, JsonVariantConst>::value == true);
CHECK((is_convertible<JsonArray, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonArray, JsonVariantConst>::value == true);
CHECK((is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value == CHECK(is_convertible<ElementProxy<JsonArray>, JsonVariantConst>::value ==
true)); true);
CHECK((is_convertible<JsonArrayConst, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonArrayConst, JsonVariantConst>::value == true);
CHECK((is_convertible<JsonObject, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonObject, JsonVariantConst>::value == true);
CHECK((is_convertible<MemberProxy<JsonObject, const char*>, CHECK(is_convertible<MemberProxy<JsonObject, const char*>,
JsonVariantConst>::value == true)); JsonVariantConst>::value == true);
CHECK((is_convertible<JsonObjectConst, JsonVariantConst>::value == true)); CHECK(is_convertible<JsonObjectConst, JsonVariantConst>::value == true);
CHECK( CHECK(is_convertible<DynamicJsonDocument, JsonVariantConst>::value == true);
(is_convertible<DynamicJsonDocument, JsonVariantConst>::value == true)); CHECK(is_convertible<StaticJsonDocument<10>, JsonVariantConst>::value ==
CHECK((is_convertible<StaticJsonDocument<10>, JsonVariantConst>::value == true);
true));
} }
SECTION("is_class") { SECTION("is_class") {
CHECK((is_class<int>::value == false)); CHECK(is_class<int>::value == false);
CHECK((is_class<EmptyEnum>::value == false)); CHECK(is_class<EmptyEnum>::value == false);
CHECK((is_class<int*>::value == false)); CHECK(is_class<int*>::value == false);
CHECK((is_class<EmptyClass>::value == true)); CHECK(is_class<EmptyClass>::value == true);
} }
SECTION("is_enum") { SECTION("is_enum") {

100
extras/tests/Misc/arithmeticCompare.cpp
View File

@ -9,95 +9,89 @@ using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("arithmeticCompare()") { TEST_CASE("arithmeticCompare()") {
SECTION("int vs uint8_t") { SECTION("int vs uint8_t") {
CHECK((arithmeticCompare<int, uint8_t>(256, 1) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<int, uint8_t>(256, 1) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<int, uint8_t>(41, 42) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<int, uint8_t>(41, 42) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompare<int, uint8_t>(42, 42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<int, uint8_t>(42, 42) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<int, uint8_t>(43, 42) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<int, uint8_t>(43, 42) == COMPARE_RESULT_GREATER);
} }
SECTION("unsigned vs int") { SECTION("unsigned vs int") {
CHECK((arithmeticCompare<unsigned, int>(0, -1) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<unsigned, int>(0, -1) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<unsigned, int>(42, 41) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<unsigned, int>(42, 41) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<unsigned, int>(42, 42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<unsigned, int>(42, 42) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<unsigned, int>(42, 43) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<unsigned, int>(42, 43) == COMPARE_RESULT_LESS);
} }
SECTION("float vs int") { SECTION("float vs int") {
CHECK((arithmeticCompare<float, int>(42, 41) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<float, int>(42, 41) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<float, int>(42, 42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<float, int>(42, 42) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<float, int>(42, 43) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<float, int>(42, 43) == COMPARE_RESULT_LESS);
} }
SECTION("int vs unsigned") { SECTION("int vs unsigned") {
CHECK((arithmeticCompare<int, unsigned>(-1, 0) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<int, unsigned>(-1, 0) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompare<int, unsigned>(0, 0) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<int, unsigned>(0, 0) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<int, unsigned>(1, 0) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<int, unsigned>(1, 0) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<int, unsigned>(42, 41) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<int, unsigned>(42, 41) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<int, unsigned>(42, 42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<int, unsigned>(42, 42) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<int, unsigned>(42, 43) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<int, unsigned>(42, 43) == COMPARE_RESULT_LESS);
} }
SECTION("unsigned vs unsigned") { SECTION("unsigned vs unsigned") {
CHECK((arithmeticCompare<unsigned, unsigned>(42, 41) == CHECK(arithmeticCompare<unsigned, unsigned>(42, 41) ==
COMPARE_RESULT_GREATER)); COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<unsigned, unsigned>(42, 42) == CHECK(arithmeticCompare<unsigned, unsigned>(42, 42) ==
COMPARE_RESULT_EQUAL)); COMPARE_RESULT_EQUAL);
CHECK( CHECK(arithmeticCompare<unsigned, unsigned>(42, 43) == COMPARE_RESULT_LESS);
(arithmeticCompare<unsigned, unsigned>(42, 43) == COMPARE_RESULT_LESS));
} }
SECTION("bool vs bool") { SECTION("bool vs bool") {
CHECK( CHECK(arithmeticCompare<bool, bool>(false, false) == COMPARE_RESULT_EQUAL);
(arithmeticCompare<bool, bool>(false, false) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<bool, bool>(true, true) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<bool, bool>(true, true) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<bool, bool>(false, true) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompare<bool, bool>(false, true) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<bool, bool>(true, false) == COMPARE_RESULT_GREATER);
CHECK(
(arithmeticCompare<bool, bool>(true, false) == COMPARE_RESULT_GREATER));
} }
SECTION("bool vs int") { SECTION("bool vs int") {
CHECK((arithmeticCompare<bool, int>(false, -1) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<bool, int>(false, -1) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<bool, int>(false, 0) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<bool, int>(false, 0) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<bool, int>(false, 1) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<bool, int>(false, 1) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompare<bool, int>(true, 0) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<bool, int>(true, 0) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<bool, int>(true, 1) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<bool, int>(true, 1) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<bool, int>(true, 2) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<bool, int>(true, 2) == COMPARE_RESULT_LESS);
} }
SECTION("bool vs int") { SECTION("bool vs int") {
CHECK((arithmeticCompare<int, bool>(0, false) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<int, bool>(0, false) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<int, bool>(1, true) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompare<int, bool>(1, true) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompare<int, bool>(1, false) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompare<int, bool>(1, false) == COMPARE_RESULT_GREATER);
CHECK((arithmeticCompare<int, bool>(0, true) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompare<int, bool>(0, true) == COMPARE_RESULT_LESS);
} }
} }
TEST_CASE("arithmeticCompareNegateLeft()") { TEST_CASE("arithmeticCompareNegateLeft()") {
SECTION("unsigned vs int") { SECTION("unsigned vs int") {
CHECK((arithmeticCompareNegateLeft<int>(0, 1) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompareNegateLeft<int>(0, 1) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompareNegateLeft<int>(42, -41) == COMPARE_RESULT_LESS)); CHECK(arithmeticCompareNegateLeft<int>(42, -41) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompareNegateLeft<int>(42, -42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompareNegateLeft<int>(42, -42) == COMPARE_RESULT_EQUAL);
CHECK( CHECK(arithmeticCompareNegateLeft<int>(42, -43) == COMPARE_RESULT_GREATER);
(arithmeticCompareNegateLeft<int>(42, -43) == COMPARE_RESULT_GREATER));
} }
SECTION("unsigned vs unsigned") { SECTION("unsigned vs unsigned") {
CHECK( CHECK(arithmeticCompareNegateLeft<unsigned>(42, 42) == COMPARE_RESULT_LESS);
(arithmeticCompareNegateLeft<unsigned>(42, 42) == COMPARE_RESULT_LESS));
} }
} }
TEST_CASE("arithmeticCompareNegateRight()") { TEST_CASE("arithmeticCompareNegateRight()") {
SECTION("int vs unsigned") { SECTION("int vs unsigned") {
CHECK((arithmeticCompareNegateRight<int>(1, 0) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompareNegateRight<int>(1, 0) == COMPARE_RESULT_GREATER);
CHECK( CHECK(arithmeticCompareNegateRight<int>(-41, 42) == COMPARE_RESULT_GREATER);
(arithmeticCompareNegateRight<int>(-41, 42) == COMPARE_RESULT_GREATER)); CHECK(arithmeticCompareNegateRight<int>(-42, 42) == COMPARE_RESULT_EQUAL);
CHECK((arithmeticCompareNegateRight<int>(-42, 42) == COMPARE_RESULT_EQUAL)); CHECK(arithmeticCompareNegateRight<int>(-43, 42) == COMPARE_RESULT_LESS);
CHECK((arithmeticCompareNegateRight<int>(-43, 42) == COMPARE_RESULT_LESS));
} }
SECTION("unsigned vs unsigned") { SECTION("unsigned vs unsigned") {
CHECK((arithmeticCompareNegateRight<unsigned>(42, 42) == CHECK(arithmeticCompareNegateRight<unsigned>(42, 42) ==
COMPARE_RESULT_GREATER)); COMPARE_RESULT_GREATER);
} }
} }

2
extras/tests/MsgPackDeserializer/filter.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
using namespace ARDUINOJSON_NAMESPACE; using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("deserializeMsgPack() filter") { TEST_CASE("deserializeMsgPack() filter") {

2
extras/tests/MsgPackDeserializer/misc.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
TEST_CASE("deserializeMsgPack() returns EmptyInput") { TEST_CASE("deserializeMsgPack() returns EmptyInput") {
StaticJsonDocument<100> doc; StaticJsonDocument<100> doc;

2
extras/tests/MsgPackDeserializer/nestingLimit.cpp
View File

@ -5,6 +5,8 @@
#include <ArduinoJson.h> #include <ArduinoJson.h>
#include <catch.hpp> #include <catch.hpp>
#include <sstream>
#define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression); #define SHOULD_WORK(expression) REQUIRE(DeserializationError::Ok == expression);
#define SHOULD_FAIL(expression) \ #define SHOULD_FAIL(expression) \
REQUIRE(DeserializationError::TooDeep == expression); REQUIRE(DeserializationError::TooDeep == expression);

137
extras/tests/Numbers/convertNumber.cpp
View File

@ -10,126 +10,123 @@ using namespace ARDUINOJSON_NAMESPACE;
TEST_CASE("canConvertNumber<TOut, TIn>()") { TEST_CASE("canConvertNumber<TOut, TIn>()") {
SECTION("int8_t -> int8_t") { SECTION("int8_t -> int8_t") {
CHECK((canConvertNumber<int8_t, int8_t>(0)) == true); CHECK(canConvertNumber<int8_t, int8_t>(0) == true);
CHECK((canConvertNumber<int8_t, int8_t>(127)) == true); CHECK(canConvertNumber<int8_t, int8_t>(127) == true);
CHECK((canConvertNumber<int8_t, int8_t>(-128)) == true); CHECK(canConvertNumber<int8_t, int8_t>(-128) == true);
} }
SECTION("int8_t -> int16_t") { SECTION("int8_t -> int16_t") {
CHECK((canConvertNumber<int16_t, int8_t>(0)) == true); CHECK(canConvertNumber<int16_t, int8_t>(0) == true);
CHECK((canConvertNumber<int16_t, int8_t>(127)) == true); CHECK(canConvertNumber<int16_t, int8_t>(127) == true);
CHECK((canConvertNumber<int16_t, int8_t>(-128)) == true); CHECK(canConvertNumber<int16_t, int8_t>(-128) == true);
} }
SECTION("int8_t -> uint8_t") { SECTION("int8_t -> uint8_t") {
CHECK((canConvertNumber<uint8_t, int8_t>(0)) == true); CHECK(canConvertNumber<uint8_t, int8_t>(0) == true);
CHECK((canConvertNumber<uint8_t, int8_t>(127)) == true); CHECK(canConvertNumber<uint8_t, int8_t>(127) == true);
CHECK((canConvertNumber<uint8_t, int8_t>(-128)) == false); CHECK(canConvertNumber<uint8_t, int8_t>(-128) == false);
} }
SECTION("int8_t -> uint16_t") { SECTION("int8_t -> uint16_t") {
CHECK((canConvertNumber<uint16_t, int8_t>(0)) == true); CHECK(canConvertNumber<uint16_t, int8_t>(0) == true);
CHECK((canConvertNumber<uint16_t, int8_t>(127)) == true); CHECK(canConvertNumber<uint16_t, int8_t>(127) == true);
CHECK((canConvertNumber<uint16_t, int8_t>(-128)) == false); CHECK(canConvertNumber<uint16_t, int8_t>(-128) == false);
} }
SECTION("int16_t -> int8_t") { SECTION("int16_t -> int8_t") {
CHECK((canConvertNumber<int8_t, int16_t>(0)) == true); CHECK(canConvertNumber<int8_t, int16_t>(0) == true);
CHECK((canConvertNumber<int8_t, int16_t>(127)) == true); CHECK(canConvertNumber<int8_t, int16_t>(127) == true);
CHECK((canConvertNumber<int8_t, int16_t>(128)) == false); CHECK(canConvertNumber<int8_t, int16_t>(128) == false);
CHECK((canConvertNumber<int8_t, int16_t>(-128)) == true); CHECK(canConvertNumber<int8_t, int16_t>(-128) == true);
CHECK((canConvertNumber<int8_t, int16_t>(-129)) == false); CHECK(canConvertNumber<int8_t, int16_t>(-129) == false);
} }
SECTION("int16_t -> uint8_t") { SECTION("int16_t -> uint8_t") {
CHECK((canConvertNumber<uint8_t, int16_t>(0)) == true); CHECK(canConvertNumber<uint8_t, int16_t>(0) == true);
CHECK((canConvertNumber<uint8_t, int16_t>(255)) == true); CHECK(canConvertNumber<uint8_t, int16_t>(255) == true);
CHECK((canConvertNumber<uint8_t, int16_t>(256)) == false); CHECK(canConvertNumber<uint8_t, int16_t>(256) == false);
CHECK((canConvertNumber<uint8_t, int16_t>(-1)) == false); CHECK(canConvertNumber<uint8_t, int16_t>(-1) == false);
} }
SECTION("uint8_t -> int8_t") { SECTION("uint8_t -> int8_t") {
CHECK((canConvertNumber<int8_t, uint8_t>(0)) == true); CHECK(canConvertNumber<int8_t, uint8_t>(0) == true);
CHECK((canConvertNumber<int8_t, uint8_t>(127)) == true); CHECK(canConvertNumber<int8_t, uint8_t>(127) == true);
CHECK((canConvertNumber<int8_t, uint8_t>(128)) == false); CHECK(canConvertNumber<int8_t, uint8_t>(128) == false);
CHECK((canConvertNumber<int8_t, uint8_t>(255)) == false); CHECK(canConvertNumber<int8_t, uint8_t>(255) == false);
} }
SECTION("uint8_t -> int16_t") { SECTION("uint8_t -> int16_t") {
CHECK((canConvertNumber<int16_t, uint8_t>(0)) == true); CHECK(canConvertNumber<int16_t, uint8_t>(0) == true);
CHECK((canConvertNumber<int16_t, uint8_t>(127)) == true); CHECK(canConvertNumber<int16_t, uint8_t>(127) == true);
CHECK((canConvertNumber<int16_t, uint8_t>(128)) == true); CHECK(canConvertNumber<int16_t, uint8_t>(128) == true);
CHECK((canConvertNumber<int16_t, uint8_t>(255)) == true); CHECK(canConvertNumber<int16_t, uint8_t>(255) == true);
} }
SECTION("uint8_t -> uint8_t") { SECTION("uint8_t -> uint8_t") {
CHECK((canConvertNumber<uint8_t, uint8_t>(0)) == true); CHECK(canConvertNumber<uint8_t, uint8_t>(0) == true);
CHECK((canConvertNumber<uint8_t, uint8_t>(127)) == true); CHECK(canConvertNumber<uint8_t, uint8_t>(127) == true);
CHECK((canConvertNumber<uint8_t, uint8_t>(128)) == true); CHECK(canConvertNumber<uint8_t, uint8_t>(128) == true);
CHECK((canConvertNumber<uint8_t, uint8_t>(255)) == true); CHECK(canConvertNumber<uint8_t, uint8_t>(255) == true);
} }
SECTION("uint8_t -> uint16_t") { SECTION("uint8_t -> uint16_t") {
CHECK((canConvertNumber<uint16_t, uint8_t>(0)) == true); CHECK(canConvertNumber<uint16_t, uint8_t>(0) == true);
CHECK((canConvertNumber<uint16_t, uint8_t>(127)) == true); CHECK(canConvertNumber<uint16_t, uint8_t>(127) == true);
CHECK((canConvertNumber<uint16_t, uint8_t>(128)) == true); CHECK(canConvertNumber<uint16_t, uint8_t>(128) == true);
CHECK((canConvertNumber<uint16_t, uint8_t>(255)) == true); CHECK(canConvertNumber<uint16_t, uint8_t>(255) == true);
} }
SECTION("float -> int32_t") { SECTION("float -> int32_t") {
CHECK((canConvertNumber<int32_t, float>(0)) == true); CHECK(canConvertNumber<int32_t, float>(0) == true);
CHECK((canConvertNumber<int32_t, float>(-2.147483904e9f)) == false); CHECK(canConvertNumber<int32_t, float>(-2.147483904e9f) == false);
CHECK((canConvertNumber<int32_t, float>(-2.147483648e+9f)) == true); CHECK(canConvertNumber<int32_t, float>(-2.147483648e+9f) == true);
CHECK((canConvertNumber<int32_t, float>(2.14748352e+9f)) == true); CHECK(canConvertNumber<int32_t, float>(2.14748352e+9f) == true);
CHECK((canConvertNumber<int32_t, float>(2.14748365e+9f)) == false); CHECK(canConvertNumber<int32_t, float>(2.14748365e+9f) == false);
} }
SECTION("double -> int32_t") { SECTION("double -> int32_t") {
CHECK((canConvertNumber<int32_t, double>(0)) == true); CHECK(canConvertNumber<int32_t, double>(0) == true);
CHECK((canConvertNumber<int32_t, double>(-2.147483649e+9)) == false); CHECK(canConvertNumber<int32_t, double>(-2.147483649e+9) == false);
CHECK((canConvertNumber<int32_t, double>(-2.147483648e+9)) == true); CHECK(canConvertNumber<int32_t, double>(-2.147483648e+9) == true);
CHECK((canConvertNumber<int32_t, double>(2.147483647e+9)) == true); CHECK(canConvertNumber<int32_t, double>(2.147483647e+9) == true);
CHECK((canConvertNumber<int32_t, double>(2.147483648e+9)) == false); CHECK(canConvertNumber<int32_t, double>(2.147483648e+9) == false);
} }
SECTION("float -> uint32_t") { SECTION("float -> uint32_t") {
CHECK((canConvertNumber<uint32_t, float>(0)) == true); CHECK(canConvertNumber<uint32_t, float>(0) == true);
CHECK((canConvertNumber<uint32_t, float>(-1.401298e-45f)) == false); CHECK(canConvertNumber<uint32_t, float>(-1.401298e-45f) == false);
CHECK((canConvertNumber<uint32_t, float>(4.29496704e+9f)) == true); CHECK(canConvertNumber<uint32_t, float>(4.29496704e+9f) == true);
CHECK((canConvertNumber<uint32_t, float>(4.294967296e+9f)) == false); CHECK(canConvertNumber<uint32_t, float>(4.294967296e+9f) == false);
} }
#if ARDUINOJSON_HAS_LONG_LONG #if ARDUINOJSON_HAS_LONG_LONG
SECTION("float -> int64_t") { SECTION("float -> int64_t") {
CHECK((canConvertNumber<int64_t, float>(0)) == true); CHECK(canConvertNumber<int64_t, float>(0) == true);
CHECK((canConvertNumber<int64_t, float>(-9.22337204e+18f)) == true); CHECK(canConvertNumber<int64_t, float>(-9.22337204e+18f) == true);
CHECK((canConvertNumber<int64_t, float>(9.22337149e+18f)) == true); CHECK(canConvertNumber<int64_t, float>(9.22337149e+18f) == true);
CHECK((canConvertNumber<int64_t, float>(9.22337204e+18f)) == false); CHECK(canConvertNumber<int64_t, float>(9.22337204e+18f) == false);
} }
SECTION("double -> int64_t") { SECTION("double -> int64_t") {
CHECK((canConvertNumber<int64_t, double>(0)) == true); CHECK(canConvertNumber<int64_t, double>(0) == true);
CHECK((canConvertNumber<int64_t, double>(-9.2233720368547758e+18)) == true); CHECK(canConvertNumber<int64_t, double>(-9.2233720368547758e+18) == true);
CHECK((canConvertNumber<int64_t, double>(9.2233720368547748e+18)) == true); CHECK(canConvertNumber<int64_t, double>(9.2233720368547748e+18) == true);
CHECK((canConvertNumber<int64_t, double>(9.2233720368547758e+18)) == false); CHECK(canConvertNumber<int64_t, double>(9.2233720368547758e+18) == false);
} }
SECTION("float -> uint64_t") { SECTION("float -> uint64_t") {
CHECK((canConvertNumber<uint64_t, float>(0)) == true); CHECK(canConvertNumber<uint64_t, float>(0) == true);
CHECK((canConvertNumber<uint64_t, float>(-1.401298e-45f)) == false); CHECK(canConvertNumber<uint64_t, float>(-1.401298e-45f) == false);
CHECK((canConvertNumber<uint64_t, float>(1.844674297419792384e+19f)) == CHECK(canConvertNumber<uint64_t, float>(1.84467429741979238e+19f) == true);
true); CHECK(canConvertNumber<uint64_t, float>(1.844674407370955161e+19f) ==
CHECK((canConvertNumber<uint64_t, float>(1.8446744073709551616e+19f)) ==
false); false);
} }
SECTION("double -> uint64_t") { SECTION("double -> uint64_t") {
CHECK((canConvertNumber<uint64_t, double>(0)) == true); CHECK(canConvertNumber<uint64_t, double>(0) == true);
CHECK((canConvertNumber<uint64_t, double>(-4.94065645841247e-324)) == CHECK(canConvertNumber<uint64_t, double>(-4.9406564584124e-324) == false);
false); CHECK(canConvertNumber<uint64_t, double>(1.844674407370954958e+19) == true);
CHECK((canConvertNumber<uint64_t, double>(1.8446744073709549568e+19)) == CHECK(canConvertNumber<uint64_t, double>(1.844674407370955166e+19) ==
true);
CHECK((canConvertNumber<uint64_t, double>(1.8446744073709551616e+19)) ==
false); false);
} }
#endif #endif

8
extras/tests/catch/CMakeLists.txt
View File

@ -2,7 +2,7 @@
# Copyright Benoit Blanchon 2014-2021 # Copyright Benoit Blanchon 2014-2021
# MIT License # MIT License
set(CMAKE_CXX_STANDARD 11) set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED OFF) set(CMAKE_CXX_STANDARD_REQUIRED OFF)
add_library(catch add_library(catch
@ -15,7 +15,7 @@ target_include_directories(catch
${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_SOURCE_DIR}
) )
if(CMAKE_CXX_COMPILER_ID MATCHES "GNU") if(MINGW)
# prevent "xxx will change in GCC x.x" with arm-linux-gnueabihf-gcc # prevent "too many sections (32837)" with MinGW
target_compile_options(catch PRIVATE -Wno-psabi) target_compile_options(catch PRIVATE -Wa,-mbig-obj)
endif() endif()

25308
extras/tests/catch/catch.hpp
View File

File diff suppressed because it is too large Load Diff