Setups are considered harmful

NUnit.Analyzers/Constants/AnalyzerIdentifiers.cs

@@ -3,5 +3,6 @@
     internal static class AnalyzerIdentifiers
     {
         internal const string TestFieldIsNotReadonly = "NU0001";
+        internal const string TestUsesSetupAttributes = "NU0002";
     }
 }

NUnit.Analyzers/TestUsesSetupMethods/TestUsesSetupMethodsAnalyzer.cs

@@ -0,0 +1,50 @@
+using System.Collections.Immutable;
+using System.Linq;
+
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+using NUnit.Analyzers.Constants;
+using NUnit.Analyzers.Extensions;
+
+namespace NUnit.Analyzers.TestUsesSetupMethods
+{
+    [DiagnosticAnalyzer(LanguageNames.CSharp)]
+    public class TestUsesSetupMethodsAnalyzer : DiagnosticAnalyzer
+    {
+        public override void Initialize(AnalysisContext context)
+        {
+            context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+            context.EnableConcurrentExecution();
+            context.RegisterSymbolAction(AnalyzeMethod, SymbolKind.Method);
+        }
+
+        private static void AnalyzeMethod(SymbolAnalysisContext context)
+        {
+            var methodSymbol = (IMethodSymbol)context.Symbol;
+            if (IsSetUpTearDownMethod(context.Compilation, methodSymbol))
+            {
+                context.ReportDiagnostic(Diagnostic.Create(testUsesSetupMethods, methodSymbol.Locations[0]));
+            }
+        }
+
+        private static bool IsSetUpTearDownMethod(Compilation compilation, IMethodSymbol methodSymbol)
+        {
+            return methodSymbol.GetAttributes().Any(a => a.IsSetUpOrTearDownMethodAttribute(compilation));
+        }
+
+        public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
+            ImmutableArray.Create(testUsesSetupMethods);
+
+        private static readonly DiagnosticDescriptor testUsesSetupMethods = new DiagnosticDescriptor(
+            AnalyzerIdentifiers.TestUsesSetupAttributes,
+            TestUsesSetupMethodsConstants.TestUsesSetupMethodsTitle,
+            TestUsesSetupMethodsConstants.TestUsesSetupMethodsMessage,
+            Categories.ParallelExecution,
+            DiagnosticSeverity.Warning,
+            true,
+            TestUsesSetupMethodsConstants.TestUsesSetupMethodsDescription,
+            TestUsesSetupMethodsConstants.TestUsesSetupMethodsUri
+        );
+    }
+}

NUnit.Analyzers/TestUsesSetupMethods/TestUsesSetupMethodsConstants.cs

@@ -0,0 +1,10 @@
+namespace NUnit.Analyzers.TestUsesSetupMethods
+{
+    internal class TestUsesSetupMethodsConstants
+    {
+        internal const string TestUsesSetupMethodsTitle = "Test uses setup methods";
+        internal const string TestUsesSetupMethodsMessage = "Setup methods are considered harmful";
+        internal const string TestUsesSetupMethodsDescription = "If you require a similar object or state for your tests, prefer a helper method than using Setup and Teardown attributes.";
+        internal const string TestUsesSetupMethodsUri = "https://learn.microsoft.com/en-us/dotnet/core/testing/unit-testing-best-practices#prefer-helper-methods-to-setup-and-teardown";
+    }
+}

NUnit.Extensions.Tests/Middlewares/ParallelParametrizedTestFixtureTest.cs

@@ -4,7 +4,6 @@
 using FluentAssertions;
 
 using NUnit.Framework;
-using NUnit.Framework.Internal.Execution;
 
 using SkbKontur.NUnit.Middlewares;
 
@@ -24,18 +23,16 @@ namespace SkbKontur.NUnit.Extensions.Tests.Middlewares
     [Parallelizable(ParallelScope.Self)]
     public class ParallelParametrizedTestFixtureTest : SimpleTestBase
     {
-        private event Action E;
-        private readonly int i1;
-        private int i2;
-        private const int i3 = 0;
-
         public ParallelParametrizedTestFixtureTest(int i, int i2)
         {
             this.i = i;
             this.i1 = 1;
             E += () => {};
         }
 
+        private event Action E;
+        private const int i3 = 0;
+
         protected override void Configure(ISetupBuilder fixture, ISetupBuilder test)
         {
             i2 = 3;
@@ -44,6 +41,11 @@ protected override void Configure(ISetupBuilder fixture, ISetupBuilder test)
                 .Use(t => t.GetFromThisOrParentContext<Counter>().InvocationsCount += i);
         }
 
+        [SetUp]
+        public void F()
+        {
+        }
+
         [Test]
         public void Test()
         {
@@ -57,6 +59,9 @@ public void Test()
             counter.InvocationsCount.Should().Be(i);
         }
 
+        private readonly int i1;
+        private int i2;
+
         private readonly int i;
 
         private static readonly TestFixtureData[] testCases = Enumerable.Range(0, 100).Select(x => new TestFixtureData(x)).ToArray();