diff --git a/FineCodeCoverage/Core/CoverageUtilManager.cs b/FineCodeCoverage/Core/CoverageUtilManager.cs
new file mode 100644
index 00000000..11303c61
--- /dev/null
+++ b/FineCodeCoverage/Core/CoverageUtilManager.cs
@@ -0,0 +1,42 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.Threading.Tasks;
+using FineCodeCoverage.Engine.Coverlet;
+using FineCodeCoverage.Engine.Model;
+using FineCodeCoverage.Engine.OpenCover;
+
+namespace FineCodeCoverage.Engine
+{
+    [Export(typeof(ICoverageUtilManager))]
+    internal class CoverageUtilManager : ICoverageUtilManager
+    {
+        private readonly IOpenCoverUtil openCoverUtil;
+        private readonly ICoverletUtil coverletUtil;
+
+        [ImportingConstructor]
+        public CoverageUtilManager(IOpenCoverUtil openCoverUtil, ICoverletUtil coverletUtil)
+        {
+            this.openCoverUtil = openCoverUtil;
+            this.coverletUtil = coverletUtil;
+        }
+        
+        public void Initialize(string appDataFolder)
+        {
+            openCoverUtil.Initialize(appDataFolder);
+            coverletUtil.Initialize(appDataFolder);
+        }
+
+        public Task<bool> RunCoverageAsync(ICoverageProject project, bool throwError = false)
+        {
+            if (project.IsDotNetSdkStyle())
+            {
+                return coverletUtil.RunCoverletAsync(project, throwError);
+            }
+            else
+            {
+                return openCoverUtil.RunOpenCoverAsync(project, throwError);
+            }
+        }
+    }
+}
diff --git a/FineCodeCoverage/Core/FCCEngine.cs b/FineCodeCoverage/Core/FCCEngine.cs
index 1327c4ee..7286db85 100644
--- a/FineCodeCoverage/Core/FCCEngine.cs
+++ b/FineCodeCoverage/Core/FCCEngine.cs
@@ -6,10 +6,8 @@
 using System.Threading;
 using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine.Cobertura;
-using FineCodeCoverage.Engine.Coverlet;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Engine.MsTestPlatform;
-using FineCodeCoverage.Engine.OpenCover;
 using FineCodeCoverage.Engine.ReportGenerator;
 using FineCodeCoverage.Impl;
 using FineCodeCoverage.Options;
@@ -36,8 +34,7 @@ internal class FCCEngine : IFCCEngine
         public string AppDataFolderPath { get; private set; }
         public List<CoverageLine> CoverageLines { get; internal set; }
 
-        private readonly ICoverletUtil coverletUtil;
-        private readonly IOpenCoverUtil openCoverUtil;
+        private readonly ICoverageUtilManager coverageUtilManager;
         private readonly ICoberturaUtil coberturaUtil;
         private readonly IMsTestPlatformUtil msTestPlatformUtil;
         private readonly IReportGeneratorUtil reportGeneratorUtil;
@@ -51,8 +48,7 @@ internal class FCCEngine : IFCCEngine
 
         [ImportingConstructor]
         public FCCEngine(
-            ICoverletUtil coverletUtil,
-            IOpenCoverUtil openCoverUtil,
+            ICoverageUtilManager coverageUtilManager,
             ICoberturaUtil coberturaUtil,
             IMsTestPlatformUtil msTestPlatformUtil,
             IReportGeneratorUtil reportGeneratorUtil,
@@ -64,8 +60,7 @@ public FCCEngine(
             IServiceProvider serviceProvider
             )
         {
-            this.coverletUtil = coverletUtil;
-            this.openCoverUtil = openCoverUtil;
+            this.coverageUtilManager = coverageUtilManager;
             this.coberturaUtil = coberturaUtil;
             this.msTestPlatformUtil = msTestPlatformUtil;
             this.reportGeneratorUtil = reportGeneratorUtil;
@@ -96,8 +91,7 @@ public void Initialize(IInitializeStatusProvider initializeStatusProvider)
 
             reportGeneratorUtil.Initialize(AppDataFolderPath);
             msTestPlatformUtil.Initialize(AppDataFolderPath);
-            openCoverUtil.Initialize(AppDataFolderPath);
-            coverletUtil.Initialize(AppDataFolderPath);
+            coverageUtilManager.Initialize(AppDataFolderPath);
         }
 
         public void ClearUI()
@@ -128,18 +122,6 @@ private CancellationToken Reset()
             return cancellationToken;
         }
 
