diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/BenchmarkDotNetAnalyser.Tests.Integration.csproj b/test/BenchmarkDotNetAnalyser.Tests.Integration/BenchmarkDotNetAnalyser.Tests.Integration.csproj
index 2771fb0..2af3460 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/BenchmarkDotNetAnalyser.Tests.Integration.csproj
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/BenchmarkDotNetAnalyser.Tests.Integration.csproj
@@ -11,7 +11,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="FluentAssertions" Version="7.1.0" />
+    <PackageReference Include="Shouldly" Version="4.2.1" />
     <PackageReference Include="FsCheck.Xunit" Version="3.2.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NSubstitute" Version="5.3.0" />
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkInfoJsonFileProviderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkInfoJsonFileProviderTests.cs
index 9e881ff..8254620 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkInfoJsonFileProviderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkInfoJsonFileProviderTests.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Integration.Classes.Benchmarks
@@ -35,7 +35,7 @@ public async Task GetBenchmarkInfosAsync_WriteBenchmarkInfosAsync_Symmetric(stri
             var readResult = await p.GetBenchmarkInfosAsync(dir);
             var readResultCount = readResult.Sum(r => r.Runs.Sum(x => x.Results.Count));
             
-            benchmarkInfosResultCount.Should().Be(readResultCount);
+            benchmarkInfosResultCount.ShouldBe(readResultCount);
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkParserTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkParserTests.cs
index 76871f2..56189a0 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkParserTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkParserTests.cs
@@ -5,7 +5,7 @@
 using BenchmarkDotNet.Attributes;
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.IO;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Integration.Classes.Benchmarks
@@ -49,9 +49,9 @@ public async Task GetCreation_ValueParsed(string filePath)
 
             var result = new BenchmarkParser(json).GetCreation();
 
-            result.Should().BeAfter(default);
-            result.Year.Should().BeGreaterThan(2020);
-            result.Year.Should().BeLessThan(2100);
+            result.ShouldBeGreaterThan(default);
+            result.Year.ShouldBeGreaterThan(2020);
+            result.Year.ShouldBeLessThan(2100);
         }
 
         [Theory]
@@ -63,16 +63,24 @@ public async Task GetBenchmarkEnvironment_ValueParsed(string filePath)
             var jo = Newtonsoft.Json.Linq.JObject.Parse(json)["HostEnvironmentInfo"];
             var result = new BenchmarkParser(json).GetBenchmarkEnvironment();
 
-            result.Should().NotBeNull();
-            result.BenchmarkDotNetVersion.Should().Be(jo.GetStringValue("BenchmarkDotNetVersion")).And.NotBeNullOrWhiteSpace();
-            result.DotNetCliVersion.Should().Be(jo.Value<string>("DotNetCliVersion")).And.NotBeNullOrWhiteSpace();
-            result.DotNetRuntimeVersion.Should().Be(jo.Value<string>("RuntimeVersion")).And.NotBeNullOrWhiteSpace();
-            result.OsVersion.Should().Be(jo.Value<string>("OsVersion")).And.NotBeNullOrWhiteSpace();
-            result.ProcessorName.Should().Be(jo.Value<string>("ProcessorName")).And.NotBeNullOrWhiteSpace();
-
-            result.PhysicalProcessorCount.Should().Be(jo.Value<int>("PhysicalProcessorCount")).And.BeGreaterThan(0);
-            result.LogicalCoreCount.Should().Be(jo.Value<int>("LogicalCoreCount")).And.BeGreaterThan(0);
-            result.MachineArchitecture.Should().Be(jo.Value<string>("Architecture")).And.NotBeNullOrWhiteSpace();
+            result.ShouldNotBeNull();
+            result.BenchmarkDotNetVersion.ShouldBe(jo.GetStringValue("BenchmarkDotNetVersion"));
+            result.BenchmarkDotNetVersion.ShouldNotBeNullOrWhiteSpace();
+            result.DotNetCliVersion.ShouldBe(jo.Value<string>("DotNetCliVersion"));
+            result.DotNetCliVersion.ShouldNotBeNullOrWhiteSpace();
+            result.DotNetRuntimeVersion.ShouldBe(jo.Value<string>("RuntimeVersion"));
+            result.DotNetRuntimeVersion.ShouldNotBeNullOrWhiteSpace();
+            result.OsVersion.ShouldBe(jo.Value<string>("OsVersion"));
+            result.OsVersion.ShouldNotBeNullOrWhiteSpace();
+            result.ProcessorName.ShouldBe(jo.Value<string>("ProcessorName"));
+            result.ProcessorName.ShouldNotBeNullOrWhiteSpace();
+
+            result.PhysicalProcessorCount.ShouldBe(jo.Value<int>("PhysicalProcessorCount"));
+            result.PhysicalProcessorCount.ShouldBeGreaterThan(0);
+            result.LogicalCoreCount.ShouldBe(jo.Value<int>("LogicalCoreCount"));
+            result.LogicalCoreCount.ShouldBeGreaterThan(0);
+            result.MachineArchitecture.ShouldBe(jo.Value<string>("Architecture"));
+            result.MachineArchitecture.ShouldNotBeNullOrWhiteSpace();
         }
 
         [Theory]
@@ -82,22 +90,32 @@ public async Task GetBenchmarkResults_ValuesParsed(string filePath)
             var json = await FileReader.ReadAsync(filePath);
             var results = new BenchmarkParser(json).GetBenchmarkResults().ToList();
 
-            results.Count.Should().BeGreaterThan(0);
+            results.Count.ShouldBeGreaterThan(0);
             
             foreach (var result in results)
             {
-                result.FullName.Should().NotBeNullOrWhiteSpace().And.ContainAny(_benchmarkTypeFullNames);
-                result.Namespace.Should().NotBeNullOrWhiteSpace().And.ContainAny(_benchmarkTypeNamespaces);
-                result.Type.Should().NotBeNullOrWhiteSpace().And.ContainAny(_benchmarkTypeNames);
-                result.Method.Should().NotBeNullOrWhiteSpace().And.ContainAny(_benchmarkMethods);
-                result.Parameters.Should().NotBeNull();
-
-                result.MaxTime.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
-                result.MinTime.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
-                result.MeanTime.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
-                result.MedianTime.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
-                result.Q1Time.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
-                result.Q3Time.Should().HaveValue().And.BeGreaterOrEqualTo(0M);
+                result.FullName.ShouldNotBeNullOrWhiteSpace();
+                _benchmarkTypeFullNames.Any(x => result.FullName.Contains(x)).ShouldBeTrue();
+                result.Namespace.ShouldNotBeNullOrWhiteSpace();
+                _benchmarkTypeNamespaces.Any(x => result.Namespace.Contains(x)).ShouldBeTrue();
+                result.Type.ShouldNotBeNullOrWhiteSpace();
+                _benchmarkTypeNames.Any(x => result.Type.Contains(x)).ShouldBeTrue();
+                result.Method.ShouldNotBeNullOrWhiteSpace();
+                _benchmarkMethods.Any(x => result.Method.Contains(x)).ShouldBeTrue();
+                result.Parameters.ShouldNotBeNull();
+
+                result.MaxTime.ShouldNotBeNull();
+                result.MaxTime.Value.ShouldBeGreaterThanOrEqualTo(0M);
+                result.MinTime.ShouldNotBeNull();
+                result.MinTime.Value.ShouldBeGreaterThanOrEqualTo(0M);
+                result.MeanTime.ShouldNotBeNull();
+                result.MeanTime.Value.ShouldBeGreaterThanOrEqualTo(0M);
+                result.MedianTime.ShouldNotBeNull();
+                result.MedianTime.Value.ShouldBeGreaterThanOrEqualTo(0M);
+                result.Q1Time.ShouldNotBeNull();
+                result.Q1Time.Value.ShouldBeGreaterThanOrEqualTo(0M);
+                result.Q3Time.ShouldNotBeNull();
+                result.Q3Time.Value.ShouldBeGreaterThanOrEqualTo(0M);
             }
         }
     }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkResultJsonFileReaderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkResultJsonFileReaderTests.cs
index 6f79cb0..21428a7 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkResultJsonFileReaderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkResultJsonFileReaderTests.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Integration.Classes.Benchmarks
@@ -19,7 +19,7 @@ public async Task GetBenchmarkResultsAsync_ResultsReturned(string path)
 
             var result = await reader.GetBenchmarkResultsAsync(path);
 
