public ScheduleResult Execute(ITestExecutionContext context)
{
if (!_initialUserCount.HasValue)
{
_initialUserCount = context.CurrentUsers;
}
var totalSeconds = context.TotalSeconds;
var doneUserCount = _initialUserCount.Value - Users;
var shouldRemoveUsers = context.CurrentUsers > doneUserCount;
var enoughTimeHasElapsed = !_lastIteration.HasValue || (totalSeconds - _lastIteration.Value) > Seconds;
if (shouldRemoveUsers && enoughTimeHasElapsed)
{
Console.WriteLine("Removed {0} Users", UsersEvery);
_lastIteration = context.TotalSeconds;
return(new ScheduleResult(false, -UsersEvery));
}
if (shouldRemoveUsers)
{
return(new ScheduleResult(false));
}
return(new ScheduleResult(true));
}
protected override TestResult HandleCompilerException(ITestExecutionContext context, MethodInfo methodInfo)
{
var arguments = GetArgumentsArray(_originalMethod);
Type[] nativeArgTypes = new Type[arguments.Length];
for (var i = 0; i < arguments.Length; ++i)
{
nativeArgTypes[i] = arguments[i].GetType();
}
bool isInRegistry;
Func <object, object[], object> caller;
var delegateType = CreateNativeDelegateType(methodInfo.ReturnType, nativeArgTypes, out isInRegistry, out caller);
var functionDelegate = Delegate.CreateDelegate(delegateType, methodInfo);
Delegate compiledFunction = BurstCompiler.CompileDelegate(functionDelegate);
if (functionDelegate == compiledFunction)
{
context.CurrentResult.SetResult(ResultState.Success);
}
else
{
context.CurrentResult.SetResult(ResultState.Failure, $"The function have been compiled successfully, but an error was expected.");
}
return(context.CurrentResult);
}
public override TestResult Execute(ITestExecutionContext context)
{
Type caughtType = null;
try
{
innerCommand.Execute(context);
}
catch (Exception ex)
{
if (ex is NUnitException)
{
ex = ex.InnerException;
}
caughtType = ex.GetType();
}
if (caughtType == _expectedType)
{
context.CurrentResult.SetResult(ResultState.Success);
}
else if (caughtType != null)
{
context.CurrentResult.SetResult(ResultState.Failure,
string.Format("Expected {0} but got {1}", _expectedType.Name, caughtType.Name));
}
else
{
context.CurrentResult.SetResult(ResultState.Failure,
string.Format("Expected {0} but no exception was thrown", _expectedType.Name));
}
return(context.CurrentResult);
}
private bool EvaluteTest(Type type, MethodInfo method, bool useCallbacks = true)
{
ITestExecutionContext testExecutionContext = null;
if (useCallbacks)
{
testExecutionContext = BuildTestExecutionContext(type, method);
}
bool passed = false;
try
{
InvokeAction(PreTest, testExecutionContext);
object instance = Activator.CreateInstance(type);
method.Invoke(instance, null);
passed = true;
InvokeAction(OnTestPass, testExecutionContext);
}
catch (Exception ex)
{
log.Warning($"Failed Test: {ex?.InnerException?.Message}");
InvokeAction(OnTestFail, testExecutionContext);
}
return(passed);
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
var unityContext = (UnityTestExecutionContext)context;
int count = unityContext.EnumerableRepeatedTestState;
while (count < repeatCount)
{
count++;
unityContext.EnumerableRepeatedTestState = count;
if (innerCommand is IEnumerableTestMethodCommand)
{
var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
foreach (var iterator in executeEnumerable)
{
yield return(iterator);
}
}
else
{
context.CurrentResult = innerCommand.Execute(context);
}
if (context.CurrentResult.ResultState != ResultState.Success)
{
break;
}
}
unityContext.EnumerableRepeatedTestState = 0;
}
public override TestResult Execute(ITestExecutionContext context)
{
var logCollector = new LogScope();
try
{
innerCommand.Execute(context);
if (logCollector.AnyFailingLogs())
{
var failingLog = logCollector.FailingLogs.First();
throw new UnhandledLogMessageException(failingLog);
}
if (logCollector.ExpectedLogs.Any())
{
throw new UnexpectedLogMessageException(logCollector.ExpectedLogs.Peek());
}
}
catch (Exception exception)
{
context.CurrentResult.RecordException(exception);
}
logCollector.Dispose();
return(context.CurrentResult);
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
yield return(null);
var currentExecutingTestEnumerator = new TestEnumeratorWrapper(testMethod).GetEnumerator(context);
if (currentExecutingTestEnumerator != null)
{
var testEnumeraterYieldInstruction = new TestEnumerator(context, currentExecutingTestEnumerator);
yield return(testEnumeraterYieldInstruction);
var enumerator = testEnumeraterYieldInstruction.Execute();
var executingEnumerator = ExecuteEnumerableAndRecordExceptions(enumerator, context);
while (executingEnumerator.MoveNext())
{
yield return(executingEnumerator.Current);
}
}
else
{
if (context.CurrentResult.ResultState != ResultState.Ignored)
{
context.CurrentResult.SetResult(ResultState.Success);
}
}
}
protected override Delegate CompileDelegate(ITestExecutionContext context, MethodInfo methodInfo,
Type delegateType)
{
var functionDelegate = Delegate.CreateDelegate(delegateType, methodInfo);
var compiledFunction = BurstCompiler.CompileDelegate(functionDelegate);
return(compiledFunction);
}
private static bool CoroutineTimedOut(ITestExecutionContext unityContext)
{
if (string.IsNullOrEmpty(unityContext.CurrentResult.Message))
{
return(false);
}
return(unityContext.CurrentResult.ResultState.Equals(ResultState.Failure) &&
unityContext.CurrentResult.Message.Contains(new UnityTestTimeoutException(unityContext.TestCaseTimeout).Message));
}
protected unsafe override Delegate CompileDelegate(ITestExecutionContext context, MethodInfo methodInfo,
Type delegateType, byte *returnBox, out Type returnBoxType)
{
returnBoxType = null;
var functionDelegate = Delegate.CreateDelegate(delegateType, methodInfo);
var compiledFunction = BurstCompiler.CompileDelegate(functionDelegate);
return(compiledFunction);
}
public Task GetTask(ITestExecutionContext context)
{
if (m_TestMethod.Method.ReturnType.Type == typeof(Task))
{
return(HandleAsyncTest(context));
}
var message = string.Format("Return type {0} of {1} in {2} is not supported.",
m_TestMethod.Method.ReturnType, m_TestMethod.Method.Name, m_TestMethod.Method.TypeInfo.FullName);
throw new InvalidSignatureException(message);
}
private void InvokeAction(Action <ITestExecutionContext> action, ITestExecutionContext testExecutionContext)
{
try
{
// No exception, so test was passed
action?.Invoke(testExecutionContext);
}
catch (Exception ex)
{
log.Exception(ex);
}
}
public override TestResult Execute(ITestExecutionContext context)
{
using (var logScope = new LogScope())
{
if (ExecuteAndCheckLog(logScope, context.CurrentResult, () => innerCommand.Execute(context)))
{
PostTestValidation(logScope, innerCommand, context.CurrentResult);
}
}
return(context.CurrentResult);
}
public ITestExecutionContext BuildTestExecutionContext(Type type, MethodInfo method)
{
IWrittenByAttribute writtenBy = attributeUtility.GetAttribute <WrittenByAttribute>(type);
IUnderTestAttribute classUnderTest = attributeUtility.GetAttribute <UnderTestAttribute>(type);
ITestExecutionContext testExecutionContext = Factory.Get <ITestExecutionContext>();
testExecutionContext.TestClass = type;
testExecutionContext.ClassUnderTest = classUnderTest?.Type;
testExecutionContext.Method = method;
testExecutionContext.WrittenBy = writtenBy;
return(testExecutionContext);
}
public object Delegate(Type type, object[] arguments)
{
AssertState();
m_Context = UnityTestExecutionContext.CurrentContext;
m_RequestedType = type;
m_Arguments = arguments;
using (var logScope = new LogScope())
{
Execute(logScope);
}
return(HandleResult());
}
public IEnumerator GetEnumerator(ITestExecutionContext context)
{
if (m_TestMethod.Method.ReturnType.Type == typeof(IEnumerator))
{
return(HandleEnumerableTest(context));
}
var message = string.Format("Return type {0} of {1} in {2} is not supported.",
m_TestMethod.Method.ReturnType, m_TestMethod.Method.Name, m_TestMethod.Method.TypeInfo.FullName);
if (m_TestMethod.Method.ReturnType.Type == typeof(IEnumerable))
{
message += "\nDid you mean IEnumerator?";
}
throw new InvalidSignatureException(message);
}
private Task HandleAsyncTest(ITestExecutionContext context)
{
try
{
return(m_TestMethod.Method.MethodInfo.Invoke(context.TestObject, m_TestMethod.parms != null ? m_TestMethod.parms.OriginalArguments : null) as Task);
}
catch (TargetInvocationException e)
{
if (e.InnerException is IgnoreException)
{
context.CurrentResult.SetResult(ResultState.Ignored, e.InnerException.Message);
return(null);
}
throw;
}
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
ApplyChanges(context);
if (innerCommand is IEnumerableTestMethodCommand)
{
var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
foreach (var iterator in executeEnumerable)
{
yield return(iterator);
}
}
else
{
context.CurrentResult = innerCommand.Execute(context);
}
}
public override TestResult Execute(ITestExecutionContext context)
{
if (innerCommand is IEnumerableTestMethodCommand)
{
var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
foreach (var iterator in executeEnumerable)
{
if (iterator != null)
{
throw new Exception("Only null can be yielded at this point.");
}
}
return(context.CurrentResult);
}
return(innerCommand.Execute(context));
}
public void Run(IConeTest test, ITestResult result, ITestExecutionContext context)
{
var ignore = test.Attributes.GetCustomAttributes(typeof(IPendingAttribute)).Cast<IPendingAttribute>().FirstOrDefault(x => x.NoExecute);
if(ignore != null) {
result.Pending(ignore.Reason);
return;
}
var wrap = CombineEstablish(new FixtureContext(fixture, test.Attributes));
var next = ExecutionContext
.Concat(fixtureContext)
.Concat(GetTestContexts(test.Attributes))
.Aggregate((t, r) => t.Run(r), wrap);
var testContext = test as ITestExecutionContext;
if(testContext != null)
next = wrap(next, testContext);
wrap(next, context)(test, result);
}
public ScheduleResult Execute(ITestExecutionContext context)
{
if (!_endDuration.HasValue)
{
_endDuration = context.TotalMinutes + Length;
Console.WriteLine($"Starting Duration of {Length} Minutes.");
}
var durationDone = _endDuration.Value < context.TotalMinutes;
if (durationDone)
{
Console.WriteLine($"Duration of {Length} Minutes Finished.");
Console.WriteLine("Actual: {0}", context.TotalMinutes - _endDuration.Value + Length);
}
return(new ScheduleResult(durationDone));
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
var unityContext = (UnityTestExecutionContext)context;
if (unityContext.EnumerableTestState?.GetHashCode() == null)
{
unityContext.EnumerableTestState = new EnumerableTestState();
}
int count = unityContext.EnumerableTestState.Retry;
var firstCycleAfterResume = count > 0;
while (count < retryCount || (firstCycleAfterResume && count <= retryCount))
{
if (!firstCycleAfterResume)
{
count++;
}
firstCycleAfterResume = false;
unityContext.EnumerableTestState.Retry = count;
if (innerCommand is IEnumerableTestMethodCommand)
{
var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
foreach (var iterator in executeEnumerable)
{
yield return(iterator);
}
}
else
{
context.CurrentResult = innerCommand.Execute(context);
}
if (context.CurrentResult.ResultState != ResultState.Failure)
{
break;
}
}
unityContext.EnumerableTestState.Retry = 0;
}
private async Task <bool> Execute(ISchedule scheduleItem, ITestExecutionContext context)
{
var result = scheduleItem.Execute(context);
if (result.UsersChanged != 0)
{
var internalContext = (ITestExecutionContextInternal)context;
if (result.UsersChanged > 0)
{
await AddNewUsers(result.UsersChanged, internalContext);
}
else
{
RemoveUsers(result.UsersChanged * -1, internalContext);
}
}
return(result.ScheduleComplete);
}
public override TestResult Execute(ITestExecutionContext context)
{
PerformanceTest.StartTest(context.CurrentTest);
try
{
innerCommand.Execute(context);
}
catch (Exception exception)
{
context.CurrentResult.RecordException(exception);
}
if (PerformanceTest.Active.Failed)
{
context.CurrentResult.SetResult(ResultState.Failure);
}
PerformanceTest.EndTest(context.CurrentTest);
return(context.CurrentResult);
}
private object RunAsyncVoidTestMethod(ITestExecutionContext context)
{
var previousContext = SynchronizationContext.Current;
var currentContext = new AsyncSynchronizationContext();
SynchronizationContext.SetSynchronizationContext(currentContext);
try
{
object result = Reflect.InvokeMethod(testMethod.Method, context.TestObject, arguments);
currentContext.WaitForOperationCompleted();
if (currentContext.Exceptions.Count > 0)
throw new NUnitException("Rethrown", currentContext.Exceptions[0]);
return result;
}
finally
{
SynchronizationContext.SetSynchronizationContext(previousContext);
}
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
if (!(innerCommand is IEnumerableTestMethodCommand enumerableTestMethodCommand))
{
Execute(context);
yield break;
}
using (var logScope = new LogScope())
{
IEnumerable executeEnumerable = null;
if (!ExecuteAndCheckLog(logScope, context.CurrentResult,
() => executeEnumerable = enumerableTestMethodCommand.ExecuteEnumerable(context)))
{
yield break;
}
foreach (var step in executeEnumerable)
{
// do not check expected logs here - we want to permit expecting and receiving messages to run
// across frames. (but we do always want to catch a fail immediately.)
if (!CheckFailingLogs(logScope, context.CurrentResult))
{
yield break;
}
yield return(step);
}
if (!CheckLogs(context.CurrentResult, logScope))
{
yield break;
}
PostTestValidation(logScope, innerCommand, context.CurrentResult);
}
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
yield return(null);
Task currentExecutingTestTask;
try
{
currentExecutingTestTask = new TestTaskWrapper(testMethod).GetTask(context);
}
catch (Exception ex)
{
context.CurrentResult.RecordException(ex);
yield break;
}
if (currentExecutingTestTask != null)
{
var testTaskYieldInstruction = new TestTask(context, currentExecutingTestTask);
yield return(testTaskYieldInstruction);
var enumerator = testTaskYieldInstruction.Execute();
var executingEnumerator = ExecuteEnumerableAndRecordExceptions(enumerator, context);
while (executingEnumerator.MoveNext())
{
yield return(executingEnumerator.Current);
}
}
else
{
if (context.CurrentResult.ResultState != ResultState.Ignored)
{
context.CurrentResult.SetResult(ResultState.Success);
}
}
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
yield return(null);
IEnumerator currentExecutingTestEnumerator;
try
{
currentExecutingTestEnumerator = new TestEnumeratorWrapper(testMethod).GetEnumerator(context);
}
catch (Exception ex)
{
context.CurrentResult.RecordException(ex);
yield break;
}
if (currentExecutingTestEnumerator != null)
{
var testEnumeraterYieldInstruction = new TestEnumerator(context, currentExecutingTestEnumerator);
yield return(testEnumeraterYieldInstruction);
var enumerator = testEnumeraterYieldInstruction.Execute();
var executingEnumerator = ExecuteEnumerableAndRecordExceptions(enumerator, new EnumeratorContext(context));
while (AdvanceEnumerator(executingEnumerator))
{
yield return(executingEnumerator.Current);
}
}
else
{
if (context.CurrentResult.ResultState != ResultState.Ignored)
{
context.CurrentResult.SetResult(ResultState.Success);
}
}
}
public IEnumerable ExecuteEnumerable(ITestExecutionContext context)
{
var unityContext = (UnityTestExecutionContext)context;
int count = unityContext.EnumerableTestState.Repeat;
var firstCycleAfterResume = count > 0;
while (count < repeatCount || (firstCycleAfterResume && count <= repeatCount))
{
if (!firstCycleAfterResume)
{
count++;
}
firstCycleAfterResume = false;
unityContext.EnumerableTestState.Repeat = count;
if (innerCommand is IEnumerableTestMethodCommand)
{
var executeEnumerable = ((IEnumerableTestMethodCommand)innerCommand).ExecuteEnumerable(context);
foreach (var iterator in executeEnumerable)
{
yield return(iterator);
}
}
else
{
context.CurrentResult = innerCommand.Execute(context);
}
if (context.CurrentResult.ResultState != ResultState.Success)
{
break;
}
}
unityContext.EnumerableTestState.Repeat = 0;
}
public ScheduleResult Execute(ITestExecutionContext context)
{
if (!_initialUserCount.HasValue)
{
_initialUserCount = context.CurrentUsers;
Console.WriteLine($"Add Users Started. Adding {UsersEvery} every {AddUsersEverySeconds} seconds for a total of {Users}");
}
var totalSeconds = context.TotalSeconds;
var doneUserCount = _initialUserCount.Value + Users;
var needsMoreUsers = context.CurrentUsers < doneUserCount;
var enoughTimeHasElapsed = !_lastIteration.HasValue || (totalSeconds - _lastIteration.Value) > AddUsersEverySeconds;
if (!needsMoreUsers || !enoughTimeHasElapsed)
{
return(new ScheduleResult(!needsMoreUsers));
}
_lastIteration = context.TotalSeconds;
return(new ScheduleResult(false, UsersEvery));
}
protected override void CompleteTest(ITestExecutionContext context)
{
context.CurrentResult.SetResult(ResultState.Success);
}
public void Run(IConeTest test, ITestResult result, ITestExecutionContext context)
{
var wrap = CombineEstablish(new FixtureContext(fixture, test.Attributes));
var next = ExecutionContext
.Concat(fixtureContext)
.Concat(GetTestContexts(test.Attributes))
.Aggregate((t, r) => t.Run(r), wrap);
var testContext = test as ITestExecutionContext;
if(testContext != null)
next = wrap(next, testContext);;
wrap(next, context)(test, result);
}
