diff --git a/Directory.Build.targets b/Directory.Build.targets
index 475ad7649..e3d7b9076 100644
--- a/Directory.Build.targets
+++ b/Directory.Build.targets
@@ -14,7 +14,7 @@
     <!-- Do not upgrade this version or we won't support old SDK -->
     <PackageReference Update="Newtonsoft.Json" Version="9.0.1" />
     <PackageReference Update="NuGet.Packaging" Version="5.4.0" />
-    <PackageReference Update="ReportGenerator.Core" Version="4.4.4" />
+    <PackageReference Update="ReportGenerator.Core" Version="4.4.5" />
     <!--
         Do not change System.Reflection.Metadata version since we need to support VSTest DataCollectors. Goto https://www.nuget.org/packages/System.Reflection.Metadata to check versions.
         We need to load assembly version 1.4.2.0 to properly work
diff --git a/coverlet.sln b/coverlet.sln
index 0df80bdce..7019ec9b8 100644
--- a/coverlet.sln
+++ b/coverlet.sln
@@ -46,6 +46,8 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "coverlet.integration.tests"
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "coverlet.integration.template", "test\coverlet.integration.template\coverlet.integration.template.csproj", "{F6FE7678-C662-43D3-AC6A-64F6AC5A5935}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "coverlet.core.tests.samples.netstandard", "test\coverlet.core.tests.samples.netstandard\coverlet.core.tests.samples.netstandard.csproj", "{5FF404AD-7C0B-465A-A1E9-558CDC642B0C}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -104,6 +106,10 @@ Global
 		{F6FE7678-C662-43D3-AC6A-64F6AC5A5935}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{F6FE7678-C662-43D3-AC6A-64F6AC5A5935}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{F6FE7678-C662-43D3-AC6A-64F6AC5A5935}.Release|Any CPU.Build.0 = Release|Any CPU
+		{5FF404AD-7C0B-465A-A1E9-558CDC642B0C}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{5FF404AD-7C0B-465A-A1E9-558CDC642B0C}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{5FF404AD-7C0B-465A-A1E9-558CDC642B0C}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{5FF404AD-7C0B-465A-A1E9-558CDC642B0C}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -122,6 +128,7 @@ Global
 		{D6B14F2F-9E7D-4D2C-BAC8-48834F853ED6} = {2FEBDE1B-83E3-445B-B9F8-5644B0E0E134}
 		{99B4059C-B25C-4B82-8117-A0E9DC9B0949} = {2FEBDE1B-83E3-445B-B9F8-5644B0E0E134}
 		{F6FE7678-C662-43D3-AC6A-64F6AC5A5935} = {2FEBDE1B-83E3-445B-B9F8-5644B0E0E134}
+		{5FF404AD-7C0B-465A-A1E9-558CDC642B0C} = {2FEBDE1B-83E3-445B-B9F8-5644B0E0E134}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {9CA57C02-97B0-4C38-A027-EA61E8741F10}
diff --git a/eng/build.yml b/eng/build.yml
index e12b5069a..996e9476f 100644
--- a/eng/build.yml
+++ b/eng/build.yml
@@ -22,5 +22,5 @@ steps:
   displayName: Test
   inputs:
     command: test
-    arguments: -c $(BuildConfiguration) --no-build /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Include=[coverlet.*]* /p:Exclude=[coverlet.tests.remoteexecutor]*
+    arguments: -c $(BuildConfiguration) --no-build /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Include="[coverlet.collector]*%2c[coverlet.core]*%2c[coverlet.msbuild.tasks]*" /p:Exclude="[coverlet.core.tests.samples.netstandard]*%2c[coverlet.tests.remoteexecutor]*"
     testRunTitle: $(Agent.JobName)
\ No newline at end of file
diff --git a/src/coverlet.core/Symbols/CecilSymbolHelper.cs b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
index c528c607e..876a3586c 100644
--- a/src/coverlet.core/Symbols/CecilSymbolHelper.cs
+++ b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
@@ -60,6 +60,25 @@ private static bool IsMoveNextInsideEnumerator(MethodDefinition methodDefinition
             return false;
         }
 