-            result.Count.Should().BeGreaterThan(0);
+            result.Count.ShouldBeGreaterThan(0);
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkRunInfoJsonFileProviderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkRunInfoJsonFileProviderTests.cs
index ae9a3ba..31b03f8 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkRunInfoJsonFileProviderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/Benchmarks/BenchmarkRunInfoJsonFileProviderTests.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Integration.Classes.Benchmarks
@@ -20,10 +20,10 @@ public async Task GetBenchmarkJsonAsync_ResultsParsed(string path)
 
             var result = await provider.GetRunInfoAsync(path);
 
-            result.Should().NotBeNull();
-            result.BenchmarkDotNetVersion.Should().NotBeNullOrWhiteSpace();
-            result.Creation.Should().NotBe(DateTimeOffset.MinValue);
-            result.Results.Count.Should().BeGreaterThan(0);
+            result.ShouldNotBeNull();
+            result.BenchmarkDotNetVersion.ShouldNotBeNullOrWhiteSpace();
+            result.Creation.ShouldNotBe(DateTimeOffset.MinValue);
+            result.Results.Count.ShouldBeGreaterThan(0);
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/IO/FileFinderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/IO/FileFinderTests.cs
index e781aaa..2256059 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/IO/FileFinderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/Classes/IO/FileFinderTests.cs
@@ -1,6 +1,6 @@
 using System.Linq;
 using BenchmarkDotNetAnalyser.IO;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Integration.Classes.IO
@@ -18,9 +18,9 @@ public void Find_ReturnsFiles()
 
             var expected = IOHelper.GetSourceResultFilePaths().ToList();
 
-            result.Count.Should().BeGreaterThan(0);
-            result.SequenceEqual(expected).Should().BeTrue();
-            result.All(x => x.EndsWith(ext)).Should().BeTrue();
+            result.Count.ShouldBeGreaterThan(0);
+            result.SequenceEqual(expected).ShouldBeTrue();
+            result.All(x => x.EndsWith(ext)).ShouldBeTrue();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Integration/E2E/BaseStory.cs b/test/BenchmarkDotNetAnalyser.Tests.Integration/E2E/BaseStory.cs
index 576380e..a830f06 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Integration/E2E/BaseStory.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Integration/E2E/BaseStory.cs
@@ -11,8 +11,8 @@
 using BenchmarkDotNetAnalyser.Instrumentation;
 using BenchmarkDotNetAnalyser.IO;
 using BenchmarkDotNetAnalyser.Reporting;
-using FluentAssertions;
-using FluentAssertions.Execution;
+using Shouldly;
+
 using Newtonsoft.Json;
 using NSubstitute;
 
@@ -89,7 +89,7 @@ public async Task AggregationExecutorExecuted(bool expectedResult = true)
 
             _aggregateResult = await aggregator.ExecuteAsync(_aggregateArgs);
 
-            _aggregateResult.Should().Be(expectedResult);
+            _aggregateResult.ShouldBe(expectedResult);
         }
 
         public async Task AggregatedBenchmarkInfosFetched()
@@ -101,34 +101,34 @@ public async Task AggregatedBenchmarkInfosFetched()
 
         public void SingletonBenchmarkInfoIsChecked()
         {
-            _newBenchmarkInfos.Count.Should().Be(1);
+            _newBenchmarkInfos.Count.ShouldBe(1);
 
-            _newBenchmarkInfos[0].BranchName.Should().Be(_aggregateArgs.BranchName);
-            _newBenchmarkInfos[0].CommitSha.Should().Be(_aggregateArgs.CommitSha);
-            _newBenchmarkInfos[0].BuildUri.Should().Be(_aggregateArgs.BuildUri);
-            _newBenchmarkInfos[0].Tags.Should().BeEquivalentTo(_aggregateArgs.Tags);
+            _newBenchmarkInfos[0].BranchName.ShouldBe(_aggregateArgs.BranchName);
+            _newBenchmarkInfos[0].CommitSha.ShouldBe(_aggregateArgs.CommitSha);
+            _newBenchmarkInfos[0].BuildUri.ShouldBe(_aggregateArgs.BuildUri);
+            _newBenchmarkInfos[0].Tags.ShouldBe(_aggregateArgs.Tags);
 
-            _newBenchmarkInfos[0].Runs.Should().HaveCount(_newRunFiles);
+            _newBenchmarkInfos[0].Runs.Count.ShouldBe(_newRunFiles);
             
-            _newBenchmarkInfos[0].Runs.All(p => !string.IsNullOrWhiteSpace(p.BenchmarkDotNetVersion)).Should().BeTrue();
-            _newBenchmarkInfos[0].Runs.All(p => p.Creation > DateTimeOffset.MinValue).Should().BeTrue();
+            _newBenchmarkInfos[0].Runs.All(p => !string.IsNullOrWhiteSpace(p.BenchmarkDotNetVersion)).ShouldBeTrue();
+            _newBenchmarkInfos[0].Runs.All(p => p.Creation > DateTimeOffset.MinValue).ShouldBeTrue();
         }
 
         public void MultipleBenchmarkInfosAreChecked()
         {
-            _newBenchmarkInfos.Count.Should().Be(_aggregateArgs.BenchmarkRuns);
+            _newBenchmarkInfos.Count.ShouldBe(_aggregateArgs.BenchmarkRuns);
 
             foreach (var bi in _newBenchmarkInfos)
             {
-                bi.BranchName.Should().Be(_aggregateArgs.BranchName);
-                bi.CommitSha.Should().Be(_aggregateArgs.CommitSha);
-                bi.BuildUri.Should().Be(_aggregateArgs.BuildUri);
-                bi.Tags.Should().BeEquivalentTo(_aggregateArgs.Tags);
+                bi.BranchName.ShouldBe(_aggregateArgs.BranchName);
+                bi.CommitSha.ShouldBe(_aggregateArgs.CommitSha);
+                bi.BuildUri.ShouldBe(_aggregateArgs.BuildUri);
+                bi.Tags.ShouldBe(_aggregateArgs.Tags);
 
-                bi.Runs.Should().HaveCount(_newRunFiles);
+                bi.Runs.Count.ShouldBe(_newRunFiles);
 
-                bi.Runs.All(p => !string.IsNullOrWhiteSpace(p.BenchmarkDotNetVersion)).Should().BeTrue();
-                bi.Runs.All(p => p.Creation > DateTimeOffset.MinValue).Should().BeTrue();
+                bi.Runs.All(p => !string.IsNullOrWhiteSpace(p.BenchmarkDotNetVersion)).ShouldBeTrue();
+                bi.Runs.All(p => p.Creation > DateTimeOffset.MinValue).ShouldBeTrue();
             }
         }
         
@@ -141,7 +141,7 @@ public void BenchmarkRunResultsRetrieved()
 
         public void EmptyBenchmarkRunResultsChecked()
         {
-            _benchmarkRunResults.Count.Should().Be(0);
+            _benchmarkRunResults.Count.ShouldBe(0);
         }
 
         public void BenchmarkRunResultsChecked()
@@ -150,12 +150,12 @@ public void BenchmarkRunResultsChecked()
 
             foreach (var br in results)
             {
-                br.FullName.Should().NotBeNullOrWhiteSpace();
-                br.Method.Should().NotBeNullOrWhiteSpace();
-                br.Namespace.Should().NotBeNullOrWhiteSpace();
+                br.FullName.ShouldNotBeNullOrWhiteSpace();
+                br.Method.ShouldNotBeNullOrWhiteSpace();
+                br.Namespace.ShouldNotBeNullOrWhiteSpace();
             }
-            _benchmarkRunResults.All(brr => brr.Results.Count > 0).Should().BeTrue();
-            _benchmarkRunResults.All(brr => brr.Run != null).Should().BeTrue();
+            _benchmarkRunResults.All(brr => brr.Results.Count > 0).ShouldBeTrue();
+            _benchmarkRunResults.All(brr => brr.Run != null).ShouldBeTrue();
         }
 
         public void AnalysisArgsCreated(decimal tolerance, int maxErrors)
@@ -175,20 +175,20 @@ public async Task AnalysisExecutorExecuted()
 
             _analysisResult = await analyser.ExecuteAsync(_analysisArgs);
 
