fix: add clarifying comment and tests for PublicMethodMissingTestAttributeAnalyzer (#4863) (#4912)

The MethodKind.Ordinary filter already correctly excludes property
accessors (PropertyGet/PropertySet), event accessors (EventAdd/EventRemove),
constructors, destructors, and operators. Added a clarifying comment to
document this behavior and new test cases for properties, events, overrides,
and static methods to prevent future regressions.

Author: thomhurst

TUnit.Analyzers.Tests/PublicMethodMissingTestAttributeAnalyzerTests.cs

@@ -143,7 +143,7 @@ public class MyClass : IAsyncDisposable
                     public void MyTest()
                     {
                     }
-                                
+
                     public ValueTask DisposeAsync()
                     {
                         return ValueTask.CompletedTask;
@@ -152,4 +152,104 @@ public ValueTask DisposeAsync()
                 """
             );
     }
+
+    [Test]
+    public async Task Property_Getter_Setter_No_Error()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public void MyTest()
+                    {
+                    }
+
+                    public string? Name { get; set; }
+
+                    public int Age
+                    {
+                        get { return 0; }
+                        set { }
+                    }
+                }
+                """
+            );
+    }
+
+    [Test]
+    public async Task Event_Accessors_No_Error()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using System;
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public void MyTest()
+                    {
+                    }
+
+                    public event EventHandler MyEvent
+                    {
+                        add { }
+                        remove { }
+                    }
+                }
+                """
+            );
+    }
+
+    [Test]
+    public async Task Override_Method_No_Error()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public void MyTest()
+                    {
+                    }
+
+                    public override string ToString()
+                    {
+                        return "test";
+                    }
+                }
+                """
+            );
+    }
+
+    [Test]
+    public async Task Static_Method_No_Error()
+    {
+        await Verifier
+            .VerifyAnalyzerAsync(
+                """
+                using TUnit.Core;
+
+                public class MyClass
+                {
+                    [Test]
+                    public void MyTest()
+                    {
+                    }
+
+                    public static void StaticHelper()
+                    {
+                    }
+                }
+                """
+            );
+    }
 }

TUnit.Analyzers/PublicMethodMissingTestAttributeAnalyzer.cs

@@ -32,6 +32,9 @@ private void AnalyzeSymbol(SymbolAnalysisContext context)
             return;
         }
 
+        // MethodKind.Ordinary excludes property accessors (PropertyGet/PropertySet),
+        // event accessors (EventAdd/EventRemove), constructors, destructors, operators,
+        // and other compiler-generated method kinds.
         foreach (var method in methods
                      .Where(x => x.MethodKind == MethodKind.Ordinary)
                      .Where(x => !x.IsAbstract)