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