Incorrect branch coverage with await using

[itsurkan]

If use 'using' statement only branch coverate is 100%

If use 'await using' branch coverage is 50%

But they should be the same

[MarcoRossignoli]

Which version are you using?

[alexthornton1]

Out of curiosity, I checked whether my attempted fix of #907 would also address this. It appears the answer to that is "no". I started with this example:

public class AwaitUsing
{
    async public ValueTask AsyncAwait()
    {
        await using (var ms = new MemoryStream(System.Text.Encoding.ASCII.GetBytes("abc")))
        {
        }
    }
}

I tried this test (similar to what I added in #907, according to patterns of what was already there):

[Fact]
public void GetBranchPoints_IgnoresBranchesIn_AwaitUsing()
{
    // arrange
    var nestedName = typeof(AwaitUsing).GetNestedTypes(BindingFlags.NonPublic).First().Name;
    var type = _module.Types.FirstOrDefault(x => x.FullName == typeof(AwaitUsing).FullName);
    var nestedType = type.NestedTypes.FirstOrDefault(x => x.FullName.EndsWith(nestedName));
    var method = nestedType.Methods.First(x => x.FullName.EndsWith("::MoveNext()"));

    // act
    var points = _cecilSymbolHelper.GetBranchPoints(method);

    // assert
    Assert.Empty(points);
}

Without my #907 fix, there were eight branch points found. With my #907 fix, there were six branch points found.

So, at the very least, we know these are separate issues. Whether I'll be able to figure out what the issue is, well, that's a different story, but I'm just finding my way around this code base for the first time.

[alexthornton1]

I took a crack at this one today, too. The #914 fix depends on the #907 fix, but I'll create a separate pull request for the #914 fix. (I've combined the two fixes into one pull request, since they're on the same branch.)

[alexthornton1]

Working in Debug mode, but not Release mode. Live and learn! I'll investigate.

[alexthornton1]

Fixed (I hope!) in 61e0d9f.

[Pankraty]

We have the same issue and I've prepared a simple repro. Hope it will be useful

    public class TestClass
    {
        public async Task Example1()
        {
            await using var trans = new MyTransaction();
        }
        
        public async Task Example2()
        {
            var trans = new MyTransaction();
            await trans.DisposeAsync();
        }
    }
    
    public class MyTransaction : IAsyncDisposable
    {
        public async ValueTask DisposeAsync()
        {
        }
    }

    public class UnitTest1
    {
        [Fact]
        public async Task Test1()
        {
            var c = new TestClass();
            await c.Example1().ConfigureAwait(false);
        }

        [Fact]
        public async Task Test2()
        {
            var c = new TestClass();
            await c.Example2().ConfigureAwait(false);
        }
    }

Expected behavior: treat TestClass as having 100% test coverage both by lines and by conditions.

Current behavior:
This line has 5 out of 10 branches covered:

            await using var trans = new MyTransaction();

This line has 1 of 2 branches covered:

            await trans.DisposeAsync();

---

The command line I use is

dotnet test --configuration Release /p:CollectCoverage=true /p:CoverletOutputFormat=opencover /p:CoverletOutput=./TestResults/

Target framework is netcoreapp3.1
Coverlet.MsBuild version is 2.9.0

The coverage report is attached.
coverage.opencover.xml.log

[MarcoRossignoli]

Thanks for the repro

[PovilasAtPoq]

Any forecast when could this be fixed?

I've just literally stumbled upon same issue, that using await using creates multiple branches, and google brought me here :)