Add BinaryReaderExtensions and BinaryWriterExtensions

PowerKit.Tests/BinaryReaderExtensionsTests.cs

@@ -0,0 +1,106 @@
+using System;
+using System.IO;
+using System.Text;
+using FluentAssertions;
+using PowerKit.Extensions;
+using Xunit;
+
+namespace PowerKit.Tests;
+
+public class BinaryReaderExtensionsTests
+{
+    [Fact]
+    public void SkipZeroes_NonSeekableStream_Test()
+    {
+        // Arrange
+        var data = new byte[] { 0, 0, 1, 2 };
+        using var stream = new NonSeekableStream(data);
+        using var reader = new BinaryReader(stream);
+
+        // Act & assert
+        var act = () => reader.SkipZeroes();
+        act.Should().Throw<InvalidOperationException>();
+    }
+
+    [Fact]
+    public void SkipZeroes_Test()
+    {
+        // Arrange
+        var data = new byte[] { 0, 0, 0, 1, 2, 3 };
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream);
+
+        // Act
+        reader.SkipZeroes();
+
+        // Assert
+        stream.Position.Should().Be(3);
+        reader.ReadByte().Should().Be(1);
+    }
+
+    [Fact]
+    public void SkipZeroes_WithMaxLength_Test()
+    {
+        // Arrange
+        var data = new byte[] { 0, 0, 0, 0, 1, 2, 3 };
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream);
+
+        // Act
+        reader.SkipZeroes(maxSkipLength: 2);
+
+        // Assert
+        stream.Position.Should().Be(2);
+        reader.ReadByte().Should().Be(0);
+    }
+
+    [Fact]
+    public void SkipZeroes_AllZeroes_Test()
+    {
+        // Arrange
+        var data = new byte[] { 0, 0, 0 };
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream);
+
+        // Act
+        reader.SkipZeroes();
+
+        // Assert
+        stream.Position.Should().Be(3);
+    }
+
+    [Fact]
+    public void ReadNullTerminatedString_Test()
+    {
+        // Arrange
+        var data = Encoding.ASCII.GetBytes("hello\0");
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream, Encoding.ASCII);
+
+        // Act
+        var result = reader.ReadNullTerminatedString();
+
+        // Assert
+        result.Should().Be("hello");
+    }
+
+    [Fact]
+    public void ReadNullTerminatedString_Empty_Test()
+    {
+        // Arrange
+        var data = new byte[] { 0 };
+        using var stream = new MemoryStream(data);
+        using var reader = new BinaryReader(stream, Encoding.ASCII);
+
+        // Act
+        var result = reader.ReadNullTerminatedString();
+
+        // Assert
+        result.Should().Be("");
+    }
+}
+
+file class NonSeekableStream(byte[] data) : MemoryStream(data)
+{
+    public override bool CanSeek => false;
+}

PowerKit.Tests/BinaryWriterExtensionsTests.cs

@@ -0,0 +1,38 @@
+using System.IO;
+using System.Text;
+using FluentAssertions;
+using PowerKit.Extensions;
+using Xunit;
+
+namespace PowerKit.Tests;
+
+public class BinaryWriterExtensionsTests
+{
+    [Fact]
+    public void WriteNullTerminatedString_Test()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, Encoding.ASCII);
+
+        // Act
+        writer.WriteNullTerminatedString("hello");
+
+        // Assert
+        stream.ToArray().Should().Equal((byte)'h', (byte)'e', (byte)'l', (byte)'l', (byte)'o', 0);
+    }
+
+    [Fact]
+    public void WriteNullTerminatedString_Empty_Test()
+    {
+        // Arrange
+        using var stream = new MemoryStream();
+        using var writer = new BinaryWriter(stream, Encoding.ASCII);
+
+        // Act
+        writer.WriteNullTerminatedString("");
+
+        // Assert
+        stream.ToArray().Should().Equal(0);
+    }
+}

PowerKit/Extensions/BinaryReaderExtensions.cs

@@ -0,0 +1,57 @@
+using System;
+using System.IO;
+using System.Text;
+
+namespace PowerKit.Extensions;
+
+internal static class BinaryReaderExtensions
+{
+    extension(BinaryReader reader)
+    {
+        /// <summary>
+        /// Skips zero bytes in the stream, up to the specified maximum length.
+        /// </summary>
+        public void SkipZeroes(long? maxSkipLength = null)
+        {
+            if (!reader.BaseStream.CanSeek)
+            {
+                throw new InvalidOperationException("The underlying stream must be seekable.");
+            }
+
+            var endPosition = maxSkipLength is not null
+                ? Math.Min(reader.BaseStream.Position + maxSkipLength.Value, reader.BaseStream.Length)
+                : reader.BaseStream.Length;
+
+            while (reader.BaseStream.Position < endPosition)
+            {
+                if (reader.ReadByte() != 0)
+                {
+                    // Go back to non-zero byte
+                    reader.BaseStream.Seek(-1, SeekOrigin.Current);
+                    return;
+                }
+            }
+        }
+
+        /// <summary>
+        /// Reads a null-terminated string from the binary reader.
+        /// </summary>
+        public string ReadNullTerminatedString()
+        {
+            var buffer = new StringBuilder();
+
+            while (true)
+            {
+                var ch = reader.ReadChar();
+                if (ch == '\0')
+                {
+                    break;
+                }
+
+                buffer.Append(ch);
+            }
+
+            return buffer.ToString();
+        }
+    }
+}

PowerKit/Extensions/BinaryWriterExtensions.cs

@@ -0,0 +1,19 @@
+using System.IO;
+using System.Text;
+
+namespace PowerKit.Extensions;
+
+internal static class BinaryWriterExtensions
+{
+    extension(BinaryWriter writer)
+    {
+        /// <summary>
+        /// Writes a null-terminated string to the binary writer.
+        /// </summary>
+        public void WriteNullTerminatedString(string value)
+        {
+            writer.Write(Encoding.UTF8.GetBytes(value));
+            writer.Write((byte)0);
+        }
+    }
+}