public void Send_CancellationToken_ShouldThrow()
{
channel <int> sut = new channel <int>(2);
Exception exception = null;
CancellationTokenSource cts = new CancellationTokenSource();
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
try
{
sut.Send(3, cts.Token);
}
catch (Exception ex)
{
exception = ex;
}
});
producer.Wait(m_awaitTimeout);
cts.Cancel();
producer.Wait(); // Await the catch block to finish
Assert.AreEqual(2, sut.Length);
Assert.IsInstanceOfType(exception, typeof(OperationCanceledException));
}
public void ProducerConsumer_FastProducer_SlowConsumer()
{
channel <int> sut = new channel <int>(2);
bool producerCalled = false;
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
sut.Send(3);
producerCalled = true;
});
bool consumerCalled = false;
List <int> items = new List <int>();
Task consumer = Task.Run(async() =>
{
await Task.Delay(m_slowActionLatency);
items.Add(sut.Receive());
await Task.Delay(m_slowActionLatency);
items.Add(sut.Receive());
await Task.Delay(m_slowActionLatency);
items.Add(sut.Receive());
consumerCalled = true;
});
Task.WaitAll(producer, consumer);
Assert.AreEqual(0, sut.Length);
Assert.IsTrue(producerCalled);
Assert.IsTrue(consumerCalled);
CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, items.ToArray());
}
public void Yield_ClosedChan_ShouldNotBeBlocked()
{
channel <int> sut = new channel <int>(2);
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
sut.Send(3);
});
List <int> items = new List <int>();
bool called = false;
Task consumer = Task.Run(() =>
{
foreach (int i in sut)
{
items.Add(i);
}
called = true;
});
producer.Wait();
sut.Close();
consumer.Wait(m_awaitTimeout);
Assert.AreEqual(3, items.Count);
Assert.IsTrue(called);
}
public void Receive_FromNonEmptyChan_ShouldNotBeBlocked()
{
channel <int> sut = new channel <int>(2);
sut.Send(1);
sut.Send(2);
int item1 = sut.Receive();
int item2 = sut.Receive();
Assert.AreEqual(0, sut.Length);
Assert.AreEqual(1, item1);
Assert.AreEqual(2, item2);
}
public void ProducerConsumer_MoreThanChanSize()
{
channel <int> sut = new channel <int>(2);
bool producerCalled = false;
int totalItemCount = 100;
Task producer = Task.Run(() =>
{
for (int i = 1; i <= totalItemCount; i++)
{
sut.Send(i);
}
producerCalled = true;
});
bool consumerCalled = false;
List <int> items = new List <int>();
Task consumer = Task.Run(() =>
{
for (int i = 1; i <= totalItemCount; i++)
{
items.Add(sut.Receive());
}
consumerCalled = true;
});
Task.WaitAll(producer, consumer);
Assert.AreEqual(0, sut.Length);
Assert.IsTrue(producerCalled);
Assert.IsTrue(consumerCalled);
CollectionAssert.AreEquivalent(Enumerable.Range(1, totalItemCount).ToArray(), items.ToArray());
}
public void Send_MoreThanSize_SendShouldBeBlocked()
{
channel <int> sut = new channel <int>(2);
bool called = false;
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
sut.Send(3);
called = true;
});
producer.Wait(m_awaitTimeout);
Assert.AreEqual(2, sut.Length);
Assert.IsFalse(called);
}
public void Send_LessThanSize_SendShouldNotBeBlocked()
{
channel <int> sut = new channel <int>(2);
bool called = false;
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
called = true;
});
producer.Wait();
Assert.AreEqual(2, sut.Length);
Assert.IsTrue(called);
}
static void sum(slice <int> s, ref channel <int> c)
{
var sum = 0;
foreach ((long, int)_tuple in s)
{
var(_, v) = _tuple;
sum += v;
}
c.Send(sum); // send sum to c
}
public void SendMany_ReceiveFew_SendShouldBeBlocked()
{
channel <int> sut = new channel <int>(2);
bool? called = null;
Task producer = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
sut.Send(3);
sut.Send(4);
sut.Send(5);
called = false;
sut.Send(6);
called = true;
});
List <int> items = new List <int> {
sut.Receive(), sut.Receive(), sut.Receive()
};
producer.Wait(m_awaitTimeout);
Assert.AreEqual(2, sut.Length);
Assert.IsFalse(called.GetValueOrDefault());
CollectionAssert.AreEquivalent(new[] { 1, 2, 3 }, items.ToArray());
}
static void fibonacci(int n, channel <int> c)
{
int x = 0, y = 1;
for (int i = 0; i < n; i++)
{
c.Send(x);
var _y1 = x + y;
x = y;
y = _y1;
}
close(c);
}
public void Send_AfterClosed_ShouldThrow()
{
channel <int> sut = new channel <int>(2);
sut.Send(1);
sut.Close();
Exception exception = null;
try
{
sut.Send(2);
}
catch (Exception ex)
{
exception = ex;
}
Assert.AreEqual(1, sut.Length);
Assert.IsTrue(sut.IsClosed);
Assert.IsInstanceOfType(exception, typeof(PanicException));
}
public void Receive_RaceCondition_OnlyOneCanGetTheSentItemEachTime()
{
channel <int> chan = new channel <int>(1);
ConcurrentBag <int> items = new ConcurrentBag <int>();
Task receiver1 = Task.Run(() => items.Add(chan.Receive()));
Task receiver2 = Task.Run(() => items.Add(chan.Receive()));
Task receiver3 = Task.Run(() => items.Add(chan.Receive()));
Thread.Sleep(m_slowActionLatency);
chan.Send(1);
Task.WaitAll(new[] { receiver1, receiver2, receiver3 }, m_awaitTimeout);
CollectionAssert.AreEquivalent(new[] { 1 }, items.ToArray());
}
public void SendFew_ReceiveMany_ReceiveShouldBeBlocked()
{
channel <int> sut = new channel <int>(2);
sut.Send(1);
sut.Send(2);
bool? called = null;
List <int> items = new List <int>();
Task consumer = Task.Run(() =>
{
items.Add(sut.Receive());
items.Add(sut.Receive());
called = false;
items.Add(sut.Receive());
called = true;
});
consumer.Wait(m_awaitTimeout);
Assert.AreEqual(0, sut.Length);
Assert.IsFalse(called.GetValueOrDefault());
CollectionAssert.AreEquivalent(new[] { 1, 2 }, items.ToArray());
}
public void Receive_ShouldGetTheSameObjectThatSenderSent()
{
channel <object> chan = new channel <object>(1);
object item = new object();
Task receiver = Task.Run(() =>
{
Thread.Sleep(m_slowActionLatency);
chan.Send(item);
});
object result = chan.Receive();
receiver.Wait();
Assert.AreSame(item, result);
}
public void Receive_RaceCondition_OneItemIsReceivedOnlyOnce()
{
channel <int> chan = new channel <int>(1);
ConcurrentBag <int> items = new ConcurrentBag <int>();
int[] samples = Enumerable.Range(0, 3).ToArray();
Task[] receivers = samples.Select(i => { return(Task.Run(() => items.Add(chan.Receive()))); }).ToArray();
Thread.Sleep((int)m_slowActionLatency.TotalMilliseconds);
foreach (int i in samples)
{
chan.Send(i);
}
Task.WaitAll(receivers);
CollectionAssert.AreEquivalent(samples, items.ToArray());
}
public void Receive_ShouldNotBeBlocked_OnceOneSend()
{
channel <int> chan = new channel <int>(1);
bool called = false;
int item = 0;
Task receiver = Task.Run(() =>
{
item = chan.Receive();
called = true;
});
Thread.Sleep(m_slowActionLatency);
chan.Send(1); // Make sure Receive() is called before Send()
receiver.Wait();
Assert.AreEqual(1, item);
Assert.IsTrue(called);
}
public void ProducerConsumer_MultipleProducers_MultipleConsumers()
{
channel <int> sut = new channel <int>(2);
bool producer1Called = false;
Task producer1 = Task.Run(() =>
{
sut.Send(1);
sut.Send(2);
sut.Send(3);
producer1Called = true;
});
bool producer2Called = false;
Task producer2 = Task.Run(() =>
{
sut.Send(4);
sut.Send(5);
sut.Send(6);
producer2Called = true;
});
ConcurrentBag <int> items = new ConcurrentBag <int>();
bool consumer1Called = false;
Task consumer1 = Task.Run(() =>
{
items.Add(sut.Receive());
items.Add(sut.Receive());
items.Add(sut.Receive());
consumer1Called = true;
});
bool consumer2Called = false;
Task consumer2 = Task.Run(() =>
{
items.Add(sut.Receive());
items.Add(sut.Receive());
items.Add(sut.Receive());
consumer2Called = true;
});
Task.WaitAll(producer1, producer2, consumer1, consumer2);
Assert.AreEqual(0, sut.Length);
Assert.IsTrue(producer1Called);
Assert.IsTrue(producer2Called);
Assert.IsTrue(consumer1Called);
Assert.IsTrue(consumer2Called);
CollectionAssert.AreEquivalent(new[] { 1, 2, 3, 4, 5, 6 }, items.ToArray());
}
