diff --git a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetCoverageRunnerTests.cs b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetCoverageRunnerTests.cs
index f285a62..eb99749 100644
--- a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetCoverageRunnerTests.cs
+++ b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetCoverageRunnerTests.cs
@@ -1,16 +1,12 @@
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Parsing;
-using System.Diagnostics;
-using System.IO.Abstractions;
+using System.Diagnostics;
 using dotnet_test_rerun.IntegrationTests.Utilities;
-using dotnet.test.rerun.Analyzers;
 using dotnet.test.rerun.DotNetRunner;
 using dotnet.test.rerun.Enums;
 using dotnet.test.rerun.Logging;
 using dotnet.test.rerun.RerunCommand;
 using FluentAssertions;
-using Moq;
+using NSubstitute;
+using NSubstitute.ExceptionExtensions;
 using Xunit;
 
 namespace dotnet_test_rerun.UnitTest.DotNetTestRunner;
@@ -25,8 +21,8 @@ public async Task Merge_GetNoErrors_Proceed(CoverageFormat? coverageFormat)
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution.Object);
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution);
         var _dir = TestUtilities.GetTmpDirectory();
         var configuration = new RerunCommandConfiguration()
         {
@@ -34,20 +30,19 @@ public async Task Merge_GetNoErrors_Proceed(CoverageFormat? coverageFormat)
         };
 
         TestUtilities.CopyFixture("DotNetCoverage", new DirectoryInfo(_dir));
-        
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>())).Verifiable();
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>())).Verifiable();
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(0).Verifiable();
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process()).Verifiable();
+
+        processExecution.End(Arg.Any<Process>()).Returns(0);
+        processExecution.Start(Arg.Any<ProcessStartInfo>()).Returns(new Process());
 
         // Act
         var act = () => dotNetCoverageRunner.Merge(configuration, _dir, DateTime.MinValue);
 
         // Assert
         await act.Should().NotThrowAsync<RerunException>();
-        processExecution.VerifyAll();
+        processExecution.Received(1).FetchOutput(Arg.Any<Process>());
+        processExecution.Received(1).FetchError(Arg.Any<Process>());
+        await processExecution.Received(1).End(Arg.Any<Process>());
+        await processExecution.Received(1).Start(Arg.Any<ProcessStartInfo>());
     }
     
     [Fact]
@@ -55,8 +50,8 @@ public async Task Merge_GetNoErrors_WithInvalidCoverageFormat()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution.Object);
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution);
         var _dir = TestUtilities.GetTmpDirectory();
         var configuration = new RerunCommandConfiguration()
         {
@@ -77,8 +72,8 @@ public async Task Merge_GetErrorsWhileExecuting_Fail()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution.Object);
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution);
         var _dir = TestUtilities.GetTmpDirectory();
         var configuration = new RerunCommandConfiguration()
         {
@@ -88,21 +83,20 @@ public async Task Merge_GetErrorsWhileExecuting_Fail()
 
         TestUtilities.CopyFixture("DotNetCoverage", new DirectoryInfo(_dir));
         
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>())).Verifiable();
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>())).Verifiable();
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(1).Verifiable();
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process()).Verifiable();
-        processExecution.Setup(x => x.GetError())
-            .Returns(errorMessage).Verifiable();
+        processExecution.End(Arg.Any<Process>()).Returns(1);
+        processExecution.Start(Arg.Any<ProcessStartInfo>())!.Returns(new Process());
+        processExecution.GetError().Returns(errorMessage);
 
         // Act
         var act = () => dotNetCoverageRunner.Merge(configuration, _dir, DateTime.MinValue);
 
         // Assert
         await act.Should().ThrowAsync<RerunException>().WithMessage($"*{errorMessage}");
-        processExecution.VerifyAll();
+        processExecution.Received(1).FetchOutput(Arg.Any<Process>());
+        processExecution.Received(1).FetchError(Arg.Any<Process>());
+        await processExecution.Received(1).End(Arg.Any<Process>());
+        await processExecution.Received(1).Start(Arg.Any<ProcessStartInfo>());
+        processExecution.Received(2).GetError();
     }
     
     [Fact]
