improve performance of EndianBitConverter and small formatting fixes

src/ImageSharp/IO/BigEndianBitConverter.cs

@@ -6,43 +6,81 @@
 namespace ImageSharp.IO
 {
     /// <summary>
-    /// Implementation of EndianBitConverter which converts to/from big-endian
-    /// byte arrays.
-    /// <remarks>
-    /// Adapted from Miscellaneous Utility Library <see href="http://jonskeet.uk/csharp/miscutil/" />
-    /// This product includes software developed by Jon Skeet and Marc Gravell. Contact <see href="mailto:skeet@pobox.com" />, or see
-    /// <see href="http://www.pobox.com/~skeet/" />.
-    /// </remarks>
+    /// Implementation of EndianBitConverter which converts to/from big-endian byte arrays.
     /// </summary>
     internal sealed class BigEndianBitConverter : EndianBitConverter
     {
         /// <inheritdoc/>
-        public override Endianness Endianness => Endianness.BigEndian;
+        public override Endianness Endianness
+        {
+            get { return Endianness.BigEndian; }
+        }
 
         /// <inheritdoc/>
-        public override bool IsLittleEndian() => false;
+        public override bool IsLittleEndian
+        {
+            get { return false; }
+        }
 
         /// <inheritdoc/>
-        protected internal override void CopyBytesImpl(long value, int bytes, byte[] buffer, int index)
+        public override void CopyBytes(short value, byte[] buffer, int index)
         {
-            int endOffset = index + bytes - 1;
-            for (int i = 0; i < bytes; i++)
-            {
-                buffer[endOffset - i] = unchecked((byte)(value & 0xff));
-                value = value >> 8;
-            }
+            CheckByteArgument(buffer, index, 2);
+
+            buffer[index] = (byte)(value >> 8);
+            buffer[index + 1] = (byte)value;
+        }
+
+        /// <inheritdoc/>
+        public override void CopyBytes(int value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 4);
+
+            buffer[index] = (byte)(value >> 24);
+            buffer[index + 1] = (byte)(value >> 16);
+            buffer[index + 2] = (byte)(value >> 8);
+            buffer[index + 3] = (byte)value;
+        }
+
+        /// <inheritdoc/>
+        public override void CopyBytes(long value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 8);
+
+            buffer[index] = (byte)(value >> 56);
+            buffer[index + 1] = (byte)(value >> 48);
+            buffer[index + 2] = (byte)(value >> 40);
+            buffer[index + 3] = (byte)(value >> 32);
+            buffer[index + 4] = (byte)(value >> 24);
+            buffer[index + 5] = (byte)(value >> 16);
+            buffer[index + 6] = (byte)(value >> 8);
+            buffer[index + 7] = (byte)value;
+        }
+
+        /// <inheritdoc/>
+        public override short ToInt16(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 2);
+
+            return (short)((value[0] << 8) | value[1]);
+        }
+
+        /// <inheritdoc/>
+        public override int ToInt32(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 4);
+
+            return (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3];
         }
 
         /// <inheritdoc/>
-        protected internal override long FromBytes(byte[] buffer, int startIndex, int bytesToConvert)
+        public override long ToInt64(byte[] value, int startIndex)
         {
-            long ret = 0;
-            for (int i = 0; i < bytesToConvert; i++)
-            {
-                ret = unchecked((ret << 8) | buffer[startIndex + i]);
-            }
+            CheckByteArgument(value, startIndex, 8);
 
-            return ret;
+            long p1 = (value[0] << 24) | (value[1] << 16) | (value[2] << 8) | value[3];
+            long p2 = (value[4] << 24) | (value[5] << 16) | (value[6] << 8) | value[7];
+            return p2 | (p1 << 32);
         }
     }
 }

src/ImageSharp/IO/EndianBinaryReader.cs

