< Summary

Line coverage
10%
Covered lines: 1
Uncovered lines: 9
Coverable lines: 10
Total lines: 114
Line coverage: 10%
Branch coverage
N/A
Covered branches: 0
Total branches: 0
Branch coverage: N/A
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
ReadAsync(...)100%11100%
ReadAtLeastAsync(...)100%110%
ReadExactlyAsync(...)100%110%
WriteAsync(...)100%110%
CopyToAsync(...)100%110%
DisposeAsync(...)100%110%
FlushAsync(...)100%110%
WaitAsync(...)100%110%
WaitAsync(...)100%110%
WaitAsync(...)100%110%

File(s)

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/System/ReadWriteAdapter.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System.IO;
 5using System.Threading;
 6using System.Threading.Tasks;
 7
 8namespace System
 9{
 10    // Static-abstract adapter that lets a single generic implementation serve both
 11    // synchronous and asynchronous code paths. The sync entry point passes
 12    // SyncReadWriteAdapter and asserts the returned ValueTask is already completed;
 13    // the async entry point passes AsyncReadWriteAdapter.
 14    //
 15    // Originally used by SslStream and SmtpClient for networking I/O deduplication.
 16    // Extended for System.Formats.Tar (CopyToAsync, ReadExactlyAsync, DisposeAsync)
 17    // to unify TarReader/TarWriter/GnuSparseStream sync/async pairs.
 18    internal interface IReadWriteAdapter
 19    {
 20        static abstract ValueTask<int> ReadAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationToken
 21        static abstract ValueTask<int> ReadAtLeastAsync(Stream stream, Memory<byte> buffer, int minimumBytes, bool throw
 22        static abstract ValueTask ReadExactlyAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationTok
 23        static abstract ValueTask WriteAsync(Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationT
 24        static abstract ValueTask CopyToAsync(Stream source, Stream destination, CancellationToken cancellationToken);
 25        static abstract ValueTask DisposeAsync(Stream stream);
 26        static abstract Task FlushAsync(Stream stream, CancellationToken cancellationToken);
 27        static abstract Task WaitAsync(TaskCompletionSource<bool> waiter);
 28        static abstract Task WaitAsync(Task task);
 29        static abstract ValueTask<T> WaitAsync<T>(ValueTask<T> task);
 30    }
 31
 32    internal readonly struct AsyncReadWriteAdapter : IReadWriteAdapter
 33    {
 34        public static ValueTask<int> ReadAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationToken) 
 7635            stream.ReadAsync(buffer, cancellationToken);
 36
 37        public static ValueTask<int> ReadAtLeastAsync(Stream stream, Memory<byte> buffer, int minimumBytes, bool throwOn
 038            stream.ReadAtLeastAsync(buffer, minimumBytes, throwOnEndOfStream, cancellationToken);
 39
 40        public static ValueTask ReadExactlyAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationToken
 041            stream.ReadExactlyAsync(buffer, cancellationToken);
 42
 43        public static ValueTask WriteAsync(Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationTok
 044            stream.WriteAsync(buffer, cancellationToken);
 45
 46        public static ValueTask CopyToAsync(Stream source, Stream destination, CancellationToken cancellationToken) =>
 047            new ValueTask(source.CopyToAsync(destination, cancellationToken));
 48
 049        public static ValueTask DisposeAsync(Stream stream) => stream.DisposeAsync();
 50
 051        public static Task FlushAsync(Stream stream, CancellationToken cancellationToken) => stream.FlushAsync(cancellat
 52
 053        public static Task WaitAsync(TaskCompletionSource<bool> waiter) => waiter.Task;
 054        public static Task WaitAsync(Task task) => task;
 055        public static ValueTask<T> WaitAsync<T>(ValueTask<T> task) => task;
 56    }
 57
 58    internal readonly struct SyncReadWriteAdapter : IReadWriteAdapter
 59    {
 60        public static ValueTask<int> ReadAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationToken) 
 61            new ValueTask<int>(stream.Read(buffer.Span));
 62
 63        public static ValueTask<int> ReadAtLeastAsync(Stream stream, Memory<byte> buffer, int minimumBytes, bool throwOn
 64            new ValueTask<int>(stream.ReadAtLeast(buffer.Span, minimumBytes, throwOnEndOfStream));
 65
 66        public static ValueTask ReadExactlyAsync(Stream stream, Memory<byte> buffer, CancellationToken cancellationToken
 67        {
 68            stream.ReadExactly(buffer.Span);
 69            return default;
 70        }
 71
 72        public static ValueTask WriteAsync(Stream stream, ReadOnlyMemory<byte> buffer, CancellationToken cancellationTok
 73        {
 74            stream.Write(buffer.Span);
 75            return default;
 76        }
 77
 78        public static ValueTask CopyToAsync(Stream source, Stream destination, CancellationToken cancellationToken)
 79        {
 80            source.CopyTo(destination);
 81            return default;
 82        }
 83
 84        public static ValueTask DisposeAsync(Stream stream)
 85        {
 86            stream.Dispose();
 87            return default;
 88        }
 89
 90        public static Task FlushAsync(Stream stream, CancellationToken cancellationToken)
 91        {
 92            stream.Flush();
 93            return Task.CompletedTask;
 94        }
 95
 96        public static Task WaitAsync(TaskCompletionSource<bool> waiter)
 97        {
 98            waiter.Task.GetAwaiter().GetResult();
 99            return Task.CompletedTask;
 100        }
 101
 102        public static Task WaitAsync(Task task)
 103        {
 104            task.GetAwaiter().GetResult();
 105            return Task.CompletedTask;
 106        }
 107
 108        public static ValueTask<T> WaitAsync<T>(ValueTask<T> task)
 109        {
 110            return ValueTask.FromResult(task.AsTask().GetAwaiter().GetResult());
 111        }
 112    }
 113}
 114