avoid problem with literal "nan" / "inf" having inconsistent equality behaviour

Author: mgravell

src/StackExchange.Redis/RedisValue.cs

@@ -986,7 +986,8 @@ internal RedisValue Simplify()
                         if (Format.TryParseInt64(s, out i64)) return i64;
                         if (Format.TryParseUInt64(s, out u64)) return u64;
                     }
-                    if (Format.TryParseDouble(s, out var f64)) return f64;
+                    // note: don't simplify inf/nan, as that causes equality semantic problems
+                    if (Format.TryParseDouble(s, out var f64) && !IsSpecialDouble(f64)) return f64;
                     break;
                 case StorageType.Raw:
                     var b = _memory.Span;
@@ -995,7 +996,8 @@ internal RedisValue Simplify()
                         if (Format.TryParseInt64(b, out i64)) return i64;
                         if (Format.TryParseUInt64(b, out u64)) return u64;
                     }
-                    if (TryParseDouble(b, out f64)) return f64;
+                    // note: don't simplify inf/nan, as that causes equality semantic problems
+                    if (TryParseDouble(b, out f64) && !IsSpecialDouble(f64)) return f64;
                     break;
                 case StorageType.Double:
                     // is the double actually an integer?
@@ -1006,6 +1008,8 @@ internal RedisValue Simplify()
             return this;
         }
 
+        private static bool IsSpecialDouble(double d) => double.IsNaN(d) || double.IsInfinity(d);
+
         /// <summary>
         /// Convert to a signed <see cref="long"/> if possible.
         /// </summary>

tests/StackExchange.Redis.Tests/RedisValueEquivalencyTests.cs

@@ -157,6 +157,125 @@ static void Check(RedisValue known, RedisValue test)
         CheckString(double.NaN, "NaN");
     }
 
+    [Theory]
+    [InlineData("na")]
+    [InlineData("nan")]
+    [InlineData("nans")]
+    [InlineData("in")]
+    [InlineData("inf")]
+    [InlineData("info")]
+    public void SpecialCaseEqualityRules_String(string value)
+    {
+        RedisValue x = value, y = value;
+        Assert.Equal(x, y);
+
+        Assert.True(x.Equals(y));
+        Assert.True(y.Equals(x));
+        Assert.True(x == y);
+        Assert.True(y == x);
+        Assert.False(x != y);
+        Assert.False(y != x);
+        Assert.Equal(x.GetHashCode(), y.GetHashCode());
+    }
+
+    [Theory]
+    [InlineData("na")]
+    [InlineData("nan")]
+    [InlineData("nans")]
+    [InlineData("in")]
+    [InlineData("inf")]
+    [InlineData("info")]
+    public void SpecialCaseEqualityRules_Bytes(string value)
+    {
+        byte[] bytes0 = Encoding.UTF8.GetBytes(value),
+               bytes1 = Encoding.UTF8.GetBytes(value);
+        Assert.NotSame(bytes0, bytes1);
+        RedisValue x = bytes0, y = bytes1;
+
+        Assert.True(x.Equals(y));
+        Assert.True(y.Equals(x));
+        Assert.True(x == y);
+        Assert.True(y == x);
+        Assert.False(x != y);
+        Assert.False(y != x);
+        Assert.Equal(x.GetHashCode(), y.GetHashCode());
+    }
+
+    [Theory]
+    [InlineData("na")]
+    [InlineData("nan")]
+    [InlineData("nans")]
+    [InlineData("in")]
+    [InlineData("inf")]
+    [InlineData("info")]
+    public void SpecialCaseEqualityRules_Hybrid(string value)
+    {
+        byte[] bytes = Encoding.UTF8.GetBytes(value);
+        RedisValue x = bytes, y = value;
+
+        Assert.True(x.Equals(y));
+        Assert.True(y.Equals(x));
+        Assert.True(x == y);
+        Assert.True(y == x);
+        Assert.False(x != y);
+        Assert.False(y != x);
+        Assert.Equal(x.GetHashCode(), y.GetHashCode());
+    }
+
+    [Theory]
+    [InlineData("na", "NA")]
+    [InlineData("nan", "NAN")]
+    [InlineData("nans", "NANS")]
+    [InlineData("in", "IN")]
+    [InlineData("inf", "INF")]
+    [InlineData("info", "INFO")]
+    public void SpecialCaseNonEqualityRules_String(string s, string t)
+    {
+        RedisValue x = s, y = t;
+        Assert.False(x.Equals(y));
+        Assert.False(y.Equals(x));
+        Assert.False(x == y);
+        Assert.False(y == x);
+        Assert.True(x != y);
+        Assert.True(y != x);
+    }
+
+    [Theory]
+    [InlineData("na", "NA")]
+    [InlineData("nan", "NAN")]
+    [InlineData("nans", "NANS")]
+    [InlineData("in", "IN")]
+    [InlineData("inf", "INF")]
+    [InlineData("info", "INFO")]
+    public void SpecialCaseNonEqualityRules_Bytes(string s, string t)
+    {
+        RedisValue x = Encoding.UTF8.GetBytes(s), y = Encoding.UTF8.GetBytes(t);
+        Assert.False(x.Equals(y));
+        Assert.False(y.Equals(x));
+        Assert.False(x == y);
+        Assert.False(y == x);
+        Assert.True(x != y);
+        Assert.True(y != x);
+    }
+
+    [Theory]
+    [InlineData("na", "NA")]
+    [InlineData("nan", "NAN")]
+    [InlineData("nans", "NANS")]
+    [InlineData("in", "IN")]
+    [InlineData("inf", "INF")]
+    [InlineData("info", "INFO")]
+    public void SpecialCaseNonEqualityRules_Hybrid(string s, string t)
+    {
+        RedisValue x = s, y = Encoding.UTF8.GetBytes(t);
+        Assert.False(x.Equals(y));
+        Assert.False(y.Equals(x));
+        Assert.False(x == y);
+        Assert.False(y == x);
+        Assert.True(x != y);
+        Assert.True(y != x);
+    }
+
     private static void CheckString(RedisValue value, string expected)
     {
         var s = value.ToString();