Compare records by properties when requested (nunit#4837)

* Compare records by properties when requested

* review fixes

src/NUnitFramework/Directory.Build.props

@@ -1,7 +1,7 @@
 <Project>
 
   <PropertyGroup>
-    <LangVersion Condition="'$(MSBuildProjectExtension)' == '.csproj'">11</LangVersion>
+    <LangVersion Condition="'$(MSBuildProjectExtension)' == '.csproj'">12</LangVersion>
     <Features>strict</Features>
     <SignAssembly>true</SignAssembly>
     <AssemblyOriginatorKeyFile>..\..\nunit.snk</AssemblyOriginatorKeyFile>

src/NUnitFramework/Directory.Packages.props

@@ -30,7 +30,7 @@
     <PackageVersion Include="DotNetAnalyzers.DocumentationAnalyzers" Version="1.0.0-beta.59" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp.CodeStyle" Version="4.10.0" />
     <PackageVersion Include="NUnit.Analyzers" Version="4.3.0" />
-    <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.507" />
+    <PackageVersion Include="StyleCop.Analyzers" Version="1.2.0-beta.556" />
   </ItemGroup>
   <!-- Specific dependencies -->
   <ItemGroup>

src/NUnitFramework/framework/Constraints/Comparers/EqualsComparer.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Reflection;
+using NUnit.Framework.Internal;
 
 namespace NUnit.Framework.Constraints.Comparers
 {
@@ -17,6 +18,12 @@ public static EqualMethodResult Equal(object x, object y, ref Tolerance toleranc
 
             Type xType = x.GetType();
 
+            if (equalityComparer.CompareProperties && TypeHelper.HasCompilerGeneratedEquals(xType))
+            {
+                // For record types, when CompareProperties is requested, we ignore generated Equals method and compare by properties.
+                return EqualMethodResult.TypesNotSupported;
+            }
+
             if (OverridesEqualsObject(xType))
             {
                 if (tolerance.HasVariance)

src/NUnitFramework/framework/Constraints/Comparers/EquatablesComparer.cs

@@ -2,6 +2,7 @@
 
 using System;
 using System.Reflection;
+using NUnit.Framework.Internal;
 
 namespace NUnit.Framework.Constraints.Comparers
 {
@@ -18,6 +19,12 @@ public static EqualMethodResult Equal(object x, object y, ref Tolerance toleranc
             Type xType = x.GetType();
             Type yType = y.GetType();
 
+            if (equalityComparer.CompareProperties && TypeHelper.HasCompilerGeneratedEquals(xType))
+            {
+                // For record types, when CompareProperties is requested, we ignore generated Equals method and compare by properties.
+                return EqualMethodResult.TypesNotSupported;
+            }
+
             MethodInfo? equals = FirstImplementsIEquatableOfSecond(xType, yType);
             if (equals is not null)
             {

src/NUnitFramework/framework/Internal/TypeHelper.cs

@@ -4,6 +4,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Text;
 using NUnit.Framework.Interfaces;
 
@@ -387,5 +388,13 @@ internal static string FullName(this Type type)
         {
             return type.FullName ?? throw new InvalidOperationException("No name for type: " + type);
         }
+
+        internal static bool HasCompilerGeneratedEquals(this Type type)
+        {
+            var equalsMethod = type.GetMethod(nameof(type.Equals), BindingFlags.Instance | BindingFlags.Public,
+                null, [type], null);
+
+            return equalsMethod?.GetCustomAttribute<CompilerGeneratedAttribute>() is not null;
+        }
     }
 }

src/NUnitFramework/tests/Assertions/AssertThatTests.cs

@@ -3,8 +3,8 @@
 using System;
 using System.Threading.Tasks;
 using NUnit.Framework.Interfaces;
-using NUnit.TestData;
 using NUnit.Framework.Tests.TestUtilities;
+using NUnit.TestData;
 
 namespace NUnit.Framework.Tests.Assertions
 {
@@ -599,6 +599,26 @@ public void AssertWithCyclicRecursiveClass()
             Assert.That(list1, Is.EqualTo(list2).UsingPropertiesComparer());
         }
 
+        [Test]
+        public void AssertRecordsComparingProperties()
+        {
+            var record1 = new Record("Name", [1, 2, 3]);
+            var record2 = new Record("Name", [1, 2, 3]);
+
+            Assert.That(record1, Is.Not.EqualTo(record2)); // Record's generated method does not handle collections
+            Assert.That(record1, Is.EqualTo(record2).UsingPropertiesComparer());
+        }
+
+        [Test]
+        public void AssertRecordsComparingProperties_WhenRecordHasUserDefinedEqualsMethod()
+        {
+            var record1 = new ParentRecord(new RecordWithOverriddenEquals("Name"), [1, 2, 3]);
+            var record2 = new ParentRecord(new RecordWithOverriddenEquals("NAME"), [1, 2, 3]);
+
+            Assert.That(record1, Is.Not.EqualTo(record2)); // ParentRecord's generated method does not handle collections
+            Assert.That(record1, Is.EqualTo(record2).UsingPropertiesComparer());
+        }
+
         private sealed class LinkedList
         {
             public LinkedList(int value, LinkedList? next = null)
@@ -655,6 +675,23 @@ public void TestPropertyFailureSecondLevel()
              */
         }
 
+        private record Record(string Name, int[] Collection);
+
+        private record ParentRecord(RecordWithOverriddenEquals Child, int[] Collection);
+
+        private record RecordWithOverriddenEquals(string Name)
+        {
+            public virtual bool Equals(RecordWithOverriddenEquals? other)
+            {
+                return string.Equals(Name, other?.Name, StringComparison.OrdinalIgnoreCase);
+            }
+
+            public override int GetHashCode()
+            {
+                return Name.ToUpperInvariant().GetHashCode();
+            }
+        }
+
         private sealed class ParentClass
         {
             public ParentClass(ChildClass one, ChildClass two)

src/NUnitFramework/tests/Internal/TypeHelperTests.cs

@@ -84,5 +84,67 @@ private class Generic<T>
         }
 
         #endregion
+
+        #region HasCompilerGeneratedEquals
+
+        [TestCase(typeof(RecordClass), ExpectedResult = true)]
+        [TestCase(typeof(RecordStruct), ExpectedResult = true)]
+        [TestCase(typeof(RecordWithProperties), ExpectedResult = true)]
+        [TestCase(typeof(RecordWithOverriddenEquals), ExpectedResult = false)]
+        [TestCase(typeof(int), ExpectedResult = false)]
+        [TestCase(typeof(int[]), ExpectedResult = false)]
+        [TestCase(typeof(DtoClass), ExpectedResult = false)]
+        [TestCase(typeof(ClassWithPrimaryConstructor), ExpectedResult = false)]
+        [TestCase(typeof(ClassWithOverriddenEquals), ExpectedResult = false)]
+        public bool HasCompilerGeneratedEqualsTests(Type type) => TypeHelper.HasCompilerGeneratedEquals(type);
+
+        private class DtoClass
+        {
+            public string? Name { get; set; }
+        }
+
+        private class ClassWithPrimaryConstructor(string name)
+        {
+            public string Name => name;
+        }
+
+        private class ClassWithOverriddenEquals
+        {
+            public string? Name { get; set; }
+
+            public override bool Equals(object? obj)
+            {
+                return obj is ClassWithOverriddenEquals other && other.Name == Name;
+            }
+
+            public override int GetHashCode()
+            {
+                return 539060726 + EqualityComparer<string?>.Default.GetHashCode(Name ?? string.Empty);
+            }
+        }
+
+        private record class RecordClass(string Name);
+
+        private record struct RecordStruct(string Name);
+
+        private record RecordWithProperties
+        {
+            public string? Name { get; set; }
+        }
+
+        private record RecordWithOverriddenEquals(string Name)
+        {
+            public virtual bool Equals(RecordWithOverriddenEquals? other)
+            {
+                return string.Equals(Name, other?.Name, StringComparison.OrdinalIgnoreCase);
+            }
+
+            public override int GetHashCode()
+            {
+                return Name.ToUpperInvariant().GetHashCode();
+            }
+        }
+
+        #endregion
     }
 }