Have MergedLinesEnumerable implement IAsyncEnumerable<string>

MedallionShell.Tests/MedallionShell.Tests.csproj

@@ -6,9 +6,9 @@
     <IsPackable>false</IsPackable>
     <LangVersion>Latest</LangVersion>
     <Nullable>enable</Nullable>
-	  <GenerateDocumentationFile>True</GenerateDocumentationFile>
-	  <CodeAnalysisRuleSet>..\stylecop.analyzers.ruleset</CodeAnalysisRuleSet>
-	  <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <GenerateDocumentationFile>True</GenerateDocumentationFile>
+    <CodeAnalysisRuleSet>..\stylecop.analyzers.ruleset</CodeAnalysisRuleSet>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
     <NoWarn>1591</NoWarn>
     <RootNamespace>Medallion.Shell.Tests</RootNamespace>
   </PropertyGroup>
@@ -17,15 +17,16 @@
     <PackageReference Include="nunit" Version="3.13.3" />
     <PackageReference Include="NUnit3TestAdapter" Version="4.4.0-beta.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.4.1" />
-	  <PackageReference Include="Moq" Version="4.7.63" />
-	  <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">
+    <PackageReference Include="Moq" Version="4.7.63" />
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
+    <PackageReference Include="StyleCop.Analyzers" Version="1.2.0-beta.435">
       <PrivateAssets>All</PrivateAssets>
     </PackageReference>
   </ItemGroup>
 
   <ItemGroup>
     <ProjectReference Include="..\MedallionShell\MedallionShell.csproj" />
-	  <ProjectReference Include="..\SampleCommand\SampleCommand.csproj" />
+    <ProjectReference Include="..\SampleCommand\SampleCommand.csproj" />
   </ItemGroup>
 
   <ItemGroup Condition="'$(TargetFramework)' == 'net462'">

MedallionShell.Tests/Streams/AsyncEnumerableAdapter.cs

@@ -0,0 +1,38 @@
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace Medallion.Shell.Tests.Streams;
+
+public class AsyncEnumerableAdapter : IAsyncEnumerable<string>
+{
+    private readonly IEnumerable<string> strings;
+
+    public AsyncEnumerableAdapter(IEnumerable<string> strings)
+    {
+        this.strings = strings;
+    }
+
+    public IAsyncEnumerator<string> GetAsyncEnumerator(CancellationToken cancellationToken = default) =>
+        new AsyncEnumeratorAdapter(this.strings.GetEnumerator());
+
+    private class AsyncEnumeratorAdapter : IAsyncEnumerator<string>
+    {
+        private readonly IEnumerator<string> enumerator;
+
+        public AsyncEnumeratorAdapter(IEnumerator<string> enumerator)
+        {
+            this.enumerator = enumerator;
+        }
+
+        public string Current => this.enumerator.Current;
+
+        public ValueTask DisposeAsync()
+        {
+            this.enumerator.Dispose();
+            return new(Task.CompletedTask);
+        }
+
+        public ValueTask<bool> MoveNextAsync() => new(this.enumerator.MoveNext());
+    }
+}

MedallionShell.Tests/Streams/MergedLinesEnumerableTestAsync.cs

@@ -0,0 +1,13 @@
+#if NETCOREAPP3_0_OR_GREATER || NETSTANDARD2_1_OR_GREATER
+using System.Collections.Generic;
+using System.IO;
+using Medallion.Shell.Streams;
+
+namespace Medallion.Shell.Tests.Streams;
+
+public class MergedLinesEnumerableTestAsync : MergedLinesEnumerableTestBase
+{
+    protected override IAsyncEnumerable<string> Create(TextReader reader1, TextReader reader2) =>
+        new MergedLinesEnumerable(reader1, reader2);
+}
+#endif

MedallionShell.Tests/Streams/MergedLinesEnumerableTest.cs → MedallionShell.Tests/Streams/MergedLinesEnumerableTestBase.cs

