feat: Enhance numeric comparison in HeapEquableValue and add unit tests for double vs int equality

Author: gedaiu

source/fluentasserts/core/conversion/floats.d

@@ -11,8 +11,8 @@ version (unittest) {
 
 /// Parses a string as a double value.
 ///
-/// A simple parser for numeric strings that handles integers and decimals.
-/// Does not support scientific notation.
+/// A simple parser for numeric strings that handles integers, decimals,
+/// and scientific notation (e.g., "1.0032e+06").
 ///
 /// Params:
 ///   s = The string to parse
@@ -52,6 +52,54 @@ double parseDouble(const(char)[] s, out bool success) @nogc nothrow pure @safe {
       }
     } else if (c == '.' && !seenDot) {
       seenDot = true;
+    } else if ((c == 'e' || c == 'E') && seenDigit) {
+      // Handle scientific notation
+      i++;
+      if (i >= s.length) {
+        return 0.0;
+      }
+
+      bool expNegative = false;
+      if (s[i] == '-') {
+        expNegative = true;
+        i++;
+      } else if (s[i] == '+') {
+        i++;
+      }
+
+      if (i >= s.length) {
+        return 0.0;
+      }
+
+      int exponent = 0;
+      bool seenExpDigit = false;
+      for (; i < s.length; i++) {
+        char ec = s[i];
+        if (ec >= '0' && ec <= '9') {
+          seenExpDigit = true;
+          exponent = exponent * 10 + (ec - '0');
+        } else {
+          return 0.0;
+        }
+      }
+
+      if (!seenExpDigit) {
+        return 0.0;
+      }
+
+      // Apply exponent
+      double multiplier = 1.0;
+      for (int j = 0; j < exponent; j++) {
+        multiplier *= 10.0;
+      }
+
+      if (expNegative) {
+        result /= multiplier;
+      } else {
+        result *= multiplier;
+      }
+
+      break;
     } else {
       return 0.0;
     }
@@ -198,3 +246,21 @@ unittest {
   expect(result.value).to.be.approximately(0.125, 0.001);
 }
 
+@("parseDouble parses scientific notation 1.0032e+06")
+unittest {
+  import std.math : abs;
+  bool success;
+  double val = parseDouble("1.0032e+06", success);
+  assert(success, "parseDouble should succeed for scientific notation");
+  // Use approximate comparison for floating point
+  assert(abs(val - 1003200.0) < 0.01, "1.0032e+06 should parse to approximately 1003200.0");
+}
+
+@("parseDouble parses integer 1003200")
+unittest {
+  bool success;
+  double val = parseDouble("1003200", success);
+  assert(success, "parseDouble should succeed for integer");
+  assert(val == 1003200.0, "1003200 should parse to 1003200.0");
+}
+

source/fluentasserts/core/memory/heapequable.d

@@ -81,8 +81,17 @@ struct HeapEquableValue {
       return false;
     }
 
-    // Otherwise fall back to string comparison
-    return _serialized == other._serialized;
+    // Try string comparison first
+    if (_serialized == other._serialized) {
+      return true;
+    }
+
+    // For scalars, try numeric comparison (handles double vs int, scientific notation)
+    if (_kind == Kind.scalar && other._kind == Kind.scalar) {
+      return numericEquals(_serialized[], other._serialized[]);
+    }
+
+    return false;
   }
 
   bool isEqualTo(const HeapEquableValue other) nothrow const @trusted {
@@ -96,8 +105,52 @@ struct HeapEquableValue {
       return false;
     }
 
-    // Otherwise fall back to string comparison
-    return _serialized == other._serialized;
+    // Try string comparison first
+    if (_serialized == other._serialized) {
+      return true;
+    }
+
+    // For scalars, try numeric comparison (handles double vs int, scientific notation)
+    if (_kind == Kind.scalar && other._kind == Kind.scalar) {
+      return numericEquals(_serialized[], other._serialized[]);
+    }
+
+    return false;
+  }
+
+  /// Compares two string representations as numbers if both are numeric.
+  /// Uses relative epsilon comparison for floating point tolerance.
+  private static bool numericEquals(const(char)[] a, const(char)[] b) @nogc nothrow pure @safe {
+    bool aIsNum, bIsNum;
+    double aVal = parseDouble(a, aIsNum);
+    double bVal = parseDouble(b, bIsNum);
+
+    if (aIsNum && bIsNum) {
+      return approxEqual(aVal, bVal);
+    }
+
+    return false;
+  }
+
+  /// Approximate equality check for floating point numbers.
+  /// Uses relative epsilon for large numbers and absolute epsilon for small numbers.
+  private static bool approxEqual(double a, double b) @nogc nothrow pure @safe {
+    import core.stdc.math : fabs;
+
+    // Handle exact equality (including infinities)
+    if (a == b) {
+      return true;
+    }
+
+    double diff = fabs(a - b);
+    double larger = fabs(a) > fabs(b) ? fabs(a) : fabs(b);
+
+    // Use relative epsilon scaled to the magnitude of the numbers
+    // For numbers around 1e6, epsilon of ~1e-9 relative gives ~1e-3 absolute tolerance
+    enum double relEpsilon = 1e-9;
+    enum double absEpsilon = 1e-9;
+
+    return diff <= larger * relEpsilon || diff <= absEpsilon;
   }
 
   bool isLessThan(ref const HeapEquableValue other) @nogc nothrow const @trusted {
@@ -376,6 +429,18 @@ version (unittest) {
     assert(!v1.isEqualTo(v3));
   }
 
+  @("isEqualTo handles numeric comparison for double vs int")
+  unittest {
+    // 1003200.0 serialized as scientific notation vs integer
+    auto doubleVal = HeapEquableValue.createScalar("1.0032e+06");
+    auto intVal = HeapEquableValue.createScalar("1003200");
+
+    assert(doubleVal.kind() == HeapEquableValue.Kind.scalar);
+    assert(intVal.kind() == HeapEquableValue.Kind.scalar);
+    assert(doubleVal.isEqualTo(intVal), "1.0032e+06 should equal 1003200");
+    assert(intVal.isEqualTo(doubleVal), "1003200 should equal 1.0032e+06");
+  }
+
   @("array type stores elements")
   unittest {
     auto arr = HeapEquableValue.createArray("[1, 2, 3]");

source/fluentasserts/operations/equality/equal.d

@@ -939,6 +939,23 @@ unittest {
   evaluation.result.messageString.should.contain("should equal null.");
 }
 
+@("double equals int with same value passes")
+unittest {
+  // 1003200.0 serializes as "1.0032e+06" and 1003200 as "1003200"
+  // Numeric comparison should still work
+  (1003200.0).should.equal(1003200);
+  (1003200).should.equal(1003200.0);
+}
+
+@("double equals int with different value fails")
+unittest {
+  auto evaluation = ({
+    (1003200.0).should.equal(1003201);
+  }).recordEvaluation;
+
+  evaluation.result.hasContent().should.equal(true);
+}
+
 version (unittest):
 class EqualThing {
   int x;