-            _analysisResult.Should().NotBeNull();
+            _analysisResult.ShouldNotBeNull();
         }
 
         public void AnalysisResultCheckedForSuccess()
         {
-            _analysisResult.MeetsRequirements.Should().BeTrue();
-            _analysisResult.InnerResults.Any(bra => bra.MeetsRequirements).Should().BeTrue();
-            _analysisResult.InnerResults.Count.Should().BeGreaterThan(0);
+            _analysisResult.MeetsRequirements.ShouldBeTrue();
+            _analysisResult.InnerResults.Any(bra => bra.MeetsRequirements).ShouldBeTrue();
+            _analysisResult.InnerResults.Count.ShouldBeGreaterThan(0);
         }
 
         public void AnalysisResultCheckedForFailure()
         {
-            _analysisResult.MeetsRequirements.Should().BeFalse();
-            _analysisResult.Message.Should().NotBeNullOrWhiteSpace();
+            _analysisResult.MeetsRequirements.ShouldBeFalse();
+            _analysisResult.Message.ShouldNotBeNullOrWhiteSpace();
         }
 
         public void ReportsDirectoryCreated()
@@ -221,7 +221,7 @@ public void CsvReportsAreVerified()
             {
                 if (!File.Exists(file))
                 {
-                    throw new AssertionFailedException($"File {file} does not exist.");
+                    throw new Exception($"File {file} does not exist.");
                 }
 
                 using (var stream = File.OpenText(file))
@@ -230,7 +230,7 @@ public void CsvReportsAreVerified()
                     {
                         var recs = csvReader.GetRecords<object>().ToList();
 
-                        recs.Count.Should().BeGreaterThan(0);
+                        recs.Count.ShouldBeGreaterThan(0);
                     }
                 }
             }
@@ -244,12 +244,12 @@ public void JsonReportsAreVerified()
             {
                 if (!File.Exists(file))
                 {
-                    throw new AssertionFailedException($"File {file} does not exist.");
+                    throw new Exception($"File {file} does not exist.");
                 }
                 
                 var json = File.ReadAllText(file);
                 var records = JsonConvert.DeserializeObject<IList<BenchmarkRecord>>(json);
-                records.Count.Should().BeGreaterThan(0);
+                records.Count.ShouldBeGreaterThan(0);
             }
         }
     }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceAnalyserTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceAnalyserTests.cs
index 47a8582..ba7170a 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceAnalyserTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceAnalyserTests.cs
@@ -1,6 +1,6 @@
 using BenchmarkDotNetAnalyser.Analysis;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -69,7 +69,7 @@ public void CreateAnalysis_ToleranceHasPositiveNegativeBoundaries_OutsideBoundar
             
             var result = analyser.CreateAnalysis("", baseline, test);
 
-            result.MeetsRequirements.Should().BeFalse();
+            result.MeetsRequirements.ShouldBeFalse();
         }
 
         [Theory]
@@ -85,7 +85,7 @@ public void CreateAnalysis_ToleranceHasPositiveNegativeBoundaries_InsideBoundari
             
             var result = analyser.CreateAnalysis("", baseline, test);
 
-            result.MeetsRequirements.Should().BeTrue();
+            result.MeetsRequirements.ShouldBeTrue();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceGroupAnalyserTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceGroupAnalyserTests.cs
index 04089f2..c5f3e2a 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceGroupAnalyserTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BaselineDevianceGroupAnalyserTests.cs
@@ -3,7 +3,7 @@
 using BenchmarkDotNetAnalyser.Analysis;
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -41,9 +41,9 @@ public void Analyse_LatestWithinTolerance_ReturnsTrue(int resultCount)
 
             var result = analyser.Analyse(group).ToList();
 
-            result.Count.Should().Be(1);
-            result[0].MeetsRequirements.Should().BeTrue();
-            result[0].Message.Should().BeNull();
+            result.Count.ShouldBe(1);
+            result[0].MeetsRequirements.ShouldBeTrue();
+            result[0].Message.ShouldBeNull();
             telemetry.Received(0).Write(Arg.Any<TelemetryEntry>());
         }
 
@@ -77,9 +77,9 @@ public void Analyse_LatestExceedsTolerance_ReturnsFalse(int resultCount)
 
             var result = analyser.Analyse(group).ToList();
 
-            result.Count.Should().Be(1);
-            result[0].MeetsRequirements.Should().BeFalse();
-            result[0].Message.Should().NotBeNullOrWhiteSpace();
+            result.Count.ShouldBe(1);
+            result[0].MeetsRequirements.ShouldBeFalse();
+            result[0].Message.ShouldNotBeNullOrWhiteSpace();
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(t => t.AddLineBreak && t.IsVerbose && !string.IsNullOrWhiteSpace(t.Message)));
         }
     }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BenchmarkResultGroupBuilderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BenchmarkResultGroupBuilderTests.cs
index 7fc78ae..9589cc7 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BenchmarkResultGroupBuilderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/BenchmarkResultGroupBuilderTests.cs
@@ -3,7 +3,7 @@
 using System.Linq;
 using BenchmarkDotNetAnalyser.Analysis;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Unit.Analysis
@@ -17,7 +17,7 @@ public void FromResults_EmptyRuns_EmptyResults()
 
             var result = new BenchmarkResultGroupBuilder().FromResults(runs).ToList();
 
-            result.Count.Should().Be(0);
+            result.Count.ShouldBe(0);
         }
 
         [Fact]
@@ -30,7 +30,7 @@ public void FromResults_SingleRun_EmptyRun_EmptyResults()
 
             var result = new BenchmarkResultGroupBuilder().FromResults(runs).ToList();
 
-            result.Count.Should().Be(0);
+            result.Count.ShouldBe(0);
         }
 
         [Fact]
@@ -50,8 +50,8 @@ public void FromResults_MultipleRuns_NamesMatch()
 
             var result = new BenchmarkResultGroupBuilder().FromResults(runs).ToList();
 
-            result.Count.Should().Be(resultRuns.Count);
-            result.Select(r => r.Name).SequenceEqual(names).Should().BeTrue();
+            result.Count.ShouldBe(resultRuns.Count);
+            result.Select(r => r.Name).SequenceEqual(names).ShouldBeTrue();
         }
 
         
@@ -72,10 +72,10 @@ public void FromResults_SingletonRun_ResultsInChronoOrder()
             
             var result = new BenchmarkResultGroupBuilder().FromResults(runs).ToList();
 
-            result.Count.Should().Be(1);
+            result.Count.ShouldBe(1);
 
             var xs = result[0].Results.Select(r => r.Item1.Creation.DateTime).Reverse();
-            xs.SequenceEqual(times).Should().Be(true);
+            xs.SequenceEqual(times).ShouldBe(true);
         }
 
         [Fact]
@@ -95,10 +95,10 @@ public void FromResults_SingletonRun_ResultsMapped()
 
             var result = new BenchmarkResultGroupBuilder().FromResults(runs).ToList();
 
-            result.Count.Should().Be(1);
+            result.Count.ShouldBe(1);
 
             var xs = result.SelectMany(r => r.Results).Select(t => (int)t.Item2.MinTime);
-            xs.SequenceEqual(expectedValues).Should().BeTrue();
+            xs.SequenceEqual(expectedValues).ShouldBeTrue();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/TelemetryBenchmarkResultAnalysisReporterTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/TelemetryBenchmarkResultAnalysisReporterTests.cs
index 81186d9..d9a0433 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/TelemetryBenchmarkResultAnalysisReporterTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Analysis/TelemetryBenchmarkResultAnalysisReporterTests.cs
@@ -2,7 +2,7 @@
 using System.Linq;
 using BenchmarkDotNetAnalyser.Analysis;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -23,7 +23,7 @@ public void Report_MeetsRequirementsTrue_ErrorReturned()
             };
 
             var result = reporter.Report(analysis);
-            result.Should().BeTrue();
+            result.ShouldBeTrue();
             telemetry.Received(0).Error(Arg.Any<string>());
             telemetry.Received(1).Success(Arg.Is<string>(s => !string.IsNullOrWhiteSpace(s)));
         }
@@ -42,7 +42,7 @@ public void Report_MeetsRequirementsFalse_EmptyInnerResults_ErrorReturned()
 
             var result = reporter.Report(analysis);
 
