Update HashAlgorithm

Author: xoofx

src/Blake3.Tests/Blake3HashAlgorithmTests.cs

@@ -2,22 +2,71 @@
 // Licensed under the BSD-Clause 2 license.
 // See license.txt file in the project root for full license information.
 
+using System;
 using NUnit.Framework;
 
 namespace Blake3.Tests
 {
     /// <summary>
-    /// Tests for <see cref="Hasher"/>
+    /// Tests for <see cref="Blake3HashAlgorithm"/>
     /// </summary>
     public class Blake3HashAlgorithmTests : Blake3TestsBase
     {
         [Test]
         public void TestComputeHash()
         {
-            var hashAlgorithm = new Blake3HashAlgorithm();
+            using var hashAlgorithm = new Blake3HashAlgorithm();
             var result = hashAlgorithm.ComputeHash(HasherTests.BigData);
             var hash = Hash.FromBytes(result);
             AssertTextAreEqual(HasherTests.BigExpected, hash.ToString());
         }
+
+        [Test]
+        public void TestComputeHash_Span_And_TryHashFinal()
+        {
+            using var hashAlgorithm = new Blake3HashAlgorithm();
+
+            var data = HasherTests.BigData;
+
+            Span<byte> destination = stackalloc byte[Hash.Size];
+            Assert.True(hashAlgorithm.TryComputeHash(data, destination, out var written));
+            Assert.AreEqual(Hash.Size, written);
+
+            var hash = Hash.FromBytes(destination);
+            AssertTextAreEqual(HasherTests.BigExpected, hash.ToString());
+        }
+
+        [Test]
+        public void TestTryHashFinal_BufferTooSmall()
+        {
+            using var hashAlgorithm = new Blake3HashAlgorithm();
+
+            Span<byte> destination = stackalloc byte[Hash.Size - 1];
+            Assert.False(hashAlgorithm.TryComputeHash(HasherTests.BigData, destination, out var written));
+            Assert.AreEqual(0, written);
+        }
+
+        [Test]
+        public void TestChunking_And_InitializeReuse()
+        {
+            var data = HasherTests.BigData;
+
+            using var hashAlgorithm = new Blake3HashAlgorithm();
+
+            // Chunked updates
+            hashAlgorithm.TransformBlock(data, 0, 7, null, 0);
+            hashAlgorithm.TransformBlock(data, 7, 13, null, 0);
+            hashAlgorithm.TransformBlock(data, 20, data.Length - 20, null, 0);
+            hashAlgorithm.TransformFinalBlock(Array.Empty<byte>(), 0, 0);
+
+            var hash1 = Hash.FromBytes(hashAlgorithm.Hash);
+            AssertTextAreEqual(HasherTests.BigExpected, hash1.ToString());
+
+            // Reuse
+            hashAlgorithm.Initialize();
+            var result = hashAlgorithm.ComputeHash(data);
+            var hash2 = Hash.FromBytes(result);
+            AssertTextAreEqual(HasherTests.BigExpected, hash2.ToString());
+        }
     }
 }

src/Blake3/Blake3HashAlgorithm.cs

@@ -13,30 +13,67 @@ namespace Blake3;
 public class Blake3HashAlgorithm : HashAlgorithm
 {
     private Hasher _hasher;
+    private bool _disposed;
 
     public Blake3HashAlgorithm()
     {
         _hasher = Hasher.New();
+        HashSizeValue = Blake3.Hash.Size * 8;
     }
-        
+
+    public override int InputBlockSize => 1;
+
+    public override int OutputBlockSize => Blake3.Hash.Size;
+
+    public override bool CanTransformMultipleBlocks => true;
+
+    public override bool CanReuseTransform => true;
+
     protected override void Dispose(bool disposing)
     {
+        if (disposing && !_disposed)
+        {
+            _hasher.Dispose();
+            _disposed = true;
+        }
+
         base.Dispose(disposing);
-        _hasher.Dispose();
     }
-        
+
     protected override void HashCore(byte[] array, int ibStart, int cbSize)
     {
+        if (array is null) throw new ArgumentNullException(nameof(array));
+        if ((uint)ibStart > (uint)array.Length) throw new ArgumentOutOfRangeException(nameof(ibStart));
+        if ((uint)cbSize > (uint)(array.Length - ibStart)) throw new ArgumentOutOfRangeException(nameof(cbSize));
+
         _hasher.Update(new ReadOnlySpan<byte>(array, ibStart, cbSize));
     }
 
+    protected override void HashCore(ReadOnlySpan<byte> source)
+    {
+        _hasher.Update(source);
+    }
+
     protected override byte[] HashFinal()
     {
         var hash = new byte[Blake3.Hash.Size];
         _hasher.Finalize(hash);
         return hash;
     }
 
+    protected override bool TryHashFinal(Span<byte> destination, out int bytesWritten)
+    {
+        if (destination.Length < Blake3.Hash.Size)
+        {
+            bytesWritten = 0;
+            return false;
+        }
+
+        _hasher.Finalize(destination.Slice(0, Blake3.Hash.Size));
+        bytesWritten = Blake3.Hash.Size;
+        return true;
+    }
+
     public override void Initialize()
     {
         _hasher.Reset();