public void ItShouldBePossibleToWaitForATaskToCompleteWithinTimeout() { _taskStarted = false; _taskRun = false; _completed = false; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(CoroutineWaitingHavingTimeoutNotExploding()); var target = new CoroutinesManager(); target.TestInitialize(); var rft = new RunnerForTest(target); target.StartCoroutine(coroutine.Object); target.TestRun(); rft.RunCycleFor(200); target.TestRun(); Assert.IsTrue(_taskStarted); Assert.IsTrue(_taskRun); Assert.IsTrue(_completed); coroutine.Verify(a => a.OnError(It.IsAny <Exception>()), Times.Never); }
public void NotWaitingItShouldBePossibleToWaitForATaskToCompleteWithTimeoutError() { _notWaitingCompleted = false; _notWaitingStarted = false; _taskRun = false; _taskStarted = false; _completedTaks = false; _exception = null; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(NotWaitingHavingTimeout()); var target = new CoroutinesManager(); target.TestInitialize(); var rtt = new RunnerForTest(target); target.StartCoroutine(coroutine.Object); rtt.RunCycle(); //Coroutine initialized Assert.IsTrue(_notWaitingStarted); rtt.RunCycle(2); //Coroutine started Assert.IsTrue(_notWaitingCompleted); Assert.IsTrue(_taskStarted); Assert.IsNull(_exception); Assert.IsFalse(_completedTaks); rtt.RunCycleFor(150); Assert.IsTrue(_taskStarted); Assert.IsNotNull(_exception); Assert.IsFalse(_completedTaks); }
public void NotWaitingItShouldBePossibleToWaitForEnEntireForEach() { _notWaitingStarted = false; _notWaitingCompleted = false; _coroutineResultsCount = 0; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(NotWaitingForAllResults(10)); var target = new CoroutinesManager(); target.TestInitialize(); var rtt = new RunnerForTest(target); target.StartCoroutine(coroutine.Object); rtt.RunCycle(); //Coroutine initialized Assert.IsTrue(_notWaitingStarted); rtt.RunCycle(2); //Coroutine started Assert.IsTrue(_notWaitingCompleted); Assert.AreEqual(0, _coroutineResultsCount); rtt.RunCycle(50); //Coroutine started Assert.AreEqual(10, _coroutineResultsCount); }
public void RunningACoroutineFromEverywhereShouldPropagateExceptions() { var coroutine = new ExeCoRoutine(); coroutine.Enumerable = ExecuteAndThrowAfterInitialization().GetEnumerator(); var target = new CoroutinesManager(); target.TestInitialize(); RunnerFactory.Initialize(() => target); target.Start(); var parent = Task.Run(() => { var task = CoroutineResult.WaitForCoroutine(coroutine); task.Wait(); }); Exception expected = null; try { parent.Wait(); } catch (Exception ex) { expected = ex; } target.Stop(); Assert.IsNotNull(expected); }
public void ItShoudlBePossibleToStopTheManager() { Exception thrown = null; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(Execute(int.MaxValue)); coroutine.Setup(a => a.OnError(It.IsAny <Exception>())) .Returns((Exception ex) => { thrown = ex; return(false); }); var target = new CoroutinesManager(); target.StartCoroutine(coroutine.Object); target.Start(); Thread.Sleep(200); target.Stop(); Thread.Sleep(100); coroutine.Verify(a => a.Execute(), Times.AtLeastOnce); coroutine.Verify(a => a.OnError(It.IsAny <Exception>()), Times.Once); coroutine.Verify(a => a.OnError(It.IsAny <ManagerStoppedException>()), Times.Once); coroutine.Verify(a => a.OnDestroy(), Times.AtMostOnce); }
public void ItShouldBePossibleToWaitForCoroutineCallingFunctionThatWait() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(CoroutineWaitingForSingleResult(10)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(20); Assert.AreEqual("RESULT", _coroutineSingleResult); }
public void WhenTerminatingShouldBeCalledOnDestroy() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(ExecuteAndTerminate); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(); coroutine.Verify(a => a.OnDestroy(), Times.Once); }
public void RunnerShouldCallExecute() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(Execute()); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(); coroutine.Verify(a => a.Execute(), Times.Once); }
public void NotWaitingItShouldBePossibleToWaitForCoroutineCallingFunctionThatWait() { const int items = 10; const int itemsAndWait = items * 2; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(NotWaitingCoroutineWaitingForSingleResult(items)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(itemsAndWait); Assert.AreEqual("RESULT", _coroutineSingleResult); }
public void ExceptionOnFirstyCycleShouldBeHandledAndRoutineTerminatedForcibly() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(ExecuteAndThrowInstantly); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(); coroutine.Verify(a => a.OnError(It.IsAny <NotImplementedException>()), Times.Once); coroutine.Verify(a => a.OnDestroy(), Times.Once); }
public void ExceptionInNestedCallShouldBeHandledByCaller() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(ExecuteNestedAndThrowInsideNested(10)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(6); Assert.AreEqual(6, _cyclesRunExecuteNested); coroutine.Verify(a => a.OnError(It.IsAny <NotImplementedException>())); coroutine.Verify(a => a.OnDestroy(), Times.Never); }
public void ExceptionShouldTerminateCoroutineWhenOnErrorReturnTrue() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(ExecuteWithErrorAndContinue); coroutine.Setup(a => a.OnError(It.IsAny <Exception>())) .Returns(true); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); _shouldThrowExceptionOnExecuteWithErrorAndContinue = true; target.TestRun(3); coroutine.Verify(a => a.OnError(It.IsAny <NotImplementedException>()), Times.Once); coroutine.Verify(a => a.OnDestroy(), Times.Once); }
public void PausingRunnerShouldPauseAllCoroutines() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(Execute(10)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(); target.Pause(); target.TestRunWhenPaused(10); target.Restart(); target.TestRun(); Assert.AreEqual(_cyclesRunSimpleExecute, 2); coroutine.Verify(a => a.OnDestroy(), Times.Never); }
public void WaitForTaskToComplete() { const int waitTime = 100; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(CoroutineWaitingForTask(waitTime)); var target = new CoroutinesManager(); target.TestInitialize(); var rft = new RunnerForTest(target); target.StartCoroutine(coroutine.Object); target.TestRun(); //Initialize rft.RunCycleFor(waitTime * 2); target.TestRun(); //CleanUp Assert.IsTrue(_taskStarted); Assert.IsTrue(_taskRun); Assert.IsTrue(_completed); }
public void ItShouldBePossibleToWaitForEnEntireForEach() { _completed = false; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(CoroutineWaitingForSeveralItems(10)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(3); //Initialize the call target.TestRun(20); //Set results Assert.AreEqual(10, _partialCoroutineResultsCount); Assert.IsTrue(_completed); target.TestRun(2); //Copy the completed Assert.AreEqual(10, _coroutineResultsCount); }
public void StoppingRunnerShouldSendManagerStoppedExceptionToAllCoroutinesDestroyingEvenIfNotRequired() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(Execute(3)); coroutine.Setup(a => a.OnError(It.IsAny <Exception>())) .Returns(false); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(); target.Stop(); target.TestRun(); coroutine.Verify(a => a.OnError(It.IsAny <ManagerStoppedException>()), Times.Once); coroutine.Verify(a => a.OnDestroy(), Times.Once); }
public void NotWaitingItShouldBePossibleToWaitForATaskToCompleteWithTimeout() { var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(NotWaitingCoroutineWaitingHavingTimeoutNotExploding()); coroutine.Setup(o => o.OnError(It.IsAny <Exception>())).Returns(true); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); Task.Factory.StartNew(() => target.TestRun(3)); Thread.Sleep(300); target.TestRun(); coroutine.Verify(a => a.OnError(It.IsAny <Exception>()), Times.Never); Assert.IsTrue(_taskStarted); Assert.IsTrue(_taskRun); Assert.IsTrue(_completed); }
public void RunningACoroutineFromEverywhere() { var coroutine = new ExeCoRoutine(); coroutine.Enumerable = Execute().GetEnumerator(); var target = new CoroutinesManager(); target.TestInitialize(); RunnerFactory.Initialize(() => target); target.Start(); var parent = Task.Run(() => { var task = CoroutineResult.WaitForCoroutine(coroutine); task.Wait(); }); parent.Wait(); target.Stop(); Assert.AreEqual(1, coroutine.Cycles); }
public void NestedCallsToCoroutinesShouldWork() { _cyclesRunSimpleExecute = 0; _cyclesRunExecuteNested = 0; var coroutine = new Mock <ICoroutineThread>(); coroutine.Setup(a => a.Execute()) .Returns(ExecuteNested(10)); var target = new CoroutinesManager(); target.TestInitialize(); target.StartCoroutine(coroutine.Object); target.TestRun(20); Assert.AreEqual(10, _cyclesRunSimpleExecute); Assert.AreEqual(10, _cyclesRunExecuteNested); coroutine.Verify(a => a.OnDestroy(), Times.Never); target.TestRun(); coroutine.Verify(a => a.OnDestroy(), Times.Once); }
public RunnerForTest(CoroutinesManager runner) { _runner = runner; }
public RunnerForTest() { RunnerFactory.Initialize(); _runner = (CoroutinesManager)RunnerFactory.Create(); _runner.TestInitialize(); }