@@ -110,8 +104,8 @@ public async Task Merge_GetExceptionWhileExecuting_Fail()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution.Object);
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetCoverageRunner = new DotNetCoverageRunner(logger, processExecution);
         var _dir = TestUtilities.GetTmpDirectory();
         var configuration = new RerunCommandConfiguration()
         {
@@ -121,14 +115,12 @@ public async Task Merge_GetExceptionWhileExecuting_Fail()
 
         TestUtilities.CopyFixture("DotNetCoverage", new DirectoryInfo(_dir));
         
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ThrowsAsync(new Exception(errorMessage)).Verifiable();
+        processExecution.Start(Arg.Any<ProcessStartInfo>()).Throws(new Exception(errorMessage));
 
         // Act
         var act = () => dotNetCoverageRunner.Merge(configuration, _dir, DateTime.MinValue);
 
         // Assert
         await act.Should().ThrowAsync<RerunException>().WithMessage($"*{errorMessage}");
-        processExecution.VerifyAll();
     }
 }
\ No newline at end of file
diff --git a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetTestRunnerTests.cs b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetTestRunnerTests.cs
index 58b2b5a..ee216dd 100644
--- a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetTestRunnerTests.cs
+++ b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/DotNetTestRunnerTests.cs
@@ -1,15 +1,10 @@
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Parsing;
-using System.Diagnostics;
-using System.IO.Abstractions;
-using dotnet.test.rerun.Analyzers;
+using System.Diagnostics;
 using dotnet.test.rerun.DotNetRunner;
 using dotnet.test.rerun.Enums;
 using dotnet.test.rerun.Logging;
 using dotnet.test.rerun.RerunCommand;
 using FluentAssertions;
-using Moq;
+using NSubstitute;
 using Xunit;
 
 namespace dotnet_test_rerun.UnitTest.DotNetTestRunner;
@@ -21,8 +16,8 @@ public void GetErrorCode_GetDefaultValue()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution.Object);
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution);
 
         // Act
         var error = dotNetTestRunner.GetErrorCode();
@@ -36,18 +31,16 @@ public async Task Test_GetNoErrors_Proceed()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution.Object);
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>()));
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>()));
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(0);
-        processExecution.Setup(x => x.GetOutput())
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution);
+        processExecution.End(Arg.Any<Process>())
+            .Returns(0);
+        processExecution.GetOutput()
             .Returns("No errors");
-        processExecution.Setup(x => x.GetError())
+        processExecution.GetError()
             .Returns(string.Empty);
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process());
+        processExecution.Start(Arg.Any<ProcessStartInfo>())
+            .Returns(new Process());
 
         // Act
         await dotNetTestRunner.Test(new RerunCommandConfiguration(), "resultsDirectory");
@@ -61,18 +54,16 @@ public async Task Test_GetErrors_UnknownError()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution.Object);
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>()));
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>()));
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(1);
-        processExecution.Setup(x => x.GetOutput())
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution);
+        processExecution.End(Arg.Any<Process>())
+            .Returns(1);
+        processExecution.GetOutput()
             .Returns(string.Empty);
-        processExecution.Setup(x => x.GetError())
+        processExecution.GetError()
             .Returns("Unexpected error");
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process());
+        processExecution.Start(Arg.Any<ProcessStartInfo>())
+            .Returns(new Process());
 
         // Act
         var act = () => dotNetTestRunner.Test(new RerunCommandConfiguration(), "resultsDirectory");
@@ -87,18 +78,16 @@ public async Task Test_GetErrors_WellKnownError()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution.Object);
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>()));
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>()));
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(1);
-        processExecution.Setup(x => x.GetOutput())
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution);
+        processExecution.End(Arg.Any<Process>())
+            .Returns(1);
+        processExecution.GetOutput()
             .Returns(String.Empty);
-        processExecution.Setup(x => x.GetError())
+        processExecution.GetError()
             .Returns("No test source files were specified.");
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process());
+        processExecution.Start(Arg.Any<ProcessStartInfo>())
+            .Returns(new Process());
 
         // Act
         await dotNetTestRunner.Test(new RerunCommandConfiguration(), "resultsDirectory");
@@ -112,18 +101,16 @@ public async Task Test_GetErrors_FailedTests()
     {
         // Arrange
         var logger = new Logger();
-        var processExecution = new Mock<IProcessExecution>(MockBehavior.Strict);
-        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution.Object);
-        processExecution.Setup(x => x.FetchOutput(It.IsAny<Process>()));
-        processExecution.Setup(x => x.FetchError(It.IsAny<Process>()));
-        processExecution.Setup(x => x.End(It.IsAny<Process>()))
-            .ReturnsAsync(1);
-        processExecution.Setup(x => x.GetOutput())
+        var processExecution = Substitute.For<IProcessExecution>();
+        var dotNetTestRunner = new dotnet.test.rerun.DotNetRunner.DotNetTestRunner(logger, processExecution);
+        processExecution.End(Arg.Any<Process>())
+            .Returns(1);
+        processExecution.GetOutput()
             .Returns("FirstLine\nFailed!  - Failed:\nThirdLine");
