Problems running multiple xunit tests under STA Thread WPF - wpf

Question

Following on from my experimentation with xunit wpf tests I have hit an issue when running multiple tests.
The issue is when I am checking Application.Current.Windows in my assertions.
The Code
To replicate the following code will cause the issue:
TestWindow
<Window x:Class="acme.foonav.Issues.TestWindow"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
xmlns:local="clr-namespace:acme.foonav.Issues"
mc:Ignorable="d"
Title="TestWindow" Height="450" Width="800">
<Grid>
</Grid>
</Window>
Test
public class WpfFactIssues
{
public WpfFactIssues()
{
if (Application.Current == null)
{
new Application();
}
}
[WpfFact]
public void Test1()
{
TestWindow window = new TestWindow();
Assert.Equal(typeof(TestWindow), Application.Current.Windows[0]?.GetType());
}
[WpfFact]
public void Test2()
{
TestWindow window = new TestWindow();
Assert.Equal(typeof(TestWindow), Application.Current.Windows[0]?.GetType());
}
}
So here, Test1 and Test2 are identical. I have removed any other logic not required to demonstrate this scenario to focus on the actual issue - and not why would I want to do this!
The purpose of the scenario was to check whether a window was added into the current application's window collection.
We are using Xunit.StaFact to manage running on the STA Thread.
The Issue
If I execute ALL tests (in Rider) then Test1 will pass, and Test2 will fail on the assertion.
System.InvalidOperationException: The calling thread cannot access this object because a different thread owns it.
However, I can successfully execute Test1 and Test2 individually.
When executing, Test1 will run on say thread id (Thread.CurrentThread.ManagedThreadId) of 20 then Test2 will execute on.
When Test2 executes, then Application.Current is set to what Test1 setup.
What I have tried
Implementing IDisposable and trying calling Application.Current?.Shutdown() in the desperate attempt to make it work.
public void Dispose()
{
if (Application.Current != null)
{
ManualResetEventSlim manualResetEvent = new ManualResetEventSlim(false);
Application.Current.Exit += (sender, args) => { manualResetEvent.Set(); };
Application.Current?.Shutdown();
manualResetEvent.Wait(TimeSpan.FromSeconds(5));
}
}
Here the Exit event is never raised.
This will throw a different exception:
System.InvalidOperationException: Cannot create more than one System.Windows.Application instance in the same AppDomain.
Help!
Is there a way to work with the Application in unit tests when executing lots of methods in the same class?
Update
Currently looking at:
Manage Application.Current while all tests are running in Test Project

Answer 1

I'll post this on here for now, although it solves the issue, it yields a further issue.
If we implement a dispose pattern on the test class, we can force a shutdown of the application. This is somewhat slightly crude.
public void Dispose()
{
if (Application.Current != null)
{
Application.Current.Shutdown(0);
var result = Application.Current.Dispatcher.InvokeAsync(() => { }, DispatcherPriority.ContextIdle).Result;
}
}
However, when the second test runs, the following exception will be thrown:
System.InvalidOperationException: Cannot create more than one System.Windows.Application instance in the same AppDomain.
Don't try this at home!
So lets have some hacky fun with reflection around the internals of Application - to make this work - at least for this scenario:
Let's track our test state around the Application:
public static class FooYou
{
public static bool hasInited = false;
}
This all becomes clear when we new up the Application in our test constructor:
public WpfFactIssues()
{
if (Application.Current == null)
{
new Application()
{
ShutdownMode = ShutdownMode.OnExplicitShutdown
};
if (!FooYou.hasInited)
{
FooYou.hasInited = true;
}
else
{
var appInit = typeof(Application).GetMethod("ApplicationInit", BindingFlags.Static | BindingFlags.NonPublic);
appInit.Invoke(null, null);
}
}
}
One final change in the dispose implementation - pretend the app wasn't created in this app domain otherwise this causes the Cannot create more than one System.Windows.Application instance in the same AppDomain exception.
public void Dispose()
{
if (Application.Current != null)
{
Application.Current.Resources.MergedDictionaries.Clear();
Application.Current.Shutdown(0);
var result = Application.Current.Dispatcher.InvokeAsync(() => { }, DispatcherPriority.ContextIdle).Result;
var appCreated = typeof(Application).GetField("_appCreatedInThisAppDomain",
BindingFlags.Static |
BindingFlags.NonPublic);
appCreated.SetValue(null, false);
}
}
Here we are forcing the reinit of the Application - as done by the Application's static initializer.
Of course, this is a hideous abomination of a solution. It's dirty. It is of course very susceptible to breaking - never touch a classes privates.
A more workable application of helpers
The above is a little crude, so wrapping up to make the tests work without much effort:
using System.Reflection;
using System.Windows;
using System.Windows.Threading;
namespace acme.foonav.Fixture
{
public static class ApplicationState
{
private static bool hasApplicationPreviouslyInitialized;
public static void CreateNew()
{
Shutdown();
if (Application.Current == null)
{
new Application()
{
ShutdownMode = ShutdownMode.OnExplicitShutdown
};
if (!hasApplicationPreviouslyInitialized)
{
hasApplicationPreviouslyInitialized = true;
}
else
{
var pre = typeof(Application);
var clear = pre.GetMethod("ApplicationInit", BindingFlags.Static | BindingFlags.NonPublic);
clear.Invoke(null, null);
}
}
}
public static void Shutdown()
{
if (Application.Current != null)
{
Application.Current.Resources.MergedDictionaries.Clear();
Application.Current.Shutdown(0);
var result = Application.Current.Dispatcher.InvokeAsync(() => { }, DispatcherPriority.ContextIdle).Result;
var appCreated = typeof(Application).GetField("_appCreatedInThisAppDomain",
BindingFlags.Static |
BindingFlags.NonPublic);
appCreated.SetValue(null, false);
}
}
}
}
Base class for tests that need to use Application:
using System;
using System.Threading.Tasks;
using System.Windows.Threading;
using acme.foonav.Fixture;
namespace acme.foonav
{
public abstract class ApplicationContextTest : IDisposable
{
protected ApplicationContextTest() => ApplicationState.CreateNew();
public void Dispose() => ApplicationState.Shutdown();
protected async Task AwaitDispatcher() => await Dispatcher.CurrentDispatcher.InvokeAsync(() => { }, DispatcherPriority.ContextIdle);
}
}
A test file:
using System.Windows;
using Xunit;
namespace acme.foonav.Issues
{
public class WpfFactIssues : ApplicationContextTest
{
[WpfFact]
public void Test1()
{
TestWindow window = new TestWindow();
Assert.Equal(typeof(TestWindow), Application.Current.Windows[0]?.GetType());
}
[WpfFact]
public void Test2()
{
TestWindow window = new TestWindow();
Assert.Equal(typeof(TestWindow), Application.Current.Windows[0]?.GetType());
}
}
}
And make sure the tests don't execute in parallel:
using Xunit;
[assembly: CollectionBehavior(DisableTestParallelization = true)]