Why can't "async void" unit tests be recognized?

Question

async void unit tests cannot be run within Visual Studio 2012:

[TestClass]
public class MyTestClass
{
    [TestMethod]
    public async void InvisibleMyTestMethod()
    {
        await Task.Delay(1000);
        Assert.IsTrue(true);
    }
}

If I want to have an asynchronous unit test, the test method has to return a Task:

[TestMethod]
public async Task VisibleMyTestMethod()
{
    await Task.Delay(1000);
    Assert.IsTrue(true);
}

Why is it so? Not that I absolutely need to have an async void test method, I am just curious. Visual Studio 2012 gives no warning nor error when you build an async void test method even though it won't be able to be run...

Solution 1

async void methods should be considered as "Fire and Forget" - there is no way to wait for them to finish. If Visual Studio were to start one of these tests, it wouldn't be able to wait for the test to complete (mark it as successful) or trap any exceptions raised.

With an async Task, the caller is able to wait for execution to complete, and to trap any exceptions raised while it runs.

See this answer for more discussion of async void vs async Task.

Solution 2

It's just because MSTest doesn't support async void unit tests. It is possible to do so by introducing a context in which they can execute.

MSTest doesn't support this, probably because Microsoft decided it was too much of a change for existing tests (it's possible that existing tests would deadlock if they were given an unexpected context).

There's no compiler warning/error because it's perfectly valid C# code. The only reason it doesn't work is because of the unit test framework (i.e., I believe that xUnit does support async void tests), and it would be a gross violation of separation of concerns for the C# compiler to look at your attributes, determine you are using MSTest, and decide that you really didn't want to use async void.

Solution 3

I found in VS2015 that any Test methods decorated with async would not show in Test Explorer. I ended up removing the async keyword and replacing the await call in the test with a task.Wait() and done my asertions on task.Result.

Seems to be working ok. Haven't tried it with exception testing yet.

var task = TheMethodIWantToTestAsync(someValue);
task.Wait();
var response = task.Result;

Assert.IsNotNull(response);
Assert.IsTrue(response.somevalue);

Comments

[Paulo Morgado]

In the first implementation (Visual Studio Preview) the test would be recogized and "run". The problema was that the method would end on the first await and that was the result of the test.

[Anupam]

This is not true. NUnit does support async void tests and how and why of supporting it is detailed to some extent in this link. See answer below.

[dragonfly02]

Don't think it needs to call task.Wait() as calling task.Result will call task.Wait() automatically if the task hasn't finished.