(+) full test coverage

Author: Felix

DualNumbers.Test/Interfaces/Dual_IDecrementOperatorsTests.cs

@@ -7,11 +7,21 @@ public class DualIDecrementOperatorsTests
 {
     private static T Decrement<T>(T value) where T : IDecrementOperators<T> => --value;
 
+    private static Dual DecrementDirect(Dual value) => --value;
+
     [Test]
     public void IDecrementOperators_Decrement_ReducesRealPartOnly()
     {
         Dual result = Decrement(new Dual(8.0, 3.0));
 
         DualInterfaceAssert.AreEqual(result, 7.0, 3.0);
     }
+
+    [Test]
+    public void OperatorDecrement_DirectOperator_ReducesRealPartOnly()
+    {
+        Dual result = DecrementDirect(new Dual(8.0, 3.0));
+
+        DualInterfaceAssert.AreEqual(result, 7.0, 3.0);
+    }
 }

DualNumbers.Test/Interfaces/Dual_IEqualityOperatorsTests.cs

@@ -17,4 +17,15 @@ public void IEqualityOperators_EqualityAndInequality_WorkAsExpected()
         Assert.That(AreEqual(left, new Dual(3.0, 2.0)), Is.True);
         Assert.That(AreNotEqual(left, new Dual(3.0, 5.0)), Is.True);
     }
+
+    [Test]
+    public void IEqualityOperators_BranchCombinations_WorkAsExpected()
+    {
+        Dual reference = new(3.0, 2.0);
+
+        Assert.That(AreEqual(reference, new Dual(9.0, 2.0)), Is.False);
+        Assert.That(AreEqual(reference, new Dual(3.0, 9.0)), Is.False);
+        Assert.That(AreNotEqual(reference, new Dual(9.0, 2.0)), Is.True);
+        Assert.That(AreNotEqual(reference, new Dual(3.0, 2.0)), Is.False);
+    }
 }

DualNumbers.Test/Interfaces/Dual_IEquatableTests.cs

@@ -13,4 +13,26 @@ public void IEquatable_Equals_WorkAsExpected()
         Assert.That(EqualsViaInterface(left, new Dual(3.0, 2.0)), Is.True);
         Assert.That(EqualsViaInterface(left, new Dual(3.0, 5.0)), Is.False);
     }
+
+    [Test]
+    public void IEquatable_EqualsObjectAndHashCode_WorkAsExpected()
+    {
+        Dual left = new(3.0, 2.0);
+        object same = new Dual(3.0, 2.0);
+        object different = new Dual(3.0, 5.0);
+
+        Assert.That(left.Equals(same), Is.True);
+        Assert.That(left.Equals(different), Is.False);
+        Assert.That(left.GetHashCode(), Is.EqualTo(((Dual)same).GetHashCode()));
+    }
+
+    [Test]
+    public void IEquatable_EqualsObject_BranchesForNullAndDifferentType()
+    {
+        Dual left = new(3.0, 2.0);
+
+        Assert.That(left.Equals(null), Is.False);
+        Assert.That(left.Equals("not-a-dual"), Is.False);
+        Assert.That(left.Equals(new Dual(9.0, 2.0)), Is.False);
+    }
 }

DualNumbers.Test/Interfaces/Dual_IIncrementOperatorsTests.cs

@@ -7,11 +7,21 @@ public class DualIIncrementOperatorsTests
 {
     private static T Increment<T>(T value) where T : IIncrementOperators<T> => ++value;
 
+    private static Dual IncrementDirect(Dual value) => ++value;
+
     [Test]
     public void IIncrementOperators_Increment_IncreasesRealPartOnly()
     {
         Dual result = Increment(new Dual(8.0, 3.0));
 
         DualInterfaceAssert.AreEqual(result, 9.0, 3.0);
     }
+
+    [Test]
+    public void OperatorIncrement_DirectOperator_IncreasesRealPartOnly()
+    {
+        Dual result = IncrementDirect(new Dual(8.0, 3.0));
+
+        DualInterfaceAssert.AreEqual(result, 9.0, 3.0);
+    }
 }

DualNumbers.Test/Interfaces/Dual_INumberBaseTests.cs

@@ -1,4 +1,6 @@
 using System.Numerics;
