add functionality and update readme

Author: tonyhallett

FineCodeCoverageTests/AppOptionsProvider_Tests.cs

@@ -307,6 +307,8 @@ internal void Should_Use_Deseralized_String_From_Store_For_AppOption_Property(Fu
                 { nameof(IAppOptions.ShowPartiallyCoveredInOverviewMargin),true},
                 { nameof(IAppOptions.ShowUncoveredInOverviewMargin),true},
                 { nameof(IAppOptions.ShowToolWindowToolbar),true},
+                {nameof(IAppOptions.ExcludeAssemblies),new string[]{ "Exclude"} },
+                {nameof(IAppOptions.IncludeAssemblies),new string[]{ "Include"} },
             };
             var mockJsonConvertService = autoMocker.GetMock<IJsonConvertService>();
             mockJsonConvertService.Setup(

FineCodeCoverageTests/CoverageProject_Settings_Tests.cs

@@ -1,3 +1,4 @@
+using AutoMoq;
 using FineCodeCoverage.Core.Utilities;
 using FineCodeCoverage.Engine.Model;
 using FineCodeCoverage.Options;
@@ -12,7 +13,7 @@
 using System.Threading.Tasks;
 using System.Xml.Linq;
 
-namespace Test
+namespace FineCodeCoverageTests
 {
     public class CoverageProject_Settings_Tests
     {
@@ -675,5 +676,34 @@ public async Task Should_Provide_The_Merged_Result_Using_Project_Settings()
             var coverageProjectSettings = await coverageProjectSettingsManager.GetSettingsAsync(coverageProject);
             Assert.AreSame(mergedSettings, coverageProjectSettings);
         }
+
+        [Test]
+        public async Task Should_Add_Common_Assembly_Excludes_Includes()
+        {
+            var mockAppOptions = new Mock<IAppOptions>();
+            mockAppOptions.SetupAllProperties();
+            var appOptions = mockAppOptions.Object;
+            appOptions.Exclude = new string[] { "oldexclude" };
+            appOptions.Include = new string[] { "oldinclude" };
+            appOptions.ModulePathsExclude = new string[] { "msexclude" };
+            appOptions.ModulePathsInclude = new string[] { "msinclude" };
+            appOptions.ExcludeAssemblies = new string[] { "excludeassembly" };
+            appOptions.IncludeAssemblies = new string[] { "includeassembly" };
+
+            var autoMoqer = new AutoMoqer();
+            var coverageProjectSettingsManager = autoMoqer.Create<CoverageProjectSettingsManager>();
+            autoMoqer.GetMock<ISettingsMerger>().Setup(settingsMerger => settingsMerger.Merge(
+                It.IsAny<IAppOptions>(),
+                It.IsAny<List<XElement>>(),
+                It.IsAny<XElement>()
+                )).Returns(appOptions);
+
+            var settings = await coverageProjectSettingsManager.GetSettingsAsync(new Mock<ICoverageProject>().Object);
+            
+            Assert.That(settings.Exclude, Is.EquivalentTo(new string[] { "oldexclude", "[excludeassembly]*" }));
+            Assert.That(settings.Include, Is.EquivalentTo(new string[] { "oldinclude", "[includeassembly]*" }));
+            Assert.That(settings.ModulePathsExclude, Is.EquivalentTo(new string[] { "msexclude", ".*\\excludeassembly.dll$" }));
+            Assert.That(settings.ModulePathsInclude, Is.EquivalentTo(new string[] { "msinclude", ".*\\includeassembly.dll$" }));
+        }
     }
 }

FineCodeCoverageTests/MsCodeCoverage/RunSettingsTemplateReplacementsFactory_Tests.cs

@@ -30,6 +30,8 @@ internal class TestMsCodeCoverageOptions : IMsCodeCoverageOptions
 
         public bool IncludeTestAssembly { get; set; }
         public bool IncludeReferencedProjects { get; set; }
+        public string[] ExcludeAssemblies { get; set; }
+        public string[] IncludeAssemblies { get; set; }
     }
 
     internal static class ReplacementsAssertions
