C# Async with .NET Core Kaitai.Struct.Runtime.Async

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/Data/DecimalData.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Kaitai.Struct.Runtime.Async.Tests
+{
+    public class DecimalData
+    {
+        public static IEnumerable<object[]> Decimal4Data =>
+            new List<(float expected, byte[] streamContent)>
+            {
+                (0f, BitConverter.GetBytes(0f)),
+                (1f, BitConverter.GetBytes(1f)),
+                (0.1f, BitConverter.GetBytes(0.1f)),
+                (1.1f, BitConverter.GetBytes(1.1f)),
+                (float.MinValue, BitConverter.GetBytes(float.MinValue)),
+                (float.MaxValue, BitConverter.GetBytes(float.MaxValue))
+            }.Select(t => new object[] {t.expected, t.streamContent});
+
+        public static IEnumerable<object[]> Decimal8Data =>
+            new List<(double expected, byte[] streamContent)>
+            {
+                (0d, BitConverter.GetBytes(0d)),
+                (1d, BitConverter.GetBytes(1d)),
+                (0.1d, BitConverter.GetBytes(0.1d)),
+                (1.1d, BitConverter.GetBytes(1.1d)),
+                (double.MinValue, BitConverter.GetBytes(double.MinValue)),
+                (double.MaxValue, BitConverter.GetBytes(double.MaxValue))
+            }.Select(t => new object[] {t.expected, t.streamContent});
+    }
+}

Kaitai.Struct.Runtime.Async.Tests/Data/IntegralData.cs

