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); }