Changed unit testing framework from Google Test to Catch

test/JsonVariant/as.cpp

@@ -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
+  }
 }