Fix iteration cleanup bug

src/BenchmarkDotNet/Toolchains/InProcess.Emit.Implementation/Runnable/RunnableReuse.cs

@@ -98,7 +98,7 @@ private static EngineParameters CreateEngineParameters<T>(
                 GlobalSetupAction = CallbackFromField(instance, GlobalSetupActionFieldName),
                 GlobalCleanupAction = CallbackFromField(instance, GlobalCleanupActionFieldName),
                 IterationSetupAction = CallbackFromField(instance, IterationSetupActionFieldName),
-                IterationCleanupAction = CallbackFromField(instance, IterationSetupActionFieldName),
+                IterationCleanupAction = CallbackFromField(instance, IterationCleanupActionFieldName),
                 TargetJob = benchmarkCase.Job,
                 OperationsPerInvoke = benchmarkCase.Descriptor.OperationsPerInvoke,
                 MeasureExtraStats = benchmarkCase.Config.HasExtraStatsDiagnoser(),

tests/BenchmarkDotNet.IntegrationTests/InProcessEmitTest.cs

@@ -221,5 +221,36 @@ public static ValueTask<decimal> InvokeOnceStaticValueTaskOfT()
                 return new ValueTask<decimal>(DecimalResult);
             }
         }
+
+        [Fact]
+        public void InProcessEmitToolchainSupportsIterationSetupAndCleanup()
+        {
+            var logger = new OutputLogger(Output);
+            var config = CreateInProcessConfig(logger);
+
+            WithIterationSetupAndCleanup.SetupCounter = 0;
+            WithIterationSetupAndCleanup.BenchmarkCounter = 0;
+            WithIterationSetupAndCleanup.CleanupCounter = 0;
+
+            var summary = CanExecute<WithIterationSetupAndCleanup>(config);
+
+            Assert.Equal(1, WithIterationSetupAndCleanup.SetupCounter);
+            Assert.Equal(16, WithIterationSetupAndCleanup.BenchmarkCounter);
+            Assert.Equal(1, WithIterationSetupAndCleanup.CleanupCounter);
+        }
+
+        public class WithIterationSetupAndCleanup
+        {
+            public static int SetupCounter, BenchmarkCounter, CleanupCounter;
+
+            [IterationSetup]
+            public void Setup() => Interlocked.Increment(ref SetupCounter);
+
+            [Benchmark]
+            public void Benchmark() => Interlocked.Increment(ref BenchmarkCounter);
+
+            [IterationCleanup]
+            public void Cleanup() => Interlocked.Increment(ref CleanupCounter);
+        }
     }
 }