-        private System.Threading.Tasks.Task RunCoverToolAsync(ICoverageProject project)
-        {
-            if (project.IsDotNetSdkStyle())
-            {
-                return coverletUtil.RunCoverletAsync(project, true);
-            }
-            else
-            {
-                return openCoverUtil.RunOpenCoverAsync(project, true);
-            }
-        }
-
         private async System.Threading.Tasks.Task<string[]> RunCoverageAsync(List<ICoverageProject> coverageProjects,CancellationToken cancellationToken)
         {
             // process pipeline
@@ -149,7 +131,7 @@ private async System.Threading.Tasks.Task<string[]> RunCoverageAsync(List<ICover
             foreach (var coverageProject in coverageProjects)
             {
                 cancellationToken.ThrowIfCancellationRequested();
-                await coverageProject.StepAsync("Run Coverage Tool", RunCoverToolAsync);
+                await coverageProject.StepAsync("Run Coverage Tool", (project) => coverageUtilManager.RunCoverageAsync(project, true));
             }
 
             var passedProjects = coverageProjects.Where(p => !p.HasFailed);
diff --git a/FineCodeCoverage/Core/ICoverageUtilManager.cs b/FineCodeCoverage/Core/ICoverageUtilManager.cs
new file mode 100644
index 00000000..95834ee2
--- /dev/null
+++ b/FineCodeCoverage/Core/ICoverageUtilManager.cs
@@ -0,0 +1,11 @@
+using System.Threading.Tasks;
+using FineCodeCoverage.Engine.Model;
+
+namespace FineCodeCoverage.Engine
+{
+    internal interface ICoverageUtilManager
+    {
+        void Initialize(string appDataFolder);
+        Task<bool> RunCoverageAsync(ICoverageProject project, bool throwError = false);
+    }
+}
diff --git a/FineCodeCoverage/FineCodeCoverage.csproj b/FineCodeCoverage/FineCodeCoverage.csproj
index 18975232..04b8611f 100644
--- a/FineCodeCoverage/FineCodeCoverage.csproj
+++ b/FineCodeCoverage/FineCodeCoverage.csproj
@@ -69,9 +69,11 @@
     <Compile Include="Core\Cobertura\Packages.cs" />
     <Compile Include="Core\Cobertura\Sources.cs" />
     <Compile Include="Core\CoverageUIEvents.cs" />
+    <Compile Include="Core\CoverageUtilManager.cs" />
     <Compile Include="Core\Coverlet\Console\CoverletConsoleDotnetToolsGlobalExecutor.cs" />
     <Compile Include="Core\Coverlet\Console\CoverletConsoleCustomPathExecutor.cs" />
     <Compile Include="Core\Coverlet\Console\CoverletConsoleDotnetToolsLocalExecutor.cs" />
+    <Compile Include="Core\ICoverageUtilManager.cs" />
     <Compile Include="Core\MsTestPlatform\IMsTestPlatformUtil.cs" />
     <Compile Include="Core\Utilities\ToolZip\IToolFolder.cs" />
     <Compile Include="Core\Utilities\ToolZip\IToolZipProvider.cs" />
diff --git a/FineCodeCoverageTests/CoverageUtilManager_Tests.cs b/FineCodeCoverageTests/CoverageUtilManager_Tests.cs
new file mode 100644
index 00000000..a5b3c401
--- /dev/null
+++ b/FineCodeCoverageTests/CoverageUtilManager_Tests.cs
@@ -0,0 +1,57 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using AutoMoq;
+using FineCodeCoverage.Engine;
+using FineCodeCoverage.Engine.Coverlet;
+using FineCodeCoverage.Engine.Model;
+using FineCodeCoverage.Engine.OpenCover;
+using Moq;
+using NUnit.Framework;
+
+namespace FineCodeCoverageTests
+{
+    class CoverageUtilManager_Tests
+    {
+        private AutoMoqer mocker;
+        [SetUp]
+        public void SetUp()
+        {
+            mocker = new AutoMoqer();
+        }
+
+        [Test]
+        public void Initialize_Should_Initialize_The_Coverage_Utils()
+        {
+            var coverageUtilManager = mocker.Create<CoverageUtilManager>();
+            coverageUtilManager.Initialize("AppDataFolder");
+            mocker.Verify<ICoverletUtil>(coverletUtil => coverletUtil.Initialize("AppDataFolder"));
+            mocker.Verify<IOpenCoverUtil>(coverletUtil => coverletUtil.Initialize("AppDataFolder"));
+        }
+
+        [TestCase(true, true)]
+        [TestCase(true, false)]
+        [TestCase(false, true)]
+        [TestCase(false, false)]
+        public void Should_Run_The_Appropriate_Cover_Tool_Based_On_IsDotNetSdkStyle(bool isDotNetSdkStyle, bool throwError)
+        {
+            var mockProject = new Mock<ICoverageProject>();
+            mockProject.Setup(cp => cp.IsDotNetSdkStyle()).Returns(isDotNetSdkStyle);
+            var mockedProject = mockProject.Object;
+
+            var coverageUtilManager = mocker.Create<CoverageUtilManager>();
+            coverageUtilManager.RunCoverageAsync(mockedProject, throwError);
+
+            if (isDotNetSdkStyle)
+            {
+                mocker.Verify<ICoverletUtil>(coverletUtil => coverletUtil.RunCoverletAsync(mockedProject, throwError));
+            }
+            else
+            {
+                mocker.Verify<IOpenCoverUtil>(openCoverUtil => openCoverUtil.RunOpenCoverAsync(mockedProject, throwError));
+            }
+        }
+    }
+}
diff --git a/FineCodeCoverageTests/FCCEngine_Tests.cs b/FineCodeCoverageTests/FCCEngine_Tests.cs
index b40c8736..e34eb833 100644
--- a/FineCodeCoverageTests/FCCEngine_Tests.cs
+++ b/FineCodeCoverageTests/FCCEngine_Tests.cs
@@ -8,10 +8,8 @@
 using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine;
 using FineCodeCoverage.Engine.Cobertura;
-using FineCodeCoverage.Engine.Coverlet;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Engine.MsTestPlatform;
-using FineCodeCoverage.Engine.OpenCover;
 using FineCodeCoverage.Engine.ReportGenerator;
 using FineCodeCoverage.Impl;
 using Moq;
@@ -54,17 +52,15 @@ public void Should_Initialize_AppFolder_Then_Utils()
             mockAppDataFolder.Setup(appDataFolder => appDataFolder.Initialize()).Callback(() => callOrder.Add(1));
             mockAppDataFolder.Setup(appDataFolder => appDataFolder.DirectoryPath).Returns(appDataFolderPath);
 
-            var coverletMock = mocker.GetMock<ICoverletUtil>().Setup(coverlet => coverlet.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(2));
+            var reportGeneratorMock = mocker.GetMock<IReportGeneratorUtil>().Setup(reportGenerator => reportGenerator.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(2));
 
-            var reportGeneratorMock = mocker.GetMock<IReportGeneratorUtil>().Setup(reportGenerator => reportGenerator.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(3));
+            var msTestPlatformMock = mocker.GetMock<IMsTestPlatformUtil>().Setup(msTestPlatform => msTestPlatform.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(3));
 
-            var msTestPlatformMock = mocker.GetMock<IMsTestPlatformUtil>().Setup(msTestPlatform => msTestPlatform.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(4));
-
-            var openCoverMock = mocker.GetMock<IOpenCoverUtil>().Setup(openCover => openCover.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(5));
+            var openCoverMock = mocker.GetMock<ICoverageUtilManager>().Setup(openCover => openCover.Initialize(appDataFolderPath)).Callback(() => callOrder.Add(4));
 
             fccEngine.Initialize(null);
 
-            Assert.AreEqual(5, callOrder.Count);
+            Assert.AreEqual(4, callOrder.Count);
             Assert.AreEqual(1, callOrder[0]);
         }
 
@@ -232,29 +228,20 @@ public async Task Should_Run_The_CoverTool_Step()
             mockCoverageProject.Verify(p => p.StepAsync("Run Coverage Tool", It.IsAny<Func<ICoverageProject, Task>>()));
         }
 
