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);
}
}