@@ -68,7 +68,7 @@ namespace ImageSharp.IO
         {
             Guard.NotNull(stream, nameof(stream));
             Guard.NotNull(encoding, nameof(encoding));
-            Guard.IsTrue(stream.CanRead, nameof(stream), "Stream isn't readable.");
+            Guard.IsTrue(stream.CanRead, nameof(stream), "Stream isn't readable");
 
             this.BaseStream = stream;
             this.BitConverter = EndianBitConverter.GetConverter(endianness);
@@ -510,7 +510,7 @@ namespace ImageSharp.IO
         {
             if (this.disposed)
             {
-                throw new ObjectDisposedException("EndianBinaryReader");
+                throw new ObjectDisposedException(nameof(EndianBinaryReader));
             }
         }
 

src/ImageSharp/IO/EndianBinaryWriter.cs

@@ -52,31 +52,12 @@ namespace ImageSharp.IO
         /// </param>
         public EndianBinaryWriter(Endianness endianness, Stream stream, Encoding encoding)
         {
-            EndianBitConverter bitConverter = EndianBitConverter.GetConverter(endianness);
-
-            // TODO: Use Guard
-            if (bitConverter == null)
-            {
-                throw new ArgumentNullException("bitConverter");
-            }
-
-            if (stream == null)
-            {
-                throw new ArgumentNullException("stream");
-            }
-
-            if (encoding == null)
-            {
-                throw new ArgumentNullException("encoding");
-            }
-
-            if (!stream.CanWrite)
-            {
-                throw new ArgumentException("Stream isn't writable", "stream");
-            }
+            Guard.NotNull(stream, nameof(stream));
+            Guard.NotNull(stream, nameof(encoding));
+            Guard.IsTrue(stream.CanWrite, nameof(stream), "Stream isn't writable");
 
             this.BaseStream = stream;
-            this.BitConverter = bitConverter;
+            this.BitConverter = EndianBitConverter.GetConverter(endianness);
             this.Encoding = encoding;
         }
 
@@ -256,13 +237,10 @@ namespace ImageSharp.IO
         /// Writes an array of bytes to the stream.
         /// </summary>
         /// <param name="value">The values to write</param>
+        /// <exception cref="ArgumentNullException">value is null</exception>
         public void Write(byte[] value)
         {
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
+            Guard.NotNull(value, nameof(value));
             this.WriteInternal(value, value.Length);
         }
 
@@ -272,6 +250,7 @@ namespace ImageSharp.IO
         /// <param name="value">An array containing the bytes to write</param>
         /// <param name="offset">The index of the first byte to write within the array</param>
         /// <param name="count">The number of bytes to write</param>
+        /// <exception cref="ArgumentNullException">value is null</exception>
         public void Write(byte[] value, int offset, int count)
         {
             this.CheckDisposed();
@@ -292,12 +271,10 @@ namespace ImageSharp.IO
         /// Writes an array of characters to the stream, using the encoding for this writer.
         /// </summary>
         /// <param name="value">An array containing the characters to write</param>
+        /// <exception cref="ArgumentNullException">value is null</exception>
         public void Write(char[] value)
         {
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
+            Guard.NotNull(value, nameof(value));
 
             this.CheckDisposed();
             byte[] data = this.Encoding.GetBytes(value, 0, value.Length);
@@ -305,16 +282,13 @@ namespace ImageSharp.IO
         }
 
         /// <summary>
-        /// Writes a string to the stream, using the encoding for this writer.
+        /// Writes a length-prefixed string to the stream, using the encoding for this writer.
         /// </summary>
         /// <param name="value">The value to write. Must not be null.</param>
-        /// <exception cref="System.ArgumentNullException">value is null</exception>
+        /// <exception cref="ArgumentNullException">value is null</exception>
         public void Write(string value)
         {
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
+            Guard.NotNull(value, nameof(value));
 
             this.CheckDisposed();
             byte[] data = this.Encoding.GetBytes(value);
@@ -368,7 +342,7 @@ namespace ImageSharp.IO
         {
             if (this.disposed)
             {
-                throw new ObjectDisposedException("EndianBinaryWriter");
+                throw new ObjectDisposedException(nameof(EndianBinaryWriter));
             }
         }
 

src/ImageSharp/IO/EndianBitConverter.Conversion.cs

@@ -0,0 +1,63 @@
+// <copyright file="EndianBitConverter.Conversion.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.IO
+{
+    using System;
+
+    /// <summary>
+    /// Equivalent of <see cref="BitConverter"/>, but with either endianness.
+    /// </summary>
+    internal abstract partial class EndianBitConverter
+    {
+        /// <summary>
+        /// Converts the specified double-precision floating point number to a
+        /// 64-bit signed integer. Note: the endianness of this converter does not
+        /// affect the returned value.
+        /// </summary>
+        /// <param name="value">The number to convert. </param>
+        /// <returns>A 64-bit signed integer whose value is equivalent to value.</returns>
+        public unsafe long DoubleToInt64Bits(double value)
+        {
+            return *((long*)&value);
+        }
+
+        /// <summary>
+        /// Converts the specified 64-bit signed integer to a double-precision
+        /// floating point number. Note: the endianness of this converter does not
+        /// affect the returned value.
+        /// </summary>
+        /// <param name="value">The number to convert. </param>
+        /// <returns>A double-precision floating point number whose value is equivalent to value.</returns>
+        public unsafe double Int64BitsToDouble(long value)
+        {
+            return *((double*)&value);
+        }
+
+        /// <summary>
+        /// Converts the specified single-precision floating point number to a
+        /// 32-bit signed integer. Note: the endianness of this converter does not
+        /// affect the returned value.
+        /// </summary>
+        /// <param name="value">The number to convert. </param>
+        /// <returns>A 32-bit signed integer whose value is equivalent to value.</returns>
+        public unsafe int SingleToInt32Bits(float value)
+        {
+            return *((int*)&value);
+        }
+
+        /// <summary>
+        /// Converts the specified 32-bit signed integer to a single-precision floating point
+        /// number. Note: the endianness of this converter does not
+        /// affect the returned value.
+        /// </summary>
+        /// <param name="value">The number to convert. </param>
+        /// <returns>A single-precision floating point number whose value is equivalent to value.</returns>
+        public unsafe float Int32BitsToSingle(int value)
+        {
+            return *((float*)&value);
+        }
+    }
+}

src/ImageSharp/IO/EndianBitConverter.CopyBytes.cs

@@ -0,0 +1,145 @@
+// <copyright file="EndianBitConverter.CopyBytes.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.IO
+{
+    using System;
+
+    /// <summary>
+    /// Equivalent of <see cref="BitConverter"/>, but with either endianness.
+    /// </summary>
+    internal abstract partial class EndianBitConverter
+    {
+        /// <summary>
+        /// Copies the specified 16-bit signed integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public abstract void CopyBytes(short value, byte[] buffer, int index);
+
+        /// <summary>
+        /// Copies the specified 32-bit signed integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public abstract void CopyBytes(int value, byte[] buffer, int index);
+
+        /// <summary>
+        /// Copies the specified 64-bit signed integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public abstract void CopyBytes(long value, byte[] buffer, int index);
+
+        /// <summary>
+        /// Copies the specified 16-bit unsigned integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public void CopyBytes(ushort value, byte[] buffer, int index)
+        {
+            this.CopyBytes(unchecked((short)value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified 32-bit unsigned integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public void CopyBytes(uint value, byte[] buffer, int index)
+        {
+            this.CopyBytes(unchecked((int)value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified 64-bit unsigned integer value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public void CopyBytes(ulong value, byte[] buffer, int index)
+        {
+            this.CopyBytes(unchecked((long)value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified Boolean value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">A Boolean value.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public void CopyBytes(bool value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 1);
+            buffer[index] = value ? (byte)1 : (byte)0;
+        }
+
+        /// <summary>
+        /// Copies the specified Unicode character value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">A character to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public void CopyBytes(char value, byte[] buffer, int index)
+        {
+            this.CopyBytes(unchecked((short)value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified double-precision floating point value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public unsafe void CopyBytes(double value, byte[] buffer, int index)
+        {
+            this.CopyBytes(*((long*)&value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified single-precision floating point value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public unsafe void CopyBytes(float value, byte[] buffer, int index)
+        {
+            this.CopyBytes(*((int*)&value), buffer, index);
+        }
+
+        /// <summary>
+        /// Copies the specified decimal value into the specified byte array,
+        /// beginning at the specified index.
+        /// </summary>
+        /// <param name="value">A character to convert.</param>
+        /// <param name="buffer">The byte array to copy the bytes into</param>
+        /// <param name="index">The first index into the array to copy the bytes into</param>
+        public unsafe void CopyBytes(decimal value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 16);
+
+            int* pvalue = (int*)&value;
+            this.CopyBytes(pvalue[0], buffer, index);
+            this.CopyBytes(pvalue[1], buffer, index + 4);
+            this.CopyBytes(pvalue[2], buffer, index + 8);
+            this.CopyBytes(pvalue[3], buffer, index + 12);
+        }
+    }
+}

src/ImageSharp/IO/EndianBitConverter.GetBytes.cs

@@ -0,0 +1,139 @@
+// <copyright file="EndianBitConverter.GetBytes.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.IO
+{
+    using System;
+
+    /// <summary>
+    /// Equivalent of <see cref="BitConverter"/>, but with either endianness.
+    /// </summary>
+    internal abstract partial class EndianBitConverter
+    {
+        /// <summary>
+        /// Returns the specified 16-bit signed integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 2.</returns>
+        public byte[] GetBytes(short value)
+        {
+            byte[] result = new byte[2];
+            this.CopyBytes(value, result, 0);
+            return result;
+        }
+
+        /// <summary>
+        /// Returns the specified 32-bit signed integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 4.</returns>
+        public byte[] GetBytes(int value)
+        {
+            byte[] result = new byte[4];
+            this.CopyBytes(value, result, 0);
+            return result;
+        }
+
+        /// <summary>
+        /// Returns the specified 64-bit signed integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 8.</returns>
+        public byte[] GetBytes(long value)
+        {
+            byte[] result = new byte[8];
+            this.CopyBytes(value, result, 0);
+            return result;
+        }
+
+        /// <summary>
+        /// Returns the specified 16-bit unsigned integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 2.</returns>
+        public byte[] GetBytes(ushort value)
+        {
+            return this.GetBytes(unchecked((short)value));
+        }
+
+        /// <summary>
+        /// Returns the specified 32-bit unsigned integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 4.</returns>
+        public byte[] GetBytes(uint value)
+        {
+            return this.GetBytes(unchecked((int)value));
+        }
+
+        /// <summary>
+        /// Returns the specified 64-bit unsigned integer value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 8.</returns>
+        public byte[] GetBytes(ulong value)
+        {
+            return this.GetBytes(unchecked((long)value));
+        }
+
+        /// <summary>
+        /// Returns the specified Boolean value as an array of bytes.
+        /// </summary>
+        /// <param name="value">A Boolean value.</param>
+        /// <returns>An array of bytes with length 1.</returns>
+        /// <returns>
+        /// The <see cref="T:byte[]"/>.
+        /// </returns>
+        public byte[] GetBytes(bool value)
+        {
+            return new byte[1] { value ? (byte)1 : (byte)0 };
+        }
+
+        /// <summary>
+        /// Returns the specified Unicode character value as an array of bytes.
+        /// </summary>
+        /// <param name="value">A character to convert.</param>
+        /// <returns>An array of bytes with length 2.</returns>
+        /// <returns>
+        /// The <see cref="T:byte[]"/>.
+        /// </returns>
+        public byte[] GetBytes(char value)
+        {
+            return this.GetBytes((short)value);
+        }
+
+        /// <summary>
+        /// Returns the specified double-precision floating point value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 8.</returns>
+        public unsafe byte[] GetBytes(double value)
+        {
+            return this.GetBytes(*((long*)&value));
+        }
+
+        /// <summary>
+        /// Returns the specified single-precision floating point value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 4.</returns>
+        public unsafe byte[] GetBytes(float value)
+        {
+            return this.GetBytes(*((int*)&value));
+        }
+
+        /// <summary>
+        /// Returns the specified decimal value as an array of bytes.
+        /// </summary>
+        /// <param name="value">The number to convert.</param>
+        /// <returns>An array of bytes with length 16.</returns>
+        public byte[] GetBytes(decimal value)
+        {
+            byte[] result = new byte[16];
+            this.CopyBytes(value, result, 0);
+            return result;
+        }
+    }
+}

src/ImageSharp/IO/EndianBitConverter.ToType.cs

@@ -0,0 +1,141 @@
+// <copyright file="EndianBitConverter.ToType.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.IO
+{
+    using System;
+
+    /// <summary>
+    /// Equivalent of <see cref="BitConverter"/>, but with either endianness.
+    /// </summary>
+    internal abstract partial class EndianBitConverter
+    {
+        /// <summary>
+        /// Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 16-bit signed integer formed by two bytes beginning at startIndex.</returns>
+        public abstract short ToInt16(byte[] value, int startIndex);
+
+        /// <summary>
+        /// Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 32-bit signed integer formed by four bytes beginning at startIndex.</returns>
+        public abstract int ToInt32(byte[] value, int startIndex);
+
+        /// <summary>
+        /// Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 64-bit signed integer formed by eight bytes beginning at startIndex.</returns>
+        public abstract long ToInt64(byte[] value, int startIndex);
+
+        /// <summary>
+        /// Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 16-bit unsigned integer formed by two bytes beginning at startIndex.</returns>
+        public ushort ToUInt16(byte[] value, int startIndex)
+        {
+            return unchecked((ushort)this.ToInt16(value, startIndex));
+        }
+
+        /// <summary>
+        /// Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 32-bit unsigned integer formed by four bytes beginning at startIndex.</returns>
+        public uint ToUInt32(byte[] value, int startIndex)
+        {
+            return unchecked((uint)this.ToInt32(value, startIndex));
+        }
+
+        /// <summary>
+        /// Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A 64-bit unsigned integer formed by eight bytes beginning at startIndex.</returns>
+        public ulong ToUInt64(byte[] value, int startIndex)
+        {
+            return unchecked((ulong)this.ToInt64(value, startIndex));
+        }
+
+        /// <summary>
+        /// Returns a Boolean value converted from one byte at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>true if the byte at startIndex in value is nonzero; otherwise, false.</returns>
+        public bool ToBoolean(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 1);
+            return value[startIndex] != 0;
+        }
+
+        /// <summary>
+        /// Returns a Unicode character converted from two bytes at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A character formed by two bytes beginning at startIndex.</returns>
+        public char ToChar(byte[] value, int startIndex)
+        {
+            return unchecked((char)this.ToInt16(value, startIndex));
+        }
+
+        /// <summary>
+        /// Returns a double-precision floating point number converted from eight bytes
+        /// at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A double precision floating point number formed by eight bytes beginning at startIndex.</returns>
+        public unsafe double ToDouble(byte[] value, int startIndex)
+        {
+            long intValue = this.ToInt64(value, startIndex);
+            return *((double*)&intValue);
+        }
+
+        /// <summary>
+        /// Returns a single-precision floating point number converted from four bytes
+        /// at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A single precision floating point number formed by four bytes beginning at startIndex.</returns>
+        public unsafe float ToSingle(byte[] value, int startIndex)
+        {
+            int intValue = this.ToInt32(value, startIndex);
+            return *((float*)&intValue);
+        }
+
+        /// <summary>
+        /// Returns a decimal value converted from sixteen bytes
+        /// at a specified position in a byte array.
+        /// </summary>
+        /// <param name="value">An array of bytes.</param>
+        /// <param name="startIndex">The starting position within value.</param>
+        /// <returns>A decimal  formed by sixteen bytes beginning at startIndex.</returns>
+        public unsafe decimal ToDecimal(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 16);
+
+            decimal result = 0m;
+            int* presult = (int*)&result;
+            presult[0] = this.ToInt32(value, startIndex);
+            presult[1] = this.ToInt32(value, startIndex + 4);
+            presult[2] = this.ToInt32(value, startIndex + 8);
+            presult[3] = this.ToInt32(value, startIndex + 12);
+            return result;
+        }
+    }
+}

src/ImageSharp/IO/EndianBitConverter.cs

@@ -6,291 +6,56 @@
 namespace ImageSharp.IO
 {
     using System;
-    using System.Diagnostics.CodeAnalysis;
-    using System.Runtime.InteropServices;
+    using System.Runtime.CompilerServices;
 
     /// <summary>
-    /// Equivalent of <see cref="System.BitConverter"/>, but with either endianness.
-    /// <remarks>
-    /// Adapted from Miscellaneous Utility Library <see href="http://jonskeet.uk/csharp/miscutil/"/>
-    /// This product includes software developed by Jon Skeet and Marc Gravell. Contact <see href="mailto:skeet@pobox.com"/>, or see
-    /// <see href="http://www.pobox.com/~skeet/"/>.
-    /// </remarks>
+    /// Equivalent of <see cref="BitConverter"/>, but with either endianness.
     /// </summary>
-    [SuppressMessage("StyleCop.CSharp.OrderingRules", "SA1201:ElementsMustAppearInTheCorrectOrder", Justification = "Reviewed. Suppression is OK here. Better readability.")]
-    [SuppressMessage("StyleCop.CSharp.OrderingRules", "SA1202:ElementsMustBeOrderedByAccess", Justification = "Reviewed. Suppression is OK here. Better readability.")]
-    [SuppressMessage("StyleCop.CSharp.OrderingRules", "SA1204:StaticElementsMustAppearBeforeInstanceElements", Justification = "Reviewed. Suppression is OK here. Better readability.")]
-    [SuppressMessage("StyleCop.CSharp.ReadabilityRules", "SA1124:DoNotUseRegions", Justification = "Reviewed. Suppression is OK here. Better readability.")]
-    internal abstract class EndianBitConverter
+    internal abstract partial class EndianBitConverter
     {
-        #region Endianness of this converter
-
         /// <summary>
-        /// Indicates the byte order ("endianness") in which data is converted using this class.
+        /// The little-endian bit converter.
         /// </summary>
-        /// <remarks>
-        /// Different computer architectures store data using different byte orders. "Big-endian"
-        /// means the most significant byte is on the left end of a word. "Little-endian" means the
-        /// most significant byte is on the right end of a word.
-        /// </remarks>
-        /// <returns>true if this converter is little-endian, false otherwise.</returns>
-        public abstract bool IsLittleEndian();
+        public static readonly LittleEndianBitConverter LittleEndianConverter = new LittleEndianBitConverter();
 
         /// <summary>
-        /// Gets the byte order ("endianness") in which data is converted using this class.
+        /// The big-endian bit converter.
         /// </summary>
-        public abstract Endianness Endianness { get; }
-        #endregion
-
-        #region Factory properties
+        public static readonly BigEndianBitConverter BigEndianConverter = new BigEndianBitConverter();
 
         /// <summary>
-        /// The little-endian bit converter.
+        /// Gets the byte order ("endianness") in which data is converted using this class.
         /// </summary>
-        private static readonly LittleEndianBitConverter LittleConverter = new LittleEndianBitConverter();
+        public abstract Endianness Endianness { get; }
 
         /// <summary>
-        /// The big-endian bit converter.
+        /// Gets a value indicating whether the byte order ("endianness") in which data is converted is little endian.
         /// </summary>
-        private static readonly BigEndianBitConverter BigConverter = new BigEndianBitConverter();
+        /// <remarks>
+        /// Different computer architectures store data using different byte orders. "Big-endian"
+        /// means the most significant byte is on the left end of a word. "Little-endian" means the
+        /// most significant byte is on the right end of a word.
+        /// </remarks>
+        public abstract bool IsLittleEndian { get; }
 
         /// <summary>
         /// Gets the converter.
         /// </summary>
         /// <param name="endianness">The endianness.</param>
         /// <returns>an <see cref="EndianBitConverter"/></returns>
-        /// <exception cref="System.ArgumentException">Not a valid form of Endianness - endianness</exception>
-        internal static EndianBitConverter GetConverter(Endianness endianness)
+        /// <exception cref="ArgumentException">Not a valid form of Endianness - endianness</exception>
+        public static EndianBitConverter GetConverter(Endianness endianness)
         {
             switch (endianness)
             {
                 case Endianness.LittleEndian:
-                    return LittleConverter;
+                    return LittleEndianConverter;
                 case Endianness.BigEndian:
-                    return BigConverter;
+                    return BigEndianConverter;
                 default:
                     throw new ArgumentException("Not a valid form of Endianness", nameof(endianness));
             }
         }
-        #endregion
-
-        #region Double/primitive conversions
-
-        /// <summary>
-        /// Converts the specified double-precision floating point number to a
-        /// 64-bit signed integer. Note: the endianness of this converter does not
-        /// affect the returned value.
-        /// </summary>
-        /// <param name="value">The number to convert. </param>
-        /// <returns>A 64-bit signed integer whose value is equivalent to value.</returns>
-        public long DoubleToInt64Bits(double value)
-        {
-            return BitConverter.DoubleToInt64Bits(value);
-        }
-
-        /// <summary>
-        /// Converts the specified 64-bit signed integer to a double-precision
-        /// floating point number. Note: the endianness of this converter does not
-        /// affect the returned value.
-        /// </summary>
-        /// <param name="value">The number to convert. </param>
-        /// <returns>A double-precision floating point number whose value is equivalent to value.</returns>
-        public double Int64BitsToDouble(long value)
-        {
-            return BitConverter.Int64BitsToDouble(value);
-        }
-
-        /// <summary>
-        /// Converts the specified single-precision floating point number to a
-        /// 32-bit signed integer. Note: the endianness of this converter does not
-        /// affect the returned value.
-        /// </summary>
-        /// <param name="value">The number to convert. </param>
-        /// <returns>A 32-bit signed integer whose value is equivalent to value.</returns>
-        public int SingleToInt32Bits(float value)
-        {
-            return new Int32SingleUnion(value).AsInt32;
-        }
-
-        /// <summary>
-        /// Converts the specified 32-bit signed integer to a single-precision floating point
-        /// number. Note: the endianness of this converter does not
-        /// affect the returned value.
-        /// </summary>
-        /// <param name="value">The number to convert. </param>
-        /// <returns>A single-precision floating point number whose value is equivalent to value.</returns>
-        public float Int32BitsToSingle(int value)
-        {
-            return new Int32SingleUnion(value).AsSingle;
-        }
-        #endregion
-
-        #region To(PrimitiveType) conversions
-
-        /// <summary>
-        /// Returns a Boolean value converted from one byte at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>true if the byte at startIndex in value is nonzero; otherwise, false.</returns>
-        public bool ToBoolean(byte[] value, int startIndex)
-        {
-            CheckByteArgument(value, startIndex, 1);
-            return BitConverter.ToBoolean(value, startIndex);
-        }
-
-        /// <summary>
-        /// Returns a Unicode character converted from two bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A character formed by two bytes beginning at startIndex.</returns>
-        public char ToChar(byte[] value, int startIndex)
-        {
-            return unchecked((char)this.CheckedFromBytes(value, startIndex, 2));
-        }
-
-        /// <summary>
-        /// Returns a double-precision floating point number converted from eight bytes
-        /// at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A double precision floating point number formed by eight bytes beginning at startIndex.</returns>
-        public double ToDouble(byte[] value, int startIndex)
-        {
-            return this.Int64BitsToDouble(this.ToInt64(value, startIndex));
-        }
-
-        /// <summary>
-        /// Returns a single-precision floating point number converted from four bytes
-        /// at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A single precision floating point number formed by four bytes beginning at startIndex.</returns>
-        public float ToSingle(byte[] value, int startIndex)
-        {
-            return this.Int32BitsToSingle(this.ToInt32(value, startIndex));
-        }
-
-        /// <summary>
-        /// Returns a 16-bit signed integer converted from two bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 16-bit signed integer formed by two bytes beginning at startIndex.</returns>
-        public short ToInt16(byte[] value, int startIndex)
-        {
-            return unchecked((short)this.CheckedFromBytes(value, startIndex, 2));
-        }
-
-        /// <summary>
-        /// Returns a 32-bit signed integer converted from four bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 32-bit signed integer formed by four bytes beginning at startIndex.</returns>
-        public int ToInt32(byte[] value, int startIndex)
-        {
-            return unchecked((int)this.CheckedFromBytes(value, startIndex, 4));
-        }
-
-        /// <summary>
-        /// Returns a 64-bit signed integer converted from eight bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 64-bit signed integer formed by eight bytes beginning at startIndex.</returns>
-        public long ToInt64(byte[] value, int startIndex)
-        {
-            return this.CheckedFromBytes(value, startIndex, 8);
-        }
-
-        /// <summary>
-        /// Returns a 16-bit unsigned integer converted from two bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 16-bit unsigned integer formed by two bytes beginning at startIndex.</returns>
-        public ushort ToUInt16(byte[] value, int startIndex)
-        {
-            return unchecked((ushort)this.CheckedFromBytes(value, startIndex, 2));
-        }
-
-        /// <summary>
-        /// Returns a 32-bit unsigned integer converted from four bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 32-bit unsigned integer formed by four bytes beginning at startIndex.</returns>
-        public uint ToUInt32(byte[] value, int startIndex)
-        {
-            return unchecked((uint)this.CheckedFromBytes(value, startIndex, 4));
-        }
-
-        /// <summary>
-        /// Returns a 64-bit unsigned integer converted from eight bytes at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A 64-bit unsigned integer formed by eight bytes beginning at startIndex.</returns>
-        public ulong ToUInt64(byte[] value, int startIndex)
-        {
-            return unchecked((ulong)this.CheckedFromBytes(value, startIndex, 8));
-        }
-
-        /// <summary>
-        /// Convert the given number of bytes from the given array, from the given start
-        /// position, into a long, using the bytes as the least significant part of the long.
-        /// By the time this is called, the arguments have been checked for validity.
-        /// </summary>
-        /// <param name="value">The bytes to convert</param>
-        /// <param name="startIndex">The index of the first byte to convert</param>
-        /// <param name="bytesToConvert">The number of bytes to use in the conversion</param>
-        /// <returns>The converted number</returns>
-        protected internal abstract long FromBytes(byte[] value, int startIndex, int bytesToConvert);
-
-        /// <summary>
-        /// Checks the given argument for validity.
-        /// </summary>
-        /// <param name="value">The byte array passed in</param>
-        /// <param name="startIndex">The start index passed in</param>
-        /// <param name="bytesRequired">The number of bytes required</param>
-        /// <exception cref="System.ArgumentNullException">value is a null reference</exception>
-        /// <exception cref="System.ArgumentOutOfRangeException">
-        /// startIndex is less than zero or greater than the length of value minus bytesRequired.
-        /// </exception>
-        [SuppressMessage("ReSharper", "UnusedParameter.Local", Justification = "Keeps code DRY")]
-        private static void CheckByteArgument(byte[] value, int startIndex, int bytesRequired)
-        {
-            if (value == null)
-            {
-                throw new ArgumentNullException(nameof(value));
-            }
-
-            if (startIndex < 0 || startIndex > value.Length - bytesRequired)
-            {
-                throw new ArgumentOutOfRangeException(nameof(startIndex));
-            }
-        }
-
-        /// <summary>
-        /// Checks the arguments for validity before calling FromBytes
-        /// (which can therefore assume the arguments are valid).
-        /// </summary>
-        /// <param name="value">The bytes to convert after checking</param>
-        /// <param name="startIndex">The index of the first byte to convert</param>
-        /// <param name="bytesToConvert">The number of bytes to convert</param>
-        /// <returns>The <see cref="long"/></returns>
-        private long CheckedFromBytes(byte[] value, int startIndex, int bytesToConvert)
-        {
-            CheckByteArgument(value, startIndex, bytesToConvert);
-            return this.FromBytes(value, startIndex, bytesToConvert);
-        }
-        #endregion
-
-        #region ToString conversions
 
         /// <summary>
         /// Returns a String converted from the elements of a byte array.
@@ -336,406 +101,29 @@ namespace ImageSharp.IO
         {
             return BitConverter.ToString(value, startIndex, length);
         }
-        #endregion
-
-        #region Decimal conversions
 
         /// <summary>
-        /// Returns a decimal value converted from sixteen bytes
-        /// at a specified position in a byte array.
-        /// </summary>
-        /// <param name="value">An array of bytes.</param>
-        /// <param name="startIndex">The starting position within value.</param>
-        /// <returns>A decimal  formed by sixteen bytes beginning at startIndex.</returns>
-        public decimal ToDecimal(byte[] value, int startIndex)
-        {
-            // HACK: This always assumes four parts, each in their own endianness,
-            // starting with the first part at the start of the byte array.
-            // On the other hand, there's no real format specified...
-            int[] parts = new int[4];
-            for (int i = 0; i < 4; i++)
-            {
-                parts[i] = this.ToInt32(value, startIndex + (i * 4));
-            }
-
-            return new decimal(parts);
-        }
-
-        /// <summary>
-        /// Returns the specified decimal value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 16.</returns>
-        public byte[] GetBytes(decimal value)
-        {
-            byte[] bytes = new byte[16];
-            int[] parts = decimal.GetBits(value);
-            for (int i = 0; i < 4; i++)
-            {
-                this.CopyBytesImpl(parts[i], 4, bytes, i * 4);
-            }
-
-            return bytes;
-        }
-
-        /// <summary>
-        /// Copies the specified decimal value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">A character to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(decimal value, byte[] buffer, int index)
-        {
-            int[] parts = decimal.GetBits(value);
-            for (int i = 0; i < 4; i++)
-            {
-                this.CopyBytesImpl(parts[i], 4, buffer, (i * 4) + index);
-            }
-        }
-        #endregion
-
-        #region GetBytes conversions
-
-        /// <summary>
-        /// Returns an array with the given number of bytes formed
-        /// from the least significant bytes of the specified value.
-        /// This is used to implement the other GetBytes methods.
-        /// </summary>
-        /// <param name="value">The value to get bytes for</param>
-        /// <param name="bytes">The number of significant bytes to return</param>
-        /// <returns>
-        /// The <see cref="T:byte[]"/>.
-        /// </returns>
-        private byte[] GetBytes(long value, int bytes)
-        {
-            byte[] buffer = new byte[bytes];
-            this.CopyBytes(value, bytes, buffer, 0);
-            return buffer;
-        }
-
-        /// <summary>
-        /// Returns the specified Boolean value as an array of bytes.
-        /// </summary>
-        /// <param name="value">A Boolean value.</param>
-        /// <returns>An array of bytes with length 1.</returns>
-        /// <returns>
-        /// The <see cref="T:byte[]"/>.
-        /// </returns>
-        public byte[] GetBytes(bool value)
-        {
-            return BitConverter.GetBytes(value);
-        }
-
-        /// <summary>
-        /// Returns the specified Unicode character value as an array of bytes.
-        /// </summary>
-        /// <param name="value">A character to convert.</param>
-        /// <returns>An array of bytes with length 2.</returns>
-        /// <returns>
-        /// The <see cref="T:byte[]"/>.
-        /// </returns>
-        public byte[] GetBytes(char value)
-        {
-            return this.GetBytes(value, 2);
-        }
-
-        /// <summary>
-        /// Returns the specified double-precision floating point value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 8.</returns>
-        public byte[] GetBytes(double value)
-        {
-            return this.GetBytes(this.DoubleToInt64Bits(value), 8);
-        }
-
-        /// <summary>
-        /// Returns the specified 16-bit signed integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 2.</returns>
-        public byte[] GetBytes(short value)
-        {
-            return this.GetBytes(value, 2);
-        }
-
-        /// <summary>
-        /// Returns the specified 32-bit signed integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 4.</returns>
-        public byte[] GetBytes(int value)
-        {
-            return this.GetBytes(value, 4);
-        }
-
-        /// <summary>
-        /// Returns the specified 64-bit signed integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 8.</returns>
-        public byte[] GetBytes(long value)
-        {
-            return this.GetBytes(value, 8);
-        }
-
-        /// <summary>
-        /// Returns the specified single-precision floating point value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 4.</returns>
-        public byte[] GetBytes(float value)
-        {
-            return this.GetBytes(this.SingleToInt32Bits(value), 4);
-        }
-
-        /// <summary>
-        /// Returns the specified 16-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 2.</returns>
-        public byte[] GetBytes(ushort value)
-        {
-            return this.GetBytes(value, 2);
-        }
-
-        /// <summary>
-        /// Returns the specified 32-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 4.</returns>
-        public byte[] GetBytes(uint value)
-        {
-            return this.GetBytes(value, 4);
-        }
-
-        /// <summary>
-        /// Returns the specified 64-bit unsigned integer value as an array of bytes.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <returns>An array of bytes with length 8.</returns>
-        public byte[] GetBytes(ulong value)
-        {
-            return this.GetBytes(unchecked((long)value), 8);
-        }
-
-        #endregion
-
-        #region CopyBytes conversions
-
-        /// <summary>
-        /// Copies the given number of bytes from the least-specific
-        /// end of the specified value into the specified byte array, beginning
-        /// at the specified index.
-        /// This is used to implement the other CopyBytes methods.
-        /// </summary>
-        /// <param name="value">The value to copy bytes for</param>
-        /// <param name="bytes">The number of significant bytes to copy</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        private void CopyBytes(long value, int bytes, byte[] buffer, int index)
-        {
-            if (buffer == null)
-            {
-                throw new ArgumentNullException(nameof(buffer), "Byte array must not be null");
-            }
-
-            if (buffer.Length < index + bytes)
-            {
-                throw new ArgumentOutOfRangeException(nameof(buffer), "Buffer not big enough for value");
-            }
-
-            this.CopyBytesImpl(value, bytes, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the given number of bytes from the least-specific
-        /// end of the specified value into the specified byte array, beginning
-        /// at the specified index.
-        /// This must be implemented in concrete derived classes, but the implementation
-        /// may assume that the value will fit into the buffer.
-        /// </summary>
-        /// <param name="value">The value to copy bytes for</param>
-        /// <param name="bytes">The number of significant bytes to copy</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        protected internal abstract void CopyBytesImpl(long value, int bytes, byte[] buffer, int index);
-
-        /// <summary>
-        /// Copies the specified Boolean value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">A Boolean value.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(bool value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value ? 1 : 0, 1, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified Unicode character value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">A character to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(char value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 2, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified double-precision floating point value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(double value, byte[] buffer, int index)
-        {
-            this.CopyBytes(this.DoubleToInt64Bits(value), 8, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 16-bit signed integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(short value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 2, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 32-bit signed integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(int value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 4, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 64-bit signed integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(long value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 8, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified single-precision floating point value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(float value, byte[] buffer, int index)
-        {
-            this.CopyBytes(this.SingleToInt32Bits(value), 4, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 16-bit unsigned integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(ushort value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 2, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 32-bit unsigned integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(uint value, byte[] buffer, int index)
-        {
-            this.CopyBytes(value, 4, buffer, index);
-        }
-
-        /// <summary>
-        /// Copies the specified 64-bit unsigned integer value into the specified byte array,
-        /// beginning at the specified index.
-        /// </summary>
-        /// <param name="value">The number to convert.</param>
-        /// <param name="buffer">The byte array to copy the bytes into</param>
-        /// <param name="index">The first index into the array to copy the bytes into</param>
-        public void CopyBytes(ulong value, byte[] buffer, int index)
-        {
-            this.CopyBytes(unchecked((long)value), 8, buffer, index);
-        }
-
-        #endregion
-
-        #region Private struct used for Single/Int32 conversions
-
-        /// <summary>
-        /// Union used solely for the equivalent of DoubleToInt64Bits and vice versa.
+        /// Checks the given argument for validity.
         /// </summary>
-        [StructLayout(LayoutKind.Explicit)]
-        private struct Int32SingleUnion
+        /// <param name="value">The byte array passed in</param>
+        /// <param name="startIndex">The start index passed in</param>
+        /// <param name="bytesRequired">The number of bytes required</param>
+        /// <exception cref="ArgumentNullException">value is a null reference</exception>
+        /// <exception cref="ArgumentOutOfRangeException">
+        /// startIndex is less than zero or greater than the length of value minus bytesRequired.
+        /// </exception>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected static void CheckByteArgument(byte[] value, int startIndex, int bytesRequired)
         {
-            /// <summary>
-            /// Int32 version of the value.
-            /// </summary>
-            [FieldOffset(0)]
-            private readonly int i;
-
-            /// <summary>
-            /// Single version of the value.
-            /// </summary>
-            [FieldOffset(0)]
-            private readonly float f;
-
-            /// <summary>
-            /// Initializes a new instance of the <see cref="Int32SingleUnion"/> struct.
-            /// </summary>
-            /// <param name="i">The integer value of the new instance.</param>
-            internal Int32SingleUnion(int i)
+            if (value == null)
             {
-                this.f = 0; // Just to keep the compiler happy
-                this.i = i;
+                throw new ArgumentNullException(nameof(value));
             }
 
-            /// <summary>
-            /// Initializes a new instance of the <see cref="Int32SingleUnion"/> struct.
-            /// </summary>
-            /// <param name="f">
-            /// The floating point value of the new instance.
-            /// </param>
-            internal Int32SingleUnion(float f)
+            if (startIndex < 0 || startIndex > value.Length - bytesRequired)
             {
-                this.i = 0; // Just to keep the compiler happy
-                this.f = f;
+                throw new ArgumentOutOfRangeException(nameof(startIndex));
             }
-
-            /// <summary>
-            /// Gets the value of the instance as an integer.
-            /// </summary>
-            internal int AsInt32 => this.i;
-
-            /// <summary>
-            /// Gets the value of the instance as a floating point number.
-            /// </summary>
-            internal float AsSingle => this.f;
         }
-        #endregion
     }
-}
+}

src/ImageSharp/IO/LittleEndianBitConverter.cs

@@ -6,42 +6,78 @@
 namespace ImageSharp.IO
 {
     /// <summary>
-    /// Implementation of EndianBitConverter which converts to/from little-endian
-    /// byte arrays.
-    /// <remarks>
-    /// Adapted from Miscellaneous Utility Library <see href="http://jonskeet.uk/csharp/miscutil/"/>
-    /// This product includes software developed by Jon Skeet and Marc Gravell. Contact <see href="mailto:skeet@pobox.com"/>, or see
-    /// <see href="http://www.pobox.com/~skeet/"/>.
-    /// </remarks>
+    /// Implementation of EndianBitConverter which converts to/from little-endian byte arrays.
     /// </summary>
     internal sealed class LittleEndianBitConverter : EndianBitConverter
     {
         /// <inheritdoc/>
-        public override Endianness Endianness => Endianness.LittleEndian;
+        public override Endianness Endianness
+        {
+            get { return Endianness.LittleEndian; }
+        }
+
+        /// <inheritdoc/>
+        public override bool IsLittleEndian
+        {
+            get { return true; }
+        }
+
+        /// <inheritdoc/>
+        public override void CopyBytes(short value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 2);
+
+            buffer[index + 1] = (byte)(value >> 8);
+            buffer[index] = (byte)value;
+        }
 
         /// <inheritdoc/>
-        public override bool IsLittleEndian() => true;
+        public override void CopyBytes(int value, byte[] buffer, int index)
+        {
+            CheckByteArgument(buffer, index, 4);
+
+            buffer[index + 3] = (byte)(value >> 24);
+            buffer[index + 2] = (byte)(value >> 16);
+            buffer[index + 1] = (byte)(value >> 8);
+            buffer[index] = (byte)value;
+        }
 
         /// <inheritdoc/>
-        protected internal override void CopyBytesImpl(long value, int bytes, byte[] buffer, int index)
+        public override void CopyBytes(long value, byte[] buffer, int index)
         {
-            for (int i = 0; i < bytes; i++)
-            {
-                buffer[i + index] = unchecked((byte)(value & 0xff));
-                value = value >> 8;
-            }
+            CheckByteArgument(buffer, index, 8);
+
+            buffer[index + 7] = (byte)(value >> 56);
+            buffer[index + 6] = (byte)(value >> 48);
+            buffer[index + 5] = (byte)(value >> 40);
+            buffer[index + 4] = (byte)(value >> 32);
+            buffer[index + 3] = (byte)(value >> 24);
+            buffer[index + 2] = (byte)(value >> 16);
+            buffer[index + 1] = (byte)(value >> 8);
+            buffer[index] = (byte)value;
         }
 
         /// <inheritdoc/>
-        protected internal override long FromBytes(byte[] buffer, int startIndex, int bytesToConvert)
+        public unsafe override short ToInt16(byte[] value, int startIndex)
         {
-            long ret = 0;
-            for (int i = 0; i < bytesToConvert; i++)
-            {
-                ret = unchecked((ret << 8) | buffer[startIndex + bytesToConvert - 1 - i]);
-            }
+            CheckByteArgument(value, startIndex, 2);
+            return (short)((value[1] << 8) | value[0]);
+        }
 
-            return ret;
+        /// <inheritdoc/>
+        public unsafe override int ToInt32(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 4);
+            return (value[3] << 24) | (value[2] << 16) | (value[1] << 8) | value[0];
+        }
+
+        /// <inheritdoc/>
+        public unsafe override long ToInt64(byte[] value, int startIndex)
+        {
+            CheckByteArgument(value, startIndex, 8);
+            long p1 = (value[7] << 24) | (value[6] << 16) | (value[5] << 8) | value[4];
+            long p2 = (value[3] << 24) | (value[2] << 16) | (value[1] << 8) | value[0];
+            return p2 | (p1 << 32);
         }
     }
 }

tests/ImageSharp.Tests/IO/BigEndianBitConverter.CopyBytesTests.cs

@@ -0,0 +1,230 @@
+// <copyright file="BigEndianBitConverter.CopyBytesTests.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Tests.IO
+{
+    using System;
+    using ImageSharp.IO;
+    using Xunit;
+
+    /// <summary>
+    /// The <see cref="BigEndianBitConverter"/> tests.
+    /// </summary>
+    public class BigEndianBitConverterCopyBytesTests
+    {
+        [Fact]
+        public void CopyToWithNullBufferThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(false, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((short)42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ushort)42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42u, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42L, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ulong)42L, null, 0));
+        }
+
+        [Fact]
+        public void CopyToWithIndexTooBigThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(false, new byte[1], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((short)42, new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ushort)42, new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42, new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42u, new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42L, new byte[8], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ulong)42L, new byte[8], 1));
+        }
+
+        [Fact]
+        public void CopyToWithBufferTooSmallThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(false, new byte[0], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((short)42, new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ushort)42, new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42, new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42u, new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes(42L, new byte[7], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.CopyBytes((ulong)42L, new byte[7], 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesBoolean()
+        {
+            byte[] buffer = new byte[1];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes(false, buffer, 0);
+            this.CheckBytes(new byte[] { 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(true, buffer, 0);
+            this.CheckBytes(new byte[] { 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="short"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesShort()
+        {
+            byte[] buffer = new byte[2];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes((short)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((short)1, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((short)256, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((short)-1, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((short)257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesUShort()
+        {
+            byte[] buffer = new byte[2];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes((ushort)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((ushort)1, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((ushort)256, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(ushort.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((ushort)257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="int"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesInt()
+        {
+            byte[] buffer = new byte[4];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes(0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(65536, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(16777216, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(-1, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(257, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="uint"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesUInt()
+        {
+            byte[] buffer = new byte[4];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)1, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)65536, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)16777216, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(uint.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes((uint)257, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="long"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesLong()
+        {
+            byte[] buffer = new byte[8];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes(0L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(256L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(65536L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(16777216L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(4294967296L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776L * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776L * 256 * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(-1L, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(257L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ulong"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesULong()
+        {
+            byte[] buffer = new byte[8];
+
+            EndianBitConverter.BigEndianConverter.CopyBytes(0UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(256UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(65536UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(16777216UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(4294967296UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776UL * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(1099511627776UL * 256 * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(ulong.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.BigEndianConverter.CopyBytes(257UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests the two byte arrays for equality.
+        /// </summary>
+        /// <param name="expected">The expected bytes.</param>
+        /// <param name="actual">The actual bytes.</param>
+        private void CheckBytes(byte[] expected, byte[] actual)
+        {
+            Assert.Equal(expected.Length, actual.Length);
+            Assert.Equal(expected, actual);
+        }
+    }
+}

tests/ImageSharp.Tests/IO/BigEndianBitConverterTests.cs → tests/ImageSharp.Tests/IO/BigEndianBitConverter.GetBytesTests.cs

@@ -1,4 +1,4 @@
-// <copyright file="BigEndianBitConverterTests.cs" company="James Jackson-South">
+// <copyright file="BigEndianBitConverter.GetBytesTests.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -6,25 +6,47 @@
 namespace ImageSharp.Tests.IO
 {
     using ImageSharp.IO;
-
     using Xunit;
 
     /// <summary>
     /// The <see cref="BigEndianBitConverter"/> tests.
     /// </summary>
-    public class BigEndianBitConverterTests
+    public class BigEndianBitConverterGetBytesTests
     {
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void GetBytesBoolean()
+        {
+            this.CheckBytes(new byte[] { 0 }, EndianBitConverter.BigEndianConverter.GetBytes(false));
+            this.CheckBytes(new byte[] { 1 }, EndianBitConverter.BigEndianConverter.GetBytes(true));
+        }
+
         /// <summary>
         /// Tests that passing a <see cref="short"/> returns the correct bytes.
         /// </summary>
         [Fact]
         public void GetBytesShort()
         {
-            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((short)0));
-            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((short)1));
-            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((short)256));
-            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((short)-1));
-            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((short)257));
+            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((short)0));
+            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((short)1));
+            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((short)256));
+            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes((short)-1));
+            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((short)257));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void GetBytesUShort()
+        {
+            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((ushort)0));
+            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((ushort)1));
+            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((ushort)256));
+            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes(ushort.MaxValue));
+            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((ushort)257));
         }
 
         /// <summary>
@@ -33,13 +55,13 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesInt()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)0));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)1));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)256));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)65536));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)16777216));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)-1));
-            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((int)257));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(0));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(1));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(256));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(65536));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(16777216));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes(-1));
+            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(257));
         }
 
         /// <summary>
@@ -48,13 +70,13 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesUInt()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)0));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)1));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)256));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)65536));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)16777216));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)uint.MaxValue));
-            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes((uint)257));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)0));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)1));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)256));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)65536));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)16777216));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes(uint.MaxValue));
+            this.CheckBytes(new byte[] { 0, 0, 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes((uint)257));
         }
 
         /// <summary>