-            result.Should().BeFalse();
+            result.ShouldBeFalse();
             telemetry.Received(0).Error(Arg.Any<string>());
             telemetry.Received(0).Success(Arg.Any<string>());
         }
@@ -70,7 +70,7 @@ public void Report_MeetsRequirementsFalse_NullMessage_InnerMessageReturned()
 
             var result = reporter.Report(analysis);
 
-            result.Should().BeFalse();
+            result.ShouldBeFalse();
             telemetry.Received(0).Success(Arg.Any<string>());
             telemetry.Received(1).Error(Arg.Is<string>(s => msgs.Any(s.Contains)));
         }
@@ -96,7 +96,7 @@ public void Report_MeetsRequirementsFalse_InnerMessageNotReturned()
 
             var result = reporter.Report(analysis);
 
-            result.Should().BeFalse();
+            result.ShouldBeFalse();
             telemetry.Received(0).Success(Arg.Any<string>());
             telemetry.Received(1).Error(Arg.Any<string>());
             telemetry.Received(0).Error(Arg.Is<string>(s => msgs.Any(s.Contains)));
@@ -125,7 +125,7 @@ public void Report_MeetsRequirementsFalse_WhitespaceMessage_InnerMessageReturned
 
             var result = reporter.Report(analysis);
 
-            result.Should().BeFalse();
+            result.ShouldBeFalse();
             telemetry.Received(0).Success(Arg.Any<string>());
             telemetry.Received(1).Error(Arg.Is<string>(s => msgs.Any(s.Contains)));
             telemetry.Received(1).Error(Arg.Is<string>(s => !s.Contains(analysis.Message)));
@@ -153,7 +153,7 @@ public void Report_MeetsRequirementsFalse_NonNullMessage_InnerMessageReturned()
 
             var result = reporter.Report(analysis);
 
-            result.Should().BeFalse();
+            result.ShouldBeFalse();
             telemetry.Received(0).Success(Arg.Any<string>());
             telemetry.Received(1).Error(Arg.Is<string>(s => msgs.Any(s.Contains)));
             telemetry.Received(1).Error(Arg.Is<string>(s => s.Contains(analysis.Message)));
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/BenchmarkDotNetAnalyser.Tests.Unit.csproj b/test/BenchmarkDotNetAnalyser.Tests.Unit/BenchmarkDotNetAnalyser.Tests.Unit.csproj
index 3390831..7173dd6 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/BenchmarkDotNetAnalyser.Tests.Unit.csproj
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/BenchmarkDotNetAnalyser.Tests.Unit.csproj
@@ -12,7 +12,7 @@
       <PrivateAssets>all</PrivateAssets>
       <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
     </PackageReference>
-    <PackageReference Include="FluentAssertions" Version="7.1.0" />
+    <PackageReference Include="Shouldly" Version="4.2.1" />
     <PackageReference Include="FsCheck.Xunit" Version="3.2.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.13.0" />
     <PackageReference Include="NSubstitute" Version="5.3.0" />
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkInfoExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkInfoExtensionsTests.cs
index 4944fad..f442ac0 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkInfoExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkInfoExtensionsTests.cs
@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using NSubstitute;
@@ -70,7 +70,7 @@ public void PreservePinned_InterpolatedPinBitmap_BenchmarksTrimmed(int runs, boo
 
             var actual = benchmarks.Select(b => result.Contains(b)).ToArray();
             
-            actual.SequenceEqual(survivors).Should().BeTrue();
+            actual.SequenceEqual(survivors).ShouldBeTrue();
         }
 
         [Fact]
@@ -83,7 +83,7 @@ public void PinBest_SameValues_AllPinned()
             
             var _ = benchmarks.PinBest(stats);
 
-            benchmarks.All(b => b.Pinned).Should().BeTrue();
+            benchmarks.All(b => b.Pinned).ShouldBeTrue();
         }
 
         [Fact]
@@ -100,8 +100,8 @@ public void PinBest_DistinctValues_LowestPinned()
             var lowest = benchmarks.Single(b => b.Runs.Any(r => r.Results.Contains(lowestResult)));
             var others = benchmarks.Where(b => b != lowest);
 
-            lowest.Pinned.Should().BeTrue();
-            others.All(b => !b.Pinned).Should().BeTrue();
+            lowest.Pinned.ShouldBeTrue();
+            others.All(b => !b.Pinned).ShouldBeTrue();
         }
 
         [Fact]
@@ -122,8 +122,8 @@ public void PinBest_DistinctValues_LowestPinned_MultipleRuns()
             var lowest = benchmarks.Single(b => b.Runs.Any(r => r.Results.Contains(lowestResult)));
             var others = benchmarks.Where(b => b != lowest);
 
-            lowest.Pinned.Should().BeTrue();
-            others.All(b => !b.Pinned).Should().BeTrue();
+            lowest.Pinned.ShouldBeTrue();
+            others.All(b => !b.Pinned).ShouldBeTrue();
         }
 
         [Theory]
@@ -151,7 +151,7 @@ public void TrimRunsByFilter_RunsTrimmed(string filter, int expectedCount, param
             };
 
             var result = bi.TrimRunsByFilter(new[] {filter});
-            result.Runs.Sum(ri => ri.Results.Count).Should().Be(expectedCount);
+            result.Runs.Sum(ri => ri.Results.Count).ShouldBe(expectedCount);
         }
 
         [Theory]
@@ -171,7 +171,7 @@ public void IsIncluded_ResultFiltered(string ns, string t, string m, bool expect
                 Method = m,
             };
 
-            result.IsIncluded(filters).Should().Be(expected);
+            result.IsIncluded(filters).ShouldBe(expected);
         }
 
         private IBenchmarkStatisticAccessorProvider CreateMockStatsProvider()
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkParserTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkParserTests.cs
index 9b0883b..1037dfd 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkParserTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkParserTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Linq;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using Newtonsoft.Json;
 using Xunit;
 
@@ -21,7 +21,7 @@ public void GetBenchmarkEnvironment_GetCreation()
 
             var expected = new DateTime(2021, 3, 16, 17, 37, 43, DateTimeKind.Utc);
 
-            ct.Should().Be(expected);
+            ct.ShouldBe(expected);
         }
 
         [Theory]
@@ -51,15 +51,15 @@ public void GetBenchmarkEnvironment_ValuesParsed(string caption, string bdnVersi
             var json = JsonConvert.SerializeObject(hostInfo);
             var env = new BenchmarkParser(json).GetBenchmarkEnvironment();
 
-            env.Should().NotBeNull();
-            env.BenchmarkDotNetVersion.Should().Be(hostInfo.HostEnvironmentInfo.BenchmarkDotNetVersion);
-            env.OsVersion.Should().Be(hostInfo.HostEnvironmentInfo.OsVersion);
-            env.ProcessorName.Should().Be(hostInfo.HostEnvironmentInfo.ProcessorName);
-            env.LogicalCoreCount.Should().Be(hostInfo.HostEnvironmentInfo.LogicalCoreCount);
-            env.PhysicalProcessorCount.Should().Be(hostInfo.HostEnvironmentInfo.PhysicalProcessorCount);
-            env.MachineArchitecture.Should().Be(hostInfo.HostEnvironmentInfo.Architecture);
-            env.DotNetCliVersion.Should().Be(hostInfo.HostEnvironmentInfo.DotNetCliVersion);
-            env.DotNetRuntimeVersion.Should().Be(hostInfo.HostEnvironmentInfo.RuntimeVersion);
+            env.ShouldNotBeNull();
+            env.BenchmarkDotNetVersion.ShouldBe(hostInfo.HostEnvironmentInfo.BenchmarkDotNetVersion);
+            env.OsVersion.ShouldBe(hostInfo.HostEnvironmentInfo.OsVersion);
+            env.ProcessorName.ShouldBe(hostInfo.HostEnvironmentInfo.ProcessorName);
+            env.LogicalCoreCount.ShouldBe(hostInfo.HostEnvironmentInfo.LogicalCoreCount);
+            env.PhysicalProcessorCount.ShouldBe(hostInfo.HostEnvironmentInfo.PhysicalProcessorCount);
+            env.MachineArchitecture.ShouldBe(hostInfo.HostEnvironmentInfo.Architecture);
+            env.DotNetCliVersion.ShouldBe(hostInfo.HostEnvironmentInfo.DotNetCliVersion);
+            env.DotNetRuntimeVersion.ShouldBe(hostInfo.HostEnvironmentInfo.RuntimeVersion);
         }
 
         [Theory]
