From 3223c94a92050147a02482a3810860703f0c5171 Mon Sep 17 00:00:00 2001
From: Andrey Akinshin <andrey.akinshin@gmail.com>
Date: Thu, 12 Mar 2020 12:24:54 +0300
Subject: [PATCH] Code cleanup

---
 build/CodingStyle.ruleset                     | 10 +++
 .../BenchmarkDotNet.Samples.csproj            |  1 +
 .../IntroCultureInfo.cs                       |  2 +-
 .../IntroCustomMonoArguments.cs               |  2 +-
 .../IntroDisassembly.cs                       |  2 +-
 .../IntroDisassemblyRyuJit.cs                 |  2 +-
 .../IntroEventPipeProfiler.cs                 |  2 +-
 .../IntroInliningDiagnoser.cs                 |  3 +-
 .../BenchmarkDotNet.Samples/IntroOutliers.cs  |  1 -
 .../BenchmarkDotNet.Samples/IntroRatioSD.cs   |  1 -
 samples/BenchmarkDotNet.Samples/Program.cs    |  4 +-
 .../Attributes/TargetedAttribute.cs           |  2 +-
 .../BenchmarkDotNet.Annotations.csproj        |  2 +-
 .../Jobs/RuntimeMoniker.cs                    | 24 ++++-
 .../ConcurrencyVisualizerProfilerAttribute.cs |  1 +
 .../Configs/EtwProfilerAttribute.cs           |  1 +
 .../Configs/InliningDiagnoserAttribute.cs     |  1 +
 .../Configs/TailCallDiagnoserAttribute.cs     |  1 +
 .../EtwProfiler.cs                            |  2 +-
 .../EtwProfilerConfig.cs                      |  2 -
 .../HardwareCounters.cs                       |  2 -
 .../Tracing/BenchmarkEvent.cs                 |  1 -
 .../Tracing/NativeMemoryLogParser.cs          |  4 +-
 .../ClrMdDisassembler.cs                      |  2 +-
 .../DataContracts.cs                          | 10 +--
 .../Program.cs                                |  6 +-
 src/BenchmarkDotNet.Tool/Program.cs           |  2 +-
 .../Analysers/BaselineCustomAnalyzer.cs       |  2 +-
 .../MultimodalDistributionAnalyzer.cs         |  1 -
 .../Analysers/OutliersAnalyser.cs             |  3 +-
 .../Attributes/ArtifactsPathAttribute.cs      |  1 -
 .../ConfidenceIntervalErrorColumnAttribute.cs |  1 -
 .../Attributes/EncodingAttribute.cs           |  2 +-
 .../Attributes/EventPipeProfilerAttribute.cs  |  2 +-
 .../Attributes/Mutators/OutliersAttribute.cs  |  1 -
 .../UnicodeConsoleLoggerAttribute.cs          |  2 +-
 src/BenchmarkDotNet/BenchmarkDotNet.csproj    |  2 +-
 src/BenchmarkDotNet/Code/ArrayParam.cs        |  2 +-
 src/BenchmarkDotNet/Code/CodeGenerator.cs     |  2 +-
 src/BenchmarkDotNet/Columns/SizeUnit.cs       |  2 +-
 .../Columns/StatisticColumn.cs                |  1 -
 .../Configs/ConfigExtensions.cs               | 10 +--
 src/BenchmarkDotNet/Configs/ManualConfig.cs   |  8 +-
 .../ConsoleArguments/CommandLineOptions.cs    |  7 +-
 .../ConsoleArguments/ConfigParser.cs          |  3 +-
 .../Diagnosers/EventPipeProfile.cs            |  2 +-
 .../Disassemblers/DisassemblyDiagnoser.cs     |  2 +-
 .../DisassemblyDiagnoserConfig.cs             |  2 +-
 .../Disassemblers/InstructionFormatter.cs     |  2 +-
 .../Disassemblers/LinuxDisassembler.cs        |  2 +-
 .../Disassemblers/MonoDisassembler.cs         |  4 +-
 src/BenchmarkDotNet/Engines/ConsoleHost.cs    |  2 +-
 src/BenchmarkDotNet/Engines/Engine.cs         |  4 +-
 src/BenchmarkDotNet/Engines/EngineFactory.cs  |  2 +-
 src/BenchmarkDotNet/Engines/EngineResolver.cs |  1 -
 src/BenchmarkDotNet/Engines/GcStats.cs        |  2 +-
 src/BenchmarkDotNet/Engines/ThreadingStats.cs |  4 +-
 .../Exporters/CompositeExporter.cs            |  2 +-
 .../Exporters/InstructionPointerExporter.cs   |  2 +-
 .../Exporters/Json/JsonExporterBase.cs        |  2 +-
 .../Exporters/RPlotExporter.cs                |  2 +-
 .../Extensions/ReflectionExtensions.cs        |  1 -
 .../Extensions/StatisticsExtensions.cs        | 14 +--
 .../Helpers/ArtifactFileNameHelper.cs         |  2 +-
 src/BenchmarkDotNet/Helpers/AsciiHelper.cs    |  4 +-
 .../Helpers/PowerManagementHelper.cs          |  2 +
 src/BenchmarkDotNet/Helpers/ProcessHelper.cs  |  2 +-
 .../Helpers/SourceCodeHelper.cs               |  3 +
 src/BenchmarkDotNet/Jobs/AccuracyMode.cs      |  1 -
 src/BenchmarkDotNet/Jobs/Argument.cs          |  2 +-
 src/BenchmarkDotNet/Jobs/Job.cs               |  2 +
 src/BenchmarkDotNet/Jobs/JobExtensions.cs     | 11 ++-
 .../Loggers/AccumulationLogger.cs             |  4 +-
 src/BenchmarkDotNet/Loggers/ConsoleLogger.cs  |  4 +-
 src/BenchmarkDotNet/Loggers/ILogger.cs        |  4 +-
 src/BenchmarkDotNet/Reports/SummaryStyle.cs   |  4 +-
 .../Running/BenchmarkConverter.cs             |  4 +-
 .../Running/BenchmarkRunnerClean.cs           |  8 +-
 .../Running/BenchmarkSwitcher.cs              | 11 ++-
 .../Running/PowerManagementApplier.cs         |  8 +-
 .../CoreRt/CoreRtToolchainBuilder.cs          |  4 +-
 .../Toolchains/CoreRt/Generator.cs            |  8 +-
 .../Toolchains/CoreRun/CoreRunGenerator.cs    |  5 +-
 .../Toolchains/CoreRun/CoreRunPublisher.cs    |  4 +-
 .../Toolchains/CsProj/CsProjGenerator.cs      |  2 +-
 .../CustomDotNetCliToolchainBuilder.cs        |  2 +
 .../DotNetCli/DotNetCliGenerator.cs           |  2 +-
 .../DotNetCli/MsBuildErrorMapper.cs           |  4 +-
 .../InProcess.Emit/InProcessEmitExecutor.cs   |  5 +-
 .../InProcess.Emit/InProcessEmitGenerator.cs  | 89 +++++++++----------
 .../Toolchains/InProcess/InProcessExecutor.cs |  4 +-
 .../Toolchains/ToolchainExtensions.cs         |  2 +-
 .../Validators/CompilationValidator.cs        |  2 +-
 .../Validators/ParamsAllValuesValidator.cs    |  6 +-
 .../BenchmarksThatUsesFileFromOutput.cs       |  2 +-
 .../LocalCoreRtToolchainTests.cs              |  2 +-
 .../AttributesTests.cs                        | 12 +--
 .../BenchmarkDotNet.IntegrationTests.csproj   |  1 +
 .../BenchmarkSwitcherTest.cs                  | 14 +--
 .../CustomEngineTests.cs                      |  1 -
 .../Diagnosers/ProcessMetricsTests.cs         |  2 +-
 .../EnvironmentVariablesTests.cs              |  4 +-
 .../ExporterIOTests.cs                        |  1 -
 .../GcModeTests.cs                            |  4 +-
 .../InProcess.EmitTests/Runnable_0.cs         |  4 +-
 .../InProcessTest.cs                          |  2 +
 .../JitRuntimeValidationTest.cs               |  2 +-
 .../MemoryDiagnoserTests.cs                   |  2 +-
 .../ParamsTests.cs                            |  4 +-
 .../ProcessorArchitectureTest.cs              | 11 ++-
 .../Analysers/ZeroMeasurementHelperTests.cs   | 36 ++++----
 .../ParamsAllValuesApprovalTests.cs           |  3 -
 .../BenchmarkDotNet.Tests.csproj              |  4 +-
 .../ConfigParserTests.cs                      |  1 -
 .../Configs/EnvironmentVariableTests.cs       |  2 +-
 .../Configs/ImmutableConfigTests.cs           |  4 +-
 .../CsProjGeneratorTests.cs                   |  3 +-
 .../Engine/EngineFactoryTests.cs              | 28 +++---
 .../Engine/EngineResultStageTests.cs          |  1 -
 .../Exporters/CommonExporterApprovalTests.cs  |  1 -
 .../FullNameProviderTests.cs                  |  2 -
 .../GenericBuilderTests.cs                    | 12 +--
 .../Loggers/LoggerWithPrefixTests.cs          |  1 -
 .../Mathematics/StatisticsTests.cs            |  1 -
 .../ParameterInstanceTests.cs                 |  3 +-
 .../Reports/DisplayPrecisionManagerTests.cs   |  1 -
 .../Reports/RatioPrecisionTests.cs            |  6 +-
 .../Running/BenchmarkConverterTests.cs        |  1 -
 .../RuntimeVersionDetectionTests.cs           |  1 -
 tests/BenchmarkDotNet.Tests/SizeUnitTests.cs  |  6 +-
 .../BenchmarkDotNet.Tests/TypeFilterTests.cs  | 10 +--
 131 files changed, 310 insertions(+), 297 deletions(-)

diff --git a/build/CodingStyle.ruleset b/build/CodingStyle.ruleset
index 0c7f7f27d..9f5935249 100644
--- a/build/CodingStyle.ruleset
+++ b/build/CodingStyle.ruleset
@@ -6,6 +6,7 @@
     <Rule Id="CA1028" Action="None" /> <!-- Enum storage should be Int32 -->
     <Rule Id="CA1030" Action="None" /> <!-- Use events where appropriate -->
     <Rule Id="CA1031" Action="None" /> <!-- Do not catch general exception types -->
+    <Rule Id="CA1032" Action="None" /> <!-- Implement standard exception constructors -->
     <Rule Id="CA1034" Action="None" /> <!-- Nested types should not be visible -->
     <Rule Id="CA1036" Action="None" /> <!-- Overload comparison operators when implementing System.IComparable -->
     <Rule Id="CA1043" Action="None" /> <!-- Use integral or string argument for indexers -->
@@ -18,6 +19,7 @@
     <Rule Id="CA1058" Action="None" /> <!-- Types should not extend certain base types -->
     <Rule Id="CA1061" Action="None" /> <!-- Do not hide base class methods -->
     <Rule Id="CA1062" Action="None" /> <!-- Validate arguments of public methods -->
+    <Rule Id="CA1063" Action="None" /> <!-- Implement IDisposable correctly -->
     <Rule Id="CA1064" Action="None" /> <!-- Exceptions should be public -->
     <Rule Id="CA1065" Action="None" /> <!-- Do not raise exceptions in unexpected locations -->
     <Rule Id="CA1066" Action="None" /> <!-- Type should implement IEquatable -->
@@ -37,8 +39,10 @@
     <Rule Id="CA1717" Action="None" /> <!-- Only FlagsAttribute enums should have plural names -->
     <Rule Id="CA1720" Action="None" /> <!-- Identifier contains type name -->
     <Rule Id="CA1721" Action="None" /> <!-- Property names should not match get methods -->
+    <Rule Id="CA1724" Action="None" /> <!-- Type names should not match namespaces -->
     <Rule Id="CA1801" Action="None" /> <!-- Review unused parameters -->
     <Rule Id="CA1806" Action="None" /> <!-- Do not ignore method results -->
+    <Rule Id="CA1810" Action="None" /> <!-- Initialize reference type static fields inline -->
     <Rule Id="CA1812" Action="None" /> <!-- Avoid uninstantiated internal classes -->
     <Rule Id="CA1814" Action="None" /> <!-- Prefer jagged arrays over multidimensional -->
     <Rule Id="CA1815" Action="None" /> <!-- Override equals and operator equals on value types -->
@@ -46,6 +50,10 @@
     <Rule Id="CA1819" Action="None" /> <!-- Properties should not return arrays -->
     <Rule Id="CA1820" Action="None" /> <!-- Test for empty strings using string length -->
     <Rule Id="CA1822" Action="None" /> <!-- Mark members as static -->
+    <Rule Id="CA1826" Action="None" /> <!-- Do not use Enumerable methods on indexable collections. Instead use the collection directly -->
+    <Rule Id="CA2208" Action="None" /> <!-- Instantiate argument exceptions correctly -->
+    <Rule Id="CA2000" Action="None" /> <!-- Dispose objects before losing scope -->
+    <Rule Id="CA2008" Action="None" /> <!-- Do not create tasks without passing a TaskScheduler -->
     <Rule Id="CA2010" Action="None" /> <!-- Always consume the value returned by methods marked with PreserveSigAttribute -->
     <Rule Id="CA2100" Action="None" /> <!-- Review SQL queries for security vulnerabilities -->
     <Rule Id="CA2101" Action="None" /> <!-- Specify marshaling for P/Invoke string arguments -->
@@ -89,6 +97,7 @@
     <Rule Id="SA1110" Action="None" /> <!-- Opening parenthesis or bracket should be on declaration line -->
     <Rule Id="SA1111" Action="None" /> <!-- Closing parenthesis should be on line of last parameter -->
     <Rule Id="SA1114" Action="None" /> <!-- Parameter list should follow declaration -->
+    <Rule Id="SA1115" Action="None" /> <!-- The parameter should begin on the line after the previous parameter -->
     <Rule Id="SA1116" Action="None" /> <!-- Split parameters should start on line after declaration -->
     <Rule Id="SA1117" Action="None" /> <!-- Parameters should be on same line or separate lines -->
     <Rule Id="SA1118" Action="None" /> <!-- Parameter should not span multiple lines -->
@@ -115,6 +124,7 @@
     <Rule Id="SA1202" Action="None" /> <!-- Elements should be ordered by access -->
     <Rule Id="SA1203" Action="None" /> <!-- Constants should appear before fields -->
     <Rule Id="SA1204" Action="None" /> <!-- Static elements should appear before instance elements -->
+    <Rule Id="SA1206" Action="None" /> <!-- The 'static' modifier should appear before 'new' -->
     <Rule Id="SA1208" Action="None" /> <!-- Using directive ordering -->
     <Rule Id="SA1209" Action="None" /> <!-- Using alias directives should be placed after all using namespace directives -->
     <Rule Id="SA1210" Action="None" /> <!-- Using directives should be ordered alphabetically by the namespaces -->
diff --git a/samples/BenchmarkDotNet.Samples/BenchmarkDotNet.Samples.csproj b/samples/BenchmarkDotNet.Samples/BenchmarkDotNet.Samples.csproj
index cfa469445..e17e3f83f 100644
--- a/samples/BenchmarkDotNet.Samples/BenchmarkDotNet.Samples.csproj
+++ b/samples/BenchmarkDotNet.Samples/BenchmarkDotNet.Samples.csproj
@@ -11,6 +11,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <DebugType>pdbonly</DebugType>
     <DebugSymbols>true</DebugSymbols>
+    <NoWarn>$(NoWarn);CA1018;CA5351</NoWarn>
   </PropertyGroup>
   <ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' ">
     <Reference Include="System.Reflection" />
diff --git a/samples/BenchmarkDotNet.Samples/IntroCultureInfo.cs b/samples/BenchmarkDotNet.Samples/IntroCultureInfo.cs
index c2134b02e..aa44212db 100644
--- a/samples/BenchmarkDotNet.Samples/IntroCultureInfo.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroCultureInfo.cs
@@ -17,7 +17,7 @@ namespace BenchmarkDotNet.Samples
                 CultureInfo.NumberFormat.NumberDecimalSeparator = "@";
             }
         }
-        
+
         [Benchmark]
         public void Foo() => Thread.Sleep(100);
     }
diff --git a/samples/BenchmarkDotNet.Samples/IntroCustomMonoArguments.cs b/samples/BenchmarkDotNet.Samples/IntroCustomMonoArguments.cs
index af207bda3..aa775de0a 100644
--- a/samples/BenchmarkDotNet.Samples/IntroCustomMonoArguments.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroCustomMonoArguments.cs
@@ -36,6 +36,6 @@ namespace BenchmarkDotNet.Samples
             ShouldGetInlined(); ShouldGetInlined(); ShouldGetInlined();
         }
 
-        void ShouldGetInlined() { }
+        private void ShouldGetInlined() { }
     }
 }
