Beispiel #1
0
        public void AsyncAwait_Issue_1177()
        {
            string path = Path.GetTempFileName();

            try
            {
                FunctionExecutor.Run(async(string[] pathSerialize) =>
                {
                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run <Issue_1177>(instance =>
                    {
                        ((Task)instance.Test()).ConfigureAwait(false).GetAwaiter().GetResult();
                        return(Task.CompletedTask);
                    },
                                                                                                                   persistPrepareResultToFile: pathSerialize[0]);

                    return(0);
                }, new string[] { path });

                Core.Instrumentation.Document document = TestInstrumentationHelper.GetCoverageResult(path).Document("Instrumentation.AsyncAwait.cs");
                document.AssertLinesCovered(BuildConfiguration.Debug, (133, 1), (134, 1), (135, 1), (136, 1), (137, 1));
                Assert.DoesNotContain(document.Branches, x => x.Key.Line == 134);
            }
            finally
            {
                File.Delete(path);
            }
        }
Beispiel #2
0
        public void AsyncAwait_Issue_1275()
        {
            string path = Path.GetTempFileName();

            try
            {
                FunctionExecutor.Run(async(string[] pathSerialize) =>
                {
                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run <Issue_1275>(instance =>
                    {
                        var cts = new CancellationTokenSource();
                        ((Task)instance.Execute(cts.Token)).ConfigureAwait(false).GetAwaiter().GetResult();
                        return(Task.CompletedTask);
                    },
                                                                                                                   persistPrepareResultToFile: pathSerialize[0]);

                    return(0);
                }, new string[] { path });

                Core.Instrumentation.Document document = TestInstrumentationHelper.GetCoverageResult(path).Document("Instrumentation.AsyncAwait.cs");
                document.AssertLinesCoveredFromTo(BuildConfiguration.Debug, 170, 176);
                document.AssertBranchesCovered(BuildConfiguration.Debug, (171, 0, 1), (171, 1, 1));
                Assert.DoesNotContain(document.Branches, x => x.Key.Line == 176);
            }
            finally
            {
                File.Delete(path);
            }
        }
        public void ExcludeFromCodeCoverage_CompilerGeneratedMethodsAndTypes()
        {
            string path = Path.GetTempFileName();

            try
            {
                FunctionExecutor.Run(async(string[] pathSerialize) =>
                {
                    CoveragePrepareResult coveragePrepareResult = await TestInstrumentationHelper.Run <MethodsWithExcludeFromCodeCoverageAttr>(instance =>
                    {
                        ((Task <int>)instance.Test("test")).ConfigureAwait(false).GetAwaiter().GetResult();
                        return(Task.CompletedTask);
                    }, persistPrepareResultToFile: pathSerialize[0]);

                    return(0);
                }, new string[] { path });

                CoverageResult result = TestInstrumentationHelper.GetCoverageResult(path);

                Core.Instrumentation.Document 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);
            }
        }