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"); }