+        private static bool IsRecognizedMoveNextInsideAsyncStateMachineProlog(MethodDefinition methodDefinition)
+        {
+            /*
+                int num = <>1__state;
+                IL_0000: ldarg.0
+                IL_0001: ldfld ...::'<>1__state'
+                IL_0006: stloc.0
+            */
+            return (methodDefinition.Body.Instructions[0].OpCode == OpCodes.Ldarg_0 ||
+                    methodDefinition.Body.Instructions[0].OpCode == OpCodes.Ldarg) &&
+
+                    methodDefinition.Body.Instructions[1].OpCode == OpCodes.Ldfld &&
+                    methodDefinition.Body.Instructions[1].Operand is FieldDefinition fd && fd.Name == "<>1__state" &&
+
+                    (methodDefinition.Body.Instructions[2].OpCode == OpCodes.Stloc &&
+                    methodDefinition.Body.Instructions[2].Operand is VariableDefinition vd && vd.Index == 0) ||
+                    methodDefinition.Body.Instructions[2].OpCode == OpCodes.Stloc_0;
+        }
+
         public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinition)
         {
             var list = new List<BranchPoint>();
@@ -69,9 +88,9 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
             UInt32 ordinal = 0;
             var instructions = methodDefinition.Body.Instructions;
 
-            // if method is a generated MoveNext skip first branch (could be a switch or a branch)
             bool isAsyncStateMachineMoveNext = IsMoveNextInsideAsyncStateMachine(methodDefinition);
-            bool skipFirstBranch = isAsyncStateMachineMoveNext || IsMoveNextInsideEnumerator(methodDefinition);
+            bool isRecognizedMoveNextInsideAsyncStateMachineProlog = isAsyncStateMachineMoveNext && IsRecognizedMoveNextInsideAsyncStateMachineProlog(methodDefinition);
+            bool skipFirstBranch = IsMoveNextInsideEnumerator(methodDefinition);
 
             foreach (Instruction instruction in instructions.Where(instruction => instruction.OpCode.FlowControl == FlowControl.Cond_Branch))
             {
@@ -83,15 +102,87 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                         continue;
                     }
 
+                    /* 
+                       If method is a generated MoveNext we'll skip first branches (could be a switch or a series of branches) 
+                       that check state machine value to jump to correct state(for instance after a true async call)
+                       Check if it's a Cond_Branch on state machine current value int num = <>1__state;
+                       We are on branch OpCode so we need to go back by max 2 operation to reach ldloc.0 the load of "num"
+                       Max 2 because we handle following patterns
+
+                        Swich
+
+                        // switch (num)
+                        IL_0007: ldloc.0                        2
+                        // (no C# code)
+                        IL_0008: switch (IL_0037, IL_003c, ...  1
+                        ...
+
+                        Single branch
+
+                        // if (num != 0)
+                        IL_0007: ldloc.0           2
+                        // (no C# code)
+                        IL_0008: brfalse.s IL_000c 1
+                        IL_000a: br.s IL_000e
+                        IL_000c: br.s IL_0049
+                        IL_000e: nop
+                        ...
+
+                        More tha one branch
+
+                        // if (num != 0)
+                        IL_0007: ldloc.0
+                        // (no C# code)
+                        IL_0008: brfalse.s IL_0012
+                        IL_000a: br.s IL_000c
+                        // if (num == 1)
+                        IL_000c: ldloc.0       3
+                        IL_000d: ldc.i4.1      2
+                        IL_000e: beq.s IL_0014 1
+                        // (no C# code)
+                        IL_0010: br.s IL_0019
+                        IL_0012: br.s IL_0060
+                        IL_0014: br IL_00e5
+                        IL_0019: nop
+                        ...
+
+                        so we know that current branch are checking that field and we're not interested in.
+                    */
+                    if (isAsyncStateMachineMoveNext && isRecognizedMoveNextInsideAsyncStateMachineProlog)
+                    {
+                        bool skipInstruction = false;
+                        Instruction current = instruction.Previous;
+                        for (int instructionBefore = 2; instructionBefore > 0 && current.Previous != null; current = current.Previous, instructionBefore--)
+                        {
+                            if (
+                                    (current.OpCode == OpCodes.Ldloc && current.Operand is VariableDefinition vo && vo.Index == 0) ||
+                                    current.OpCode == OpCodes.Ldloc_0
+                                )
+                            {
+                                skipInstruction = true;
+                                break;
+                            }
+                        }
+                        if (skipInstruction)
+                        {
+                            continue;
+                        }
+                    }
+
                     // Skip get_IsCompleted to avoid unuseful branch due to async/await state machine
-                    if (isAsyncStateMachineMoveNext && instruction.Previous.Operand is MethodReference operand &&
+                    if (
+                            isAsyncStateMachineMoveNext && instruction.Previous.Operand is MethodReference operand &&
                             operand.Name == "get_IsCompleted" &&
                             (
                                 operand.DeclaringType.FullName.StartsWith("System.Runtime.CompilerServices.TaskAwaiter") ||
                                 operand.DeclaringType.FullName.StartsWith("System.Runtime.CompilerServices.ConfiguredTaskAwaitable")
                             )
                             &&
-                            operand.DeclaringType.Scope.Name == "System.Runtime")
+                            (
+                                operand.DeclaringType.Scope.Name == "System.Runtime" ||
+                                operand.DeclaringType.Scope.Name == "netstandard"
+                            )
+                       )
                     {
                         continue;
                     }
diff --git a/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
new file mode 100644
index 000000000..c183d1448
--- /dev/null
+++ b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
@@ -0,0 +1,17 @@
+// Remember to use full name because adding new using directives change line numbers
+
+namespace Coverlet.Core.Tests
+{
+    public class Issue_669_2
+    {
+        private readonly System.Net.Http.HttpClient _httpClient = new System.Net.Http.HttpClient();
+
+        async public System.Threading.Tasks.ValueTask<System.Net.Http.HttpResponseMessage> SendRequest()
+        {
+            using (var requestMessage = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, "https://www.google.it"))
+            {
+                return await _httpClient.SendAsync(requestMessage).ConfigureAwait(false);
+            }
+        }
+    }
+}
diff --git a/test/coverlet.core.tests.samples.netstandard/coverlet.core.tests.samples.netstandard.csproj b/test/coverlet.core.tests.samples.netstandard/coverlet.core.tests.samples.netstandard.csproj
new file mode 100644
index 000000000..783e0d0c3
--- /dev/null
+++ b/test/coverlet.core.tests.samples.netstandard/coverlet.core.tests.samples.netstandard.csproj
@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+    <IsPackable>false</IsPackable>
+    <IsTestProject>false</IsTestProject>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.3" />
+  </ItemGroup>
+
+</Project>
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
new file mode 100644
index 000000000..b61fad206
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -0,0 +1,130 @@
+using System.IO;
+using System.Threading.Tasks;
+
+using Coverlet.Core.Samples.Tests;
+using Coverlet.Tests.RemoteExecutor;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void AsyncAwait()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<AsyncAwait>(instance =>
+                    {
+                        instance.SyncExecution();
+
+                        int res = ((Task<int>)instance.AsyncExecution(true)).ConfigureAwait(false).GetAwaiter().GetResult();
+                        res = ((Task<int>)instance.AsyncExecution(1)).ConfigureAwait(false).GetAwaiter().GetResult();
+                        res = ((Task<int>)instance.AsyncExecution(2)).ConfigureAwait(false).GetAwaiter().GetResult();
+                        res = ((Task<int>)instance.AsyncExecution(3)).ConfigureAwait(false).GetAwaiter().GetResult();
+                        res = ((Task<int>)instance.ContinuationCalled()).ConfigureAwait(false).GetAwaiter().GetResult();
+                        res = ((Task<int>)instance.ConfigureAwait()).ConfigureAwait(false).GetAwaiter().GetResult();
+
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+                    return 0;
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                result.Document("Instrumentation.AsyncAwait.cs")
+                      .AssertLinesCovered(BuildConfiguration.Debug,
+                                            // AsyncExecution(bool)
+                                            (10, 1), (11, 1), (12, 1), (14, 1), (16, 1), (17, 0), (18, 0), (19, 0), (21, 1), (22, 1),
+                                            // Async
+                                            (25, 9), (26, 9), (27, 9), (28, 9),
+                                            // SyncExecution
+                                            (31, 1), (32, 1), (33, 1),
+                                            // Sync
+                                            (36, 1), (37, 1), (38, 1),
+                                            // AsyncExecution(int)
+                                            (41, 3), (42, 3), (43, 3), (46, 1), (47, 1), (48, 1), (51, 1),
+                                            (52, 1), (53, 1), (56, 1), (57, 1), (58, 1), (59, 1),
+                                            (62, 0), (63, 0), (64, 0), (65, 0), (68, 0), (70, 3), (71, 3),
+                                            // ContinuationNotCalled
+                                            (74, 0), (75, 0), (76, 0), (77, 0), (78, 0),
+                                            // ContinuationCalled -> line 83 should be 1 hit some issue with Continuation state machine
+                                            (81, 1), (82, 1), (83, 2), (84, 1), (85, 1),
+                                            // ConfigureAwait
+                                            (89, 1), (90, 1)
+                                         )
+                      .AssertBranchesCovered(BuildConfiguration.Debug, (16, 0, 0), (16, 1, 1), (43, 0, 3), (43, 1, 1), (43, 2, 1), (43, 3, 1), (43, 4, 0))
+                      // Real branch should be 2, we should try to remove compiler generated branch in method ContinuationNotCalled/ContinuationCalled
+                      // for Continuation state machine
+                      .ExpectedTotalNumberOfBranches(BuildConfiguration.Debug, 4);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void AsyncAwait_Issue_669_1()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_1>(instance =>
+                    {
+                        ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
+                        return Task.CompletedTask;
+                    },
+                    persistPrepareResultToFile: pathSerialize, disableRestoreModules: true);
+
+                    return 0;
+                }, path, invokeInProcess: true).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.AsyncAwait.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug,
+                (97, 1), (98, 1), (99, 1), (101, 1), (102, 1), (103, 1),
+                (110, 1), (111, 1), (112, 1), (113, 1),
+                (116, 1), (117, 1), (118, 1), (119, 1));
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void AsyncAwait_Issue_669_2()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_2>(instance =>
+                    {
+                        ((ValueTask<System.Net.Http.HttpResponseMessage>)instance.SendRequest()).ConfigureAwait(false).GetAwaiter().GetResult();
+                        return Task.CompletedTask;
+                    },
+                    persistPrepareResultToFile: pathSerialize, disableRestoreModules: true);
+
+                    return 0;
+                }, path, invokeInProcess: true).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.AsyncAwait.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug, (7, 1), (10, 1), (11, 1), (12, 1), (13, 1), (15, 1))
+                .ExpectedTotalNumberOfBranches(BuildConfiguration.Debug, 0);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.ExcludeFromCoverageAttribute.cs b/test/coverlet.core.tests/Coverage/CoverageTests.ExcludeFromCoverageAttribute.cs
new file mode 100644
index 000000000..61f0ccebb
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.ExcludeFromCoverageAttribute.cs
@@ -0,0 +1,165 @@
+using System;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+
+using Coverlet.Core.Abstracts;
+using Coverlet.Core.Helpers;
+using Coverlet.Core.Samples.Tests;
+using Coverlet.Tests.RemoteExecutor;
+using Moq;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void TestCoverageSkipModule__AssemblyMarkedAsExcludeFromCodeCoverage()
+        {
+            Mock<FileSystem> partialMockFileSystem = new Mock<FileSystem>();
+            partialMockFileSystem.CallBase = true;
+            partialMockFileSystem.Setup(fs => fs.NewFileStream(It.IsAny<string>(), It.IsAny<FileMode>(), It.IsAny<FileAccess>())).Returns((string path, FileMode mode, FileAccess access) =>
+            {
+                return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
+            });
+            var loggerMock = new Mock<ILogger>();
+
+            string excludedbyattributeDll = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets"), "coverlet.tests.projectsample.excludedbyattribute.dll").First();
+            // test skip module include test assembly feature
+            var coverage = new Coverage(excludedbyattributeDll, new string[] { "[coverlet.tests.projectsample.excludedbyattribute*]*" }, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), true, false, string.Empty, false, loggerMock.Object, _instrumentationHelper, partialMockFileSystem.Object);
+            CoveragePrepareResult result = coverage.PrepareModules();
+            Assert.Empty(result.Results);
+            loggerMock.Verify(l => l.LogVerbose(It.IsAny<string>()));
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverage_CompilerGeneratedMethodsAndTypes()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr>(instance =>
+                    {
+                        ((Task<int>)instance.Test("test")).ConfigureAwait(false).GetAwaiter().GetResult();
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                var document = result.Document("Instrumentation.ExcludeFromCoverage.cs");
+
+                // Invoking method "Test" of class "MethodsWithExcludeFromCodeCoverageAttr" we expect to cover 100% lines for MethodsWithExcludeFromCodeCoverageAttr 
+                Assert.DoesNotContain(document.Lines, l =>
+                    (l.Value.Class == "Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr" ||
+                    // Compiler generated
+                    l.Value.Class.StartsWith("Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr/")) &&
+                    l.Value.Hits == 0);
+                // and 0% for MethodsWithExcludeFromCodeCoverageAttr2
+                Assert.DoesNotContain(document.Lines, l =>
+                    (l.Value.Class == "Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr2" ||
+                    // Compiler generated
+                    l.Value.Class.StartsWith("Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr2/")) &&
+                    l.Value.Hits == 1);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverage_CompilerGeneratedMethodsAndTypes_NestedMembers()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr_NestedStateMachines>(instance =>
+                    {
+                        instance.Test();
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                result.Document("Instrumentation.ExcludeFromCoverage.NestedStateMachines.cs")
+                        .AssertLinesCovered(BuildConfiguration.Debug, (14, 1), (15, 1), (16, 1))
+                        .AssertNonInstrumentedLines(BuildConfiguration.Debug, 9, 11);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageCompilerGeneratedMethodsAndTypes_Issue670()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr_Issue670>(instance =>
+                    {
+                        instance.Test("test");
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                result.Document("Instrumentation.ExcludeFromCoverage.Issue670.cs")
+                        .AssertLinesCovered(BuildConfiguration.Debug, (8, 1), (9, 1), (10, 1), (11, 1))
+                        .AssertNonInstrumentedLines(BuildConfiguration.Debug, 15, 53);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void ExcludeFromCodeCoverageNextedTypes()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFromCoverageAttrFilterClass1>(instance =>
+                    {
+                        Assert.Equal(42, instance.Run());
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+                }, path).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.ExcludeFromCoverage.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug, (143, 1))
+                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 146, 160);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.Filters.cs b/test/coverlet.core.tests/Coverage/CoverageTests.Filters.cs
new file mode 100644
index 000000000..071b0c9e3
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.Filters.cs
@@ -0,0 +1,131 @@
+using System;
+using System.IO;
+using System.Reflection;
+using System.Threading.Tasks;
+
+using Coverlet.Core.Samples.Tests;
+using Coverlet.Tests.RemoteExecutor;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void ExcludeFilteredNestedAutogeneratedTypes()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterNestedAutogeneratedTypes>(instance =>
+                    {
+                        instance.Run();
+
+                        PropertyInfo stateProp = null;
+                        foreach (Type type in ((Type)instance.GetType()).Assembly.GetTypes())
+                        {
+                            if (typeof(Issue_689).FullName == type.FullName)
+                            {
+                                Assert.Equal(0, (stateProp = type.GetProperty("State")).GetValue(null));
+                                break;
+                            }
+                        }
+
+                        foreach (Type type in ((Type)instance.GetType()).Assembly.GetTypes())
+                        {
+                            if (typeof(EventSource_Issue_689).FullName == type.FullName)
+                            {
+                                type.GetMethod("RaiseEvent").Invoke(null, null);
+                                break;
+                            }
+                        }
+
+                        Assert.Equal(2, stateProp.GetValue(null));
+
+                        return Task.CompletedTask;
+                    },
+                    includeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterNestedAutogeneratedTypes", $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*Issue_689" },
+                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*NestedToFilterOut", $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*Uncoverlet" },
+                    persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+                }, path).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.ExcludeFilter.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug, (12, 1), (13, 1), (14, 1))
+                .AssertLinesCovered(BuildConfiguration.Debug, (27, 1), (28, 1), (29, 1), (30, 1), (31, 1))
+                .AssertLinesCovered(BuildConfiguration.Debug, (39, 2), (40, 2), (41, 2), (43, 5))
+                .AssertLinesCovered(BuildConfiguration.Debug, (50, 1), (51, 1), (52, 1))
+                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 17, 21)
+                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 33, 36);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void ExcludeFilteredTypes()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterOuterTypes>(instance =>
+                    {
+                        Assert.Equal(42, instance.Run());
+                        return Task.CompletedTask;
+                    },
+                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterOuterTypes" },
+                    persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+                }, path).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.ExcludeFilter.cs")
+                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 1, 62)
+                .AssertLinesCovered(BuildConfiguration.Debug, (66, 1), (68, 1));
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void ExcludeFilteredNestedTypes()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterClass1>(instance =>
+                    {
+                        Assert.Equal(42, instance.Run());
+                        return Task.CompletedTask;
+                    },
+                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterClass2" },
+                    persistPrepareResultToFile: pathSerialize);
+
+                    return 0;
+                }, path).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .Document("Instrumentation.ExcludeFilter.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug, (73, 1))
+                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 75, 93);
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs b/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
new file mode 100644
index 000000000..28f4d71a8
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
@@ -0,0 +1,56 @@
+using System.IO;
+using System.Threading.Tasks;
+
+using Coverlet.Core.Samples.Tests;
+using Coverlet.Tests.RemoteExecutor;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void Lambda_Issue343()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Lambda_Issue343>(instance =>
+                    {
+                        instance.InvokeAnonymous_Test();
+                        ((Task<bool>)instance.InvokeAnonymousAsync_Test()).ConfigureAwait(false).GetAwaiter().GetResult();
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+                    return 0;
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                result.Document("Instrumentation.Lambda.cs")
+                      .AssertLinesCoveredAllBut(BuildConfiguration.Debug, 23, 51)
+                      .AssertBranchesCovered(BuildConfiguration.Debug,
+                        // Expected branches
+                        (22, 0, 0),
+                        (22, 1, 1),
+                        (50, 2, 0),
+                        (50, 3, 1),
+                        // Unexpected branches
+                        (20, 0, 1),
+                        (20, 1, 1),
+                        (49, 0, 1),
+                        (49, 1, 0),
+                        (54, 4, 0),
+                        (54, 5, 1),
+                        (48, 0, 1),
+                        (48, 1, 1)
+                      );
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.SelectionStatements.cs b/test/coverlet.core.tests/Coverage/CoverageTests.SelectionStatements.cs
new file mode 100644
index 000000000..2710e49ae
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.SelectionStatements.cs
@@ -0,0 +1,88 @@
+using System.IO;
+using System.Threading.Tasks;
+
+using Coverlet.Core.Samples.Tests;
+using Coverlet.Tests.RemoteExecutor;
+using Xunit;
+
+namespace Coverlet.Core.Tests
+{
+    public partial class CoverageTests
+    {
+        [Fact]
+        public void SelectionStatements_If()
+        {
+            // We need to pass file name to remote process where it save instrumentation result
+            // Similar to msbuild input/output
+            string path = Path.GetTempFileName();
+            try
+            {
+                // Lambda will run in a custom process to avoid issue with statics and file locking
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    // Run load and call a delegate passing class as dynamic to simplify method call
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<SelectionStatements>(instance =>
+                    {
+                        // We call method to trigger coverage hits
+                        instance.If(true);
+
+                        // For now we have only async Run helper
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+
+                    // we return 0 if we return something different assert fail
+                    return 0;
+                }, path).Dispose();
+
+                // We retrive and load CoveragePrepareResult and run coverage calculation
+                // Similar to msbuild coverage result task
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                // Generate html report to check
+                // TestInstrumentationHelper.GenerateHtmlReport(result);
+
+                // Asserts on doc/lines/branches
+                result.Document("Instrumentation.SelectionStatements.cs")
+                      // (line, hits)
+                      .AssertLinesCovered((11, 1), (15, 0))
+                      // (line,ordinal,hits)
+                      .AssertBranchesCovered((9, 0, 1), (9, 1, 0));
+            }
+            finally
+            {
+                // Cleanup tmp file
+                File.Delete(path);
+            }
+        }
+
+        [Fact]
+        public void SelectionStatements_Switch()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<SelectionStatements>(instance =>
+                    {
+                        instance.Switch(1);
+                        return Task.CompletedTask;
+                    }, persistPrepareResultToFile: pathSerialize);
+                    return 0;
+                }, path).Dispose();
+
+                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
+
+                result.Document("Instrumentation.SelectionStatements.cs")
+                      .AssertLinesCovered(BuildConfiguration.Release, (24, 1), (26, 0), (28, 0))
+                      .AssertBranchesCovered(BuildConfiguration.Release, (24, 1, 1))
+                      .AssertLinesCovered(BuildConfiguration.Debug, (20, 1), (21, 1), (24, 1), (30, 1))
+                      .AssertBranchesCovered(BuildConfiguration.Debug, (21, 0, 0), (21, 1, 1), (21, 2, 0), (21, 3, 0));
+            }
+            finally
+            {
+                File.Delete(path);
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.cs b/test/coverlet.core.tests/Coverage/CoverageTests.cs
index 5925c01e5..5dbd3681e 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.cs
@@ -1,19 +1,14 @@
 using System;
 using System.IO;
-using System.Linq;
-using System.Reflection;
-using System.Threading.Tasks;
 
 using Coverlet.Core.Abstracts;
 using Coverlet.Core.Helpers;
-using Coverlet.Core.Samples.Tests;
-using Coverlet.Tests.RemoteExecutor;
 using Moq;
 using Xunit;
 
 namespace Coverlet.Core.Tests
 {
-    public class CoverageTests
+    public partial class CoverageTests
     {
         private readonly InstrumentationHelper _instrumentationHelper = new InstrumentationHelper(new ProcessExitHandler(), new RetryHelper(), new FileSystem());
         private readonly Mock<ILogger> _mockLogger = new Mock<ILogger>();
@@ -41,25 +36,6 @@ public void TestCoverage()
             directory.Delete(true);
         }
 
-        [Fact]
-        public void TestCoverageSkipModule__AssemblyMarkedAsExcludeFromCodeCoverage()
-        {
-            Mock<FileSystem> partialMockFileSystem = new Mock<FileSystem>();
-            partialMockFileSystem.CallBase = true;
-            partialMockFileSystem.Setup(fs => fs.NewFileStream(It.IsAny<string>(), It.IsAny<FileMode>(), It.IsAny<FileAccess>())).Returns((string path, FileMode mode, FileAccess access) =>
-            {
-                return new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read);
-            });
-            var loggerMock = new Mock<ILogger>();
-
-            string excludedbyattributeDll = Directory.GetFiles(Path.Combine(Directory.GetCurrentDirectory(), "TestAssets"), "coverlet.tests.projectsample.excludedbyattribute.dll").First();
-            // test skip module include test assembly feature
-            var coverage = new Coverage(excludedbyattributeDll, new string[] { "[coverlet.tests.projectsample.excludedbyattribute*]*" }, Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), Array.Empty<string>(), true, false, string.Empty, false, loggerMock.Object, _instrumentationHelper, partialMockFileSystem.Object);
-            CoveragePrepareResult result = coverage.PrepareModules();
-            Assert.Empty(result.Results);
-            loggerMock.Verify(l => l.LogVerbose(It.IsAny<string>()));
-        }
-
         [Fact]
         public void TestCoverageWithTestAssembly()
         {
@@ -80,432 +56,5 @@ public void TestCoverageWithTestAssembly()
 
             directory.Delete(true);
         }
-
-        [Fact]
-        public void SelectionStatements_If()
-        {
-            // We need to pass file name to remote process where it save instrumentation result
-            // Similar to msbuild input/output
-            string path = Path.GetTempFileName();
-            try
-            {
-                // Lambda will run in a custom process to avoid issue with statics and file locking
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    // Run load and call a delegate passing class as dynamic to simplify method call
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<SelectionStatements>(instance =>
-                    {
-                        // We call method to trigger coverage hits
-                        instance.If(true);
-
-                        // For now we have only async Run helper
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-
-                    // we return 0 if we return something different assert fail
-                    return 0;
-                }, path).Dispose();
-
-                // We retrive and load CoveragePrepareResult and run coverage calculation
-                // Similar to msbuild coverage result task
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                // Generate html report to check
-                // TestInstrumentationHelper.GenerateHtmlReport(result);
-
-                // Asserts on doc/lines/branches
-                result.Document("Instrumentation.SelectionStatements.cs")
-                      // (line, hits)
-                      .AssertLinesCovered((11, 1), (15, 0))
-                      // (line,ordinal,hits)
-                      .AssertBranchesCovered((9, 0, 1), (9, 1, 0));
-            }
-            finally
-            {
-                // Cleanup tmp file
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void SelectionStatements_Switch()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<SelectionStatements>(instance =>
-                    {
-                        instance.Switch(1);
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-                    return 0;
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                result.Document("Instrumentation.SelectionStatements.cs")
-                      .AssertLinesCovered(BuildConfiguration.Release, (24, 1), (26, 0), (28, 0))
-                      .AssertBranchesCovered(BuildConfiguration.Release, (24, 1, 1))
-                      .AssertLinesCovered(BuildConfiguration.Debug, (20, 1), (21, 1), (24, 1), (30, 1))
-                      .AssertBranchesCovered(BuildConfiguration.Debug, (21, 0, 0), (21, 1, 1), (21, 2, 0), (21, 3, 0));
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void AsyncAwait()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<AsyncAwait>(instance =>
-                    {
-                        instance.SyncExecution();
-
-                        int res = ((Task<int>)instance.AsyncExecution(true)).ConfigureAwait(false).GetAwaiter().GetResult();
-                        res = ((Task<int>)instance.AsyncExecution(1)).ConfigureAwait(false).GetAwaiter().GetResult();
-                        res = ((Task<int>)instance.AsyncExecution(2)).ConfigureAwait(false).GetAwaiter().GetResult();
-                        res = ((Task<int>)instance.AsyncExecution(3)).ConfigureAwait(false).GetAwaiter().GetResult();
-                        res = ((Task<int>)instance.ContinuationCalled()).ConfigureAwait(false).GetAwaiter().GetResult();
-                        res = ((Task<int>)instance.ConfigureAwait()).ConfigureAwait(false).GetAwaiter().GetResult();
-
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-                    return 0;
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                result.Document("Instrumentation.AsyncAwait.cs")
-                      .AssertLinesCovered(BuildConfiguration.Debug,
-                                            // AsyncExecution(bool)
-                                            (10, 1), (11, 1), (12, 1), (14, 1), (16, 1), (17, 0), (18, 0), (19, 0), (21, 1), (22, 1),
-                                            // Async
-                                            (25, 9), (26, 9), (27, 9), (28, 9),
-                                            // SyncExecution
-                                            (31, 1), (32, 1), (33, 1),
-                                            // Sync
-                                            (36, 1), (37, 1), (38, 1),
-                                            // AsyncExecution(int)
-                                            (41, 3), (42, 3), (43, 3), (46, 1), (47, 1), (48, 1), (51, 1),
-                                            (52, 1), (53, 1), (56, 1), (57, 1), (58, 1), (59, 1),
-                                            (62, 0), (63, 0), (64, 0), (65, 0), (68, 0), (70, 3), (71, 3),
-                                            // ContinuationNotCalled
-                                            (74, 0), (75, 0), (76, 0), (77, 0), (78, 0),
-                                            // ContinuationCalled -> line 83 should be 1 hit some issue with Continuation state machine
-                                            (81, 1), (82, 1), (83, 2), (84, 1), (85, 1),
-                                            // ConfigureAwait
-                                            (89, 1), (90, 1)
-                                         )
-                      .AssertBranchesCovered(BuildConfiguration.Debug, (16, 0, 0), (16, 1, 1), (43, 0, 3), (43, 1, 1), (43, 2, 1), (43, 3, 1), (43, 4, 0))
-                      // Real branch should be 2, we should try to remove compiler generated branch in method ContinuationNotCalled/ContinuationCalled
-                      // for Continuation state machine
-                      .ExpectedTotalNumberOfBranches(BuildConfiguration.Debug, 4);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void Lambda_Issue343()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Lambda_Issue343>(instance =>
-                    {
-                        instance.InvokeAnonymous_Test();
-                        ((Task<bool>)instance.InvokeAnonymousAsync_Test()).ConfigureAwait(false).GetAwaiter().GetResult();
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-                    return 0;
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                result.Document("Instrumentation.Lambda.cs")
-                      .AssertLinesCoveredAllBut(BuildConfiguration.Debug, 23, 51)
-                      .AssertBranchesCovered(BuildConfiguration.Debug,
-                        // Expected branches
-                        (22, 0, 0),
-                        (22, 1, 1),
-                        (50, 2, 0),
-                        (50, 3, 1),
-                        // Unexpected branches
-                        (20, 0, 1),
-                        (20, 1, 1),
-                        (49, 0, 1),
-                        (49, 1, 0),
-                        (54, 4, 0),
-                        (54, 5, 1),
-                        (39, 0, 1),
-                        (39, 1, 0),
-                        (48, 0, 1),
-                        (48, 1, 1)
-                      );
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-
-        [Fact]
-        public void ExcludeFromCodeCoverage_CompilerGeneratedMethodsAndTypes()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr>(instance =>
-                    {
-                        ((Task<int>)instance.Test("test")).ConfigureAwait(false).GetAwaiter().GetResult();
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                var document = result.Document("Instrumentation.ExcludeFromCoverage.cs");
-
-                // Invoking method "Test" of class "MethodsWithExcludeFromCodeCoverageAttr" we expect to cover 100% lines for MethodsWithExcludeFromCodeCoverageAttr 
-                Assert.DoesNotContain(document.Lines, l =>
-                    (l.Value.Class == "Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr" ||
-                    // Compiler generated
-                    l.Value.Class.StartsWith("Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr/")) &&
-                    l.Value.Hits == 0);
-                // and 0% for MethodsWithExcludeFromCodeCoverageAttr2
-                Assert.DoesNotContain(document.Lines, l =>
-                    (l.Value.Class == "Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr2" ||
-                    // Compiler generated
-                    l.Value.Class.StartsWith("Coverlet.Core.Samples.Tests.MethodsWithExcludeFromCodeCoverageAttr2/")) &&
-                    l.Value.Hits == 1);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFromCodeCoverage_CompilerGeneratedMethodsAndTypes_NestedMembers()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr_NestedStateMachines>(instance =>
-                    {
-                        instance.Test();
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                result.Document("Instrumentation.ExcludeFromCoverage.NestedStateMachines.cs")
-                        .AssertLinesCovered(BuildConfiguration.Debug, (14, 1), (15, 1), (16, 1))
-                        .AssertNonInstrumentedLines(BuildConfiguration.Debug, 9, 11);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFromCodeCoverageCompilerGeneratedMethodsAndTypes_Issue670()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<MethodsWithExcludeFromCodeCoverageAttr_Issue670>(instance =>
-                    {
-                        instance.Test("test");
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-
-                }, path).Dispose();
-
-                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
-
-                result.Document("Instrumentation.ExcludeFromCoverage.Issue670.cs")
-                        .AssertLinesCovered(BuildConfiguration.Debug, (8, 1), (9, 1), (10, 1), (11, 1))
-                        .AssertNonInstrumentedLines(BuildConfiguration.Debug, 15, 53);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFromCodeCoverageNextedTypes()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFromCoverageAttrFilterClass1>(instance =>
-                    {
-                        Assert.Equal(42, instance.Run());
-                        return Task.CompletedTask;
-                    }, persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-                }, path).Dispose();
-
-                TestInstrumentationHelper.GetCoverageResult(path)
-                .Document("Instrumentation.ExcludeFromCoverage.cs")
-                .AssertLinesCovered(BuildConfiguration.Debug, (143, 1))
-                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 146, 160);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFilteredNestedAutogeneratedTypes()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterNestedAutogeneratedTypes>(instance =>
-                    {
-                        instance.Run();
-
-                        PropertyInfo stateProp = null;
-                        foreach (Type type in ((Type)instance.GetType()).Assembly.GetTypes())
-                        {
-                            if (typeof(Issue_689).FullName == type.FullName)
-                            {
-                                Assert.Equal(0, (stateProp = type.GetProperty("State")).GetValue(null));
-                                break;
-                            }
-                        }
-
-                        foreach (Type type in ((Type)instance.GetType()).Assembly.GetTypes())
-                        {
-                            if (typeof(EventSource_Issue_689).FullName == type.FullName)
-                            {
-                                type.GetMethod("RaiseEvent").Invoke(null, null);
-                                break;
-                            }
-                        }
-
-                        Assert.Equal(2, stateProp.GetValue(null));
-
-                        return Task.CompletedTask;
-                    },
-                    includeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterNestedAutogeneratedTypes", $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*Issue_689" },
-                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*NestedToFilterOut", $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*Uncoverlet" },
-                    persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-                }, path).Dispose();
-
-               TestInstrumentationHelper.GetCoverageResult(path)
-               .Document("Instrumentation.ExcludeFilter.cs")
-               .AssertLinesCovered(BuildConfiguration.Debug, (12, 1), (13, 1), (14, 1))
-               .AssertLinesCovered(BuildConfiguration.Debug, (27, 1), (28, 1), (29, 1), (30, 1), (31, 1))
-               .AssertLinesCovered(BuildConfiguration.Debug, (39, 2), (40, 2), (41, 2), (43, 5))
-               .AssertLinesCovered(BuildConfiguration.Debug, (50, 1), (51, 1), (52, 1))
-               .AssertNonInstrumentedLines(BuildConfiguration.Debug, 17, 21)
-               .AssertNonInstrumentedLines(BuildConfiguration.Debug, 33, 36);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFilteredTypes()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterOuterTypes>(instance =>
-                    {
-                        Assert.Equal(42, instance.Run());
-                        return Task.CompletedTask;
-                    },
-                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterOuterTypes" },
-                    persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-                }, path).Dispose();
-
-                TestInstrumentationHelper.GetCoverageResult(path)
-                .Document("Instrumentation.ExcludeFilter.cs")
-                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 1, 62)
-                .AssertLinesCovered(BuildConfiguration.Debug, (66, 1), (68, 1));
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
-
-        [Fact]
-        public void ExcludeFilteredNestedTypes()
-        {
-            string path = Path.GetTempFileName();
-            try
-            {
-                RemoteExecutor.Invoke(async pathSerialize =>
-                {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<ExcludeFilterClass1>(instance =>
-                    {
-                        Assert.Equal(42, instance.Run());
-                        return Task.CompletedTask;
-                    },
-                    excludeFilter: moduleFileName => new string[] { $"[{Path.GetFileNameWithoutExtension(moduleFileName)}*]*ExcludeFilterClass2" },
-                    persistPrepareResultToFile: pathSerialize);
-
-                    return 0;
-                }, path).Dispose();
-
-                TestInstrumentationHelper.GetCoverageResult(path)
-                .Document("Instrumentation.ExcludeFilter.cs")
-                .AssertLinesCovered(BuildConfiguration.Debug, (73, 1))
-                .AssertNonInstrumentedLines(BuildConfiguration.Debug, 75, 93);
-            }
-            finally
-            {
-                File.Delete(path);
-            }
-        }
     }
 }
\ No newline at end of file
diff --git a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
index f6cb5b167..9d47a7aab 100644
--- a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
+++ b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.IO;
 using System.Linq;
 using System.Reflection;
@@ -29,7 +30,7 @@ public enum BuildConfiguration
 
     static class TestInstrumentationAssert
     {
-        public static CoverageResult GenerateReport(this CoverageResult coverageResult, [CallerMemberName]string directory = "")
+        public static CoverageResult GenerateReport(this CoverageResult coverageResult, [CallerMemberName]string directory = "", bool show = false)
         {
             if (coverageResult is null)
             {
@@ -38,6 +39,11 @@ public static CoverageResult GenerateReport(this CoverageResult coverageResult,
 
             TestInstrumentationHelper.GenerateHtmlReport(coverageResult, directory: directory);
 
+            if (show && Debugger.IsAttached)
+            {
+                Process.Start("cmd", "/C " + Path.GetFullPath(Path.Combine(directory, "index.htm")));
+            }
+
             return coverageResult;
         }
 
diff --git a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
index 6c0a5c3b7..3270a77b6 100644
--- a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
@@ -90,4 +90,39 @@ async public Task<int> ConfigureAwait()
             return 42;
         }
     }
+
+    public class Issue_669_1
+    {
+        async public Task Test()
+        {
+            var service = new Moq.Mock<IService>();
+            service.Setup(c => c.GetCat()).Returns(Task.FromResult("cat"));
+
+            var foo = new Foo(service.Object);
+            await foo.Bar();
+        }
+
+
+        public class Foo
+        {
+            private readonly IService _service;
+
+            public Foo(IService service)
+            {
+                _service = service;
+            }
+
+            public async Task Bar()
+            {
+                var cat = await _service.GetCat();
+                await _service.Process(cat);
+            }
+        }
+
+        public interface IService
+        {
+            Task<string> GetCat();
+            Task Process(string cat);
+        }
+    }
 }
diff --git a/test/coverlet.core.tests/coverlet.core.tests.csproj b/test/coverlet.core.tests/coverlet.core.tests.csproj
index 8976dbaeb..f8377f5e4 100644
--- a/test/coverlet.core.tests/coverlet.core.tests.csproj
+++ b/test/coverlet.core.tests/coverlet.core.tests.csproj
@@ -24,6 +24,7 @@
     <ProjectReference Include="$(RepoRoot)test\coverlet.tests.remoteexecutor\coverlet.tests.remoteexecutor.csproj" />
     <ProjectReference Include="$(RepoRoot)test\coverlet.tests.projectsample.empty\coverlet.tests.projectsample.empty.csproj" />
     <ProjectReference Include="$(RepoRoot)test\coverlet.tests.projectsample.excludedbyattribute\coverlet.tests.projectsample.excludedbyattribute.csproj" />
+    <ProjectReference Include="$(RepoRoot)test\coverlet.core.tests.samples.netstandard\coverlet.core.tests.samples.netstandard.csproj" />
   </ItemGroup>
 
   <!--For test TestInstrument_NetstandardAwareAssemblyResolver_PreserveCompilationContext-->