From 2347c5a6291c827d1b8be12c4ce9d88f33ee6e87 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 14:39:11 +0100
Subject: [PATCH 01/14] new async prolog alg, reorganize tests.

---
 Directory.Build.targets                       |   2 +-
 .../Symbols/CecilSymbolHelper.cs              |  27 +-
 .../Coverage/CoverageTests.AsyncAwait.cs      | 103 ++++
 ...erageTests.ExcludeFromCoverageAttribute.cs | 165 +++++++
 .../Coverage/CoverageTests.Filters.cs         | 131 +++++
 .../Coverage/CoverageTests.Lambda.cs          |  56 +++
 .../CoverageTests.SelectionStatements.cs      |  88 ++++
 .../Coverage/CoverageTests.cs                 | 453 +-----------------
 .../Coverage/InstrumenterHelper.cs            |   8 +-
 .../Samples/Instrumentation.AsyncAwait.cs     |  35 ++
 10 files changed, 612 insertions(+), 456 deletions(-)
 create mode 100644 test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
 create mode 100644 test/coverlet.core.tests/Coverage/CoverageTests.ExcludeFromCoverageAttribute.cs
 create mode 100644 test/coverlet.core.tests/Coverage/CoverageTests.Filters.cs
 create mode 100644 test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
 create mode 100644 test/coverlet.core.tests/Coverage/CoverageTests.SelectionStatements.cs

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/src/coverlet.core/Symbols/CecilSymbolHelper.cs b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
index c528c607e..c49538306 100644
--- a/src/coverlet.core/Symbols/CecilSymbolHelper.cs
+++ b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
@@ -69,9 +69,8 @@ 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 skipFirstBranch = IsMoveNextInsideEnumerator(methodDefinition);
 
             foreach (Instruction instruction in instructions.Where(instruction => instruction.OpCode.FlowControl == FlowControl.Cond_Branch))
             {
@@ -83,6 +82,30 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                         continue;
                     }
 
+                    // If method is a generated MoveNext 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;]
+                    if (isAsyncStateMachineMoveNext)
+                    {
+                        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 &&
                             operand.Name == "get_IsCompleted" &&
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..93a46fd27
--- /dev/null
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -0,0 +1,103 @@
+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()
+        {
+            string path = Path.GetTempFileName();
+            try
+            {
+                RemoteExecutor.Invoke(async pathSerialize =>
+                {
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669>(instance =>
+                    {
+                        ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
+                        return Task.CompletedTask;
+                    },
+                    persistPrepareResultToFile: pathSerialize, disableRestoreModules: true);
+
+                    return 0;
+                }, path, invokeInProcess: true).Dispose();
+
+                TestInstrumentationHelper.GetCoverageResult(path)
+                .GenerateReport(show: true)
+                .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);
+            }
+        }
+    }
+}
\ 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..a7557b7f1
--- /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.GenerateReport(show: true).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..bc8e69c1b 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
+    {
+        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);
+        }
+    }
 }

From 69431e9a14306766c20910b28b0a69dbfcda8e53 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 16:05:04 +0100
Subject: [PATCH 02/14] fix netstandard async/await coverage bug

