From 00c391320c8a98d8946a7af03d9eff6c55d47401 Mon Sep 17 00:00:00 2001 From: Benoit Blanchon Date: Tue, 24 Dec 2019 16:41:00 +0100 Subject: [PATCH] Added support for CMake's unity builds --- extras/tests/JsonDeserializer/CMakeLists.txt | 2 + .../tests/JsonSerializer/JsonArrayPretty.cpp | 52 ++++---- extras/tests/JsonSerializer/JsonObject.cpp | 28 ++--- .../tests/JsonSerializer/JsonObjectPretty.cpp | 51 ++++---- extras/tests/JsonSerializer/misc.cpp | 10 -- extras/tests/JsonVariant/add.cpp | 2 - extras/tests/JsonVariant/as.cpp | 4 +- extras/tests/JsonVariant/clear.cpp | 2 - extras/tests/JsonVariant/compare.cpp | 4 +- extras/tests/JsonVariant/createNested.cpp | 2 - extras/tests/MemoryPool/StringBuilder.cpp | 4 +- extras/tests/MemoryPool/allocVariant.cpp | 4 +- extras/tests/MemoryPool/size.cpp | 4 +- extras/tests/Misc/CMakeLists.txt | 2 + .../tests/MixedConfiguration/CMakeLists.txt | 2 + .../MsgPackSerializer/serializeVariant.cpp | 87 +++++++------- extras/tests/Numbers/CMakeLists.txt | 1 + extras/tests/Numbers/parseFloat.cpp | 112 +++++++++--------- extras/tests/Numbers/parseInteger.cpp | 74 ++++++------ extras/tests/TextFormatter/CMakeLists.txt | 2 + 20 files changed, 226 insertions(+), 223 deletions(-) diff --git a/extras/tests/JsonDeserializer/CMakeLists.txt b/extras/tests/JsonDeserializer/CMakeLists.txt index 70e71db0..67200ea3 100644 --- a/extras/tests/JsonDeserializer/CMakeLists.txt +++ b/extras/tests/JsonDeserializer/CMakeLists.txt @@ -18,4 +18,6 @@ add_executable(JsonDeserializerTests ) target_link_libraries(JsonDeserializerTests catch) +set_target_properties(JsonDeserializerTests PROPERTIES UNITY_BUILD OFF) + add_test(JsonDeserializer JsonDeserializerTests) diff --git a/extras/tests/JsonSerializer/JsonArrayPretty.cpp b/extras/tests/JsonSerializer/JsonArrayPretty.cpp index 4122043c..c561761c 100644 --- a/extras/tests/JsonSerializer/JsonArrayPretty.cpp +++ b/extras/tests/JsonSerializer/JsonArrayPretty.cpp @@ -5,7 +5,7 @@ #include #include -static void check(JsonArray array, std::string expected) { +static void checkArray(JsonArray array, std::string expected) { std::string actual; size_t actualLen = serializeJsonPretty(array, actual); size_t measuredLen = measureJsonPretty(array); @@ -19,38 +19,38 @@ TEST_CASE("serializeJsonPretty(JsonArray)") { JsonArray array = doc.to(); SECTION("Empty") { - check(array, "[]"); + checkArray(array, "[]"); } SECTION("OneElement") { array.add(1); - check(array, - "[\r\n" - " 1\r\n" - "]"); + checkArray(array, + "[\r\n" + " 1\r\n" + "]"); } SECTION("TwoElements") { array.add(1); array.add(2); - check(array, - "[\r\n" - " 1,\r\n" - " 2\r\n" - "]"); + checkArray(array, + "[\r\n" + " 1,\r\n" + " 2\r\n" + "]"); } SECTION("EmptyNestedArrays") { array.createNestedArray(); array.createNestedArray(); - check(array, - "[\r\n" - " [],\r\n" - " []\r\n" - "]"); + checkArray(array, + "[\r\n" + " [],\r\n" + " []\r\n" + "]"); } SECTION("NestedArrays") { @@ -61,15 +61,15 @@ TEST_CASE("serializeJsonPretty(JsonArray)") { JsonObject nested2 = array.createNestedObject(); nested2["key"] = 3; - check(array, - "[\r\n" - " [\r\n" - " 1,\r\n" - " 2\r\n" - " ],\r\n" - " {\r\n" - " \"key\": 3\r\n" - " }\r\n" - "]"); + checkArray(array, + "[\r\n" + " [\r\n" + " 1,\r\n" + " 2\r\n" + " ],\r\n" + " {\r\n" + " \"key\": 3\r\n" + " }\r\n" + "]"); } } diff --git a/extras/tests/JsonSerializer/JsonObject.cpp b/extras/tests/JsonSerializer/JsonObject.cpp index 573b4ae6..76488acc 100644 --- a/extras/tests/JsonSerializer/JsonObject.cpp +++ b/extras/tests/JsonSerializer/JsonObject.cpp @@ -6,7 +6,7 @@ #include #include -void check(const JsonObject obj, const std::string &expected) { +static void checkObject(const JsonObject obj, const std::string &expected) { char actual[256]; size_t actualLen = serializeJson(obj, actual); size_t measuredLen = measureJson(obj); @@ -21,14 +21,14 @@ TEST_CASE("serializeJson(JsonObject)") { JsonObject obj = doc.to(); SECTION("EmptyObject") { - check(obj, "{}"); + checkObject(obj, "{}"); } SECTION("TwoStrings") { obj["key1"] = "value1"; obj["key2"] = "value2"; - check(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}"); + checkObject(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}"); } SECTION("RemoveFirst") { @@ -36,7 +36,7 @@ TEST_CASE("serializeJson(JsonObject)") { obj["key2"] = "value2"; obj.remove("key1"); - check(obj, "{\"key2\":\"value2\"}"); + checkObject(obj, "{\"key2\":\"value2\"}"); } SECTION("RemoveLast") { @@ -44,7 +44,7 @@ TEST_CASE("serializeJson(JsonObject)") { obj["key2"] = "value2"; obj.remove("key2"); - check(obj, "{\"key1\":\"value1\"}"); + checkObject(obj, "{\"key1\":\"value1\"}"); } SECTION("RemoveUnexistingKey") { @@ -52,44 +52,44 @@ TEST_CASE("serializeJson(JsonObject)") { obj["key2"] = "value2"; obj.remove("key3"); - check(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}"); + checkObject(obj, "{\"key1\":\"value1\",\"key2\":\"value2\"}"); } SECTION("ReplaceExistingKey") { obj["key"] = "value1"; obj["key"] = "value2"; - check(obj, "{\"key\":\"value2\"}"); + checkObject(obj, "{\"key\":\"value2\"}"); } SECTION("TwoIntegers") { obj["a"] = 1; obj["b"] = 2; - check(obj, "{\"a\":1,\"b\":2}"); + checkObject(obj, "{\"a\":1,\"b\":2}"); } SECTION("serialized(const char*)") { obj["a"] = serialized("[1,2]"); obj["b"] = serialized("[4,5]"); - check(obj, "{\"a\":[1,2],\"b\":[4,5]}"); + checkObject(obj, "{\"a\":[1,2],\"b\":[4,5]}"); } SECTION("Two doubles") { obj["a"] = 12.34; obj["b"] = 56.78; - check(obj, "{\"a\":12.34,\"b\":56.78}"); + checkObject(obj, "{\"a\":12.34,\"b\":56.78}"); } SECTION("TwoNull") { obj["a"] = static_cast(0); obj["b"] = static_cast(0); - check(obj, "{\"a\":null,\"b\":null}"); + checkObject(obj, "{\"a\":null,\"b\":null}"); } SECTION("TwoBooleans") { obj["a"] = true; obj["b"] = false; - check(obj, "{\"a\":true,\"b\":false}"); + checkObject(obj, "{\"a\":true,\"b\":false}"); } SECTION("ThreeNestedArrays") { @@ -100,7 +100,7 @@ TEST_CASE("serializeJson(JsonObject)") { obj["b"] = b.to(); obj["c"] = c.to(); - check(obj, "{\"a\":[],\"b\":[],\"c\":[]}"); + checkObject(obj, "{\"a\":[],\"b\":[],\"c\":[]}"); } SECTION("ThreeNestedObjects") { @@ -111,6 +111,6 @@ TEST_CASE("serializeJson(JsonObject)") { obj["b"] = b.to(); obj["c"] = c.to(); - check(obj, "{\"a\":{},\"b\":{},\"c\":{}}"); + checkObject(obj, "{\"a\":{},\"b\":{},\"c\":{}}"); } } diff --git a/extras/tests/JsonSerializer/JsonObjectPretty.cpp b/extras/tests/JsonSerializer/JsonObjectPretty.cpp index aa33fbbf..60ee5fd4 100644 --- a/extras/tests/JsonSerializer/JsonObjectPretty.cpp +++ b/extras/tests/JsonSerializer/JsonObjectPretty.cpp @@ -6,7 +6,8 @@ #include #include -void check(const JsonObject obj, const std::string expected) { +static void checkObjectPretty(const JsonObject obj, + const std::string expected) { char json[256]; size_t actualLen = serializeJsonPretty(obj, json); @@ -22,38 +23,38 @@ TEST_CASE("serializeJsonPretty(JsonObject)") { JsonObject obj = doc.to(); SECTION("EmptyObject") { - check(obj, "{}"); + checkObjectPretty(obj, "{}"); } SECTION("OneMember") { obj["key"] = "value"; - check(obj, - "{\r\n" - " \"key\": \"value\"\r\n" - "}"); + checkObjectPretty(obj, + "{\r\n" + " \"key\": \"value\"\r\n" + "}"); } SECTION("TwoMembers") { obj["key1"] = "value1"; obj["key2"] = "value2"; - check(obj, - "{\r\n" - " \"key1\": \"value1\",\r\n" - " \"key2\": \"value2\"\r\n" - "}"); + checkObjectPretty(obj, + "{\r\n" + " \"key1\": \"value1\",\r\n" + " \"key2\": \"value2\"\r\n" + "}"); } SECTION("EmptyNestedContainers") { obj.createNestedObject("key1"); obj.createNestedArray("key2"); - check(obj, - "{\r\n" - " \"key1\": {},\r\n" - " \"key2\": []\r\n" - "}"); + checkObjectPretty(obj, + "{\r\n" + " \"key1\": {},\r\n" + " \"key2\": []\r\n" + "}"); } SECTION("NestedContainers") { @@ -63,14 +64,14 @@ TEST_CASE("serializeJsonPretty(JsonObject)") { JsonArray nested2 = obj.createNestedArray("key2"); nested2.add(2); - check(obj, - "{\r\n" - " \"key1\": {\r\n" - " \"a\": 1\r\n" - " },\r\n" - " \"key2\": [\r\n" - " 2\r\n" - " ]\r\n" - "}"); + checkObjectPretty(obj, + "{\r\n" + " \"key1\": {\r\n" + " \"a\": 1\r\n" + " },\r\n" + " \"key2\": [\r\n" + " 2\r\n" + " ]\r\n" + "}"); } } diff --git a/extras/tests/JsonSerializer/misc.cpp b/extras/tests/JsonSerializer/misc.cpp index 1cf24d09..59c09eba 100644 --- a/extras/tests/JsonSerializer/misc.cpp +++ b/extras/tests/JsonSerializer/misc.cpp @@ -2,16 +2,6 @@ #include #include -template -void check(T value, const std::string &expected) { - DynamicJsonDocument doc(4096); - doc.to().set(value); - char buffer[256] = ""; - size_t returnValue = serializeJson(doc, buffer, sizeof(buffer)); - REQUIRE(expected == buffer); - REQUIRE(expected.size() == returnValue); -} - TEST_CASE("serializeJson(MemberProxy)") { DynamicJsonDocument doc(4096); deserializeJson(doc, "{\"hello\":42}"); diff --git a/extras/tests/JsonVariant/add.cpp b/extras/tests/JsonVariant/add.cpp index ce899034..e2fcb876 100644 --- a/extras/tests/JsonVariant/add.cpp +++ b/extras/tests/JsonVariant/add.cpp @@ -6,8 +6,6 @@ #include #include -static const char* null = 0; - TEST_CASE("JsonVariant::add()") { DynamicJsonDocument doc(4096); JsonVariant var = doc.to(); diff --git a/extras/tests/JsonVariant/as.cpp b/extras/tests/JsonVariant/as.cpp index 3e306bbe..9011b976 100644 --- a/extras/tests/JsonVariant/as.cpp +++ b/extras/tests/JsonVariant/as.cpp @@ -10,9 +10,9 @@ namespace my { using ARDUINOJSON_NAMESPACE::isinf; } // namespace my -static const char* null = 0; - TEST_CASE("JsonVariant::as()") { + static const char* null = 0; + DynamicJsonDocument doc(4096); JsonVariant variant = doc.to(); diff --git a/extras/tests/JsonVariant/clear.cpp b/extras/tests/JsonVariant/clear.cpp index d6231162..338191fc 100644 --- a/extras/tests/JsonVariant/clear.cpp +++ b/extras/tests/JsonVariant/clear.cpp @@ -6,8 +6,6 @@ #include #include -static const char* null = 0; - TEST_CASE("JsonVariant::clear()") { DynamicJsonDocument doc(4096); JsonVariant var = doc.to(); diff --git a/extras/tests/JsonVariant/compare.cpp b/extras/tests/JsonVariant/compare.cpp index 1ecbd5e5..bf926b86 100644 --- a/extras/tests/JsonVariant/compare.cpp +++ b/extras/tests/JsonVariant/compare.cpp @@ -5,8 +5,6 @@ #include #include -static const char* null = 0; - template void checkEquals(T a, T b) { DynamicJsonDocument doc(4096); @@ -70,6 +68,8 @@ void checkComparisons(T low, T mid, T high) { } TEST_CASE("JsonVariant comparisons") { + static const char* null = 0; + SECTION("Double") { checkComparisons(123.44, 123.45, 123.46); } diff --git a/extras/tests/JsonVariant/createNested.cpp b/extras/tests/JsonVariant/createNested.cpp index 8db9d5af..ad2244e6 100644 --- a/extras/tests/JsonVariant/createNested.cpp +++ b/extras/tests/JsonVariant/createNested.cpp @@ -6,8 +6,6 @@ #include #include -static const char* null = 0; - TEST_CASE("JsonVariant::createNestedObject()") { DynamicJsonDocument doc(4096); JsonVariant variant = doc.to(); diff --git a/extras/tests/MemoryPool/StringBuilder.cpp b/extras/tests/MemoryPool/StringBuilder.cpp index c9afdbfa..355907f1 100644 --- a/extras/tests/MemoryPool/StringBuilder.cpp +++ b/extras/tests/MemoryPool/StringBuilder.cpp @@ -8,9 +8,9 @@ using namespace ARDUINOJSON_NAMESPACE; -static char buffer[4096]; - TEST_CASE("StringBuilder") { + char buffer[4096]; + SECTION("Works when buffer is big enough") { MemoryPool pool(buffer, addPadding(JSON_STRING_SIZE(6))); diff --git a/extras/tests/MemoryPool/allocVariant.cpp b/extras/tests/MemoryPool/allocVariant.cpp index 10f79d60..1066a459 100644 --- a/extras/tests/MemoryPool/allocVariant.cpp +++ b/extras/tests/MemoryPool/allocVariant.cpp @@ -7,9 +7,9 @@ using namespace ARDUINOJSON_NAMESPACE; -static char buffer[4096]; - TEST_CASE("MemoryPool::allocVariant()") { + char buffer[4096]; + SECTION("Returns different pointer") { MemoryPool pool(buffer, sizeof(buffer)); diff --git a/extras/tests/MemoryPool/size.cpp b/extras/tests/MemoryPool/size.cpp index 50163aca..130c5682 100644 --- a/extras/tests/MemoryPool/size.cpp +++ b/extras/tests/MemoryPool/size.cpp @@ -7,15 +7,15 @@ using namespace ARDUINOJSON_NAMESPACE; -char buffer[4096]; - TEST_CASE("MemoryPool::capacity()") { + char buffer[4096]; const size_t capacity = 64; MemoryPool pool(buffer, capacity); REQUIRE(capacity == pool.capacity()); } TEST_CASE("MemoryPool::size()") { + char buffer[4096]; MemoryPool pool(buffer, sizeof(buffer)); SECTION("Initial size is 0") { diff --git a/extras/tests/Misc/CMakeLists.txt b/extras/tests/Misc/CMakeLists.txt index 73ac51d6..ccd2f1b8 100644 --- a/extras/tests/Misc/CMakeLists.txt +++ b/extras/tests/Misc/CMakeLists.txt @@ -14,6 +14,8 @@ add_executable(MiscTests ) target_link_libraries(MiscTests catch) +set_target_properties(MiscTests PROPERTIES UNITY_BUILD OFF) + add_test(Misc MiscTests) diff --git a/extras/tests/MixedConfiguration/CMakeLists.txt b/extras/tests/MixedConfiguration/CMakeLists.txt index afcf514b..5a06c304 100644 --- a/extras/tests/MixedConfiguration/CMakeLists.txt +++ b/extras/tests/MixedConfiguration/CMakeLists.txt @@ -21,4 +21,6 @@ add_executable(MixedConfigurationTests ) target_link_libraries(MixedConfigurationTests catch) +set_target_properties(MixedConfigurationTests PROPERTIES UNITY_BUILD OFF) + add_test(MixedConfiguration MixedConfigurationTests) diff --git a/extras/tests/MsgPackSerializer/serializeVariant.cpp b/extras/tests/MsgPackSerializer/serializeVariant.cpp index d67b050e..c3125dad 100644 --- a/extras/tests/MsgPackSerializer/serializeVariant.cpp +++ b/extras/tests/MsgPackSerializer/serializeVariant.cpp @@ -6,7 +6,8 @@ #include template -void check(T value, const char* expected_data, size_t expected_len) { +static void checkVariant(T value, const char* expected_data, + size_t expected_len) { DynamicJsonDocument doc(4096); JsonVariant variant = doc.to(); variant.set(value); @@ -19,120 +20,122 @@ void check(T value, const char* expected_data, size_t expected_len) { } template -void check(T value, const char (&expected_data)[N]) { +static void checkVariant(T value, const char (&expected_data)[N]) { const size_t expected_len = N - 1; - check(value, expected_data, expected_len); + checkVariant(value, expected_data, expected_len); } template -void check(T value, const std::string& expected) { - check(value, expected.data(), expected.length()); +static void checkVariant(T value, const std::string& expected) { + checkVariant(value, expected.data(), expected.length()); } TEST_CASE("serialize MsgPack value") { SECTION("undefined") { - check(JsonVariant(), "\xC0"); // we represent undefined as nil + checkVariant(JsonVariant(), "\xC0"); // we represent undefined as nil } SECTION("nil") { const char* nil = 0; // ArduinoJson uses a string for null - check(nil, "\xC0"); + checkVariant(nil, "\xC0"); } SECTION("bool") { - check(false, "\xC2"); - check(true, "\xC3"); + checkVariant(false, "\xC2"); + checkVariant(true, "\xC3"); } SECTION("positive fixint") { - check(0, "\x00"); - check(127, "\x7F"); + checkVariant(0, "\x00"); + checkVariant(127, "\x7F"); } SECTION("uint 8") { - check(128, "\xCC\x80"); - check(255, "\xCC\xFF"); + checkVariant(128, "\xCC\x80"); + checkVariant(255, "\xCC\xFF"); } SECTION("uint 16") { - check(256, "\xCD\x01\x00"); - check(0xFFFF, "\xCD\xFF\xFF"); + checkVariant(256, "\xCD\x01\x00"); + checkVariant(0xFFFF, "\xCD\xFF\xFF"); } SECTION("uint 32") { - check(0x00010000U, "\xCE\x00\x01\x00\x00"); - check(0x12345678U, "\xCE\x12\x34\x56\x78"); - check(0xFFFFFFFFU, "\xCE\xFF\xFF\xFF\xFF"); + checkVariant(0x00010000U, "\xCE\x00\x01\x00\x00"); + checkVariant(0x12345678U, "\xCE\x12\x34\x56\x78"); + checkVariant(0xFFFFFFFFU, "\xCE\xFF\xFF\xFF\xFF"); } #if ARDUINOJSON_USE_LONG_LONG SECTION("uint 64") { - check(0x0001000000000000U, "\xCF\x00\x01\x00\x00\x00\x00\x00\x00"); - check(0x123456789ABCDEF0U, "\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0"); - check(0xFFFFFFFFFFFFFFFFU, "\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); + checkVariant(0x0001000000000000U, "\xCF\x00\x01\x00\x00\x00\x00\x00\x00"); + checkVariant(0x123456789ABCDEF0U, "\xCF\x12\x34\x56\x78\x9A\xBC\xDE\xF0"); + checkVariant(0xFFFFFFFFFFFFFFFFU, "\xCF\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF"); } #endif SECTION("negative fixint") { - check(-1, "\xFF"); - check(-32, "\xE0"); + checkVariant(-1, "\xFF"); + checkVariant(-32, "\xE0"); } SECTION("int 8") { - check(-33, "\xD0\xDF"); - check(-128, "\xD0\x80"); + checkVariant(-33, "\xD0\xDF"); + checkVariant(-128, "\xD0\x80"); } SECTION("int 16") { - check(-129, "\xD1\xFF\x7F"); - check(-32768, "\xD1\x80\x00"); + checkVariant(-129, "\xD1\xFF\x7F"); + checkVariant(-32768, "\xD1\x80\x00"); } SECTION("int 32") { - check(-32769, "\xD2\xFF\xFF\x7F\xFF"); - check(-2147483647 - 1, "\xD2\x80\x00\x00\x00"); + checkVariant(-32769, "\xD2\xFF\xFF\x7F\xFF"); + checkVariant(-2147483647 - 1, "\xD2\x80\x00\x00\x00"); } #if ARDUINOJSON_USE_LONG_LONG SECTION("int 64") { - check(int64_t(0xFEDCBA9876543210), "\xD3\xFE\xDC\xBA\x98\x76\x54\x32\x10"); + checkVariant(int64_t(0xFEDCBA9876543210), + "\xD3\xFE\xDC\xBA\x98\x76\x54\x32\x10"); } #endif SECTION("float 32") { - check(1.25, "\xCA\x3F\xA0\x00\x00"); + checkVariant(1.25, "\xCA\x3F\xA0\x00\x00"); } SECTION("float 64") { - check(3.1415, "\xCB\x40\x09\x21\xCA\xC0\x83\x12\x6F"); + checkVariant(3.1415, "\xCB\x40\x09\x21\xCA\xC0\x83\x12\x6F"); } SECTION("fixstr") { - check("", "\xA0"); - check("hello world hello world hello !", - "\xBFhello world hello world hello !"); + checkVariant("", "\xA0"); + checkVariant("hello world hello world hello !", + "\xBFhello world hello world hello !"); } SECTION("str 8") { - check("hello world hello world hello !!", - "\xD9\x20hello world hello world hello !!"); + checkVariant("hello world hello world hello !!", + "\xD9\x20hello world hello world hello !!"); } SECTION("str 16") { std::string shortest(256, '?'); - check(shortest.c_str(), std::string("\xDA\x01\x00", 3) + shortest); + checkVariant(shortest.c_str(), std::string("\xDA\x01\x00", 3) + shortest); std::string longest(65535, '?'); - check(longest.c_str(), std::string("\xDA\xFF\xFF", 3) + longest); + checkVariant(longest.c_str(), std::string("\xDA\xFF\xFF", 3) + longest); } SECTION("str 32") { std::string shortest(65536, '?'); - check(shortest.c_str(), std::string("\xDB\x00\x01\x00\x00", 5) + shortest); + checkVariant(shortest.c_str(), + std::string("\xDB\x00\x01\x00\x00", 5) + shortest); } SECTION("serialized(const char*)") { - check(serialized("\xDA\xFF\xFF"), "\xDA\xFF\xFF"); - check(serialized("\xDB\x00\x01\x00\x00", 5), "\xDB\x00\x01\x00\x00"); + checkVariant(serialized("\xDA\xFF\xFF"), "\xDA\xFF\xFF"); + checkVariant(serialized("\xDB\x00\x01\x00\x00", 5), "\xDB\x00\x01\x00\x00"); } } diff --git a/extras/tests/Numbers/CMakeLists.txt b/extras/tests/Numbers/CMakeLists.txt index 4e39bd9b..44bfcedb 100644 --- a/extras/tests/Numbers/CMakeLists.txt +++ b/extras/tests/Numbers/CMakeLists.txt @@ -9,4 +9,5 @@ add_executable(NumbersTests ) target_link_libraries(NumbersTests catch) + add_test(Numbers NumbersTests) diff --git a/extras/tests/Numbers/parseFloat.cpp b/extras/tests/Numbers/parseFloat.cpp index dbdfd454..a0976bc9 100644 --- a/extras/tests/Numbers/parseFloat.cpp +++ b/extras/tests/Numbers/parseFloat.cpp @@ -12,7 +12,7 @@ using namespace ARDUINOJSON_NAMESPACE; template -void check(const char* input, T expected) { +void checkFloat(const char* input, T expected) { CAPTURE(input); REQUIRE(parseFloat(input) == Approx(expected)); } @@ -38,51 +38,54 @@ void checkInf(const char* input, bool negative) { TEST_CASE("parseFloat()") { SECTION("Float_Short_NoExponent") { - check("3.14", 3.14f); - check("-3.14", -3.14f); - check("+3.14", +3.14f); + checkFloat("3.14", 3.14f); + checkFloat("-3.14", -3.14f); + checkFloat("+3.14", +3.14f); } SECTION("Short_NoDot") { - check("1E+38", 1E+38f); - check("-1E+38", -1E+38f); - check("+1E-38", +1E-38f); - check("+1e+38", +1e+38f); - check("-1e-38", -1e-38f); + checkFloat("1E+38", 1E+38f); + checkFloat("-1E+38", -1E+38f); + checkFloat("+1E-38", +1E-38f); + checkFloat("+1e+38", +1e+38f); + checkFloat("-1e-38", -1e-38f); } SECTION("Max") { - check("340.2823e+36", 3.402823e+38f); - check("34.02823e+37", 3.402823e+38f); - check("3.402823e+38", 3.402823e+38f); - check("0.3402823e+39", 3.402823e+38f); - check("0.03402823e+40", 3.402823e+38f); - check("0.003402823e+41", 3.402823e+38f); + checkFloat("340.2823e+36", 3.402823e+38f); + checkFloat("34.02823e+37", 3.402823e+38f); + checkFloat("3.402823e+38", 3.402823e+38f); + checkFloat("0.3402823e+39", 3.402823e+38f); + checkFloat("0.03402823e+40", 3.402823e+38f); + checkFloat("0.003402823e+41", 3.402823e+38f); } SECTION("VeryLong") { - check("0.00000000000000000000000000000001", 1e-32f); - check("100000000000000000000000000000000.0", 1e+32f); - check( + checkFloat("0.00000000000000000000000000000001", 1e-32f); + checkFloat("100000000000000000000000000000000.0", 1e+32f); + checkFloat( "100000000000000000000000000000000.00000000000000000000000000000", 1e+32f); } SECTION("MantissaTooLongToFit") { - check("0.340282346638528861111111111111", 0.34028234663852886f); - check("34028234663852886.11111111111111", 34028234663852886.0f); - check("34028234.66385288611111111111111", 34028234.663852886f); + checkFloat("0.340282346638528861111111111111", 0.34028234663852886f); + checkFloat("34028234663852886.11111111111111", 34028234663852886.0f); + checkFloat("34028234.66385288611111111111111", 34028234.663852886f); - check("-0.340282346638528861111111111111", -0.34028234663852886f); - check("-34028234663852886.11111111111111", -34028234663852886.0f); - check("-34028234.66385288611111111111111", -34028234.663852886f); + checkFloat("-0.340282346638528861111111111111", + -0.34028234663852886f); + checkFloat("-34028234663852886.11111111111111", + -34028234663852886.0f); + checkFloat("-34028234.66385288611111111111111", + -34028234.663852886f); } SECTION("ExponentTooBig") { checkInf("1e39", false); checkInf("-1e39", true); checkInf("1e255", false); - check("1e-255", 0.0f); + checkFloat("1e-255", 0.0f); } SECTION("NaN") { @@ -105,58 +108,61 @@ TEST_CASE("parseFloat()") { TEST_CASE("parseFloat()") { SECTION("Short_NoExponent") { - check("3.14", 3.14); - check("-3.14", -3.14); - check("+3.14", +3.14); + checkFloat("3.14", 3.14); + checkFloat("-3.14", -3.14); + checkFloat("+3.14", +3.14); } SECTION("Short_NoDot") { - check("1E+308", 1E+308); - check("-1E+308", -1E+308); - check("+1E-308", +1E-308); - check("+1e+308", +1e+308); - check("-1e-308", -1e-308); + checkFloat("1E+308", 1E+308); + checkFloat("-1E+308", -1E+308); + checkFloat("+1E-308", +1E-308); + checkFloat("+1e+308", +1e+308); + checkFloat("-1e-308", -1e-308); } SECTION("Max") { - check(".017976931348623147e+310", 1.7976931348623147e+308); - check(".17976931348623147e+309", 1.7976931348623147e+308); - check("1.7976931348623147e+308", 1.7976931348623147e+308); - check("17.976931348623147e+307", 1.7976931348623147e+308); - check("179.76931348623147e+306", 1.7976931348623147e+308); + checkFloat(".017976931348623147e+310", 1.7976931348623147e+308); + checkFloat(".17976931348623147e+309", 1.7976931348623147e+308); + checkFloat("1.7976931348623147e+308", 1.7976931348623147e+308); + checkFloat("17.976931348623147e+307", 1.7976931348623147e+308); + checkFloat("179.76931348623147e+306", 1.7976931348623147e+308); } SECTION("Min") { - check(".022250738585072014e-306", 2.2250738585072014e-308); - check(".22250738585072014e-307", 2.2250738585072014e-308); - check("2.2250738585072014e-308", 2.2250738585072014e-308); - check("22.250738585072014e-309", 2.2250738585072014e-308); - check("222.50738585072014e-310", 2.2250738585072014e-308); + checkFloat(".022250738585072014e-306", 2.2250738585072014e-308); + checkFloat(".22250738585072014e-307", 2.2250738585072014e-308); + checkFloat("2.2250738585072014e-308", 2.2250738585072014e-308); + checkFloat("22.250738585072014e-309", 2.2250738585072014e-308); + checkFloat("222.50738585072014e-310", 2.2250738585072014e-308); } SECTION("VeryLong") { - check("0.00000000000000000000000000000001", 1e-32); - check("100000000000000000000000000000000.0", 1e+32); - check( + checkFloat("0.00000000000000000000000000000001", 1e-32); + checkFloat("100000000000000000000000000000000.0", 1e+32); + checkFloat( "100000000000000000000000000000000.00000000000000000000000000000", 1e+32); } SECTION("MantissaTooLongToFit") { - check("0.179769313486231571111111111111", 0.17976931348623157); - check("17976931348623157.11111111111111", 17976931348623157.0); - check("1797693.134862315711111111111111", 1797693.1348623157); + checkFloat("0.179769313486231571111111111111", 0.17976931348623157); + checkFloat("17976931348623157.11111111111111", 17976931348623157.0); + checkFloat("1797693.134862315711111111111111", 1797693.1348623157); - check("-0.179769313486231571111111111111", -0.17976931348623157); - check("-17976931348623157.11111111111111", -17976931348623157.0); - check("-1797693.134862315711111111111111", -1797693.1348623157); + checkFloat("-0.179769313486231571111111111111", + -0.17976931348623157); + checkFloat("-17976931348623157.11111111111111", + -17976931348623157.0); + checkFloat("-1797693.134862315711111111111111", + -1797693.1348623157); } SECTION("ExponentTooBig") { checkInf("1e309", false); checkInf("-1e309", true); checkInf("1e65535", false); - check("1e-65535", 0.0); + checkFloat("1e-65535", 0.0); } SECTION("NaN") { diff --git a/extras/tests/Numbers/parseInteger.cpp b/extras/tests/Numbers/parseInteger.cpp index e8b3b37b..b8287003 100644 --- a/extras/tests/Numbers/parseInteger.cpp +++ b/extras/tests/Numbers/parseInteger.cpp @@ -9,59 +9,59 @@ using namespace ARDUINOJSON_NAMESPACE; template -void check(const char* input, T expected) { +void checkInteger(const char* input, T expected) { CAPTURE(input); T actual = parseInteger(input); REQUIRE(expected == actual); } TEST_CASE("parseInteger()") { - check("-128", -128); - check("127", 127); - check("+127", 127); - check("3.14", 3); - check("x42", 0); - check("128", 0); // overflow - check("-129", 0); // overflow + checkInteger("-128", -128); + checkInteger("127", 127); + checkInteger("+127", 127); + checkInteger("3.14", 3); + checkInteger("x42", 0); + checkInteger("128", 0); // overflow + checkInteger("-129", 0); // overflow } TEST_CASE("parseInteger()") { - check("-32768", -32768); - check("32767", 32767); - check("+32767", 32767); - check("3.14", 3); - check("x42", 0); - check("-32769", 0); // overflow - check("32768", 0); // overflow + checkInteger("-32768", -32768); + checkInteger("32767", 32767); + checkInteger("+32767", 32767); + checkInteger("3.14", 3); + checkInteger("x42", 0); + checkInteger("-32769", 0); // overflow + checkInteger("32768", 0); // overflow } TEST_CASE("parseInteger()") { - check("-2147483648", (-2147483647 - 1)); - check("2147483647", 2147483647); - check("+2147483647", 2147483647); - check("3.14", 3); - check("x42", 0); - check("-2147483649", 0); // overflow - check("2147483648", 0); // overflow + checkInteger("-2147483648", (-2147483647 - 1)); + checkInteger("2147483647", 2147483647); + checkInteger("+2147483647", 2147483647); + checkInteger("3.14", 3); + checkInteger("x42", 0); + checkInteger("-2147483649", 0); // overflow + checkInteger("2147483648", 0); // overflow } TEST_CASE("parseInteger()") { - check("0", 0); - check("255", 255); - check("+255", 255); - check("3.14", 3); - check("x42", 0); - check("-1", 0); - check("256", 0); + checkInteger("0", 0); + checkInteger("255", 255); + checkInteger("+255", 255); + checkInteger("3.14", 3); + checkInteger("x42", 0); + checkInteger("-1", 0); + checkInteger("256", 0); } TEST_CASE("parseInteger()") { - check("0", 0); - check("65535", 65535); - check("+65535", 65535); - check("3.14", 3); - // check(" 42", 0); - check("x42", 0); - check("-1", 0); - check("65536", 0); + checkInteger("0", 0); + checkInteger("65535", 65535); + checkInteger("+65535", 65535); + checkInteger("3.14", 3); + // checkInteger(" 42", 0); + checkInteger("x42", 0); + checkInteger("-1", 0); + checkInteger("65536", 0); } diff --git a/extras/tests/TextFormatter/CMakeLists.txt b/extras/tests/TextFormatter/CMakeLists.txt index c2aba37d..22af18c5 100644 --- a/extras/tests/TextFormatter/CMakeLists.txt +++ b/extras/tests/TextFormatter/CMakeLists.txt @@ -8,4 +8,6 @@ add_executable(TextFormatterTests ) target_link_libraries(TextFormatterTests catch) +set_target_properties(TextFormatterTests PROPERTIES UNITY_BUILD OFF) + add_test(TextFormatter TextFormatterTests)