@@ -103,22 +103,22 @@ public void GetBenchmarkResults_ValuesParsed(string fullName, string benchmarkNa
 
             var results = new BenchmarkParser(json).GetBenchmarkResults().ToList();
 
-            results[0].FullName.Should().Be(benchmark.FullName);
-            results[0].Namespace.Should().Be(benchmark.Namespace);
-            results[0].Type.Should().Be(benchmark.Type);
-            results[0].Method.Should().Be(benchmark.Method);
-            results[0].Parameters.Should().Be(benchmark.Parameters);
-            results[0].MinTime.Should().Be(benchmark.Statistics.Min);
-            results[0].MaxTime.Should().Be(benchmark.Statistics.Max);
-            results[0].MeanTime.Should().Be(benchmark.Statistics.Mean);
-            results[0].MedianTime.Should().Be(benchmark.Statistics.Median);
-            results[0].Q1Time.Should().Be(benchmark.Statistics.Q1);
-            results[0].Q3Time.Should().Be(benchmark.Statistics.Q3);
-
-            results[0].Gen0Collections.Should().Be(benchmark.Memory.Gen0Collections);
-            results[0].Gen1Collections.Should().Be(benchmark.Memory.Gen1Collections);
-            results[0].Gen2Collections.Should().Be(benchmark.Memory.Gen2Collections);
-            results[0].BytesAllocatedPerOp.Should().Be(benchmark.Memory.BytesAllocatedPerOperation);
+            results[0].FullName.ShouldBe(benchmark.FullName);
+            results[0].Namespace.ShouldBe(benchmark.Namespace);
+            results[0].Type.ShouldBe(benchmark.Type);
+            results[0].Method.ShouldBe(benchmark.Method);
+            results[0].Parameters.ShouldBe(benchmark.Parameters);
+            results[0].MinTime.ShouldBe(benchmark.Statistics.Min);
+            results[0].MaxTime.ShouldBe(benchmark.Statistics.Max);
+            results[0].MeanTime.ShouldBe(benchmark.Statistics.Mean);
+            results[0].MedianTime.ShouldBe(benchmark.Statistics.Median);
+            results[0].Q1Time.ShouldBe(benchmark.Statistics.Q1);
+            results[0].Q3Time.ShouldBe(benchmark.Statistics.Q3);
+
+            results[0].Gen0Collections.ShouldBe(benchmark.Memory.Gen0Collections);
+            results[0].Gen1Collections.ShouldBe(benchmark.Memory.Gen1Collections);
+            results[0].Gen2Collections.ShouldBe(benchmark.Memory.Gen2Collections);
+            results[0].BytesAllocatedPerOp.ShouldBe(benchmark.Memory.BytesAllocatedPerOperation);
         }
 
         [Theory]
@@ -154,22 +154,22 @@ public void GetBenchmarkResults_WithoutMemory_ValuesParsed(string fullName, stri
 
             var results = new BenchmarkParser(json).GetBenchmarkResults().ToList();
 
-            results[0].FullName.Should().Be(benchmark.FullName);
-            results[0].Namespace.Should().Be(benchmark.Namespace);
-            results[0].Type.Should().Be(benchmark.Type);
-            results[0].Method.Should().Be(benchmark.Method);
-            results[0].Parameters.Should().Be(benchmark.Parameters);
-            results[0].MinTime.Should().Be(benchmark.Statistics.Min);
-            results[0].MaxTime.Should().Be(benchmark.Statistics.Max);
-            results[0].MeanTime.Should().Be(benchmark.Statistics.Mean);
-            results[0].MedianTime.Should().Be(benchmark.Statistics.Median);
-            results[0].Q1Time.Should().Be(benchmark.Statistics.Q1);
-            results[0].Q3Time.Should().Be(benchmark.Statistics.Q3);
-
-            results[0].Gen0Collections.Should().BeNull();
-            results[0].Gen1Collections.Should().BeNull(); ;
-            results[0].Gen2Collections.Should().BeNull(); ;
-            results[0].BytesAllocatedPerOp.Should().BeNull();
+            results[0].FullName.ShouldBe(benchmark.FullName);
+            results[0].Namespace.ShouldBe(benchmark.Namespace);
+            results[0].Type.ShouldBe(benchmark.Type);
+            results[0].Method.ShouldBe(benchmark.Method);
+            results[0].Parameters.ShouldBe(benchmark.Parameters);
+            results[0].MinTime.ShouldBe(benchmark.Statistics.Min);
+            results[0].MaxTime.ShouldBe(benchmark.Statistics.Max);
+            results[0].MeanTime.ShouldBe(benchmark.Statistics.Mean);
+            results[0].MedianTime.ShouldBe(benchmark.Statistics.Median);
+            results[0].Q1Time.ShouldBe(benchmark.Statistics.Q1);
+            results[0].Q3Time.ShouldBe(benchmark.Statistics.Q3);
+
+            results[0].Gen0Collections.ShouldBeNull();
+            results[0].Gen1Collections.ShouldBeNull(); ;
+            results[0].Gen2Collections.ShouldBeNull(); ;
+            results[0].BytesAllocatedPerOp.ShouldBeNull();
         }
 
 
@@ -197,17 +197,17 @@ public void GetBenchmarkResults_NoStats_ValuesParsed(string fullName, string ben
 
             var results = new BenchmarkParser(json).GetBenchmarkResults().ToList();
 
-            results[0].FullName.Should().Be(benchmark.FullName);
-            results[0].Namespace.Should().Be(benchmark.Namespace);
-            results[0].Type.Should().Be(benchmark.Type);
-            results[0].Method.Should().Be(benchmark.Method);
-            results[0].Parameters.Should().Be(benchmark.Parameters);
-            results[0].MinTime.Should().BeNull();
-            results[0].MaxTime.Should().BeNull();
-            results[0].MeanTime.Should().BeNull();
-            results[0].MedianTime.Should().BeNull();
-            results[0].Q1Time.Should().BeNull();
-            results[0].Q3Time.Should().BeNull();
+            results[0].FullName.ShouldBe(benchmark.FullName);
+            results[0].Namespace.ShouldBe(benchmark.Namespace);
+            results[0].Type.ShouldBe(benchmark.Type);
+            results[0].Method.ShouldBe(benchmark.Method);
+            results[0].Parameters.ShouldBe(benchmark.Parameters);
+            results[0].MinTime.ShouldBeNull();
+            results[0].MaxTime.ShouldBeNull();
+            results[0].MeanTime.ShouldBeNull();
+            results[0].MedianTime.ShouldBeNull();
+            results[0].Q1Time.ShouldBeNull();
+            results[0].Q3Time.ShouldBeNull();
         }
 
     }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkStatisticAccessorProviderTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkStatisticAccessorProviderTests.cs
index 0cfb08c..4a55b48 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkStatisticAccessorProviderTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Benchmarks/BenchmarkStatisticAccessorProviderTests.cs
@@ -1,6 +1,6 @@
 using System.Linq;
 using BenchmarkDotNetAnalyser.Benchmarks;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -19,7 +19,7 @@ public void GetAccessor_NullName_DefaultReturned(string name)
             var p = new BenchmarkStatisticAccessorProvider();
             var a = p.GetAccessor(name);
 
-            a.Should().NotBeNull();
+            a.ShouldNotBeNull();
         }
 
         [Theory]
@@ -41,7 +41,7 @@ public void GetAccessor_AccessorFound(string name, bool upper)
             var p = new BenchmarkStatisticAccessorProvider();
             var a = p.GetAccessor(name);
 
-            a.Should().NotBeNull();
+            a.ShouldNotBeNull();
         }
 
         [Property(Verbose = true)]
@@ -74,7 +74,7 @@ public void GetAccessor_AccessorFound_AccessorEvaluates(string name, decimal exp
 
             var result = a(br);
 
-            result.Should().Be(expected);
+            result.ShouldBe(expected);
         }
 
         
@@ -88,7 +88,7 @@ public void GetNullableAccessor_NullName_DefaultReturned(string name)
             var p = new BenchmarkStatisticAccessorProvider();
             var a = p.GetNullableAccessor(name);
 
