Beispiel #1
0
        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");
        }
Beispiel #2
0
        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");
        }
Beispiel #3
0
        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");
        }
Beispiel #4
0
        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
        }
Beispiel #5
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()
                        {
                            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);
        }
Beispiel #6
0
        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");
        }
Beispiel #7
0
        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");
        }
Beispiel #8
0
        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()");
        }
Beispiel #9
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");
        }
Beispiel #10
0
        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");
        }
Beispiel #11
0
        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");
        }
Beispiel #12
0
        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");
        }
Beispiel #13
0
        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");
        }
Beispiel #14
0
        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");
        }
Beispiel #15
0
        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");
        }
Beispiel #16
0
        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()");
        }
Beispiel #17
0
        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");
        }
Beispiel #18
0
        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");
        }
Beispiel #19
0
        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!");
        }
Beispiel #20
0
        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");
        }
Beispiel #21
0
        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());
        }
Beispiel #22
0
        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");
        }
Beispiel #23
0
        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");
        }
Beispiel #24
0
        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");
        }
Beispiel #25
0
        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");
        }
Beispiel #26
0
        public void Test_GenericAsyncRetval()
        {
            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<T> CallMe<T>(T param, string param2, int paraInt)
                        {
                            var result = await Double(paraInt);
                            return param;
                        }

                        public 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(4);
            result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "Hello", "param2", "Hello2", "paraInt", "42");
            result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "Hello");
            result.ElementAt(2).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "12", "param2", "Ahoy2", "paraInt", "43");
            result.ElementAt(3).ShouldBeTraceLeaveFrom("First.MyClass::CallMe", "12");
        }
Beispiel #27
0
        public void Test_AsyncNoReturnValue()
        {
            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();
                            myClass.CallMe(""Hello"", ""Hello2"", 42).Wait();
                        }

                        private async Task CallMe(string param, string param2, int paraInt)
                        {
                            var result = await Double(paraInt);
                            return;
                        }

                        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(4);
            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");
        }
Beispiel #28
0
        public void Test_Instance_Empty_Method_Returns_Struct()
        {
            string code = @"
                using System;
                using System.Diagnostics;

                namespace First
                {
                    public struct MyStruct
                    {
                        public int IntVal { get; set; }

                        public override string ToString()
                        {
                            return String.Format(""I{0}"", IntVal);
                        }
                    }

                    public class MyClass
                    {
                        public static void Main()
                        {
                            var mc = new MyClass();
                            var i = mc.GetStructValue();
                        }

                        private MyStruct GetStructValue()
                        {
                            return new MyStruct() { IntVal = 42 };
                        }
                    }
                }
            ";

            MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");

            result.Count.Should().Be(2);
            result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::GetStructValue");
            result.ElementAt(1).ShouldBeTraceLeaveFrom("First.MyClass::GetStructValue", "I42");
        }
Beispiel #29
0
        public void Test_Static_Struct()
        {
            string code = @"
                using System;
                using System.Diagnostics;

                namespace First
                {
                    public struct MyStruct
                    {
                        public int IntVal { get; set; }

                        public override string ToString()
                        {
                            return String.Format(""I{0}"", IntVal);
                        }
                    }

                    public class MyClass
                    {
                        public static void Main()
                        {
                            MyStruct inp = new MyStruct() { IntVal = 42 };
                            CallMe(ref inp);
                        }

                        private static void CallMe(ref MyStruct param)
                        {
                            param = new MyStruct() { IntVal = 24 };
                        }
                    }
                }
            ";

            MockLogResult result = RunTest(code, new PrivateOnlyTraceLoggingFilter(), "First.MyClass::Main");

            result.Count.Should().Be(2);
            result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass::CallMe", "param", "I42");
            result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass::CallMe", "param", "I24");
        }
Beispiel #30
0
        public void Test_Instance_Generic()
        {
            string code = @"
                using System;
                using System.Diagnostics;

                namespace First
                {
                    public class StartupClass
                    {
                        public static void Main()
                        {
                            var mc1 = new MyClass<string>();
                            string outp1;    
                            mc1.CallMe(out outp1);
                            var mc2 = new MyClass<int>();
                            int outp2;    
                            mc2.CallMe(out outp2);
                        }
                    }

                    public class MyClass<T>
                    {
                        internal void CallMe(out T param)
                        {
                            param = default(T);
                        }
                    }
                }
            ";

            MockLogResult result = RunTest(code, new InternalOnlyTraceLoggingFilter(), "First.StartupClass::Main");

            result.Count.Should().Be(4);
            result.ElementAt(0).ShouldBeTraceEnterInto("First.MyClass<String>::CallMe");
            result.ElementAt(1).ShouldBeTraceLeaveWithOutsFrom("First.MyClass<String>::CallMe", "param", null);
            result.ElementAt(2).ShouldBeTraceEnterInto("First.MyClass<Int32>::CallMe");
            result.ElementAt(3).ShouldBeTraceLeaveWithOutsFrom("First.MyClass<Int32>::CallMe", "param", "0");
        }