public void Shutdown_AbortsAllProcesses()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process1 = new ProcessStub(1);
process1.Initialize();
pm.AddProcess(process1);
var process2 = new ProcessStub(2);
process1.AttachChild(process2);
var process3 = new ProcessStub(3);
process3.Initialize();
pm.AddProcess(process3);
pm.Shutdown();
Assert.IsEmpty(pm.Processes);
Assert.IsTrue(process1.WasAborted);
Assert.IsTrue(process2.WasAborted);
Assert.IsTrue(process3.WasAborted);
}
public void RemoveChild_HandlesNoChild()
{
var proc = new ProcessStub(1);
var result = proc.RemoveChild();
Assert.IsNull(result);
}
public void AttachChild_HandlesNull()
{
var proc = new ProcessStub(1);
TestDelegate func = () => proc.AttachChild(null);
Assert.Throws <ArgumentNullException>(func);
}
public void AttachChild_AddsFirstChild()
{
var proc = new ProcessStub(1);
var child = new ProcessStub(2);
proc.AttachChild(child);
Assert.IsNotNull(proc.Child);
Assert.AreEqual(2, proc.Child.Id);
}
public void Initialize_Fails()
{
var proc = new ProcessStub(1, false);
var result = proc.Initialize();
Assert.IsFalse(result);
Assert.AreEqual(1, proc.DoInitializeCallCount);
Assert.IsFalse(proc.IsInitialized);
}
public void Initialize_Success()
{
var proc = new ProcessStub(1);
var result = proc.Initialize();
Assert.IsTrue(result);
Assert.AreEqual(1, proc.DoInitializeCallCount);
Assert.IsTrue(proc.IsInitialized);
Assert.IsTrue(proc.IsPaused);
}
public void AttachChild_RejectsInitializedChild()
{
var proc = new ProcessStub(1);
var child = new ProcessStub(2);
child.Initialize();
TestDelegate func = () => proc.AttachChild(child);
Assert.Throws <InvalidOperationException>(func);
Assert.IsNull(proc.Child);
}
public void Update_CallsHandlers()
{
var proc = new ProcessStub(1);
proc.Initialize();
proc.Resume();
proc.Update(1f);
Assert.AreEqual(1, proc.DoUpdateCallCount);
Assert.AreEqual(1f, proc.RunningTime);
}
public void RemoveChild_DetachesChild()
{
var proc = new ProcessStub(1);
var child = new ProcessStub(2);
proc.AttachChild(child);
var result = proc.RemoveChild();
Assert.IsNotNull(result);
Assert.AreEqual(2, child.Id);
}
public void AddProcess_AcceptsInitializedProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
}
public void Update_AccumulatesRunTime()
{
var proc = new ProcessStub(1);
proc.Initialize();
proc.Resume();
proc.Update(1f);
proc.Update(1f);
Assert.AreEqual(2, proc.DoUpdateCallCount);
Assert.AreEqual(2f, proc.RunningTime);
}
public void AddProcess_RejectsUnInitializedProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
TestDelegate func = () => pm.AddProcess(process);
Assert.Throws <InvalidOperationException>(func);
Assert.IsFalse(pm.Processes.Any());
}
public async Task TestThatProcessIsRestarted()
{
ProcessStub process = new ProcessStub("exePath", "exeArgs");
SelfRestartingProcess selfRestartingProcess = new SelfRestartingProcess(process, 1);
await selfRestartingProcess.Start();
Assert.IsTrue(process.IsRunning);
process.RaiseExitedEvent();
Assert.IsTrue(await SpinWaitForRestart(selfRestartingProcess, 1));
Assert.IsTrue(process.IsRunning);
}
public void IsPaused_Setter_Resumes()
{
var proc = new ProcessStub(1);
var resumeEvent = false;
proc.Resumed += (sender, args) => resumeEvent = true;
proc.Initialize();
proc.IsPaused = false;
Assert.AreEqual(1, proc.DoResumeCallCount);
Assert.IsTrue(resumeEvent);
Assert.IsTrue(proc.IsRunning);
}
public void AttachChild_ChainsChildren()
{
var proc = new ProcessStub(1);
var child1 = new ProcessStub(2);
var child2 = new ProcessStub(3);
proc.AttachChild(child1);
proc.AttachChild(child2);
Assert.IsNotNull(proc.Child);
Assert.AreEqual(2, proc.Child.Id);
Assert.IsNotNull(proc.Child.Child);
Assert.AreEqual(3, proc.Child.Child.Id);
}
public void Abort_HandlesUninitializedState()
{
var proc = new ProcessStub(1);
var abortEvent = false;
proc.Aborted += (sender, args) => abortEvent = true;
proc.Abort();
Assert.AreEqual(1, proc.DoAbortCallCount);
Assert.IsTrue(abortEvent);
Assert.IsTrue(proc.WasAborted);
Assert.IsTrue(proc.IsCompleted);
}
public void Pause_DoesNothingIfPaused()
{
var proc = new ProcessStub(1);
var pauseEvent = false;
proc.Initialize();
proc.Paused += (sender, args) => pauseEvent = true;
proc.Pause();
Assert.AreEqual(0, proc.DoPauseCallCount);
Assert.IsFalse(pauseEvent);
Assert.IsTrue(proc.IsPaused);
}
public void GetProcess_DoesNotFindNonExistingProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
var result = pm.GetProcess(2);
Assert.IsNull(result);
}
public void Fail_ChangesState()
{
var proc = new ProcessStub(1);
var failEvent = false;
proc.Failed += (sender, args) => failEvent = true;
proc.Initialize();
proc.Fail();
Assert.AreEqual(1, proc.DoFailCallCount);
Assert.IsTrue(failEvent);
Assert.IsTrue(proc.HasFailed);
Assert.IsTrue(proc.IsCompleted);
}
public void AbortAll_HandlesNoChild()
{
var proc = new ProcessStub(1);
var abortEvent = false;
proc.Aborted += (sender, args) => abortEvent = true;
proc.AbortAll();
Assert.AreEqual(1, proc.DoAbortCallCount);
Assert.IsTrue(abortEvent);
Assert.IsTrue(proc.WasAborted);
Assert.IsTrue(proc.IsCompleted);
Assert.IsNull(proc.Child);
}
public void GetProcesses_DoesNotFindNonExisting()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process1 = new ProcessStub(1);
process1.Initialize();
pm.AddProcess(process1);
var result = pm.GetProcesses <ProcessStub2>().ToList();
Assert.IsEmpty(result);
}
public void Succeed_ChangesState()
{
var proc = new ProcessStub(1);
var succeedEvent = false;
proc.Succeeded += (sender, args) => succeedEvent = true;
proc.Initialize();
proc.Succeed();
Assert.AreEqual(1, proc.DoSucceedCallCount);
Assert.IsTrue(succeedEvent);
Assert.IsTrue(proc.HasSucceeded);
Assert.IsTrue(proc.IsCompleted);
}
public void Pause_Pauses()
{
var proc = new ProcessStub(1);
var pauseEvent = false;
proc.Paused += (sender, args) => pauseEvent = true;
proc.Initialize();
proc.Resume();
proc.Pause();
Assert.AreEqual(1, proc.DoPauseCallCount);
Assert.IsTrue(pauseEvent);
Assert.IsTrue(proc.IsPaused);
}
public void Update_DoesNotUpdatePausedProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
const float time = 1.0f;
pm.Update(time);
Assert.AreEqual(0, process.DoUpdateCallCount);
}
public void GetProcess_FindsProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
var result = pm.GetProcess(1);
Assert.IsNotNull(result);
Assert.AreSame(process, result);
}
public void Resume_DoesNothingIfRunning()
{
var proc = new ProcessStub(1);
proc.Initialize();
proc.Resume();
var resumeEvent = false;
proc.Resumed += (sender, args) => resumeEvent = true;
proc.Resume();
Assert.AreEqual(1, proc.DoResumeCallCount); // one call to start running
Assert.IsFalse(resumeEvent);
Assert.IsTrue(proc.IsRunning);
}
public void Update_RemovesAbortedProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
const float time = 1.0f;
process.Abort();
pm.Update(time);
Assert.IsEmpty(pm.Processes);
}
public void Update_UpdatesRunningProcess()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process = new ProcessStub(1);
process.Initialize();
pm.AddProcess(process);
process.Resume();
const float time = 1.0f;
pm.Update(time);
Assert.AreEqual(1, process.DoUpdateCallCount);
Assert.AreEqual(time, process.LastUpdateDeltaTime);
}
public void AddProcess_RejectsDuplicateProcessId()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process1 = new ProcessStub(1);
process1.Initialize();
var process2 = new ProcessStub(1);
process2.Initialize();
pm.AddProcess(process1);
TestDelegate func = () => pm.AddProcess(process2);
Assert.Throws <InvalidOperationException>(func);
Assert.AreEqual(1, pm.Processes.Count);
}
public void GetProcesses_FindsProcessesByMostDerived()
{
var pm = new ProcessManager();
pm.Initialize();
pm.PostInitialize();
var process1 = new ProcessStub(1);
process1.Initialize();
pm.AddProcess(process1);
var process2 = new ProcessStub2(2);
process2.Initialize();
pm.AddProcess(process2);
var result = pm.GetProcesses <ProcessStub2>().ToList();
Assert.AreEqual(1, result.Count);
Assert.IsNotNull(result.Single(p => ReferenceEquals(p, process2)));
}
