Add unit test

Author: qmfrederik

src/NerdBank.GitVersioning.Tests/ManagedGit/GitPackMemoryCacheTests.cs

@@ -0,0 +1,41 @@
+using System.IO;
+using Nerdbank.GitVersioning.ManagedGit;
+using Xunit;
+
+namespace NerdBank.GitVersioning.Tests.ManagedGit
+{
+    /// <summary>
+    /// Tests the <see cref="GitPackMemoryCache"/> class.
+    /// </summary>
+    public class GitPackMemoryCacheTests
+    {
+        [Fact]
+        public void StreamsAreIndependent()
+        {
+            using (MemoryStream stream = new MemoryStream(
+                new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }))
+            {
+                var cache = new GitPackMemoryCache();
+
+                var stream1 = cache.Add(0, stream);
+                Assert.True(cache.TryOpen(0, out Stream stream2));
+
+                using (stream1)
+                using (stream2)
+                {
+                    stream1.Seek(5, SeekOrigin.Begin);
+                    Assert.Equal(5, stream1.Position);
+                    Assert.Equal(0, stream2.Position);
+                    Assert.Equal(5, stream1.ReadByte());
+
+                    Assert.Equal(6, stream1.Position);
+                    Assert.Equal(0, stream2.Position);
+
+                    Assert.Equal(0, stream2.ReadByte());
+                    Assert.Equal(6, stream1.Position);
+                    Assert.Equal(1, stream2.Position);
+                }
+            }
+        }
+    }
+}

src/NerdBank.GitVersioning/ManagedGit/GitPackMemoryCache.cs

@@ -7,17 +7,37 @@
 
 namespace Nerdbank.GitVersioning.ManagedGit
 {
-    internal class GitPackMemoryCache : GitPackCache
+    /// <summary>
+    /// <para>
+    ///   The <see cref="GitPackMemoryCache"/> implements the <see cref="GitPackCache"/> abstract class.
+    ///   When a <see cref="Stream"/> is added to the <see cref="GitPackMemoryCache"/>, it is wrapped in a
+    ///   <see cref="GitPackMemoryCacheStream"/>. This stream allows for just-in-time, random, read-only
+    ///   access to the underlying data (which may deltafied and/or compressed).
+    /// </para>
+    /// <para>
+    ///   Whenever data is read from a <see cref="GitPackMemoryCacheStream"/>, the call is forwarded to the
+    ///   underlying <see cref="Stream"/> and cached in a <see cref="MemoryStream"/>. If the same data is read
+    ///   twice, it is read from the <see cref="MemoryStream"/>, rather than the underlying <see cref="Stream"/>.
+    /// </para>
+    /// <para>
+    ///   <see cref="Add(long, Stream)"/> and <see cref="TryOpen(long, out Stream?)"/> return <see cref="Stream"/>
+    ///   objects which may operate on the same underlying <see cref="Stream"/>, but independently maintain
+    ///   their state.
+    /// </para>
+    /// </summary>
+    public class GitPackMemoryCache : GitPackCache
     {
         private readonly Dictionary<long, GitPackMemoryCacheStream> cache = new Dictionary<long, GitPackMemoryCacheStream>();
 
+        /// <inheritdoc/>
         public override Stream Add(long offset, Stream stream)
         {
             var cacheStream = new GitPackMemoryCacheStream(stream);
             this.cache.Add(offset, cacheStream);
             return new GitPackMemoryCacheViewStream(cacheStream);
         }
 
+        /// <inheritdoc/>
         public override bool TryOpen(long offset, [NotNullWhen(true)] out Stream? stream)
         {
             if (this.cache.TryGetValue(offset, out GitPackMemoryCacheStream? cacheStream))
@@ -30,6 +50,7 @@ public override bool TryOpen(long offset, [NotNullWhen(true)] out Stream? stream
             return false;
         }
 
+        /// <inheritdoc/>
         public override void GetCacheStatistics(StringBuilder builder)
         {
             builder.AppendLine($"{this.cache.Count} items in cache");