-        processExecution.Setup(x => x.GetError())
+        processExecution.GetError()
             .Returns(string.Empty);
-        processExecution.Setup(x => x.Start(It.IsAny<ProcessStartInfo>()))
-            .ReturnsAsync(new Process());
+        processExecution.Start(Arg.Any<ProcessStartInfo>())
+            .Returns(new Process());
 
         // Act
         await dotNetTestRunner.Test(new RerunCommandConfiguration(), "resultsDirectory");
diff --git a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/ProcessExecutionTests.cs b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/ProcessExecutionTests.cs
index d1250ce..35fa72c 100644
--- a/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/ProcessExecutionTests.cs
+++ b/test/dotnet-test-rerun.UnitTests/DotNetTestRunner/ProcessExecutionTests.cs
@@ -1,15 +1,6 @@
-using System.CommandLine;
-using System.CommandLine.Invocation;
-using System.CommandLine.Parsing;
-using System.Diagnostics;
-using System.IO.Abstractions;
-using dotnet.test.rerun.Analyzers;
-using dotnet.test.rerun.DotNetRunner;
-using dotnet.test.rerun.Enums;
+using dotnet.test.rerun.DotNetRunner;
 using dotnet.test.rerun.Logging;
-using dotnet.test.rerun.RerunCommand;
 using FluentAssertions;
-using Moq;
 using Xunit;
 
 namespace dotnet_test_rerun.UnitTest.DotNetTestRunner;
diff --git a/test/dotnet-test-rerun.UnitTests/RerunCommand/RerunCommandTests.cs b/test/dotnet-test-rerun.UnitTests/RerunCommand/RerunCommandTests.cs
index c669ca9..3d72bf1 100644
--- a/test/dotnet-test-rerun.UnitTests/RerunCommand/RerunCommandTests.cs
+++ b/test/dotnet-test-rerun.UnitTests/RerunCommand/RerunCommandTests.cs
@@ -8,7 +8,7 @@
 using dotnet.test.rerun.Logging;
 using dotnet.test.rerun.RerunCommand;
 using FluentAssertions;
-using Moq;
+using NSubstitute;
 using Xunit;
 
 namespace dotnet_test_rerun.UnitTest.RerunCommand;
@@ -22,22 +22,22 @@ public async Task Run_TestsOnce_NoFailures()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
 
-        dotNetTestRunner.Setup(x => x.Test(config, directoryInfo.FullName))
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Once);
+        await dotNetTestRunner.Received(1).Test(config, directoryInfo.FullName);
     }
 
 
@@ -49,15 +49,15 @@ public async Task InvokeCommand_TestsOnce_NoFailures()
         var config = new RerunCommandConfiguration();
         var cmd = new Command("test-rerun");
         config.Set(cmd);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New("results-directory");
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
 
-        dotNetTestRunner.Setup(x => x.Test(config, directoryInfo.FullName))
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
 
         // Act
@@ -65,7 +65,7 @@ await command.InvokeAsync("path --filter filter --settings settings --logger log
                                   "--results-directory results-directory --rerunMaxAttempts 2 --loglevel Debug");
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Once);
+        await dotNetTestRunner.Received(1).Test(config, directoryInfo.FullName);
     }
 
     [Fact]
@@ -75,27 +75,28 @@ public async Task Run_TestsFail_NoTrxFound()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
 
-        dotNetTestRunner.Setup(x => x.Test(config, directoryInfo.FullName))
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.Setup(x => x.GetErrorCode())
+        dotNetTestRunner.GetErrorCode()
             .Returns(ErrorCode.FailedTests);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
             .Returns(Array.Empty<IFileInfo>());
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Once);
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Once);
+        await dotNetTestRunner.Received(1).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(1).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
     }
 
     [Fact]
@@ -105,30 +106,32 @@ public async Task Run_TestsFail_NoTestsFoundInTrxToRerun()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
         var trxFile = fileSystem.FileInfo.New("Second.trx");
 
-        dotNetTestRunner.Setup(x => x.Test(config, directoryInfo.FullName))
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.Setup(x => x.GetErrorCode())
+        dotNetTestRunner.GetErrorCode()
             .Returns(ErrorCode.FailedTests);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
             .Returns(new[] { trxFile });
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == trxFile)))
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == trxFile))
             .Returns(String.Empty);
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Once);
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Once);
+        await dotNetTestRunner.Received(1).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(1).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == trxFile));
     }
 
     [Fact]
