public void StandardAsyncSingleConsumerCode()
{
Test.Async(async() =>
{
var queue = new AsyncProducerConsumerQueue <int>();
var producer = TaskShim.Run(() =>
{
queue.Enqueue(3);
queue.Enqueue(13);
queue.Enqueue(17);
queue.CompleteAdding();
});
var results = new List <int>();
while (await queue.OutputAvailableAsync())
{
results.Add(queue.Dequeue());
}
Assert.AreEqual(results.Count, 3);
Assert.AreEqual(results[0], 3);
Assert.AreEqual(results[1], 13);
Assert.AreEqual(results[2], 17);
});
}
public void GetEnumerator_ModDuringEnumeration_RetainsSnapshot()
{
var queue = new AsyncProducerConsumerQueue <int>(new[] { 1, 2, 3 });
var seq = queue as IEnumerable <int>;
var enumerator = seq.GetEnumerator();
bool hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(1));
queue.Enqueue(4);
var num = queue.Dequeue();
Assert.That(num, Is.EqualTo(1));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(2));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(3));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.False);
}
public void GetEnumerator_ItemInQueue_DoesNotConsumeItem()
{
var queue = new AsyncProducerConsumerQueue <int>(new[] { 1 });
var seq = queue as IEnumerable <int>;
// Force enumeration
int sum = seq.Sum();
Assert.That(sum, Is.EqualTo(1));
int val = queue.Dequeue();
Assert.That(val, Is.EqualTo(1));
}
public ShadowBufferData RequestNewBuffer()
{
if (finished)
{
return(null);
}
if (!finishedBuffers.OutputAvailable())
{
finished = true;
return(null);
}
ShadowBufferData newBuffer = finishedBuffers.Dequeue();
if (newBuffer.byteCount == 0)
{
finished = true;
return(null);
}
return(newBuffer);
}
private unsafe void WorkerThreadEntrypoint()
{
try
{
var token = tokenSource.Token;
while (!tokenSource.IsCancellationRequested)
{
ShadowBufferData newBuffer;
try
{
newBuffer = idleBuffers.Dequeue(token);
}
catch (OperationCanceledException)
{
if (tokenSource.IsCancellationRequested)
{
break;
}
throw;
}
newBuffer.byteCount = shadowBufferSize;
long maxBytesRemaining = stopPrefetchAfterXBytes - totalBytesProcessed;
if (maxBytesRemaining < shadowBufferSize)
{
newBuffer.byteCount = (int)maxBytesRemaining;
}
if (newBuffer.byteCount == 0)
{
break;
}
newBuffer.byteCount = stream.Read(newBuffer.buffer, 0, newBuffer.byteCount);
totalBytesProcessed += newBuffer.byteCount;
finishedBuffers.Enqueue(newBuffer);
}
}
finally
{
finishedBuffers.CompleteAdding();
}
}
public async Task StandardAsyncSingleConsumerCode()
{
var queue = new AsyncProducerConsumerQueue <int>();
var producer = Task.Run(() =>
{
queue.Enqueue(3);
queue.Enqueue(13);
queue.Enqueue(17);
queue.CompleteAdding();
});
var results = new List <int>();
while (await queue.OutputAvailableAsync())
{
results.Add(queue.Dequeue());
}
Assert.Equal(3, results.Count);
Assert.Equal(3, results[0]);
Assert.Equal(13, results[1]);
Assert.Equal(17, results[2]);
}
public async Task StandardAsyncSingleConsumerCode()
{
AsyncProducerConsumerQueue <int> queue = new AsyncProducerConsumerQueue <int>();
Task producer = Task.Run(() =>
{
queue.Enqueue(3);
queue.Enqueue(13);
queue.Enqueue(17);
queue.CompleteAdding();
});
List <int> results = new List <int>();
while (await queue.OutputAvailableAsync().ConfigureAwait(false))
{
results.Add(queue.Dequeue());
}
Assert.Equal(results.Count, 3);
Assert.Equal(results[0], 3);
Assert.Equal(results[1], 13);
Assert.Equal(results[2], 17);
}
public void StandardAsyncSingleConsumerCode()
{
Test.Async(async () =>
{
var queue = new AsyncProducerConsumerQueue<int>();
var producer = TaskShim.Run(() =>
{
queue.Enqueue(3);
queue.Enqueue(13);
queue.Enqueue(17);
queue.CompleteAdding();
});
var results = new List<int>();
while (await queue.OutputAvailableAsync())
{
results.Add(queue.Dequeue());
}
Assert.AreEqual(results.Count, 3);
Assert.AreEqual(results[0], 3);
Assert.AreEqual(results[1], 13);
Assert.AreEqual(results[2], 17);
});
}
public void GetEnumerator_ModDuringEnumeration_RetainsSnapshot()
{
var queue = new AsyncProducerConsumerQueue<int>(new[] { 1, 2, 3 });
var seq = queue as IEnumerable<int>;
var enumerator = seq.GetEnumerator();
bool hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(1));
queue.Enqueue(4);
var num = queue.Dequeue();
Assert.That(num, Is.EqualTo(1));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(2));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.True);
Assert.That(enumerator.Current, Is.EqualTo(3));
hasNext = enumerator.MoveNext();
Assert.That(hasNext, Is.False);
}
public void GetEnumerator_ItemInQueue_DoesNotConsumeItem()
{
var queue = new AsyncProducerConsumerQueue<int>(new[] { 1 });
var seq = queue as IEnumerable<int>;
// Force enumeration
int sum = seq.Sum();
Assert.That(sum, Is.EqualTo(1));
int val = queue.Dequeue();
Assert.That(val, Is.EqualTo(1));
}
