public void AdvanceTo_PositionFromUnrelatedSequence()
{
MockPool <char> mockPool = new MockPool <char>();
var seqA = new Sequence <char>(mockPool);
var seqB = new Sequence <char>(mockPool);
var mem1 = seqA.GetMemory(3);
mem1.Span.Fill('a');
seqA.Advance(mem1.Length);
var mem2 = seqB.GetMemory(3);
mem2.Span.Fill('b');
seqB.Advance(mem2.Length);
ReadOnlySequence <char> rosA = seqA;
ReadOnlySequence <char> rosB = seqB;
var posB = rosB.GetPosition(2);
Assert.Throws <ArgumentException>(() => seqA.AdvanceTo(posB));
Assert.Equal(3, seqA.AsReadOnlySequence.Length);
Assert.Equal(3, seqB.AsReadOnlySequence.Length);
}
public void AdvanceTo_PriorPositionInPriorBlock()
{
MockPool <char> mockPool = new MockPool <char>();
var seq = new Sequence <char>(mockPool);
var mem1 = seq.GetMemory(3);
mem1.Span.Fill('a');
seq.Advance(mem1.Length);
var mem2 = seq.GetMemory(3);
mem2.Span.Fill('b');
seq.Advance(mem2.Length);
ReadOnlySequence <char> ros = seq;
SequencePosition pos1 = ros.GetPosition(1);
SequencePosition pos4 = ros.GetPosition(4);
seq.AdvanceTo(pos4);
Assert.Throws <ArgumentException>(() => seq.AdvanceTo(pos1));
ros = seq;
Assert.Equal(2, ros.Length);
Assert.Equal(ros.Length, seq.Length);
}
public void GetMemory_TwiceInARowRecyclesOldArray(int leadingBlocks)
{
MockPool <char> mockPool = new MockPool <char>();
var seq = new Sequence <char>(mockPool);
seq.MinimumSpanLength = 1;
for (int i = 0; i < leadingBlocks; i++)
{
seq.GetMemory(1);
seq.Advance(1);
}
var mem1 = seq.GetMemory(16);
// This second request cannot be satisfied by the first one since it's larger. So the first should be freed.
var mem2 = seq.GetMemory(32);
mockPool.AssertContents(mem1);
// This third one *can* be satisfied by the 32 byte array allocation requested previously, so no recycling should take place.
var mem3 = seq.GetMemory(24);
mockPool.AssertContents(mem1);
}
public void Dispose_ReturnsArraysToPool()
{
MockPool <char> mockPool = new MockPool <char>();
var seq = new Sequence <char>(mockPool);
var expected = new List <Memory <char> >();
for (int i = 0; i < 3; i++)
{
var mem = seq.GetMemory(3);
expected.Add(mem);
seq.Advance(mem.Length);
}
seq.Dispose();
Assert.True(seq.AsReadOnlySequence.IsEmpty);
mockPool.AssertContents(expected);
}
public void AdvanceTo_ReturnsArraysToPool()
{
MockPool <char> mockPool = new MockPool <char>();
var seq = new Sequence <char>(mockPool);
var mem1 = seq.GetMemory(3);
mem1.Span.Fill('a');
seq.Advance(mem1.Length);
var mem2 = seq.GetMemory(3);
mem2.Span.Fill('b');
seq.Advance(mem2.Length);
var mem3 = seq.GetMemory(3);
mem3.Span.Fill('c');
seq.Advance(mem3.Length);
// Assert that the used arrays are not in the pool.
Assert.Empty(mockPool.Contents);
// Advance, but don't go beyond the first array.
seq.AdvanceTo(seq.AsReadOnlySequence.GetPosition(mem1.Length - 1));
Assert.Empty(mockPool.Contents);
// Now advance beyond the first array and assert that it has been returned to the pool.
seq.AdvanceTo(seq.AsReadOnlySequence.GetPosition(1));
mockPool.AssertContents(mem1);
// Skip past the second array.
seq.AdvanceTo(seq.AsReadOnlySequence.GetPosition(mem2.Length));
mockPool.AssertContents(mem1, mem2);
// Advance part way through the third array.
seq.AdvanceTo(seq.AsReadOnlySequence.GetPosition(mem3.Length - 2));
mockPool.AssertContents(mem1, mem2);
// Now advance to the end.
seq.AdvanceTo(seq.AsReadOnlySequence.GetPosition(2));
Assert.True(seq.AsReadOnlySequence.IsEmpty);
mockPool.AssertContents(mem1, mem2, mem3);
}
public void Setup()
{
pool = new MockPool("mock", PoolSize, TimeSpan.FromSeconds(2));
}
internal Rental(MockPool <T> owner, Memory <T> memory)
{
this.owner = owner ?? throw new ArgumentNullException(nameof(owner));
this.Memory = memory;
}
