public async Task StartAsyncWorks()
{
var task = new FuncTask <int>(Token, _ => 1);
var ret = await task.StartAsAsync();
Assert.AreEqual(1, ret);
}
public async Task DeferExceptions()
{
var runOrder = new List <string>();
var task = new FuncTask <int>(Token, _ => 1)
.Defer(async d =>
{
throw new InvalidOperationException();
return(await TaskEx.FromResult(d));
})
.Then(_ => { });
await task.StartAsAsync();
}
/// <summary>
/// Always call Then or another non-Defer variant after calling Defer
/// </summary>
//[Test]
//[Ignore("borked")]
public async Task TwoDefersInARowWillNotWork()
{
var runOrder = new List <int>();
var act = new FuncTask <List <int> >(Token, _ => runOrder)
{
Name = "First"
}
.Defer(GetData)
.Defer(GetData2)
.Finally((_, e, v) => v);
;
var ret = await act.StartAsAsync();
Assert.IsNull(ret);
}
public async Task FinallyCanAlsoNotReturnData()
{
var success = false;
Exception exception = null;
Exception finallyException = null;
var runOrder = new List <string>();
var output = new List <string>();
var expectedOutput = new List <string> {
"one name", "another name", "done"
};
var task =
new FuncTask <string>(Token, _ => "one name")
{
Affinity = TaskAffinity.UI
}
.Then((s, d) => output.Add(d))
.Then(new FuncTask <string>(Token, _ => "another name")
{
Affinity = TaskAffinity.Exclusive
})
.Then((s, d) =>
{
output.Add(d);
return("done");
})
.Finally((s, e, d) =>
{
lock (runOrder)
{
success = s;
output.Add(d);
finallyException = e;
runOrder.Add("finally");
}
});
await task.StartAsAsync();
Assert.IsTrue(success);
CollectionAssert.AreEqual(expectedOutput, output);
Assert.IsNull(exception);
Assert.IsNull(finallyException);
CollectionAssert.AreEqual(new List <string> {
"finally"
}, runOrder);
}
public async Task StartAsyncWorks()
{
Stopwatch watch;
ILogging logger;
StartTest(out watch, out logger);
var task = new FuncTask <int>(Token, _ => 1);
StartTrackTime(watch);
var waitTask = task.StartAsAsync();
var retTask = await TaskEx.WhenAny(waitTask, TaskEx.Delay(Timeout));
StopTrackTimeAndLog(watch, logger);
Assert.AreEqual(retTask, waitTask);
var ret = await waitTask;
Assert.AreEqual(1, ret);
}
/// <summary>
/// Always call Then or another non-Defer variant after calling Defer
/// </summary>
//[Test]
//[Ignore("borked")]
public async Task AlwaysChainAsyncBodiesWithNonAsync()
{
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)
.Finally((_, e, v) => v);
;
var ret = await act.StartAsAsync();
CollectionAssert.AreEqual(Enumerable.Range(1, 7), runOrder);
}
