ActualValueDelegate and Func are always evaluated

We need to consider their return type.
TestDelegate and Action are never evaluated for their return type as they don't have one.

Author: manfred-brands

src/nunit.analyzers.tests/Constants/NUnitFrameworkConstantsTests.cs

@@ -160,6 +160,7 @@ public static readonly (string Constant, Type Type)[] FullNameOfTypeSource =
             (nameof(NUnitFrameworkConstants.FullNameOfActualValueDelegate), typeof(ActualValueDelegate<>)),
             (nameof(NUnitFrameworkConstants.FullNameOfDelayedConstraint), typeof(DelayedConstraint)),
             (nameof(NUnitFrameworkConstants.FullNameOfTestDelegate), typeof(TestDelegate)),
+            (nameof(NUnitFrameworkConstants.FullNameOfAsyncTestDelegate), typeof(AsyncTestDelegate)),
             (nameof(NUnitFrameworkConstants.FullNameOfThrows), typeof(Throws)),
         ];
 

src/nunit.analyzers.tests/EqualToIncompatibleTypes/EqualToIncompatibleTypesAnalyzerTests.cs

@@ -396,9 +396,9 @@ public void AnalyzeWhenActualAndExpectedTypesAreSameWithFuncActualValue()
             var testCode = TestUtility.WrapInTestMethod(@"
                 Func<string> actual = () => """";
                 var expected = """";
-                Assert.That(actual, Is.EqualTo(↓expected));");
+                Assert.That(actual, Is.EqualTo(expected));");
 
-            RoslynAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
+            RoslynAssert.Valid(analyzer, testCode);
         }
 
         [Test]
@@ -1153,5 +1153,27 @@ public void AnalyzeOnNullableDouble()
 
             RoslynAssert.Valid(analyzer, testCode);
         }
+
+        [Test]
+        public void AnalyzeOnFuncReturningDouble()
+        {
+            var testCode = TestUtility.WrapInTestMethod(@$"
+                Func<double> actual = () => Math.PI;
+                Assert.That(actual, Is.Not.NaN);
+                Assert.That(actual, Is.EqualTo(Math.PI));
+            ");
+            RoslynAssert.Valid(analyzer, testCode);
+        }
+
+        [Test]
+        public void AnalyzeOnAsyncFuncReturningDouble()
+        {
+            var testCode = TestUtility.WrapInTestMethod(@$"
+                Func<Task<double>> actual = () => Task.FromResult(Math.PI);
+                Assert.That(actual, Is.Not.NaN);
+                Assert.That(actual, Is.EqualTo(Math.PI));
+            ");
+            RoslynAssert.Valid(analyzer, testCode);
+        }
     }
 }

src/nunit.analyzers.tests/NullConstraintUsage/NullConstraintUsageAnalyzerTests.cs

@@ -138,7 +138,7 @@ public void AnalyzeWhenActualIsTestDelegate(string constraint)
                 Action<bool> action = b => {{ }};
                 Assert.That(() => action(true), ↓{constraint});");
 
-            RoslynAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
+            RoslynAssert.Valid(analyzer, testCode);
         }
 
         [Test]
@@ -156,19 +156,21 @@ public void ActualNUnitFunction()
 
             Assert.Multiple(() =>
             {
-                Assert.That(function, Is.Not.Null);
-                Assert.That(functionCalled, Is.False);
-
-#pragma warning disable NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(() => function, Is.Not.Null);
-#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(functionCalled, Is.False);
 
-#pragma warning disable NUnit2057 // Unnecessary DelegateCreation
+#if NUNIT5
+                Assert.That(function, Is.False);
+                Assert.That(functionCalled, Is.True);
+                functionCalled = false;
+#else
 #pragma warning disable NUnit2023 // Invalid NullConstraint usage
-                Assert.That(() => function(), Is.Not.Null);
+                Assert.That(function, Is.Not.Null);
 #pragma warning restore NUnit2023 // Invalid NullConstraint usage
-#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
+                Assert.That(functionCalled, Is.False);
+#endif
+
+                Assert.That(() => function(), Is.False);
                 Assert.That(functionCalled, Is.True);
             });
         }