@@ -63,17 +85,17 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesLong()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(0L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(256L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(65536L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(16777216L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(4294967296L));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776L));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776L * 256));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776L * 256 * 256));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(-1L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(257L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(0L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(1L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(256L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(65536L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(16777216L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(4294967296L));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776L));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776L * 256));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776L * 256 * 256));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes(-1L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(257L));
         }
 
         /// <summary>
@@ -82,17 +104,17 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesULong()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(0UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(256UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(65536UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(16777216UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(4294967296UL));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776UL));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776UL * 256));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(1099511627776UL * 256 * 256));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(ulong.MaxValue));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, EndianBitConverter.GetConverter(Endianness.BigEndian).GetBytes(257UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(0UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(1UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(256UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(65536UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(16777216UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(4294967296UL));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776UL));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776UL * 256));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.BigEndianConverter.GetBytes(1099511627776UL * 256 * 256));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.BigEndianConverter.GetBytes(ulong.MaxValue));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, EndianBitConverter.BigEndianConverter.GetBytes(257UL));
         }
 
         /// <summary>

tests/ImageSharp.Tests/IO/BigEndianBitConverter.ToTypeTests.cs

@@ -0,0 +1,158 @@
+// <copyright file="BigEndianBitConverter.ToTypeTests.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Tests.IO
+{
+    using System;
+    using ImageSharp.IO;
+    using Xunit;
+
+    /// <summary>
+    /// The <see cref="BigEndianBitConverter"/> tests.
+    /// </summary>
+    public class BigEndianBitConverterTests
+    {
+        [Fact]
+        public void CopyToWithNullBufferThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToBoolean(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToInt16(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToUInt16(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToInt32(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToUInt32(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToInt64(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.BigEndianConverter.ToUInt64(null, 0));
+        }
+
+        [Fact]
+        public void CopyToWithIndexTooBigThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToBoolean(new byte[1], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt16(new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt16(new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt32(new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt32(new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt64(new byte[8], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt64(new byte[8], 1));
+        }
+
+        [Fact]
+        public void CopyToWithBufferTooSmallThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToBoolean(new byte[0], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt16(new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt16(new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt32(new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt32(new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToInt64(new byte[7], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.BigEndianConverter.ToUInt64(new byte[7], 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToBoolean()
+        {
+            Assert.Equal(false, EndianBitConverter.BigEndianConverter.ToBoolean(new byte[] { 0 }, 0));
+            Assert.Equal(true, EndianBitConverter.BigEndianConverter.ToBoolean(new byte[] { 1 }, 0));
+            Assert.Equal(true, EndianBitConverter.BigEndianConverter.ToBoolean(new byte[] { 42 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="short"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt16()
+        {
+            Assert.Equal((short)0, EndianBitConverter.BigEndianConverter.ToInt16(new byte[] { 0, 0 }, 0));
+            Assert.Equal((short)1, EndianBitConverter.BigEndianConverter.ToInt16(new byte[] { 0, 1 }, 0));
+            Assert.Equal((short)256, EndianBitConverter.BigEndianConverter.ToInt16(new byte[] { 1, 0 }, 0));
+            Assert.Equal((short)-1, EndianBitConverter.BigEndianConverter.ToInt16(new byte[] { 255, 255 }, 0));
+            Assert.Equal((short)257, EndianBitConverter.BigEndianConverter.ToInt16(new byte[] { 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToUInt16()
+        {
+            Assert.Equal((ushort)0, EndianBitConverter.BigEndianConverter.ToUInt16(new byte[] { 0, 0 }, 0));
+            Assert.Equal((ushort)1, EndianBitConverter.BigEndianConverter.ToUInt16(new byte[] { 0, 1 }, 0));
+            Assert.Equal((ushort)256, EndianBitConverter.BigEndianConverter.ToUInt16(new byte[] { 1, 0 }, 0));
+            Assert.Equal(ushort.MaxValue, EndianBitConverter.BigEndianConverter.ToUInt16(new byte[] { 255, 255 }, 0));
+            Assert.Equal((ushort)257, EndianBitConverter.BigEndianConverter.ToUInt16(new byte[] { 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="int"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt32()
+        {
+            Assert.Equal(0, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 0, 0, 0, 0 }, 0));
+            Assert.Equal(1, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 0, 0, 0, 1 }, 0));
+            Assert.Equal(256, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 0, 0, 1, 0 }, 0));
+            Assert.Equal(65536, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 0, 1, 0, 0 }, 0));
+            Assert.Equal(16777216, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 1, 0, 0, 0 }, 0));
+            Assert.Equal(-1, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 255, 255, 255, 255 }, 0));
+            Assert.Equal(257, EndianBitConverter.BigEndianConverter.ToInt32(new byte[] { 0, 0, 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="uint"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToUInt32()
+        {
+            Assert.Equal((uint)0, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 0, 0, 0, 0 }, 0));
+            Assert.Equal((uint)1, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 0, 0, 0, 1 }, 0));
+            Assert.Equal((uint)256, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 0, 0, 1, 0 }, 0));
+            Assert.Equal((uint)65536, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 0, 1, 0, 0 }, 0));
+            Assert.Equal((uint)16777216, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 1, 0, 0, 0 }, 0));
+            Assert.Equal(uint.MaxValue, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 255, 255, 255, 255 }, 0));
+            Assert.Equal((uint)257, EndianBitConverter.BigEndianConverter.ToUInt32(new byte[] { 0, 0, 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="long"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt64()
+        {
+            Assert.Equal(0L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, 0));
+            Assert.Equal(256L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, 0));
+            Assert.Equal(65536L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, 0));
+            Assert.Equal(16777216L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, 0));
+            Assert.Equal(4294967296L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776L * 256, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776L * 256 * 256, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(-1L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, 0));
+            Assert.Equal(257L, EndianBitConverter.BigEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ulong"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void GetBytesULong()
+        {
+            Assert.Equal(0UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, 0));
+            Assert.Equal(256UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, 0));
+            Assert.Equal(65536UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, 0));
+            Assert.Equal(16777216UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, 0));
+            Assert.Equal(4294967296UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776UL * 256, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776UL * 256 * 256, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(ulong.MaxValue, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, 0));
+            Assert.Equal(257UL, EndianBitConverter.BigEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 1 }, 0));
+        }
+    }
+}

tests/ImageSharp.Tests/IO/LittleEndianBitConverter.CopyBytesTests.cs

@@ -0,0 +1,230 @@
+// <copyright file="LittleEndianBitConverter.CopyBytesTests.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Tests.IO
+{
+    using System;
+    using ImageSharp.IO;
+    using Xunit;
+
+    /// <summary>
+    /// The <see cref="LittleEndianBitConverter"/> tests.
+    /// </summary>
+    public class LittleEndianBitConverterCopyBytesTests
+    {
+        [Fact]
+        public void CopyToWithNullBufferThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(false, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((short)42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42u, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42L, null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ulong)42L, null, 0));
+        }
+
+        [Fact]
+        public void CopyToWithIndexTooBigThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(false, new byte[1], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((short)42, new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)42, new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42, new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42u, new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42L, new byte[8], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ulong)42L, new byte[8], 1));
+        }
+
+        [Fact]
+        public void CopyToWithBufferTooSmallThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(false, new byte[0], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((short)42, new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)42, new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42, new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42u, new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes(42L, new byte[7], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.CopyBytes((ulong)42L, new byte[7], 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesBoolean()
+        {
+            byte[] buffer = new byte[1];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes(false, buffer, 0);
+            this.CheckBytes(new byte[] { 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(true, buffer, 0);
+            this.CheckBytes(new byte[] { 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="short"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesShort()
+        {
+            byte[] buffer = new byte[2];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes((short)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((short)1, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((short)256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((short)-1, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((short)257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesUShort()
+        {
+            byte[] buffer = new byte[2];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)1, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(ushort.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((ushort)257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="int"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesInt()
+        {
+            byte[] buffer = new byte[4];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes(0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(65536, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(16777216, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(-1, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="uint"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesUInt()
+        {
+            byte[] buffer = new byte[4];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)0, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)1, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)65536, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)16777216, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(uint.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes((uint)257, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="long"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesLong()
+        {
+            byte[] buffer = new byte[8];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes(0L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1L, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(256L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(65536L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(16777216L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(4294967296L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776L, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776L * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776L * 256 * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(-1L, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(257L, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ulong"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void CopyBytesULong()
+        {
+            byte[] buffer = new byte[8];
+
+            EndianBitConverter.LittleEndianConverter.CopyBytes(0UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1UL, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(256UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(65536UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(16777216UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(4294967296UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776UL, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776UL * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(1099511627776UL * 256 * 256, buffer, 0);
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(ulong.MaxValue, buffer, 0);
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, buffer);
+            EndianBitConverter.LittleEndianConverter.CopyBytes(257UL, buffer, 0);
+            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, buffer);
+        }
+
+        /// <summary>
+        /// Tests the two byte arrays for equality.
+        /// </summary>
+        /// <param name="expected">The expected bytes.</param>
+        /// <param name="actual">The actual bytes.</param>
+        private void CheckBytes(byte[] expected, byte[] actual)
+        {
+            Assert.Equal(expected.Length, actual.Length);
+            Assert.Equal(expected, actual);
+        }
+    }
+}

tests/ImageSharp.Tests/IO/LittleEndianBitConverterTests.cs → tests/ImageSharp.Tests/IO/LittleEndianBitConverter.GetBytesTests.cs

@@ -1,4 +1,4 @@
-// <copyright file="LittleEndianBitConverterTests.cs" company="James Jackson-South">
+// <copyright file="LittleEndianBitConverter.GetBytesTests.cs" company="James Jackson-South">
 // Copyright (c) James Jackson-South and contributors.
 // Licensed under the Apache License, Version 2.0.
 // </copyright>
@@ -6,25 +6,47 @@
 namespace ImageSharp.Tests.IO
 {
     using ImageSharp.IO;
-
     using Xunit;
 
     /// <summary>
     /// The <see cref="LittleEndianBitConverter"/> tests.
     /// </summary>
-    public class LittleEndianBitConverterTests
+    public class LittleEndianBitConverterGetBytesTests
     {
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void GetBytesBoolean()
+        {
+            this.CheckBytes(new byte[] { 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(false));
+            this.CheckBytes(new byte[] { 1 }, EndianBitConverter.LittleEndianConverter.GetBytes(true));
+        }
+
         /// <summary>
         /// Tests that passing a <see cref="short"/> returns the correct bytes.
         /// </summary>
         [Fact]
         public void GetBytesShort()
         {
-            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((short)0));
-            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((short)1));
-            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((short)256));
-            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((short)-1));
-            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((short)257));
+            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((short)0));
+            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((short)1));
+            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes((short)256));
+            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes((short)-1));
+            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes((short)257));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void GetBytesUShort()
+        {
+            this.CheckBytes(new byte[] { 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((ushort)0));
+            this.CheckBytes(new byte[] { 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((ushort)1));
+            this.CheckBytes(new byte[] { 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes((ushort)256));
+            this.CheckBytes(new byte[] { 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes(ushort.MaxValue));
+            this.CheckBytes(new byte[] { 1, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes((ushort)257));
         }
 
         /// <summary>
@@ -33,13 +55,13 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesInt()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)0));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)1));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)256));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)65536));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)16777216));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)-1));
-            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((int)257));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(0));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(256));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(65536));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes(16777216));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes(-1));
+            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(257));
         }
 
         /// <summary>
@@ -48,13 +70,13 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesUInt()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)0));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)1));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)256));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)65536));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)16777216));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)uint.MaxValue));
-            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes((uint)257));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)0));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)1));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)256));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)65536));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)16777216));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes(uint.MaxValue));
+            this.CheckBytes(new byte[] { 1, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes((uint)257));
         }
 
         /// <summary>
