public void Test_Static_MultipleParameters()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
CallMe(""Hello"", ""Hello2"", 42);
}
private static void CallMe(string param, string param2, int paraInt)
{
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe");
}
public void Test_Static_Multiple_Outs_And_ReturnValue()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
string inp;
int inp2;
CallMe(out inp, out inp2);
}
private static string CallMe(out string param, out int para2)
{
param = ""rv"";
para2 = 42;
return ""response"";
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "response");
result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass::CallMe", "param", "rv", "para2", "42");
}
public void TestLoging_In_StaticConstructor()
{
string code = @"
using System;
using System.Diagnostics;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
static MyClass()
{
MockLog.OuterNoParam();
}
public static void Main()
{
var myClass = new MyClass();
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(1);
result.ElementAt(0).ShouldBeLogCall("First.MyClass::.cctor()", "MockLogOuterNoParam");
}
public void Test_Static_Double()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
double inp;
CallMe(out inp);
}
private static void CallMe(out double param)
{
param = 42.5;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe");
result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass::CallMe", "param", 42.5.ToString());
}
public void Test_Static_Class()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class InnerClass
{
public string Value { get; set; }
}
public class MyClass
{
public static void Main()
{
InnerClass inp;
CallMe(out inp);
}
private static void CallMe(out InnerClass param)
{
param = new InnerClass() { Value=""Hi"" };
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe");
result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass::CallMe", "param", "First.InnerClass"); //ToString=First.InnerClass
}
public void Test_Static_Empty_Method()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading;
namespace First
{
public class MyClass
{
public static void Main()
{
Thread.Sleep(10);
}
}
}
";
MockLogResult result = RunTest(code, new AllTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::Main");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::Main");
result.ElementAt(1).NumberOfTicks.Should().BeGreaterThan(0);
}
public void Weaving_Twice_Second_Time_No_Weave()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading;
namespace First
{
public class MyClass
{
public static void Main()
{
Thread.Sleep(10);
}
}
}
";
Uri testDllLocation = new Uri(Assembly.GetExecutingAssembly().CodeBase);
string assemblyPath = Compile(code, "testasm", new[] { testDllLocation.AbsolutePath });
Rewrite(assemblyPath, new AllTraceLoggingFilter());
Rewrite(assemblyPath, new AllTraceLoggingFilter());
MockLogResult result = RunCode(assemblyPath, "First.MyClass", "Main");
result.Count.Should().Be(2);
}
public void Test_Property_Setter()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
private int _intValue;
public static void Main()
{
var mc = new MyClass();
mc.IntValue = 2;
}
private int IntValue
{
set { _intValue = value; }
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::set_IntValue", "value", "2");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::set_IntValue");
}
public void Test_Generic_ReturnValue_Method()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
var r1 = myClass.CallMe<string>(""Hello"");
var r2 = myClass.CallMe<int>(""Ahoy"");
}
private T CallMe<T>(string param)
{
return default(T);
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(4);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", null);
result.ElementAt(2).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Ahoy");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "0");
}
public void Test_Static_Empty_Method()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading;
namespace First
{
public class MyClass
{
public static void Main()
{
try { MyStatic(); } catch { }
}
public static void MyStatic()
{
throw new ApplicationException(""failed"");
}
}
}
";
MockLogResult result = RunTest(code, new AllTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(4);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::Main");
result.ElementAt(1).ShouldBeTraceEnterInto("First.MyClass::MyStatic");
result.ElementAt(2).ShouldBeTraceLeaveWithExceptionFrom("First.MyClass::MyStatic", "failed");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::Main");
}
public void Test_Static_MultipleParameters()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
try {
CallMe(""Hello"", ""Hello2"", 42); } catch {}
}
private static string CallMe(string param, string param2, int paraInt)
{
throw new ApplicationException(""failed"");
return ""response"" + paraInt.ToString();
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceLeaveWithExceptionFrom("First.MyClass::CallMe", "failed");
}
public void Test_Static_ObjectParameter()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyInput
{}
public class MyClass
{
public static void Main()
{
CallMe(new MyInput());
}
private static void CallMe(MyInput param)
{
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "First.MyInput");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe");
}
public void Test_Static_SingleIntParameter_Empty_Method()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
SetInt(42);
}
private static void SetInt(int param)
{
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::SetInt", "param", "42");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::SetInt");
}
public void Test_Static_SingleStructParameter_Empty_Method()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public struct MyStruct
{
public string ValStr {get; set;}
public int ValInt {get; set;}
}
public class MyClass
{
public static void Main()
{
SetStruct(new MyStruct() { ValStr=""Hi"", ValInt=42 });
}
private static void SetStruct(MyStruct param)
{
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::SetStruct", "param", "First.MyStruct");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::SetStruct");
}
public void TestLoging_In_Closure()
{
string code = @"
using System;
using System.Diagnostics;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
delegate void TestDelegate();
public static void Main()
{
int foo = 1;
TestDelegate dlg = () => {
foo++;
MockLog.OuterNoParam();
};
dlg();
}
}
}
";
MockLogResult result = RunTest(code, new NoTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(1);
result.ElementAt(0).ShouldBeLogCall("First.MyClass::Main", "MockLogOuterNoParam");
result.ElementAt(0).ContainingMethod.Should().Be("Main()");
}
public void Test_Instance_MultipleParameters_Returns_Int()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
myClass.CallMe(""Hello"", ""Hello2"", 42);
myClass.CallMe(""Ahoy"", ""Ahoy2"", 43);
}
private int CallMe(string param, string param2, int paraInt)
{
return paraInt * 2;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(4);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "84");
result.ElementAt(2).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Ahoy", "param2", "Ahoy2", "paraInt", "43");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "86");
}
public void Test_Multiple_LogCalls_NoTracing()
{
string code = @"
using System;
using System.Diagnostics;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
public static void Main()
{
MockLog.Outer(""Hello"");
int i = 1;
MockLog.Outer(""String"", i);
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeLogCall("First.MyClass::Main", "MockLogOuter", "Hello");
result.ElementAt(1).ShouldBeLogCall("First.MyClass::Main", "MockLogOuter", "String", "1");
}
public void Test_Generic_Parameter_Method()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
myClass.CallMe<string, int>(""Hello"", ""Hello2"", 42);
myClass.CallMe<string, double>(""Ahoy"", ""Ahoy2"", 0.5);
}
private string CallMe<T, K>(T param, string param2, K paraNum)
{
return param2 + ""!"";
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(4);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraNum", "42");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "Hello2!");
result.ElementAt(2).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Ahoy", "param2", "Ahoy2", "paraNum", $"0{Thread.CurrentThread.CurrentCulture.NumberFormat.NumberDecimalSeparator}5");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "Ahoy2!");
}
public void Test_Instance_Empty_Method()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
myClass.Run();
}
public void Run()
{
}
}
}
";
MockLogResult result = RunTest(code, new AllTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(4);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::Main");
result.ElementAt(1).ShouldBeTraceEnterInto("First.MyClass::Run");
result.ElementAt(2).ShouldBeTraceLeaveFrom("First.MyClass::Run");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::Main");
}
public void TestLoging_In_Lambda()
{
string code = @"
using System;
using System.Diagnostics;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
public static void Main()
{
Action act = () => {
MockLog.OuterNoParam();
};
act();
}
}
}
";
MockLogResult result = RunTest(code, new NoTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(1);
result.ElementAt(0).ShouldBeLogCall("First.MyClass::Main", "MockLogOuterNoParam");
result.ElementAt(0).ContainingMethod.Should().Be("Main()");
}
public void Test_Static_OutParameter_NotListed()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
string outval;
SetString(""Hello"", out outval);
}
private static void SetString(string param, out string outval)
{
outval = ""outval"";
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::SetString", "param", "Hello");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::SetString");
}
public void Test_Static_Empty_Method_Returns_Object()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyRetVal
{}
public class MyClass
{
public static void Main()
{
var val = GetValue();
}
private static MyRetVal GetValue()
{
return new MyRetVal();
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::GetValue");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::GetValue", "First.MyRetVal");
}
public void Test_Instance_Empty_Method_Returns_Int()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
var mc = new MyClass();
var i = mc.GetIntValue();
}
private int GetIntValue()
{
return 1;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::GetIntValue");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::GetIntValue", "1");
}
public void Test_Returning_From_NestedScope()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
CallMe(""Hello"", ""Hello2"", 42);
}
private static string CallMe(string param, string param2, int paraInt)
{
for (int i=0; i < 1; i++)
{
return ""response"" + paraInt.ToString();
}
return String.Empty;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "response42");
}
public void Test_Static_Int()
{
string code = @"
using System;
using System.Diagnostics;
namespace First
{
public class MyClass
{
public static void Main()
{
int inp = 42;
CallMe(ref inp);
}
private static void CallMe(ref int param)
{
param = 24;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(2);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "42");
result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass::CallMe", "param", "24");
}
public void Test_AsyncUsingOtherClass()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
var x1 = myClass.CallMe(""Hello"", ""Hello2"", 42).Result;
}
private OtherClass _otc = new OtherClass();
private int _num = 2;
private async Task<int> CallMe(string param, string param2, int paraInt)
{
var result = await _otc.Double(paraInt);
MockLog.OuterNoParam();
return result * _num;
}
}
public class OtherClass
{
public async Task<int> Double(int p)
{
return await DoubleInt(p);
}
private async Task<int> DoubleInt(int p)
{
MockLog.OuterNoParam();
return await Task.Run(()=> p * 2);
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(6);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceEnterInto("First.OtherClass::DoubleInt", "p", "42");
result.ElementAt(2).ShouldBeLogCall("First.OtherClass::DoubleInt", "MockLogOuterNoParam");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.OtherClass::DoubleInt", "84");
result.ElementAt(4).ShouldBeLogCall("First.MyClass::CallMe", "MockLogOuterNoParam");
result.ElementAt(5).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "168");
}
public void TraceOn_Attribute_On_Property_Adds_Getter_And_Setter()
{
string code = @"
using System;
using System.Diagnostics;
namespace TracerAttributes
{
[AttributeUsage(AttributeTargets.Class | AttributeTargets.Method | AttributeTargets.Property, AllowMultiple = true, Inherited = true)]
public class TraceOn : Attribute
{
public TraceTarget Target { get; set; }
public TraceOn()
{}
public TraceOn(TraceTarget traceTarget)
{
Target = traceTarget;
}
}
}
namespace First
{
using TracerAttributes;
public class MyClass
{
private int _intValue;
public static void Main()
{
var mc = new MyClass();
var i = mc.IntValue;
mc.IntValue = 2;
}
[TraceOn]
private int IntValue
{
get { return 1; }
set { _intValue = value; }
}
}
}
";
AssemblyLevelTraceOnDefinition def = new AssemblyLevelTraceOnDefinition(NamespaceScope.All, TraceTargetVisibility.Public,
TraceTargetVisibility.Public);
MockLogResult result = RunTest(code, new DefaultFilter(new[] { def }), "First.MyClass::Main");
result.Count.Should().Be(6);
}
protected MockLogResult RunCode(string assemblyPath, string entryClass, string entryMethod)
{
AppDomainSetup currentSetup = AppDomain.CurrentDomain.SetupInformation;
AppDomain appDomain = AppDomain.CreateDomain("testrun", null, currentSetup);
try
{
Worker remote = (Worker)appDomain.CreateInstanceAndUnwrap(Assembly.GetExecutingAssembly().FullName, "Tracer.Fody.Tests.TestBase+Worker");
MockLogResult result = remote.Run(assemblyPath, entryClass, entryMethod, typeof(MockLogManagerAdapter).FullName);
return(result);
}
finally
{
AppDomain.Unload(appDomain);
}
}
public void Test_AsyncLoggingCallOrderWithException()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
public static void Main()
{
try {
var myClass = new MyClass();
var x1 = myClass.CallMe(""Hello"", ""Hello2"", 42).Result;
} catch {}
}
private async Task<int> CallMe(string param, string param2, int paraInt)
{
var result = await Double(paraInt);
return result;
}
private async Task<int> Double(int p)
{
return await Task.Run(() => Calculate());
}
public int Calculate()
{
throw new ApplicationException(""Err""); return 1;
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(6);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceEnterInto("First.MyClass::Double", "p", "42");
result.ElementAt(4).ShouldBeTraceLeaveWithExceptionFrom("First.MyClass::Double", "Err");
result.ElementAt(5).ShouldBeTraceLeaveWithExceptionFrom("First.MyClass::CallMe", "Err");
}
public void Test_GenericAsync()
{
string code = @"
using System;
using System.Diagnostics;
using System.Threading.Tasks;
using Tracer.Fody.Tests.MockLoggers;
namespace First
{
public class MyClass
{
public static void Main()
{
var myClass = new MyClass();
var x1 = myClass.CallMe<string>(""Hello"", ""Hello2"", 42).Result;
var x2 = myClass.CallMe<int>(12, ""Ahoy2"", 43).Result;
}
private async Task<int> CallMe<T>(T param, string param2, int paraInt)
{
var result = await Double(paraInt);
return result;
}
private async Task<int> Double(int p)
{
return await Task.Run(()=> p * 2);
}
}
}
";
MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");
result.Count.Should().Be(8);
result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
result.ElementAt(1).ShouldBeTraceEnterInto("First.MyClass::Double", "p", "42");
result.ElementAt(2).ShouldBeTraceLeaveFrom("First.MyClass::Double", "84");
result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "84");
result.ElementAt(4).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "12", "param2", "Ahoy2", "paraInt", "43");
result.ElementAt(5).ShouldBeTraceEnterInto("First.MyClass::Double", "p", "43");
result.ElementAt(6).ShouldBeTraceLeaveFrom("First.MyClass::Double", "86");
result.ElementAt(7).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "86");
}