@@ -51,6 +53,7 @@ public static void AssertAllEmpty(IRunSettingsTemplateReplacements replacements)
         }
     }
 
+    
     internal class RunSettingsTemplateReplacementsFactory_UserRunSettings_Tests
     {
         private RunSettingsTemplateReplacementsFactory runSettingsTemplateReplacementsFactory;
@@ -694,5 +697,7 @@ internal class TestCoverageProjectOptions : IAppOptions
         public bool ShowToolWindowToolbar { get; set; }
         public bool Hide0Coverable { get; set; }
         public bool Hide0Coverage { get; set; }
+        public string[] ExcludeAssemblies { get; set; }
+        public string[] IncludeAssemblies { get; set; }
     }
 }

README.md

@@ -20,6 +20,7 @@ tool for most developers.  It is currently in Beta.
 
 With the old coverage it was possible for FCC to provide an abstraction over each tool's exclusion / inclusion options.  This abstraction does not work for MS code coverage.  
 Thus you will find that there are separate configuration options for Ms coverage vs old coverage and options that are common to the two.
+Assembly level exclusions and inclusions can be achieved - see ExcludeAssemblies and IncludeAssemblies.
 Configuration is ( mostly ) determined from Visual Studio options, finecodecoverage-settings.xml files and project msbuild properties.  All of these settings are optional.
 For options that have a project scope, these settings form a hierarchy where lower levels override or, for collections, override or merge with the level above.  This is described in detail further on.  
 
@@ -260,6 +261,8 @@ RunMsCodeCoverage                    Change to IfInRunSettings to only collect w
 
 IncludeTestAssembly				     Specifies whether to report code coverage of the test assembly
 IncludeReferencedProjects            Set to true to add all referenced projects to Include.
+IncludeAssemblies                    Provide a list of assemblies to include in coverage. The dll name without extension is used for matching.
+ExcludeAssemblies                    Provide a list of assemblies to exclude from coverage.  The dll name without extension is used for matching.
 
 *** OpenCover / Coverlet
 AdjacentBuildOutput                  If your tests are dependent upon their path set this to true.