@@ -63,17 +85,17 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesLong()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(0L));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1L));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(256L));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(65536L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(16777216L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(4294967296L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776L));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776L * 256));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776L * 256 * 256));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(-1L));
-            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(257L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(0L));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1L));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(256L));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(65536L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(16777216L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(4294967296L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776L));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776L * 256));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776L * 256 * 256));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes(-1L));
+            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(257L));
         }
 
         /// <summary>
@@ -82,17 +104,17 @@ namespace ImageSharp.Tests.IO
         [Fact]
         public void GetBytesULong()
         {
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(0UL));
-            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1UL));
-            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(256UL));
-            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(65536UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(16777216UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(4294967296UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776UL));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776UL * 256));
-            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(1099511627776UL * 256 * 256));
-            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(ulong.MaxValue));
-            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.GetConverter(Endianness.LittleEndian).GetBytes(257UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(0UL));
+            this.CheckBytes(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1UL));
+            this.CheckBytes(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(256UL));
+            this.CheckBytes(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(65536UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(16777216UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(4294967296UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776UL));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776UL * 256));
+            this.CheckBytes(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, EndianBitConverter.LittleEndianConverter.GetBytes(1099511627776UL * 256 * 256));
+            this.CheckBytes(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, EndianBitConverter.LittleEndianConverter.GetBytes(ulong.MaxValue));
+            this.CheckBytes(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, EndianBitConverter.LittleEndianConverter.GetBytes(257UL));
         }
 
         /// <summary>

