test: fix BatchBuffer and Tests

src/Sentry/Internal/BatchBuffer.cs

@@ -1,8 +1,8 @@
 namespace Sentry.Internal;
 
 /// <summary>
-/// A slim wrapper over an <see cref="System.Array"/>,
-/// intended for buffering.
+/// A slim wrapper over an <see cref="System.Array"/>, intended for buffering.
+/// <para>Requires a minimum capacity of 2.</para>
 /// </summary>
 /// <remarks>
 /// <para><see cref="Capacity"/> is thread-safe.</para>
@@ -23,7 +23,6 @@ public BatchBuffer(int capacity)
         _additions = 0;
     }
 
-    //internal int Count => _count;
     internal int Capacity => _array.Length;
     internal bool IsEmpty => _additions == 0;
     internal bool IsFull => _additions >= _array.Length;
@@ -43,7 +42,13 @@ internal bool TryAdd(T item, out int count)
 
     internal T[] ToArrayAndClear()
     {
-        return ToArrayAndClear(_additions);
+        var additions = _additions;
+        var length = _array.Length;
+        if (additions < length)
+        {
+            length = additions;
+        }
+        return ToArrayAndClear(length);
     }
 
     internal T[] ToArrayAndClear(int length)

test/Sentry.Tests/Internals/BatchBufferTests.cs

@@ -2,171 +2,147 @@ namespace Sentry.Tests.Internals;
 
 public class BatchBufferTests
 {
-    [Fact]
-    public void Ctor_CapacityIsNegative_Throws()
+    [Theory]
+    [InlineData(-1)]
+    [InlineData(0)]
+    [InlineData(1)]
+    public void Ctor_CapacityIsOutOfRange_Throws(int capacity)
     {
-        var ctor = () => new BatchBuffer<string>(-1);
+        var ctor = () => new BatchBuffer<string>(capacity);
 
         Assert.Throws<ArgumentOutOfRangeException>("capacity", ctor);
     }
 
     [Fact]
-    public void Ctor_CapacityIsZero_Throws()
+    public void TryAdd_CapacityTwo_CanAddTwice()
     {
-        var ctor = () => new BatchBuffer<string>(0);
-
-        Assert.Throws<ArgumentOutOfRangeException>("capacity", ctor);
-    }
+        var buffer = new BatchBuffer<string>(2);
+        AssertEmpty(buffer, 2);
 
-    [Fact]
-    public void TryAdd_CapacityOne_CanAddOnce()
-    {
-        var buffer = new BatchBuffer<string>(1);
-        AssertProperties(buffer, 0, 1, true, false);
+        buffer.TryAdd("one", out var first).Should().BeTrue();
+        Assert.Equal(1, first);
+        AssertPartial(buffer, 2);
 
-        buffer.TryAdd("one").Should().BeTrue();
-        AssertProperties(buffer, 1, 1, false, true);
+        buffer.TryAdd("two", out var second).Should().BeTrue();
+        Assert.Equal(2, second);
+        AssertFull(buffer, 2);
 
-        buffer.TryAdd("two").Should().BeFalse();
-        AssertProperties(buffer, 1, 1, false, true);
+        buffer.TryAdd("three", out var third).Should().BeFalse();
+        Assert.Equal(3, third);
+        AssertFull(buffer, 2);
     }
 
     [Fact]
-    public void TryAdd_CapacityTwo_CanAddTwice()
+    public void TryAdd_CapacityThree_CanAddThrice()
     {
-        var buffer = new BatchBuffer<string>(2);
-        AssertProperties(buffer, 0, 2, true, false);
+        var buffer = new BatchBuffer<string>(3);
+        AssertEmpty(buffer, 3);
+
+        buffer.TryAdd("one", out var first).Should().BeTrue();
+        Assert.Equal(1, first);
+        AssertPartial(buffer, 3);
 
-        buffer.TryAdd("one").Should().BeTrue();
-        AssertProperties(buffer, 1, 2, false, false);
+        buffer.TryAdd("two", out var second).Should().BeTrue();
+        Assert.Equal(2, second);
+        AssertPartial(buffer, 3);
 
-        buffer.TryAdd("two").Should().BeTrue();
-        AssertProperties(buffer, 2, 2, false, true);
+        buffer.TryAdd("three", out var third).Should().BeTrue();
+        Assert.Equal(3, third);
+        AssertFull(buffer, 3);
 
-        buffer.TryAdd("three").Should().BeFalse();
-        AssertProperties(buffer, 2, 2, false, true);
+        buffer.TryAdd("four", out var fourth).Should().BeFalse();
+        Assert.Equal(4, fourth);
+        AssertFull(buffer, 3);
     }
 
     [Fact]
-    public void ToArray_IsEmpty_EmptyArray()
+    public void ToArrayAndClear_IsEmpty_EmptyArray()
     {
-        var buffer = new BatchBuffer<string>(3);
+        var buffer = new BatchBuffer<string>(2);
 
-        var array = buffer.ToArray();
+        var array = buffer.ToArrayAndClear();
 
         Assert.Empty(array);
-        AssertProperties(buffer, 0, 3, true, false);
+        AssertEmpty(buffer, 2);
     }
 
     [Fact]
-    public void ToArray_IsNotEmptyNorFull_PartialArray()
+    public void ToArrayAndClear_IsNotEmptyNorFull_PartialCopy()
     {
-        var buffer = new BatchBuffer<string>(3);
-        buffer.TryAdd("one").Should().BeTrue();
-        buffer.TryAdd("two").Should().BeTrue();
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one", out _).Should().BeTrue();
 
-        var array = buffer.ToArray();
+        var array = buffer.ToArrayAndClear();
 
         Assert.Collection(array,
-            item => Assert.Equal("one", item),
-            item => Assert.Equal("two", item));
-        AssertProperties(buffer, 2, 3, false, false);
+            item => Assert.Equal("one", item));
+        AssertEmpty(buffer, 2);
     }
 
     [Fact]