+using System.Globalization;
+using System.Diagnostics.CodeAnalysis;
 
 namespace DualNumbers.Test.Interfaces;
 
@@ -14,6 +16,22 @@ public class DualINumberBaseTests
     private static double GetAbs<T>(T value) where T : INumberBase<T>
         => double.CreateChecked(T.Abs(value));
 
+    private static bool IsFinite<T>(T value) where T : INumberBase<T> => T.IsFinite(value);
+
+    private static bool IsZero<T>(T value) where T : INumberBase<T> => T.IsZero(value);
+
+    private static T ParseFromString<T>(string s, NumberStyles style, IFormatProvider? provider) where T : INumberBase<T>
+        => T.Parse(s, style, provider);
+
+    private static T ParseFromSpan<T>(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider) where T : INumberBase<T>
+        => T.Parse(s, style, provider);
+
+    private static bool TryParseFromString<T>(string? s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out T result) where T : INumberBase<T>
+        => T.TryParse(s, style, provider, out result);
+
+    private static bool TryParseFromSpan<T>(ReadOnlySpan<char> s, NumberStyles style, IFormatProvider? provider, [MaybeNullWhen(false)] out T result) where T : INumberBase<T>
+        => T.TryParse(s, style, provider, out result);
+
     [Test]
     public void INumberBase_RadixOneAndZero_ReturnExpectedValues()
     {
@@ -29,4 +47,62 @@ public void INumberBase_Abs_UsesMagnitude()
 
         Assert.That(abs, Is.EqualTo(5.0).Within(1e-12));
     }
+
+    [Test]
+    public void INumberBase_IsFiniteAndIsZero_WorkAsExpected()
+    {
+        Assert.That(IsFinite(new Dual(1.0, 0.0)), Is.True);
+        Assert.That(IsFinite(new Dual(double.PositiveInfinity, 0.0)), Is.False);
+        Assert.That(IsZero(Dual.Zero), Is.True);
+    }
+
+    [Test]
+    public void INumberBase_ParseAndTryParse_WithNumberStyles_WorkAsExpected()
+    {
+        Complex expected = new(3.5, -2.25);
+        string text = expected.ToString(CultureInfo.InvariantCulture);
+        NumberStyles style = NumberStyles.Float | NumberStyles.AllowParentheses;
+
+        Dual parsedFromString = ParseFromString<Dual>(text, style, CultureInfo.InvariantCulture);
+        Dual parsedFromSpan = ParseFromSpan<Dual>(text.AsSpan(), style, CultureInfo.InvariantCulture);
+        bool tryStringOk = TryParseFromString<Dual>(text, style, CultureInfo.InvariantCulture, out Dual tryParsedFromString);
+        bool trySpanOk = TryParseFromSpan<Dual>(text.AsSpan(), style, CultureInfo.InvariantCulture, out Dual tryParsedFromSpan);
+
+        Assert.That(tryStringOk, Is.True);
+        Assert.That(trySpanOk, Is.True);
+        DualInterfaceAssert.AreEqual(parsedFromString, expected.Real, expected.Imaginary);
+        DualInterfaceAssert.AreEqual(parsedFromSpan, expected.Real, expected.Imaginary);
+        DualInterfaceAssert.AreEqual(tryParsedFromString, expected.Real, expected.Imaginary);
+        DualInterfaceAssert.AreEqual(tryParsedFromSpan, expected.Real, expected.Imaginary);
+    }
+
+    [Test]
+    public void INumberBase_ExplicitTryConvertFromMethods_WorkAsExpected()
+    {
+        bool checkedOk = Dual.TryConvertFromChecked(3.25d, out Dual checkedResult);
+        bool saturatingOk = Dual.TryConvertFromSaturating(new Complex(double.PositiveInfinity, double.NegativeInfinity), out Dual saturatingResult);
+        bool truncatingOk = Dual.TryConvertFromTruncating(new Complex(2.9, -7.2), out Dual truncatingResult);
+
+        Assert.That(checkedOk, Is.True);
+        Assert.That(saturatingOk, Is.True);
+        Assert.That(truncatingOk, Is.True);
+        DualInterfaceAssert.AreEqual(checkedResult, 3.25, 0.0);
+        DualInterfaceAssert.AreEqual(saturatingResult, double.MaxValue, double.MinValue);
+        DualInterfaceAssert.AreEqual(truncatingResult, 2.0, -7.0);
+    }
+
+    [Test]
+    public void INumberBase_ExplicitTryConvertToMethods_WorkAsExpected()
+    {
+        bool checkedOk = Dual.TryConvertToChecked(new Dual(3.0, 4.0), out int checkedResult);
+        bool saturatingOk = Dual.TryConvertToSaturating(new Dual(1e308, 1e308), out int saturatingResult);
+        bool truncatingOk = Dual.TryConvertToTruncating(new Dual(3.0, 4.0), out Complex truncatingResult);
+
+        Assert.That(checkedOk, Is.True);
+        Assert.That(saturatingOk, Is.True);
+        Assert.That(truncatingOk, Is.True);
+        Assert.That(checkedResult, Is.EqualTo(5));
+        Assert.That(saturatingResult, Is.EqualTo(int.MaxValue));
+        Assert.That(truncatingResult, Is.EqualTo(new Complex(3.0, 4.0)));
+    }
 }