@@ -2,7 +2,6 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
-using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 using Medallion.Shell.Streams;
@@ -11,66 +10,68 @@
 
 namespace Medallion.Shell.Tests.Streams
 {
-    public class MergedLinesEnumerableTest
+    public abstract class MergedLinesEnumerableTestBase
     {
+        protected abstract IAsyncEnumerable<string> Create(TextReader reader1, TextReader reader2);
+
         [Test]
-        public void TestOneIsEmpty()
+        public async Task TestOneIsEmpty()
         {
             var empty1 = new StringReader(string.Empty);
             var nonEmpty1 = new StringReader("abc\r\ndef\r\nghi\r\njkl");
 
-            var enumerable1 = new MergedLinesEnumerable(empty1, nonEmpty1);
-            var list1 = enumerable1.ToList();
+            var enumerable1 = this.Create(empty1, nonEmpty1);
+            var list1 = await enumerable1.ToListAsync();
             list1.SequenceEqual(new[] { "abc", "def", "ghi", "jkl" })
                 .ShouldEqual(true, string.Join(", ", list1));
 
             var empty2 = new StringReader(string.Empty);
             var nonEmpty2 = new StringReader("a\nbb\nccc\n");
-            var enumerable2 = new MergedLinesEnumerable(nonEmpty2, empty2);
-            var list2 = enumerable2.ToList();
+            var enumerable2 = this.Create(nonEmpty2, empty2);
+            var list2 = await enumerable2.ToListAsync();
             list2.SequenceEqual(new[] { "a", "bb", "ccc" })
                 .ShouldEqual(true, string.Join(", ", list2));
         }
 
         [Test]
-        public void TestBothAreEmpty()
+        public async Task TestBothAreEmpty()
         {
-            var list = new MergedLinesEnumerable(new StringReader(string.Empty), new StringReader(string.Empty)).ToList();
+            var list = await this.Create(new StringReader(string.Empty), new StringReader(string.Empty)).ToListAsync();
             list.Count.ShouldEqual(0, string.Join(", ", list));
         }
 
         [Test]
-        public void TestBothArePopulatedEqualSizes()
+        public async Task TestBothArePopulatedEqualSizes()
         {
-            var list = new MergedLinesEnumerable(
+            var list = await this.Create(
                     new StringReader("a\nbb\nccc"),
                     new StringReader("1\r\n22\r\n333")
                 )
-                .ToList();
+                .ToListAsync();
             string.Join(", ", list).ShouldEqual("a, 1, bb, 22, ccc, 333");
         }
 
         [Test]
-        public void TestBothArePopulatedDifferenceSizes()
+        public async Task TestBothArePopulatedDifferenceSizes()
         {
             var lines1 = string.Join("\n", new[] { "x", "y", "z" });
             var lines2 = string.Join("\n", new[] { "1", "2", "3", "4", "5" });
 
-            var list1 = new MergedLinesEnumerable(new StringReader(lines1), new StringReader(lines2))
-                .ToList();
+            var list1 = await this.Create(new StringReader(lines1), new StringReader(lines2))
+                .ToListAsync();
             string.Join(", ", list1).ShouldEqual("x, 1, y, 2, z, 3, 4, 5");
 
-            var list2 = new MergedLinesEnumerable(new StringReader(lines2), new StringReader(lines1))
-                .ToList();
+            var list2 = await this.Create(new StringReader(lines2), new StringReader(lines1))
+                .ToListAsync();
             string.Join(", ", list2).ShouldEqual("1, x, 2, y, 3, z, 4, 5");
         }
 
         [Test]
         public void TestConsumeTwice()
         {
-            var enumerable = new MergedLinesEnumerable(new StringReader("a"), new StringReader("b"));
-            enumerable.GetEnumerator();
-            Assert.Throws<InvalidOperationException>(() => enumerable.GetEnumerator());
+            var asyncEnumerable = this.Create(new StringReader("a"), new StringReader("b"));
+            asyncEnumerable.GetAsyncEnumerator();
+            Assert.Throws<InvalidOperationException>(() => asyncEnumerable.GetAsyncEnumerator());
         }
 
         [Test]
@@ -84,12 +85,11 @@ void TestOneThrows(bool reverse)
                 mockReader.Setup(r => r.ReadLineAsync())
                     .ReturnsAsync(() => ++count < 3 ? "LINE" : throw new TimeZoneNotFoundException());
 
-                Assert.Throws<TimeZoneNotFoundException>(
-                    () => new MergedLinesEnumerable(
+                Assert.ThrowsAsync<TimeZoneNotFoundException>(
+                    async () => await this.Create(
                             reverse ? mockReader.Object : reader1,
                             reverse ? reader1 : mockReader.Object
-                        )
-                        .ToList()
+                        ).ToListAsync()
                 );
             }
 
@@ -98,40 +98,50 @@ void TestOneThrows(bool reverse)
         }
 
         [Test]
-        public void FuzzTest()
+        public async Task FuzzTest()
         {
             var pipe1 = new Pipe();
             var pipe2 = new Pipe();
 
-            var enumerable = new MergedLinesEnumerable(new StreamReader(pipe1.OutputStream), new StreamReader(pipe2.OutputStream));
+            var enumerable = this.Create(new StreamReader(pipe1.OutputStream), new StreamReader(pipe2.OutputStream));
 
             var strings1 = Enumerable.Range(0, 2000).Select(_ => Guid.NewGuid().ToString()).ToArray();
             var strings2 = Enumerable.Range(0, 2300).Select(_ => Guid.NewGuid().ToString()).ToArray();
 
-            void WriteStrings(IReadOnlyList<string> strings, Pipe pipe)
+            static void WriteStrings(IReadOnlyList<string> strings, Pipe pipe)
             {
                 var spinWait = default(SpinWait);
                 var random = new Random(Guid.NewGuid().GetHashCode());
-                using (var writer = new StreamWriter(pipe.InputStream))
+                using var writer = new StreamWriter(pipe.InputStream);
+                foreach (var line in strings)
                 {
-                    foreach (var line in strings)
+                    if (random.Next(5) == 1)
                     {
-                        if (random.Next(4) == 1)
-                        {
-                            spinWait.SpinOnce();
-                        }
-
-                        writer.WriteLine(line);
+                        spinWait.SpinOnce();
                     }
+
+                    writer.WriteLine(line);
                 }
             }
 
             var task1 = Task.Run(() => WriteStrings(strings1, pipe1));
             var task2 = Task.Run(() => WriteStrings(strings2, pipe2));
-            var consumeTask = Task.Run(() => enumerable.ToList());
-            Task.WaitAll(task1, task2, consumeTask);
+            Task.WaitAll(task1, task2);
 
-            CollectionAssert.AreEquivalent(strings1.Concat(strings2).ToList(), consumeTask.Result);
+            var consumeTask = Task.Run(async () => await enumerable.ToListAsync());
+            CollectionAssert.AreEquivalent(strings1.Concat(strings2).ToList(), await consumeTask);
+        }
+    }
+    public static class AsyncEnumerableExtensions
+    {
+        public static async Task<List<string>> ToListAsync(this IAsyncEnumerable<string> strings)
+        {
+            List<string> list = new();
+            await foreach (var item in strings)
+            {
+                list.Add(item);
+            }
+            return list;
         }
     }
 }

MedallionShell.Tests/Streams/MergedLinesEnumerableTestSync.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using System.IO;
+using Medallion.Shell.Streams;
+
+namespace Medallion.Shell.Tests.Streams;
+
+public class MergedLinesEnumerableTestSync : MergedLinesEnumerableTestBase
+{
+    protected override IAsyncEnumerable<string> Create(TextReader reader1, TextReader reader2) =>
+        new AsyncEnumerableAdapter(new MergedLinesEnumerable(reader1, reader2));
+}

MedallionShell/MedallionShell.csproj

@@ -80,4 +80,7 @@
       <LogicalName>MedallionShell.ProcessSignaler.exe</LogicalName>
     </EmbeddedResource>
   </ItemGroup>
+  <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <PackageReference Include="Microsoft.Bcl.AsyncInterfaces" Version="8.0.0" />
+  </ItemGroup>
 </Project>