-    public void ToArray_IsFull_FullArray()
+    public void ToArrayAndClear_IsFull_FullCopy()
     {
-        var buffer = new BatchBuffer<string>(3);
-        buffer.TryAdd("one").Should().BeTrue();
-        buffer.TryAdd("two").Should().BeTrue();
-        buffer.TryAdd("three").Should().BeTrue();
+        var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one", out _).Should().BeTrue();
+        buffer.TryAdd("two", out _).Should().BeTrue();
 
-        var array = buffer.ToArray();
+        var array = buffer.ToArrayAndClear();
 
         Assert.Collection(array,
             item => Assert.Equal("one", item),
-            item => Assert.Equal("two", item),
-            item => Assert.Equal("three", item));
-        AssertProperties(buffer, 3, 3, false, true);
+            item => Assert.Equal("two", item));
+        AssertEmpty(buffer, 2);
     }
 
     [Fact]
-    public void Clear_IsEmpty_NoOp()
+    public void ToArrayAndClear_CapacityExceeded_FullCopy()
     {
         var buffer = new BatchBuffer<string>(2);
+        buffer.TryAdd("one", out _).Should().BeTrue();
+        buffer.TryAdd("two", out _).Should().BeTrue();
+        buffer.TryAdd("three", out _).Should().BeFalse();
 
-        AssertProperties(buffer, 0, 2, true, false);
-        buffer.Clear();
-        AssertProperties(buffer, 0, 2, true, false);
-    }
-
-    [Fact]
-    public void Clear_IsNotEmptyNorFull_ClearArray()
-    {
-        var buffer = new BatchBuffer<string>(2);
-        buffer.TryAdd("one").Should().BeTrue();
+        var array = buffer.ToArrayAndClear();
 
-        AssertProperties(buffer, 1, 2, false, false);
-        buffer.Clear();
-        AssertProperties(buffer, 0, 2, true, false);
+        Assert.Collection(array,
+            item => Assert.Equal("one", item),
+            item => Assert.Equal("two", item));
+        AssertEmpty(buffer, 2);
     }
 
     [Fact]
-    public void Clear_IsFull_ClearArray()
+    public void ToArrayAndClear_WithLength_PartialCopy()
     {
         var buffer = new BatchBuffer<string>(2);
-        buffer.TryAdd("one").Should().BeTrue();
-        buffer.TryAdd("two").Should().BeTrue();
+        buffer.TryAdd("one", out _).Should().BeTrue();
+        buffer.TryAdd("two", out _).Should().BeTrue();
+
+        var array = buffer.ToArrayAndClear(1);
 
-        AssertProperties(buffer, 2, 2, false, true);
-        buffer.Clear();
-        AssertProperties(buffer, 0, 2, true, false);
+        Assert.Collection(array,
+            item => Assert.Equal("one", item));
+        AssertEmpty(buffer, 2);
     }
 
-    [Fact]
-    public void ToArrayAndClear_IsEmpty_EmptyArray()
+    private static void AssertEmpty<T>(BatchBuffer<T> buffer, int capacity)
     {
-        var buffer = new BatchBuffer<string>(2);
-
-        AssertProperties(buffer, 0, 2, true, false);
-        var array = buffer.ToArrayAndClear();
-        AssertProperties(buffer, 0, 2, true, false);
-        Assert.Empty(array);
+        AssertProperties(buffer, capacity, true, false);
     }
 
-    [Fact]
-    public void ToArrayAndClear_IsNotEmptyNorFull_PartialArray()
+    private static void AssertPartial<T>(BatchBuffer<T> buffer, int capacity)
     {
-        var buffer = new BatchBuffer<string>(2);
-        buffer.TryAdd("one").Should().BeTrue();
-
-        AssertProperties(buffer, 1, 2, false, false);
-        var array = buffer.ToArrayAndClear();
-        AssertProperties(buffer, 0, 2, true, false);
-        Assert.Collection(array,
-            item => Assert.Equal("one", item));
+        AssertProperties(buffer, capacity, false, false);
     }
 
-    [Fact]
-    public void ToArrayAndClear_IsFull_FullArray()
+    private static void AssertFull<T>(BatchBuffer<T> buffer, int capacity)
     {
-        var buffer = new BatchBuffer<string>(2);
-        buffer.TryAdd("one").Should().BeTrue();
-        buffer.TryAdd("two").Should().BeTrue();
-
-        AssertProperties(buffer, 2, 2, false, true);
-        var array = buffer.ToArrayAndClear();
-        AssertProperties(buffer, 0, 2, true, false);
-        Assert.Collection(array,
-            item => Assert.Equal("one", item),
-            item => Assert.Equal("two", item));
+        AssertProperties(buffer, capacity, false, true);
     }
 
-    private static void AssertProperties<T>(BatchBuffer<T> buffer, int count, int capacity, bool empty, bool full)
+    private static void AssertProperties<T>(BatchBuffer<T> buffer, int capacity, bool empty, bool full)
     {
         using (new AssertionScope())
         {
-            buffer.Count.Should().Be(count);
             buffer.Capacity.Should().Be(capacity);
             buffer.IsEmpty.Should().Be(empty);
             buffer.IsFull.Should().Be(full);