JsonDeserializer: use float when the value has few digits

extras/tests/JsonDeserializer/array.cpp

@@ -69,14 +69,32 @@ TEST_CASE("deserialize JSON array") {
       REQUIRE(arr[1] == 84);
     }
 
-    SECTION("Double") {
+    SECTION("Float") {
       DeserializationError err = deserializeJson(doc, "[4.2,1e2]");
       JsonArray arr = doc.as<JsonArray>();
 
       REQUIRE(err == DeserializationError::Ok);
       REQUIRE(2 == arr.size());
-      REQUIRE(arr[0] == 4.2);
-      REQUIRE(arr[1] == 1e2);
+      REQUIRE(arr[0].as<float>() == Approx(4.2f));
+      REQUIRE(arr[1] == 1e2f);
+      REQUIRE(spy.log() == AllocatorLog{
+                               Allocate(sizeofPool()),
+                               Reallocate(sizeofPool(), sizeofPool(2)),
+                           });
+    }
+
+    SECTION("Double") {
+      DeserializationError err = deserializeJson(doc, "[4.2123456,-7E89]");
+      JsonArray arr = doc.as<JsonArray>();
+
+      REQUIRE(err == DeserializationError::Ok);
+      REQUIRE(2 == arr.size());
+      REQUIRE(arr[0].as<double>() == Approx(4.2123456));
+      REQUIRE(arr[1] == -7E89);
+      REQUIRE(spy.log() == AllocatorLog{
+                               Allocate(sizeofPool()),
+                               Reallocate(sizeofPool(), sizeofPool(4)),
+                           });
     }
 
     SECTION("Unsigned long") {

extras/tests/JsonDeserializer/errors.cpp

@@ -6,6 +6,8 @@
 #include <ArduinoJson.h>
 #include <catch.hpp>
 
+#include "Allocators.hpp"
+
 TEST_CASE("deserializeJson() returns IncompleteInput") {
   const char* testCases[] = {
       // strings
@@ -118,3 +120,43 @@ TEST_CASE("deserializeJson() returns NoMemory if string length overflows") {
     REQUIRE(err == DeserializationError::NoMemory);
   }
 }
+
+TEST_CASE("deserializeJson() returns NoMemory if extension allocation fails") {
+  JsonDocument doc(FailingAllocator::instance());
+
+  SECTION("uint32_t should pass") {
+    auto err = deserializeJson(doc, "4294967295");
+
+    REQUIRE(err == DeserializationError::Ok);
+  }
+
+  SECTION("uint64_t should fail") {
+    auto err = deserializeJson(doc, "18446744073709551615");
+
+    REQUIRE(err == DeserializationError::NoMemory);
+  }
+
+  SECTION("int32_t should pass") {
+    auto err = deserializeJson(doc, "-2147483648");
+
+    REQUIRE(err == DeserializationError::Ok);
+  }
+
+  SECTION("int64_t should fail") {
+    auto err = deserializeJson(doc, "-9223372036854775808");
+
+    REQUIRE(err == DeserializationError::NoMemory);
+  }
+
+  SECTION("float should pass") {
+    auto err = deserializeJson(doc, "3.402823e38");
+
+    REQUIRE(err == DeserializationError::Ok);
+  }
+
+  SECTION("double should fail") {
+    auto err = deserializeJson(doc, "1.7976931348623157e308");
+
+    REQUIRE(err == DeserializationError::NoMemory);
+  }
+}

extras/tests/JsonDeserializer/object.cpp

@@ -155,15 +155,27 @@ TEST_CASE("deserialize JSON object") {
       REQUIRE(obj["key2"] == -42);
     }
 
-    SECTION("Double") {
+    SECTION("Float") {
       DeserializationError err =
-          deserializeJson(doc, "{\"key1\":12.345,\"key2\":-7E89}");
+          deserializeJson(doc, "{\"key1\":12.345,\"key2\":-7E3}");
       JsonObject obj = doc.as<JsonObject>();
 
       REQUIRE(err == DeserializationError::Ok);
       REQUIRE(doc.is<JsonObject>());
       REQUIRE(obj.size() == 2);
-      REQUIRE(obj["key1"] == 12.345);
+      REQUIRE(obj["key1"].as<float>() == Approx(12.345f));
+      REQUIRE(obj["key2"] == -7E3f);
+    }
+
+    SECTION("Double") {
+      DeserializationError err =
+          deserializeJson(doc, "{\"key1\":12.3456789,\"key2\":-7E89}");
+      JsonObject obj = doc.as<JsonObject>();
+
+      REQUIRE(err == DeserializationError::Ok);
+      REQUIRE(doc.is<JsonObject>());
+      REQUIRE(obj.size() == 2);
+      REQUIRE(obj["key1"].as<double>() == Approx(12.3456789));
       REQUIRE(obj["key2"] == -7E89);
     }
 

extras/tests/JsonVariant/as.cpp

@@ -203,7 +203,7 @@ TEST_CASE("JsonVariant::as()") {
 
     REQUIRE(variant.as<bool>() == true);
     REQUIRE(variant.as<long>() == 4L);
-    REQUIRE(variant.as<double>() == 4.2);
+    REQUIRE(variant.as<double>() == Approx(4.2));
     REQUIRE(variant.as<const char*>() == "4.2"_s);
     REQUIRE(variant.as<std::string>() == "4.2"_s);
     REQUIRE(variant.as<JsonString>() == "4.2");

extras/tests/Numbers/parseFloat.cpp

@@ -60,10 +60,15 @@ TEST_CASE("parseNumber<float>()") {
 
   SECTION("VeryLong") {
     checkFloat("0.00000000000000000000000000000001", 1e-32f);
-    checkFloat("100000000000000000000000000000000.0", 1e+32f);
-    checkFloat(
-        "100000000000000000000000000000000.00000000000000000000000000000",
-        1e+32f);
+
+    // The following don't work because they have many digits so parseNumber()
+    // treats them as double. But it's not an issue because JsonVariant will use
+    // a float to store them.
+    //
+    // checkFloat("100000000000000000000000000000000.0", 1e+32f);
+    // checkFloat(
+    //     "100000000000000000000000000000000.00000000000000000000000000000",
+    //     1e+32f);
   }
 
   SECTION("NaN") {

extras/tests/Numbers/parseNumber.cpp

@@ -23,7 +23,7 @@ TEST_CASE("Test unsigned integer overflow") {
   }
 
   REQUIRE(first.type() == NumberType::UnsignedInteger);
-  REQUIRE(second.type() == NumberType::Float);
+  REQUIRE(second.type() == NumberType::Double);
 }
 
 TEST_CASE("Test signed integer overflow") {
@@ -41,7 +41,7 @@ TEST_CASE("Test signed integer overflow") {
   }
 
   REQUIRE(first.type() == NumberType::SignedInteger);
-  REQUIRE(second.type() == NumberType::Float);
+  REQUIRE(second.type() == NumberType::Double);
 }
 
 TEST_CASE("Invalid value") {
@@ -49,3 +49,15 @@ TEST_CASE("Invalid value") {
 
   REQUIRE(result.type() == NumberType::Invalid);
 }
+
+TEST_CASE("float") {
+  auto result = parseNumber("3.402823e38");
+
+  REQUIRE(result.type() == NumberType::Float);
+}
+
+TEST_CASE("double") {
+  auto result = parseNumber("1.7976931348623157e308");
+
+  REQUIRE(result.type() == NumberType::Double);
+}