public void WaitAsync_NotEmpty_CanCedeTurn()
{
using (var cts = new CancellationTokenSource())
using (var turnstile = new Turnstile())
{
var t1 = turnstile.WaitAsync();
var t2 = turnstile.WaitAsync(cts.Token);
var t3 = turnstile.WaitAsync();
Assert.That(turnstile.HasWaiting);
TaskAssert.DoesNotEnd(t1);
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
cts.Cancel();
Assert.That(turnstile.Turn());
TaskAssert.Completed(t1);
TaskAssert.Cancelled(t2);
TaskAssert.DoesNotEnd(t3);
Assert.That(turnstile.Turn());
TaskAssert.Completed(t3);
Assert.That(!turnstile.HasWaiting);
Assert.That(!turnstile.Turn());
}
}
public void OrCanceledBy_NotCanceled_Propagates(TaskStatus AStatus)
{
using (var cts = new CancellationTokenSource())
{
var tcs = new TaskCompletionSource <Void>();
var cont = tcs.Task.OrCanceledBy(cts.Token);
Assume.That(cont.Wait(10), Is.False);
switch (AStatus)
{
case TaskStatus.RanToCompletion:
tcs.TrySetResult(default);
TaskAssert.Completed(cont);
break;
case TaskStatus.Canceled:
tcs.TrySetCanceled(_FCanceled.Token);
TaskAssert.Cancelled(cont);
break;
case TaskStatus.Faulted:
tcs.TrySetException(_FFaulted);
Assert.That(
TaskAssert.Faulted <Exception>(cont),
Is.SameAs(_FFaulted)
);
break;
default:
throw new NotImplementedException();
}
}
}
public void WaitAsync_NotEmpty_WaitsForTurn()
{
using (var turnstile = new Turnstile())
{
var t1 = turnstile.WaitAsync();
var t2 = turnstile.WaitAsync();
var t3 = turnstile.WaitAsync();
Assert.That(turnstile.HasWaiting);
TaskAssert.DoesNotEnd(t1);
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
Assert.That(turnstile.Turn());
TaskAssert.Completed(t1);
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
Assert.That(turnstile.Turn());
TaskAssert.Completed(t2);
TaskAssert.DoesNotEnd(t3);
Assert.That(turnstile.Turn());
TaskAssert.Completed(t3);
Assert.That(!turnstile.HasWaiting);
Assert.That(!turnstile.Turn());
}
}
public void WaitAsync_Empty_ReturnsCompletedTask()
{
using (var queue = new Queue())
{
using (TaskAssert.Completed(queue.WaitAsync())) { }
}
}
public void Dispose_FaultsAwaiters()
{
var turnstile = new Turnstile();
using (var cts = new CancellationTokenSource())
{
var awaiters = new[]
{
turnstile.WaitAsync(),
turnstile.WaitAsync(cts.Token),
turnstile.WaitAsync(),
turnstile.WaitAsync()
};
cts.Cancel();
turnstile.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(awaiters[0]);
TaskAssert.Cancelled(awaiters[1]);
foreach (var awaiter in awaiters.Skip(2))
{
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
}
}
public void WaitAsync_Exceeded_WaitsForTurn()
{
using (var quota = new Quota(1L))
{
var t1 = quota.WaitAsync();
var t2 = quota.WaitAsync();
var t3 = quota.WaitAsync();
Assert.That(quota.Balance, Is.EqualTo(-2L));
using (TaskAssert.Completed(t1))
{
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
}
Assert.That(quota.Balance, Is.EqualTo(-1L));
using (TaskAssert.Completed(t2))
{
TaskAssert.DoesNotEnd(t3);
}
Assert.That(quota.Balance, Is.EqualTo(0L));
using (TaskAssert.Completed(t3)) { }
Assert.That(quota.Balance, Is.EqualTo(1L));
}
}
public void ReadFromStreamAsyncCallsOnReadFromStreamInTask()
{
Type calledType = null;
Stream calledStream = null;
HttpContentHeaders calledHeaders = null;
SMediaTypeFormatter formatter = new SMediaTypeFormatter()
{
CallBase = true
};
formatter.OnReadFromStreamTypeStreamHttpContentHeaders = (type, stream, headers) =>
{
calledType = type;
calledStream = stream;
calledHeaders = headers;
return(5);
};
SHttpContent content = new SHttpContent();
HttpContentHeaders contentHeaders = content.Headers;
Task <object> createdTask =
StreamAssert.WriteAndReadResult <Task <object> >(
(stream) => { },
(stream) => formatter.ReadFromStreamAsync(typeof(int), stream, contentHeaders));
object readObject = TaskAssert.SucceedsWithResult(createdTask);
Assert.AreEqual(5, readObject, "ReadFromStreamAsync should have returned this value from stub.");
Assert.AreEqual(typeof(int), calledType, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.IsNotNull(calledStream, "OnReadFromStreamAsync was not called or did not pass Type.");
Assert.AreSame(contentHeaders, calledHeaders, "OnReadFromStreamAsync was not called or did not pass ContentHeaders.");
}
public void WriteToStreamAsyncCallsOnWriteToStreamInTask()
{
Type calledType = null;
object calledObj = null;
Stream calledStream = null;
HttpContentHeaders calledHeaders = null;
Task createdTask = null;
SMediaTypeFormatter formatter = new SMediaTypeFormatter()
{
CallBase = true
};
formatter.OnWriteToStreamTypeObjectStreamHttpContentHeadersTransportContext = (type, obj, stream, headers, context) =>
{
calledType = type;
calledObj = obj;
calledStream = stream;
calledHeaders = headers;
};
SHttpContent content = new SHttpContent();
HttpContentHeaders contentHeaders = content.Headers;
StreamAssert.WriteAndRead(
(stream) => createdTask = formatter.WriteToStreamAsync(typeof(int), 5, stream, contentHeaders, /*transportContext*/ null),
(stream) => { });
TaskAssert.Succeeds(createdTask);
Assert.AreEqual(typeof(int), calledType, "OnWriteToStream was not called or did not pass Type.");
Assert.AreEqual(5, calledObj, "OnWriteToStream was not called or did not pass the object value.");
Assert.IsNotNull(calledStream, "OnWriteToStream was not called or did not pass Type.");
Assert.AreSame(contentHeaders, calledHeaders, "OnWriteToStream was not called or did not pass ContentHeaders.");
}
public void WaitAsync_NotEmpty_WaitsForTurn()
{
using (var queue = new Queue())
{
var t1 = queue.WaitAsync();
var t2 = queue.WaitAsync();
var t3 = queue.WaitAsync();
using (TaskAssert.Completed(t1))
{
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
}
using (TaskAssert.Completed(t2))
{
TaskAssert.DoesNotEnd(t3);
}
using (TaskAssert.Completed(t3))
{
Assert.That(!queue.IsEmpty);
}
Assert.That(queue.IsEmpty);
}
}
public void WaitAsync_Released_ReturnsCompletedTask()
{
using (var lck = new Lock())
{
using (TaskAssert.Completed(lck.WaitAsync())) { }
}
}
public void Dispose_FaultsAwaiters()
{
var lck = new Lock();
using (var cts = new CancellationTokenSource())
{
var awaiters = new[]
{
TaskAssert.Detach(lck.WaitAsync),
TaskAssert.Detach(() => lck.WaitAsync(cts.Token)),
TaskAssert.Detach(lck.WaitAsync),
TaskAssert.Detach(lck.WaitAsync)
};
cts.Cancel();
lck.Dispose();
using (TaskAssert.Completed(awaiters[0])) { }
TaskAssert.Cancelled(awaiters[1]);
foreach (var awaiter in awaiters.Skip(2))
{
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
}
}
public void WaitAsync_Set_ReturnsCompletedTask()
{
using (var cond = Condition.True())
{
TaskAssert.Completed(cond.WaitAsync());
}
}
public void Dispose_FaultsAwaiters()
{
var quota = new Quota(1L);
using (var cts = new CancellationTokenSource())
{
var awaiters = new[]
{
quota.WaitAsync(),
quota.WaitAsync(cts.Token),
quota.WaitAsync(),
quota.WaitAsync()
};
cts.Cancel();
quota.Dispose();
using (TaskAssert.Completed(awaiters[0])) { }
TaskAssert.Cancelled(awaiters[1]);
foreach (var awaiter in awaiters.Skip(2))
{
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
}
}
public async void SaveIsIncompleteEnsureAllPendingOperationsAreCancelledStream()
{
var store = (FilesStore)filesStore;
using (var session = filesStore.OpenAsyncSession())
{
var fileStream = CreateUniformFileStream(128);
session.RegisterUpload("test2.file", fileStream);
session.RegisterUpload("test1.file", 128, x =>
{
for (byte i = 0; i < 60; i++)
{
x.WriteByte(i);
}
});
session.RegisterRename("test2.file", "test3.file");
TaskAssert.Throws <BadRequestException>(() => session.SaveChangesAsync());
var shouldExist = await session.LoadFileAsync("test2.file");
Assert.NotNull(shouldExist);
var shouldNotExist = await session.LoadFileAsync("test3.file");
Assert.Null(shouldNotExist);
}
}
public void WaitAsync_Ended_ReturnsCompletedTask()
{
using (var era = Era.Ended())
{
TaskAssert.Completed(era.WaitAsync());
}
}
public void WaitAsync_Exceeded_CanCedeTurn()
{
using (var cts = new CancellationTokenSource())
using (var quota = new Quota(1L))
{
var t1 = quota.WaitAsync();
var t2 = quota.WaitAsync(cts.Token);
var t3 = quota.WaitAsync();
Assert.That(quota.Balance, Is.EqualTo(-2L));
cts.Cancel();
Assert.That(quota.Balance, Is.EqualTo(-1L));
using (TaskAssert.Completed(t1))
{
TaskAssert.Cancelled(t2);
TaskAssert.DoesNotEnd(t3);
}
Assert.That(quota.Balance, Is.EqualTo(0L));
using (TaskAssert.Completed(t3)) { }
Assert.That(quota.Balance, Is.EqualTo(1L));
}
}
public void WaitAsync_NotEmpty_CanCedeTurn()
{
using (var cts = new CancellationTokenSource())
using (var queue = new Queue())
{
var t1 = queue.WaitAsync();
var t2 = queue.WaitAsync(cts.Token);
var t3 = queue.WaitAsync();
using (TaskAssert.Completed(t1))
{
TaskAssert.DoesNotEnd(t2);
TaskAssert.DoesNotEnd(t3);
cts.Cancel();
TaskAssert.Cancelled(t2);
TaskAssert.DoesNotEnd(t3);
}
using (TaskAssert.Completed(t3))
{
Assert.That(!queue.IsEmpty);
}
Assert.That(queue.IsEmpty);
}
}
public void WaitAsync_Disposed_ReturnsFaultedTask()
{
var future = new Future <int>();
future.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(future.WaitAsync());
}
public void WaitAsync_Disposed_ThrowsObjectDisposedException()
{
var turnstile = new Turnstile();
turnstile.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(turnstile.WaitAsync());
}
public void WaitAsync_Disposed_ThrowsObjectDisposedException()
{
var lck = new Lock();
lck.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(lck.WaitAsync());
}
public void WaitAsync_Disposed_ThrowsObjectDisposedException()
{
var cond = new Condition();
cond.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(cond.WaitAsync());
}
public void WaitAsync_Disposed_ReturnsFaultedTask()
{
var evt = new Event <int>();
evt.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(evt.WaitAsync());
}
public void WaitAsync_Disposed_ReturnsFaultedTask()
{
var trigger = new Trigger();
trigger.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(trigger.WaitAsync());
}
public void WaitAsync_Disposed_ReturnsFaultedTask()
{
var era = new Era();
era.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(era.WaitAsync());
}
public void WaitAsync_Disposed_ThrowsObjectDisposedException()
{
var quota = new Quota(1L);
quota.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(quota.WaitAsync());
}
public void Dispose_FaultsAwaiters()
{
var era = new Era();
var awaiter = era.WaitAsync();
era.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
public void Dispose_FaultsAwaiters()
{
var future = new Future <int>();
var awaiter = future.WaitAsync();
future.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
public void Dispose_FaultsAwaiters()
{
var trigger = new Trigger();
var awaiter = trigger.WaitAsync();
trigger.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
public void WaitAsync_Disposed_ThrowsObjectDisposedException()
{
var barrier = new Barrier(3);
barrier.Dispose();
var awaiter = barrier.WaitAsync();
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
public void Dispose_FaultsAwaiters()
{
var cond = new Condition();
var awaiter = cond.WaitAsync();
cond.Dispose();
TaskAssert.Faulted <ObjectDisposedException>(awaiter);
}
