public override TestResult Execute(TestExecutionContext 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; }
public override TestResult Execute(TestExecutionContext context) { string setCulture = (string)Test.Properties.Get(PropertyNames.SetCulture); if (setCulture != null) context.CurrentCulture = new System.Globalization.CultureInfo(setCulture); return innerCommand.Execute(context); }
public void Initialize() { setupContext = new TestExecutionContext(TestExecutionContext.CurrentContext); #if !NETCF currentCulture = CultureInfo.CurrentCulture; currentUICulture = CultureInfo.CurrentUICulture; currentDirectory = Environment.CurrentDirectory; currentPrincipal = Thread.CurrentPrincipal; #endif }
public static TestResult RunTestFixture(Type type) { TestSuite suite = MakeFixture(type); TestExecutionContext context = new TestExecutionContext(); context.TestObject = null; CompositeWorkItem work = new CompositeWorkItem(suite, TestFilter.Empty); return ExecuteAndWaitForResult(work, context); }
public void Initialize() { setupContext = new TestExecutionContext(TestExecutionContext.CurrentContext); #if !NETCF && !PORTABLE originalCulture = CultureInfo.CurrentCulture; originalUICulture = CultureInfo.CurrentUICulture; #endif #if !NETCF && !SILVERLIGHT && !PORTABLE originalDirectory = Environment.CurrentDirectory; originalPrincipal = Thread.CurrentPrincipal; #endif }
public override TestResult Execute(TestExecutionContext context) { Type caughtType = null; Exception exception = null; try { innerCommand.Execute(context); } catch (Exception ex) { exception = ex; if (exception is NUnitException) exception = ex.InnerException; caughtType = exception.GetType(); } if (caughtType == _expectedType) { if (_expectedMessage == null || _expectedMessage == exception.Message) context.CurrentResult.SetResult(ResultState.Success); else context.CurrentResult.SetResult(ResultState.Failure, "Expected {0} but got {1}".Args(_expectedMessage, exception.Message)); } else if (caughtType != null) { context.CurrentResult.SetResult(ResultState.Failure, "Expected {0} but got {1}".Args(_expectedType.Name, caughtType.Name)); } else { context.CurrentResult.SetResult(ResultState.Failure, "Expected {0} but no exception was thrown".Args(_expectedType.Name)); } return context.CurrentResult; }
internal static void SetCurrentContext(TestExecutionContext ec) { current = ec; }
/// <summary> /// Initializes a new instance of the <see cref="TestExecutionContext"/> class. /// </summary> /// <param name="other">An existing instance of TestExecutionContext.</param> public TestExecutionContext( TestExecutionContext other ) { this.prior = other; this.currentTest = other.currentTest; this.currentResult = other.currentResult; this.testObject = other.testObject; this.workDirectory = other.workDirectory; this.listener = other.listener; this.stopOnError = other.stopOnError; this.testCaseTimeout = other.testCaseTimeout; #if !NETCF this.currentCulture = CultureInfo.CurrentCulture; this.currentUICulture = CultureInfo.CurrentUICulture; #endif #if !NETCF && !SILVERLIGHT this.outWriter = other.outWriter; this.errorWriter = other.errorWriter; this.traceWriter = other.traceWriter; this.tracing = other.tracing; #endif #if !NUNITLITE this.logging = other.logging; this.currentDirectory = Environment.CurrentDirectory; this.logCapture = other.logCapture; this.currentPrincipal = Thread.CurrentPrincipal; #endif }
public void OneTimeSetUp() { _fixtureContext = TestExecutionContext.CurrentContext; _fixtureResult = _fixtureContext.CurrentResult.ResultState; }
public static FakeWorkItem GetWorkItem(Test test, TestExecutionContext context) { return new FakeWorkItem(test, context); }
public void ExecutionStatusIsPromulgatedAcrossBranches() { var topContext = new TestExecutionContext(); var leftContext = new TestExecutionContext(new TestExecutionContext(new TestExecutionContext(topContext))); var rightContext = new TestExecutionContext(new TestExecutionContext(new TestExecutionContext(topContext))); leftContext.ExecutionStatus = TestExecutionStatus.StopRequested; Assert.That(rightContext.ExecutionStatus, Is.EqualTo(TestExecutionStatus.StopRequested)); }
public void ExecutionStatusIsPushedToHigherContext() { var topContext = new TestExecutionContext(); var bottomContext = new TestExecutionContext(new TestExecutionContext(new TestExecutionContext(topContext))); bottomContext.ExecutionStatus = TestExecutionStatus.StopRequested; Assert.That(topContext.ExecutionStatus, Is.EqualTo(TestExecutionStatus.StopRequested)); }
// This method can't currently be used. It would be more efficient // to run test cases using the command directly, but that would // cause errors in tests that have a timeout or that require a // separate thread or a specific apartment. Those features are // handled at the level of the WorkItem in the current build. // Therefore, we run all tests, both test cases and fixtures, // by creating a WorkItem and executing it. See the RunTest // method below. //public static ITestResult RunTestMethod(TestMethod testMethod, object fixture) //{ // TestExecutionContext context = new TestExecutionContext(); // context.CurrentTest = testMethod; // context.CurrentResult = testMethod.MakeTestResult(); // context.TestObject = fixture; // TestCommand command = testMethod.MakeTestCommand(); // return command.Execute(context); //} //public static ITestResult RunTest(Test test) //{ // return RunTest(test, null); //} public static ITestResult RunTest(Test test, object testObject) { TestExecutionContext context = new TestExecutionContext(); context.TestObject = testObject; WorkItem work = WorkItem.CreateWorkItem(test, TestFilter.Empty); work.InitializeContext(context); work.Execute(); // TODO: Replace with an event - but not while method is static while (work.State != WorkItemState.Complete) { #if PORTABLE System.Threading.Tasks.Task.Delay(1); #else Thread.Sleep(1); #endif } return work.Result; }
public void OneTimeSetUp() { fixtureContext = TestExecutionContext.CurrentContext; }
/// <summary> /// Run selected tests and return a test result. The test is run synchronously, /// and the listener interface is notified as it progresses. /// </summary> /// <param name="listener">Interface to receive EventListener notifications.</param> /// <param name="filter">A test filter used to select tests to be run</param> /// <returns></returns> public ITestResult Run(ITestListener listener, ITestFilter filter) { log.Info("Running tests"); if (_loadedTest == null) { throw new InvalidOperationException("Run was called but no test has been loaded."); } // Save Console.Out and Error for later restoration TextWriter savedOut = Console.Out; TextWriter savedErr = Console.Error; TestExecutionContext initialContext = CreateTestExecutionContext(_settings); #if NUNITLITE initialContext.Listener = listener; WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter); workItem.Completed += new EventHandler(OnRunCompleted); workItem.Execute(); _runComplete.WaitOne(); return(workItem.Result); #else QueuingEventListener queue = new QueuingEventListener(); if (_settings.Contains("CaptureStandardOutput")) { initialContext.Out = new EventListenerTextWriter(queue, TestOutputType.Out); } if (_settings.Contains("CapureStandardError")) { initialContext.Error = new EventListenerTextWriter(queue, TestOutputType.Error); } initialContext.Listener = queue; int levelOfParallelization = _settings.Contains("NumberOfTestWorkers") ? (int)_settings["NumberOfTestWorkers"] : _loadedTest.Properties.ContainsKey(PropertyNames.LevelOfParallelization) ? (int)_loadedTest.Properties.Get(PropertyNames.LevelOfParallelization) : Math.Max(Environment.ProcessorCount, 2); WorkItemDispatcher dispatcher = null; if (levelOfParallelization > 0) { dispatcher = new WorkItemDispatcher(levelOfParallelization); initialContext.Dispatcher = dispatcher; // Assembly does not have IApplyToContext attributes applied // when the test is built, so we do it here. // TODO: Generalize this if (_loadedTest.Properties.ContainsKey(PropertyNames.ParallelScope)) { initialContext.ParallelScope = (ParallelScope)_loadedTest.Properties.Get(PropertyNames.ParallelScope) & ~ParallelScope.Self; } } WorkItem workItem = WorkItem.CreateWorkItem(_loadedTest, initialContext, filter); workItem.Completed += new EventHandler(OnRunCompleted); using (EventPump pump = new EventPump(listener, queue.Events)) { pump.Start(); if (dispatcher != null) { dispatcher.Dispatch(workItem); dispatcher.Start(); } else { workItem.Execute(); } _runComplete.WaitOne(); } Console.SetOut(savedOut); Console.SetError(savedErr); if (dispatcher != null) { dispatcher.Stop(); dispatcher = null; } return(workItem.Result); #endif }
/// <summary> /// Clear the current context. This is provided to /// prevent "leakage" of the CallContext containing /// the current context back to any runners. /// </summary> public static void ClearCurrentContext() { CurrentContext = null; }
/// <summary> /// Save the original current TestExecutionContext and /// make a new isolated context current. /// </summary> public IsolatedContext() { _originalContext = CurrentContext; CurrentContext = _originalContext.CreateIsolatedContext(); }
public void SetAndRestoreValueFormatter() { var context = new TestExecutionContext(setupContext); var originalFormatter = context.CurrentValueFormatter; try { ValueFormatter f = val => "dummy"; context.AddFormatter(next => f); Assert.That(context.CurrentValueFormatter, Is.EqualTo(f)); context.EstablishExecutionEnvironment(); Assert.That(MsgUtils.FormatValue(123), Is.EqualTo("dummy")); } finally { setupContext.EstablishExecutionEnvironment(); } Assert.That(TestExecutionContext.CurrentContext.CurrentValueFormatter, Is.EqualTo(originalFormatter)); Assert.That(MsgUtils.FormatValue(123), Is.EqualTo("123")); }
/// <summary> /// Construct a TestContext for an ExecutionContext /// </summary> /// <param name="ec">The ExecutionContext to adapt</param> public TestContext(TestExecutionContext ec) { this.ec = ec; }
public void SingleThreadedIsInherited() { var parent = new TestExecutionContext(); parent.IsSingleThreaded = true; Assert.True(new TestExecutionContext(parent).IsSingleThreaded); }
public void SetUp() { _context = new TestExecutionContext(); }
public void ExecutionStatusIsPulledFromHigherContext() { var topContext = new TestExecutionContext(); var bottomContext = new TestExecutionContext(new TestExecutionContext(new TestExecutionContext(topContext))); topContext.ExecutionStatus = TestExecutionStatus.AbortRequested; Assert.That(bottomContext.ExecutionStatus, Is.EqualTo(TestExecutionStatus.AbortRequested)); }
public static FakeWorkItem GetWorkItem(object obj, string name, TestExecutionContext context) { return GetWorkItem(obj.GetType(), name, context); }
public void OneTimeSetUp() { fixtureContext = TestExecutionContext.CurrentContext; }
/// <summary> /// Initializes a new instance of the <see cref="TestExecutionContext"/> class. /// </summary> /// <param name="other">An existing instance of TestExecutionContext.</param> public TestExecutionContext(TestExecutionContext other) { _priorContext = other; this.CurrentTest = other.CurrentTest; this.CurrentResult = other.CurrentResult; this.TestObject = other.TestObject; this.WorkDirectory = other.WorkDirectory; _listener = other._listener; this.StopOnError = other.StopOnError; this.TestCaseTimeout = other.TestCaseTimeout; this.UpstreamActions = new List<ITestAction>(other.UpstreamActions); _currentCulture = CultureInfo.CurrentCulture; _currentUICulture = CultureInfo.CurrentUICulture; #if !NETCF && !SILVERLIGHT && !PORTABLE _currentPrincipal = other.CurrentPrincipal; #endif this.Dispatcher = other.Dispatcher; this.ParallelScope = other.ParallelScope; }
public FakeWorkItem(Test test, TestExecutionContext context) : base(test) { InitializeContext(context); }
/// <summary> /// Initializes the underlying test engine. /// </summary> private static void InitializeTestEngine() { TestExecutionContext context = new TestExecutionContext(); context.WorkDirectory = Environment.CurrentDirectory; CallContext.SetData( "NUnit.Framework.TestContext", context ); }
public static FakeWorkItem GetWorkItem(Type type, string name, TestExecutionContext context) { return GetWorkItem(GetTestMethod(type, name), context); }
/// <summary> /// Saves the old context and makes a fresh one /// current without changing any settings. /// </summary> public static void Save() { TestExecutionContext.current = new TestExecutionContext(current); }
/// <summary> /// Initializes a new instance of the <see cref="TestExecutionContext"/> class. /// </summary> public TestExecutionContext() { _priorContext = null; this.TestCaseTimeout = 0; this.UpstreamActions = new List<ITestAction>(); _currentCulture = CultureInfo.CurrentCulture; _currentUICulture = CultureInfo.CurrentUICulture; #if !NETCF && !SILVERLIGHT && !PORTABLE _currentPrincipal = Thread.CurrentPrincipal; #endif }
/// <summary> /// Saves the old context and makes a fresh one /// current without changing any settings. /// </summary> public static void Save() { TestExecutionContext.current = new TestExecutionContext(current); }
/// <summary> /// Clear the current context. This is provided to /// prevent "leakage" of the CallContext containing /// the current context back to any runners. /// </summary> public static void ClearCurrentContext() { CurrentContext = null; }
/// <summary> /// Restores the last saved context and puts /// any saved settings back into effect. /// </summary> public static void Restore() { current.ReverseChanges(); int latestAsserts = current.AssertCount; current = current.prior; current.assertCount += latestAsserts; }
/// <summary> /// Initializes a new instance of the <see cref="TestExecutionContext"/> class. /// </summary> public TestExecutionContext() { this.prior = null; this.testCaseTimeout = 0; #if !NETCF this.currentCulture = CultureInfo.CurrentCulture; this.currentUICulture = CultureInfo.CurrentUICulture; #endif #if !NETCF && !SILVERLIGHT this.outWriter = Console.Out; this.errorWriter = Console.Error; this.traceWriter = null; this.tracing = false; #endif #if !NUNITLITE this.logging = false; this.currentDirectory = Environment.CurrentDirectory; this.logCapture = new Log4NetCapture(); this.currentPrincipal = Thread.CurrentPrincipal; #endif }
public void SetAndRestoreCurrentUICulture() { var context = new TestExecutionContext(setupContext); try { CultureInfo otherCulture = new CultureInfo(originalUICulture.Name == "fr-FR" ? "en-GB" : "fr-FR"); context.CurrentUICulture = otherCulture; Assert.AreEqual(otherCulture, CultureInfo.CurrentUICulture, "UICulture was not set"); Assert.AreEqual(otherCulture, context.CurrentUICulture, "UICulture not in new context"); Assert.AreEqual(setupContext.CurrentUICulture, originalUICulture, "Original context should not change"); } finally { setupContext.EstablishExecutionEnvironment(); } Assert.AreEqual(CultureInfo.CurrentUICulture, originalUICulture, "UICulture was not restored"); Assert.AreEqual(setupContext.CurrentUICulture, originalUICulture, "UICulture not in final context"); }
internal static void SetCurrentContext(TestExecutionContext ec) { #if SILVERLIGHT || NETCF || __MOBILE__ current = ec; #else CallContext.SetData(CONTEXT_KEY, ec); #endif }
public void SetAndRestoreCurrentPrincipal() { var context = new TestExecutionContext(setupContext); try { GenericIdentity identity = new GenericIdentity("foo"); context.CurrentPrincipal = new GenericPrincipal(identity, new string[0]); Assert.AreEqual("foo", Thread.CurrentPrincipal.Identity.Name, "Principal was not set"); Assert.AreEqual("foo", context.CurrentPrincipal.Identity.Name, "Principal not in new context"); Assert.AreEqual(setupContext.CurrentPrincipal, originalPrincipal, "Original context should not change"); } finally { setupContext.EstablishExecutionEnvironment(); } Assert.AreEqual(Thread.CurrentPrincipal, originalPrincipal, "Principal was not restored"); Assert.AreEqual(setupContext.CurrentPrincipal, originalPrincipal, "Principal not in final context"); }