diff --git a/src/ByteSizeLib.Tests/BinaryByteSizeTest/ArithmeticMethods.cs b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ArithmeticMethods.cs
new file mode 100644
index 0000000..b59e97c
--- /dev/null
+++ b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ArithmeticMethods.cs
@@ -0,0 +1,145 @@
+using Xunit;
+
+namespace ByteSizeLib.Tests.BinaryByteSizeTests
+{
+    public class ArithmeticMethods
+    {
+        [Fact]
+        public void AddMethod()
+        {
+            var size1 = BinaryByteSize.FromBytes(1);
+            var result = size1.Add(size1);
+
+            Assert.Equal(2, result.Bytes);
+            Assert.Equal(16, result.Bits);
+        }
+
+        [Fact]
+        public void AddBitsMethod()
+        {
+            var size = BinaryByteSize.FromBytes(1).AddBits(8);
+
+            Assert.Equal(2, size.Bytes);
+            Assert.Equal(16, size.Bits);
+        }
+
+        [Fact]
+        public void AddBytesMethod()
+        {
+            var size = BinaryByteSize.FromBytes(1).AddBytes(1);
+
+            Assert.Equal(2, size.Bytes);
+            Assert.Equal(16, size.Bits);
+        }
+
+        [Fact]
+        public void AddKibiBytesMethod()
+        {
+            var size = BinaryByteSize.FromKibiBytes(2).AddKibiBytes(2);
+
+            Assert.Equal(4 * 1024 * 8, size.Bits);
+            Assert.Equal(4 * 1024, size.Bytes);
+            Assert.Equal(4, size.KibiBytes);
+        }
+
+        [Fact]
+        public void AddMebiBytesMethod()
+        {
+            var size = BinaryByteSize.FromMebiBytes(2).AddMebiBytes(2);
+
+            Assert.Equal(4 * 1024 * 1024 * 8, size.Bits);
+            Assert.Equal(4 * 1024 * 1024, size.Bytes);
+            Assert.Equal(4 * 1024, size.KibiBytes);
+            Assert.Equal(4, size.MebiBytes);
+        }
+
+        [Fact]
+        public void AddGibiBytesMethod()
+        {
+            var size = BinaryByteSize.FromGibiBytes(2).AddGibiBytes(2);
+
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 8, size.Bits);
+            Assert.Equal(4d * 1024 * 1024 * 1024, size.Bytes);
+            Assert.Equal(4d * 1024 * 1024, size.KibiBytes);
+            Assert.Equal(4d * 1024, size.MebiBytes);
+            Assert.Equal(4d, size.GibiBytes);
+        }
+
+        [Fact]
+        public void AddTebiBytesMethod()
+        {
+            var size = BinaryByteSize.FromTebiBytes(2).AddTebiBytes(2);
+
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 1024 * 8, size.Bits);
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 1024, size.Bytes);
+            Assert.Equal(4d * 1024 * 1024 * 1024, size.KibiBytes);
+            Assert.Equal(4d * 1024 * 1024, size.MebiBytes);
+            Assert.Equal(4d * 1024, size.GibiBytes);
+            Assert.Equal(4d, size.TebiBytes);
+        }
+
+        [Fact]
+        public void AddPebiBytesMethod()
+        {
+            var size = BinaryByteSize.FromPebiBytes(2).AddPebiBytes(2);
+
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 1024 * 1024 * 8, size.Bits);
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 1024 * 1024, size.Bytes);
+            Assert.Equal(4d * 1024 * 1024 * 1024 * 1024, size.KibiBytes);
+            Assert.Equal(4d * 1024 * 1024 * 1024, size.MebiBytes);
+            Assert.Equal(4d * 1024 * 1024, size.GibiBytes);
+            Assert.Equal(4d * 1024, size.TebiBytes);
+            Assert.Equal(4d, size.PebiBytes);
+        }
+
+        [Fact]
+        public void SubtractMethod()
+        {
+            var size = BinaryByteSize.FromBytes(4).Subtract(BinaryByteSize.FromBytes(2));
+
+            Assert.Equal(16, size.Bits);
+            Assert.Equal(2, size.Bytes);
+        }
+
+        [Fact]
+        public void IncrementOperator()
+        {
+            var size = BinaryByteSize.FromBytes(2);
+            size++;
+
+            Assert.Equal(24, size.Bits);
+            Assert.Equal(3, size.Bytes);
+        }
+
+
+        [Fact]
+        public void MinusOperatorUnary()
+        {
+            var size = BinaryByteSize.FromBytes(2);
+
+            size = -size;
+
+            Assert.Equal(-16, size.Bits);
+            Assert.Equal(-2, size.Bytes);
+        }
+
+        [Fact]
+        public void MinusOperatorBinary()
+        {
+            var size = BinaryByteSize.FromBytes(4) - BinaryByteSize.FromBytes(2);
+
+            Assert.Equal(16, size.Bits);
+            Assert.Equal(2, size.Bytes);
+        }
+
+        [Fact]
+        public void DecrementOperator()
+        {
+            var size = BinaryByteSize.FromBytes(2);
+            size--;
+
+            Assert.Equal(8, size.Bits);
+            Assert.Equal(1, size.Bytes);
+        }
+    }
+}
diff --git a/src/ByteSizeLib.Tests/BinaryByteSizeTest/CreatingMethods.cs b/src/ByteSizeLib.Tests/BinaryByteSizeTest/CreatingMethods.cs
new file mode 100644
index 0000000..10d61cf
--- /dev/null
+++ b/src/ByteSizeLib.Tests/BinaryByteSizeTest/CreatingMethods.cs
@@ -0,0 +1,124 @@
+using Xunit;
+
+namespace ByteSizeLib.Tests.BinaryByteSizeTests
+{
+    public class CreatingMethods
+    {
+        [Fact]
+        public void Constructor()
+        {
+            // Arrange
+            double bytes = 1125899906842624;
+
+            // Act
+            var result = new BinaryByteSize(bytes);
+
+            // Assert
+            Assert.Equal(bytes * 8, result.Bits);
+            Assert.Equal(bytes, result.Bytes);
+            Assert.Equal(bytes / 1024, result.KibiBytes);
+            Assert.Equal(bytes / 1024 / 1024, result.MebiBytes);
+            Assert.Equal(bytes / 1024 / 1024 / 1024, result.GibiBytes);
+            Assert.Equal(bytes / 1024 / 1024 / 1024 / 1024, result.TebiBytes);
+            Assert.Equal(1, result.PebiBytes);
+        }
+
+        [Fact]
+        public void FromBitsMethod()
+        {
+            // Arrange
+            long value = 8;
+
+            // Act
+            var result = BinaryByteSize.FromBits(value);
+
+            // Assert
+            Assert.Equal(8, result.Bits);
+            Assert.Equal(1, result.Bytes);
+        }
+
+        [Fact]
+        public void FromBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromBytes(value);
+
+            // Assert
+            Assert.Equal(12, result.Bits);
+            Assert.Equal(1.5, result.Bytes);
+        }
+
+        [Fact]
+        public void FromKibiBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromKibiBytes(value);
+
+            // Assert
+            Assert.Equal(1536, result.Bytes);
+            Assert.Equal(1.5, result.KibiBytes);
+        }
+
+        [Fact]
+        public void FromMebiBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromMebiBytes(value);
+
+            // Assert
+            Assert.Equal(1572864, result.Bytes);
+            Assert.Equal(1.5, result.MebiBytes);
+        }
+
+        [Fact]
+        public void FromGibiBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromGibiBytes(value);
+
+            // Assert
+            Assert.Equal(1610612736, result.Bytes);
+            Assert.Equal(1.5, result.GibiBytes);
+        }
+
+        [Fact]
+        public void FromTebiBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromTebiBytes(value);
+
+            // Assert
+            Assert.Equal(1649267441664, result.Bytes);
+            Assert.Equal(1.5, result.TebiBytes);
+        }
+
+        [Fact]
+        public void FromPebiBytesMethod()
+        {
+            // Arrange
+            double value = 1.5;
+
+            // Act
+            var result = BinaryByteSize.FromPebiBytes(value);
+
+            // Assert
+            Assert.Equal(1688849860263936, result.Bytes);
+            Assert.Equal(1.5, result.PebiBytes);
+        }
+    }
+}
diff --git a/src/ByteSizeLib.Tests/BinaryByteSizeTest/ParsingMethods.cs b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ParsingMethods.cs
new file mode 100644
index 0000000..15ad9d5
--- /dev/null
+++ b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ParsingMethods.cs
@@ -0,0 +1,220 @@
+using System;
+using System.Globalization;
+using System.Threading;
+using Xunit;
+
+namespace ByteSizeLib.Tests.BinaryByteSizeTests
+{
+    public class ParsingMethods
+    {
+        // Base parsing functionality
+        [Fact]
+        public void Parse()
+        {
+            string val = "1020KiB";
+            var expected = BinaryByteSize.FromKibiBytes(1020);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void TryParse()
+        {
+            string val = "1020KiB";
+            var expected = BinaryByteSize.FromKibiBytes(1020);
+
+            BinaryByteSize resultBinaryByteSize;
+            var resultBool = BinaryByteSize.TryParse(val, out resultBinaryByteSize);
+
+            Assert.True(resultBool);
+            Assert.Equal(expected, resultBinaryByteSize);
+        }
+
+        [Fact]
+        public void ParseDecimalMiB()
+        {
+            string val = "100.5MiB";
+            var expected = BinaryByteSize.FromMebiBytes(100.5);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        // Failure modes
+        [Fact]
+        public void TryParseReturnsFalseOnBadValue()
+        {
+            string val = "Unexpected Value";
+
+            BinaryByteSize resultBinaryByteSize;
+            var resultBool = BinaryByteSize.TryParse(val, out resultBinaryByteSize);
+
+            Assert.False(resultBool);
+            Assert.Equal(new BinaryByteSize(), resultBinaryByteSize);
+        }
+
+        [Fact]
+        public void TryParseReturnsFalseOnMissingMagnitude()
+        {
+            string val = "1000";
+
+            BinaryByteSize resultBinaryByteSize;
+            var resultBool = BinaryByteSize.TryParse(val, out resultBinaryByteSize);
+
+            Assert.False(resultBool);
+            Assert.Equal(new BinaryByteSize(), resultBinaryByteSize);
+        }
+
+        [Fact]
+        public void TryParseReturnsFalseOnMissingValue()
+        {
+            string val = "KiB";
+
+            BinaryByteSize resultBinaryByteSize;
+            var resultBool = BinaryByteSize.TryParse(val, out resultBinaryByteSize);
+
+            Assert.False(resultBool);
+            Assert.Equal(new BinaryByteSize(), resultBinaryByteSize);
+        }
+
+        [Fact]
+        public void TryParseWorksWithLotsOfSpaces()
+        {
+            string val = " 100 KiB ";
+            var expected = BinaryByteSize.FromKibiBytes(100);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParsePartialBits()
+        {
+            string val = "10.5b";
+
+            Assert.Throws<FormatException>(() =>
+                {
+                    BinaryByteSize.Parse(val);
+                });
+        }
+
+
+        // Parse method throws exceptions
+        [Fact]
+        public void ParseThrowsOnInvalid()
+        {
+            string badValue = "Unexpected Value";
+
+            Assert.Throws<FormatException>(() =>
+                {
+                    BinaryByteSize.Parse(badValue);
+                });
+        }
+
+        [Fact]
+        public void ParseThrowsOnNull()
+        {
+            Assert.Throws<ArgumentNullException>(() =>
+                {
+                    BinaryByteSize.Parse(null);
+                });
+        }
+
+
+        // Various magnitudes
+        [Fact]
+        public void ParseBits()
+        {
+            string val = "1b";
+            var expected = BinaryByteSize.FromBits(1);
+            
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseBytes()
+        {
+            string val = "1B";
+            var expected = BinaryByteSize.FromBytes(1);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseKiB()
+        {
+            string val = "1020KiB";
+            var expected = BinaryByteSize.FromKibiBytes(1020);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseMiB()
+        {
+            string val = "1000MiB";
+            var expected = BinaryByteSize.FromMebiBytes(1000);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseGiB()
+        {
+            string val = "805GiB";
+            var expected = BinaryByteSize.FromGibiBytes(805);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseTiB()
+        {
+            string val = "100TiB";
+            var expected = BinaryByteSize.FromTebiBytes(100);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParsePiB()
+        {
+            string val = "100PiB";
+            var expected = BinaryByteSize.FromPebiBytes(100);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+        }
+
+        [Fact]
+        public void ParseCultureNumberSeparator()
+        {
+            CultureInfo.CurrentCulture = new CultureInfo("de-DE");
+            string val = "1.500,5 MiB";
+            var expected = BinaryByteSize.FromMebiBytes(1500.5);
+
+            var result = BinaryByteSize.Parse(val);
+
+            Assert.Equal(expected, result);
+            
+            CultureInfo.CurrentCulture = new CultureInfo("en-US");
+        }
+    }
+}
diff --git a/src/ByteSizeLib.Tests/BinaryByteSizeTest/ToStringMethod.cs b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ToStringMethod.cs
new file mode 100644
index 0000000..7d8175d
--- /dev/null
+++ b/src/ByteSizeLib.Tests/BinaryByteSizeTest/ToStringMethod.cs
@@ -0,0 +1,236 @@
+using System.Globalization;
+using System.Threading;
+using Xunit;
+
+namespace ByteSizeLib.Tests.BinaryByteSizeTests
+{
+    public class ToStringMethod
+    {
+        [Fact]
+        public void ReturnsLargestMetricSuffix()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10.5);
+
+            // Act
+            var result = b.ToString();
+
+            // Assert
+            Assert.Equal(10.5.ToString("0.0 KiB"), result);
+        }
+
+        [Fact]
+        public void ReturnsDefaultNumberFormat()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10.5);
+
+            // Act
+            var result = b.ToString("KiB");
+
+            // Assert
+            Assert.Equal(10.5.ToString("0.0 KiB"), result);
+        }
+
+        [Fact]
+        public void ReturnsProvidedNumberFormat()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10.1234);
+
+            // Act
+            var result = b.ToString("#.#### KiB");
+
+            // Assert
+            Assert.Equal(10.1234.ToString("0.0000 KiB"), result);
+        }
+
+        [Fact]
+        public void ReturnsBits()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromBits(10);
+
+            // Act
+            var result = b.ToString("##.#### b");
+
+            // Assert
+            Assert.Equal("10 b", result);
+        }
+
+        [Fact]
+        public void ReturnsBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### B");
+
+            // Assert
+            Assert.Equal("10 B", result);
+        }
+
+        [Fact]
+        public void ReturnsKibiBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### KiB");
+
+            // Assert
+            Assert.Equal("10 KiB", result);
+        }
+
+        [Fact]
+        public void ReturnsMebiBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromMebiBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### MiB");
+
+            // Assert
+            Assert.Equal("10 MiB", result);
+        }
+
+        [Fact]
+        public void ReturnsGibiBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromGibiBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### GiB");
+
+            // Assert
+            Assert.Equal("10 GiB", result);
+        }
+
+        [Fact]
+        public void ReturnsTebiBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromTebiBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### TiB");
+
+            // Assert
+            Assert.Equal("10 TiB", result);
+        }
+
+        [Fact]
+        public void ReturnsPebiBytes()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromPebiBytes(10);
+
+            // Act
+            var result = b.ToString("##.#### PiB");
+
+            // Assert
+            Assert.Equal("10 PiB", result);
+        }
+
+        [Fact]
+        public void ReturnsSelectedFormat()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromTebiBytes(10);
+
+            // Act
+            var result = b.ToString("0.0 TiB");
+
+            // Assert
+            Assert.Equal(10.ToString("0.0 TiB"), result);
+        }
+
+        [Fact]
+        public void ReturnsLargestMetricPrefixLargerThanZero()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromMebiBytes(.5);
+
+            // Act
+            var result = b.ToString("#.#");
+
+            // Assert
+            Assert.Equal("512 KiB", result);
+        }
+
+        [Fact]
+        public void ReturnsLargestMetricPrefixLargerThanZeroForNegativeValues()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromMebiBytes(-.5);
+
+            // Act
+            var result = b.ToString("#.#");
+
+            // Assert
+            Assert.Equal("-512 KiB", result);
+        }
+
+        [Fact]
+        public void ReturnsLargestMetricSuffixUsingCurrentCulture()
+        {
+            var originalCulture = CultureInfo.CurrentCulture;
+            CultureInfo.CurrentCulture = new CultureInfo("fr-FR");
+
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10000);
+
+            // Act
+            var result = b.ToString();
+
+            // Assert
+            Assert.Equal("9,77 MiB", result);
+
+            CultureInfo.CurrentCulture = originalCulture;
+        }
+
+        [Fact]
+        public void ReturnsLargestMetricSuffixUsingSpecifiedCulture()
+        {
+            // Arrange
+            var b = BinaryByteSize.FromKibiBytes(10000);
+
+            // Act
+            var result = b.ToString("#.#", new CultureInfo("fr-FR"));
+
+            // Assert
+            Assert.Equal("9,8 MiB", result);
+		}
+
+		[Fact]
+		public void ReturnsCultureSpecificFormat()
+		{
+			// Arrange
+			var b = BinaryByteSize.FromKibiBytes(10.5);
+
+			// Act
+			var deCulture = new CultureInfo("de-DE");
+			var result = b.ToString("0.0 KiB", deCulture);
+
+			// Assert
+			Assert.Equal(10.5.ToString("0.0 KiB", deCulture), result);
+		}
+
+        [Fact]
+		public void ReturnsZeroBits()
+		{
+			// Arrange
+			var b = BinaryByteSize.FromBits(0);
+
+			// Act
+			var result = b.ToString();
+
+			// Assert
+			Assert.Equal("0 b", result);
+		}
+	}
+}
diff --git a/src/ByteSizeLib.Tests/ArithmeticMethods.cs b/src/ByteSizeLib.Tests/ByteSizeTests/ArithmeticMethods.cs
similarity index 100%
rename from src/ByteSizeLib.Tests/ArithmeticMethods.cs
rename to src/ByteSizeLib.Tests/ByteSizeTests/ArithmeticMethods.cs
diff --git a/src/ByteSizeLib.Tests/CreatingMethods.cs b/src/ByteSizeLib.Tests/ByteSizeTests/CreatingMethods.cs
similarity index 84%
rename from src/ByteSizeLib.Tests/CreatingMethods.cs
rename to src/ByteSizeLib.Tests/ByteSizeTests/CreatingMethods.cs
index 066ebd2..8467d6c 100644
--- a/src/ByteSizeLib.Tests/CreatingMethods.cs
+++ b/src/ByteSizeLib.Tests/ByteSizeTests/CreatingMethods.cs
@@ -8,18 +8,18 @@ public class CreatingMethods
         public void Constructor()
         {
             // Arrange
-            double byteSize = 1125899906842624;
+            double bytes = 1125899906842624;
 
             // Act
-            var result = new ByteSize(byteSize);
+            var result = new ByteSize(bytes);
 
             // Assert
-            Assert.Equal(byteSize * 8, result.Bits);
-            Assert.Equal(byteSize, result.Bytes);
-            Assert.Equal(byteSize / 1024, result.KiloBytes);
-            Assert.Equal(byteSize / 1024 / 1024, result.MegaBytes);
-            Assert.Equal(byteSize / 1024 / 1024 / 1024, result.GigaBytes);
-            Assert.Equal(byteSize / 1024 / 1024 / 1024 / 1024, result.TeraBytes);
+            Assert.Equal(bytes * 8, result.Bits);
+            Assert.Equal(bytes, result.Bytes);
+            Assert.Equal(bytes / 1024, result.KiloBytes);
+            Assert.Equal(bytes / 1024 / 1024, result.MegaBytes);
+            Assert.Equal(bytes / 1024 / 1024 / 1024, result.GigaBytes);
+            Assert.Equal(bytes / 1024 / 1024 / 1024 / 1024, result.TeraBytes);
             Assert.Equal(1, result.PetaBytes);
         }
 
