public async Task YouCanUseCatchAtTheEndOfAChain() { var success = false; Exception exception = null; var output = new List <string>(); var expectedOutput = new List <string> { "one name" }; var task = new FuncTask <string>(Token, _ => "one name") { Affinity = TaskAffinity.UI } .Then((s, d) => output.Add(d)) .Then(_ => { throw new Exception("an exception"); }) .Then(new FuncTask <string>(Token, _ => "another name") { Affinity = TaskAffinity.Exclusive }) .ThenInUI((s, d) => output.Add(d)) .Finally((_, __) => { }) .Catch(ex => { exception = ex; }); await task.Start().Task; Assert.IsFalse(success); CollectionAssert.AreEqual(expectedOutput, output); Assert.IsNotNull(exception); }
public async Task AllFinallyHandlersAreCalledOnException() { Stopwatch watch; ILogging logger; StartTest(out watch, out logger); var task = new FuncTask <string>(TaskManager.Token, () => { throw new InvalidOperationException(); }); bool exceptionThrown1, exceptionThrown2; exceptionThrown1 = exceptionThrown2 = false; task.Finally(success => exceptionThrown1 = !success); task.Finally((success, _) => exceptionThrown2 = !success); StartTrackTime(watch); var waitTask = task.Start().Task; var ret = await TaskEx.WhenAny(waitTask, TaskEx.Delay(Timeout)); StopTrackTimeAndLog(watch, logger); Assert.AreEqual(ret, waitTask); exceptionThrown1.Should().BeTrue(); exceptionThrown2.Should().BeTrue(); }
public void ConditionalChaining() { var success = false; Exception exception = null; Exception finallyException = null; var runOrder = new List <string>(); var output = new List <string>(); var bools = new List <bool>(); for (int i = 0; i < 10; i++) { bools.Add(i % 2 == 0); } var expectedOutput = bools.SelectMany(x => new List <string> { x.ToString().ToLower(), x ? "something" : "nothing" }).ToList(); var tasks = new List <ITask>(); foreach (var b in bools) { var task = new FuncTask <bool>(Token, _ => b) .ThenIf(go => { output.Add(go.ToString().ToLower()); if (go) { return(new FuncTask <string>(Token, _ => "something")); } else { return(new FuncTask <string>(Token, _ => "nothing")); } }) .Finally((s, e, d) => { lock (runOrder) { success = s; output.Add(d); finallyException = e; } return(d); }); tasks.Add(task.Start()); } Task.WaitAll(tasks.Select(x => x.Task).ToArray()); Assert.IsTrue(success); Assert.IsNull(exception); Assert.IsNull(finallyException); expectedOutput.Sort(); output.Sort(); CollectionAssert.AreEquivalent(expectedOutput, output); }
//[Test] //[Ignore("borked")] public async Task DoNotEndChainsWithDefer() { var runOrder = new List <int>(); var act = new FuncTask <List <int> >(Token, _ => runOrder) { Name = "First" } .Defer(GetData) .Then((_, v) => { v.Add(2); return(v); }) .Defer(GetData2) .Then((_, v) => { v.Add(4); return(v); }) .Defer(async v => { await TaskEx.Delay(10); v.Add(5); return(v); }) .Then((_, v) => { v.Add(6); return(v); }) .Defer(v => new Task <List <int> >(() => { v.Add(7); return(v); }), TaskAffinity.Concurrent); ; var ret = await act.Start().Task; // the last one hasn't finished before await is done CollectionAssert.AreEqual(Enumerable.Range(1, 6), runOrder); }
public IEnumerator AllFinallyHandlersAreCalledOnException() { using (var test = StartTest()) { var task = new FuncTask <string>(test.TaskManager, () => { throw new InvalidOperationException(); }); bool exceptionThrown1, exceptionThrown2; exceptionThrown1 = exceptionThrown2 = false; task.FinallyInline(success => exceptionThrown1 = !success); task.FinallyInline((success, _) => exceptionThrown2 = !success); var waitTask = task.Start().Task; var aggregateTask = Task.WhenAny(waitTask, Task.Delay(Timeout)); foreach (var frame in WaitForCompletion(aggregateTask)) { yield return(frame); } var ret = aggregateTask.Result; Assert.AreEqual(ret, waitTask); Assert.IsTrue(exceptionThrown1); Assert.IsTrue(exceptionThrown2); } }