test(extensions): 添加字节序转换测试

为 byte[]、Span<byte> 和 ReadOnlySpan<byte> 的字节序转换方法添加单元测试

Author: AlianBlank

GameFrameX.Foundation.Tests/Extensions/ByteExtensionTests.cs

@@ -2428,4 +2428,105 @@ public void RoundTrip_WriteStringWithoutLengthLittleEndian_ReadStringLittleEndia
     }
 
     #endregion
-}
+
+    #region Endian Conversion Tests
+
+    [Fact]
+    public void ConvertEndianInPlace_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] buffer = { 0x12, 0x34, 0x56, 0x78 };
+
+        // Act
+        buffer.ConvertEndianInPlace(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x34, 0x12, 0x78, 0x56 }, buffer);
+    }
+
+    [Fact]
+    public void ConvertEndian_ValidInput_ShouldReturnConvertedCopy()
+    {
+        // Arrange
+        byte[] source = { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act
+        var result = source.ConvertEndian(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x02, 0x01, 0x04, 0x03 }, result);
+        Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, source);
+    }
+
+    [Fact]
+    public void BigEndianToLittleEndian_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] source = { 0x11, 0x22, 0x33, 0x44 };
+
+        // Act
+        var result = source.BigEndianToLittleEndian(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x22, 0x11, 0x44, 0x33 }, result);
+    }
+
+    [Fact]
+    public void ConvertEndianInPlace_InvalidElementSize_ShouldThrowArgumentOutOfRangeException()
+    {
+        // Arrange
+        byte[] buffer = { 0x12, 0x34 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentOutOfRangeException>(() => buffer.ConvertEndianInPlace(0));
+    }
+
+    [Fact]
+    public void ConvertEndianInPlace_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        byte[] buffer = { 0x01, 0x02, 0x03 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => buffer.ConvertEndianInPlace(2));
+    }
+
+    [Fact]
+    public void ConvertEndianByInt16InPlace_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] buffer = { 0x12, 0x34, 0x56, 0x78 };
+
+        // Act
+        buffer.ConvertEndianByInt16InPlace();
+
+        // Assert
+        Assert.Equal(new byte[] { 0x34, 0x12, 0x78, 0x56 }, buffer);
+    }
+
+    [Fact]
+    public void ConvertEndianByInt32_ValidInput_ShouldReturnConvertedCopy()
+    {
+        // Arrange
+        byte[] source = { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act
+        var result = source.ConvertEndianByInt32();
+
+        // Assert
+        Assert.Equal(new byte[] { 0x04, 0x03, 0x02, 0x01 }, result);
+        Assert.Equal(new byte[] { 0x01, 0x02, 0x03, 0x04 }, source);
+    }
+
+    [Fact]
+    public void ConvertEndianByInt64_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        byte[] source = { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => source.ConvertEndianByInt64());
+    }
+
+    #endregion
+}

GameFrameX.Foundation.Tests/Extensions/ReadOnlySpanExtensionsTests.cs

@@ -705,5 +705,68 @@ public void ReadDoubleBigEndianValue_NegativeOffset_ShouldThrowException()
 
     #endregion
 
+    #region Endian Conversion Tests
+
+    [Fact]
+    public void ConvertEndian_ValidInput_ShouldReturnConvertedArray()
+    {
+        // Arrange
+        var buffer = new byte[] { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act
+        var result = ((ReadOnlySpan<byte>)buffer).ConvertEndian(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x02, 0x01, 0x04, 0x03 }, result);
+    }
+
+    [Fact]
+    public void LittleEndianToBigEndian_ValidInput_ShouldReturnConvertedArray()
+    {
+        // Arrange
+        var buffer = new byte[] { 0x78, 0x56, 0x34, 0x12 };
+
+        // Act
+        var result = ((ReadOnlySpan<byte>)buffer).LittleEndianToBigEndian(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x56, 0x78, 0x12, 0x34 }, result);
+    }
+
+    [Fact]
+    public void ConvertEndian_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        var buffer = new byte[] { 0x01, 0x02, 0x03 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => ((ReadOnlySpan<byte>)buffer).ConvertEndian(2));
+    }
+
+    [Fact]
+    public void ConvertEndianByInt16_ValidInput_ShouldReturnConvertedArray()
+    {
+        // Arrange
+        var buffer = new byte[] { 0x12, 0x34, 0x56, 0x78 };
+
+        // Act
+        var result = ((ReadOnlySpan<byte>)buffer).ConvertEndianByInt16();
+
+        // Assert
+        Assert.Equal(new byte[] { 0x34, 0x12, 0x78, 0x56 }, result);
+    }
+
+    [Fact]
+    public void ConvertEndianByInt64_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        var buffer = new byte[] { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => ((ReadOnlySpan<byte>)buffer).ConvertEndianByInt64());
+    }
+
+    #endregion
+
     #endregion
-}
+}

GameFrameX.Foundation.Tests/Extensions/SpanExtensionTests.cs

@@ -904,4 +904,67 @@ public void RoundTrip_WriteStringLittleEndianValue_ReadStringLittleEndianValue_S
     }
 
     #endregion
+
+    #region Endian Conversion Tests
+
+    [Fact]
+    public void ConvertEndianInPlace_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] buffer = { 0x10, 0x20, 0x30, 0x40 };
+
+        // Act
+        buffer.AsSpan().ConvertEndianInPlace(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0x20, 0x10, 0x40, 0x30 }, buffer);
+    }
+
+    [Fact]
+    public void BigEndianToLittleEndianInPlace_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] buffer = { 0xAA, 0xBB, 0xCC, 0xDD };
+
+        // Act
+        buffer.AsSpan().BigEndianToLittleEndianInPlace(2);
+
+        // Assert
+        Assert.Equal(new byte[] { 0xBB, 0xAA, 0xDD, 0xCC }, buffer);
+    }
+
+    [Fact]
+    public void ConvertEndianInPlace_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        byte[] buffer = { 0x01, 0x02, 0x03 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => buffer.AsSpan().ConvertEndianInPlace(2));
+    }
+
+    [Fact]
+    public void ConvertEndianByInt16InPlace_ValidInput_ShouldConvertCorrectly()
+    {
+        // Arrange
+        byte[] buffer = { 0x10, 0x20, 0x30, 0x40 };
+
+        // Act
+        buffer.AsSpan().ConvertEndianByInt16InPlace();
+
+        // Assert
+        Assert.Equal(new byte[] { 0x20, 0x10, 0x40, 0x30 }, buffer);
+    }
+
+    [Fact]
+    public void ConvertEndianByInt64InPlace_LengthNotAligned_ShouldThrowArgumentException()
+    {
+        // Arrange
+        byte[] buffer = { 0x01, 0x02, 0x03, 0x04 };
+
+        // Act & Assert
+        Assert.Throws<ArgumentException>(() => buffer.AsSpan().ConvertEndianByInt64InPlace());
+    }
+
+    #endregion
 }