-            a.Should().NotBeNull();
+            a.ShouldNotBeNull();
         }
 
         [Theory]
@@ -110,7 +110,7 @@ public void GetNullableAccessor_AccessorFound(string name, bool upper)
             var p = new BenchmarkStatisticAccessorProvider();
             var a = p.GetNullableAccessor(name);
 
-            a.Should().NotBeNull();
+            a.ShouldNotBeNull();
         }
 
         [Property(Verbose = true)]
@@ -151,7 +151,7 @@ public void GetNullableAccessor_AccessorFound_AccessorEvaluates(string name, dec
 
             var result = a(br);
 
-            result.Should().Be(expected);
+            result.ShouldBe(expected);
         }
 
         [Theory]
@@ -183,7 +183,7 @@ public void GetNullableAccessor_AccessorFound_AccessorEvaluates_2(string name)
 
             var result = a(br);
 
-            result.Should().BeNull();
+            result.ShouldBeNull();
         }
 
         [Fact]
@@ -192,9 +192,9 @@ public void GetAccessorInfos_UniquesReturned()
             var p = new BenchmarkStatisticAccessorProvider();
             var result = p.GetAccessorInfos().ToList();
 
-            result.Count.Should().BeGreaterThan(0);
-            result.Distinct().Should().BeEquivalentTo(result);
-            result.All(s => !string.IsNullOrWhiteSpace(s.Name)).Should().BeTrue();
+            result.Count.ShouldBeGreaterThan(0);
+            result.Distinct().ShouldBe(result);
+            result.All(s => !string.IsNullOrWhiteSpace(s.Name)).ShouldBeTrue();
         }
 
         [Fact]
@@ -203,7 +203,7 @@ public void GetAccessorInfos_OrderedReturn()
             var p = new BenchmarkStatisticAccessorProvider();
             var result = p.GetAccessorInfos().ToList();
             
-            result.Should().BeInAscendingOrder(x => x.Name);
+            result.Select(x => x.Name).ShouldBe(result.Select(x => x.Name).OrderBy(x => x));
         }
 
         [Fact]
@@ -212,7 +212,7 @@ public void GetAccessorInfos_SingleIsDefault()
             var p = new BenchmarkStatisticAccessorProvider();
             var result = p.GetAccessorInfos().ToList();
 
-            result.SingleOrDefault(x => x.IsDefault).Should().NotBeNull();
+            result.SingleOrDefault(x => x.IsDefault).ShouldNotBeNull();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksCommandTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksCommandTests.cs
index 34ffdd8..5f49f2c 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksCommandTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksCommandTests.cs
@@ -2,7 +2,7 @@
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -26,7 +26,7 @@ public async Task OnExecuteAsync_ValidationError_ReturnsError()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().BeGreaterThan(0);
+            rc.ShouldBeGreaterThan(0);
             executor.Received(0);
         }
 
@@ -45,7 +45,7 @@ public async Task OnExecuteAsync_NoValidationError_ExecuteOk_ReturnsOk()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().Be(0);
+            rc.ShouldBe(0);
             executor.Received(1);
             telemetry.Received(0);
         }
@@ -65,7 +65,7 @@ public async Task OnExecuteAsync_NoValidationError_ExecuteError_ReturnsError()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().BeGreaterThan(0);
+            rc.ShouldBeGreaterThan(0);
             executor.Received(1);
             telemetry.Received(1);
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksExecutorTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksExecutorTests.cs
index d0b2ef3..486c9a2 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksExecutorTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AggregateBenchmarksExecutorTests.cs
@@ -7,7 +7,7 @@
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
 using BenchmarkDotNetAnalyser.IO;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -64,7 +64,7 @@ public async Task ExecuteAsync_BenchmarksAggregated_AggregateWritten(int aggrega
 
             var r = await exec.ExecuteAsync(args);
 
-            r.Should().BeTrue();
+            r.ShouldBeTrue();
 
             aggregator.Received(1).Aggregate(Arg.Is<BenchmarkAggregationOptions>(x => x.PreservePinned),
                 Arg.Any<IEnumerable<BenchmarkInfo>>(), Arg.Any<BenchmarkInfo>());
@@ -102,7 +102,7 @@ public async Task ExecuteAsync_Success_ConsoleMessagesSent()
 
             var r = await exec.ExecuteAsync(args);
 
-            r.Should().BeTrue();
+            r.ShouldBeTrue();
 
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "Getting new benchmark..."));
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "Getting prior benchmarks..."));
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandTests.cs
index c200354..b42ab72 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandTests.cs
@@ -4,7 +4,7 @@
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -29,7 +29,7 @@ public async Task OnExecuteAsync_ValidationError_ReturnsError()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().BeGreaterThan(0);
+            rc.ShouldBeGreaterThan(0);
             executor.Received(0);
         }
 
@@ -54,7 +54,7 @@ public async Task OnExecuteAsync_NoValidationError_ExecuteOk_ReturnsOk()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().Be(0);
+            rc.ShouldBe(0);
             executor.Received(1);
             telemetry.Received(0);
         }
@@ -77,7 +77,7 @@ public async Task OnExecuteAsync_NoValidationError_ExecuteError_ReturnsError()
 
             var rc = await cmd.OnExecuteAsync();
 
-            rc.Should().BeGreaterThan(0);
+            rc.ShouldBeGreaterThan(0);
             executor.Received(1);
             telemetry.Received(1);
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandValidatorTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandValidatorTests.cs
index a6bf501..a9bccbc 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandValidatorTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksCommandValidatorTests.cs
@@ -6,7 +6,7 @@
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using NSubstitute;
@@ -121,7 +121,7 @@ public bool Validate_MaxErrors_InvalidForm(DirectoryInfo path, string maxErrors)
             }
             catch (InvalidOperationException ex)
             {
-                ex.Message.Should().NotBeNullOrWhiteSpace();
+                ex.Message.ShouldNotBeNullOrWhiteSpace();
                 return true;
             }
         }
@@ -150,7 +150,7 @@ public bool Validate_MaxErrors_NegativeValue(DirectoryInfo path, NegativeInt max
             }
             catch (InvalidOperationException ex)
             {
-                ex.Message.Should().NotBeNullOrWhiteSpace();
+                ex.Message.ShouldNotBeNullOrWhiteSpace();
                 return true;
             }
         }
@@ -214,7 +214,7 @@ public bool Validate_Tolerance_InvalidForm(DirectoryInfo path, string tolerance)
             }
             catch (InvalidOperationException ex)
             {
-                ex.Message.Should().NotBeNullOrWhiteSpace();
+                ex.Message.ShouldNotBeNullOrWhiteSpace();
                 return true;
             }
         }
@@ -242,7 +242,7 @@ public bool Validate_Tolerance_NegativeValue(DirectoryInfo path, NegativeInt tol
             }
             catch (InvalidOperationException ex)
             {
-                ex.Message.Should().NotBeNullOrWhiteSpace();
+                ex.Message.ShouldNotBeNullOrWhiteSpace();
                 return true;
             }
         }
@@ -274,7 +274,7 @@ public bool Validate_Statistic_UnknownStatistic_ExceptionThrown(DirectoryInfo pa
             }
             catch (InvalidOperationException ex)
             {
-                ex.Message.Should().NotBeNullOrWhiteSpace();
+                ex.Message.ShouldNotBeNullOrWhiteSpace();
                 return true;
             }
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksExecutorTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksExecutorTests.cs
index 1396e7a..6d14c98 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksExecutorTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/AnalyseBenchmarksExecutorTests.cs
@@ -4,7 +4,7 @@
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -26,7 +26,7 @@ public async Task ExecuteAsync_EmptyBenchmarks_ReturnsFalse()
 
             var result = await exec.ExecuteAsync(args);
 
-            result.MeetsRequirements.Should().BeFalse();
+            result.MeetsRequirements.ShouldBeFalse();
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "Getting benchmarks..."));
             telemetry.Received(1).Error(Arg.Is<string>(x => x == "No benchmarks found."));
         } 
@@ -67,7 +67,7 @@ public async Task ExecuteAsync_SingleBenchmark_MeetsRequirements_ReturnsTrue()
 
             var result = await exec.ExecuteAsync(args);
 
