private void PrepareForDomainReload()
{
m_TestRunnerStateSerializer.SaveContext();
m_CurrentPC = EnumeratorStepHelper.GetEnumeratorPC(TestEnumerator.Enumerator);
m_ExecuteOnEnable = true;
RunningTests = false;
}
public void OnEnable()
{
if (m_ExecuteOnEnable)
{
InitRunner();
m_ExecuteOnEnable = false;
foreach (var callback in m_CallbackObjects)
{
AddListeners(callback as ITestRunnerListener);
}
m_ConstructDelegator = new ConstructDelegator(m_TestRunnerStateSerializer);
EnumeratorStepHelper.SetEnumeratorPC(m_CurrentPC);
UnityWorkItemDataHolder.alreadyExecutedTests = m_ExecutedTests.Select(x => x.uniqueName).ToList();
UnityWorkItemDataHolder.alreadyStartedTests = m_AlreadyStartedTests;
Run();
}
}
public void Resume(ITest testTree, RunStartedEvent runStartedEvent, TestStartedEvent testStartedEvent, TestFinishedEvent testFinishedEvent, RunFinishedEvent runFinishedEvent)
{
if (m_ResumeAfterDomainReload)
{
m_RunStartedEvent = runStartedEvent;
m_TestStartedEvent = testStartedEvent;
m_TestFinishedEvent = testFinishedEvent;
m_RunFinishedEvent = runFinishedEvent;
InitRunner(testTree);
m_ResumeAfterDomainReload = false;
foreach (var callback in m_CallbackObjects)
{
AddListeners(callback as ITestRunnerListener);
}
m_ConstructDelegator = new ConstructDelegator(m_TestRunnerStateSerializer);
EnumeratorStepHelper.SetEnumeratorPC(m_CurrentPC);
UnityWorkItemDataHolder.alreadyExecutedTests = m_ExecutedTests.Select(x => x.fullName).ToList();
UnityWorkItemDataHolder.alreadyStartedTests = m_AlreadyStartedTests;
Run();
}
}
protected override IEnumerable PerformWork()
{
if (IsCancelledRun())
{
yield break;
}
if (m_DontRunRestoringResult)
{
if (EditModeTestCallbacks.RestoringTestContext == null)
{
throw new NullReferenceException("RestoringTestContext is not set");
}
EditModeTestCallbacks.RestoringTestContext();
Result = Context.CurrentResult;
yield break;
}
try
{
if (IsCancelledRun())
{
yield break;
}
if (m_Command is SkipCommand)
{
m_Command.Execute(Context);
Result = Context.CurrentResult;
yield break;
}
//Check if we can execute this test
var firstEnumerableCommand = FindFirstIEnumerableTestMethodCommand(m_Command);
if (firstEnumerableCommand == null)
{
Context.CurrentResult.SetResult(ResultState.Error, "Returning IEnumerator but not using test attribute supporting this");
yield break;
}
if (Context.TestCaseTimeout == 0)
{
Context.TestCaseTimeout = k_DefaultTimeout;
}
if (m_Command.Test.Method.ReturnType.IsType(typeof(IEnumerator)))
{
if (m_Command is ApplyChangesToContextCommand)
{
var applyChangesToContextCommand = ((ApplyChangesToContextCommand)m_Command);
applyChangesToContextCommand.ApplyChanges(Context);
m_Command = applyChangesToContextCommand.GetInnerCommand();
}
var innerCommand = m_Command as IEnumerableTestMethodCommand;
if (innerCommand == null)
{
Debug.Log("failed getting innerCommand");
throw new Exception("Tests returning IEnumerator can only use test attributes handling those");
}
foreach (var workItemStep in innerCommand.ExecuteEnumerable(Context))
{
if (IsCancelledRun())
{
yield break;
}
if (workItemStep is TestEnumerator)
{
if (EnumeratorStepHelper.UpdateEnumeratorPcIfNeeded(TestEnumerator.Enumerator))
{
yield return(new RestoreTestContextAfterDomainReload());
}
continue;
}
if (workItemStep is AsyncOperation)
{
var asyncOperation = (AsyncOperation)workItemStep;
while (!asyncOperation.isDone)
{
if (IsCancelledRun())
{
yield break;
}
yield return(null);
}
continue;
}
ResultedInDomainReload = false;
if (workItemStep is IEditModeTestYieldInstruction)
{
var editModeTestYieldInstruction = (IEditModeTestYieldInstruction)workItemStep;
yield return(editModeTestYieldInstruction);
var enumerator = editModeTestYieldInstruction.Perform();
while (true)
{
bool moveNext;
try
{
moveNext = enumerator.MoveNext();
}
catch (Exception e)
{
Context.CurrentResult.RecordException(e);
break;
}
if (!moveNext)
{
break;
}
yield return(null);
}
}
else
{
yield return(workItemStep);
}
}
Result = Context.CurrentResult;
EditorApplication.isPlaying = false;
yield return(null);
}
}
finally
{
WorkItemComplete();
}
}
