public IEnumerator AsyncAwaitTasks_ExclusiveScheduler_RunInSchedulingOrder()
{
using (var test = StartTest())
{
var runOrder = new List <string>();
var task1 = new TPLTask(test.TaskManager, () => SetDataExclusiveAsync(test.TaskManager, runOrder, "task1"))
{
Name = "Task1", Affinity = TaskAffinity.Exclusive
};
var task2 = new TPLTask(test.TaskManager, () => SetDataExclusiveAsync1(test.TaskManager, runOrder, "task2"))
{
Name = "Task2", Affinity = TaskAffinity.Exclusive
};
var task3 = new TPLTask(test.TaskManager, () => SetDataExclusiveAsync2(test.TaskManager, runOrder, "task3"))
{
Name = "Task3", Affinity = TaskAffinity.Exclusive
};
task1.Start();
task2.Start();
task3.Start();
// wait for the tasks to finish
foreach (var frame in WaitForCompletion(task1, task2, task3))
{
yield return(frame);
}
CollectionAssert.AreEqual(new[] { "task1 start", "task1 then", "task1 end", "task2 start", "task2 then", "task2 end", "task3 start", "task3 then", "task3 end" }, runOrder);
}
}
public async Task MergingTwoChainsWorks()
{
var callOrder = new List <string>();
var dependsOrder = new List <ITask>();
var innerChainTask1 = new TPLTask(TaskEx.FromResult(LogAndReturnResult(callOrder, "chain2 completed1", true)));
var innerChainTask2 = innerChainTask1.Then(_ =>
{
callOrder.Add("chain2 FuncTask<string>");
return("1");
});
var innerChainTask3 = innerChainTask2
.Finally((s, e, d) =>
{
callOrder.Add("chain2 Finally");
return(d);
}, TaskAffinity.Concurrent);
var outerChainTask1 = new FuncTask <int>(Token, _ =>
{
callOrder.Add("chain1 FuncTask<int>");
return(1);
});
var outerChainTask2 = outerChainTask1.Then(innerChainTask3);
var outerChainTask3 = outerChainTask2
.Finally((s, e) =>
{
callOrder.Add("chain1 Finally");
}, TaskAffinity.Concurrent);
await outerChainTask3.StartAwait();
var dependsOn = outerChainTask3;
while (dependsOn != null)
{
dependsOrder.Add(dependsOn);
dependsOn = dependsOn.DependsOn;
}
Assert.AreEqual(innerChainTask3, outerChainTask2);
CollectionAssert.AreEqual(new ITask[] { outerChainTask1, innerChainTask1, innerChainTask2, innerChainTask3, outerChainTask3 }, dependsOrder.Reverse <ITask>().ToArray());
CollectionAssert.AreEqual(new string[] {
"chain2 completed1",
"chain1 FuncTask<int>",
"chain2 FuncTask<string>",
"chain2 Finally",
"chain1 Finally"
}, callOrder);
}
public void GetTopOfChain_ReturnsTopTaskWhenNotStarted()
{
var task1 = new TPLTask(TaskEx.FromResult(true));
var task2 = new TestActionTask(Token, _ => { });
var task3 = new TestActionTask(Token, _ => { });
task1.Then(task2).Then(task3);
var top = task3.GetTopOfChain();
Assert.AreSame(task1, top);
}
public async Task CanWrapATask()
{
var runOrder = new List <string>();
var task = new Task(() => runOrder.Add($"ran"));
var act = new TPLTask(task)
{
Affinity = TaskAffinity.Exclusive
};
await act.Start().Task;
CollectionAssert.AreEqual(new string[] { $"ran" }, runOrder);
}
public void GetTopOfChain_ReturnsTopTaskWhenNotStarted()
{
using (var test = StartTest())
{
var task1 = new TPLTask(test.TaskManager, () => Task.FromResult(true));
var task2 = new TestActionTask(test.TaskManager, _ => { });
var task3 = new TestActionTask(test.TaskManager, _ => { });
task1.Then(task2).Then(task3);
var top = task3.GetTopOfChain();
Assert.AreSame(task1, top);
}
}
protected override RpcClient RunWithReturn(bool success)
{
var result = base.RunWithReturn(success);
try
{
var retries = 2;
var port = expectedPort;
while (result == null && retries > 0)
{
IProcessTask <int> processTask = null;
try
{
var ipcTask = new TPLTask <int, RpcClient>(TaskManager, ConnectToServer)
{
Affinity = TaskAffinity.None
};
if (port > 0)
{
ipcTask.PreviousResult = port;
}
else
{
// run the server process, we don't know which port it's on
processTask = SetupServerProcess();
ipcTask = processTask.Then(ipcTask);
}
ipcTask.StartSync(Token);
result = ipcTask.Result;
}
catch (Exception ex)
{
if (ex is AggregateException)
{
if (processTask != null && !processTask.Successful)
{
ex = processTask.Exception;
}
}
retries--;
processTask?.Stop();
processTask?.Dispose();
processTask = null;
port = 0;
result = default;
if (retries == 0 || ex is OperationCanceledException)
{
ex.Rethrow();
}
}
}
}
catch (Exception ex)
{
#if UNITY_EDITOR
UnityEngine.Debug.LogException(ex);
#endif
if (!RaiseFaultHandlers(ex))
{
Exception.Rethrow();
}
}
return(result);
}
