feat(tests): add new equality assertions for enums and custom value types

TUnit.Assertions.Tests/EnumTests.cs

@@ -167,4 +167,123 @@ await Assert.That(async () =>
             await Assert.That(value).DoesNotHaveSameValueAs(value2)
         ).Throws<AssertionException>();
     }
+
+    [Test]
+    public async Task IsEqualTo_Good()
+    {
+        var value = MyEnum.One;
+
+        await Assert.That(value).IsEqualTo(MyEnum.One);
+    }
+
+    [Test]
+    public async Task IsEqualTo_Bad()
+    {
+        var value = MyEnum.One;
+
+        await Assert.That(async () =>
+            await Assert.That(value).IsEqualTo(MyEnum.Two)
+        ).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task IsEqualTo_Nullable_Good()
+    {
+        MyEnum? value = MyEnum.One;
+
+        await Assert.That(value).IsEqualTo(MyEnum.One);
+    }
+
+    [Test]
+    public async Task IsEqualTo_Nullable_Bad()
+    {
+        MyEnum? value = MyEnum.One;
+
+        await Assert.That(async () =>
+            await Assert.That(value).IsEqualTo(MyEnum.Two)
+        ).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task IsEqualTo_Nullable_Null()
+    {
+        MyEnum? value = null;
+
+        await Assert.That(async () =>
+            await Assert.That(value).IsEqualTo(MyEnum.One)
+        ).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task IsTypeOf_Enum()
+    {
+        object value = MyEnum.One;
+
+        await Assert.That(value).IsTypeOf<MyEnum>();
+    }
+
+    [Test]
+    public async Task IsNotEqualTo_Good()
+    {
+        var value = MyEnum.One;
+
+        await Assert.That(value).IsNotEqualTo(MyEnum.Two);
+    }
+
+    [Test]
+    public async Task IsNotEqualTo_Bad()
+    {
+        var value = MyEnum.One;
+
+        await Assert.That(async () =>
+            await Assert.That(value).IsNotEqualTo(MyEnum.One)
+        ).Throws<AssertionException>();
+    }
+
+    // Custom value type (struct) tests
+    public struct CustomValueType
+    {
+        public int Value { get; set; }
+        public string Name { get; set; }
+
+        public CustomValueType(int value, string name)
+        {
+            Value = value;
+            Name = name;
+        }
+    }
+
+    [Test]
+    public async Task CustomValueType_IsEqualTo_Good()
+    {
+        var value = new CustomValueType(42, "Test");
+
+        await Assert.That(value).IsEqualTo(new CustomValueType(42, "Test"));
+    }
+
+    [Test]
+    public async Task CustomValueType_IsEqualTo_Bad()
+    {
+        var value = new CustomValueType(42, "Test");
+
+        await Assert.That(async () =>
+            await Assert.That(value).IsEqualTo(new CustomValueType(99, "Different"))
+        ).Throws<AssertionException>();
+    }
+
+    [Test]
+    public async Task CustomValueType_IsNotEqualTo_Good()
+    {
+        var value = new CustomValueType(42, "Test");
+
+        await Assert.That(value).IsNotEqualTo(new CustomValueType(99, "Different"));
+    }
+
+    [Test]
+    public async Task CustomValueType_IsTypeOf()
+    {
+        object value = new CustomValueType(42, "Test");
+
+        await Assert.That(value).IsTypeOf<CustomValueType>();
+    }
 }

TUnit.Assertions/Extensions/AssertionExtensions.cs

@@ -206,9 +206,9 @@ public static EqualsAssertion<TimeSpan> IsEqualTo(
     /// Asserts that a struct implementing IEquatable&lt;TExpected&gt; is equal to the expected value.
     /// This enables direct equality comparisons for structs with cross-type IEquatable implementations.
     /// Example: A Wrapper struct implementing IEquatable&lt;long&gt; can be compared directly to a long value.
-    /// Priority 1: Higher priority than generic fallback, uses type-specific IEquatable.Equals.
+    /// Priority -1: Lower than generic fallback; only used for cross-type IEquatable scenarios (TActual != TExpected).
     /// </summary>
-    [OverloadResolutionPriority(1)]
+    [OverloadResolutionPriority(-1)]
     public static EquatableAssertion<TActual, TExpected> IsEqualTo<TActual, TExpected>(
         this IAssertionSource<TActual> source,
         TExpected expected,
@@ -222,9 +222,9 @@ public static EquatableAssertion<TActual, TExpected> IsEqualTo<TActual, TExpecte
     /// <summary>
     /// Asserts that a nullable struct implementing IEquatable&lt;TExpected&gt; is equal to the expected value.
     /// Handles nullable structs with cross-type IEquatable implementations.
-    /// Priority 1: Higher priority than generic fallback, uses type-specific IEquatable.Equals.
+    /// Priority -1: Lower than generic fallback; only used for cross-type IEquatable scenarios (TActual != TExpected).
     /// </summary>
-    [OverloadResolutionPriority(1)]
+    [OverloadResolutionPriority(-1)]
     public static NullableEquatableAssertion<TActual, TExpected> IsEqualTo<TActual, TExpected>(
         this IAssertionSource<TActual?> source,
         TExpected expected,

TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet10_0.verified.txt

@@ -1685,10 +1685,10 @@ namespace .Extensions
         public static . IsEqualTo(this .<string> source, string expected,  comparison, [.("expected")] string? expression = null) { }
         [.(0)]
         public static .<TValue> IsEqualTo<TValue>(this .<TValue> source, TValue expected, [.("expected")] string? expression = null) { }
-        [.(1)]
+        [.(-1)]
         public static .<TActual, TExpected> IsEqualTo<TActual, TExpected>(this .<TActual> source, TExpected expected, [.("expected")] string? expression = null)
             where TActual :  struct, <TExpected> { }
-        [.(1)]
+        [.(-1)]
         public static .<TActual, TExpected> IsEqualTo<TActual, TExpected>(this .<TActual?> source, TExpected expected, [.("expected")] string? expression = null)
             where TActual :  struct, <TExpected> { }
         public static .<TValue> IsEquivalentTo<TValue>(this .<TValue> source, object? expected, [.("expected")] string? expression = null) { }

TUnit.PublicAPI/Tests.Assertions_Library_Has_No_API_Changes.DotNet9_0.verified.txt

@@ -1685,10 +1685,10 @@ namespace .Extensions
         public static . IsEqualTo(this .<string> source, string expected,  comparison, [.("expected")] string? expression = null) { }
         [.(0)]
         public static .<TValue> IsEqualTo<TValue>(this .<TValue> source, TValue expected, [.("expected")] string? expression = null) { }
-        [.(1)]
+        [.(-1)]
         public static .<TActual, TExpected> IsEqualTo<TActual, TExpected>(this .<TActual> source, TExpected expected, [.("expected")] string? expression = null)
             where TActual :  struct, <TExpected> { }
-        [.(1)]
+        [.(-1)]
         public static .<TActual, TExpected> IsEqualTo<TActual, TExpected>(this .<TActual?> source, TExpected expected, [.("expected")] string? expression = null)
             where TActual :  struct, <TExpected> { }
         public static .<TValue> IsEquivalentTo<TValue>(this .<TValue> source, object? expected, [.("expected")] string? expression = null) { }