-        [TestCase(true)]
-        [TestCase(false)]
-        public async Task Should_Run_The_Appropriate_Cover_Tool_Based_On_IsDotNetSdkStyle(bool isDotNetSdkStyle)
+        [Test]
+        public async Task Should_Run_Coverage_ThrowingErrors_But_Safely_With_StepAsync()
         {
-            Task waitForCoverage = null;
             ICoverageProject coverageProject = null;
             await ReloadSuitableCoverageProject(mockCoverageProject => {
                 coverageProject = mockCoverageProject.Object;
-                mockCoverageProject.Setup(p => p.IsDotNetSdkStyle()).Returns(isDotNetSdkStyle);
                 mockCoverageProject.Setup(p => p.StepAsync("Run Coverage Tool", It.IsAny<Func<ICoverageProject, Task>>())).Callback<string,Func<ICoverageProject, Task>>((_,runCoverTool) =>
                 {
-                    waitForCoverage = runCoverTool(coverageProject);
+                    runCoverTool(coverageProject);
                 });
             });
-            if (isDotNetSdkStyle)
-            {
-                mocker.Verify<ICoverletUtil>(coverlet => coverlet.RunCoverletAsync(coverageProject, true));
-            }
-            else
-            {
-                mocker.Verify<IOpenCoverUtil>(openCover => openCover.RunOpenCoverAsync(coverageProject, true));
-            }
-            
+
+            mocker.Verify<ICoverageUtilManager>(coverageUtilManager => coverageUtilManager.RunCoverageAsync(coverageProject, true));
+
         }
     
         [Test] // Not testing dark mode as ui will change
diff --git a/FineCodeCoverageTests/FineCodeCoverageTests.csproj b/FineCodeCoverageTests/FineCodeCoverageTests.csproj
index 13bc8d04..2f472ded 100644
--- a/FineCodeCoverageTests/FineCodeCoverageTests.csproj
+++ b/FineCodeCoverageTests/FineCodeCoverageTests.csproj
@@ -86,6 +86,7 @@
     </Reference>
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="CoverageUtilManager_Tests.cs" />
     <Compile Include="ToolFolder_Tests.cs" />
     <Compile Include="ToolZipProvider_Tests.cs" />
     <Compile Include="CoverletDataCollectorGeneratedCobertura_Tests.cs" />