Increase coverage

extras/tests/JsonVariant/undefined.cpp

@@ -9,88 +9,58 @@ TEST_CASE("JsonVariant undefined") {
   JsonVariant variant;
 
   SECTION("as<T>()") {
-    SECTION("long") {
-      REQUIRE(variant.as<long>() == 0);
-    }
-
-    SECTION("unsigned") {
-      REQUIRE(variant.as<unsigned>() == 0);
-    }
-
-    SECTION("const char*") {
-      REQUIRE(variant.as<const char*>() == 0);
-    }
-
-    SECTION("double") {
-      REQUIRE(variant.as<double>() == 0);
-    }
-
-    SECTION("bool") {
-      REQUIRE(variant.as<bool>() == false);
-    }
-
-    SECTION("JsonArray") {
-      REQUIRE(variant.as<JsonArray>().isNull());
-    }
-
-    SECTION("JsonObject") {
-      REQUIRE(variant.as<JsonObject>().isNull());
-    }
+    CHECK(variant.as<bool>() == false);
+    CHECK(variant.as<int>() == 0);
+    CHECK(variant.as<float>() == 0.0f);
+    CHECK(variant.as<const char*>() == 0);
+    CHECK(variant.as<std::string>() == "null");
+    CHECK(variant.as<JsonVariant>().isNull());
+    CHECK(variant.as<JsonVariantConst>().isNull());
+    CHECK(variant.as<JsonArray>().isNull());
+    CHECK(variant.as<JsonArrayConst>().isNull());
+    CHECK(variant.as<JsonObject>().isNull());
+    CHECK(variant.as<JsonObjectConst>().isNull());
+    CHECK(variant.as<JsonString>().isNull());
   }
 
   SECTION("is<T>()") {
-    SECTION("long") {
-      REQUIRE(variant.is<long>() == false);
-    }
-
-    SECTION("unsigned") {
-      REQUIRE(variant.is<unsigned>() == false);
-    }
-
-    SECTION("const char*") {
-      REQUIRE(variant.is<const char*>() == false);
-    }
-
-    SECTION("double") {
-      REQUIRE(variant.is<double>() == false);
-    }
-
-    SECTION("bool") {
-      REQUIRE(variant.is<bool>() == false);
-    }
-
-    SECTION("JsonArray") {
-      REQUIRE(variant.is<JsonArray>() == false);
-    }
-
-    SECTION("JsonObject") {
-      REQUIRE(variant.is<JsonObject>() == false);
-    }
+    CHECK_FALSE(variant.is<bool>());
+    CHECK_FALSE(variant.is<int>());
+    CHECK_FALSE(variant.is<float>());
+    CHECK_FALSE(variant.is<const char*>());
+    CHECK_FALSE(variant.is<std::string>());
+    CHECK_FALSE(variant.is<JsonVariant>());
+    CHECK_FALSE(variant.is<JsonVariantConst>());
+    CHECK_FALSE(variant.is<JsonArray>());
+    CHECK_FALSE(variant.is<JsonArrayConst>());
+    CHECK_FALSE(variant.is<JsonObject>());
+    CHECK_FALSE(variant.is<JsonObjectConst>());
+    CHECK_FALSE(variant.is<JsonString>());
   }
 
-  SECTION("set<T>()") {
-    SECTION("long") {
-      REQUIRE(variant.set(42L) == false);
-    }
-
-    SECTION("unsigned") {
-      REQUIRE(variant.set(42U) == false);
-    }
-
-    SECTION("const char*") {
-      REQUIRE(variant.set("42") == false);
-    }
-
-    SECTION("Serialized<const char*>") {
-      REQUIRE(variant.set(serialized("42")) == false);
-    }
+  SECTION("set()") {
+    CHECK_FALSE(variant.set("42"));
+    CHECK_FALSE(variant.set(42.0));
+    CHECK_FALSE(variant.set(42L));
+    CHECK_FALSE(variant.set(42U));
+    CHECK_FALSE(variant.set(serialized("42")));
+    CHECK_FALSE(variant.set(true));
+  }
 
-    SECTION("double") {
-      REQUIRE(variant.set(42.0) == false);
-    }
+  SECTION("add()") {
+    CHECK_FALSE(variant.add("42"));
+    CHECK_FALSE(variant.add(42.0));
+    CHECK_FALSE(variant.add(42L));
+    CHECK_FALSE(variant.add(42U));
+    CHECK_FALSE(variant.add(serialized("42")));
+    CHECK_FALSE(variant.add(true));
+  }
 
-    SECTION("bool") {
-      REQUIRE(variant.set(true) == false);
-    }
+  SECTION("operator[]") {
+    CHECK(variant[0].isNull());
+    CHECK(variant["key"].isNull());
+    CHECK_FALSE(variant[0].set(1));
+    CHECK_FALSE(variant["key"].set(1));
+    CHECK_FALSE(variant[std::string("key")].set(1));
   }
 }

src/ArduinoJson/Variant/VariantFunctions.hpp

@@ -86,18 +86,20 @@ inline NO_INLINE VariantData *variantGetOrAddElement(VariantData *var,
 template <typename TChar>
 NO_INLINE VariantData *variantGetOrAddMember(VariantData *var, TChar *key,
                                              MemoryPool *pool) {
-  return var != 0 ? var->getOrAddMember(adaptString(key), pool,
-                                        getStringStoragePolicy(key))
-                  : 0;
+  if (!var)
+    return 0;
+  return var->getOrAddMember(adaptString(key), pool,
+                             getStringStoragePolicy(key));
 }
 
 template <typename TString>
 NO_INLINE VariantData *variantGetOrAddMember(VariantData *var,
                                              const TString &key,
                                              MemoryPool *pool) {
-  return var != 0 ? var->getOrAddMember(adaptString(key), pool,
-                                        getStringStoragePolicy(key))
-                  : 0;
+  if (!var)
+    return 0;
+  return var->getOrAddMember(adaptString(key), pool,
+                             getStringStoragePolicy(key));
 }
 
 inline bool variantIsNull(const VariantData *var) {