\ No newline at end of file
diff --git a/samples/BenchmarkDotNet.Samples/IntroDisassembly.cs b/samples/BenchmarkDotNet.Samples/IntroDisassembly.cs
index 4b35da9fa..87fd0a315 100644
--- a/samples/BenchmarkDotNet.Samples/IntroDisassembly.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroDisassembly.cs
@@ -6,7 +6,7 @@ namespace BenchmarkDotNet.Samples
     [DisassemblyDiagnoser]
     public class IntroDisassembly
     {
-        int[] field = Enumerable.Range(0, 100).ToArray();
+        private int[] field = Enumerable.Range(0, 100).ToArray();
 
         [Benchmark]
         public int SumLocal()
diff --git a/samples/BenchmarkDotNet.Samples/IntroDisassemblyRyuJit.cs b/samples/BenchmarkDotNet.Samples/IntroDisassemblyRyuJit.cs
index de4ecaaff..0d41d2c92 100644
--- a/samples/BenchmarkDotNet.Samples/IntroDisassemblyRyuJit.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroDisassemblyRyuJit.cs
@@ -7,7 +7,7 @@ namespace BenchmarkDotNet.Samples
     [RyuJitX64Job]
     public class IntroDisassemblyRyuJit
     {
-        int[] field = Enumerable.Range(0, 100).ToArray();
+        private int[] field = Enumerable.Range(0, 100).ToArray();
 
         [Benchmark]
         public int SumLocal()
diff --git a/samples/BenchmarkDotNet.Samples/IntroEventPipeProfiler.cs b/samples/BenchmarkDotNet.Samples/IntroEventPipeProfiler.cs
index feb6ace5a..3e754c3a4 100644
--- a/samples/BenchmarkDotNet.Samples/IntroEventPipeProfiler.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroEventPipeProfiler.cs
@@ -2,7 +2,7 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Diagnosers;
 
-namespace BenchmarkDotNet.Samples 
+namespace BenchmarkDotNet.Samples
 {
     [ShortRunJob]
     [EventPipeProfiler(EventPipeProfile.CpuSampling)]
diff --git a/samples/BenchmarkDotNet.Samples/IntroInliningDiagnoser.cs b/samples/BenchmarkDotNet.Samples/IntroInliningDiagnoser.cs
index 4e1a70b2b..22f639e96 100644
--- a/samples/BenchmarkDotNet.Samples/IntroInliningDiagnoser.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroInliningDiagnoser.cs
@@ -1,10 +1,9 @@
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Configs;
 using System.Runtime.CompilerServices;
 
 namespace BenchmarkDotNet.Samples
 {
-    [Diagnostics.Windows.Configs.InliningDiagnoser(logFailuresOnly: false, allowedNamespaces: new [] { "BenchmarkDotNet.Samples" })]
+    [Diagnostics.Windows.Configs.InliningDiagnoser(logFailuresOnly: false, allowedNamespaces: new[] { "BenchmarkDotNet.Samples" })]
     public class IntroInliningDiagnoser
     {
         [Benchmark]
diff --git a/samples/BenchmarkDotNet.Samples/IntroOutliers.cs b/samples/BenchmarkDotNet.Samples/IntroOutliers.cs
index 18782c8b1..8a6519109 100644
--- a/samples/BenchmarkDotNet.Samples/IntroOutliers.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroOutliers.cs
@@ -2,7 +2,6 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Mathematics.OutlierDetection;
 
 namespace BenchmarkDotNet.Samples
diff --git a/samples/BenchmarkDotNet.Samples/IntroRatioSD.cs b/samples/BenchmarkDotNet.Samples/IntroRatioSD.cs
index 85b8e7e04..86b32f997 100644
--- a/samples/BenchmarkDotNet.Samples/IntroRatioSD.cs
+++ b/samples/BenchmarkDotNet.Samples/IntroRatioSD.cs
@@ -1,7 +1,6 @@
 using System.Threading;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Engines;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Mathematics.OutlierDetection;
 
 namespace BenchmarkDotNet.Samples
diff --git a/samples/BenchmarkDotNet.Samples/Program.cs b/samples/BenchmarkDotNet.Samples/Program.cs
index 4c83c2ffa..71daa668b 100644
--- a/samples/BenchmarkDotNet.Samples/Program.cs
+++ b/samples/BenchmarkDotNet.Samples/Program.cs
@@ -2,8 +2,8 @@
 
 namespace BenchmarkDotNet.Samples
 {
-    class Program
+    public class Program
     {
-        static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
+        public static void Main(string[] args) => BenchmarkSwitcher.FromAssembly(typeof(Program).Assembly).Run(args);
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet.Annotations/Attributes/TargetedAttribute.cs b/src/BenchmarkDotNet.Annotations/Attributes/TargetedAttribute.cs
index b31815969..897298ebe 100644
--- a/src/BenchmarkDotNet.Annotations/Attributes/TargetedAttribute.cs
+++ b/src/BenchmarkDotNet.Annotations/Attributes/TargetedAttribute.cs
@@ -16,8 +16,8 @@ namespace BenchmarkDotNet.Attributes
         /// </summary>
         public string Target
         {
-            set => Targets = string.IsNullOrEmpty(value) ? new string[0] : value.Split(','); // , is for backward compat
             get => throw new InvalidOperationException("Please use Targets property"); // kept to keep compiler happy "Named attribute arguments must be fields which are not readonly, static, or const, or read-write properties which are public and not static."
+            set => Targets = string.IsNullOrEmpty(value) ? new string[0] : value.Split(','); // , is for backward compat
         }
 
         public bool Match(MethodInfo method) => Targets == null || Targets.Length == 0 || Targets.Contains(method.Name);
diff --git a/src/BenchmarkDotNet.Annotations/BenchmarkDotNet.Annotations.csproj b/src/BenchmarkDotNet.Annotations/BenchmarkDotNet.Annotations.csproj
index 110d3487b..f96dc9370 100644
--- a/src/BenchmarkDotNet.Annotations/BenchmarkDotNet.Annotations.csproj
+++ b/src/BenchmarkDotNet.Annotations/BenchmarkDotNet.Annotations.csproj
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <AssemblyTitle>Basic BenchmarkDotNet attributes that can be used to annotate your benchmarks</AssemblyTitle>
     <TargetFrameworks>netstandard1.0;netstandard2.0</TargetFrameworks>
-    <NoWarn>$(NoWarn);1701;1702;1705;1591;3005;NU1702</NoWarn>
+    <NoWarn>$(NoWarn);1701;1702;1705;1591;3005;NU1702;CA1825</NoWarn>
     <AssemblyName>BenchmarkDotNet.Annotations</AssemblyName>
     <PackageId>BenchmarkDotNet.Annotations</PackageId>
     <RootNamespace>BenchmarkDotNet</RootNamespace>
diff --git a/src/BenchmarkDotNet.Annotations/Jobs/RuntimeMoniker.cs b/src/BenchmarkDotNet.Annotations/Jobs/RuntimeMoniker.cs
index f4328a462..ad70bed16 100644
--- a/src/BenchmarkDotNet.Annotations/Jobs/RuntimeMoniker.cs
+++ b/src/BenchmarkDotNet.Annotations/Jobs/RuntimeMoniker.cs
@@ -6,85 +6,105 @@ namespace BenchmarkDotNet.Jobs
         /// the same Runtime as the host Process (default setting)
         /// </summary>
         HostProcess = 0,
+
         /// <summary>
         /// not recognized, possibly a new version of .NET Core
         /// </summary>
         NotRecognized,
+
         /// <summary>
         /// Mono
         /// </summary>
         Mono,
+
         /// <summary>
         /// .NET 4.6.1
         /// </summary>
         Net461,
+
         /// <summary>
         /// .NET 4.6.2
         /// </summary>
         Net462,
+
         /// <summary>
         /// .NET 4.7
         /// </summary>
         Net47,
+
         /// <summary>
         /// .NET 4.7.1
         /// </summary>
         Net471,
+
         /// <summary>
         /// .NET 4.7.2
         /// </summary>
         Net472,
+
         /// <summary>
         /// .NET 4.8
         /// </summary>
         Net48,
+
         /// <summary>
         /// .NET Core 2.0
         /// </summary>
         NetCoreApp20,
+
         /// <summary>
         /// .NET Core 2.1
         /// </summary>
         NetCoreApp21,
+
         /// <summary>
         /// .NET Core 2.2
         /// </summary>
         NetCoreApp22,
+
         /// <summary>
         /// .NET Core 3.0
         /// </summary>
         NetCoreApp30,
+
         /// <summary>
         /// .NET Core 3.1
         /// </summary>
         NetCoreApp31,
+
         /// <summary>
         /// .NET Core 5.0 aka ".NET 5"
         /// </summary>
         NetCoreApp50,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp2.0
         /// </summary>
         CoreRt20,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp2.1
         /// </summary>
         CoreRt21,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp2.2
         /// </summary>
         CoreRt22,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp3.0
         /// </summary>
         CoreRt30,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp3.1
         /// </summary>
         CoreRt31,
+
         /// <summary>
         /// CoreRT compiled as netcoreapp5.0
         /// </summary>
-        CoreRt50,
+        CoreRt50
     }
-}
+}
\ No newline at end of file
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/ConcurrencyVisualizerProfilerAttribute.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/ConcurrencyVisualizerProfilerAttribute.cs
index eb6e0001b..77bf22bb6 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/ConcurrencyVisualizerProfilerAttribute.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/ConcurrencyVisualizerProfilerAttribute.cs
@@ -5,6 +5,7 @@ using JetBrains.Annotations;
 namespace BenchmarkDotNet.Diagnostics.Windows.Configs
 {
     [PublicAPI]
+    [AttributeUsage(AttributeTargets.Class)]
     public class ConcurrencyVisualizerProfilerAttribute : Attribute, IConfigSource
     {
         public ConcurrencyVisualizerProfilerAttribute() => Config = ManualConfig.CreateEmpty().AddDiagnoser(new ConcurrencyVisualizerProfiler());
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/EtwProfilerAttribute.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/EtwProfilerAttribute.cs
index e083df10a..2ee038aa7 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/EtwProfilerAttribute.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/EtwProfilerAttribute.cs
@@ -5,6 +5,7 @@ using JetBrains.Annotations;
 namespace BenchmarkDotNet.Diagnostics.Windows.Configs
 {
     [PublicAPI]
+    [AttributeUsage(AttributeTargets.Class)]
     public class EtwProfilerAttribute : Attribute, IConfigSource
     {
         /// <param name="performExtraBenchmarksRun">if set to true, benchmarks will be executed on more time with the profiler attached. If set to false, there will be no extra run but the results will contain overhead. True by default.</param>
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/InliningDiagnoserAttribute.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/InliningDiagnoserAttribute.cs
index 9db162d99..0a3f4e0dc 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/InliningDiagnoserAttribute.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/InliningDiagnoserAttribute.cs
@@ -3,6 +3,7 @@ using BenchmarkDotNet.Configs;
 
 namespace BenchmarkDotNet.Diagnostics.Windows.Configs
 {
+    [AttributeUsage(AttributeTargets.Class)]
     public class InliningDiagnoserAttribute : Attribute, IConfigSource
     {
         /// <param name="logFailuresOnly">only the methods that failed to get inlined. True by default.</param>
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/TailCallDiagnoserAttribute.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/TailCallDiagnoserAttribute.cs
index b1b80ff02..712da63f5 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Configs/TailCallDiagnoserAttribute.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Configs/TailCallDiagnoserAttribute.cs
@@ -3,6 +3,7 @@ using System;
 
 namespace BenchmarkDotNet.Diagnostics.Windows.Configs
 {
+    [AttributeUsage(AttributeTargets.Class)]
     public class TailCallDiagnoserAttribute : Attribute, IConfigSource
     {
         public IConfig Config { get; }
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfiler.cs b/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfiler.cs
index 273d75bf6..a7c75bc12 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfiler.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfiler.cs
@@ -43,7 +43,7 @@ namespace BenchmarkDotNet.Diagnostics.Windows
 
         public string ShortName => "ETW";
 
-        public IEnumerable<string> Ids => new [] { nameof(EtwProfiler) };
+        public IEnumerable<string> Ids => new[] { nameof(EtwProfiler) };
 
         public IEnumerable<IExporter> Exporters => Array.Empty<IExporter>();
 
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfilerConfig.cs b/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfilerConfig.cs
index 3d6710257..ee6ed5465 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfilerConfig.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/EtwProfilerConfig.cs
@@ -1,7 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Collections.Immutable;
-using System.Linq;
 using BenchmarkDotNet.Diagnosers;
 using Microsoft.Diagnostics.Tracing;
 using Microsoft.Diagnostics.Tracing.Parsers;
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/HardwareCounters.cs b/src/BenchmarkDotNet.Diagnostics.Windows/HardwareCounters.cs
index f0ae8939a..d0aeaa048 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/HardwareCounters.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/HardwareCounters.cs
@@ -2,9 +2,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Diagnosers;
-using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Portability;
-using BenchmarkDotNet.Toolchains.InProcess;
 using BenchmarkDotNet.Toolchains.InProcess.Emit;
 using BenchmarkDotNet.Validators;
 using Microsoft.Diagnostics.Tracing.Session;
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/BenchmarkEvent.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/BenchmarkEvent.cs
index b97557852..f3ee11ac9 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/BenchmarkEvent.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/BenchmarkEvent.cs
@@ -1,5 +1,4 @@
 using System;
-using System.Diagnostics;
 using System.Text;
 using Microsoft.Diagnostics.Tracing;
 
diff --git a/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/NativeMemoryLogParser.cs b/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/NativeMemoryLogParser.cs
index b3cf196e1..cd5c085fc 100644
--- a/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/NativeMemoryLogParser.cs
+++ b/src/BenchmarkDotNet.Diagnostics.Windows/Tracing/NativeMemoryLogParser.cs
@@ -1,9 +1,8 @@
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Diagnosers;
-using BenchmarkDotNet.Extensions;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Running;
@@ -13,6 +12,7 @@ using Address = System.UInt64;
 
 namespace BenchmarkDotNet.Diagnostics.Windows.Tracing
 {
+    [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1121:UseBuiltInTypeAlias")]
     public class NativeMemoryLogParser
     {
         private static readonly string LogSeparator = new string('-', 20);
diff --git a/src/BenchmarkDotNet.Disassembler.x64/ClrMdDisassembler.cs b/src/BenchmarkDotNet.Disassembler.x64/ClrMdDisassembler.cs
index a66429aa0..2967441ba 100644
--- a/src/BenchmarkDotNet.Disassembler.x64/ClrMdDisassembler.cs
+++ b/src/BenchmarkDotNet.Disassembler.x64/ClrMdDisassembler.cs
@@ -111,7 +111,7 @@ namespace BenchmarkDotNet.Disassemblers
 
             Map[] maps = settings.PrintSource
                 ? codes.GroupBy(code => code.InstructionPointer).OrderBy(group => group.Key).Select(group => new Map() { SourceCodes = group.ToArray() }).ToArray()
-                : new [] { new Map() { SourceCodes = codes.ToArray() } };
+                : new[] { new Map() { SourceCodes = codes.ToArray() } };
 
             return new DisassembledMethod
             {
diff --git a/src/BenchmarkDotNet.Disassembler.x64/DataContracts.cs b/src/BenchmarkDotNet.Disassembler.x64/DataContracts.cs
index 0fba37c23..669f9811c 100644
--- a/src/BenchmarkDotNet.Disassembler.x64/DataContracts.cs
+++ b/src/BenchmarkDotNet.Disassembler.x64/DataContracts.cs
@@ -50,7 +50,7 @@ namespace BenchmarkDotNet.Disassemblers
         public string Problem { get; set; }
 
         public Map[] Maps { get; set; }
-        
+
         public string CommandLine { get; set; }
 
         public static DisassembledMethod Empty(string fullSignature, ulong nativeCode, string problem)
@@ -70,17 +70,17 @@ namespace BenchmarkDotNet.Disassemblers
         public MutablePair[] SerializedAddressToNameMapping { get; set; }
         public uint PointerSize { get; set; }
 
-        [XmlIgnore()] // XmlSerializer does not support dictionaries ;)
+        [XmlIgnore] // XmlSerializer does not support dictionaries ;)
         public Dictionary<ulong, string> AddressToNameMapping
             => _addressToNameMapping ?? (_addressToNameMapping = SerializedAddressToNameMapping.ToDictionary(x => x.Key, x => x.Value));
 
-        [XmlIgnore()]
+        [XmlIgnore]
         private Dictionary<ulong, string> _addressToNameMapping;
 
         public DisassemblyResult()
         {
-            Methods = new DisassembledMethod[0];
-            Errors = new string[0];
+            Methods = Array.Empty<DisassembledMethod>();
+            Errors = Array.Empty<string>();
         }
 
         // KeyValuePair is not serializable, because it has read-only properties
diff --git a/src/BenchmarkDotNet.Disassembler.x64/Program.cs b/src/BenchmarkDotNet.Disassembler.x64/Program.cs
index 241e532ba..aeb649ff2 100644
--- a/src/BenchmarkDotNet.Disassembler.x64/Program.cs
+++ b/src/BenchmarkDotNet.Disassembler.x64/Program.cs
@@ -8,14 +8,14 @@ namespace BenchmarkDotNet.Disassemblers
 {
     internal static class Program
     {
-        // the goals of the existence of this process: 
+        // the goals of the existence of this process:
         // 1. attach to benchmarked process
         // 2. disassemble the code
         // 3. save it to xml file
         // 4. detach & shut down
         //
         // requirements: must not have any dependencies to BenchmarkDotNet itself, KISS
-        static void Main(string[] args)
+        public static void Main(string[] args)
         {
             var options = Settings.FromArgs(args);
 
@@ -25,7 +25,7 @@ namespace BenchmarkDotNet.Disassemblers
             try
             {
                 var methodsToExport = ClrMdDisassembler.AttachAndDisassemble(options);
-                
+
                 SaveToFile(methodsToExport, options.ResultsPath);
             }
             catch (OutOfMemoryException) // thrown by clrmd when pdb is missing or in invalid format
diff --git a/src/BenchmarkDotNet.Tool/Program.cs b/src/BenchmarkDotNet.Tool/Program.cs
index 114dc7f6d..2da94260f 100644
--- a/src/BenchmarkDotNet.Tool/Program.cs
+++ b/src/BenchmarkDotNet.Tool/Program.cs
@@ -13,7 +13,7 @@ namespace BenchmarkDotNet.Tool
     [Command(
         Name = "benchmark",
         Description = "A dotnet tool to execute benchmarks built with BenchmarkDotNet.")]
-    [HelpOption()]
+    [HelpOption]
     [VersionOptionFromMember(MemberName = nameof(GetVersion))]
     public sealed class Program
     {
diff --git a/src/BenchmarkDotNet/Analysers/BaselineCustomAnalyzer.cs b/src/BenchmarkDotNet/Analysers/BaselineCustomAnalyzer.cs
index 7ca34a97a..51663e408 100644
--- a/src/BenchmarkDotNet/Analysers/BaselineCustomAnalyzer.cs
+++ b/src/BenchmarkDotNet/Analysers/BaselineCustomAnalyzer.cs
@@ -20,7 +20,7 @@ namespace BenchmarkDotNet.Analysers
                                               .ToArray();
             if (columns.IsEmpty())
                 yield break;
-            
+
             var columnNames = string.Join(", ", columns);
 
             foreach (var benchmarkCase in summary.BenchmarksCases)
diff --git a/src/BenchmarkDotNet/Analysers/MultimodalDistributionAnalyzer.cs b/src/BenchmarkDotNet/Analysers/MultimodalDistributionAnalyzer.cs
index 5fd49214d..9adf1bf05 100644
--- a/src/BenchmarkDotNet/Analysers/MultimodalDistributionAnalyzer.cs
+++ b/src/BenchmarkDotNet/Analysers/MultimodalDistributionAnalyzer.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Globalization;
 using BenchmarkDotNet.Engines;
-using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Reports;
 using JetBrains.Annotations;
 using Perfolizer.Mathematics.Multimodality;
diff --git a/src/BenchmarkDotNet/Analysers/OutliersAnalyser.cs b/src/BenchmarkDotNet/Analysers/OutliersAnalyser.cs
index 1e6543f56..f4f5abea7 100644
--- a/src/BenchmarkDotNet/Analysers/OutliersAnalyser.cs
+++ b/src/BenchmarkDotNet/Analysers/OutliersAnalyser.cs
@@ -53,6 +53,7 @@ namespace BenchmarkDotNet.Analysers
         /// <param name="allOutliers">All outliers which present in the distribution (lower and upper)</param>
         /// <param name="lowerOutliers">All lower outliers</param>
         /// <param name="upperOutliers">All upper outliers</param>
+        /// <param name="cultureInfo">CultureInfo</param>
         /// <returns>The message</returns>
         [PublicAPI, NotNull, Pure]
         public static string GetMessage(double[] actualOutliers, double[] allOutliers, double[] lowerOutliers, double[] upperOutliers, CultureInfo cultureInfo)
@@ -83,7 +84,7 @@ namespace BenchmarkDotNet.Analysers
         private static string GetRangeMessage([NotNull] double[] values, CultureInfo cultureInfo)
         {
             string Format(double value) => TimeInterval.FromNanoseconds(value).ToString(cultureInfo, "N2");
-            
+
             switch (values.Length) {
                 case 0:
                     return null;
diff --git a/src/BenchmarkDotNet/Attributes/ArtifactsPathAttribute.cs b/src/BenchmarkDotNet/Attributes/ArtifactsPathAttribute.cs
index 37dd521f8..f417d31fa 100644
--- a/src/BenchmarkDotNet/Attributes/ArtifactsPathAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/ArtifactsPathAttribute.cs
@@ -18,4 +18,3 @@ namespace BenchmarkDotNet.Attributes
         }
     }
 }
-
diff --git a/src/BenchmarkDotNet/Attributes/Columns/ConfidenceIntervalErrorColumnAttribute.cs b/src/BenchmarkDotNet/Attributes/Columns/ConfidenceIntervalErrorColumnAttribute.cs
index 56998f827..d0d1f90fa 100644
--- a/src/BenchmarkDotNet/Attributes/Columns/ConfidenceIntervalErrorColumnAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Columns/ConfidenceIntervalErrorColumnAttribute.cs
@@ -1,5 +1,4 @@
 using BenchmarkDotNet.Columns;
-using BenchmarkDotNet.Mathematics;
 using JetBrains.Annotations;
 using Perfolizer.Mathematics.Common;
 
diff --git a/src/BenchmarkDotNet/Attributes/EncodingAttribute.cs b/src/BenchmarkDotNet/Attributes/EncodingAttribute.cs
index 68d098b81..8737c194b 100644
--- a/src/BenchmarkDotNet/Attributes/EncodingAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/EncodingAttribute.cs
@@ -8,7 +8,7 @@ using JetBrains.Annotations;
 namespace BenchmarkDotNet.Attributes
 {
     [AttributeUsage(AttributeTargets.Class | AttributeTargets.Assembly, AllowMultiple = true)]
-    [Obsolete]
+    [Obsolete("Don't use it")]
     public class EncodingAttribute : Attribute, IConfigSource
     {
         public IConfig Config { get; }
diff --git a/src/BenchmarkDotNet/Attributes/EventPipeProfilerAttribute.cs b/src/BenchmarkDotNet/Attributes/EventPipeProfilerAttribute.cs
index 0eac7fbf1..fa71f295e 100644
--- a/src/BenchmarkDotNet/Attributes/EventPipeProfilerAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/EventPipeProfilerAttribute.cs
@@ -2,7 +2,7 @@ using System;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Diagnosers;
 
-namespace BenchmarkDotNet.Attributes 
+namespace BenchmarkDotNet.Attributes
 {
     [AttributeUsage(AttributeTargets.Class)]
     public class EventPipeProfilerAttribute : Attribute, IConfigSource
diff --git a/src/BenchmarkDotNet/Attributes/Mutators/OutliersAttribute.cs b/src/BenchmarkDotNet/Attributes/Mutators/OutliersAttribute.cs
index c03654c8e..bda7eed2d 100644
--- a/src/BenchmarkDotNet/Attributes/Mutators/OutliersAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/Mutators/OutliersAttribute.cs
@@ -1,5 +1,4 @@
 using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Mathematics.OutlierDetection;
 
 namespace BenchmarkDotNet.Attributes
diff --git a/src/BenchmarkDotNet/Attributes/UnicodeConsoleLoggerAttribute.cs b/src/BenchmarkDotNet/Attributes/UnicodeConsoleLoggerAttribute.cs
index 7ae9117d3..79fa57199 100644
--- a/src/BenchmarkDotNet/Attributes/UnicodeConsoleLoggerAttribute.cs
+++ b/src/BenchmarkDotNet/Attributes/UnicodeConsoleLoggerAttribute.cs
@@ -14,7 +14,7 @@ namespace BenchmarkDotNet.Attributes
         {
             Config = ManualConfig.CreateEmpty().AddLogger(ConsoleLogger.Unicode);
         }
-        
+
         public IConfig Config { get; }
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/BenchmarkDotNet.csproj b/src/BenchmarkDotNet/BenchmarkDotNet.csproj
index cdad647fb..fe44b1298 100644
--- a/src/BenchmarkDotNet/BenchmarkDotNet.csproj
+++ b/src/BenchmarkDotNet/BenchmarkDotNet.csproj
@@ -4,7 +4,7 @@
     <AssemblyTitle>BenchmarkDotNet</AssemblyTitle>
     <TargetFramework>netstandard2.0</TargetFramework>
     <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
-    <NoWarn>$(NoWarn);1701;1702;1705;1591;3005;NU1702</NoWarn>
+    <NoWarn>$(NoWarn);1701;1702;1705;1591;3005;NU1702;CS3001;CS3003</NoWarn>
     <AssemblyName>BenchmarkDotNet</AssemblyName>
     <PackageId>BenchmarkDotNet</PackageId>
     <RootNamespace>BenchmarkDotNet</RootNamespace>
diff --git a/src/BenchmarkDotNet/Code/ArrayParam.cs b/src/BenchmarkDotNet/Code/ArrayParam.cs
index bf765407b..131906753 100644
--- a/src/BenchmarkDotNet/Code/ArrayParam.cs
+++ b/src/BenchmarkDotNet/Code/ArrayParam.cs
@@ -57,7 +57,7 @@ namespace BenchmarkDotNet.Code
 
             var methodInfo = arrayParamType.GetMethod(nameof(ForPrimitives), BindingFlags.Public | BindingFlags.Static)
                 ?? throw new InvalidOperationException($"{nameof(ForPrimitives)} not found");
-            return (IParam)methodInfo.Invoke(null, new []{ array});
+            return (IParam)methodInfo.Invoke(null, new[]{ array});
         }
     }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Code/CodeGenerator.cs b/src/BenchmarkDotNet/Code/CodeGenerator.cs
index 15ee0a662..7a705cb48 100644
--- a/src/BenchmarkDotNet/Code/CodeGenerator.cs
+++ b/src/BenchmarkDotNet/Code/CodeGenerator.cs
@@ -276,7 +276,7 @@ namespace BenchmarkDotNet.Code
         private static Type GetFieldType(Type argumentType, ParameterInstance argument)
         {
             // #774 we can't store Span in a field, so we store an array (which is later casted to Span when we load the arguments)
-            if(argumentType.IsStackOnlyWithImplicitCast(argument.Value))
+            if (argumentType.IsStackOnlyWithImplicitCast(argument.Value))
                 return argument.Value.GetType();
 
             return argumentType;
diff --git a/src/BenchmarkDotNet/Columns/SizeUnit.cs b/src/BenchmarkDotNet/Columns/SizeUnit.cs
index dfc3057a3..3f701069a 100644
--- a/src/BenchmarkDotNet/Columns/SizeUnit.cs
+++ b/src/BenchmarkDotNet/Columns/SizeUnit.cs
@@ -20,7 +20,7 @@ namespace BenchmarkDotNet.Columns
         }
 
         private const long BytesInKiloByte = 1024L; // this value MUST NOT be changed
-        
+
         public SizeValue ToValue(long value = 1) => new SizeValue(value, this);
 
         [PublicAPI] public static readonly SizeUnit B = new SizeUnit("B", "Byte", 1L);
diff --git a/src/BenchmarkDotNet/Columns/StatisticColumn.cs b/src/BenchmarkDotNet/Columns/StatisticColumn.cs
index c4f9a3319..f3d37af8c 100644
--- a/src/BenchmarkDotNet/Columns/StatisticColumn.cs
+++ b/src/BenchmarkDotNet/Columns/StatisticColumn.cs
@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Running;
diff --git a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
index c9b1c16f6..9c903566f 100644
--- a/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
+++ b/src/BenchmarkDotNet/Configs/ConfigExtensions.cs
@@ -23,7 +23,7 @@ namespace BenchmarkDotNet.Configs
         [Obsolete("This method will soon be removed, please start using .AddColumn() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IColumn[] columns) => config.AddColumn(columns);
         [PublicAPI] public static ManualConfig AddColumn(this IConfig config, params IColumn[] columns) => config.With(m => m.AddColumn(columns));
-        
+
         [Obsolete("This method will soon be removed, please start using .AddColumnProvider() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params IColumnProvider[] columnProviders) => config.AddColumnProvider(columnProviders);
         [PublicAPI] public static ManualConfig AddColumnProvider(this IConfig config, params IColumnProvider[] columnProviders) => config.With(m => m.AddColumnProvider(columnProviders));
@@ -74,7 +74,7 @@ namespace BenchmarkDotNet.Configs
         [PublicAPI] public static ManualConfig WithArtifactsPath(this IConfig config, string artifactsPath) => config.With(m => m.WithArtifactsPath(artifactsPath));
         [PublicAPI] public static ManualConfig WithUnionRule(this IConfig config, ConfigUnionRule unionRule) => config.With(m => m.WithUnionRule(unionRule));
         [PublicAPI] public static ManualConfig WithCultureInfo(this IConfig config, CultureInfo cultureInfo) => config.With(m => m.CultureInfo = cultureInfo);
-        
+
         /// <summary>
         /// determines if all auto-generated files should be kept or removed after running the benchmarks
         /// </summary>
@@ -96,17 +96,17 @@ namespace BenchmarkDotNet.Configs
         /// </summary>
         [Obsolete("This method will soon be removed, please start using .WithOptions() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, ConfigOptions options) => config.WithOptions(options);
-        
+
         /// <summary>
         /// sets given option to provided value
         /// </summary>
         [PublicAPI] public static ManualConfig WithOption(this IConfig config, ConfigOptions option, bool value) => config.With(m => m.WithOption(option, value));
-        
+
         /// <summary>
         /// sets given options for the config
         /// </summary>
         [PublicAPI] public static ManualConfig WithOptions(this IConfig config, ConfigOptions options) => config.With(m => m.WithOptions(options));
-        
+
         [Obsolete("This method will soon be removed, please start using .AddLogicalGroupRules() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params BenchmarkLogicalGroupRule[] rules) => config.AddLogicalGroupRules(rules);
         [PublicAPI] public static ManualConfig AddLogicalGroupRules(this IConfig config, params BenchmarkLogicalGroupRule[] rules) => config.With(c => c.AddLogicalGroupRules(rules));
diff --git a/src/BenchmarkDotNet/Configs/ManualConfig.cs b/src/BenchmarkDotNet/Configs/ManualConfig.cs
index d9f4e373a..f8e54c390 100644
--- a/src/BenchmarkDotNet/Configs/ManualConfig.cs
+++ b/src/BenchmarkDotNet/Configs/ManualConfig.cs
@@ -54,7 +54,7 @@ namespace BenchmarkDotNet.Configs
             Options = Options.Set(value, option);
             return this;
         }
-        
+
         public ManualConfig WithOptions(ConfigOptions options)
         {
             Options |= options;
@@ -168,7 +168,7 @@ namespace BenchmarkDotNet.Configs
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using ..AddHardwareCounters()() instead.")]
         public void Add(params HardwareCounter[] newHardwareCounters) => AddHardwareCounters(newHardwareCounters);
-        
+
         public ManualConfig AddHardwareCounters(params HardwareCounter[] newHardwareCounters)
         {
             hardwareCounters.AddRange(newHardwareCounters);
@@ -178,7 +178,7 @@ namespace BenchmarkDotNet.Configs
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddFilter() instead.")]
         public void Add(params IFilter[] newFilters) => AddFilter(newFilters);
-        
+
         public ManualConfig AddFilter(params IFilter[] newFilters)
         {
             filters.AddRange(newFilters);
@@ -188,7 +188,7 @@ namespace BenchmarkDotNet.Configs
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .AddLogicalGroupRules() instead.")]
         public void Add(params BenchmarkLogicalGroupRule[] rules) => AddLogicalGroupRules(rules);
-        
+
         public ManualConfig AddLogicalGroupRules(params BenchmarkLogicalGroupRule[] rules)
         {
             logicalGroupRules.AddRange(rules);
diff --git a/src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs b/src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs
index 85d2c3d0a..a5ce016b2 100644
--- a/src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs
+++ b/src/BenchmarkDotNet/ConsoleArguments/CommandLineOptions.cs
@@ -6,7 +6,6 @@ using BenchmarkDotNet.ConsoleArguments.ListBenchmarks;
 using BenchmarkDotNet.Diagnosers;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Helpers;
-using BenchmarkDotNet.Mathematics;
 using CommandLine;
 using CommandLine.Text;
 using JetBrains.Annotations;
@@ -182,7 +181,7 @@ namespace BenchmarkDotNet.ConsoleArguments
                 yield return new Example("Run benchmarks for .NET Core 2.0, .NET Core 2.1 and .NET Core 2.2. .NET Core 2.0 will be baseline because it was first.", longName, new CommandLineOptions { Runtimes = new[] { "netcoreapp2.0", "netcoreapp2.1", "netcoreapp2.2" } });
                 yield return new Example("Use MemoryDiagnoser to get GC stats", shortName, new CommandLineOptions { UseMemoryDiagnoser = true });
                 yield return new Example("Use DisassemblyDiagnoser to get disassembly", shortName, new CommandLineOptions { UseDisassemblyDiagnoser = true });
-                yield return new Example("Use HardwareCountersDiagnoser to get hardware counter info", longName, new CommandLineOptions { HardwareCounters = new [] { nameof(HardwareCounter.CacheMisses), nameof(HardwareCounter.InstructionRetired) } });
+                yield return new Example("Use HardwareCountersDiagnoser to get hardware counter info", longName, new CommandLineOptions { HardwareCounters = new[] { nameof(HardwareCounter.CacheMisses), nameof(HardwareCounter.InstructionRetired) } });
                 yield return new Example("Run all benchmarks exactly once", shortName, new CommandLineOptions { BaseJob = "Dry", Filters = new[] { Escape("*") } });
                 yield return new Example("Run all benchmarks from System.Memory namespace", shortName, new CommandLineOptions { Filters = new[] { Escape("System.Memory*") } });
                 yield return new Example("Run all benchmarks from ClassA and ClassB using type names", shortName, new CommandLineOptions { Filters = new[] { "ClassA", "ClassB" } });
@@ -192,8 +191,8 @@ namespace BenchmarkDotNet.ConsoleArguments
                 yield return new Example("Run selected benchmarks 100 times per iteration. Perform single warmup iteration and 5 actual workload iterations", longName, new CommandLineOptions { InvocationCount = 100, WarmupIterationCount = 1, IterationCount = 5});
                 yield return new Example("Run selected benchmarks 250ms per iteration. Perform from 9 to 15 iterations", longName, new CommandLineOptions { IterationTimeInMilliseconds = 250, MinIterationCount = 9, MaxIterationCount = 15});
                 yield return new Example("Run MannWhitney test with relative ratio of 5% for all benchmarks for .NET Core 2.0 (base) vs .NET Core 2.1 (diff). .NET Core 2.0 will be baseline because it was provided as first.", longName,
-                    new CommandLineOptions { Filters = new [] { "*"}, Runtimes = new[] { "netcoreapp2.0", "netcoreapp2.1" }, StatisticalTestThreshold = "5%" });
-                yield return new Example("Run benchmarks using environment variables 'ENV_VAR_KEY_1' with value 'value_1' and 'ENV_VAR_KEY_2' with value 'value_2'", longName, 
+                    new CommandLineOptions { Filters = new[] { "*"}, Runtimes = new[] { "netcoreapp2.0", "netcoreapp2.1" }, StatisticalTestThreshold = "5%" });
+                yield return new Example("Run benchmarks using environment variables 'ENV_VAR_KEY_1' with value 'value_1' and 'ENV_VAR_KEY_2' with value 'value_2'", longName,
                     new CommandLineOptions { EnvironmentVariables = new[] { "ENV_VAR_KEY_1:value_1", "ENV_VAR_KEY_2:value_2" } });
             }
         }
diff --git a/src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs b/src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs
index c2718b8c6..0cd5b5ace 100644
--- a/src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs
+++ b/src/BenchmarkDotNet/ConsoleArguments/ConfigParser.cs
@@ -15,7 +15,6 @@ using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Filters;
 using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Loggers;
-using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Portability;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Toolchains.CoreRt;
@@ -270,7 +269,7 @@ namespace BenchmarkDotNet.ConsoleArguments
             {
                 baseJob = baseJob.WithEnvironmentVariables(options.EnvironmentVariables.Select(text =>
                 {
-                    var separated = text.Split(new [] { EnvVarKeyValueSeparator }, 2);
+                    var separated = text.Split(new[] { EnvVarKeyValueSeparator }, 2);
                     return new EnvironmentVariable(separated[0], separated[1]);
                 }).ToArray());
             }
diff --git a/src/BenchmarkDotNet/Diagnosers/EventPipeProfile.cs b/src/BenchmarkDotNet/Diagnosers/EventPipeProfile.cs
index ba637d6ed..8f22a6f6d 100644
--- a/src/BenchmarkDotNet/Diagnosers/EventPipeProfile.cs
+++ b/src/BenchmarkDotNet/Diagnosers/EventPipeProfile.cs
@@ -1,4 +1,4 @@
-namespace BenchmarkDotNet.Diagnosers 
+namespace BenchmarkDotNet.Diagnosers
 {
     public enum EventPipeProfile
     {
diff --git a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs
index 4da6af3ea..747ae1689 100644
--- a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs
+++ b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoser.cs
@@ -131,7 +131,7 @@ namespace BenchmarkDotNet.Diagnosers
 
         private static bool ShouldUseWindowsDisassembler(BenchmarkCase benchmarkCase)
             => !(benchmarkCase.Job.Environment.Runtime is MonoRuntime) && RuntimeInformation.IsWindows();
-        
+
         private static bool ShouldUseLinuxDisassembler(BenchmarkCase benchmarkCase)
             => !(benchmarkCase.Job.Environment.Runtime is MonoRuntime) && RuntimeInformation.IsLinux();
 
diff --git a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoserConfig.cs b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoserConfig.cs
index 45b848839..c646ae1ed 100644
--- a/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoserConfig.cs
+++ b/src/BenchmarkDotNet/Disassemblers/DisassemblyDiagnoserConfig.cs
@@ -62,7 +62,7 @@ namespace BenchmarkDotNet.Diagnosers
         {
             var symbolSolver = new SymbolResolver(addressToNameMapping);
 
-            switch(Formatter)
+            switch (Formatter)
             {
                 case MasmFormatter masmFormatter:
                     return new MasmFormatter(masmFormatter.MasmOptions, symbolSolver);
diff --git a/src/BenchmarkDotNet/Disassemblers/InstructionFormatter.cs b/src/BenchmarkDotNet/Disassemblers/InstructionFormatter.cs
index 05c99e6d3..3570e73c2 100644
--- a/src/BenchmarkDotNet/Disassemblers/InstructionFormatter.cs
+++ b/src/BenchmarkDotNet/Disassemblers/InstructionFormatter.cs
@@ -7,7 +7,7 @@ namespace BenchmarkDotNet.Disassemblers
     {
         internal static string Format(SourceCode sourceCode, Formatter formatter, bool printInstructionAddresses, uint pointerSize)
         {
-            switch(sourceCode)
+            switch (sourceCode)
             {
                 case Asm asm:
                     return InstructionFormatter.Format(asm.Instruction, formatter, printInstructionAddresses, pointerSize);
diff --git a/src/BenchmarkDotNet/Disassemblers/LinuxDisassembler.cs b/src/BenchmarkDotNet/Disassemblers/LinuxDisassembler.cs
index 66b118cbd..ee6cdc6cb 100644
--- a/src/BenchmarkDotNet/Disassemblers/LinuxDisassembler.cs
+++ b/src/BenchmarkDotNet/Disassemblers/LinuxDisassembler.cs
@@ -8,7 +8,7 @@ namespace BenchmarkDotNet.Disassemblers
 
         internal LinuxDisassembler(DisassemblyDiagnoserConfig config) => this.config = config;
 
-        internal DisassemblyResult Disassemble(DiagnoserActionParameters parameters) 
+        internal DisassemblyResult Disassemble(DiagnoserActionParameters parameters)
             => ClrMdDisassembler.AttachAndDisassemble(BuildDisassemblerSettings(parameters));
 
         private Settings BuildDisassemblerSettings(DiagnoserActionParameters parameters)
diff --git a/src/BenchmarkDotNet/Disassemblers/MonoDisassembler.cs b/src/BenchmarkDotNet/Disassemblers/MonoDisassembler.cs
index 5d7ae642e..75868a9ca 100644
--- a/src/BenchmarkDotNet/Disassemblers/MonoDisassembler.cs
+++ b/src/BenchmarkDotNet/Disassemblers/MonoDisassembler.cs
@@ -125,8 +125,8 @@ namespace BenchmarkDotNet.Disassemblers
                 };
             }
 
-            //line example 1:  0:	48 83 ec 28          	sub    $0x28,%rsp
-            //line example 2: 0000000000000000	subq	$0x28, %rsp
+            //line example 1:  0:   48 83 ec 28             sub    $0x28,%rsp
+            //line example 2: 0000000000000000  subq    $0x28, %rsp
             private static readonly Regex InstructionRegex = new Regex(@"\s*(?<address>[0-9a-f]+)(\:\s+([0-9a-f]{2}\s+)+)?\s+(?<instruction>.*)\s*", RegexOptions.Compiled);
 
             private static bool TryParseInstruction(string line, out MonoCode instruction)
diff --git a/src/BenchmarkDotNet/Engines/ConsoleHost.cs b/src/BenchmarkDotNet/Engines/ConsoleHost.cs
index a4107193f..918e2af72 100644
--- a/src/BenchmarkDotNet/Engines/ConsoleHost.cs
+++ b/src/BenchmarkDotNet/Engines/ConsoleHost.cs
@@ -30,7 +30,7 @@ namespace BenchmarkDotNet.Engines
             // I did not use Mutexes because they are not supported for Linux/MacOs for .NET Core
             // this solution is stupid simple and it works
             string acknowledgment = inReader.ReadLine();
-            if(acknowledgment != Engine.Signals.Acknowledgment)
+            if (acknowledgment != Engine.Signals.Acknowledgment)
                 throw new NotSupportedException($"Unknown Acknowledgment: {acknowledgment}");
         }
 
diff --git a/src/BenchmarkDotNet/Engines/Engine.cs b/src/BenchmarkDotNet/Engines/Engine.cs
index 427171263..7ba21a490 100644
--- a/src/BenchmarkDotNet/Engines/Engine.cs
+++ b/src/BenchmarkDotNet/Engines/Engine.cs
@@ -148,7 +148,7 @@ namespace BenchmarkDotNet.Engines
             bool isOverhead = data.IterationMode == IterationMode.Overhead;
             var action = isOverhead ? OverheadAction : WorkloadAction;
 
-            if(!isOverhead)
+            if (!isOverhead)
                 IterationSetupAction();
 
             GcCollect();
@@ -164,7 +164,7 @@ namespace BenchmarkDotNet.Engines
             if (EngineEventSource.Log.IsEnabled())
                 EngineEventSource.Log.IterationStop(data.IterationMode, data.IterationStage, totalOperations);
 
-            if(!isOverhead)
+            if (!isOverhead)
                 IterationCleanupAction();
 
             GcCollect();
diff --git a/src/BenchmarkDotNet/Engines/EngineFactory.cs b/src/BenchmarkDotNet/Engines/EngineFactory.cs
index d63081cec..f15c21fac 100644
--- a/src/BenchmarkDotNet/Engines/EngineFactory.cs
+++ b/src/BenchmarkDotNet/Engines/EngineFactory.cs
@@ -22,7 +22,7 @@ namespace BenchmarkDotNet.Engines
                 throw new ArgumentNullException(nameof(engineParameters.OverheadActionNoUnroll));
             if (engineParameters.OverheadActionUnroll == null)
                 throw new ArgumentNullException(nameof(engineParameters.OverheadActionUnroll));
-            if(engineParameters.TargetJob == null)
+            if (engineParameters.TargetJob == null)
                 throw new ArgumentNullException(nameof(engineParameters.TargetJob));
 
             engineParameters.GlobalSetupAction?.Invoke(); // whatever the settings are, we MUST call global setup here, the global cleanup is part of Engine's Dispose
diff --git a/src/BenchmarkDotNet/Engines/EngineResolver.cs b/src/BenchmarkDotNet/Engines/EngineResolver.cs
index c6d079c04..9f042e003 100644
--- a/src/BenchmarkDotNet/Engines/EngineResolver.cs
+++ b/src/BenchmarkDotNet/Engines/EngineResolver.cs
@@ -1,7 +1,6 @@
 using System;
 using BenchmarkDotNet.Characteristics;
 using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Horology;
 using Perfolizer.Mathematics.OutlierDetection;
 
diff --git a/src/BenchmarkDotNet/Engines/GcStats.cs b/src/BenchmarkDotNet/Engines/GcStats.cs
index 5cd500e89..b30a56727 100644
--- a/src/BenchmarkDotNet/Engines/GcStats.cs
+++ b/src/BenchmarkDotNet/Engines/GcStats.cs
@@ -175,7 +175,7 @@ namespace BenchmarkDotNet.Engines
 
         public static GcStats Parse(string line)
         {
-            if(!line.StartsWith(ResultsLinePrefix))
+            if (!line.StartsWith(ResultsLinePrefix))
                 throw new NotSupportedException($"Line must start with {ResultsLinePrefix}");
 
             var measurementSplit = line.Remove(0, ResultsLinePrefix.Length).Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);
diff --git a/src/BenchmarkDotNet/Engines/ThreadingStats.cs b/src/BenchmarkDotNet/Engines/ThreadingStats.cs
index 0e265e16c..d196577b7 100644
--- a/src/BenchmarkDotNet/Engines/ThreadingStats.cs
+++ b/src/BenchmarkDotNet/Engines/ThreadingStats.cs
@@ -8,8 +8,8 @@ namespace BenchmarkDotNet.Engines
         internal const string ResultsLinePrefix = "Threading: ";
 
         // BDN targets .NET Standard 2.0, these properties are not part of .NET Standard 2.0, were added in .NET Core 3.0
-        private static readonly Func<long> GetCompletedWorkItemCountDelegate = CreateGetterDelegate(typeof(ThreadPool), "CompletedWorkItemCount");
-        private static readonly Func<long> GetLockContentionCountDelegate = CreateGetterDelegate(typeof(Monitor), "LockContentionCount");
+        private static readonly Func<long> GetCompletedWorkItemCountDelegate = CreateGetterDelegate(typeof(ThreadPool), nameof(CompletedWorkItemCount));
+        private static readonly Func<long> GetLockContentionCountDelegate = CreateGetterDelegate(typeof(Monitor), nameof(LockContentionCount));
 
         public static ThreadingStats Empty => new ThreadingStats(0, 0, 0);
 
diff --git a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
index 360c26851..57b1bd866 100644
--- a/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/CompositeExporter.cs
@@ -17,7 +17,7 @@ namespace BenchmarkDotNet.Exporters
 
         public void ExportToLog(Summary summary, ILogger logger)
         {
-            if(summary.GetColumns().IsNullOrEmpty())
+            if (summary.GetColumns().IsNullOrEmpty())
                 logger.WriteLineHint("You haven't configured any columns, your results will be empty");
 
             foreach (var exporter in exporters)
diff --git a/src/BenchmarkDotNet/Exporters/InstructionPointerExporter.cs b/src/BenchmarkDotNet/Exporters/InstructionPointerExporter.cs
index e9b12df0c..862041827 100644
--- a/src/BenchmarkDotNet/Exporters/InstructionPointerExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/InstructionPointerExporter.cs
@@ -175,7 +175,7 @@ namespace BenchmarkDotNet.Exporters
             logger.WriteLine("<body>");
 
             logger.WriteLine("<!-- Generated with BenchmarkDotNet ");
-            foreach(var total in totals)
+            foreach (var total in totals)
             {
                 // this stats are mostly for me, the maintainer, who wants to know if removing noise makes any sense
                 logger.WriteLine($"For {total.Key} we have {total.Value.total} in total, {total.Value.withoutNoise} without noise");
diff --git a/src/BenchmarkDotNet/Exporters/Json/JsonExporterBase.cs b/src/BenchmarkDotNet/Exporters/Json/JsonExporterBase.cs
index 22a5b52c4..f485415d0 100644
--- a/src/BenchmarkDotNet/Exporters/Json/JsonExporterBase.cs
+++ b/src/BenchmarkDotNet/Exporters/Json/JsonExporterBase.cs
@@ -63,7 +63,7 @@ namespace BenchmarkDotNet.Exporters.Json
                 };
 
                 // We show MemoryDiagnoser's results only if it is being used
-                if(report.BenchmarkCase.Config.HasMemoryDiagnoser())
+                if (report.BenchmarkCase.Config.HasMemoryDiagnoser())
                 {
                     data.Add("Memory", report.GcStats);
                 }
diff --git a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
index 408e655c8..253fbad2c 100644
--- a/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
+++ b/src/BenchmarkDotNet/Exporters/RPlotExporter.cs
@@ -41,7 +41,7 @@ namespace BenchmarkDotNet.Exporters
             lock (BuildScriptLock)
                 File.WriteAllText(scriptFullPath, script);
 
-            if(!TryFindRScript(consoleLogger, out string rscriptPath))
+            if (!TryFindRScript(consoleLogger, out string rscriptPath))
             {
                 yield break;
             }
diff --git a/src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs b/src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs
index 265b1cd2f..cf711a708 100644
--- a/src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs
+++ b/src/BenchmarkDotNet/Extensions/ReflectionExtensions.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Linq;
 using System.Reflection;
 using BenchmarkDotNet.Attributes;
diff --git a/src/BenchmarkDotNet/Extensions/StatisticsExtensions.cs b/src/BenchmarkDotNet/Extensions/StatisticsExtensions.cs
index e81051970..7abb00768 100644
--- a/src/BenchmarkDotNet/Extensions/StatisticsExtensions.cs
+++ b/src/BenchmarkDotNet/Extensions/StatisticsExtensions.cs
@@ -18,7 +18,7 @@ namespace BenchmarkDotNet.Extensions
             var timeUnit = TimeUnit.GetBestTimeUnit(s.Mean);
             return x => TimeInterval.FromNanoseconds(x).ToString(timeUnit, cultureInfo, format);
         }
-        
+
         [PublicAPI]
         public static string ToString(this Statistics s, CultureInfo cultureInfo, Func<double, string> formatter, bool calcHistogram = false)
         {
@@ -26,7 +26,7 @@ namespace BenchmarkDotNet.Extensions
                 return NullSummaryMessage;
 
             string listSeparator = cultureInfo.GetActualListSeparator();
-            
+
             var builder = new StringBuilder();
             string errorPercent = (s.StandardError / s.Mean * 100).ToString("0.00", cultureInfo);
             var ci = s.ConfidenceInterval;
@@ -48,7 +48,7 @@ namespace BenchmarkDotNet.Extensions
             builder.Append(" StdDev = ");
             builder.Append(formatter(s.StandardDeviation));
             builder.AppendLine();
-            
+
             builder.Append("Min = ");
             builder.Append(formatter(s.Min));
             builder.Append(listSeparator);
@@ -64,7 +64,7 @@ namespace BenchmarkDotNet.Extensions
             builder.Append(" Max = ");
             builder.Append(formatter(s.Max));
             builder.AppendLine();
-            
+
             builder.Append("IQR = ");
             builder.Append(formatter(s.InterquartileRange));
             builder.Append(listSeparator);
@@ -74,7 +74,7 @@ namespace BenchmarkDotNet.Extensions
             builder.Append(" UpperFence = ");
             builder.Append(formatter(s.UpperFence));
             builder.AppendLine();
-            
+
             builder.Append("ConfidenceInterval = ");
             builder.Append(s.ConfidenceInterval.ToString(formatter));
             builder.Append(listSeparator);
@@ -84,7 +84,7 @@ namespace BenchmarkDotNet.Extensions
             builder.Append(ciMarginPercent);
             builder.Append("% of Mean)");
             builder.AppendLine();
-            
+
             builder.Append("Skewness = ");
             builder.Append(s.Skewness.ToString("0.##", cultureInfo));
             builder.Append(listSeparator);
@@ -94,7 +94,7 @@ namespace BenchmarkDotNet.Extensions
             builder.Append(" MValue = ");
             builder.Append(mValue.ToString("0.##", cultureInfo));
             builder.AppendLine();
-            
+
             if (calcHistogram)
             {
                 var histogram = HistogramBuilder.Adaptive.Build(s.OriginalValues);
diff --git a/src/BenchmarkDotNet/Helpers/ArtifactFileNameHelper.cs b/src/BenchmarkDotNet/Helpers/ArtifactFileNameHelper.cs
index 52bbdab88..2a8a5dd57 100644
--- a/src/BenchmarkDotNet/Helpers/ArtifactFileNameHelper.cs
+++ b/src/BenchmarkDotNet/Helpers/ArtifactFileNameHelper.cs
@@ -7,7 +7,7 @@ using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Toolchains;
 
-namespace BenchmarkDotNet.Helpers 
+namespace BenchmarkDotNet.Helpers
 {
     internal static class ArtifactFileNameHelper
     {
diff --git a/src/BenchmarkDotNet/Helpers/AsciiHelper.cs b/src/BenchmarkDotNet/Helpers/AsciiHelper.cs
index 8c44d45f2..7c19c7eee 100644
--- a/src/BenchmarkDotNet/Helpers/AsciiHelper.cs
+++ b/src/BenchmarkDotNet/Helpers/AsciiHelper.cs
@@ -7,8 +7,8 @@ namespace BenchmarkDotNet.Helpers
         /// <summary>
         /// The 'μ' symbol
         /// </summary>
-        private const string Mu = "\u03BC"; 
-        
+        private const string Mu = "\u03BC";
+
         public static string ToAscii([CanBeNull] this string s)
         {
             // We should replace all non-ASCII symbols that used in BenchmarkDotNet by ASCII-compatible analogues
diff --git a/src/BenchmarkDotNet/Helpers/PowerManagementHelper.cs b/src/BenchmarkDotNet/Helpers/PowerManagementHelper.cs
index 93401171c..e3d82dd51 100644
--- a/src/BenchmarkDotNet/Helpers/PowerManagementHelper.cs
+++ b/src/BenchmarkDotNet/Helpers/PowerManagementHelper.cs
@@ -1,9 +1,11 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Runtime.InteropServices;
 using System.Text;
 
 namespace BenchmarkDotNet.Helpers
 {
+    [SuppressMessage("ReSharper", "InconsistentNaming")]
     internal class PowerManagementHelper
     {
         private const uint ErrorMoreData = 234;
diff --git a/src/BenchmarkDotNet/Helpers/ProcessHelper.cs b/src/BenchmarkDotNet/Helpers/ProcessHelper.cs
index 6a38aaff3..69e20b7f5 100644
--- a/src/BenchmarkDotNet/Helpers/ProcessHelper.cs
+++ b/src/BenchmarkDotNet/Helpers/ProcessHelper.cs
@@ -57,7 +57,7 @@ namespace BenchmarkDotNet.Helpers
                 RedirectStandardError = true
             };
 
-            if(environmentVariables != null)
+            if (environmentVariables != null)
                 foreach (var environmentVariable in environmentVariables)
                     processStartInfo.Environment[environmentVariable.Key] = environmentVariable.Value;
 
diff --git a/src/BenchmarkDotNet/Helpers/SourceCodeHelper.cs b/src/BenchmarkDotNet/Helpers/SourceCodeHelper.cs
index c1e894e2e..3553ece5f 100644
--- a/src/BenchmarkDotNet/Helpers/SourceCodeHelper.cs
+++ b/src/BenchmarkDotNet/Helpers/SourceCodeHelper.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
 using System.Numerics;
 using BenchmarkDotNet.Extensions;
@@ -95,6 +96,7 @@ namespace BenchmarkDotNet.Helpers
             return false;
         }
 
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
         private static string ToSourceCode(double value)
         {
             if (double.IsNaN(value))
@@ -113,6 +115,7 @@ namespace BenchmarkDotNet.Helpers
             return value.ToString("G", CultureInfo.InvariantCulture) + "d";
         }
 
+        [SuppressMessage("ReSharper", "CompareOfFloatsByEqualityOperator")]
         private static string ToSourceCode(float value)
         {
             if (float.IsNaN(value))
diff --git a/src/BenchmarkDotNet/Jobs/AccuracyMode.cs b/src/BenchmarkDotNet/Jobs/AccuracyMode.cs
index 23c35b1aa..75cc38e47 100644
--- a/src/BenchmarkDotNet/Jobs/AccuracyMode.cs
+++ b/src/BenchmarkDotNet/Jobs/AccuracyMode.cs
@@ -1,6 +1,5 @@
 using System.Diagnostics.CodeAnalysis;
 using BenchmarkDotNet.Characteristics;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Horology;
 using Perfolizer.Mathematics.OutlierDetection;
 
diff --git a/src/BenchmarkDotNet/Jobs/Argument.cs b/src/BenchmarkDotNet/Jobs/Argument.cs
index 51613f5cd..0932ad994 100644
--- a/src/BenchmarkDotNet/Jobs/Argument.cs
+++ b/src/BenchmarkDotNet/Jobs/Argument.cs
@@ -19,7 +19,7 @@ namespace BenchmarkDotNet.Jobs
     {
         public MonoArgument(string value)
         {
-            if(value == "--llvm" || value == "--nollvm")
+            if (value == "--llvm" || value == "--nollvm")
                 throw new NotSupportedException("Please use job.Env.Jit to specify Jit in explicit way");
 
             TextRepresentation = value;
diff --git a/src/BenchmarkDotNet/Jobs/Job.cs b/src/BenchmarkDotNet/Jobs/Job.cs
index 214bc735f..18f28397a 100644
--- a/src/BenchmarkDotNet/Jobs/Job.cs
+++ b/src/BenchmarkDotNet/Jobs/Job.cs
@@ -1,9 +1,11 @@
 using BenchmarkDotNet.Characteristics;
 using JetBrains.Annotations;
 using System;
+using System.Diagnostics.CodeAnalysis;
 
 namespace BenchmarkDotNet.Jobs
 {
+    [SuppressMessage("ReSharper", "UnassignedReadonlyField")]
     public sealed class Job : JobMode<Job>
     {
         [PublicAPI] public static readonly Characteristic<EnvironmentMode> EnvironmentCharacteristic = CreateCharacteristic<EnvironmentMode>(nameof(Environment));
diff --git a/src/BenchmarkDotNet/Jobs/JobExtensions.cs b/src/BenchmarkDotNet/Jobs/JobExtensions.cs
index 3e8247300..165c64819 100644
--- a/src/BenchmarkDotNet/Jobs/JobExtensions.cs
+++ b/src/BenchmarkDotNet/Jobs/JobExtensions.cs
@@ -5,7 +5,6 @@ using System.Linq;
 using BenchmarkDotNet.Analysers;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Environments;
-using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Toolchains;
 using JetBrains.Annotations;
@@ -121,7 +120,7 @@ namespace BenchmarkDotNet.Jobs
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .WithStrategy instead")]
         public static Job With(this Job job, RunStrategy strategy) => job.WithCore(j => j.Run.RunStrategy = strategy);        // Run
-        
+
         /// <summary>
         /// Available values: Throughput, ColdStart and Monitoring.
         ///     Throughput: default strategy which allows to get good precision level.
@@ -227,7 +226,7 @@ namespace BenchmarkDotNet.Jobs
         [Obsolete("This method will soon be removed, please start using .WithClock instead")]
         public static Job With(this Job job, IClock clock) => job.WithClock(clock);
         [PublicAPI] public static Job WithClock(this Job job, IClock clock) => job.WithCore(j => j.Infrastructure.Clock = clock);
-        
+
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .WithEngineFactory instead")]
         public static Job With(this Job job, IEngineFactory engineFactory) => job.WithEngineFactory(engineFactory);
@@ -249,7 +248,7 @@ namespace BenchmarkDotNet.Jobs
         [EditorBrowsable(EditorBrowsableState.Never)]
         [Obsolete("This method will soon be removed, please start using .WithEnvironmentVariables instead")]
         public static Job With(this Job job, IReadOnlyList<EnvironmentVariable> environmentVariables) => job.WithEnvironmentVariables(environmentVariables.ToArray());
-        
+
         /// <summary>
         /// Creates a new job based on the given job with specified environment variables.
         /// It overrides the whole list of environment variables which were defined in the original job.
@@ -382,14 +381,14 @@ namespace BenchmarkDotNet.Jobs
         /// Specifies which outliers should be removed from the distribution
         /// </summary>
         public static Job WithOutlierMode(this Job job, OutlierMode value) => job.WithCore(j => j.Accuracy.OutlierMode = value);
-        
+
         [PublicAPI]
         public static Job WithAnalyzeLaunchVariance(this Job job, bool value) => job.WithCore(j => j.Accuracy.AnalyzeLaunchVariance = value);
 
         // Meta
         public static Job AsBaseline(this Job job) => job.WithCore(j => j.Meta.Baseline = true);
         public static Job WithBaseline(this Job job, bool value) => job.WithCore(j => j.Meta.Baseline = value);
-        
+
         /// <summary>
         /// mutator job should not be added to the config, but instead applied to other jobs in given config
         /// </summary>
diff --git a/src/BenchmarkDotNet/Loggers/AccumulationLogger.cs b/src/BenchmarkDotNet/Loggers/AccumulationLogger.cs
index f55745272..2cfeee224 100644
--- a/src/BenchmarkDotNet/Loggers/AccumulationLogger.cs
+++ b/src/BenchmarkDotNet/Loggers/AccumulationLogger.cs
@@ -12,10 +12,10 @@ namespace BenchmarkDotNet.Loggers
             // All AccumulationLoggers should have unique Ids
             Id = nameof(AccumulationLogger) + "." + Guid.NewGuid().ToString("N");
         }
-        
+
         public string Id { get; }
         public int Priority => 0;
-        
+
         public virtual void Write(LogKind logKind, string text) => builder.Append(text);
 
         public virtual void WriteLine() => builder.AppendLine();
diff --git a/src/BenchmarkDotNet/Loggers/ConsoleLogger.cs b/src/BenchmarkDotNet/Loggers/ConsoleLogger.cs
index 75c0a2683..8d9a96e93 100644
--- a/src/BenchmarkDotNet/Loggers/ConsoleLogger.cs
+++ b/src/BenchmarkDotNet/Loggers/ConsoleLogger.cs
@@ -27,7 +27,7 @@ namespace BenchmarkDotNet.Loggers
         public string Id => nameof(ConsoleLogger);
 
         public int Priority => unicodeSupport ? 1 : 0;
-        
+
         public void Write(LogKind logKind, string text) => Write(logKind, Console.Write, text);
 
         public void WriteLine() => Console.WriteLine();
@@ -40,7 +40,7 @@ namespace BenchmarkDotNet.Loggers
         {
             if (!unicodeSupport)
                 text = text.ToAscii();
-            
+
             var colorBefore = Console.ForegroundColor;
 
             try
diff --git a/src/BenchmarkDotNet/Loggers/ILogger.cs b/src/BenchmarkDotNet/Loggers/ILogger.cs
index 44b60ea2a..cebb60d9f 100644
--- a/src/BenchmarkDotNet/Loggers/ILogger.cs
+++ b/src/BenchmarkDotNet/Loggers/ILogger.cs
@@ -3,13 +3,13 @@
     public interface ILogger
     {
         string Id { get; }
-        
+
         /// <summary>
         /// If there are several loggers with the same <see cref="Id"/>,
         /// only logger with the highest priority will be used.
         /// </summary>
         int Priority { get; }
-        
+
         void Write(LogKind logKind, string text);
 
         void WriteLine();
diff --git a/src/BenchmarkDotNet/Reports/SummaryStyle.cs b/src/BenchmarkDotNet/Reports/SummaryStyle.cs
index 378c76d06..1280d1933 100644
--- a/src/BenchmarkDotNet/Reports/SummaryStyle.cs
+++ b/src/BenchmarkDotNet/Reports/SummaryStyle.cs
@@ -51,14 +51,14 @@ namespace BenchmarkDotNet.Reports
 
         public SummaryStyle WithCultureInfo(CultureInfo cultureInfo)
             => new SummaryStyle(cultureInfo, PrintUnitsInHeader, SizeUnit, TimeUnit, PrintUnitsInContent, PrintZeroValuesInContent, MaxParameterColumnWidth);
-        
+
         public bool Equals(SummaryStyle other)
         {
             if (ReferenceEquals(null, other))
                 return false;
             if (ReferenceEquals(this, other))
                 return true;
-            return Equals(CultureInfo, other.CultureInfo) 
+            return Equals(CultureInfo, other.CultureInfo)
                    && PrintUnitsInHeader == other.PrintUnitsInHeader
                    && PrintUnitsInContent == other.PrintUnitsInContent
                    && PrintZeroValuesInContent == other.PrintZeroValuesInContent
diff --git a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
index 494d4d034..bad64211a 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkConverter.cs
@@ -215,7 +215,7 @@ namespace BenchmarkDotNet.Running
                     argumentsAttribute
                         .Values
                         .Select((value, index) =>
-                            { 
+                            {
                                 var definition = parameterDefinitions[index];
                                 var type = definition.ParameterType;
                                 return new ParameterInstance(definition, Map(value, type), summaryStyle);
@@ -306,7 +306,7 @@ namespace BenchmarkDotNet.Running
             else if (providedValue.GetType().IsEnum || type.IsEnum)
             {
                 return EnumParam.FromObject(providedValue, type);
-            }            
+            }
             return providedValue;
         }
 
diff --git a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
index a5f822d9f..6072f80d1 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkRunnerClean.cs
@@ -47,11 +47,11 @@ namespace BenchmarkDotNet.Running
 
                 var supportedBenchmarks = GetSupportedBenchmarks(benchmarkRunInfos, compositeLogger, resolver);
                 if (!supportedBenchmarks.Any(benchmarks => benchmarks.BenchmarksCases.Any()))
-                    return new [] { Summary.NothingToRun(title, resultsFolderPath, logFilePath) };
+                    return new[] { Summary.NothingToRun(title, resultsFolderPath, logFilePath) };
 
                 var validationErrors = Validate(supportedBenchmarks, compositeLogger);
                 if (validationErrors.Any(validationError => validationError.IsCritical))
-                    return new [] { Summary.ValidationFailed(title, resultsFolderPath, logFilePath, validationErrors) };
+                    return new[] { Summary.ValidationFailed(title, resultsFolderPath, logFilePath, validationErrors) };
 
                 var benchmarksToRunCount = supportedBenchmarks.Sum(benchmarkInfo => benchmarkInfo.BenchmarksCases.Length);
                 compositeLogger.WriteLineHeader("// ***** BenchmarkRunner: Start   *****");
@@ -196,7 +196,7 @@ namespace BenchmarkDotNet.Running
         private static void PrintSummary(ILogger logger, ImmutableConfig config, Summary summary)
         {
             var cultureInfo = config.CultureInfo ?? DefaultCultureInfo.Instance;
-            
+
             logger.WriteLineHeader("// ***** BenchmarkRunner: Finish  *****");
             logger.WriteLine();
 
@@ -284,7 +284,7 @@ namespace BenchmarkDotNet.Running
             logger.WriteLineHeader("// ***** Failed to build in Parallel, switching to sequential build   *****");
 
             foreach (var buildPartition in buildPartitions)
-                if (buildResults[buildPartition].IsGenerateSuccess && !buildResults[buildPartition].IsBuildSuccess && !buildResults[buildPartition].TryToExplainFailureReason(out var reason))
+                if (buildResults[buildPartition].IsGenerateSuccess && !buildResults[buildPartition].IsBuildSuccess && !buildResults[buildPartition].TryToExplainFailureReason(out string _))
                     buildResults[buildPartition] = Build(buildPartition, rootArtifactsFolderPath, buildLogger);
 
             logger.WriteLineHeader($"// ***** Done, took {globalChronometer.GetElapsed().GetTimeSpan().ToFormattedTotalTime(DefaultCultureInfo.Instance)}   *****");
diff --git a/src/BenchmarkDotNet/Running/BenchmarkSwitcher.cs b/src/BenchmarkDotNet/Running/BenchmarkSwitcher.cs
index 4915debcc..7d918a6b4 100644
--- a/src/BenchmarkDotNet/Running/BenchmarkSwitcher.cs
+++ b/src/BenchmarkDotNet/Running/BenchmarkSwitcher.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
 using System.Runtime.CompilerServices;
@@ -30,11 +31,15 @@ namespace BenchmarkDotNet.Running
 
         [PublicAPI] public BenchmarkSwitcher With(Type type) { types.Add(type); return this; }
 
-        [PublicAPI] public BenchmarkSwitcher With(Type[] types) { this.types.AddRange(types); return this; }
+        [PublicAPI]
+        [SuppressMessage("ReSharper", "ParameterHidesMember")]
+        public BenchmarkSwitcher With(Type[] types) { this.types.AddRange(types); return this; }
 
         [PublicAPI] public BenchmarkSwitcher With(Assembly assembly) { assemblies.Add(assembly); return this; }
 
-        [PublicAPI] public BenchmarkSwitcher With(Assembly[] assemblies) { this.assemblies.AddRange(assemblies); return this; }
+        [PublicAPI]
+        [SuppressMessage("ReSharper", "ParameterHidesMember")]
+        public BenchmarkSwitcher With(Assembly[] assemblies) { this.assemblies.AddRange(assemblies); return this; }
 
         [PublicAPI] public static BenchmarkSwitcher FromTypes(Type[] types) => new BenchmarkSwitcher(types);
 
@@ -67,7 +72,7 @@ namespace BenchmarkDotNet.Running
         {
             var notNullArgs = args ?? Array.Empty<string>();
             var notNullConfig = config ?? DefaultConfig.Instance;
-            
+
             var logger = notNullConfig.GetNonNullCompositeLogger();
             var (isParsingSuccess, parsedConfig, options) = ConfigParser.Parse(notNullArgs, logger, notNullConfig);
             if (!isParsingSuccess) // invalid console args, the ConfigParser printed the error
diff --git a/src/BenchmarkDotNet/Running/PowerManagementApplier.cs b/src/BenchmarkDotNet/Running/PowerManagementApplier.cs
index 73f39f6ff..1e341f9c5 100644
--- a/src/BenchmarkDotNet/Running/PowerManagementApplier.cs
+++ b/src/BenchmarkDotNet/Running/PowerManagementApplier.cs
@@ -11,7 +11,7 @@ namespace BenchmarkDotNet.Running
     {
         private static readonly Guid UserPowerPlan = new Guid("67b4a053-3646-4532-affd-0535c9ea82a7");
 
-        private static readonly Dictionary<PowerPlan, Guid> powerPlansDict = new Dictionary<PowerPlan, Guid>()
+        private static readonly Dictionary<PowerPlan, Guid> PowerPlansDict = new Dictionary<PowerPlan, Guid>()
         {
             { PowerPlan.UserPowerPlan, UserPowerPlan },
             { PowerPlan.HighPerformance, new Guid("8c5e7fda-e8bf-4a96-9a85-a6e23a8c635c") },
@@ -22,14 +22,14 @@ namespace BenchmarkDotNet.Running
 
         private readonly ILogger logger;
         private Guid? userCurrentPowerPlan;
-        private bool powerPlanChanged = false;
-        private bool isInitialized = false;
+        private bool powerPlanChanged;
+        private bool isInitialized;
 
         internal PowerManagementApplier(ILogger logger) => this.logger = logger;
 
         public void Dispose() => ApplyUserPowerPlan();
 
-        internal static Guid Map(PowerPlan value) => powerPlansDict[value];
+        internal static Guid Map(PowerPlan value) => PowerPlansDict[value];
 
         internal void ApplyPerformancePlan(Guid id)
         {
diff --git a/src/BenchmarkDotNet/Toolchains/CoreRt/CoreRtToolchainBuilder.cs b/src/BenchmarkDotNet/Toolchains/CoreRt/CoreRtToolchainBuilder.cs
index 4648382d9..739c7ea8b 100644
--- a/src/BenchmarkDotNet/Toolchains/CoreRt/CoreRtToolchainBuilder.cs
+++ b/src/BenchmarkDotNet/Toolchains/CoreRt/CoreRtToolchainBuilder.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using BenchmarkDotNet.Toolchains.DotNetCli;
 using JetBrains.Annotations;
@@ -14,7 +15,7 @@ namespace BenchmarkDotNet.Toolchains.CoreRt
         private bool useCppCodeGenerator;
         private string packagesRestorePath;
         // we set those default values on purpose https://github.com/dotnet/BenchmarkDotNet/pull/1057#issuecomment-461832612
-        private bool rootAllApplicationAssemblies = false;
+        private bool rootAllApplicationAssemblies;
         private bool ilcGenerateCompleteTypeMetadata = true;
         private bool ilcGenerateStackTraceData = true;
 
@@ -75,6 +76,7 @@ namespace BenchmarkDotNet.Toolchains.CoreRt
         /// The directory to restore packages to (optional).
         /// </summary>
         [PublicAPI]
+        [SuppressMessage("ReSharper", "ParameterHidesMember")]
         public CoreRtToolchainBuilder PackagesRestorePath(string packagesRestorePath)
         {
             this.packagesRestorePath = packagesRestorePath;
diff --git a/src/BenchmarkDotNet/Toolchains/CoreRt/Generator.cs b/src/BenchmarkDotNet/Toolchains/CoreRt/Generator.cs
index a3833ae37..cc9684b93 100644
--- a/src/BenchmarkDotNet/Toolchains/CoreRt/Generator.cs
+++ b/src/BenchmarkDotNet/Toolchains/CoreRt/Generator.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.IO;
 using System.Linq;
 using System.Text;
@@ -41,6 +42,7 @@ namespace BenchmarkDotNet.Toolchains.CoreRt
 
         private readonly string coreRtVersion;
         private readonly bool useCppCodeGenerator;
+        [SuppressMessage("ReSharper", "NotAccessedField.Local")]
         private readonly string targetFrameworkMoniker;
         private readonly string runtimeIdentifier;
         private readonly IReadOnlyDictionary<string, string> feeds;
@@ -201,7 +203,11 @@ $@"<?xml version=""1.0"" encoding=""utf-8""?>
 </Directives>
 ";
 
-            File.WriteAllText(Path.Combine(Path.GetDirectoryName(artifactsPaths.ProjectFilePath), "rd.xml"), content);
+            string directoryName = Path.GetDirectoryName(artifactsPaths.ProjectFilePath);
+            if (directoryName != null)
+                File.WriteAllText(Path.Combine(directoryName, "rd.xml"), content);
+            else
+                throw new InvalidOperationException($"Can't get directory of projectFilePath ('{artifactsPaths.ProjectFilePath}')");
         }
     }
 }
diff --git a/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunGenerator.cs b/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunGenerator.cs
index c988066f7..f7108c990 100644
--- a/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunGenerator.cs
+++ b/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunGenerator.cs
@@ -19,8 +19,7 @@ namespace BenchmarkDotNet.Toolchains.CoreRun
 
         private bool NeedsCopy => SourceCoreRun != CopyCoreRun;
 
-        protected override string GetPackagesDirectoryPath(string buildArtifactsDirectoryPath)
-            => base.PackagesPath;
+        protected override string GetPackagesDirectoryPath(string buildArtifactsDirectoryPath) => PackagesPath;
 
         protected override string GetBinariesDirectoryPath(string buildArtifactsDirectoryPath, string configuration)
             => Path.Combine(buildArtifactsDirectoryPath, "bin", configuration, TargetFrameworkMoniker, "publish");
@@ -35,7 +34,7 @@ namespace BenchmarkDotNet.Toolchains.CoreRun
 
         protected override string[] GetArtifactsToCleanup(ArtifactsPaths artifactsPaths)
             => NeedsCopy
-                ? base.GetArtifactsToCleanup(artifactsPaths).Concat(new [] { CopyCoreRun.Directory.FullName }).ToArray()
+                ? base.GetArtifactsToCleanup(artifactsPaths).Concat(new[] { CopyCoreRun.Directory.FullName }).ToArray()
                 : base.GetArtifactsToCleanup(artifactsPaths);
 
         // source: https://stackoverflow.com/a/58779/5852046
diff --git a/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunPublisher.cs b/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunPublisher.cs
index 9fbbb7de3..bde9f4618 100644
--- a/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunPublisher.cs
+++ b/src/BenchmarkDotNet/Toolchains/CoreRun/CoreRunPublisher.cs
@@ -51,10 +51,10 @@ namespace BenchmarkDotNet.Toolchains.CoreRun
                 var publishedVersionInfo = FileVersionInfo.GetVersionInfo(publishedDependency.FullName);
                 var coreRunVersionInfo = FileVersionInfo.GetVersionInfo(coreRunDependency.FullName);
 
-                if(!Version.TryParse(publishedVersionInfo.FileVersion, out var publishedVersion) || !Version.TryParse(coreRunVersionInfo.FileVersion, out var coreRunVersion))
+                if (!Version.TryParse(publishedVersionInfo.FileVersion, out var publishedVersion) || !Version.TryParse(coreRunVersionInfo.FileVersion, out var coreRunVersion))
                     continue;
 
-                if(publishedVersion > coreRunVersion)
+                if (publishedVersion > coreRunVersion)
                 {
                     File.Copy(publishedDependency.FullName, coreRunDependency.FullName, overwrite: true); // we need to overwrite old things with their newer versions
 
diff --git a/src/BenchmarkDotNet/Toolchains/CsProj/CsProjGenerator.cs b/src/BenchmarkDotNet/Toolchains/CsProj/CsProjGenerator.cs
index 1feacffc5..8de5a140e 100644
--- a/src/BenchmarkDotNet/Toolchains/CsProj/CsProjGenerator.cs
+++ b/src/BenchmarkDotNet/Toolchains/CsProj/CsProjGenerator.cs
@@ -92,7 +92,7 @@ namespace BenchmarkDotNet.Toolchains.CsProj
 
         // the host project or one of the .props file that it imports might contain some custom settings that needs to be copied, sth like
         // <NetCoreAppImplicitPackageVersion>2.0.0-beta-001607-00</NetCoreAppImplicitPackageVersion>
-	    // <RuntimeFrameworkVersion>2.0.0-beta-001607-00</RuntimeFrameworkVersion>
+        // <RuntimeFrameworkVersion>2.0.0-beta-001607-00</RuntimeFrameworkVersion>
         internal (string customProperties, string sdkName) GetSettingsThatNeedsToBeCopied(TextReader streamReader, FileInfo projectFile)
         {
             if (!string.IsNullOrEmpty(RuntimeFrameworkVersion)) // some power users knows what to configure, just do it and copy nothing more
diff --git a/src/BenchmarkDotNet/Toolchains/DotNetCli/CustomDotNetCliToolchainBuilder.cs b/src/BenchmarkDotNet/Toolchains/DotNetCli/CustomDotNetCliToolchainBuilder.cs
index cef85cb9a..916d6ad04 100644
--- a/src/BenchmarkDotNet/Toolchains/DotNetCli/CustomDotNetCliToolchainBuilder.cs
+++ b/src/BenchmarkDotNet/Toolchains/DotNetCli/CustomDotNetCliToolchainBuilder.cs
@@ -50,6 +50,7 @@ namespace BenchmarkDotNet.Toolchains.DotNetCli
 
         /// <param name="targetFrameworkMoniker">TFM, example: netcoreapp2.1</param>
         [PublicAPI]
+        [SuppressMessage("ReSharper", "ParameterHidesMember")]
         public CustomDotNetCliToolchainBuilder TargetFrameworkMoniker(string targetFrameworkMoniker)
         {
             this.targetFrameworkMoniker = targetFrameworkMoniker ?? throw new ArgumentNullException(nameof(targetFrameworkMoniker));
@@ -124,6 +125,7 @@ namespace BenchmarkDotNet.Toolchains.DotNetCli
         /// sets provided timeout for build
         /// </summary>
         [PublicAPI]
+        [SuppressMessage("ReSharper", "ParameterHidesMember")]
         public CustomDotNetCliToolchainBuilder Timeout(TimeSpan timeout)
         {
             this.timeout = timeout;
diff --git a/src/BenchmarkDotNet/Toolchains/DotNetCli/DotNetCliGenerator.cs b/src/BenchmarkDotNet/Toolchains/DotNetCli/DotNetCliGenerator.cs
index efd6c4d71..5381ede2e 100644
--- a/src/BenchmarkDotNet/Toolchains/DotNetCli/DotNetCliGenerator.cs
+++ b/src/BenchmarkDotNet/Toolchains/DotNetCli/DotNetCliGenerator.cs
@@ -101,7 +101,7 @@ namespace BenchmarkDotNet.Toolchains.DotNetCli
             => directoryInfo
                 .GetFileSystemInfos()
                 .Any(fileInfo => fileInfo.Extension == ".sln" || fileInfo.Name == "global.json");
-        
+
         private static bool IsRootProjectFolder(DirectoryInfo directoryInfo)
             => directoryInfo
                 .GetFileSystemInfos()
diff --git a/src/BenchmarkDotNet/Toolchains/DotNetCli/MsBuildErrorMapper.cs b/src/BenchmarkDotNet/Toolchains/DotNetCli/MsBuildErrorMapper.cs
index 4e9a1f406..5565fee87 100644
--- a/src/BenchmarkDotNet/Toolchains/DotNetCli/MsBuildErrorMapper.cs
+++ b/src/BenchmarkDotNet/Toolchains/DotNetCli/MsBuildErrorMapper.cs
@@ -7,7 +7,7 @@ namespace BenchmarkDotNet.Toolchains.DotNetCli
 {
     internal static class MsBuildErrorMapper
     {
-        private static readonly (Regex regex, Func<Match, string> translation)[] rules = new (Regex rule, Func<Match, string> translation)[]
+        private static readonly (Regex regex, Func<Match, string> translation)[] Rules = new (Regex rule, Func<Match, string> translation)[]
         {
             (
                 new Regex("warning NU1702: ProjectReference '(.*)' was resolved using '(.*)' instead of the project target framework '(.*)'. This project may not be fully compatible with your project.",
@@ -40,7 +40,7 @@ namespace BenchmarkDotNet.Toolchains.DotNetCli
             }
 
             foreach (var errorLine in buildResult.ErrorMessage.Split('\r', '\n').Where(line => !string.IsNullOrEmpty(line)))
-            foreach (var rule in rules)
+            foreach (var rule in Rules)
             {
                 var match = rule.regex.Match(errorLine);
                 if (match.Success)
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitExecutor.cs b/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitExecutor.cs
index e979dadbd..e9bf492c2 100644
--- a/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitExecutor.cs
+++ b/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitExecutor.cs
@@ -76,8 +76,7 @@ namespace BenchmarkDotNet.Toolchains.InProcess.Emit
 
             return GetExecutionResult(
                 host.RunResults,
-                exitCode,
-                executeParameters.Logger);
+                exitCode);
         }
 
         private int ExecuteCore(IHost host, ExecuteParameters parameters)
@@ -127,7 +126,7 @@ namespace BenchmarkDotNet.Toolchains.InProcess.Emit
             return exitCode;
         }
 
-        private ExecuteResult GetExecutionResult(RunResults runResults, int exitCode, ILogger logger)
+        private ExecuteResult GetExecutionResult(RunResults runResults, int exitCode)
         {
             if (exitCode != 0)
             {
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitGenerator.cs b/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitGenerator.cs
index c40e04189..c169c9190 100644
--- a/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitGenerator.cs
+++ b/src/BenchmarkDotNet/Toolchains/InProcess.Emit/InProcessEmitGenerator.cs
@@ -8,56 +8,53 @@ using System.IO;
 
 namespace BenchmarkDotNet.Toolchains.InProcess.Emit
 {
-	public class InProcessEmitGenerator : IGenerator
-	{
-		public GenerateResult GenerateProject(
-			BuildPartition buildPartition,
-			ILogger logger,
-			string rootArtifactsFolderPath)
-		{
-			var artifactsPaths = ArtifactsPaths.Empty;
-			try
-			{
-				artifactsPaths = GetArtifactsPaths(buildPartition, rootArtifactsFolderPath);
+    public class InProcessEmitGenerator : IGenerator
+    {
+        public GenerateResult GenerateProject(
+            BuildPartition buildPartition,
+            ILogger logger,
+            string rootArtifactsFolderPath)
+        {
+            var artifactsPaths = ArtifactsPaths.Empty;
+            try
+            {
+                artifactsPaths = GetArtifactsPaths(buildPartition, rootArtifactsFolderPath);
 
-				return GenerateResult.Success(artifactsPaths, new List<string>());
-			}
-			catch (Exception ex)
-			{
-				logger.WriteLineError($"Failed to generate partition: {ex}");
-				return GenerateResult.Failure(artifactsPaths, new List<string>());
-			}
-		}
+                return GenerateResult.Success(artifactsPaths, new List<string>());
+            }
+            catch (Exception ex)
+            {
+                logger.WriteLineError($"Failed to generate partition: {ex}");
+                return GenerateResult.Failure(artifactsPaths, new List<string>());
+            }
+        }
 
-		private string GetBinariesDirectoryPath(string buildArtifactsDirectoryPath, string configuration) =>
-			buildArtifactsDirectoryPath;
+        private string GetBinariesDirectoryPath(string buildArtifactsDirectoryPath) => buildArtifactsDirectoryPath;
 
-		private string GetExecutableExtension() => ".dll";
+        private string GetExecutableExtension() => ".dll";
 
-		private string GetBuildArtifactsDirectoryPath(
-			BuildPartition buildPartition, string programName) =>
-			Path.GetDirectoryName(buildPartition.AssemblyLocation);
+        private string GetBuildArtifactsDirectoryPath(BuildPartition buildPartition) => Path.GetDirectoryName(buildPartition.AssemblyLocation);
 
-		private ArtifactsPaths GetArtifactsPaths(BuildPartition buildPartition, string rootArtifactsFolderPath)
-		{
-			string programName = buildPartition.ProgramName + RunnableConstants.DynamicAssemblySuffix;
-			string buildArtifactsDirectoryPath = GetBuildArtifactsDirectoryPath(buildPartition, programName);
-			string binariesDirectoryPath =
-				GetBinariesDirectoryPath(buildArtifactsDirectoryPath, buildPartition.BuildConfiguration);
-			string executablePath = Path.Combine(binariesDirectoryPath, $"{programName}{GetExecutableExtension()}");
+        private ArtifactsPaths GetArtifactsPaths(BuildPartition buildPartition, string rootArtifactsFolderPath)
+        {
+            string programName = buildPartition.ProgramName + RunnableConstants.DynamicAssemblySuffix;
+            string buildArtifactsDirectoryPath = GetBuildArtifactsDirectoryPath(buildPartition);
+            string binariesDirectoryPath =
+                GetBinariesDirectoryPath(buildArtifactsDirectoryPath);
+            string executablePath = Path.Combine(binariesDirectoryPath, $"{programName}{GetExecutableExtension()}");
 
-			return new ArtifactsPaths(
-				rootArtifactsFolderPath: rootArtifactsFolderPath,
-				buildArtifactsDirectoryPath: buildArtifactsDirectoryPath,
-				binariesDirectoryPath: binariesDirectoryPath,
-				programCodePath: null,
-				appConfigPath: null,
-				nuGetConfigPath: null,
-				projectFilePath: null,
-				buildScriptFilePath: null,
-				executablePath: executablePath,
-				programName: programName,
-				packagesDirectoryName: null);
-		}
-	}
+            return new ArtifactsPaths(
+                rootArtifactsFolderPath: rootArtifactsFolderPath,
+                buildArtifactsDirectoryPath: buildArtifactsDirectoryPath,
+                binariesDirectoryPath: binariesDirectoryPath,
+                programCodePath: null,
+                appConfigPath: null,
+                nuGetConfigPath: null,
+                projectFilePath: null,
+                buildScriptFilePath: null,
+                executablePath: executablePath,
+                programName: programName,
+                packagesDirectoryName: null);
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/BenchmarkDotNet/Toolchains/InProcess/InProcessExecutor.cs b/src/BenchmarkDotNet/Toolchains/InProcess/InProcessExecutor.cs
index 176cc61c6..224e2edad 100644
--- a/src/BenchmarkDotNet/Toolchains/InProcess/InProcessExecutor.cs
+++ b/src/BenchmarkDotNet/Toolchains/InProcess/InProcessExecutor.cs
@@ -78,7 +78,7 @@ namespace BenchmarkDotNet.Toolchains.InProcess
                     $"Benchmark {executeParameters.BenchmarkCase.DisplayInfo} takes too long to run. " +
                     "Prefer to use out-of-process toolchains for long-running benchmarks.");
 
-            return GetExecutionResult(host.RunResults, exitCode, executeParameters.Logger);
+            return GetExecutionResult(host.RunResults, exitCode);
         }
 
         private int ExecuteCore(IHost host, ExecuteParameters parameters)
@@ -121,7 +121,7 @@ namespace BenchmarkDotNet.Toolchains.InProcess
             return exitCode;
         }
 
-        private ExecuteResult GetExecutionResult(RunResults runResults, int exitCode, ILogger logger)
+        private ExecuteResult GetExecutionResult(RunResults runResults, int exitCode)
         {
             if (exitCode != 0)
             {
diff --git a/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs b/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs
index 8d260c3bb..1525883bf 100644
--- a/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs
+++ b/src/BenchmarkDotNet/Toolchains/ToolchainExtensions.cs
@@ -39,7 +39,7 @@ namespace BenchmarkDotNet.Toolchains
                     return RoslynToolchain.Instance;
 
                 case MonoRuntime mono:
-                    if(!string.IsNullOrEmpty(mono.AotArgs))
+                    if (!string.IsNullOrEmpty(mono.AotArgs))
                         return MonoAotToolchain.Instance;
 
                     return RoslynToolchain.Instance;
diff --git a/src/BenchmarkDotNet/Validators/CompilationValidator.cs b/src/BenchmarkDotNet/Validators/CompilationValidator.cs
index 5fc72e9dc..d8c2ec6c5 100644
--- a/src/BenchmarkDotNet/Validators/CompilationValidator.cs
+++ b/src/BenchmarkDotNet/Validators/CompilationValidator.cs
@@ -83,7 +83,7 @@ namespace BenchmarkDotNet.Validators
             return from memberInfo in memberInfos
                            where memberInfo.Name.EndsWith("Keyword")
                            orderby memberInfo.Name
-                           select memberInfo.Name.Substring(startIndex: 0, length: memberInfo.Name.IndexOf("Keyword")).ToLower();
+                           select memberInfo.Name.Substring(startIndex: 0, length: memberInfo.Name.IndexOf("Keyword", StringComparison.Ordinal)).ToLower();
         }
 
         private class BenchmarkMethodEqualityComparer : IEqualityComparer<BenchmarkCase>
diff --git a/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs b/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs
index f146bd72a..b774031de 100644
--- a/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs
+++ b/src/BenchmarkDotNet/Validators/ParamsAllValuesValidator.cs
@@ -7,7 +7,7 @@ using BenchmarkDotNet.Extensions;
 
 namespace BenchmarkDotNet.Validators
 {
-    class ParamsAllValuesValidator : IValidator
+    public class ParamsAllValuesValidator : IValidator
     {
         public static readonly ParamsAllValuesValidator FailOnError = new ParamsAllValuesValidator();
 
@@ -15,13 +15,13 @@ namespace BenchmarkDotNet.Validators
 
         private ParamsAllValuesValidator() { }
 
-        private const BindingFlags reflectionFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
+        private const BindingFlags ReflectionFlags = BindingFlags.Static | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
 
         public IEnumerable<ValidationError> Validate(ValidationParameters input) =>
             input.Benchmarks
                 .Select(benchmark => benchmark.Descriptor.Type)
                 .Distinct()
-                .SelectMany(type => type.GetTypeMembersWithGivenAttribute<ParamsAllValuesAttribute>(reflectionFlags))
+                .SelectMany(type => type.GetTypeMembersWithGivenAttribute<ParamsAllValuesAttribute>(ReflectionFlags))
                 .Distinct()
                 .Select(member => GetErrorOrDefault(member.ParameterType))
                 .Where(error => error != null);
diff --git a/tests/BenchmarkDotNet.IntegrationTests.CustomPaths/BenchmarksThatUsesFileFromOutput.cs b/tests/BenchmarkDotNet.IntegrationTests.CustomPaths/BenchmarksThatUsesFileFromOutput.cs
index c091d0ff7..ec6305d89 100644
--- a/tests/BenchmarkDotNet.IntegrationTests.CustomPaths/BenchmarksThatUsesFileFromOutput.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests.CustomPaths/BenchmarksThatUsesFileFromOutput.cs
@@ -9,7 +9,7 @@ namespace BenchmarkDotNet.IntegrationTests.CustomPaths
         [Benchmark]
         public void Verify()
         {
-            if(!File.Exists(Path.Combine(Directory.GetCurrentDirectory(), "ShouldGetCopied.xml")))
+            if (!File.Exists(Path.Combine(Directory.GetCurrentDirectory(), "ShouldGetCopied.xml")))
             {
                 throw new InvalidOperationException("the file did not get copied");
             }
diff --git a/tests/BenchmarkDotNet.IntegrationTests.ManualRunning/LocalCoreRtToolchainTests.cs b/tests/BenchmarkDotNet.IntegrationTests.ManualRunning/LocalCoreRtToolchainTests.cs
index 124963cca..88d5f96e4 100644
--- a/tests/BenchmarkDotNet.IntegrationTests.ManualRunning/LocalCoreRtToolchainTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests.ManualRunning/LocalCoreRtToolchainTests.cs
@@ -54,7 +54,7 @@ namespace BenchmarkDotNet.IntegrationTests.ManualRunning
         }
     }
 
-    [KeepBenchmarkFiles()]
+    [KeepBenchmarkFiles]
     public class CoreRtBenchmark
     {
         [Benchmark]
diff --git a/tests/BenchmarkDotNet.IntegrationTests/AttributesTests.cs b/tests/BenchmarkDotNet.IntegrationTests/AttributesTests.cs
index d34ead3bf..25c1e449c 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/AttributesTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/AttributesTests.cs
@@ -17,8 +17,8 @@ namespace BenchmarkDotNet.IntegrationTests
 
         public class ConsumingCustomAttributes
         {
-            const int ExpectedNumber = 123;
-            const string ExpectedText = "expectedTest";
+            private const int ExpectedNumber = 123;
+            private const string ExpectedText = "expectedTest";
 
             [CustomParams(ExpectedNumber)]
             public int Number;
@@ -34,18 +34,18 @@ namespace BenchmarkDotNet.IntegrationTests
             [CustomBenchmark]
             public void Benchmark()
             {
-                if(ExpectedNumber != Number || ExpectedText != Text)
+                if (ExpectedNumber != Number || ExpectedText != Text)
                     throw new Exception("Custom attributes were not applied!");
             }
         }
 
-        class CustomParamsAttribute : ParamsAttribute
+        private class CustomParamsAttribute : ParamsAttribute
         {
             public CustomParamsAttribute(params object[] values) : base(values) { }
         }
 
-        class CustomBenchmarkAttribute : BenchmarkAttribute { }
+        private class CustomBenchmarkAttribute : BenchmarkAttribute { }
 
-        class CustomGlobalSetupAttribute : GlobalSetupAttribute { }
+        private class CustomGlobalSetupAttribute : GlobalSetupAttribute { }
     }
 }
\ No newline at end of file
diff --git a/tests/BenchmarkDotNet.IntegrationTests/BenchmarkDotNet.IntegrationTests.csproj b/tests/BenchmarkDotNet.IntegrationTests/BenchmarkDotNet.IntegrationTests.csproj
index a6d0c17ad..d3a7f2ad5 100755
--- a/tests/BenchmarkDotNet.IntegrationTests/BenchmarkDotNet.IntegrationTests.csproj
+++ b/tests/BenchmarkDotNet.IntegrationTests/BenchmarkDotNet.IntegrationTests.csproj
@@ -11,6 +11,7 @@
     <PlatformTarget>AnyCPU</PlatformTarget>
     <DebugType>pdbonly</DebugType>
     <DebugSymbols>true</DebugSymbols>
+    <NoWarn>$(NoWarn);CA2007</NoWarn>
   </PropertyGroup>
   <ItemGroup>
     <Content Include="xunit.runner.json">
diff --git a/tests/BenchmarkDotNet.IntegrationTests/BenchmarkSwitcherTest.cs b/tests/BenchmarkDotNet.IntegrationTests/BenchmarkSwitcherTest.cs
index 068b9e28a..f7dc6e7c0 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/BenchmarkSwitcherTest.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/BenchmarkSwitcherTest.cs
@@ -60,7 +60,7 @@ namespace BenchmarkDotNet.IntegrationTests
             var config = ManualConfig.CreateEmpty().AddLogger(logger);
 
             var summaries = BenchmarkSwitcher
-                .FromTypes(new [] { typeof(ClassC) })
+                .FromTypes(new[] { typeof(ClassC) })
                 .Run(new[] { "--filter", "*" }, config);
 
             Assert.Empty(summaries);
@@ -89,7 +89,7 @@ namespace BenchmarkDotNet.IntegrationTests
 
             const string filter = "WRONG";
             var summaries = BenchmarkSwitcher
-                .FromTypes(new [] { typeof(ClassA), typeof(ClassB) })
+                .FromTypes(new[] { typeof(ClassA), typeof(ClassB) })
                 .Run(new[] { "--filter", filter }, config);
 
             Assert.Empty(summaries);
@@ -103,7 +103,7 @@ namespace BenchmarkDotNet.IntegrationTests
             var config = ManualConfig.CreateEmpty().AddLogger(logger);
 
             var summaries = BenchmarkSwitcher
-                .FromTypes(new [] { typeof(ClassA) })
+                .FromTypes(new[] { typeof(ClassA) })
                 .Run(new[] { "--list", "flat" }, config);
 
             Assert.Empty(summaries);
@@ -118,7 +118,7 @@ namespace BenchmarkDotNet.IntegrationTests
             var config = ManualConfig.CreateEmpty().AddLogger(logger);
 
             var summaries = BenchmarkSwitcher
-                .FromTypes(new [] { typeof(ClassA) })
+                .FromTypes(new[] { typeof(ClassA) })
                 .Run(new[] { "--list", "flat", "--filter", "*.Method1" }, config);
 
             Assert.Empty(summaries);
@@ -187,7 +187,7 @@ namespace BenchmarkDotNet.IntegrationTests
             var userInteractionMock = new UserInteractionMock(returnValue: Array.Empty<Type>());
 
             var summaries = new BenchmarkSwitcher(userInteractionMock)
-                .With(new [] { typeof(WithDryAttributeAndCategory) })
+                .With(new[] { typeof(WithDryAttributeAndCategory) })
                 .Run(Array.Empty<string>(), config);
 
             Assert.Empty(summaries); // summaries is empty because the returnValue configured for mock returns 0 types
@@ -206,7 +206,7 @@ namespace BenchmarkDotNet.IntegrationTests
 
             var summaries = new BenchmarkSwitcher(userInteractionMock)
                 .With(types)
-                .Run(new [] { categoriesConsoleLineArgument, TestCategory }, config);
+                .Run(new[] { categoriesConsoleLineArgument, TestCategory }, config);
 
             Assert.Single(summaries);
             Assert.Equal(0, userInteractionMock.AskUserCalledTimes);
@@ -224,7 +224,7 @@ namespace BenchmarkDotNet.IntegrationTests
 
             var summaries = new BenchmarkSwitcher(userInteractionMock)
                 .With(types)
-                .Run(new [] { categoriesConsoleLineArgument, TestCategory, "--filter", "nothing" }, config);
+                .Run(new[] { categoriesConsoleLineArgument, TestCategory, "--filter", "nothing" }, config);
 
             Assert.Empty(summaries); // the summaries is empty because the provided filter returns nothing
             Assert.Equal(0, userInteractionMock.AskUserCalledTimes);
diff --git a/tests/BenchmarkDotNet.IntegrationTests/CustomEngineTests.cs b/tests/BenchmarkDotNet.IntegrationTests/CustomEngineTests.cs
index 4bcf5e27a..b1e268673 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/CustomEngineTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/CustomEngineTests.cs
@@ -9,7 +9,6 @@ using BenchmarkDotNet.Jobs;
 using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Characteristics;
-using BenchmarkDotNet.Mathematics;
 using Perfolizer.Mathematics.OutlierDetection;
 
 namespace BenchmarkDotNet.IntegrationTests
diff --git a/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/ProcessMetricsTests.cs b/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/ProcessMetricsTests.cs
index 3a7c096f8..7223a7c6b 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/ProcessMetricsTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/Diagnosers/ProcessMetricsTests.cs
@@ -64,7 +64,7 @@ namespace BenchmarkDotNet.IntegrationTests.Diagnosers
 
             var metrics = sut.CalculateMetrics(
                 new Dictionary<int, int> { {profileSourceId, interval }},
-                new []{ new PreciseMachineCounter(profileSourceId, "test", HardwareCounter.InstructionRetired, interval), });
+                new[]{ new PreciseMachineCounter(profileSourceId, "test", HardwareCounter.InstructionRetired, interval), });
 
             const ulong expected = (4 * interval - interval) / totalOperations; // every workload was 4 events, the overhead was one and totalOperations times per iteration
 
diff --git a/tests/BenchmarkDotNet.IntegrationTests/EnvironmentVariablesTests.cs b/tests/BenchmarkDotNet.IntegrationTests/EnvironmentVariablesTests.cs
index f04c24e24..945502a90 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/EnvironmentVariablesTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/EnvironmentVariablesTests.cs
@@ -18,7 +18,7 @@ namespace BenchmarkDotNet.IntegrationTests
         [Fact]
         public void UserCanSpecifyEnvironmentVariables()
         {
-            var variables = new [] { new EnvironmentVariable(Key, Value) };
+            var variables = new[] { new EnvironmentVariable(Key, Value) };
             var jobWithCustomConfiguration = Job.Dry.WithEnvironmentVariables(variables);
             var config = CreateSimpleConfig(job: jobWithCustomConfiguration);
 
@@ -30,7 +30,7 @@ namespace BenchmarkDotNet.IntegrationTests
             [Benchmark]
             public void Benchmark()
             {
-                if(Environment.GetEnvironmentVariable(Key) != Value)
+                if (Environment.GetEnvironmentVariable(Key) != Value)
                     throw new InvalidOperationException("The env var was not set");
             }
         }
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ExporterIOTests.cs b/tests/BenchmarkDotNet.IntegrationTests/ExporterIOTests.cs
index 6ba8a9bf9..a990ba20e 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/ExporterIOTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/ExporterIOTests.cs
@@ -5,7 +5,6 @@ using System.Linq;
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Exporters;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Reports;
 using BenchmarkDotNet.Running;
diff --git a/tests/BenchmarkDotNet.IntegrationTests/GcModeTests.cs b/tests/BenchmarkDotNet.IntegrationTests/GcModeTests.cs
index 2c03bed2e..a552f620a 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/GcModeTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/GcModeTests.cs
@@ -131,8 +131,8 @@ namespace BenchmarkDotNet.IntegrationTests
 
     public class AvoidForcingGarbageCollection
     {
-        int initialCollectionCountGen1;
-        int initialCollectionCountGen2;
+        private int initialCollectionCountGen1;
+        private int initialCollectionCountGen2;
 
         [GlobalSetup]
         public void GlobalSetup()
diff --git a/tests/BenchmarkDotNet.IntegrationTests/InProcess.EmitTests/Runnable_0.cs b/tests/BenchmarkDotNet.IntegrationTests/InProcess.EmitTests/Runnable_0.cs
index 1965ccd59..4fe4fd8a2 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/InProcess.EmitTests/Runnable_0.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/InProcess.EmitTests/Runnable_0.cs
@@ -1,6 +1,4 @@
-
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Engines;
+using BenchmarkDotNet.Engines;
 using BenchmarkDotNet.Running;
 using BenchmarkDotNet.Toolchains.InProcess.Emit.Implementation;
 
diff --git a/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs b/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs
index 1660f1d54..89120e84c 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/InProcessTest.cs
@@ -17,6 +17,8 @@ using JetBrains.Annotations;
 using Xunit;
 using Xunit.Abstractions;
 
+#pragma warning disable CS0618
+
 namespace BenchmarkDotNet.IntegrationTests
 {
     public class InProcessTest : BenchmarkTestExecutor
diff --git a/tests/BenchmarkDotNet.IntegrationTests/JitRuntimeValidationTest.cs b/tests/BenchmarkDotNet.IntegrationTests/JitRuntimeValidationTest.cs
index 5abef3c25..f65ef9c69 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/JitRuntimeValidationTest.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/JitRuntimeValidationTest.cs
@@ -30,7 +30,7 @@ namespace BenchmarkDotNet.IntegrationTests
         }
 
         private const string OkCaption = "// OkCaption";
-        private const string LegacyJitNotAvailableForMono = "// ERROR:  LegacyJIT is requested but it is not available for Mono";
+        // private const string LegacyJitNotAvailableForMono = "// ERROR:  LegacyJIT is requested but it is not available for Mono";
         private const string RyuJitNotAvailable = "// ERROR:  RyuJIT is requested but it is not available in current environment";
         private const string ToolchainSupportsOnlyRyuJit = "Currently dotnet cli toolchain supports only RyuJit";
 
diff --git a/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs b/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
index 5c3c1711c..d7b5259f2 100755
--- a/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/MemoryDiagnoserTests.cs
@@ -63,7 +63,7 @@ namespace BenchmarkDotNet.IntegrationTests
             AssertAllocations(toolchain, typeof(AccurateAllocations), new Dictionary<string, long>
             {
                 { nameof(AccurateAllocations.EightBytesArray), 8 + objectAllocationOverhead + arraySizeOverhead },
-                { nameof(AccurateAllocations.SixtyFourBytesArray), 64 + + objectAllocationOverhead + arraySizeOverhead },
+                { nameof(AccurateAllocations.SixtyFourBytesArray), 64 + objectAllocationOverhead + arraySizeOverhead },
 
                 { nameof(AccurateAllocations.AllocateTask), CalculateRequiredSpace<Task<int>>() },
             });
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ParamsTests.cs b/tests/BenchmarkDotNet.IntegrationTests/ParamsTests.cs
index dd3583662..23a4a5222 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/ParamsTests.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/ParamsTests.cs
@@ -162,7 +162,7 @@ namespace BenchmarkDotNet.IntegrationTests
             [Benchmark]
             public void Benchmark()
             {
-                if(Field != null) { throw new Exception("Field should be initialized in ctor with 1 and then set to null by Engine"); }
+                if (Field != null) { throw new Exception("Field should be initialized in ctor with 1 and then set to null by Engine"); }
             }
         }
 
@@ -212,7 +212,7 @@ namespace BenchmarkDotNet.IntegrationTests
                     throw new InvalidOperationException("Incorrect array length");
 
                 for (int i = 0; i < 3; i++)
-                    if(Array[i] != i)
+                    if (Array[i] != i)
                         throw new InvalidOperationException($"Incorrect array element at index {i}, was {Array[i]} instead of {i}");
             }
         }
diff --git a/tests/BenchmarkDotNet.IntegrationTests/ProcessorArchitectureTest.cs b/tests/BenchmarkDotNet.IntegrationTests/ProcessorArchitectureTest.cs
index 6c0860a74..091e3f87e 100644
--- a/tests/BenchmarkDotNet.IntegrationTests/ProcessorArchitectureTest.cs
+++ b/tests/BenchmarkDotNet.IntegrationTests/ProcessorArchitectureTest.cs
@@ -1,6 +1,5 @@
 using System;
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
@@ -12,11 +11,11 @@ namespace BenchmarkDotNet.IntegrationTests
 {
     public class ProcessorArchitectureTest : BenchmarkTestExecutor
     {
-        const string X86FailedCaption = "// x86FAILED";
-        const string X64FailedCaption = "// x64FAILED";
-        const string AnyCpuOkCaption = "// AnyCpuOkCaption";
-        const string HostPlatformOkCaption = "// HostPlatformOkCaption";
-        const string BenchmarkNotFound = "// There are no benchmarks found";
+        private const string X86FailedCaption = "// x86FAILED";
+        private const string X64FailedCaption = "// x64FAILED";
+        private const string AnyCpuOkCaption = "// AnyCpuOkCaption";
+        private const string HostPlatformOkCaption = "// HostPlatformOkCaption";
+        private const string BenchmarkNotFound = "// There are no benchmarks found";
 
         public ProcessorArchitectureTest(ITestOutputHelper outputHelper) : base(outputHelper)
         {
diff --git a/tests/BenchmarkDotNet.Tests/Analysers/ZeroMeasurementHelperTests.cs b/tests/BenchmarkDotNet.Tests/Analysers/ZeroMeasurementHelperTests.cs
index 2750fabb9..d0bcb15ca 100644
--- a/tests/BenchmarkDotNet.Tests/Analysers/ZeroMeasurementHelperTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Analysers/ZeroMeasurementHelperTests.cs
@@ -115,14 +115,14 @@ namespace BenchmarkDotNet.Tests.Analysers
             {
                 return new[]
                 {
-                    new object[] { new [] { 2.0037, 2.0062, 2.0066, 2.0073, 2.0089, 2.0103, 2.013, 2.0169, 2.0197, 2.0224, 2.0243, 2.0271, 2.0281, 2.0514, 2.0517 },
-                                   new [] { 2.0426, 2.046, 2.0471, 2.0506, 2.0508, 2.0555, 2.0573, 2.0653, 2.0657, 2.0659, 2.0692, 2.0717, 2.0777, 2.0856, 2.0868 } },
+                    new object[] { new[] { 2.0037, 2.0062, 2.0066, 2.0073, 2.0089, 2.0103, 2.013, 2.0169, 2.0197, 2.0224, 2.0243, 2.0271, 2.0281, 2.0514, 2.0517 },
+                                   new[] { 2.0426, 2.046, 2.0471, 2.0506, 2.0508, 2.0555, 2.0573, 2.0653, 2.0657, 2.0659, 2.0692, 2.0717, 2.0777, 2.0856, 2.0868 } },
 
-                    new object[] { new [] { 2.0186, 2.0196, 2.0207, 2.0208, 2.0208, 2.0211, 2.0213, 2.0215, 2.0288, 2.0315, 2.0326, 2.039, 2.049, 2.055, 2.0598 },
-                                   new [] { 2.0151, 2.0192, 2.0226, 2.0248, 2.0271, 2.0276, 2.0298, 2.0339, 2.0411, 2.0429, 2.0458, 2.0501, 2.061, 2.0733, 2.0744 } },
+                    new object[] { new[] { 2.0186, 2.0196, 2.0207, 2.0208, 2.0208, 2.0211, 2.0213, 2.0215, 2.0288, 2.0315, 2.0326, 2.039, 2.049, 2.055, 2.0598 },
+                                   new[] { 2.0151, 2.0192, 2.0226, 2.0248, 2.0271, 2.0276, 2.0298, 2.0339, 2.0411, 2.0429, 2.0458, 2.0501, 2.061, 2.0733, 2.0744 } },
 
-                    new object[] { new [] { 2.0049, 2.0141, 2.0194, 2.0253, 2.0264, 2.0296, 2.0333, 2.0422, 2.0438, 2.044, 2.047, 2.048, 2.0494, 2.0549, 2.0675 },
-                                   new [] { 1.9963, 2.0037, 2.0037, 2.0046, 2.0051, 2.007, 2.0166, 2.021, 2.0225, 2.0247, 2.0391, 2.0473, 2.0572, 2.0576, 2.0582 } }
+                    new object[] { new[] { 2.0049, 2.0141, 2.0194, 2.0253, 2.0264, 2.0296, 2.0333, 2.0422, 2.0438, 2.044, 2.047, 2.048, 2.0494, 2.0549, 2.0675 },
+                                   new[] { 1.9963, 2.0037, 2.0037, 2.0046, 2.0051, 2.007, 2.0166, 2.021, 2.0225, 2.0247, 2.0391, 2.0473, 2.0572, 2.0576, 2.0582 } }
                 };
             }
         }
@@ -153,14 +153,14 @@ namespace BenchmarkDotNet.Tests.Analysers
             {
                 return new[]
                 {
-                    new object[] { new [] { 2.34763, 2.34861, 2.34872, 2.34953, 2.35002, 2.35614, 2.35650, 2.36323, 2.36941, 2.37376, 2.38491, 2.38619, 2.38657, 2.38902, 2.39455 },
-                                   new [] { 2.05899, 2.06069, 2.06243, 2.06405, 2.06762, 2.06785, 2.06889, 2.06891, 2.06895, 2.07531, 2.08003, 2.08024, 2.08342, 2.08959 } },
+                    new object[] { new[] { 2.34763, 2.34861, 2.34872, 2.34953, 2.35002, 2.35614, 2.35650, 2.36323, 2.36941, 2.37376, 2.38491, 2.38619, 2.38657, 2.38902, 2.39455 },
+                                   new[] { 2.05899, 2.06069, 2.06243, 2.06405, 2.06762, 2.06785, 2.06889, 2.06891, 2.06895, 2.07531, 2.08003, 2.08024, 2.08342, 2.08959 } },
 
-                    new object[] { new [] { 2.36960, 2.37438, 2.37442, 2.38332, 2.38940, 2.39099, 2.39394, 2.39974, 2.40808, 2.41760, 2.41980, 2.42275, 2.42828, 2.42946, 2.43763 },
-                                   new [] { 2.06486, 2.06599, 2.07205, 2.07660, 2.07810, 2.07841, 2.08107, 2.08714, 2.10467, 2.10469, 2.11713, 2.12078, 2.12476, 2.12858, 2.13760 } },
+                    new object[] { new[] { 2.36960, 2.37438, 2.37442, 2.38332, 2.38940, 2.39099, 2.39394, 2.39974, 2.40808, 2.41760, 2.41980, 2.42275, 2.42828, 2.42946, 2.43763 },
+                                   new[] { 2.06486, 2.06599, 2.07205, 2.07660, 2.07810, 2.07841, 2.08107, 2.08714, 2.10467, 2.10469, 2.11713, 2.12078, 2.12476, 2.12858, 2.13760 } },
 
-                    new object[] { new [] { 2.35046, 2.35630, 2.35788, 2.35801, 2.36632, 2.36841, 2.36925, 2.36980, 2.36998, 2.37153, 2.37330, 2.38491, 2.38732, 2.38853, 2.41052 },
-                                   new [] { 2.06291, 2.06545, 2.06763, 2.07381, 2.07568, 2.07810, 2.07894, 2.08153, 2.08264, 2.09000, 2.09814, 2.10082, 2.10107, 2.10576, 2.12841 } }
+                    new object[] { new[] { 2.35046, 2.35630, 2.35788, 2.35801, 2.36632, 2.36841, 2.36925, 2.36980, 2.36998, 2.37153, 2.37330, 2.38491, 2.38732, 2.38853, 2.41052 },
+                                   new[] { 2.06291, 2.06545, 2.06763, 2.07381, 2.07568, 2.07810, 2.07894, 2.08153, 2.08264, 2.09000, 2.09814, 2.10082, 2.10107, 2.10576, 2.12841 } }
                 };
             }
         }
@@ -187,14 +187,14 @@ namespace BenchmarkDotNet.Tests.Analysers
             {
                 return new[]
                 {
-                    new object[] { new [] { 2.6561, 2.658, 2.6606, 2.6621, 2.6636, 2.6639, 2.6656, 2.6673, 2.6741, 2.6754, 2.6787, 2.6935, 2.6997, 2.7313, 2.7394 },
-                                   new [] { 2.0387, 2.0436, 2.0485, 2.0485, 2.0525, 2.0584, 2.0638, 2.0678, 2.0678, 2.0698, 2.0703, 2.0715, 2.0825, 2.0864 } },
+                    new object[] { new[] { 2.6561, 2.658, 2.6606, 2.6621, 2.6636, 2.6639, 2.6656, 2.6673, 2.6741, 2.6754, 2.6787, 2.6935, 2.6997, 2.7313, 2.7394 },
+                                   new[] { 2.0387, 2.0436, 2.0485, 2.0485, 2.0525, 2.0584, 2.0638, 2.0678, 2.0678, 2.0698, 2.0703, 2.0715, 2.0825, 2.0864 } },
 
-                    new object[] { new [] { 2.6368, 2.6504, 2.652, 2.6541, 2.6607, 2.6642, 2.6698, 2.6749, 2.679, 2.6847, 2.6858, 2.6883, 2.6929, 2.702, 2.7134 },
-                                   new [] { 2.04, 2.0461, 2.0481, 2.0485, 2.0502, 2.0523, 2.0547, 2.0602, 2.0613, 2.0677, 2.069, 2.0691, 2.0699, 2.0865 } },
+                    new object[] { new[] { 2.6368, 2.6504, 2.652, 2.6541, 2.6607, 2.6642, 2.6698, 2.6749, 2.679, 2.6847, 2.6858, 2.6883, 2.6929, 2.702, 2.7134 },
+                                   new[] { 2.04, 2.0461, 2.0481, 2.0485, 2.0502, 2.0523, 2.0547, 2.0602, 2.0613, 2.0677, 2.069, 2.0691, 2.0699, 2.0865 } },
 
-                    new object[] { new [] { 2.6607, 2.6691, 2.67, 2.6741, 2.6753, 2.679, 2.6856, 2.6869, 2.6893, 2.692, 2.6971, 2.7146, 2.7245, 2.7368 },
-                                   new [] { 2.0346, 2.054, 2.0655, 2.0673, 2.0718, 2.0748, 2.0766, 2.0839, 2.0856, 2.0869, 2.0924, 2.0968, 2.1129, 2.1148, 2.1328 } }
+                    new object[] { new[] { 2.6607, 2.6691, 2.67, 2.6741, 2.6753, 2.679, 2.6856, 2.6869, 2.6893, 2.692, 2.6971, 2.7146, 2.7245, 2.7368 },
+                                   new[] { 2.0346, 2.054, 2.0655, 2.0673, 2.0718, 2.0748, 2.0766, 2.0839, 2.0856, 2.0869, 2.0924, 2.0968, 2.1129, 2.1148, 2.1328 } }
                 };
             }
         }
diff --git a/tests/BenchmarkDotNet.Tests/Attributes/ParamsAllValuesApprovalTests.cs b/tests/BenchmarkDotNet.Tests/Attributes/ParamsAllValuesApprovalTests.cs
index 74e771784..55685fbd5 100644
--- a/tests/BenchmarkDotNet.Tests/Attributes/ParamsAllValuesApprovalTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Attributes/ParamsAllValuesApprovalTests.cs
@@ -7,7 +7,6 @@ using System.Threading;
 using ApprovalTests;
 using ApprovalTests.Namers;
 using ApprovalTests.Reporters;
-using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Tests.Mocks;
@@ -15,8 +14,6 @@ using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Validators;
 using JetBrains.Annotations;
 using Xunit;
-using System.Collections.Generic;
-using BenchmarkDotNet.Running;
 
 namespace BenchmarkDotNet.Tests.Attributes
 {
diff --git a/tests/BenchmarkDotNet.Tests/BenchmarkDotNet.Tests.csproj b/tests/BenchmarkDotNet.Tests/BenchmarkDotNet.Tests.csproj
index cbc9c6a00..e3c5bc169 100755
--- a/tests/BenchmarkDotNet.Tests/BenchmarkDotNet.Tests.csproj
+++ b/tests/BenchmarkDotNet.Tests/BenchmarkDotNet.Tests.csproj
@@ -7,6 +7,7 @@
     <PackageId>BenchmarkDotNet.Tests</PackageId>
     <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
     <GenerateDocumentationFile>false</GenerateDocumentationFile>
+    <NoWarn>$(NoWarn);NU1701;1701;CA1018;CA2007</NoWarn>
   </PropertyGroup>
   <ItemGroup>
     <Content Include="xunit.runner.json">
@@ -20,9 +21,6 @@
     <PackageReference Include="xunit" Version="2.4.1" />
     <PackageReference Include="ApprovalTests" Version="3.0.13" />
   </ItemGroup>
-  <PropertyGroup>
-    <NoWarn>NU1701;1701</NoWarn>
-  </PropertyGroup>
   <ItemGroup Condition=" '$(TargetFrameworkIdentifier)' == '.NETFramework' ">
     <ProjectReference Include="..\..\src\BenchmarkDotNet.Diagnostics.Windows\BenchmarkDotNet.Diagnostics.Windows.csproj" />
     <PackageReference Include="Microsoft.NETCore.Platforms" Version="2.2.0" />
diff --git a/tests/BenchmarkDotNet.Tests/ConfigParserTests.cs b/tests/BenchmarkDotNet.Tests/ConfigParserTests.cs
index 99ec77d7d..0f3c1d310 100644
--- a/tests/BenchmarkDotNet.Tests/ConfigParserTests.cs
+++ b/tests/BenchmarkDotNet.Tests/ConfigParserTests.cs
@@ -22,7 +22,6 @@ using BenchmarkDotNet.Toolchains.DotNetCli;
 using Xunit;
 using Xunit.Abstractions;
 using BenchmarkDotNet.Portability;
-using BenchmarkDotNet.Extensions;
 using Perfolizer.Horology;
 using Perfolizer.Mathematics.SignificanceTesting;
 using Perfolizer.Mathematics.Thresholds;
diff --git a/tests/BenchmarkDotNet.Tests/Configs/EnvironmentVariableTests.cs b/tests/BenchmarkDotNet.Tests/Configs/EnvironmentVariableTests.cs
index 94acf2a2e..470623944 100644
--- a/tests/BenchmarkDotNet.Tests/Configs/EnvironmentVariableTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Configs/EnvironmentVariableTests.cs
@@ -22,7 +22,7 @@ namespace BenchmarkDotNet.Tests.Configs
             Assert.Throws<InvalidOperationException>(() =>
             {
                 new Job().WithEnvironmentVariables(
-                    new EnvironmentVariable("a", "b"), 
+                    new EnvironmentVariable("a", "b"),
                     new EnvironmentVariable("a", "c"));
             });
         }
diff --git a/tests/BenchmarkDotNet.Tests/Configs/ImmutableConfigTests.cs b/tests/BenchmarkDotNet.Tests/Configs/ImmutableConfigTests.cs
index 087981038..df068ac50 100644
--- a/tests/BenchmarkDotNet.Tests/Configs/ImmutableConfigTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Configs/ImmutableConfigTests.cs
@@ -150,7 +150,7 @@ namespace BenchmarkDotNet.Tests.Configs
         {
             var fromEmpty = ImmutableConfigBuilder.Create(ManualConfig.CreateEmpty());
             Assert.Contains(JitOptimizationsValidator.DontFailOnError, fromEmpty.GetValidators());
-            
+
 #if !DEBUG
             // DefaultConfig.Instance doesn't include JitOptimizationsValidator.FailOnError in the DEBUG mode
             var fromDefault = ImmutableConfigBuilder.Create(DefaultConfig.Instance);
@@ -304,7 +304,7 @@ namespace BenchmarkDotNet.Tests.Configs
             var leftAddedToTheRight = ManualConfig.Create(right);
             leftAddedToTheRight.Add(left);
 
-            return new []{ rightAddedToLeft.CreateImmutableConfig(), leftAddedToTheRight.CreateImmutableConfig() };
+            return new[]{ rightAddedToLeft.CreateImmutableConfig(), leftAddedToTheRight.CreateImmutableConfig() };
         }
 
         public class TestExporter : IExporter, IExporterDependencies
diff --git a/tests/BenchmarkDotNet.Tests/CsProjGeneratorTests.cs b/tests/BenchmarkDotNet.Tests/CsProjGeneratorTests.cs
index c8638a972..12b5e2f7b 100644
--- a/tests/BenchmarkDotNet.Tests/CsProjGeneratorTests.cs
+++ b/tests/BenchmarkDotNet.Tests/CsProjGeneratorTests.cs
@@ -1,5 +1,4 @@
-using System;
-using System.IO;
+using System.IO;
 using BenchmarkDotNet.Toolchains.CsProj;
 using JetBrains.Annotations;
 using Xunit;
diff --git a/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs b/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs
index f6d52f10f..74287d168 100644
--- a/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Engine/EngineFactoryTests.cs
@@ -13,31 +13,31 @@ namespace BenchmarkDotNet.Tests.Engine
 {
     public class EngineFactoryTests
     {
-        int timesBenchmarkCalled = 0, timesOverheadCalled = 0;
-        int timesGlobalSetupCalled = 0, timesGlobalCleanupCalled = 0, timesIterationSetupCalled = 0, timesIterationCleanupCalled = 0;
+        private int timesBenchmarkCalled = 0, timesOverheadCalled = 0;
+        private int timesGlobalSetupCalled = 0, timesGlobalCleanupCalled = 0, timesIterationSetupCalled = 0, timesIterationCleanupCalled = 0;
 
-        TimeSpan IterationTime => TimeSpan.FromMilliseconds(EngineResolver.Instance.Resolve(Job.Default, RunMode.IterationTimeCharacteristic).ToMilliseconds());
+        private TimeSpan IterationTime => TimeSpan.FromMilliseconds(EngineResolver.Instance.Resolve(Job.Default, RunMode.IterationTimeCharacteristic).ToMilliseconds());
 
-        IResolver DefaultResolver => BenchmarkRunnerClean.DefaultResolver;
+        private IResolver DefaultResolver => BenchmarkRunnerClean.DefaultResolver;
 
-        void GlobalSetup() => timesGlobalSetupCalled++;
-        void IterationSetup() => timesIterationSetupCalled++;
-        void IterationCleanup() => timesIterationCleanupCalled++;
-        void GlobalCleanup() => timesGlobalCleanupCalled++;
+        private void GlobalSetup() => timesGlobalSetupCalled++;
+        private void IterationSetup() => timesIterationSetupCalled++;
+        private void IterationCleanup() => timesIterationCleanupCalled++;
+        private void GlobalCleanup() => timesGlobalCleanupCalled++;
 
-        void Throwing(long _) => throw new InvalidOperationException("must NOT be called");
+        private void Throwing(long _) => throw new InvalidOperationException("must NOT be called");
 
-        void VeryTimeConsumingSingle(long _)
+        private void VeryTimeConsumingSingle(long _)
         {
             timesBenchmarkCalled++;
             Thread.Sleep(IterationTime);
         }
 
-        void InstantNoUnroll(long invocationCount) => timesBenchmarkCalled += (int) invocationCount;
-        void InstantUnroll(long _) => timesBenchmarkCalled += 16;
+        private void InstantNoUnroll(long invocationCount) => timesBenchmarkCalled += (int) invocationCount;
+        private void InstantUnroll(long _) => timesBenchmarkCalled += 16;
 
-        void OverheadNoUnroll(long invocationCount) => timesOverheadCalled += (int) invocationCount;
-        void OverheadUnroll(long _) => timesOverheadCalled += 16;
+        private void OverheadNoUnroll(long invocationCount) => timesOverheadCalled += (int) invocationCount;
+        private void OverheadUnroll(long _) => timesOverheadCalled += 16;
 
         private static readonly Dictionary<string, Job> JobsWhichDontRequireJitting = new Dictionary<string, Job>
         {
diff --git a/tests/BenchmarkDotNet.Tests/Engine/EngineResultStageTests.cs b/tests/BenchmarkDotNet.Tests/Engine/EngineResultStageTests.cs
index ea1808e28..84d24a6b1 100644
--- a/tests/BenchmarkDotNet.Tests/Engine/EngineResultStageTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Engine/EngineResultStageTests.cs
@@ -1,7 +1,6 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNet.Engines;
-using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Reports;
 using JetBrains.Annotations;
 using Perfolizer.Mathematics.OutlierDetection;
diff --git a/tests/BenchmarkDotNet.Tests/Exporters/CommonExporterApprovalTests.cs b/tests/BenchmarkDotNet.Tests/Exporters/CommonExporterApprovalTests.cs
index 895ca3f79..046d4d7dc 100644
--- a/tests/BenchmarkDotNet.Tests/Exporters/CommonExporterApprovalTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Exporters/CommonExporterApprovalTests.cs
@@ -9,7 +9,6 @@ using ApprovalTests.Reporters;
 using BenchmarkDotNet.Columns;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Exporters;
-using BenchmarkDotNet.Exporters.Csv;
 using BenchmarkDotNet.Exporters.Json;
 using BenchmarkDotNet.Exporters.Xml;
 using BenchmarkDotNet.Loggers;
diff --git a/tests/BenchmarkDotNet.Tests/FullNameProviderTests.cs b/tests/BenchmarkDotNet.Tests/FullNameProviderTests.cs
index 6e2a6da07..ffc80a93d 100644
--- a/tests/BenchmarkDotNet.Tests/FullNameProviderTests.cs
+++ b/tests/BenchmarkDotNet.Tests/FullNameProviderTests.cs
@@ -3,9 +3,7 @@ using System.Collections.Generic;
 using System.ComponentModel;
 using System.IO;
 using System.Linq;
-using System.Text;
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Code;
 using BenchmarkDotNet.Exporters;
 using BenchmarkDotNet.Running;
 using Xunit;
diff --git a/tests/BenchmarkDotNet.Tests/GenericBuilderTests.cs b/tests/BenchmarkDotNet.Tests/GenericBuilderTests.cs
index c48e76d9a..42b1e8025 100644
--- a/tests/BenchmarkDotNet.Tests/GenericBuilderTests.cs
+++ b/tests/BenchmarkDotNet.Tests/GenericBuilderTests.cs
@@ -10,7 +10,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithOneArgument()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(OneArgGenericBenchmark<>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(OneArgGenericBenchmark<>)});
 
             Assert.Equal(2, types.Length);
             Assert.Single(types, typeof(OneArgGenericBenchmark<int>));
@@ -27,7 +27,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithTwoArguments()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(TwoArgGenericBenchmark<,>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(TwoArgGenericBenchmark<,>)});
 
             Assert.Equal(2, types.Length);
             Assert.Single(types, typeof(TwoArgGenericBenchmark<int, char>));
@@ -46,7 +46,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithThreeArguments()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(ThreeArgGenericBenchmark<,,>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(ThreeArgGenericBenchmark<,,>)});
 
             Assert.Equal(2, types.Length);
             Assert.Single(types, typeof(ThreeArgGenericBenchmark<int, char, string>));
@@ -67,7 +67,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithWrongAttributes()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(GenericBenchmarkWithWrongAttribute<,>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(GenericBenchmarkWithWrongAttribute<,>)});
 
             Assert.Equal(2, types.Length);
             Assert.Single(types, typeof(GenericBenchmarkWithWrongAttribute<int, char>));
@@ -87,7 +87,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithConstraints()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(GenericBenchmarkWithConstraints<,>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(GenericBenchmarkWithConstraints<,>)});
 
             Assert.Equal(2, types.Length);
             Assert.Single(types, typeof(GenericBenchmarkWithConstraints<int, char>));
@@ -107,7 +107,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void TestBuildGenericWithConstraintsWrongArgs()
         {
-            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new [] {typeof(GenericBenchmarkWithConstraintsWrongArgs<,>)});
+            var types = GenericBenchmarksBuilder.GetRunnableBenchmarks(new[] {typeof(GenericBenchmarkWithConstraintsWrongArgs<,>)});
 
             Assert.Single(types);
             Assert.Single(types, typeof(GenericBenchmarkWithConstraintsWrongArgs<int, char>));
diff --git a/tests/BenchmarkDotNet.Tests/Loggers/LoggerWithPrefixTests.cs b/tests/BenchmarkDotNet.Tests/Loggers/LoggerWithPrefixTests.cs
index 2fd5afc61..308466287 100644
--- a/tests/BenchmarkDotNet.Tests/Loggers/LoggerWithPrefixTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Loggers/LoggerWithPrefixTests.cs
@@ -1,7 +1,6 @@
 using System;
 using BenchmarkDotNet.Loggers;
 using Xunit;
-using Xunit.Abstractions;
 
 namespace BenchmarkDotNet.Tests.Loggers
 {
diff --git a/tests/BenchmarkDotNet.Tests/Mathematics/StatisticsTests.cs b/tests/BenchmarkDotNet.Tests/Mathematics/StatisticsTests.cs
index e84c89cb2..f9d21bf45 100644
--- a/tests/BenchmarkDotNet.Tests/Mathematics/StatisticsTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Mathematics/StatisticsTests.cs
@@ -1,6 +1,5 @@
 using System;
 using System.Linq;
-using BenchmarkDotNet.Helpers;
 using BenchmarkDotNet.Mathematics;
 using Perfolizer.Mathematics.Common;
 using Xunit;
diff --git a/tests/BenchmarkDotNet.Tests/ParameterInstanceTests.cs b/tests/BenchmarkDotNet.Tests/ParameterInstanceTests.cs
index 1217d58c7..286f4a15d 100644
--- a/tests/BenchmarkDotNet.Tests/ParameterInstanceTests.cs
+++ b/tests/BenchmarkDotNet.Tests/ParameterInstanceTests.cs
@@ -1,5 +1,4 @@
-using BenchmarkDotNet.Configs;
-using BenchmarkDotNet.Parameters;
+using BenchmarkDotNet.Parameters;
 using BenchmarkDotNet.Reports;
 using System;
 using System.Collections.Generic;
diff --git a/tests/BenchmarkDotNet.Tests/Reports/DisplayPrecisionManagerTests.cs b/tests/BenchmarkDotNet.Tests/Reports/DisplayPrecisionManagerTests.cs
index f3ff513f5..c29628ee8 100644
--- a/tests/BenchmarkDotNet.Tests/Reports/DisplayPrecisionManagerTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Reports/DisplayPrecisionManagerTests.cs
@@ -1,7 +1,6 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
-using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Reports;
 using JetBrains.Annotations;
 using Xunit;
diff --git a/tests/BenchmarkDotNet.Tests/Reports/RatioPrecisionTests.cs b/tests/BenchmarkDotNet.Tests/Reports/RatioPrecisionTests.cs
index 0af55179d..c22819ef9 100644
--- a/tests/BenchmarkDotNet.Tests/Reports/RatioPrecisionTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Reports/RatioPrecisionTests.cs
@@ -29,9 +29,9 @@ namespace BenchmarkDotNet.Tests.Reports
         }
 
         [Theory]
-        [InlineData(new [] { 140, 1, 50 })]
-        [InlineData(new [] { 40, 1, 20 })]
-        [InlineData(new [] { 0, 1, 20 })]
+        [InlineData(new[] { 140, 1, 50 })]
+        [InlineData(new[] { 40, 1, 20 })]
+        [InlineData(new[] { 0, 1, 20 })]
         // First value is baseline, others are benchmark measurements
         public void RatioPrecisionTestWithBaseline(int[] values)
         {
diff --git a/tests/BenchmarkDotNet.Tests/Running/BenchmarkConverterTests.cs b/tests/BenchmarkDotNet.Tests/Running/BenchmarkConverterTests.cs
index fa1f1c334..e91716247 100644
--- a/tests/BenchmarkDotNet.Tests/Running/BenchmarkConverterTests.cs
+++ b/tests/BenchmarkDotNet.Tests/Running/BenchmarkConverterTests.cs
@@ -3,7 +3,6 @@ using BenchmarkDotNet.Attributes;
 using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.Environments;
 using BenchmarkDotNet.Jobs;
-using BenchmarkDotNet.Mathematics;
 using BenchmarkDotNet.Running;
 using Perfolizer.Mathematics.OutlierDetection;
 using Xunit;
diff --git a/tests/BenchmarkDotNet.Tests/RuntimeVersionDetectionTests.cs b/tests/BenchmarkDotNet.Tests/RuntimeVersionDetectionTests.cs
index 2fd9622c5..5cf4e43a8 100644
--- a/tests/BenchmarkDotNet.Tests/RuntimeVersionDetectionTests.cs
+++ b/tests/BenchmarkDotNet.Tests/RuntimeVersionDetectionTests.cs
@@ -128,4 +128,3 @@ namespace BenchmarkDotNet.Tests
         }
     }
 }
-
diff --git a/tests/BenchmarkDotNet.Tests/SizeUnitTests.cs b/tests/BenchmarkDotNet.Tests/SizeUnitTests.cs
index 39b135383..e8cfbd598 100644
--- a/tests/BenchmarkDotNet.Tests/SizeUnitTests.cs
+++ b/tests/BenchmarkDotNet.Tests/SizeUnitTests.cs
@@ -12,8 +12,8 @@ namespace BenchmarkDotNet.Tests
         {
             this.output = output;
         }
-        
-        
+
+
         [Fact]
         public void ConvertTest()
         {
@@ -44,7 +44,7 @@ namespace BenchmarkDotNet.Tests
         {
             Assert.Equal(expected, SizeValue.FromBytes(bytes).ToString(TestCultureInfo.Instance));
         }
-        
+
         private void CheckConvertTwoWay(long value1, SizeUnit unit1, long value2, SizeUnit unit2)
         {
             CheckConvertOneWay(value1, unit1, value2, unit2);
diff --git a/tests/BenchmarkDotNet.Tests/TypeFilterTests.cs b/tests/BenchmarkDotNet.Tests/TypeFilterTests.cs
index 0f341715a..601bad020 100644
--- a/tests/BenchmarkDotNet.Tests/TypeFilterTests.cs
+++ b/tests/BenchmarkDotNet.Tests/TypeFilterTests.cs
@@ -4,9 +4,7 @@ using System.Linq;
 using System.Reflection;
 using Xunit;
 using BenchmarkDotNet.Attributes;
-using BenchmarkDotNet.Configs;
 using BenchmarkDotNet.ConsoleArguments;
-using BenchmarkDotNet.ConsoleArguments.ListBenchmarks;
 using BenchmarkDotNet.Extensions;
 using BenchmarkDotNet.Loggers;
 using BenchmarkDotNet.Tests;
@@ -26,7 +24,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void ReturnsNoBenchmarksForInvalidTypes()
         {
-            var benchmarks = Filter(new [] { typeof(ClassC) }, new [] { "--filter", "*" });
+            var benchmarks = Filter(new[] { typeof(ClassC) }, new[] { "--filter", "*" });
 
             Assert.Empty(benchmarks);
         }
@@ -34,7 +32,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void CanFilterAllBenchmark()
         {
-            var benchmarks = Filter(new [] { typeof(ClassA), typeof(ClassB) }, new [] { "--filter", "*" });
+            var benchmarks = Filter(new[] { typeof(ClassA), typeof(ClassB) }, new[] { "--filter", "*" });
 
             Assert.Equal(5, benchmarks.Count);
             Assert.Contains("ClassA.Method1", benchmarks);
@@ -71,7 +69,7 @@ namespace BenchmarkDotNet.Tests
         [Fact]
         public void CanSelectMethods()
         {
-            var benchmarks = Filter(new [] { typeof(ClassA), typeof(ClassB) }, new [] { "--filter", "*Method2", "*Method3" });
+            var benchmarks = Filter(new[] { typeof(ClassA), typeof(ClassB) }, new[] { "--filter", "*Method2", "*Method3" });
 
             Assert.Equal(3, benchmarks.Count);
             Assert.Contains("ClassA.Method2", benchmarks);
@@ -83,7 +81,7 @@ namespace BenchmarkDotNet.Tests
         public void CanSelectMethodsWithFullName()
         {
             var benchmarks = Filter(
-                new [] { typeof(ClassA), typeof(ClassB) },
+                new[] { typeof(ClassA), typeof(ClassB) },
                 new[] { "--filter", "BenchmarkDotNet.Tests.ClassA.Method2", "BenchmarkDotNet.Tests.ClassB.Method3" });
 
             Assert.Equal(2, benchmarks.Count);