public async Task LockTest() { var asyncLock = new AsyncLock(); var opActive = false; const int time = 200; const int timeInc = 10; const int count = 10; async Task Op(int num) { using (await asyncLock.AcquireAsync()) { Assert.IsFalse(opActive); opActive = true; await TaskEx.Delay(200 + num *timeInc); Assert.IsTrue(opActive); opActive = false; } } var sw = Stopwatch.StartNew(); await Enumerable .Range(0, 10) .Select(i => TaskEx.Run(() => Op(i))) .WhenAll(); sw.Stop(); Assert.IsFalse(opActive); Assert.GreaterOrEqual(sw.ElapsedMilliseconds, time * count + timeInc * count / 2); }
public void TwoAsserts_BothAssertsFail_Async() { Assert.Multiple(async() => { await Task.Delay(100); Assert.That(complex.RealPart, Is.EqualTo(5.0), "RealPart"); Assert.That(complex.ImaginaryPart, Is.EqualTo(4.2), "ImaginaryPart"); }); }
public void ThreeAssertsSucceed_Async() { Assert.Multiple(async() => { await Task.Delay(100); Assert.That(2 + 2, Is.EqualTo(4)); Assert.That(complex.RealPart, Is.EqualTo(5.2)); Assert.That(complex.ImaginaryPart, Is.EqualTo(3.9)); }); }
/// <summary> /// Executes a provided <see cref="Task"/>, cancelling the task and executing a fallback action if the Task doesn't complete before the provided timeout. /// </summary> /// <param name="ct"></param> /// <param name="taskSelector"></param> /// <param name="timeout"></param> /// <returns></returns> public static async Task Timeout(CancellationToken ct, Func <CancellationToken, Task> taskSelector, TimeSpan timeout, Action onTimedOut) { // We're not using CancellationTokenSource's timeout support because we want to be able to trace code and know when it's // about to be cancelled because of a timeout. using (var tokenSource = new CancellationTokenSource()) { var task = taskSelector(tokenSource.Token); if ((await StaticTask.WhenAny(task, StaticTask.Delay(timeout, ct))) != task) { // We timed out, cancel the task and throw a relevant exception. tokenSource.Cancel(); onTimedOut(); } } }
public void TwoNestedBlocks_TwoAssertsFail_Async() { Assert.Multiple(() => { Assert.Multiple(async() => { await Task.Delay(100); Assert.That(2 + 2, Is.EqualTo(5)); }); Assert.Multiple(async() => { await Task.Delay(100); Assert.That(complex.RealPart, Is.EqualTo(5.2), "RealPart"); Assert.That(complex.ImaginaryPart, Is.EqualTo(4.2), "ImaginaryPart"); }); }); }
private static async Task <bool> TryTakeAndHold( [NotNull] AsyncLock asyncLock, TimeSpan holdTime, CancellationToken cancellation = default(CancellationToken), Action callback = null) { try { using (await asyncLock.AcquireAsync(holdTime, cancellation)) { callback?.Invoke(); await TaskEx.Delay(holdTime); } return(true); } catch (OperationCanceledException) { return(false); } catch (TimeoutException) { return(false); } }
public async Task LockCancellationTest() { var asyncLock = new AsyncLock(); var holdTime = TimeSpan.FromSeconds(2); var delayTime = TimeSpan.FromMilliseconds(200); var lock1Started = new ManualResetEventSlim(false); var lock1 = TryTakeAndHold(asyncLock, holdTime, callback: () => lock1Started.Set()); lock1Started.Wait(); var cts2 = new CancellationTokenSource(); var sw2 = Stopwatch.StartNew(); var lock2 = TryTakeAndHold(asyncLock, holdTime, cts2.Token); await TaskEx.Delay(delayTime); cts2.Cancel(); var lock2Taken = await lock2; sw2.Stop(); var sw3 = Stopwatch.StartNew(); var lock3 = TryTakeAndHold(asyncLock, delayTime); await TaskEx.Delay(delayTime); var lock3Taken = await lock3; sw3.Stop(); var lock1Taken = await lock1; Assert.IsTrue(lock1Taken); Assert.IsFalse(lock2Taken); Assert.Less(sw2.Elapsed, holdTime - delayTime); Assert.IsFalse(lock3Taken); Assert.Less(sw3.Elapsed, holdTime - delayTime); }
public static async System.Threading.Tasks.Task WarningAfterAwaitTaskDelay() { await Task.Delay(1); Assert.Warn("(Warning message)"); }
public async System.Threading.Tasks.Task AsyncTaskTestCase(int x) { await Task.Delay(0); }
public async void AsyncVoidTestCase(int x) { await Task.Delay(0); }
public System.Threading.Tasks.Task NonAsyncTask() { return(Task.Delay(0)); }
public async System.Threading.Tasks.Task AsyncTask() { await Task.Delay(1); }
public async void AsyncVoid() { await Task.Delay(1); // To avoid warning message }
public System.Threading.Tasks.Task TaskTestCase(int x) { return(Task.Delay(0)); }