public async Task AddCompleteTakeTake()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
await MyCollection.AddComplete(42);
var Result = await MyCollection.Take();
try
{
_ = await MyCollection.Take();
Assert.Fail("Should not reach here");
}
catch (InvalidOperationException)
{
}
//****************************************
Assert.AreEqual(0, MyCollection.Count, "Count not as expected");
Assert.AreEqual(42, Result, "Result not as expected");
Assert.IsTrue(MyCollection.IsCompleted, "Not completed");
}
public async Task TakeThenComplete()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
var MyTask = MyCollection.Take();
Assert.IsFalse(MyTask.IsCompleted, "Took too early");
_ = MyCollection.CompleteAdding();
//****************************************
try
{
_ = await MyTask;
Assert.Fail("Should not reach here");
}
catch (InvalidOperationException)
{
}
Assert.IsTrue(MyCollection.IsAddingCompleted, "Adding not completed");
Assert.IsTrue(MyCollection.IsCompleted, "Collection not completed");
}
public async Task AddCancel()
{ //****************************************
var MyCollection = new AsyncCollection <int>(1);
//****************************************
await MyCollection.Add(42);
using (var MySource = new CancellationTokenSource())
{
var MyTask = MyCollection.Add(84, MySource.Token);
Assert.IsFalse(MyTask.IsCompleted, "Added too early");
MySource.Cancel();
try
{
await MyTask;
Assert.Fail("Wait not cancelled");
}
catch (OperationCanceledException)
{
}
}
var Result = await MyCollection.Take();
//****************************************
Assert.AreEqual(0, MyCollection.WaitingToAdd, "Tasks unexpectedly waiting");
Assert.AreEqual(42, Result, "Result not as expected");
}
public async Task TakeCancel()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
using (var MySource = new CancellationTokenSource())
{
var MyTask = MyCollection.Take(MySource.Token);
Assert.IsFalse(MyTask.IsCompleted, "Took too early");
MySource.Cancel();
try
{
_ = await MyTask;
Assert.Fail("Wait not cancelled");
}
catch (OperationCanceledException)
{
}
}
await MyCollection.Add(42);
//****************************************
Assert.AreEqual(0, MyCollection.WaitingToTake, "Tasks unexpectedly waiting");
}
public ArraySegment <byte> Take(int size, CancellationToken cancellationToken = new CancellationToken())
{
if (cancellationToken.IsCancellationRequested)
{
throw new TaskCanceledException();
}
if (lastChunk == null)
{
lastChunk = buffer.Take(cancellationToken);
}
return(ConsumeChunk(size));
}
public void TakeWithDelay()
{
AsyncCollection <int> collection = new AsyncCollection <int>();
Task.Run(() =>
{
Thread.Sleep(100);
collection.Add(1);
});
int item = collection.Take();
Assert.AreEqual(item, 1);
}
public async Task AddMaximumAddCompleteTakeTake()
{ //****************************************
var MyCollection = new AsyncCollection <int>(1);
//****************************************
await MyCollection.Add(42);
var MyTask = MyCollection.AddComplete(84);
_ = await MyCollection.Take();
await MyTask;
var MyResult = await MyCollection.Take();
//****************************************
Assert.AreEqual(84, MyResult, "Result was not as expected");
Assert.AreEqual(0, MyCollection.Count, "Count not as expected");
Assert.AreEqual(0, MyCollection.WaitingToAdd, "Waiting adders not as expected");
Assert.IsTrue(MyCollection.IsCompleted, "Collection is not completed");
}
public async Task TakeMultiCancel()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
using var MySource = new CancellationTokenSource();
var MyTask1 = MyCollection.Take(MySource.Token);
var MyTask2 = MyCollection.Take();
Assert.IsFalse(MyTask1.IsCompleted, "Took too early");
Assert.IsFalse(MyTask2.IsCompleted, "Took too early");
MySource.Cancel();
try
{
_ = await MyTask1;
Assert.Fail("Wait not cancelled");
}
catch (OperationCanceledException)
{
}
await MyCollection.Add(42);
var Result = await MyTask2;
//****************************************
Assert.AreEqual(0, MyCollection.Count, "Item not removed");
Assert.AreEqual(0, MyCollection.WaitingToTake, "Tasks unexpectedly waiting");
Assert.AreEqual(42, Result, "Result not as expected");
}
public async Task AddCompleteTake()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
await MyCollection.AddComplete(42);
var MyTask = MyCollection.Take();
//****************************************
Assert.IsTrue(MyTask.IsCompleted, "Still waiting to take");
Assert.AreEqual(0, MyCollection.Count, "Count not as expected");
Assert.IsTrue(MyCollection.IsCompleted, "Not completed");
}
public async Task TakeAdd()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
var MyTask = MyCollection.Take();
Assert.IsFalse(MyTask.IsCompleted, "Took too early");
await MyCollection.Add(42);
var MyResult = await MyTask;
//****************************************
Assert.AreEqual(42, MyResult, "Result not as expected");
Assert.AreEqual(0, MyCollection.Count, "Count not as expected");
}
public async Task TakeAddMaximum()
{ //****************************************
var MyCollection = new AsyncCollection <int>(1);
//****************************************
var MyTask = MyCollection.Take();
await MyCollection.Add(42);
await MyCollection.Add(84);
var MyResult = await MyTask;
//****************************************
Assert.AreEqual(42, MyResult, "Result was not as expected");
Assert.AreEqual(1, MyCollection.Count, "Count not as expected");
Assert.AreEqual(0, MyCollection.WaitingToAdd, "Waiting adders not as expected");
}
public async Task TakeAddThenComplete()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
var MyTask = MyCollection.Take();
await MyCollection.Add(42);
_ = MyCollection.CompleteAdding();
var MyResult = await MyTask;
//****************************************
Assert.AreEqual(0, MyCollection.Count, "Count not as expected");
Assert.AreEqual(42, MyResult, "Result not as expected");
Assert.IsTrue(MyCollection.IsAddingCompleted, "Adding not completed");
Assert.IsTrue(MyCollection.IsCompleted, "Collection not completed");
}
public async Task TakeMaxTime()
{ //****************************************
var MyCollection = new AsyncCollection <int>();
//****************************************
var MyTask = MyCollection.Take(TimeSpan.FromMilliseconds(50));
Thread.Sleep(100);
//****************************************
try
{
_ = await MyTask;
Assert.Fail("Wait not cancelled");
}
catch (TimeoutException)
{
}
}