public async Task RightTimeoutLeft()
{ //****************************************
var MyLock = new AsyncSwitchLock();
ValueTask <AsyncSwitchLock.Instance> MyLeft;
//****************************************
using (await MyLock.LockRight())
{
MyLeft = MyLock.LockLeft(TimeSpan.FromMilliseconds(50));
try
{
(await MyLeft).Dispose();
Assert.Fail("Should not reach here");
}
catch (TimeoutException)
{
}
}
//****************************************
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task ConcurrentRight()
{ //****************************************
var MyLock = new AsyncSwitchLock();
var Resource = 0;
//****************************************
await Task.WhenAll(
Enumerable.Range(1, 100).Select(
async count =>
{
await Task.Yield(); // Yield, so it doesn't serialise
using (await MyLock.LockRight())
{
Interlocked.Increment(ref Resource);
}
return;
})
);
//****************************************
Assert.AreEqual(100, Resource, "Block not entered");
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task RightCancelLeftRight()
{ //****************************************
var MyLock = new AsyncSwitchLock();
ValueTask <AsyncSwitchLock.Instance> MyLeft, MyRight;
//****************************************
using (var MySource = new CancellationTokenSource())
{
using (await MyLock.LockRight())
{
MyLeft = MyLock.LockLeft(MySource.Token);
MyRight = MyLock.LockRight();
MySource.Cancel();
}
}
//****************************************
(await MyRight).Dispose();
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task RightCancelLeft()
{ //****************************************
var MyLock = new AsyncSwitchLock();
ValueTask <AsyncSwitchLock.Instance> MyLeft;
//****************************************
var MyRight = await MyLock.LockRight();
using (var MySource = new CancellationTokenSource())
{
MyLeft = MyLock.LockLeft(MySource.Token);
MySource.Cancel();
MyRight.Dispose();
}
try
{
(await MyLeft).Dispose();
Assert.Fail("Did not cancel");
}
catch (OperationCanceledException)
{
}
//****************************************
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task RightLeftRightLeft()
{ //****************************************
var MyLock = new AsyncSwitchLock();
ValueTask <AsyncSwitchLock.Instance> MyRight, MyLeft1, MyLeft2;
//****************************************
using (await MyLock.LockRight())
{
MyLeft1 = MyLock.LockLeft();
MyRight = MyLock.LockRight();
MyLeft2 = MyLock.LockLeft();
}
var Results = await MyLeft1.ThenWaitOn <AsyncSwitchLock.Instance>(MyLeft2);
Results[0].Dispose();
Results[1].Dispose();
(await MyRight).Dispose();
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task RightLeftRightUnfair()
{ //****************************************
var MyLock = new AsyncSwitchLock(true);
ValueTask <AsyncSwitchLock.Instance> MyLeft, MyRight;
//****************************************
using (await MyLock.LockRight())
{
MyLeft = MyLock.LockLeft();
MyRight = MyLock.LockRight();
Assert.IsTrue(MyRight.IsCompleted, "Right not completed");
}
(await MyRight).Dispose();
(await MyLeft).Dispose();
//****************************************
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task NoTimeoutRight()
{ //****************************************
var MyLock = new AsyncSwitchLock();
ValueTask <AsyncSwitchLock.Instance> MyRight;
//****************************************
MyRight = MyLock.LockRight(TimeSpan.FromMilliseconds(50));
//****************************************
Assert.IsTrue(MyRight.IsCompleted, "Is not completed");
(await MyRight).Dispose();
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}
public async Task StackBlow()
{ //****************************************
var MyLock = new AsyncSwitchLock();
var Depth = 0;
Task ResultTask;
Task[] Results;
//****************************************
using (await MyLock.LockLeft())
{
Results = Enumerable.Range(1, 40000).Select(
async count =>
{
using (await(count % 2 == 0 ? MyLock.LockLeft() : MyLock.LockRight()))
{
Depth++;
}
}).ToArray();
ResultTask = Results[^ 1].ContinueWith(task => System.Diagnostics.Debug.WriteLine("Done to " + new System.Diagnostics.StackTrace(false).FrameCount.ToString()), TaskContinuationOptions.ExecuteSynchronously);
public async Task SingleRight()
{ //****************************************
var MyLock = new AsyncSwitchLock();
var Resource = false;
//****************************************
using (await MyLock.LockRight())
{
Resource = true;
}
//****************************************
Assert.IsTrue(Resource, "Block not entered");
Assert.AreEqual(0, MyLock.WaitingLeft, "Lefts still waiting");
Assert.AreEqual(0, MyLock.WaitingRight, "Rights still waiting");
Assert.IsFalse(MyLock.IsLeft, "Lefts still running");
Assert.IsFalse(MyLock.IsRight, "Rights still running");
}