-            result.MeetsRequirements.Should().BeTrue();
+            result.MeetsRequirements.ShouldBeTrue();
             telemetry.Received(1).Info(Arg.Is<string>(x => x == "Analysing benchmarks..."));
             telemetry.Received(1).Info(Arg.Is<string>(x => x == "Analysis done."));
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "Getting benchmarks..."));
@@ -104,7 +104,7 @@ public async Task ExecuteAsync_SingleBenchmark_DoesNot_MeetsRequirements_Returns
 
             var result = await exec.ExecuteAsync(args);
 
-            result.MeetsRequirements.Should().BeFalse();
+            result.MeetsRequirements.ShouldBeFalse();
             telemetry.Received(1).Info(Arg.Is<string>(x => x == "Analysing benchmarks..."));
             telemetry.Received(1).Info(Arg.Is<string>(x => x == "Analysis done."));
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "Getting benchmarks..."));
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/CommandExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/CommandExtensionsTests.cs
index db39950..3de62be 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/CommandExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/CommandExtensionsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.ComponentModel;
 using BenchmarkDotNetAnalyser.Commands;
-using FluentAssertions;
+using Shouldly;
 using McMaster.Extensions.CommandLineUtils;
 using Xunit;
 
@@ -29,7 +29,7 @@ public void ToReturnCode_ValuesMapped(bool input, int expected)
         {
             var r = input.ToReturnCode();
 
-            r.Should().Be(expected);
+            r.ShouldBe(expected);
         }
 
         [Theory]
@@ -41,7 +41,7 @@ public void GetCommandOptionName_NameFound(Type commandType, string propName, st
             
             var name = cmd.GetCommandOptionName(propName);
 
-            name.Should().Be(expected);
+            name.ShouldBe(expected);
         }
 
         [Theory]
@@ -55,7 +55,7 @@ public void GetCommandOptionName_NameNotFound(Type commandType, string propName)
             
             var name = cmd.GetCommandOptionName(propName);
 
-            name.Should().BeNull();
+            name.ShouldBeNull();
         }
         
         [Theory]
@@ -67,7 +67,7 @@ public void GetCommandOptionName_NameFound_NoAttribute(string propName)
             
             var name = cmd.GetCommandOptionName(propName);
 
-            name.Should().BeNull();
+            name.ShouldBeNull();
         }
         
 
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/VersionCommandTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/VersionCommandTests.cs
index aa7d93f..40c8541 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/VersionCommandTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Commands/VersionCommandTests.cs
@@ -1,6 +1,6 @@
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Commands;
-using FluentAssertions;
+using Shouldly;
 using McMaster.Extensions.CommandLineUtils;
 using NSubstitute;
 using Xunit;
@@ -20,7 +20,7 @@ public async Task OnExecuteAsync_OkReturned()
 
             var result = await cmd.OnExecuteAsync();
 
-            result.Should().Be(0);
+            result.ShouldBe(0);
             console.WriteLine(Arg.Any<string>());
             writer.Received(1).WriteLine(Arg.Any<string>());
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/EnumerableExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/EnumerableExtensionsTests.cs
index 9da23ea..f93c751 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/EnumerableExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/EnumerableExtensionsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Linq;
-using FluentAssertions;
-using FluentAssertions.Execution;
+using Shouldly;
+
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -15,9 +15,9 @@ public void MinBy_Decimal_EmptySequence_ExceptionThrown()
         {
             var xs = Enumerable.Empty<decimal>();
 
-            Func<decimal> f = () => xs.MinBy(x => x);
+            Action f = () => xs.MinBy(x => x);
 
-            f.Should().Throw<InvalidOperationException>();
+            f.ShouldThrow<InvalidOperationException>();
         }
 
         [Fact]
@@ -33,7 +33,7 @@ public void MinBy_Decimal_EmptySequence_ExceptionMessageNonEmpty()
             {
                 if (string.IsNullOrWhiteSpace(e.Message))
                 {
-                    throw new AssertionFailedException("Missing message");
+                    throw new Exception("Missing message");
                 }
             }
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/ColourExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/ColourExtensionsTests.cs
index 4bab79f..19b4a05 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/ColourExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/ColourExtensionsTests.cs
@@ -1,6 +1,6 @@
 using System;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using FsCheck.Xunit;
 using Xunit;
 
@@ -15,7 +15,7 @@ public void Colourise_NullValue_ReturnsNull()
 
             var r = value.Colourise(ConsoleColor.Blue);
 
-            r.Should().BeNullOrEmpty();
+            r.ShouldBeNullOrEmpty();
         }
 
         [Property(Verbose = true, Arbitrary = new[] {typeof(AlphanumericStringArbitrary)})]
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/TelemetryExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/TelemetryExtensionsTests.cs
index e69b893..574f258 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/TelemetryExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Instrumentation/TelemetryExtensionsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Threading.Tasks;
 using BenchmarkDotNetAnalyser.Instrumentation;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -18,7 +18,7 @@ public async Task InvokeWithLoggingAsync_ResultReturned()
 
             var result = await telemetry.InvokeWithLoggingAsync(log, () => Task.FromResult(response));
 
-            result.Should().Be(response);
+            result.ShouldBe(response);
 
             telemetry.Received(2).Write(Arg.Any<TelemetryEntry>());
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "done." && x.AddLineBreak));
@@ -34,7 +34,7 @@ public void InvokeWithLoggingAsync_ExceptionThrown()
 
             Func<Task<int>> f = async () => await telemetry.InvokeWithLoggingAsync(log, func);
 
-            f.Should().ThrowAsync<Exception>();
+            f.ShouldThrowAsync<Exception>();
             telemetry.Received(2).Write(Arg.Any<TelemetryEntry>());
             telemetry.Received(1).Write(Arg.Is<TelemetryEntry>(x => x.Message == "" && x.AddLineBreak));
         }
@@ -48,7 +48,7 @@ public void InvokeWithLogging_ResultReturned()
 
             var result = telemetry.InvokeWithLogging(log, () => response);
 
-            result.Should().Be(response);
+            result.ShouldBe(response);
 
             telemetry.Received(2).Write(Arg.Any<TelemetryEntry>());
         }
@@ -61,9 +61,9 @@ public void InvokeWithLogging_ExceptionThrown()
             
             Func<int> func = () => throw new Exception();
 
-            Func<int> f = () => telemetry.InvokeWithLogging(log, func);
+            Action f = () => telemetry.InvokeWithLogging(log, func);
 
-            f.Should().Throw<Exception>();
+            f.ShouldThrow<Exception>();
             telemetry.Received(2).Write(Arg.Any<TelemetryEntry>());
         }
 
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/ObjectExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/ObjectExtensionsTests.cs
index 01fdcb7..d5c0446 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/ObjectExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/ObjectExtensionsTests.cs
@@ -1,5 +1,5 @@
 using System;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -22,9 +22,9 @@ public bool Pipe_ValuePiped(PositiveInt value)
         public void Pipe_NullSelector_ExceptionThrown()
         {
             Func<string, int> s = null;
-            Func<int> f = () => "".Pipe(s);
+            Action f = () => "".Pipe(s);
 
-            f.Should().Throw<ArgumentNullException>();
+            f.ShouldThrow<ArgumentNullException>();
         }
 
         [Fact]
@@ -33,9 +33,9 @@ public void Pipe_NullValue_ExceptionThrown()
             string str = null;
             Func<string, int> sel = s => { throw new AccessViolationException(); };
             
-            Func<int> f = () => str.Pipe(sel); // for clarity throw a completely unrelated exception 
+            Action f = () => str.Pipe(sel); // for clarity throw a completely unrelated exception 
 
-            f.Should().Throw<AccessViolationException>();
+            f.ShouldThrow<AccessViolationException>();
         }
 
         [Property]
@@ -53,9 +53,9 @@ public bool PipeIfNotNull_ValuePiped(NonEmptyString value)
         public void PipeIfNotNull_NullSelector_ExceptionThrown()
         {
             Func<string, int> s = null;
-            Func<int> f = () => "".PipeIfNotNull(s);
+            Action f = () => "".PipeIfNotNull(s);
 
-            f.Should().Throw<ArgumentNullException>();
+            f.ShouldThrow<ArgumentNullException>();
         }
 
         [Fact]
