Styjun

I want to unit test my UI classes (without actually showing it). I do this by invoking the constructor then calling various methods on it (as you would a normal class). At no point does the UI actually get shown by windows. However some of the UIs will throw up a modal dialog under some circumstances, I want to treat this as an error condition and fail the test.

I have tried the Timeout attribute but it isn't working (Test1), it just shows the dialog and hangs the test. I have an implementation (Test2) which works but it's a bit ugly.

Is there a cleaner way of treating modal windows as an error condition? / forcing a timeout even when modal dialogue is showing.

I am using Visual Studio test runner and nunit version 3

class Test

 //does not work
 [Test, Timeout(5000)]
 public void Test1()
 
 //blocks test and timeout is not respected
 MessageBox.Show("It went wrong");
 

 //works but is ugly
 [Test]
 public void Test2()
 
 Task runUIStuff = new Task(()=>
 
 MessageBox.Show("It went wrong"); 

 );
 runUIStuff.Start();

 Task.WaitAny(Task.Delay(5000), runUIStuff);

 if(!runUIStuff.IsCompleted)
 
 Process.GetCurrentProcess().CloseMainWindow();
 Assert.Fail("Test did not complete after timeout");
 
 

Update

Thanks for the pointer to Coded UI Tests. That looks like a good potential solution.

Since I did get something working in the mean time I thought I'd update it. This solution involves running the test in a STA thread with a custom timeout/shutdown implementation. It is an NUnitAttribute so can be used just like [Test]. It's pretty hacky and (presumabily) windows specific but it does seem to work reliably for my environment (where I don't actually want the UIs showing at all).

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using NUnit.Framework;
using NUnit.Framework.Interfaces;
using NUnit.Framework.Internal;
using NUnit.Framework.Internal.Commands;

namespace CatalogueLibraryTests.UserInterfaceTests

 [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
 class UITimeoutAttribute : NUnitAttribute, IWrapTestMethod
 
 private readonly int _timeout;

 /// <summary>
 /// Allows <paramref name="timeout"/> for the test to complete before calling <see cref="Process.CloseMainWindow"/> and failing the test
 /// </summary>
 /// <param name="timeout">timeout in milliseconds</param>
 public UITimeoutAttribute(int timeout)
 
 this._timeout = timeout;
 

 /// <inheritdoc/>
 public TestCommand Wrap(TestCommand command)
 
 return new TimeoutCommand(command, this._timeout);
 

 private class TimeoutCommand : DelegatingTestCommand
 
 private int _timeout;

 public TimeoutCommand(TestCommand innerCommand, int timeout): base(innerCommand)
 
 _timeout = timeout;
 

 [DllImport("user32.dll", CharSet = CharSet.Auto)]
 private static extern IntPtr SendMessage(IntPtr hWnd, UInt32 Msg, int wParam, IntPtr lParam);

 [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Auto)]
 static extern int GetClassName(IntPtr hWnd, StringBuilder lpClassName, int nMaxCount);

 [DllImport("user32.dll")]
 static extern IntPtr GetDlgItem(IntPtr hDlg, int nIDDlgItem);

 private string YesNoDialog = "#32770";

 private const UInt32 WM_CLOSE = 0x0010;
 private const UInt32 WM_COMMAND = 0x0111;
 private int IDNO = 7;


 public override TestResult Execute(TestExecutionContext context)
 
 TestResult result = null;
 Exception threadException = null;

 Thread thread = new Thread(() =>
 
 try
 
 result = innerCommand.Execute(context);
 
 catch (Exception ex)
 
 threadException = ex;
 
 );
 thread.SetApartmentState(ApartmentState.STA);
 thread.Start();

 try
 
 while (thread.IsAlive && (_timeout > 0 
 catch (AggregateException ae)
 
 throw ae.InnerException;
 
 
 
 

Usage

[Test, UITimeout(500)]
public void TestMessageBox()

 MessageBox.Show("hey");

[Test, UITimeout(500)]
public void TestMessageBoxYesNo()

 MessageBox.Show("hey","there",MessageBoxButtons.YesNo);

NUnit is really not equiped to test UI. Assuming from the flags you are working with Winforms in c# you should switch to CodedUI tests for this.
It is also advizable to try and take the code out of the form classes and bind to a view-model. The view and viewmodels will be testable and you code will be cleaner.