public void InheritedClassDoingConstructionCall()
    {
        var type    = assemblyWeaver.Assembly.GetType("InheritedClassDoingConstructionCall");
        var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message[0].StartsWith("InheritedClassDoingConstructionCall.ctor "), message[0]);
    }
    public void MethodWithReturn()
    {
        var type     = assemblyWeaver.Assembly.GetType("MiscMethods");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() => instance.MethodWithReturn());

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message.First().StartsWith("MiscMethods.MethodWithReturn "));
    }
    public void GenericClassWithMethod()
    {
        var type     = assemblyWeaver.Assembly.GetType("GenericClassWithMethod`1[[System.String, mscorlib]]");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() => instance.Method());

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message.First().StartsWith("GenericClassWithMethod`1.Method "));
    }
    public void ClassWithAttribute()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAttribute");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() => instance.Method());

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message.First().StartsWith("ClassWithAttribute.Method "));
    }
    public void ClassWithConstructor()
    {
        var type    = assemblyWeaver.Assembly.GetType("ClassWithConstructor");
        var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));

        Assert.AreEqual(2, message.Count);
        Assert.IsTrue(message[0].StartsWith("ClassWithConstructor.cctor "));
        Assert.IsTrue(message[1].StartsWith("ClassWithConstructor.ctor "));
    }
    public void InheritedClass()
    {
        var type    = assemblyWeaver.Assembly.GetType("InheritedClass");
        var message = DebugRunner.CaptureDebug(() => Activator.CreateInstance(type));

        Assert.AreEqual(1, message.Count);
        var first = message.First();

        Assert.IsTrue(first.StartsWith("InheritedClass.ctor "), first);
    }
    public void ClassWithAsyncMethod()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithCompilerGeneratedTypes");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() =>
        {
            var task = (Task)instance.AsyncMethod();
            task.Wait();
        });

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message.First().StartsWith("ClassWithCompilerGeneratedTypes.AsyncMethod "));
    }
    public void ClassWithAsyncMethodWithFastPath(bool recurse)
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() =>
        {
            var task = (Task)instance.MethodWithFastPathAsync(recurse);
            task.Wait();
        });

        Assert.AreEqual(recurse ? 2 : 1, message.Count);
        Assert.IsTrue(message.First().StartsWith("ClassWithAsyncMethod.MethodWithFastPathAsync "));
    }
    public void ClassWithYieldMethod()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithCompilerGeneratedTypes");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() =>
        {
            var task = (IEnumerable <string>)instance.YieldMethod();
            task.ToList();
        });

        Assert.AreEqual(0, message.Count);
        //TODO: support yield
        //Assert.IsTrue(message.First().StartsWith("ClassWithCompilerGeneratedTypes.YieldMethod "));
    }
    public void ClassWithAsyncMethod()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
        var instance = (dynamic)Activator.CreateInstance(type);

        DebugRunner.CaptureDebug(() =>
        {
            var task = (Task)instance.MethodWithAwaitAsync();
            task.Wait();
        });

        var methodBases = GetMethodInfoField();

        Assert.AreEqual(1, methodBases.Count);
        var methodBase = methodBases.First();

        Assert.AreEqual(methodBase.Name, "MethodWithAwaitAsync");
    }
    public void ClassWithAsyncMethodWithFastPath(bool recurse)
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
        var instance = (dynamic)Activator.CreateInstance(type);

        DebugRunner.CaptureDebug(() =>
        {
            var task = (Task)instance.MethodWithFastPathAsync(recurse);
            task.Wait();
        });

        var methodBases = GetMethodInfoField();

        // Interceptor can't deal with 2 test cases
        //Assert.AreEqual(recurse ? 2 : 1, methodBases.Count);

        var methodBase = methodBases.Last();

        Assert.AreEqual("MethodWithFastPathAsync", methodBase.Name);
    }
    public void ClassWithAsyncMethodThatThrowsException()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
        var instance = (dynamic)Activator.CreateInstance(type);
        var message  = DebugRunner.CaptureDebug(() =>
        {
            try
            {
                var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
                task.Wait();
            }
            catch (Exception)
            {
                // Expected
            }
        });

        Assert.AreEqual(1, message.Count);
        Assert.IsTrue(message.First().StartsWith("ClassWithAsyncMethod.MethodWithAwaitAndExceptionAsync "));
    }
    public void ClassWithAsyncMethodThatThrowsException()
    {
        var type     = assemblyWeaver.Assembly.GetType("ClassWithAsyncMethod");
        var instance = (dynamic)Activator.CreateInstance(type);

        DebugRunner.CaptureDebug(() =>
        {
            try
            {
                var task = (Task)instance.MethodWithAwaitAndExceptionAsync();
                task.Wait();
            }
            catch (Exception)
            {
                // Expected
            }
        });

        var methodBases = GetMethodInfoField();
        var methodBase  = methodBases.Last();

        Assert.AreEqual(methodBase.Name, "MethodWithAwaitAndExceptionAsync");
    }