---
 coverlet.sln                                  |  7 ++++
 .../Symbols/CecilSymbolHelper.cs              |  6 +++-
 .../CoverageTests.AsyncAwait.cs               | 19 ++++++++++
 ...rlet.core.tests.samples.netstandard.csproj |  5 +++
 .../Coverage/CoverageTests.AsyncAwait.cs      | 35 ++++++++++++++++++-
 .../coverlet.core.tests.csproj                |  1 +
 6 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs
 create mode 100644 test/coverlet.core.tests.samples.netstandard/coverlet.core.tests.samples.netstandard.csproj

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/src/coverlet.core/Symbols/CecilSymbolHelper.cs b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
index c49538306..5a691f4c7 100644
--- a/src/coverlet.core/Symbols/CecilSymbolHelper.cs
+++ b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
@@ -114,7 +114,11 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                                 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/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs
new file mode 100644
index 000000000..b981e2c1c
--- /dev/null
+++ b/test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs
@@ -0,0 +1,19 @@
+// Remember to use full name because adding new using directives change line numbers
+
+using System.Threading.Tasks;
+
+namespace Coverlet.Core.Tests
+{
+    public class Issue_669_2
+    {
+        private readonly System.Net.Http.HttpClient _httpClient = new System.Net.Http.HttpClient();
+
+        async public ValueTask<System.Net.Http.HttpResponseMessage> SendRequest()
+        {
+            using (var requestMessage = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, "http://www.google.com"))
+            {
+                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..4641dbd64
--- /dev/null
+++ b/test/coverlet.core.tests.samples.netstandard/coverlet.core.tests.samples.netstandard.csproj
@@ -0,0 +1,5 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <TargetFramework>netstandard2.0</TargetFramework>
+  </PropertyGroup>
+</Project>
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
index 93a46fd27..7894a07d6 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -86,7 +86,6 @@ public void AsyncAwait_Issue_669()
                 }, path, invokeInProcess: true).Dispose();
 
                 TestInstrumentationHelper.GetCoverageResult(path)
-                .GenerateReport(show: true)
                 .Document("Instrumentation.AsyncAwait.cs")
                 .AssertLinesCovered(BuildConfiguration.Debug,
                     (97, 1), (98, 1), (99, 1), (101, 1), (102, 1), (103, 1),
@@ -99,5 +98,39 @@ public void AsyncAwait_Issue_669()
                 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)
+                .GenerateReport(show: true)
+                //.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);
+            }
+        }
     }
 }
\ No newline at end of file
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-->

From bd5923ac5b8a9bf2458c198c210cfbb8b0dfcfa3 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 17:02:22 +0100
Subject: [PATCH 03/14] fix netstandard async/await issue, add async/await
 prolog recognition

---
 .../Symbols/CecilSymbolHelper.cs              | 30 +++++++++++++++----
 ...Await.cs => Instrumentation.AsyncAwait.cs} |  6 ++--
 ...rlet.core.tests.samples.netstandard.csproj |  8 ++++-
 .../Coverage/CoverageTests.AsyncAwait.cs      | 11 ++-----
 4 files changed, 37 insertions(+), 18 deletions(-)
 rename test/coverlet.core.tests.samples.netstandard/{CoverageTests.AsyncAwait.cs => Instrumentation.AsyncAwait.cs} (71%)

diff --git a/src/coverlet.core/Symbols/CecilSymbolHelper.cs b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
index 5a691f4c7..fb2930be3 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>();
@@ -70,6 +89,7 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
             var instructions = methodDefinition.Body.Instructions;
 
             bool isAsyncStateMachineMoveNext = IsMoveNextInsideAsyncStateMachine(methodDefinition);
+            bool isRecognizedMoveNextInsideAsyncStateMachineProlog = isAsyncStateMachineMoveNext && IsRecognizedMoveNextInsideAsyncStateMachineProlog(methodDefinition);
             bool skipFirstBranch = IsMoveNextInsideEnumerator(methodDefinition);
 
             foreach (Instruction instruction in instructions.Where(instruction => instruction.OpCode.FlowControl == FlowControl.Cond_Branch))