DualNumbers.Test/Interfaces/Dual_INumberTests.cs

@@ -1,4 +1,5 @@
 using System.Numerics;
+using System.Globalization;
 
 namespace DualNumbers.Test.Interfaces;
 
@@ -9,6 +10,20 @@ public class DualINumberTests
 
     private static bool LessThan<T>(T left, T right) where T : IComparisonOperators<T, T, bool> => left < right;
 
+    private const double Tolerance = 1e-12;
+
+    private static void AssertDualMatchesComplex(Dual actual, Complex expected)
+    {
+        Assert.That(actual.real, Is.EqualTo(expected.Real).Within(Tolerance));
+        Assert.That(actual.dual, Is.EqualTo(expected.Imaginary).Within(Tolerance));
+    }
+
+    private static bool GreaterThan(Dual left, Dual right) => left > right;
+
+    private static bool LessThanOrEqual(Dual left, Dual right) => left <= right;
+
+    private static bool GreaterThanOrEqual(Dual left, Dual right) => left >= right;
+
     [Test]
     public void INumber_UnsupportedOperators_ThrowNotSupportedException()
     {
@@ -17,5 +32,78 @@ public void INumber_UnsupportedOperators_ThrowNotSupportedException()
 
         Assert.Throws<NotSupportedException>(() => _ = Modulus(left, right));
         Assert.Throws<NotSupportedException>(() => _ = LessThan(left, right));
+        Assert.Throws<NotSupportedException>(() => _ = GreaterThan(left, right));
+        Assert.Throws<NotSupportedException>(() => _ = LessThanOrEqual(left, right));
+        Assert.Throws<NotSupportedException>(() => _ = GreaterThanOrEqual(left, right));
+    }
+
+    [Test]
+    public void INumber_PredicateMembers_MatchComplexImplementations()
+    {
+        Dual value = new(2.0, 3.0);
+        Complex expected = new(2.0, 3.0);
+
+        Assert.That(Dual.IsComplexNumber(value), Is.EqualTo(Complex.IsComplexNumber(expected)));
+        Assert.That(Dual.IsEvenInteger(value), Is.EqualTo(Complex.IsEvenInteger(expected)));
+        Assert.That(Dual.IsFinite(value), Is.EqualTo(Complex.IsFinite(expected)));
+        Assert.That(Dual.IsImaginaryNumber(value), Is.EqualTo(Complex.IsImaginaryNumber(expected)));
+        Assert.That(Dual.IsInfinity(value), Is.EqualTo(Complex.IsInfinity(expected)));
+        Assert.That(Dual.IsInteger(value), Is.EqualTo(Complex.IsInteger(expected)));
+        Assert.That(Dual.IsNaN(value), Is.EqualTo(Complex.IsNaN(expected)));
+        Assert.That(Dual.IsNegative(value), Is.EqualTo(Complex.IsNegative(expected)));
+        Assert.That(Dual.IsNegativeInfinity(value), Is.EqualTo(Complex.IsNegativeInfinity(expected)));
+        Assert.That(Dual.IsNormal(value), Is.EqualTo(Complex.IsNormal(expected)));
+        Assert.That(Dual.IsOddInteger(value), Is.EqualTo(Complex.IsOddInteger(expected)));
+        Assert.That(Dual.IsPositive(value), Is.EqualTo(Complex.IsPositive(expected)));
+        Assert.That(Dual.IsPositiveInfinity(value), Is.EqualTo(Complex.IsPositiveInfinity(expected)));
+        Assert.That(Dual.IsRealNumber(value), Is.EqualTo(Complex.IsRealNumber(expected)));
+        Assert.That(Dual.IsSubnormal(value), Is.EqualTo(Complex.IsSubnormal(expected)));
+        Assert.That(Dual.IsZero(Dual.Zero), Is.True);
+    }
+
+    [Test]
+    public void INumber_AbsAndMagnitudeMethods_MatchComplex()
+    {
+        Dual x = new(3.0, 4.0);
+        Dual y = new(2.0, -10.0);
+        Complex cx = new(3.0, 4.0);
+        Complex cy = new(2.0, -10.0);
+
+        Assert.That(Dual.Abs(x), Is.EqualTo(Complex.Abs(cx)).Within(Tolerance));
+        AssertDualMatchesComplex(Dual.MaxMagnitude(x, y), Complex.MaxMagnitude(cx, cy));
+        AssertDualMatchesComplex(Dual.MinMagnitude(x, y), Complex.MinMagnitude(cx, cy));
+    }
+
+    [Test]
+    public void INumber_ParseAndTryParse_WithNumberStyles_MatchComplex()
+    {
+        Complex expected = new(3.5, -2.25);
+        string text = expected.ToString(CultureInfo.InvariantCulture);
+        NumberStyles style = NumberStyles.Float | NumberStyles.AllowParentheses;
+
+        Dual parsedFromString = Dual.Parse(text, style, CultureInfo.InvariantCulture);
+        Dual parsedFromSpan = Dual.Parse(text.AsSpan(), style, CultureInfo.InvariantCulture);
+        bool tryStringOk = Dual.TryParse(text, style, CultureInfo.InvariantCulture, out Dual tryParsedString);
+        bool trySpanOk = Dual.TryParse(text.AsSpan(), style, CultureInfo.InvariantCulture, out Dual tryParsedSpan);
+
+        Assert.That(tryStringOk, Is.True);
+        Assert.That(trySpanOk, Is.True);
+        AssertDualMatchesComplex(parsedFromString, expected);
+        AssertDualMatchesComplex(parsedFromSpan, expected);
+        AssertDualMatchesComplex(tryParsedString, expected);
+        AssertDualMatchesComplex(tryParsedSpan, expected);
+    }
+
+    [Test]
+    public void INumber_UnsupportedMembers_ThrowNotSupportedException()
+    {
+        Dual left = new(2.0, 1.0);
+        Dual right = new(1.0, 0.0);
+
+        Assert.Throws<NotSupportedException>(() => _ = Dual.IsCanonical(left));
+        Assert.Throws<NotSupportedException>(() => _ = Dual.MaxMagnitudeNumber(left, right));
+        Assert.Throws<NotSupportedException>(() => _ = Dual.MinMagnitudeNumber(left, right));
+        Assert.Throws<NotSupportedException>(() => _ = left.CompareTo((object?)right));
+        Assert.Throws<NotSupportedException>(() => _ = left.CompareTo(right));
     }
 }

DualNumbers.Test/Interfaces/Dual_IUnaryPlusOperatorsTests.cs

@@ -7,11 +7,21 @@ public class DualIUnaryPlusOperatorsTests
 {
     private static T UnaryPlus<T>(T value) where T : IUnaryPlusOperators<T, T> => +value;
 
+    private static Dual UnaryPlusDirect(Dual value) => +value;
+
     [Test]
     public void IUnaryPlusOperators_UnaryPlus_ReturnsUnchangedDual()
     {
         Dual result = UnaryPlus(new Dual(8.0, 3.0));
 
         DualInterfaceAssert.AreEqual(result, 8.0, 3.0);
     }
+
+    [Test]
+    public void OperatorUnaryPlus_DirectOperator_ReturnsUnchangedDual()
+    {
+        Dual result = UnaryPlusDirect(new Dual(8.0, 3.0));
+
+        DualInterfaceAssert.AreEqual(result, 8.0, 3.0);
+    }
 }