improved api for Crc32 calculation, to make it more usable in external projects

Author: force-net

Blazer.Benchmark/Program.cs

@@ -40,18 +40,18 @@ private static void BenchCrc32C()
 
 			//warm-up
 			Crc32C.Crc32CAlgorithm.Compute(new byte[1]);
-			hardware.Calculate(new byte[1], 0, 1);
-			software.Calculate(new byte[1], 0, 1);
+			hardware.Calculate(0, new byte[1], 0, 1);
+			software.Calculate(0, new byte[1], 0, 1);
 
 			var sw = new Stopwatch();
 			sw.Start();
 			var cr = Crc32C.Crc32CAlgorithm.Compute(array);
 			Console.WriteLine("Crc32C.Net: " + ((array.Length / sw.Elapsed.TotalSeconds) / (1024 * 1024)).ToString("0") + " MB/s");
 			sw.Restart();
-			var hr = hardware.Calculate(array, 0, array.Length);
+			var hr = hardware.Calculate(0, array, 0, array.Length);
 			Console.WriteLine("Hardware: " + ((array.Length / sw.Elapsed.TotalSeconds) / (1024 * 1024)).ToString("0") + " MB/s");
 			sw.Restart();
-			var sr = software.Calculate(array, 0, array.Length);
+			var sr = software.Calculate(0, array, 0, array.Length);
 			Console.WriteLine("Software: " + ((array.Length / sw.Elapsed.TotalSeconds) / (1024 * 1024)).ToString("0") + " MB/s");
 			if (hr != cr)
 				Console.WriteLine("Error in hardware realization");

Blazer.Net.Tests/Blazer.Net.Tests.csproj

@@ -32,6 +32,9 @@
     <WarningLevel>4</WarningLevel>
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="Crc32C.NET">
+      <HintPath>..\packages\Crc32C.NET.1.0.5.0\lib\net20\Crc32C.NET.dll</HintPath>
+    </Reference>
     <Reference Include="nunit.framework">
       <HintPath>..\packages\NUnit.2.6.4\lib\nunit.framework.dll</HintPath>
     </Reference>
@@ -45,6 +48,7 @@
   </ItemGroup>
   <ItemGroup>
     <Compile Include="BigDataTests.cs" />
+    <Compile Include="Crc32Tests.cs" />
     <Compile Include="EncryptionTests.cs" />
     <Compile Include="IntegrityHelper.cs" />
     <Compile Include="IntegrityTests.cs" />

Blazer.Net.Tests/Crc32Tests.cs

@@ -0,0 +1,58 @@
+using System;
+using System.Linq;
+using System.Text;
+
+using Crc32C;
+
+using NUnit.Framework;
+
+using E = Force.Blazer.Algorithms.Crc32C.Crc32C;
+
+namespace Blazer.Net.Tests
+{
+	[TestFixture]
+	public class Crc32Tests
+	{
+		[TestCase("Hello", 3)]
+		[TestCase("Nazdar", 0)]
+		[TestCase("Ahoj", 1)]
+		[TestCase("Very long text.Very long text.Very long text.Very long text.Very long text.Very long text.Very long text", 0)]
+		[TestCase("Very long text.Very long text.Very long text.Very long text.Very long text.Very long text.Very long text", 3)]
+		public void ResultConsistency(string text, int offset)
+		{
+			var bytes = Encoding.ASCII.GetBytes(text);
+
+			var crc1 = E.Calculate(bytes.Skip(offset).ToArray());
+			var crc2 = Crc32CAlgorithm.Append(0, bytes, offset, bytes.Length - offset);
+			Assert.That(crc2, Is.EqualTo(crc1));
+		}
+
+		[Test]
+		public void ResultConsistencyLong()
+		{
+			var bytes = new byte[30000];
+			new Random().NextBytes(bytes);
+			var crc1 = E.Calculate(bytes, 0, bytes.Length);
+			var crc2 = Crc32CAlgorithm.Append(0, bytes, 0, bytes.Length);
+			Assert.That(crc2, Is.EqualTo(crc1));
+		}
+
+		[Test]
+		public void ResultConsistency2()
+		{
+			Assert.That(E.Calculate(new byte[] { 1 }), Is.EqualTo(Crc32CAlgorithm.Compute(new byte[] { 1 })));
+			Assert.That(E.Calculate(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }), Is.EqualTo(Crc32CAlgorithm.Compute(new byte[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })));
+		}
+
+		[Test]
+		public void PartIsWhole()
+		{
+			var bytes = new byte[30000];
+			new Random().NextBytes(bytes);
+			var r1 = E.Calculate(0, bytes, 0, 15000);
+			var r2 = E.Calculate(r1, bytes, 15000, 15000);
+			var r3 = E.Calculate(0, bytes, 0, 30000);
+			Assert.That(r2, Is.EqualTo(r3));
+		}
+	}
+}