@@ -188,20 +190,18 @@ public void ActualNUnitAsyncFunction()
 
             Assert.Multiple(() =>
             {
+#pragma warning disable NUnit2023 // Invalid NullConstraint usage
                 Assert.That(asyncFunction, Is.Not.Null);
                 Assert.That(functionCalled, Is.False);
 
 #pragma warning disable NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(() => asyncFunction, Is.Not.Null);
-#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(functionCalled, Is.False);
 
-#pragma warning disable NUnit2057 // Unnecessary DelegateCreation
-#pragma warning disable NUnit2023 // Invalid NullConstraint usage
                 Assert.That(() => asyncFunction(), Is.Not.Null);
+                Assert.That(functionCalled, Is.True);
 #pragma warning restore NUnit2023 // Invalid NullConstraint usage
 #pragma warning restore NUnit2057 // Unnecessary DelegateCreation
-                Assert.That(functionCalled, Is.True);
             });
         }
 
@@ -216,24 +216,21 @@ public void ActualNUnitForAction()
 
             Assert.Multiple(() =>
             {
+#pragma warning disable NUnit2023 // Invalid NullConstraint usage
                 Assert.That(action, Is.Not.Null);
                 Assert.That(actionCalled, Is.False);
 
 #pragma warning disable NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(() => action, Is.Not.Null);
-#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
                 Assert.That(actionCalled, Is.False);
 
-#pragma warning disable NUnit2057 // Unnecessary DelegateCreation
-#pragma warning disable NUnit2023 // Invalid NullConstraint usage
                 Assert.That(() => action(), Is.Not.Null);
-#pragma warning restore NUnit2023 // Invalid NullConstraint usage
-#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
-
 #if EXPECT_TEST_DELEGATE_TO_BE_CALLED
-            // The above test succeeds, but does not call the action!
-            Assert.That(actionCalled, Is.True);
+                // The above test succeeds, but does not call the action!
+                Assert.That(actionCalled, Is.True);
 #endif
+#pragma warning restore NUnit2057 // Unnecessary DelegateCreation
+#pragma warning restore NUnit2023 // Invalid NullConstraint usage
             });
         }
     }

src/nunit.analyzers.tests/SameAsIncompatibleTypes/SameAsIncompatibleTypesAnalyzerTests.cs

@@ -289,9 +289,9 @@ public void AnalyzeWhenActualAndExpectedTypesAreSameWithFuncActualValue()
             var testCode = TestUtility.WrapInTestMethod(@"
                 Func<string> actual = () => """";
                 var expected = """";
-                Assert.That(actual, Is.SameAs(↓expected));");
+                Assert.That(actual, Is.SameAs(expected));");
 
-            RoslynAssert.Diagnostics(analyzer, expectedDiagnostic, testCode);
+            RoslynAssert.Valid(analyzer, testCode);
         }
 
         [Test]

src/nunit.analyzers/Constants/NUnitFrameworkConstants.cs

@@ -123,6 +123,7 @@ internal abstract class NUnitFrameworkConstants
         public const string FullNameOfActualValueDelegate = "NUnit.Framework.Constraints.ActualValueDelegate`1";
         public const string FullNameOfDelayedConstraint = "NUnit.Framework.Constraints.DelayedConstraint";
         public const string FullNameOfTestDelegate = "NUnit.Framework.TestDelegate";
+        public const string FullNameOfAsyncTestDelegate = "NUnit.Framework.AsyncTestDelegate";
         public const string FullNameOfThrows = "NUnit.Framework.Throws";
 
         public const string PrefixOfAllEqualToConstraints = "NUnit.Framework.Constraints.Equal";

src/nunit.analyzers/Helpers/AssertHelper.cs

@@ -56,8 +56,9 @@ public static ITypeSymbol UnwrapActualType(ITypeSymbol actualType)
             if (actualType is INamedTypeSymbol namedType)
             {
                 var fullTypeName = namedType.GetFullMetadataName();
-                if (fullTypeName == NUnitFrameworkConstants.FullNameOfActualValueDelegate ||
-                    fullTypeName == NUnitFrameworkConstants.FullNameOfTestDelegate)
+                if (fullTypeName is NUnitFrameworkConstants.FullNameOfActualValueDelegate
+                                 or NUnitFrameworkConstants.FullNameOfAsyncTestDelegate
+                                 or "System.Func`1")
                 {
                     ITypeSymbol returnType = namedType.DelegateInvokeMethod!.ReturnType;