@@ -85,15 +105,15 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                     // If method is a generated MoveNext 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;]
-                    if (isAsyncStateMachineMoveNext)
+                    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
+                                    (current.OpCode == OpCodes.Ldloc && current.Operand is VariableDefinition vo && vo.Index == 0) ||
+                                    current.OpCode == OpCodes.Ldloc_0
                                 )
                             {
                                 skipInstruction = true;
@@ -115,8 +135,8 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                             )
                             &&
                             (
-                            operand.DeclaringType.Scope.Name == "System.Runtime" ||
-                            operand.DeclaringType.Scope.Name == "netstandard"
+                                operand.DeclaringType.Scope.Name == "System.Runtime" ||
+                                operand.DeclaringType.Scope.Name == "netstandard"
                             )
                        )
                     {
diff --git a/test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
similarity index 71%
rename from test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs
rename to test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
index b981e2c1c..c183d1448 100644
--- a/test/coverlet.core.tests.samples.netstandard/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
@@ -1,16 +1,14 @@
 // Remember to use full name because adding new using directives change line numbers
 
-using System.Threading.Tasks;
-
 namespace Coverlet.Core.Tests
 {
     public class Issue_669_2
     {
         private readonly System.Net.Http.HttpClient _httpClient = new System.Net.Http.HttpClient();
 
-        async public ValueTask<System.Net.Http.HttpResponseMessage> SendRequest()
+        async public System.Threading.Tasks.ValueTask<System.Net.Http.HttpResponseMessage> SendRequest()
         {
-            using (var requestMessage = new System.Net.Http.HttpRequestMessage(System.Net.Http.HttpMethod.Get, "http://www.google.com"))
+            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
index 4641dbd64..a409df66a 100644
--- 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
@@ -1,5 +1,11 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<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
index 7894a07d6..0fb5f50de 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -118,14 +118,9 @@ public void AsyncAwait_Issue_669_2()
                 }, path, invokeInProcess: true).Dispose();
 
                 TestInstrumentationHelper.GetCoverageResult(path)
-                .GenerateReport(show: true)
-                //.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)
-                //)
-                ;
+                .Document("Instrumentation.AsyncAwait.cs")
+                .AssertLinesCovered(BuildConfiguration.Debug, (7, 1), (10, 1), (11, 1), (12, 1), (13, 1), (15, 1))
+                .ExpectedTotalNumberOfBranches(BuildConfiguration.Debug, 0);
             }
             finally
             {

From f0f0ce07e9a5e994e151c90e5b72b5885afcf243 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 17:24:53 +0100
Subject: [PATCH 04/14] improve comment on async/await alg

---
 .../Symbols/CecilSymbolHelper.cs              | 58 ++++++++++++++++---
 ...rlet.core.tests.samples.netstandard.csproj |  1 +
 2 files changed, 52 insertions(+), 7 deletions(-)

diff --git a/src/coverlet.core/Symbols/CecilSymbolHelper.cs b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
index fb2930be3..876a3586c 100644
--- a/src/coverlet.core/Symbols/CecilSymbolHelper.cs
+++ b/src/coverlet.core/Symbols/CecilSymbolHelper.cs
@@ -63,10 +63,10 @@ private static bool IsMoveNextInsideEnumerator(MethodDefinition methodDefinition
         private static bool IsRecognizedMoveNextInsideAsyncStateMachineProlog(MethodDefinition methodDefinition)
         {
             /*
-                // int num = <>1__state;
-	            IL_0000: ldarg.0
+                int num = <>1__state;
+                IL_0000: ldarg.0
                 IL_0001: ldfld ...::'<>1__state'
-	            IL_0006: stloc.0
+                IL_0006: stloc.0
             */
             return (methodDefinition.Body.Instructions[0].OpCode == OpCodes.Ldarg_0 ||
                     methodDefinition.Body.Instructions[0].OpCode == OpCodes.Ldarg) &&
@@ -102,9 +102,52 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                         continue;
                     }
 
-                    // If method is a generated MoveNext 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;]
+                    /* 
+                       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;
@@ -127,7 +170,8 @@ public static List<BranchPoint> GetBranchPoints(MethodDefinition methodDefinitio
                     }
 
                     // 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") ||
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
index a409df66a..783e0d0c3 100644
--- 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
@@ -8,4 +8,5 @@
   <ItemGroup>
     <PackageReference Include="System.Threading.Tasks.Extensions" Version="4.5.3" />
   </ItemGroup>
+
 </Project>

From b2986dbd46fd12887b0234edeb0cdad340ce2313 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 17:44:05 +0100
Subject: [PATCH 05/14] rename test name to avoid collision on test filtering

---
 .../Coverage/CoverageTests.AsyncAwait.cs                 | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
index 0fb5f50de..b7dcbdacc 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -68,7 +68,7 @@ public void AsyncAwait()
         }
 
         [Fact]
-        public void AsyncAwait_Issue_669()
+        public void AsyncAwait_Issue_669_1()
         {
             string path = Path.GetTempFileName();
             try
@@ -88,10 +88,9 @@ public void AsyncAwait_Issue_669()
                 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)
-                );
+                (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
             {

From 89317a5c0f7d3a98644d604d8bc49a1435bd8c90 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 17:50:58 +0100
Subject: [PATCH 06/14] meh

---
 test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs  | 2 +-
 test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
index b7dcbdacc..b61fad206 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -75,7 +75,7 @@ public void AsyncAwait_Issue_669_1()
             {
                 RemoteExecutor.Invoke(async pathSerialize =>
                 {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669>(instance =>
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_1>(instance =>
                     {
                         ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
                         return Task.CompletedTask;
diff --git a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
index bc8e69c1b..3270a77b6 100644
--- a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
@@ -91,7 +91,7 @@ async public Task<int> ConfigureAwait()
         }
     }
 
-    public class Issue_669
+    public class Issue_669_1
     {
         async public Task Test()
         {

From c4ee8daba4b3c17bf99104a9f10a07a2bebc9495 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 18:08:27 +0100
Subject: [PATCH 07/14] try fix CI

---
 .../Instrumentation.AsyncAwait.cs                             | 2 +-
 test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs | 4 ++--
 .../coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
index c183d1448..daf914b13 100644
--- a/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
@@ -2,7 +2,7 @@
 
 namespace Coverlet.Core.Tests
 {
-    public class Issue_669_2
+    public class Issue_669_UC2
     {
         private readonly System.Net.Http.HttpClient _httpClient = new System.Net.Http.HttpClient();
 
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
index b61fad206..399072789 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -75,7 +75,7 @@ public void AsyncAwait_Issue_669_1()
             {
                 RemoteExecutor.Invoke(async pathSerialize =>
                 {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_1>(instance =>
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_UC1>(instance =>
                     {
                         ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
                         return Task.CompletedTask;
@@ -106,7 +106,7 @@ public void AsyncAwait_Issue_669_2()
             {
                 RemoteExecutor.Invoke(async pathSerialize =>
                 {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_2>(instance =>
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_UC2>(instance =>
                     {
                         ((ValueTask<System.Net.Http.HttpResponseMessage>)instance.SendRequest()).ConfigureAwait(false).GetAwaiter().GetResult();
                         return Task.CompletedTask;
diff --git a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
index 3270a77b6..47c32ba59 100644
--- a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
@@ -91,7 +91,7 @@ async public Task<int> ConfigureAwait()
         }
     }
 
-    public class Issue_669_1
+    public class Issue_669_UC1
     {
         async public Task Test()
         {

From 979d1d3c00468f68857d07a93ef7a5e912a0d29c Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 21:51:52 +0100
Subject: [PATCH 08/14] add some log

---
 .../Coverage/InstrumenterHelper.cs                    | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
index 9d47a7aab..88b5f7677 100644
--- a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
+++ b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
@@ -395,7 +395,16 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
             }).ToArray(), Array.Empty<string>(), Array.Empty<string>(), true, false, "", false, new Logger(logFile), DependencyInjection.Current.GetService<IInstrumentationHelper>(), DependencyInjection.Current.GetService<IFileSystem>());
             CoveragePrepareResult prepareResult = coverage.PrepareModules();
 
-            Assert.Single(prepareResult.Results);
+            StringBuilder log = new StringBuilder();
+
+            log.AppendLine($"[{Path.GetFileNameWithoutExtension(fileName)}*]{typeof(T).FullName}*");
+
+            foreach (var item in prepareResult.Results)
+            {
+                log.AppendLine(item.Module);
+            }
+
+            Assert.True(prepareResult.Results.Length == 1, log.ToString());
 
             // Load new assembly
             Assembly asm = Assembly.LoadFile(newPath);

From 6bdc49d207812a1b7ecb30ba6c46664c3c4d6e1f Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 21:59:53 +0100
Subject: [PATCH 09/14] add more log

---
 test/coverlet.core.tests/Coverage/InstrumenterHelper.cs | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
index 88b5f7677..049fa1de1 100644
--- a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
+++ b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
@@ -412,6 +412,15 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
             // Instance type and call method
             await callMethod(Activator.CreateInstance(asm.GetType(typeof(T).FullName)));
 
+            List<string> trackers = new List<string>();
+            foreach (var item in asm.GetTypes().Where(n => n.FullName.Contains("Coverlet.Core.Instrumentation.Tracker")))
+            {
+                trackers.Add(item.FullName);
+                log.AppendLine(item.FullName);
+            }
+
+            Assert.True(trackers.Count == 1, log.ToString());
+
             // Flush tracker
             Type tracker = asm.GetTypes().Single(n => n.FullName.Contains("Coverlet.Core.Instrumentation.Tracker"));
 

From cd7c9027cd8d60ad611c2fc98eafde2b6ba77da9 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 22:21:40 +0100
Subject: [PATCH 10/14] update CI

---
 eng/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/build.yml b/eng/build.yml
index e12b5069a..b79acc30d 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]*,[coverlet.core]*,[coverlet.msbuild.tasks]*\" /p:Exclude=\"[coverlet.core.tests.samples.netstandard]*,[coverlet.tests.remoteexecutor]*\"
     testRunTitle: $(Agent.JobName)
\ No newline at end of file

From a05c79cba50ce75d4d815ceac8583bf436e1bc0f Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 22:24:39 +0100
Subject: [PATCH 11/14] Update CI

---
 eng/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/build.yml b/eng/build.yml
index b79acc30d..1fcb0b08c 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.collector]*,[coverlet.core]*,[coverlet.msbuild.tasks]*\" /p:Exclude=\"[coverlet.core.tests.samples.netstandard]*,[coverlet.tests.remoteexecutor]*\"
+    arguments: -c $(BuildConfiguration) --no-build /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:Include="[coverlet.collector]*2%c[coverlet.core]*2%c[coverlet.msbuild.tasks]*" /p:Exclude="[coverlet.core.tests.samples.netstandard]*2%c[coverlet.tests.remoteexecutor]*"
     testRunTitle: $(Agent.JobName)
\ No newline at end of file

From 10270a9d5d06baf63d926420424c61e67bd5acea Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 22:29:26 +0100
Subject: [PATCH 12/14] fix CI

---
 eng/build.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/eng/build.yml b/eng/build.yml
index 1fcb0b08c..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.collector]*2%c[coverlet.core]*2%c[coverlet.msbuild.tasks]*" /p:Exclude="[coverlet.core.tests.samples.netstandard]*2%c[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

From 8fa1db3cabe6da5047d53c0703a3095ff31de91b Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 22:35:00 +0100
Subject: [PATCH 13/14] revert changes, fix tests

---
 .../Instrumentation.AsyncAwait.cs             |  2 +-
 .../Coverage/CoverageTests.AsyncAwait.cs      |  4 ++--
 .../Coverage/InstrumenterHelper.cs            | 20 +------------------
 .../Samples/Instrumentation.AsyncAwait.cs     |  2 +-
 4 files changed, 5 insertions(+), 23 deletions(-)

diff --git a/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
index daf914b13..c183d1448 100644
--- a/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests.samples.netstandard/Instrumentation.AsyncAwait.cs
@@ -2,7 +2,7 @@
 
 namespace Coverlet.Core.Tests
 {
-    public class Issue_669_UC2
+    public class Issue_669_2
     {
         private readonly System.Net.Http.HttpClient _httpClient = new System.Net.Http.HttpClient();
 
diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
index 399072789..b61fad206 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.AsyncAwait.cs
@@ -75,7 +75,7 @@ public void AsyncAwait_Issue_669_1()
             {
                 RemoteExecutor.Invoke(async pathSerialize =>
                 {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_UC1>(instance =>
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_1>(instance =>
                     {
                         ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
                         return Task.CompletedTask;
@@ -106,7 +106,7 @@ public void AsyncAwait_Issue_669_2()
             {
                 RemoteExecutor.Invoke(async pathSerialize =>
                 {
-                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_UC2>(instance =>
+                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run<Issue_669_2>(instance =>
                     {
                         ((ValueTask<System.Net.Http.HttpResponseMessage>)instance.SendRequest()).ConfigureAwait(false).GetAwaiter().GetResult();
                         return Task.CompletedTask;
diff --git a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
index 049fa1de1..9d47a7aab 100644
--- a/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
+++ b/test/coverlet.core.tests/Coverage/InstrumenterHelper.cs
@@ -395,16 +395,7 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
             }).ToArray(), Array.Empty<string>(), Array.Empty<string>(), true, false, "", false, new Logger(logFile), DependencyInjection.Current.GetService<IInstrumentationHelper>(), DependencyInjection.Current.GetService<IFileSystem>());
             CoveragePrepareResult prepareResult = coverage.PrepareModules();
 
-            StringBuilder log = new StringBuilder();
-
-            log.AppendLine($"[{Path.GetFileNameWithoutExtension(fileName)}*]{typeof(T).FullName}*");
-
-            foreach (var item in prepareResult.Results)
-            {
-                log.AppendLine(item.Module);
-            }
-
-            Assert.True(prepareResult.Results.Length == 1, log.ToString());
+            Assert.Single(prepareResult.Results);
 
             // Load new assembly
             Assembly asm = Assembly.LoadFile(newPath);
@@ -412,15 +403,6 @@ async public static Task<CoveragePrepareResult> Run<T>(Func<dynamic, Task> callM
             // Instance type and call method
             await callMethod(Activator.CreateInstance(asm.GetType(typeof(T).FullName)));
 
-            List<string> trackers = new List<string>();
-            foreach (var item in asm.GetTypes().Where(n => n.FullName.Contains("Coverlet.Core.Instrumentation.Tracker")))
-            {
-                trackers.Add(item.FullName);
-                log.AppendLine(item.FullName);
-            }
-
-            Assert.True(trackers.Count == 1, log.ToString());
-
             // Flush tracker
             Type tracker = asm.GetTypes().Single(n => n.FullName.Contains("Coverlet.Core.Instrumentation.Tracker"));
 
diff --git a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
index 47c32ba59..3270a77b6 100644
--- a/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
+++ b/test/coverlet.core.tests/Samples/Instrumentation.AsyncAwait.cs
@@ -91,7 +91,7 @@ async public Task<int> ConfigureAwait()
         }
     }
 
-    public class Issue_669_UC1
+    public class Issue_669_1
     {
         async public Task Test()
         {

From 99a3177c2db2ad78c230c053bc0a928e17b8a9f7 Mon Sep 17 00:00:00 2001
From: Marco Rossignoli <marco.rossignoli@gmail.com>
Date: Tue, 21 Jan 2020 22:41:01 +0100
Subject: [PATCH 14/14] remove report generation during test

---
 test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs b/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
index a7557b7f1..28f4d71a8 100644
--- a/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
+++ b/test/coverlet.core.tests/Coverage/CoverageTests.Lambda.cs
@@ -28,7 +28,7 @@ public void Lambda_Issue343()
 
                 CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);
 
-                result.GenerateReport(show: true).Document("Instrumentation.Lambda.cs")
+                result.Document("Instrumentation.Lambda.cs")
                       .AssertLinesCoveredAllBut(BuildConfiguration.Debug, 23, 51)
                       .AssertBranchesCovered(BuildConfiguration.Debug,
                         // Expected branches