@@ -138,37 +141,36 @@ public async Task Run_TestsFailOnFirstRun_PassOnSecond()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
         var firstTrxFile = fileSystem.FileInfo.New("First.trx");
         var secondTrxFile = fileSystem.FileInfo.New("Second.trx");
 
-        dotNetTestRunner.SetupSequence(x => x.Test(config, directoryInfo.FullName))
-            .Returns(Task.CompletedTask)
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.SetupSequence(x => x.GetErrorCode())
-            .Returns(ErrorCode.FailedTests)
-            .Returns(ErrorCode.Success);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
-            .Returns(new[] { firstTrxFile })
-            .Returns(new[] { secondTrxFile });
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == firstTrxFile)))
+        dotNetTestRunner.GetErrorCode()
+            .Returns(ErrorCode.FailedTests, ErrorCode.Success);
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
+            .Returns(new[] { firstTrxFile }, new[] { secondTrxFile });
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile))
             .Returns("filterToRerun");
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == secondTrxFile)))
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == secondTrxFile))
             .Returns(string.Empty);
 
         // Act
         await command.Run();
 
-        // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetFailedTestsFilter(new[] { secondTrxFile}), Times.Exactly(1));
+        // Assert       
+        await dotNetTestRunner.Received(2).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(2).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile));
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == secondTrxFile));
     }
 
     [Fact]
@@ -178,35 +180,33 @@ public async Task Run_TestsFailOnFirstRunWithMultipleTrxFiles_PassOnSecond()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
         var firstTrxFile = fileSystem.FileInfo.New("First.trx");
         var secondTrxFile = fileSystem.FileInfo.New("Second.trx");
 
-        dotNetTestRunner.SetupSequence(x => x.Test(config, directoryInfo.FullName))
-            .Returns(Task.CompletedTask)
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.SetupSequence(x => x.GetErrorCode())
-            .Returns(ErrorCode.FailedTests)
-            .Returns(ErrorCode.Success);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
-            .Returns(new[] { firstTrxFile, secondTrxFile })
-            .Returns(Array.Empty<IFileInfo>() );
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == firstTrxFile && files[1] == secondTrxFile)))
+        dotNetTestRunner.GetErrorCode()
+            .Returns(ErrorCode.FailedTests, ErrorCode.Success);
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
+            .Returns(new[] { firstTrxFile, secondTrxFile }, Array.Empty<IFileInfo>());
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile && files[1] == secondTrxFile))
             .Returns("filterToRerun");
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetFailedTestsFilter(new[] { firstTrxFile, secondTrxFile}), Times.Once);
+        await dotNetTestRunner.Received(2).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(2).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile && files[1] == secondTrxFile));
     }
 
     [Fact]
@@ -216,39 +216,39 @@ public async Task Run_TestsFailOnFirstRun_PassOnSecond_WithDeleteReports()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config, "--deleteReports");
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
         var firstTrxFile = fileSystem.FileInfo.New("First.trx");
         var secondTrxFile = fileSystem.FileInfo.New("Second.trx");
-
-        dotNetTestRunner.SetupSequence(x => x.Test(config, directoryInfo.FullName))
-            .Returns(Task.CompletedTask)
+        
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.SetupSequence(x => x.GetErrorCode())
-            .Returns(ErrorCode.FailedTests)
-            .Returns(ErrorCode.Success);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
-            .Returns(new []{ firstTrxFile })
-            .Returns(new [] { secondTrxFile });
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == firstTrxFile)))
+        dotNetTestRunner.GetErrorCode()
+            .Returns(ErrorCode.FailedTests, ErrorCode.Success);
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
+            .Returns(new []{ firstTrxFile },new [] { secondTrxFile });
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile))
             .Returns("filterToRerun");
-        testResultsAnalyzer.Setup(x => x.GetFailedTestsFilter(It.Is<IFileInfo[]>(files => files[0] == secondTrxFile)))
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == secondTrxFile))
             .Returns(string.Empty);
-        testResultsAnalyzer.Setup(x => x.GetReportFiles())
+        testResultsAnalyzer.GetReportFiles()
             .Returns(new HashSet<string>() {firstTrxFile.FullName, secondTrxFile.FullName});
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetFailedTestsFilter(new[] { secondTrxFile}), Times.Exactly(1));
+        await dotNetTestRunner.Received(2).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(2).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == firstTrxFile));
+        testResultsAnalyzer.Received(1).GetFailedTestsFilter(Arg.Is<IFileInfo[]>(files => files[0] == secondTrxFile));
+        testResultsAnalyzer.Received().GetReportFiles();
         firstTrxFile.Exists.Should().BeFalse();
         secondTrxFile.Exists.Should().BeFalse();
     }