@@ -321,7 +324,8 @@ ThresholdForCrapScore              When [crap score](https://testing.googleblog.
 ```
 ## Exclusions and inclusions
 You probably want to set IncludeReferencedProjects to true.  This will ensure that you do not get coverage for testing frameworks - only your code.
-
+Coverlet and OpenCover use [filter expressions](https://github.com/coverlet-coverage/coverlet/blob/master/Documentation/MSBuildIntegration.md#filters).  
+Ms code coverage uses [regexes](https://learn.microsoft.com/en-us/visualstudio/test/customizing-code-coverage-analysis?view=vs-2022#regular-expressions).
 
 ## FCC Output
 FCC outputs, by default, inside each test project's Debug folder.

SharedProject/Core/Model/CoverageProjectSettingsManager.cs

@@ -1,6 +1,9 @@
 using FineCodeCoverage.Options;
+using System;
+using System.Collections.Generic;
 using System.ComponentModel.Composition;
 using System.IO;
+using System.Linq;
 using System.Threading.Tasks;
 
 namespace FineCodeCoverage.Engine.Model
@@ -32,7 +35,44 @@ public async Task<IAppOptions> GetSettingsAsync(ICoverageProject coverageProject
             var projectDirectory = Path.GetDirectoryName(coverageProject.ProjectFile);
             var settingsFilesElements = fccSettingsFilesProvider.Provide(projectDirectory);
             var projectSettingsElement = await coverageProjectSettingsProvider.ProvideAsync(coverageProject);
-            return settingsMerger.Merge(appOptionsProvider.Get(), settingsFilesElements, projectSettingsElement);
+            var merged = settingsMerger.Merge(appOptionsProvider.Get(), settingsFilesElements, projectSettingsElement);
+            AddCommonAssemblyExcludesIncludes(merged);
+            return merged;
+        }
+
+        private void AddCommonAssemblyExcludesIncludes(IAppOptions appOptions)
+        {
+            var (newOldStyleExclude,newMsExclude) = AddCommon(appOptions.Exclude, appOptions.ModulePathsExclude, appOptions.ExcludeAssemblies);
+            var (newOldStyleInclude,newMsInclude) = AddCommon(appOptions.Include, appOptions.ModulePathsInclude, appOptions.IncludeAssemblies);
+            appOptions.Exclude = newOldStyleExclude;
+            appOptions.Include = newOldStyleInclude;
+            appOptions.ModulePathsExclude = newMsExclude;
+            appOptions.ModulePathsInclude = newMsInclude;
+        }
+        
+        private (string[] newOldStyle,string[] newMs) AddCommon(string[] oldStyle,string[] ms, string[] common )
+        {
+            if(common == null)
+            {
+                return(oldStyle,ms);
+            }
+            var newMs = ListFromExisting(ms);
+            var newOldStyle = ListFromExisting(oldStyle);
+            
+            common.ToList().ForEach(assemblyFileName =>
+            {
+                var msModulePath = $".*\\{assemblyFileName}.dll$";
+                newMs.Add(msModulePath);
+                var old = $"[{assemblyFileName}]*";
+                newOldStyle.Add(old);
+            });
+            
+            return (newOldStyle.ToArray(), newMs.ToArray());
+        }
+
+        private List<string> ListFromExisting(string[] existing)
+        {
+            return new List<string>(existing ?? new string[0]);
         }
     }
 

SharedProject/Options/AppOptionsPage.cs

@@ -78,6 +78,18 @@ private static IAppOptionsStorageProvider GetAppOptionsStorageProvider()
         @"Specifies whether to report code coverage of the test assembly
 		")]
         public bool IncludeTestAssembly { get; set; }
+
+        [Category(commonExcludeIncludeCategory)]
+        [Description(
+        @"Provide a list of assemblies to exclude from coverage.  The dll name without extension is used for matching.
+		")]
+        public string[] ExcludeAssemblies { get; set; }
+
+        [Category(commonExcludeIncludeCategory)]
+        [Description(
+        @"Provide a list of assemblies to include in coverage. The dll name without extension is used for matching.
+		")]
+        public string[] IncludeAssemblies { get; set; }
         #endregion
 
         #region old exclude include

SharedProject/Options/AppOptionsProvider.cs

@@ -205,5 +205,7 @@ internal class AppOptions : IAppOptions
 
         public bool IncludeReferencedProjects { get; set; }
         public bool ShowToolWindowToolbar { get; set; }
+        public string[] ExcludeAssemblies { get; set; }
+        public string[] IncludeAssemblies { get; set; }
     }
 }

SharedProject/Options/IAppOptions.cs

@@ -5,6 +5,9 @@ internal interface IFCCCommonOptions
         bool Enabled { get; set; }
         bool IncludeTestAssembly { get; set; }
         bool IncludeReferencedProjects { get; set; }
+
+        string[] ExcludeAssemblies { get; set; }
+        string[] IncludeAssemblies { get; set; }
     }
 
     internal interface IMsCodeCoverageIncludesExcludesOptions
@@ -23,15 +26,17 @@ internal interface IMsCodeCoverageIncludesExcludesOptions
         string[] FunctionsExclude { get; set; }
     }
     internal interface IMsCodeCoverageOptions : IMsCodeCoverageIncludesExcludesOptions, IFCCCommonOptions { }
-
     internal enum RunMsCodeCoverage { No, IfInRunSettings, Yes }
 
-    internal interface IAppOptions : IMsCodeCoverageOptions, IFCCCommonOptions
+    internal interface IOpenCoverCoverletExcludeIncludeOptions
     {
         string[] Exclude { get; set; }
         string[] ExcludeByAttribute { get; set; }
         string[] ExcludeByFile { get; set; }
         string[] Include { get; set; }
+    }
+    internal interface IAppOptions : IMsCodeCoverageOptions, IOpenCoverCoverletExcludeIncludeOptions, IFCCCommonOptions
+    {
         bool RunInParallel { get; set; }
         int RunWhenTestsExceed { get; set; }
         string ToolsDirectory { get; set; }