@@ -66,7 +66,7 @@ public void PipeIfNotNull_NullValue_NullNotPropagated()
             int defaultValue = 1234;
             var r = str.PipeIfNotNull(s => s.Length, defaultValue);
 
-            r.Should().Be(defaultValue);
+            r.ShouldBe(defaultValue);
         }
 
         [Property]
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/ParameterExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/ParameterExtensionsTests.cs
index 4e81149..47eeee9 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/ParameterExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/ParameterExtensionsTests.cs
@@ -1,5 +1,5 @@
 using System;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -29,7 +29,7 @@ public void ArgNotNull_ExceptionThrown(string paramName)
             }
             catch (ArgumentNullException ex)
             {
-                ex.ParamName.Should().Be(paramName);
+                ex.ParamName.ShouldBe(paramName);
             }
         }
 
@@ -62,9 +62,9 @@ public void InvalidOpArg_PredicateNull_ExceptionThrown()
         {
             Func<string, bool> sel = null;
 
-            Func<string> f = () => "abc".InvalidOpArg(sel, "message");
+            Action f = () => "abc".InvalidOpArg(sel, "message");
 
-            f.Should().Throw<ArgumentNullException>();
+            f.ShouldThrow<ArgumentNullException>();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/ProgramBootstrapTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/ProgramBootstrapTests.cs
index 78b6694..a9581d7 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/ProgramBootstrapTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/ProgramBootstrapTests.cs
@@ -4,7 +4,7 @@
 using BenchmarkDotNetAnalyser.Commands;
 using BenchmarkDotNetAnalyser.Instrumentation;
 using BenchmarkDotNetAnalyser.IO;
-using FluentAssertions;
+using Shouldly;
 using McMaster.Extensions.CommandLineUtils;
 using Xunit;
 
@@ -27,7 +27,7 @@ public void CreateServiceCollection_ServiceInjected(Type serviceType)
             
             var service = result.GetService(serviceType);
 
-            service.Should().NotBeNull();
+            service.ShouldNotBeNull();
         }
 
         [Fact]
@@ -35,7 +35,7 @@ public void GetDescription_SolidTextReturned()
         {
             var result = ProgramBootstrap.GetDescription();
 
-            result.Should().NotBeNullOrWhiteSpace();
+            result.ShouldNotBeNullOrWhiteSpace();
         }
     }
 }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/ReflectionExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/ReflectionExtensionsTests.cs
index 4b2b8c0..7972e78 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/ReflectionExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/ReflectionExtensionsTests.cs
@@ -2,7 +2,7 @@
 using System.ComponentModel;
 using System.Linq;
 using System.Reflection;
-using FluentAssertions;
+using Shouldly;
 using Xunit;
 
 namespace BenchmarkDotNetAnalyser.Tests.Unit
@@ -29,7 +29,7 @@ public void GetAttributeValue_CopyrightValueRetrieved()
 
             var r = attrs.GetAttributeValue<AssemblyCopyrightAttribute>(a => a.Copyright);
 
-            r.Should().NotBeNullOrWhiteSpace();
+            r.ShouldNotBeNullOrWhiteSpace();
         }
 
         [Fact]
@@ -39,14 +39,14 @@ public void GetAttributeValue_AttributeNotRetrieved()
 
             var r = attrs.GetAttributeValue<StubAttribute>(a => a.ToString());
 
-            r.Should().BeNullOrEmpty();
+            r.ShouldBeNullOrEmpty();
         }
 
         [Fact]
         public void GetMemberAttributePairs_UnknownAttribute_ReturnsEmpty()
         {
             var r = typeof(Program).GetMemberAttributePairs<StubAttribute>().ToList();
-            r.Should().BeEmpty();
+            r.ShouldBeEmpty();
         }
 
         [Fact]
@@ -58,8 +58,8 @@ public void GetMemberAttributePairs_UsedAttribute_ReturnsNonEmpty()
             var actualMembers = r.Select(t => t.Item1.Name);
             var actualAttributes = r.Select(t => t.Item2);
 
-            actualMembers.Should().BeEquivalentTo(expectedMembers);
-            actualAttributes.All(a => a is StubAttribute).Should().BeTrue();
+            actualMembers.ShouldBe(expectedMembers);
+            actualAttributes.All(a => a is StubAttribute).ShouldBeTrue();
         }
 
         [Fact]
@@ -70,8 +70,8 @@ public void GetMemberAttributePairs_UsedAttributeInBaseClass_ReturnsNonEmpty()
             var actualMembers = r.Select(t => t.Item1.Name);
             var actualAttributes = r.Select(t => t.Item2);
 
-            actualMembers.Should().BeEquivalentTo(expectedMembers);
-            actualAttributes.All(a => a is StubAttribute).Should().BeTrue();
+            actualMembers.ShouldBe(expectedMembers);
+            actualAttributes.All(a => a is StubAttribute).ShouldBeTrue();
         }
 
     }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/CsvBenchmarksReportGeneratorTest.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/CsvBenchmarksReportGeneratorTest.cs
index ec4fd7b..396ab8a 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/CsvBenchmarksReportGeneratorTest.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/CsvBenchmarksReportGeneratorTest.cs
@@ -3,7 +3,7 @@
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.IO;
 using BenchmarkDotNetAnalyser.Reporting;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -31,7 +31,7 @@ public async Task GenerateAsync_BenchmarksFlowThrough()
             
             var results = await gen.GenerateAsync(args);
 
-            results.Should().NotBeNull();
+            results.ShouldNotBeNull();
             await reader.Received(1).GetBenchmarkAsync(Arg.Is<string>(s => s == args.AggregatesPath), Arg.Any<IList<string>>());
             csvWriter.Received(1).Write<object>(Arg.Any<IEnumerable<object>>(), Arg.Is<string>(s => s.EndsWith("benchmarks.csv")));
         }
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/JsonBenchmarksReportGeneratorTest.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/JsonBenchmarksReportGeneratorTest.cs
index 4d91915..1ad6394 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/JsonBenchmarksReportGeneratorTest.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/Reporting/JsonBenchmarksReportGeneratorTest.cs
@@ -6,7 +6,7 @@
 using BenchmarkDotNetAnalyser.Benchmarks;
 using BenchmarkDotNetAnalyser.IO;
 using BenchmarkDotNetAnalyser.Reporting;
-using FluentAssertions;
+using Shouldly;
 using NSubstitute;
 using Xunit;
 
@@ -34,7 +34,7 @@ public async Task GenerateAsync_BenchmarksFlowThrough()
 
             var results = await gen.GenerateAsync(args);
 
-            results.Should().NotBeNull();
+            results.ShouldNotBeNull();
             await reader.Received(1)
                 .GetBenchmarkAsync(Arg.Is<string>(s => s == args.AggregatesPath), Arg.Any<IList<string>>());
             await jsonWriter.Received(1).WriteAsync<object>(Arg.Any<IEnumerable<object>>(),
diff --git a/test/BenchmarkDotNetAnalyser.Tests.Unit/StringExtensionsTests.cs b/test/BenchmarkDotNetAnalyser.Tests.Unit/StringExtensionsTests.cs
index 4a24902..eb6ca1a 100644
--- a/test/BenchmarkDotNetAnalyser.Tests.Unit/StringExtensionsTests.cs
+++ b/test/BenchmarkDotNetAnalyser.Tests.Unit/StringExtensionsTests.cs
@@ -1,7 +1,7 @@
 using System;
 using System.Globalization;
 using System.Linq;
-using FluentAssertions;
+using Shouldly;
 using FsCheck;
 using FsCheck.Xunit;
 using Xunit;
@@ -152,7 +152,7 @@ public bool ToInt_Passes(PositiveInt value)
         [InlineData("Époisses", "Époisses")]
         public void IsMatch_PositiveMatches(string value, string pattern)
         {
-            value.IsMatch(pattern).Should().BeTrue();
+            value.IsMatch(pattern).ShouldBeTrue();
         }
 
         [Theory]
@@ -166,7 +166,7 @@ public void IsMatch_PositiveMatches(string value, string pattern)
         [InlineData("Époisses", "Epoisses")]
         public void IsMatch_NegativeMatches(string value, string pattern)
         {
-            value.IsMatch(pattern).Should().BeFalse();
+            value.IsMatch(pattern).ShouldBeFalse();
         }
     }
 }