public override void TestPassed(object sender, TestEventArgs <UnitTestMethod> args) { UnitTestMethod test = args.Test.CopyAs <UnitTestMethod>(); TestExecution testExecution = GetTestExecution(test); testExecution.Passed = true; TestReportService.SaveTestExecution(testExecution); }
private void OnTestEvent(object sender, TestEventArgs e) { events.Add(e); if (e.Action == TestAction.RunFinished) { GotRunFinished = true; } }
private void OnTestStarting(object sender, TestEventArgs args) { if (settings.GetSetting("Gui.ResultTabs.DisplayTestLabels", false)) { //this.stdoutTab.AppendText( string.Format( "***** {0}\n", args.TestName.FullName ) ); this.stdoutTab.Writer.WriteLine("***** {0}", args.TestName.FullName); } }
private void OnTestUnloaded(object sender, TestEventArgs e) { ClosePropertiesDialog(); Clear(); contextNode = null; runCommandEnabled = false; }
private void OnTestException(object sender, TestEventArgs args) { string msg = string.Format("An unhandled {0} was thrown while executing this test : {1}", args.Exception.GetType().FullName, args.Exception.Message); TestResultItem item = new TestResultItem(args.Name, msg, args.Exception.StackTrace); InsertTestResultItem(item); }
public override void TestStarting(object sender, TestEventArgs <UnitTestMethod> args) { TestSuiteDefinition suite = TestSuiteDefinition.FromTestEventArgs(args); UnitTestMethod test = args.Test.CopyAs <UnitTestMethod>(); TestDefinition testDefinition = GetTestDefinition(suite.Title, test); SetTestExecution(args); }
protected virtual void OnProgress(TestEventArgs e) { var handler = Progress; if (handler != null) { handler(this, e); } }
public void Event_Should_Be_Routed_To_Device_Target() { InputElement element = new InputElement(); TestEventArgs e = new TestEventArgs(element); e.RoutedEvent = InputElement.RawEvent; InputManager.Current.ProcessInput(e); Assert.IsTrue(element.RawEventRaised); }
static void TestEventHandler(object sender, TestEventArgs args) { // SELECT ONE // Console.WriteLine("TEST HANDLER: " + args); // Console.WriteLine("TEST HANDLER: " + args.DataRaw); // Console.WriteLine("TEST HANDLER: " + args.DataType); // Console.WriteLine("TEST HANDLER: " + args.Schema); Console.WriteLine("TEST HANDLER: [{0}]", string.Join(", ", args.DataTest.Arguments)); }
private void OnTestFinished(object sender, TestEventArgs args) { TestResult result = args.Result; if (result.ResultState == ResultState.Skipped || result.ResultState == ResultState.Ignored) { this.AddNode(args.Result); } }
private void OnSuiteFinished(object sender, TestEventArgs e) { TestResult result = e.Result; if (result.RunState == RunState.Executed && result.IsFailure && result.FailureSite == FailureSite.TearDown) { ForeColor = FailureColor; } }
private void OnTestFinished(object sender, TestEventArgs args) { TestResult result = args.Result; if (result.Executed && result.IsFailure && result.FailureSite != FailureSite.Parent) { InsertTestResultItem(result); } }
private void OnTestFinished(object sender, TestEventArgs args) { TestResult result = args.Result; if (!result.Executed) { this.AddNode(args.Result); } }
private void OnSuiteFinished(object sender, TestEventArgs e) { TestResult result = e.Result; if ((result.IsFailure || result.IsError) && result.FailureSite == FailureSite.TearDown) { ForeColor = FailureColor; } }
private void OnTestChanged(object sender, TestEventArgs e) { TestNode test = e.Test as TestNode; if (test != null) { Invoke(new LoadHandler(Reload), new object[] { test }); } }
public override void TestsFinished(object sender, TestEventArgs <UnitTestMethod> args) { UnitTestMethod test = args.Test.CopyAs <UnitTestMethod>(); TestSuiteDefinition suite = GetTestSuiteDefinition(args); TestSuiteExecutionSummary summary = GetTestSuiteExecutionSummary(suite); summary.FinishedTime = DateTime.UtcNow; TestReportService.SaveTestSuiteExecutionSummary(summary); }
public void TestDispatch() { var expected = new TestEventArgs(); var mock = new Mock <IResponse>(); eventDispatcher.AddListener("foo", mock.Object.Foo); eventDispatcher.Dispatch("foo", expected); mock.Verify((o) => o.Foo(expected)); }
private void OnRunStarting(object sender, TestEventArgs e) { Initialize(e.TestCount, "Running :" + e.Name); DisplayTestCount(); DisplayTestsRun(); DisplayErrors(); DisplayFailures(); DisplayTime(); }
/// <summary> /// Callback Method for the TestLoaded Event /// </summary> /// <param name="sender">Sender that triggered the event</param> /// <param name="args"><see cref="TestEventArgs"/> of the Event</param> private static void NodeLoadEvent(object sender, TestEventArgs args) { var test = args.Test as TestNode; if (test != null) { AddNode(test); } }
protected virtual void OnTest(TestEventArgs e) { EventHandler <TestEventArgs> handler = Test; if (handler != null) { handler(this, e); } }
public void RaiseTestEvent(string eventData) { var arg = new TestEventArgs() { EventData = eventData }; OnTest(arg); }
private void OnCompleteTestCase(object src, TestEventArgs args) { if (args.TestStatus == TestEventArgs.Status.Fail) { string msg = string.Format("Failed in Test Dll {0} on Test Case {1} with the error {2}", args.DLL, args.CurrentRun, args.TestCase.ErrorSolution); Assert.IsTrue(false, msg); } else Assert.IsTrue(true); }
public void TestAsyncEvents() { var evtSource = new AsyncEventSource(); evtSource.TestEvent += AsyncEventsTest_AsyncHandler; evtSource.TestEvent += AsyncEventsTest_SyncHandler; var args = new TestEventArgs() { Value = 2 }; // incr value; our counter should be incremented twice by 2 - in two event handlers _counter = 0; AsyncHelper.RunSync(() => evtSource.RaiseEvent(args)); // now _counter should be 4 Assert.AreEqual(4, _counter, "Expected _counter set to 4"); }//test method
private void OnTestChanged(object sender, TestEventArgs e) { UITestNode test = e.Test; Invoke(new LoadHandler(Reload), new object[] { test }); if (ClearResultsOnChange) { ClearResults(); } }
private void OnTestFinished(object sender, TestEventArgs args) { TestResult result = args.Result; if ((result.IsFailure || result.IsError) && result.FailureSite != FailureSite.Parent || result.ResultState == ResultState.NotRunnable) { InsertTestResultItem(result); } }
private void OnSuiteFinished(object sender, TestEventArgs args) { TestResult result = args.Result; if ((result.IsFailure || result.IsError) && result.FailureSite != FailureSite.Child) { InsertTestResultItem(result); } }
private void updateTime(object sender, TestEventArgs e) { if (Dispatcher.CheckAccess()) { timeLabel.Content = e.Time; } else { Dispatcher.BeginInvoke(timeHandler, new Object[] { this, e }); } }
private void OnTestLoaded(object sender, TestEventArgs e) { CheckPropertiesDialog(); TestNode test = e.Test as TestNode; if (test != null) { Load(test); } runCommandEnabled = true; }
private void OnTestReloaded(object sender, TestEventArgs e) { if (Services.UserSettings.GetSetting("Options.TestLoader.ClearResultsOnReload", false)) { Initialize(e.TestCount); } else { Value = Maximum = e.TestCount; } }
private void OnRunFinished(object sender, TestEventArgs e) { if (e.Exception != null) { statusPanel.Text = "Failed"; } else { statusPanel.Text = "Completed"; DisplayResults(e.Results); } }
void _test_OnTestStarting(object sender, TestEventArgs args) { if (InvokeRequired) { Invoke(new TestStartingEvent(_test_OnTestStarting), sender, args); } else { _grid.Rows.Add(args.TestName, "Starting", null, null); _grid.FirstDisplayedScrollingRowIndex = _grid.Rows.Count - 1; } }
private void OnTestFinished(object sender, TestEventArgs e) { if (DisplayTestProgress && e.Result.Executed) { ++testsRun; DisplayTestsRun(); if (e.Result.IsFailure) { ++failures; DisplayFailures(); } } }
public void Event_Should_Not_Be_Routed_If_Cancelled() { PreProcessInputEventHandler preProcess = (sender, ev) => { ev.Cancel(); }; InputElement element = new InputElement(); TestEventArgs e = new TestEventArgs(element); e.RoutedEvent = InputElement.RawEvent; InputManager.Current.PreProcessInput += preProcess; InputManager.Current.ProcessInput(e); InputManager.Current.PreProcessInput -= preProcess; Assert.IsFalse(element.RawEventRaised); }
void _test_OnTestFinished(object sender, TestEventArgs args) { if (InvokeRequired) Invoke(new TestCompletedEvent(_test_OnTestFinished), sender, args); else { _grid.Rows[_grid.Rows.Count - 1].SetValues(args.TestName, args.Result, args.Duration, (args.Exception == null) ? args.Message : args.Exception.Message); if (args.Result == TestResultEnum.Failed) { _grid.Rows[_grid.Rows.Count - 1].Cells[1].Style.BackColor = Color.Red; } else if (args.Result == TestResultEnum.Inconclusive) { _grid.Rows[_grid.Rows.Count - 1].Cells[1].Style.BackColor = Color.LightBlue; } //_grid.Rows[_grid.Rows.Count - 1].Height = _grid.Rows[_grid.Rows.Count - 1].GetPreferredHeight(_grid.Rows.Count - 1, DataGridViewAutoSizeRowMode.AllCells, true); } }
public void PreNotifyInput_Should_Be_Called() { bool notified = false; NotifyInputEventHandler preNotify = (sender, ev) => { notified = true; }; InputElement element = new InputElement(); TestEventArgs e = new TestEventArgs(element); e.RoutedEvent = InputElement.RawEvent; InputManager.Current.PreNotifyInput += preNotify; InputManager.Current.ProcessInput(e); InputManager.Current.PreNotifyInput -= preNotify; Assert.IsTrue(notified); }
public void event_passes_correct_arguments() { var expectedString = "test"; var actualString = string.Empty; var testEventArgs = new TestEventArgs(); testEventArgs.TestString = expectedString; var rootState = new StateMachineBuilder() .State<TestState>("foo") .Event<TestEventArgs>("newEvent", (state, eventArgs) => actualString = eventArgs.TestString) .End() .Build(); rootState.ChangeState("foo"); rootState.TriggerEvent("newEvent", testEventArgs); Assert.Equal(expectedString, actualString); }
public void FireEventWithMultipleHandlersTest() { // Arrange eventUnderTest.EventSinks += ( sender, args ) => { args.Continue = true; }; eventUnderTest.EventSinks += ( sender, args ) => { args.Continue = true; }; eventUnderTest.EventSinks += ( sender, args ) => { args.Continue = true; }; var argsUnderTest = new TestEventArgs() { Continue = true }; // Act eventUnderTest.Fire( this, argsUnderTest, ( args ) => args.Continue == true ); // Assert Assert.IsTrue( argsUnderTest.Continue ); }
private void OnTestEvent( object sender, TestEventArgs e ) { events.Add( e ); if (e.Action == TestAction.RunFinished) GotRunFinished = true; }
private void OnRunStarting( object sender, TestEventArgs e ) { suiteName.Text = e.Name; EnableRunCommand( false ); EnableStopCommand( true ); runCount.Text = ""; }
/// <summary> /// The current test suite has changed in some way, /// so update the info in the UI and clear the /// test results, since they are no longer valid. /// </summary> private void OnTestChanged( object sender, TestEventArgs e ) { SetTitleBar(TestProject.Name); if ( longOpDisplay != null ) { longOpDisplay.Dispose(); longOpDisplay = null; } if (userSettings.GetSetting("Options.TestLoader.ClearResultsOnReload", false)) runCount.Text = null; EnableRunCommand( true ); }
/// <summary> /// A test suite has been loaded, so update /// recent assemblies and display the tests in the UI /// </summary> private void OnTestLoaded( object sender, TestEventArgs e ) { if ( longOpDisplay != null ) { longOpDisplay.Dispose(); longOpDisplay = null; } EnableRunCommand( true ); if ( TestLoader.TestCount == 0 ) { foreach( TestAssemblyInfo info in TestLoader.AssemblyInfo ) if ( info.TestFrameworks.Count > 0 ) return; MessageDisplay.Error("This assembly was not built with any known testing framework."); } }
private void OnTestUnloadStarting( object sender, TestEventArgs e ) { EnableRunCommand( false ); }
private void OnTestProjectUnloaded( object sender, TestEventArgs e ) { SetTitleBar( null ); projectMenu.Visible = false; runCount.Text = ""; }
private void OnTestProjectLoaded( object sender, TestEventArgs e ) { string projectPath = e.Name; SetTitleBar( projectPath ); projectMenu.Visible = true; runCount.Text = ""; // If this is an NUnit project, set up watcher if (NUnitProject.IsNUnitProjectFile(projectPath) && File.Exists(projectPath)) presenter.WatchProject(projectPath); }
protected virtual void OnProgress(TestEventArgs e) { var handler = Progress; if (handler != null) handler(this, e); }
public void Execute(TestEventArgs args) { ExecutionCount++; }
public void FireEventWithMultipleHandlersDoesNotContinueAfterFirstHandlerTest() { string lastEventHandler = String.Empty; // Arrange eventUnderTest.EventSinks += ( sender, args ) => { lastEventHandler = "EventHandlerOne"; args.Continue = false; }; eventUnderTest.EventSinks += ( sender, args ) => { lastEventHandler = "EventHandlerTwo"; args.Continue = true; }; eventUnderTest.EventSinks += ( sender, args ) => { lastEventHandler = "EventHandlerThree"; args.Continue = true; }; var argsUnderTest = new TestEventArgs() { Continue = true }; // Act eventUnderTest.Fire( this, argsUnderTest, ( args ) => args.Continue == true ); // Assert Assert.IsTrue( argsUnderTest.Continue == false && lastEventHandler == "EventHandlerOne", "{0} returned {1}", lastEventHandler, argsUnderTest.Continue ); }
private void OnTestProjectUnloading(object sender, TestEventArgs e) { // Remove any watcher if (e.Name != null && File.Exists(e.Name)) { presenter.RemoveWatcher(); Version version = Environment.Version; foreach( TestAssemblyInfo info in TestLoader.AssemblyInfo ) if ( info.ImageRuntimeVersion < version ) version = info.ImageRuntimeVersion; recentFilesService.SetMostRecent( new RecentFileEntry( e.Name, version ) ); } }
protected virtual void Fire( TestEventHandler handler, TestEventArgs e ) { if ( handler != null ) handler( this, e ); }
private void OnProjectLoadFailure(object sender, TestEventArgs e) { MessageDisplay.Error("Project Not Loaded", e.Exception); recentFilesService.Remove(e.Name); EnableRunCommand(IsProjectLoaded); }
private void OnLoadComplete( object sender, TestEventArgs e ) { Initialize( e.TestCount ); }
private void OnReloadStarting( object sender, TestEventArgs e ) { EnableRunCommand( false ); longOpDisplay = new LongRunningOperationDisplay( this, "Reloading..." ); }
private void OnRunStarting( object Sender, TestEventArgs e ) { Initialize( e.TestCount ); }
/// <summary> /// A test suite has been unloaded, so clear the UI /// and remove any references to the suite. /// </summary> private void OnTestUnloaded( object sender, TestEventArgs e ) { suiteName.Text = null; runCount.Text = null; EnableRunCommand( false ); Refresh(); }
private void OnTestException(object sender, TestEventArgs e) { ForeColor = FailureColor; }
/// <summary> /// Event handler for assembly load failures. We do this via /// an event since some errors may occur asynchronously. /// </summary> private void OnTestLoadFailure( object sender, TestEventArgs e ) { if ( longOpDisplay != null ) { longOpDisplay.Dispose(); longOpDisplay = null; } string message = e.Action == NUnit.Util.TestAction.TestReloadFailed ? "Test reload failed!" : "Test load failed!"; if ( e.Exception is BadImageFormatException ) message += string.Format( Environment.NewLine + Environment.NewLine + @"You may be attempting to load an assembly built with a later version of the CLR than the version under which NUnit is currently running ({0}) or trying to load a 64-bit assembly into a 32-bit process.", Environment.Version.ToString(3) ); MessageDisplay.Error(message, e.Exception); if ( !IsTestLoaded ) OnTestUnloaded( sender, e ); else EnableRunCommand( true ); }
private void OnTestFinished( object sender, TestEventArgs e ) { PerformStep(); switch (e.Result.RunState) { case RunState.Executed: if (e.Result.IsFailure) ForeColor = FailureColor; break; case RunState.Ignored: if (ForeColor == SuccessColor) ForeColor = IgnoredColor; break; default: break; } }
private void OnRunFinished( object sender, TestEventArgs e ) { EnableStopCommand( false ); EnableRunCommand( false ); if ( e.Exception != null ) { if ( ! ( e.Exception is System.Threading.ThreadAbortException ) ) MessageDisplay.Error("NUnit Test Run Failed", e.Exception); } ResultSummarizer summary = new ResultSummarizer( e.Result ); this.runCount.Text = string.Format( "Passed: {0} Failed: {1} Errors: {2} Inconclusive: {3} Invalid: {4} Ignored: {5} Skipped: {6} Time: {7}", summary.Passed, summary.Failures, summary.Errors, summary.Inconclusive, summary.NotRunnable, summary.Ignored, summary.Skipped, summary.Time); try { TestLoader.SaveLastResult("TestResult.xml"); } catch (Exception ex) { log.Warning("Unable to save TestResult.xml\n{0}", ex.ToString()); } EnableRunCommand(true); if (e.Result.ResultState == ResultState.Failure || e.Result.ResultState == ResultState.Error || e.Result.ResultState == ResultState.Cancelled) { this.Activate(); } }
private void OnUnloadComplete( object sender, TestEventArgs e ) { Initialize( 100 ); }