tests/ImageSharp.Tests/IO/LittleEndianBitConverter.ToTypeTests.cs

@@ -0,0 +1,157 @@
+// <copyright file="LittleEndianBitConverter.ToTypeTests.cs" company="James Jackson-South">
+// Copyright (c) James Jackson-South and contributors.
+// Licensed under the Apache License, Version 2.0.
+// </copyright>
+
+namespace ImageSharp.Tests.IO
+{
+    using System;
+    using ImageSharp.IO;
+    using Xunit;
+
+    /// <summary>
+    /// The <see cref="LittleEndianBitConverter"/> tests.
+    /// </summary>
+    public class LittleEndianBitConverterToTypeTests
+    {
+        [Fact]
+        public void CopyToWithNullBufferThrowsException()
+        {
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToBoolean(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToInt16(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToUInt16(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToInt32(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToUInt32(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToInt64(null, 0));
+            Assert.Throws<ArgumentNullException>(() => EndianBitConverter.LittleEndianConverter.ToUInt64(null, 0));
+        }
+
+        [Fact]
+        public void CopyToWithIndexTooBigThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToBoolean(new byte[1], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt16(new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[2], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt32(new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[4], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt64(new byte[8], 1));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[8], 1));
+        }
+
+        [Fact]
+        public void CopyToWithBufferTooSmallThrowsException()
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToBoolean(new byte[0], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt16(new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[1], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt32(new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[3], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToInt64(new byte[7], 0));
+            Assert.Throws<ArgumentOutOfRangeException>(() => EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[7], 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="bool"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToBoolean()
+        {
+            Assert.Equal(false, EndianBitConverter.LittleEndianConverter.ToBoolean(new byte[] { 0 }, 0));
+            Assert.Equal(true, EndianBitConverter.LittleEndianConverter.ToBoolean(new byte[] { 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="short"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt16()
+        {
+            Assert.Equal((short)0, EndianBitConverter.LittleEndianConverter.ToInt16(new byte[] { 0, 0 }, 0));
+            Assert.Equal((short)1, EndianBitConverter.LittleEndianConverter.ToInt16(new byte[] { 1, 0 }, 0));
+            Assert.Equal((short)256, EndianBitConverter.LittleEndianConverter.ToInt16(new byte[] { 0, 1 }, 0));
+            Assert.Equal((short)-1, EndianBitConverter.LittleEndianConverter.ToInt16(new byte[] { 255, 255 }, 0));
+            Assert.Equal((short)257, EndianBitConverter.LittleEndianConverter.ToInt16(new byte[] { 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ushort"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToUInt16()
+        {
+            Assert.Equal((ushort)0, EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[] { 0, 0 }, 0));
+            Assert.Equal((ushort)1, EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[] { 1, 0 }, 0));
+            Assert.Equal((ushort)256, EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[] { 0, 1 }, 0));
+            Assert.Equal(ushort.MaxValue, EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[] { 255, 255 }, 0));
+            Assert.Equal((ushort)257, EndianBitConverter.LittleEndianConverter.ToUInt16(new byte[] { 1, 1 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="int"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt32()
+        {
+            Assert.Equal(0, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 0, 0, 0, 0 }, 0));
+            Assert.Equal(1, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 1, 0, 0, 0 }, 0));
+            Assert.Equal(256, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 0, 1, 0, 0 }, 0));
+            Assert.Equal(65536, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 0, 0, 1, 0 }, 0));
+            Assert.Equal(16777216, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 0, 0, 0, 1 }, 0));
+            Assert.Equal(-1, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 255, 255, 255, 255 }, 0));
+            Assert.Equal(257, EndianBitConverter.LittleEndianConverter.ToInt32(new byte[] { 1, 1, 0, 0 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="uint"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToUInt32()
+        {
+            Assert.Equal((uint)0, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 0, 0, 0, 0 }, 0));
+            Assert.Equal((uint)1, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 1, 0, 0, 0 }, 0));
+            Assert.Equal((uint)256, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 0, 1, 0, 0 }, 0));
+            Assert.Equal((uint)65536, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 0, 0, 1, 0 }, 0));
+            Assert.Equal((uint)16777216, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 0, 0, 0, 1 }, 0));
+            Assert.Equal(uint.MaxValue, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 255, 255, 255, 255 }, 0));
+            Assert.Equal((uint)257, EndianBitConverter.LittleEndianConverter.ToUInt32(new byte[] { 1, 1, 0, 0 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="long"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToInt64()
+        {
+            Assert.Equal(0L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(256L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(65536L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(16777216L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, 0));
+            Assert.Equal(4294967296L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, 0));
+            Assert.Equal(1099511627776L * 256, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, 0));
+            Assert.Equal(1099511627776L * 256 * 256, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, 0));
+            Assert.Equal(-1L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, 0));
+            Assert.Equal(257L, EndianBitConverter.LittleEndianConverter.ToInt64(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, 0));
+        }
+
+        /// <summary>
+        /// Tests that passing a <see cref="ulong"/> returns the correct bytes.
+        /// </summary>
+        [Fact]
+        public void ToUInt64()
+        {
+            Assert.Equal(0UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(1UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 1, 0, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(256UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 1, 0, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(65536UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 1, 0, 0, 0, 0, 0 }, 0));
+            Assert.Equal(16777216UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 1, 0, 0, 0, 0 }, 0));
+            Assert.Equal(4294967296UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 1, 0, 0, 0 }, 0));
+            Assert.Equal(1099511627776UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 1, 0, 0 }, 0));
+            Assert.Equal(1099511627776UL * 256, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 1, 0 }, 0));
+            Assert.Equal(1099511627776UL * 256 * 256, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 0, 0, 0, 0, 0, 0, 0, 1 }, 0));
+            Assert.Equal(ulong.MaxValue, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 255, 255, 255, 255, 255, 255, 255, 255 }, 0));
+            Assert.Equal(257UL, EndianBitConverter.LittleEndianConverter.ToUInt64(new byte[] { 1, 1, 0, 0, 0, 0, 0, 0 }, 0));
+        }
+    }
+}