@@ -260,38 +260,33 @@ public async Task Run_TestsFailOnAllTries_Failure()
         var logger = new Logger();
         var config = new RerunCommandConfiguration();
         InitialConfigurationSetup(config);
-        var dotNetTestRunner = new Mock<IDotNetTestRunner>();
-        var dotNetCoverageRunner = new Mock<IDotNetCoverageRunner>();
+        var dotNetTestRunner = Substitute.For<IDotNetTestRunner>();
+        var dotNetCoverageRunner = Substitute.For<IDotNetCoverageRunner>();
         var fileSystem = new FileSystem();
-        var testResultsAnalyzer = new Mock<ITestResultsAnalyzer>();
+        var testResultsAnalyzer = Substitute.For<ITestResultsAnalyzer>();
         var directoryInfo = fileSystem.DirectoryInfo.New(config.ResultsDirectory);
-        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner.Object,
-            dotNetCoverageRunner.Object, fileSystem, testResultsAnalyzer.Object);
+        var command = new dotnet.test.rerun.RerunCommand.RerunCommand(logger, config, dotNetTestRunner,
+            dotNetCoverageRunner, fileSystem, testResultsAnalyzer);
         var firstTrxFile = fileSystem.FileInfo.New("First.trx");
         var secondTrxFile = fileSystem.FileInfo.New("Second.trx");
-
-        dotNetTestRunner.SetupSequence(x => x.Test(config, directoryInfo.FullName))
-            .Returns(Task.CompletedTask)
-            .Returns(Task.CompletedTask)
+        
+        dotNetTestRunner.Test(config, directoryInfo.FullName)
             .Returns(Task.CompletedTask);
-        dotNetTestRunner.SetupSequence(x => x.GetErrorCode())
-            .Returns(ErrorCode.FailedTests)
-            .Returns(ErrorCode.FailedTests)
+        dotNetTestRunner.GetErrorCode()
             .Returns(ErrorCode.FailedTests);
-        testResultsAnalyzer.SetupSequence(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()))
-            .Returns(new [] {firstTrxFile})
-            .Returns(new [] {secondTrxFile});
-        testResultsAnalyzer.SetupSequence(x => x.GetFailedTestsFilter(It.IsAny<IFileInfo[]>()))
-            .Returns("filterToRerun")
+        testResultsAnalyzer.GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>())
+            .Returns(new [] {firstTrxFile},new [] {secondTrxFile});
+        testResultsAnalyzer.GetFailedTestsFilter(Arg.Any<IFileInfo[]>())
             .Returns("filterToRerun");
 
         // Act
         await command.Run();
 
         // Assert
-        dotNetTestRunner.Verify(x => x.Test(config, directoryInfo.FullName), Times.Exactly(3));
-        testResultsAnalyzer.Verify(x => x.GetTrxFiles(It.IsAny<IDirectoryInfo>(), It.IsAny<DateTime>()), Times.Exactly(2));
-        testResultsAnalyzer.Verify(x => x.GetFailedTestsFilter(It.IsAny<IFileInfo[]>()), Times.Exactly(2));
+        await dotNetTestRunner.Received(3).Test(config, directoryInfo.FullName);
+        dotNetTestRunner.Received(2).GetErrorCode();
+        testResultsAnalyzer.Received(2).GetTrxFiles(Arg.Any<IDirectoryInfo>(), Arg.Any<DateTime>());
+        testResultsAnalyzer.Received(2).GetFailedTestsFilter(Arg.Any<IFileInfo[]>());
     }
 
     private void InitialConfigurationSetup(RerunCommandConfiguration configuration, string extraParams = "")
diff --git a/test/dotnet-test-rerun.UnitTests/dotnet-test-rerun.UnitTests.csproj b/test/dotnet-test-rerun.UnitTests/dotnet-test-rerun.UnitTests.csproj
index 7b72d3f..fe9461d 100644
--- a/test/dotnet-test-rerun.UnitTests/dotnet-test-rerun.UnitTests.csproj
+++ b/test/dotnet-test-rerun.UnitTests/dotnet-test-rerun.UnitTests.csproj
@@ -16,7 +16,7 @@
         </PackageReference>
         <PackageReference Include="FluentAssertions" Version="6.12.0" />
         <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.7.2" />
-        <PackageReference Include="Moq" Version="4.18.4" />
+        <PackageReference Include="NSubstitute" Version="5.0.0" />
         <PackageReference Include="Spectre.Console.Testing" Version="0.47.0" />
         <PackageReference Include="xunit" Version="2.5.0" />
         <PackageReference Include="xunit.runner.visualstudio" Version="2.5.0">