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 FuncTask <WorkflowResult> Approval(object wfAddIn)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
WorkflowResult wfResult = this.GetInstanceID(wfAddIn);
if (wfResult.InstanceId != Guid.Empty)
{
WfApprovalWindow wfApproval = new WfApprovalWindow();
wfApproval.Closed += (s, e) =>
{
bool flag = wfApproval.DialogResult.HasValue ? wfApproval.DialogResult.Value : false;
if (flag)
{
task = this.Approval(wfResult.InstanceId, ContextHelper.Account.LoginID, wfApproval.Result, wfApproval.Comment);
}
else
{
task.Complete(wfResult);
}
};
wfApproval.Show();
}
else
{
task.Complete(wfResult);
}
return(task);
}
public async Task ThrowingInterruptsTaskChainButAlwaysRunsFinallyAndCatch()
{
var success = false;
string thrown = "";
Exception finallyException = 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"); })
.Catch(ex => thrown = ex.Message)
.Then(new FuncTask <string>(Token, _ => "another name")
{
Affinity = TaskAffinity.Exclusive
})
.ThenInUI((s, d) => output.Add(d))
.Finally((s, e) =>
{
success = s;
finallyException = e;
});
await task.StartAndSwallowException();
Assert.IsFalse(success);
CollectionAssert.AreEqual(expectedOutput, output);
Assert.IsNotNull(finallyException);
}
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 FinallyReportsException()
{
var success = false;
Exception finallyException = 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((s, e) =>
{
success = s;
finallyException = e;
});
await task.StartAndSwallowException();
Assert.IsFalse(success);
CollectionAssert.AreEqual(expectedOutput, output);
Assert.IsNotNull(finallyException);
Assert.AreEqual("an exception", finallyException.Message);
}
void LoadInstanceList()
{
this.btnTrack.IsEnabled = this.btnExecute.IsEnabled = this.btnProcess.IsEnabled = false;
DateTime startTime = this.dtpStart.SelectedDate.HasValue == true ? dtpStart.SelectedDate.Value.Date : DateTime.Now.Date;
DateTime endTime = this.dtpEnd.SelectedDate.HasValue == true ? this.dtpEnd.SelectedDate.Value.Date : DateTime.Now.Date;
string flowID = this.tbKey.Tag.ToString();
FuncTask <IList <WFInstance> > task = new FuncTask <IList <WFInstance> >();
IWorkflowService wfService = ServiceContainer.GetService <IWorkflowService>(task);
wfService.GetToDoWorkflows(ContextHelper.Account.LoginID, flowID, startTime, endTime.AddDays(1));
task.Completed += (s, e)
=>
{
if (task.Error != null)
{
MessageBox.Show("请求数据时发生错误：" + task.Error.Message, "错误", MessageBoxButton.OK);
}
else
{
this.vList = task.TResult;
this.dataPager.RecordCount = this.vList.Count;
}
};
}
public async Task StartAsyncWorks()
{
var task = new FuncTask <int>(Token, _ => 1);
var ret = await task.StartAsAsync();
Assert.AreEqual(1, ret);
}
public async Task CatchAlwaysRunsBeforeFinally()
{
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"
};
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
})
.Then((s, d) =>
{
output.Add(d);
return("done");
})
.Catch(ex =>
{
Thread.Sleep(300);
lock (runOrder)
{
exception = ex;
runOrder.Add("catch");
}
})
.Finally((s, e, d) =>
{
Thread.Sleep(300);
lock (runOrder)
{
success = s;
finallyException = e;
runOrder.Add("finally");
}
return(d);
});
await task.StartAsAsyncWithoutThrowing();
Assert.IsFalse(success);
CollectionAssert.AreEqual(expectedOutput, output);
Assert.IsNotNull(exception);
Assert.IsNotNull(finallyException);
Assert.AreEqual("an exception", exception.Message);
Assert.AreEqual("an exception", finallyException.Message);
CollectionAssert.AreEqual(new List <string> {
"catch", "finally"
}, runOrder);
}
public void GitInstallTest()
{
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, DefaultEnvironment.OnWindows)
{
GitZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipMd5Url).Filename}",
GitZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitZipUrl).Filename}",
GitLfsZipMd5Url = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipMd5Url).Filename}",
GitLfsZipUrl = $"http://localhost:{server.Port}/{new UriString(GitInstaller.GitInstallDetails.DefaultGitLfsZipUrl).Filename}",
};
TestBasePath.Combine("git").CreateDirectory();
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
var startTask = gitInstaller.SetupGitIfNeeded();
var endTask = new FuncTask <NPath, NPath>(TaskManager.Token, (s, path) => path);
startTask.OnEnd += (thisTask, path, success, exception) => thisTask.GetEndOfChain().Then(endTask);
startTask.Start();
NPath?resultPath = null;
Assert.DoesNotThrow(async() => resultPath = await endTask.Task);
resultPath.Should().NotBeNull();
}
void InitializeNavigation()
{
NavigationProxy.Instance.BeginGetNavigation(SLContext.Account.LoginID).Completed +=
(s1, e1) =>
{
FuncTask <NavigationResult> task = s1 as FuncTask <NavigationResult>;
if (task.Error != null)
{
if (task.Error.InnerException != null)
{
MessageBox.Show(task.Error.InnerException.Message, "未能通过验证", MessageBoxButton.OK);
}
else
{
MessageBox.Show("获取系统导航信息时发生错误。\n\n" + task.Error.Message, "错误", MessageBoxButton.OK);
}
}
else
{
NavigationProxy.Instance.GroupList = task.TResult.Groups;
NavigationProxy.Instance.ModuleList = task.TResult.Modules;
(this.m_Menu as INavigation).Initialize(NavigationProxy.Instance.GroupList, NavigationProxy.Instance.ModuleList);
}
};
}
public FuncTask <WorkflowResult> GetWorkflowDataEntity(Guid instanceID)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(task);
service.GetWorkflowDataEntity(instanceID);
return(task);
}
public FuncTask <WorkflowResult> Approval(Guid instanceID, string loginID, bool result, string comment)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(task);
service.Approval(instanceID, loginID, result, comment);
return(task);
}
public FuncTask <WorkflowResult> Submit(Guid instanceID, string loginID, string comment)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(task);
service.Submit(instanceID, loginID, comment);
return(task);
}
public FuncTask GetAccountLoginInfo(string organ, string loginid, string password)
{
FuncTask task = new FuncTask();
ILoginService loginService = ServiceContainer.GetService <ILoginService>(task);
loginService.GetAccountInfo(organ, loginid, password);
return(task);
}
public FuncTask <NavigationResult> BeginGetNavigation(string loginID)
{
FuncTask <NavigationResult> task = new FuncTask <NavigationResult>();
INavigationService service = ServiceContainer.GetService <INavigationService>(task);
service.GetNavigation(loginID);
return(task);
}
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);
}
public async Task RunningDifferentTasksDependingOnPreviousResult()
{
var callOrder = new List <string>();
var taskEnd = new ActionTask(Token, () => callOrder.Add("chain completed"))
{
Name = "Chain Completed"
};
var final = taskEnd.Finally((_, __) => { }, TaskAffinity.Concurrent);
var taskStart = new FuncTask <bool>(Token, _ =>
{
callOrder.Add("chain start");
return(false);
})
{
Name = "Chain Start"
}
.Then(new ActionTask <bool>(Token, (_, __) =>
{
callOrder.Add("failing");
throw new InvalidOperationException();
})
{
Name = "Failing"
});
taskStart.Then(new ActionTask(Token, () =>
{
callOrder.Add("on failure");
})
{
Name = "On Failure"
}, runOptions: TaskRunOptions.OnFailure)
.Then(taskEnd, taskIsTopOfChain: true);
taskStart.Then(new ActionTask(Token, () =>
{
callOrder.Add("on success");
})
{
Name = "On Success"
}, runOptions: TaskRunOptions.OnSuccess)
.Then(taskEnd, taskIsTopOfChain: true);
await final.StartAndSwallowException();
Console.WriteLine(String.Join(",", callOrder.ToArray()));
CollectionAssert.AreEqual(new string[] {
"chain start",
"failing",
"on failure",
"chain completed"
}, callOrder);
}
public async Task MergingTwoChainsWorks()
{
var callOrder = new List <string>();
var dependsOrder = new List <ITask>();
var innerChainTask1 = new ActionTask(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);
});
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");
});
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 static void Initialize()
{
FuncTask <DateTime> task = new FuncTask <DateTime>();
ITimeService service = ServiceContainer.GetService <ITimeService>();
try
{
Instance.m_RemoteTime = service.GetCurrentTime();
Instance.m_SyncTime = DateTime.Now;
}
catch { }
}
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 FuncTask <WorkflowResult> CreateWorkflow(object wfAddIn, IWorkflowDataEntity wfData)
{
FuncTask <WorkflowResult> task = new FuncTask <WorkflowResult>();
WorkflowResult wfResult = this.GetFlowID(wfAddIn);
if (wfResult.FlowID == Guid.Empty)
{
task.Complete(wfResult);
}
else
{
IWorkflowService service = ServiceContainer.GetService <IWorkflowService>(task);
service.CreateWorkflow(wfResult.FlowID, wfData, ContextHelper.Account.LoginID);
}
return(task);
}
//[Test]
public void GitInstallMac()
{
var filesystem = Substitute.For <IFileSystem>();
DefaultEnvironment.OnMac = true;
DefaultEnvironment.OnWindows = false;
var gitInstallationPath = TestBasePath.Combine("GitInstall").CreateDirectory();
var installDetails = new GitInstaller.GitInstallDetails(gitInstallationPath, Environment.IsWindows)
{
GitZipMd5Url = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitZipMd5Url).AbsolutePath}",
GitZipUrl = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitZipUrl).AbsolutePath}",
GitLfsZipMd5Url = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitLfsZipMd5Url).AbsolutePath}",
GitLfsZipUrl = $"http://localhost:{server.Port}/{new Uri(GitInstaller.GitInstallDetails.DefaultGitLfsZipUrl).AbsolutePath}",
};
TestBasePath.Combine("git").CreateDirectory();
var gitInstaller = new GitInstaller(Environment, ProcessManager, TaskManager, installDetails);
var startTask = gitInstaller.SetupGitIfNeeded();
var endTask = new FuncTask <GitInstaller.GitInstallationState, GitInstaller.GitInstallationState>(TaskManager.Token, (s, state) => state);
startTask.OnEnd += (thisTask, path, success, exception) => thisTask.GetEndOfChain().Then(endTask);
startTask.Start();
GitInstaller.GitInstallationState result = null;
Assert.DoesNotThrow(async() => result = await endTask.Task);
result.Should().NotBeNull();
Assert.AreEqual(gitInstallationPath.Combine(installDetails.PackageNameWithVersion), result.GitInstallationPath);
result.GitExecutablePath.Should().Be(gitInstallationPath.Combine("bin", "git" + Environment.ExecutableExtension));
result.GitLfsExecutablePath.Should().Be(gitInstallationPath.Combine(installDetails.PackageNameWithVersion, "libexec", "git-core", "git-lfs" + Environment.ExecutableExtension));
var isCustomGitExec = result.GitExecutablePath != result.GitExecutablePath;
Environment.GitExecutablePath = result.GitExecutablePath;
Environment.GitLfsExecutablePath = result.GitLfsExecutablePath;
Environment.IsCustomGitExecutable = isCustomGitExec;
var procTask = new SimpleProcessTask(TaskManager.Token, "something")
.Configure(ProcessManager);
procTask.Process.StartInfo.EnvironmentVariables["PATH"].Should().StartWith(gitInstallationPath.ToString());
}
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);
}
//[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);
}
/// <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);
}
void LoadFlowList()
{
this.btnStart.IsEnabled = false;
FuncTask <IList <WFDefine> > task = new FuncTask <IList <WFDefine> >();
IWorkflowService wfService = ServiceContainer.GetService <IWorkflowService>(task);
wfService.GetWFDefineList(SLContext.Account.LoginID, this.tbKey.Text.Trim());
task.Completed += (s, e)
=>
{
if (task.Error != null)
{
MessageBox.Show("请求数据时发生错误：" + task.Error.Message, "错误", MessageBoxButton.OK);
}
else
{
this.vList = task.TResult;
this.dataPager.RecordCount = this.vList.Count;
}
};
}
public IEnumerator MultipleFinallyOrder()
{
using (var test = StartTest())
{
var results = new List <string>();
var beforeProcess = new ActionTask(test.TaskManager, _ => results.Add("BeforeProcess"))
{
Name = "BeforeProcess"
};
var processTask = new HelperProcessTask(test.TaskManager, test.ProcessManager, TestApp, "-x")
{
Name = "Process"
};
// this will never run because the process throws an exception
var processOutputTask = new FuncTask <string, int>(test.TaskManager, (success, previous) => {
results.Add(previous);
results.Add("ProcessOutput");
return(1234);
});
var innerChain = processTask.Then(processOutputTask).Finally((b, exception) => results.Add("ProcessFinally"), "ProcessFinally");
var outerChain = beforeProcess.Then(innerChain).Finally((b, exception) => results.Add("AfterProcessFinally"), "AfterProcessFinally");
// wait for the tasks to finish
foreach (var frame in StartAndWaitForCompletion(innerChain, outerChain))
{
yield return(frame);
}
results.MatchesUnsorted(new[] { "BeforeProcess", "ProcessFinally", "AfterProcessFinally" });
Assert.AreEqual("BeforeProcess", results[0]);
var expected = new List <string> {
"ProcessFinally", "AfterProcessFinally"
};
results.Skip(1).MatchesUnsorted(expected);
}
}
public async Task DoubleSchedulingStartsOnlyOnce()
{
var runOrder = new List <string>();
var queue = new TaskQueue();
var task1 = new FuncTask <string>(Token, () =>
{
runOrder.Add("1");
return("2");
});
task1.OnStart += _ => runOrder.Add("start 1");
task1.OnEnd += (a, b, c, d) => runOrder.Add("end 1");
var task2 = new FuncTask <string, string>(Token, (_, str) =>
{
runOrder.Add(str);
return("3");
});
task2.OnStart += _ => runOrder.Add("start 2");
task2.OnEnd += (a, b, c, d) => runOrder.Add("end 2");
var task3 = new FuncTask <string, string>(Token, (_, str) =>
{
runOrder.Add(str);
return("4");
});
task3.OnStart += _ => runOrder.Add("start 3");
task3.OnEnd += (a, b, c, d) => runOrder.Add("end 3");
queue.Queue(task1.Then(task2).Then(task3));
await queue.StartAwait();
var expected = new string[] {
"start 1", "1", "end 1",
"start 2", "2", "end 2",
"start 3", "3", "end 3",
};
Assert.AreEqual(expected.Join(","), runOrder.Join(","));
}