Blazer.Net.Tests/packages.config

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
+  <package id="Crc32C.NET" version="1.0.5.0" targetFramework="net40" />
   <package id="NUnit" version="2.6.4" targetFramework="net40" />
 </packages>

Blazer.Net/Algorithms/Crc32C/Crc32C.cs

@@ -19,15 +19,31 @@ static Crc32C()
 		/// </summary>
 		public static uint Calculate(byte[] buffer, int offset, int count)
 		{
-			return _calculator.Calculate(buffer, offset, count);
+			return Calculate(0, buffer, offset, count);
+		}
+
+		/// <summary>
+		/// Calculates Crc32C data of given buffer, updates existing crc
+		/// </summary>
+		public static uint Calculate(uint currentCrc, byte[] buffer)
+		{
+			return Calculate(currentCrc, buffer, 0, buffer.Length);
+		}
+
+		/// <summary>
+		/// Calculates Crc32C data of given buffer, updates existing crc
+		/// </summary>
+		public static uint Calculate(uint currentCrc, byte[] buffer, int offset, int count)
+		{
+			return _calculator.Calculate(currentCrc, buffer, offset, count);
 		}
 
 		/// <summary>
 		/// Calculates Crc32C data of given buffer
 		/// </summary>
 		public static uint Calculate(byte[] buffer)
 		{
-			return _calculator.Calculate(buffer, 0, buffer.Length);
+			return Calculate(0, buffer, 0, buffer.Length);
 		}
 	}
 }

Blazer.Net/Algorithms/Crc32C/Crc32CHardware.cs

@@ -22,10 +22,10 @@ public Crc32CHardware()
 				throw new InvalidOperationException("You have no right for hardware implementation");
 		}
 
-		uint ICrc32CCalculator.Calculate(byte[] buffer, int offset, int count)
+		uint ICrc32CCalculator.Calculate(uint crc, byte[] buffer, int offset, int count)
 		{
 			var handle = GCHandle.Alloc(buffer, GCHandleType.Pinned);
-			var res = crc32c_append(0, handle.AddrOfPinnedObject() + offset, count);
+			var res = crc32c_append(crc, handle.AddrOfPinnedObject() + offset, count);
 			handle.Free();
 			return res;
 		}

Blazer.Net/Algorithms/Crc32C/Crc32CSoftware.cs

@@ -21,9 +21,9 @@ static Crc32CSoftware()
 			}
 		}
 
-		uint ICrc32CCalculator.Calculate(byte[] buffer, int offset, int count)
+		uint ICrc32CCalculator.Calculate(uint crc, byte[] buffer, int offset, int count)
 		{
-			uint crcLocal = uint.MaxValue;
+			uint crcLocal = crc ^ uint.MaxValue;
 
 			uint[] table = _table;
 			while (count >= 16)

Blazer.Net/Algorithms/Crc32C/ICrc32CCalculator.cs

@@ -8,6 +8,6 @@ public interface ICrc32CCalculator
 		/// <summary>
 		/// Calculates Crc32C data for buffer
 		/// </summary>
-		uint Calculate(byte[] buffer, int offset, int count);
+		uint Calculate(uint crc, byte[] buffer, int offset, int count);
 	}
 }