using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Runtime.CompilerServices;

using System.Threading.Tasks;

​

using Xunit;

public class Program

{

    public static async Task Main()

    {

        var testAssemblies = new Assembly[] 

        {

            typeof(Program).Assembly

        };

        var testRunner = new XunitTestRunner();

        await testRunner.RunAsync(testAssemblies);

    }

}

​

public sealed class XunitTestRunner

{

    public async Task RunAsync(IEnumerable<Assembly> assemblies)

    {

        Console.WriteLine("Test runner starting...");

        var testEntries = assemblies

            .SelectMany(asm => asm.GetTypes()

            .SelectMany(type =>

            {

                var testEntries = type

                    .GetMethods(

                        BindingFlags.NonPublic |

                        BindingFlags.Public |

                        BindingFlags.Instance)

                    .Select(method =>

                    {

                        var factAttr = method.GetCustomAttribute(typeof(FactAttribute));

                        if (factAttr == null)

                        {

                            return null;

                        }

                        return method;

                    })

                    .Where(method => method != null)

                    .Select(method => new

                    {

                        Type = type,

                        TestMethod = method,

                    });

                return testEntries;

            }))

            .ToArray();

        Console.WriteLine($"Test runner found {testEntries.Length} tests.");

        foreach (var testEntry in testEntries)

        {

            var testName = $"{testEntry.Type.Name}.{testEntry.TestMethod.Name}";

            Console.WriteLine($"Running '{testName}'...");

            try

            {

                var instance = Activator.CreateInstance(testEntry.Type);

                var isAsync = testEntry

                    .TestMethod

                    .GetCustomAttributes(typeof(AsyncStateMachineAttribute), false)

                    .Any();

                if (isAsync)

                {

                    var asyncTestMethod = (Func<Task>)testEntry.TestMethod.CreateDelegate(typeof(Func<Task>), instance);

                    await asyncTestMethod();

                }

                else

                {

                    testEntry.TestMethod.Invoke(instance, null);

                }

            }

            catch (Exception ex)

            {

                Console.WriteLine(

                    $"Exception caught running '{testName}':\r\n" +

                    $"{ex.GetType()}: {ex.Message}\r\n" +

                    $"Stack Trace:{ex.StackTrace}");

            }

        }

        Console.WriteLine("Test runner complete.");

    }

}

​

public sealed class Tests

{

    [Fact]

    private void XX_XX_XX()

    {

        Console.WriteLine("Test...");

    }

    [Fact]

    private async Task yy_yy_yy()

    {

        await Task.Run(() => Console.WriteLine("async test..."));

    }

}