@@ -0,0 +1,82 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Kaitai.Struct.Runtime.Async.Tests
+{
+    public class IntegralData
+    {
+        public static IEnumerable<object[]> Integral1Data =>
+            new List<(sbyte expected, byte[] streamContent)>
+            {
+                (0x00, new byte[] {0x00}),
+                (0x01, new byte[] {0x01}),
+                (0x7F, new byte[] {0x7F}),
+                (unchecked((sbyte) 0xFF), new byte[] {0xFF})
+            }.Select(t => new object[] {t.expected, t.streamContent});
+
+        public static IEnumerable<object[]> Integral2Data =>
+            new List<(short expected, byte[] streamContent)>
+            {
+                (0x00, new byte[] {0x00, 0x00}),
+                (0x01, new byte[] {0x00, 0x01}),
+                (0xFF, new byte[] {0x00, 0xFF}),
+                (0x01_FF, new byte[] {0x01, 0xFF}),
+                (0x7F_FF, new byte[] {0x7F, 0xFF}),
+                (unchecked((short) 0xFF_FF), new byte[] {0xFF, 0xFF})
+            }.Select(t => new object[] {t.expected, t.streamContent});
+
+        public static IEnumerable<object[]> Integral4Data =>
+            new List<(int expected, byte[] streamContent)>
+            {
+                (0x00, new byte[] {0x00, 0x00, 0x00, 0x00}),
+                (0x01, new byte[] {0x00, 0x00, 0x00, 0x01}),
+                (0xFF, new byte[] {0x00, 0x00, 0x00, 0xFF}),
+                (0x01_FF, new byte[] {0x00, 0x00, 0x01, 0xFF}),
+                (0x7F_FF, new byte[] {0x00, 0x00, 0x7F, 0xFF}),
+                (0xFF_FF, new byte[] {0x00, 0x00, 0xFF, 0xFF}),
+                (0x01_FF_FF, new byte[] {0x00, 0x01, 0xFF, 0xFF}),
+                (0x7F_FF_FF, new byte[] {0x00, 0x7F, 0xFF, 0xFF}),
+                (0xFF_FF_FF, new byte[] {0x00, 0xFF, 0xFF, 0xFF}),
+                (0x01_FF_FF_FF, new byte[] {0x01, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF, new byte[] {0x7F, 0xFF, 0xFF, 0xFF}),
+                (unchecked((int) 0xFF_FF_FF_FF), new byte[] {0xFF, 0xFF, 0xFF, 0xFF})
+            }.Select(t => new object[] {t.expected, t.streamContent});
+
+        public static IEnumerable<object[]> Integral8Data =>
+            new List<(long expected, byte[] streamContent)>
+            {
+                (0, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}),
+                (1, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01}),
+                (0xFF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF}),
+
+                (0x01_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF}),
+                (0x7F_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF}),
+                (0xFF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF}),
+
+                (0x01_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF}),
+                (0x7F_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF}),
+                (0xFF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF}),
+
+                (0x01_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF}),
+                (0xFF_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF}),
+
+                (0x01_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0xFF_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+
+                (0x01_FF_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0xFF_FF_FF_FF_FF_FF, new byte[] {0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+
+                (0x01_FF_FF_FF_FF_FF_FF, new byte[] {0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF_FF_FF_FF, new byte[] {0x00, 0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0xFF_FF_FF_FF_FF_FF_FF, new byte[] {0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+
+                (0x01_FF_FF_FF_FF_FF_FF_FF, new byte[] {0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (0x7F_FF_FF_FF_FF_FF_FF_FF, new byte[] {0x7F, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}),
+                (unchecked((long) 0xFF_FF_FF_FF_FF_FF_FF_FF),
+                    new byte[] {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF})
+            }.Select(t => new object[] {t.expected, t.streamContent});
+    }
+}

Kaitai.Struct.Runtime.Async.Tests/Kaitai.Struct.Runtime.Async.Tests.csproj

@@ -0,0 +1,20 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.2.0" />
+    <PackageReference Include="xunit" Version="2.4.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.0" />
+    <PackageReference Include="coverlet.collector" Version="1.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Kaitai.Struct.Runtime.Async\Kaitai.Struct.Runtime.Async.csproj" />
+  </ItemGroup>
+
+</Project>

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

@@ -0,0 +1,185 @@
+using System;
+using System.IO;
+using System.IO.Pipelines;
+using System.Threading;
+using System.Threading.Tasks;
+using Kaitai.Async;
+using Xunit;
+
+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 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]
+    [InlineData(true, 0, 0)]
+    [InlineData(false, 1, 0)]
+    [InlineData(false, 1, 1)]
+    [InlineData(false, 1, 2)]
+    [InlineData(false, 1, 3)]
+    [InlineData(false, 1, 4)]
+    [InlineData(false, 1, 5)]
+    [InlineData(false, 1, 6)]
+    [InlineData(false, 1, 7)]
+    [InlineData(true, 1, 8)]
+    public async Task Eof_Test(bool shouldBeEof, int streamSize, int readBitsAmount)
+    {
+      var kaitaiStreamSUT = Create(new byte[streamSize]);
+      await EvaluateMaybeCancelled(async () =>
+      {
+        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]
+    [InlineData(0, 0)]
+    [InlineData(1, 1)]
+    public async Task Pos_ByRead_Test(int expectedPos, int readBitsAmount)
+    {
+      var kaitaiStreamSUT = Create(new byte[1]);
+
+      await EvaluateMaybeCancelled(async () =>
+      {
+        await kaitaiStreamSUT.ReadBytesAsync(readBitsAmount);
+
+        Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+      });
+    }
+
+    [Theory]
+    [InlineData(0, 0)]
+    [InlineData(1, 1)]
+    public async Task Pos_BySeek_Test(int expectedPos, int position)
+    {
+      var kaitaiStreamSUT = Create(new byte[1]);
+
+      await EvaluateMaybeCancelled(async () =>
+      {
+        await kaitaiStreamSUT.SeekAsync(position);
+
+        Assert.Equal(expectedPos, kaitaiStreamSUT.Pos);
+      });
+    }
+
+    [Fact]
+    public async Task ForwardSeek_AfterReadToEndAndBackwardSeek_Test()
+    {
+        const int toRead = 1;
+
+      var kaitaiStreamSUT = Create(new byte[2]);
+
+      await EvaluateMaybeCancelled(async () =>
+      { 
+        // Simulates kaitai compiler generated code for multiple fields defined as `instances`
+        await kaitaiStreamSUT.ReadBytesFullAsync(CancellationToken.None);
+        await kaitaiStreamSUT.SeekAsync(0);
+        await kaitaiStreamSUT.SeekAsync(toRead);
+
+        Assert.Equal(toRead, kaitaiStreamSUT.Pos);
+      });
+    }
+
+    [Theory]
+    [InlineData(0)]
+    [InlineData(1)]
+    [InlineData(100)]
+    [InlineData(1_000)]
+    [InlineData(10_000)]
+    [InlineData(100_000)]
+    [InlineData(1_000_000)]
+    public void Size_Test(int streamSize)
+    {
+      var kaitaiStreamSUT = Create(new byte[streamSize]);
+      long positionBeforeIsEof = kaitaiStreamSUT.Pos;
+
+      Assert.Equal(streamSize, kaitaiStreamSUT.Size);
+      Assert.Equal(positionBeforeIsEof, kaitaiStreamSUT.Pos);
+    }
+
+    [Fact]
+    public async Task AlignToByte_Test()
+    {
+      //Arrange
+      var kaitaiStreamSUT = Create(new byte[] {0b_1000_0000});
+
+      ulong read = await kaitaiStreamSUT.ReadBitsIntAsync(1);
+      Assert.Equal(1u, read);
+
+      //Act
+      kaitaiStreamSUT.AlignToByte();
+      //Assert
+      Assert.Equal(1, kaitaiStreamSUT.Pos);
+    }
+
+    [Fact]
+    public void EmptyStream_NoRead_NoSeek_IsEof_ShouldBe_True()
+    {
+      var kaitaiStreamSUT = Create(new byte[0]);
+
+      Assert.True(kaitaiStreamSUT.IsEof);
+    }
+
+    [Fact]
+    public void EmptyStream_NoRead_NoSeek_Pos_ShouldBe_0()
+    {
+      var kaitaiStreamSUT = Create(new byte[0]);
+
+      Assert.Equal(0, kaitaiStreamSUT.Pos);
+    }
+  }
+}