Merge branch '9-add-cancellationtoken-support' into 'master'

Resolve "Add CancellationToken support."

Closes kaitai-io#9

See merge request marta/kaitai_struct_csharp_runtime!19

Author: fukaminakrize

Kaitai.Struct.Runtime.Async.Tests/CancelableTestsBase.cs

@@ -0,0 +1,54 @@
+using System;
+using System.Threading;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace Kaitai.Struct.Runtime.Async.Tests
+{
+  public abstract class CancelableTestsBase
+  {
+    protected readonly CancellationToken CancellationToken;
+
+    protected CancelableTestsBase(bool isTestingCancellation)
+    {
+      CancellationToken = new CancellationToken(isTestingCancellation);
+    }
+
+    protected async Task Evaluate(Func<Task> assertFunc)
+    {
+      if (CancellationToken.IsCancellationRequested)
+      {
+        await Assert.ThrowsAsync<TaskCanceledException>(assertFunc);
+      }
+      else
+      {
+        await assertFunc();
+      }
+    }
+
+    protected async Task EvaluateMaybeCancelled(Func<Task> assertFunc)
+    {
+      try
+      {
+        await assertFunc();
+      }
+      catch (TaskCanceledException)
+      {
+      }
+    }
+
+    protected async Task Evaluate<TExpectedException>(Func<Task> assertFunc) where TExpectedException : Exception
+    {
+      try
+      {
+        await assertFunc();
+      }
+      catch (TaskCanceledException)
+      {
+      }
+      catch (TExpectedException)
+      {
+      }
+    }
+  }
+}

Kaitai.Struct.Runtime.Async.Tests/KaitaiAsyncStreamBaseTests.cs

@@ -1,4 +1,5 @@
-using System.IO;
+using System;
+using System.IO;
 using System.IO.Pipelines;
 using System.Threading.Tasks;
 using Kaitai.Async;
@@ -8,17 +9,48 @@ namespace Kaitai.Struct.Runtime.Async.Tests
 {
   public class StreamKaitaiAsyncStreamBaseTests : KaitaiAsyncStreamBaseTests
   {
+    public StreamKaitaiAsyncStreamBaseTests() : base(false)
+    {
+    }
+
     protected override KaitaiAsyncStream Create(byte[] data) => new KaitaiAsyncStream(data);
   }
 
   public class PipeReaderKaitaiAsyncStreamBaseTests : KaitaiAsyncStreamBaseTests
   {
+    public PipeReaderKaitaiAsyncStreamBaseTests() : base(false)
+    {
+    }
+
     protected override KaitaiAsyncStream Create(byte[] data) =>
       new KaitaiAsyncStream(PipeReader.Create(new MemoryStream(data)));
   }
 
-  public abstract class KaitaiAsyncStreamBaseTests
+  public class StreamKaitaiAsyncStreamBaseCancelledTests : KaitaiAsyncStreamBaseTests
+  {
+    public StreamKaitaiAsyncStreamBaseCancelledTests() : base(true)
+    {
+    }
+
+    protected override KaitaiAsyncStream Create(byte[] data) => new KaitaiAsyncStream(data);
+  }
+
+  public class PipeReaderKaitaiAsyncStreamBaseCancelledTests : KaitaiAsyncStreamBaseTests
   {
+    public PipeReaderKaitaiAsyncStreamBaseCancelledTests() : base(true)
+    {
+    }
+
+    protected override KaitaiAsyncStream Create(byte[] data) =>
+      new KaitaiAsyncStream(PipeReader.Create(new MemoryStream(data)));
+  }
+
+  public abstract class KaitaiAsyncStreamBaseTests : CancelableTestsBase
+  {
+    protected KaitaiAsyncStreamBaseTests(bool isTestingCancellation) : base(isTestingCancellation)
+    {
+    }
+
     protected abstract KaitaiAsyncStream Create(byte[] data);
 
     [Theory]
@@ -35,19 +67,22 @@ public abstract class KaitaiAsyncStreamBaseTests
     public async Task Eof_Test(bool shouldBeEof, int streamSize, int readBitsAmount)
     {
       var kaitaiStreamSUT = Create(new byte[streamSize]);
-      await kaitaiStreamSUT.ReadBitsIntAsync(readBitsAmount);
-      long positionBeforeIsEof = kaitaiStreamSUT.Pos;
-
-      if (shouldBeEof)
+      await EvaluateMaybeCancelled(async () =>
       {
-        Assert.True(kaitaiStreamSUT.IsEof);
-      }
-      else
-      {
-        Assert.False(kaitaiStreamSUT.IsEof);
-      }
-
-      Assert.Equal(positionBeforeIsEof, kaitaiStreamSUT.Pos);
+        await kaitaiStreamSUT.ReadBitsIntAsync(readBitsAmount);
+        long positionBeforeIsEof = kaitaiStreamSUT.Pos;
+
+        if (shouldBeEof)
+        {
+          Assert.True(kaitaiStreamSUT.IsEof);
+        }
+        else
+        {
+          Assert.False(kaitaiStreamSUT.IsEof);
+        }
+
+        Assert.Equal(positionBeforeIsEof, kaitaiStreamSUT.Pos);
+      });
     }
 
     [Theory]
@@ -57,9 +92,12 @@ public async Task Pos_ByRead_Test(int expectedPos, int readBitsAmount)
     {
       var kaitaiStreamSUT = Create(new byte[1]);
 
-      await kaitaiStreamSUT.ReadBytesAsync(readBitsAmount);
+      await EvaluateMaybeCancelled(async () =>
+      {
+        await kaitaiStreamSUT.ReadBytesAsync(readBitsAmount);
 
-      Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+        Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+      });
     }
 
     [Theory]
@@ -69,9 +107,12 @@ public async Task Pos_BySeek_Test(int expectedPos, int position)
     {
       var kaitaiStreamSUT = Create(new byte[1]);
 
-      await kaitaiStreamSUT.SeekAsync(position);
+      await EvaluateMaybeCancelled(async () =>
+      {
+        await kaitaiStreamSUT.SeekAsync(position);
 
-      Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+        Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+      });
     }
 
     [Theory]