Add more tests for BitConverter

Brings coverage of BitConvert to ~95%.

Author: stephentoub

src/System.Runtime.Extensions/tests/System.Runtime.Extensions.Tests.csproj

@@ -9,6 +9,7 @@
     <RootNamespace>System.Runtime.Extensions.Tests</RootNamespace>
     <AssemblyName>System.Runtime.Extensions.Tests</AssemblyName>
     <RestorePackages>true</RestorePackages>
+    <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
   </PropertyGroup>
   <!-- Default configurations to help VS understand the configurations -->
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">

src/System.Runtime.Extensions/tests/System/BitConverter.cs

@@ -6,6 +6,101 @@
 
 public static class BitConverterTests
 {
+    [Fact]
+    public static unsafe void IsLittleEndian()
+    {
+        short s = 1;
+        Assert.Equal(BitConverter.IsLittleEndian, *((byte*)&s) == 1);
+    }
+
+    [Fact]
+    public static void ValueArgumentNull()
+    {
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToBoolean(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToChar(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToDouble(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToInt16(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToInt32(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToInt64(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToSingle(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToUInt16(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToUInt32(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToUInt64(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToString(null));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToString(null, 0));
+        Assert.Throws<ArgumentNullException>("value", () => BitConverter.ToString(null, 0, 0));
+    }
+
+    [Fact]
+    public static void StartIndexBeyondLength()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToBoolean(new byte[1], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToBoolean(new byte[1], 1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToBoolean(new byte[1], 2));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToChar(new byte[2], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToChar(new byte[2], 2));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToChar(new byte[2], 3));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToDouble(new byte[8], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToDouble(new byte[8], 8));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToDouble(new byte[8], 9));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt16(new byte[2], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt16(new byte[2], 2));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt16(new byte[2], 3));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt32(new byte[4], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt32(new byte[4], 4));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt32(new byte[4], 5));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt64(new byte[8], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt64(new byte[8], 8));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToInt64(new byte[8], 9));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToSingle(new byte[4], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToSingle(new byte[4], 4));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToSingle(new byte[4], 5));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt16(new byte[2], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt16(new byte[2], 2));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt16(new byte[2], 3));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt32(new byte[4], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt32(new byte[4], 4));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt32(new byte[4], 5));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt64(new byte[8], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt64(new byte[8], 8));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToUInt64(new byte[8], 9));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], -1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], 1));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], 2));
+
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], -1, 0));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], 1, 0));
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToString(new byte[1], 2, 0));
+
+        Assert.Throws<ArgumentOutOfRangeException>("length", () => BitConverter.ToString(new byte[1], 0, -1));
+    }
+
+    [Fact]
+    public static void StartIndexPlusNeededLengthTooLong()
+    {
+        Assert.Throws<ArgumentOutOfRangeException>("startIndex", () => BitConverter.ToBoolean(new byte[0], 0));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToChar(new byte[2], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToDouble(new byte[8], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToInt16(new byte[2], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToInt32(new byte[4], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToInt64(new byte[8], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToSingle(new byte[4], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToUInt16(new byte[2], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToUInt32(new byte[4], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToUInt64(new byte[8], 1));
+        Assert.Throws<ArgumentException>("value", () => BitConverter.ToString(new byte[2], 1, 2));
+    }
+
     [Fact]
     public static void DoubleToInt64Bits()
     {
@@ -125,5 +220,11 @@ private static void VerifyRoundtrip<TInput>(Func<TInput, Byte[]> getBytes, Func<
 
         Assert.Equal(expectedBytes, bytes);
         Assert.Equal(input, convertBack(bytes, 0));
+
+        // Also try unaligned startIndex
+        byte[] longerBytes = new byte[bytes.Length + 1];
+        longerBytes[0] = 0;
+        Array.Copy(bytes, 0, longerBytes, 1, bytes.Length);
+        Assert.Equal(input, convertBack(longerBytes, 1));
     }
 }