diff --git a/src/ByteSizeLib.Tests/ParsingMethods.cs b/src/ByteSizeLib.Tests/ByteSizeTests/ParsingMethods.cs
similarity index 100%
rename from src/ByteSizeLib.Tests/ParsingMethods.cs
rename to src/ByteSizeLib.Tests/ByteSizeTests/ParsingMethods.cs
diff --git a/src/ByteSizeLib.Tests/ToStringMethod.cs b/src/ByteSizeLib.Tests/ByteSizeTests/ToStringMethod.cs
similarity index 100%
rename from src/ByteSizeLib.Tests/ToStringMethod.cs
rename to src/ByteSizeLib.Tests/ByteSizeTests/ToStringMethod.cs
diff --git a/src/ByteSizeLib/ByteSize.cs b/src/ByteSizeLib/ByteSize.cs
index 2851076..4d7b9f2 100644
--- a/src/ByteSizeLib/ByteSize.cs
+++ b/src/ByteSizeLib/ByteSize.cs
@@ -88,13 +88,13 @@ public double LargestWholeNumberValue
             }
         }
 
-        public ByteSize(double byteSize)
+        public ByteSize(double bytes)
             : this()
         {
             // Get ceiling because bits are whole units
-            Bits = (long)Math.Ceiling(byteSize * BitsInByte);
+            Bits = (long)Math.Ceiling(bytes * BitsInByte);
 
-            Bytes = byteSize;
+            Bytes = bytes;
         }
 
         public static ByteSize FromBits(long value)