public void CanBePerformedOnArbitrarilyDeepNodes()
        {
            const string codeText      = @"                
                using System;
                public class One
                {
                    void Foo()
                    {
                        double w = 7;
                        double l = 8;

                        if (DateTime.Now.Day == 3)
                        {
                            Console.WriteLine(""stuff"");
                            Console.WriteLine(""stuff"");
                        }
                        double area = l*w;
                    }
                    void Bar()
                    {
                        Console.WriteLine(""stuff"");                        
                    }
                }";
            var          code_text_ast = AstMatchHelper.ParseToCompilationUnit(codeText);

            IndexableMethodFinderVisitor v = new IndexableMethodFinderVisitor();

            code_text_ast.AcceptVisitor(v, null);
            MethodDeclaration method = v.Methods["Foo"];

            FindFirstIfElseVisitor v2 = new FindFirstIfElseVisitor();

            method.AcceptVisitor(v2, null);
            IfElseStatement ifelse_stmt = v2.IfElse;

            List <Statement> statements = ifelse_stmt.TrueStatement;

            Assert.AreEqual(1, statements.Count,
                            "Expect TrueStatement to always return a single element, and it's a block.");
            Assert.IsInstanceOf <BlockStatement>(statements[0], "Expect TrueStatement to always return a single element, and it's a block.");

            BlockStatement block = (BlockStatement)statements[0];

            CSharpMethodExtractor extractor = new CSharpMethodExtractor();
            var success = extractor.Extract(method, new Window(0, 0), block.Children);

            Assert.IsTrue(success);

            Console.WriteLine(extractor.ExtractedMethod.Print());

            MethodDeclaration expected_method = v.BarMethod;

            Assert.IsTrue(expected_method.Matches(extractor.ExtractedMethod),
                          "The expected AST did not match the actual extracted AST.\nExpected: {0} \nActual:{1}",
                          expected_method.Print(), extractor.ExtractedMethod.Print());
        }
        public void CanBePerformedOnArbitrarilyDeepNodes()
        {
            const string codeText = @"
                using System;
                public class One
                {
                    void Foo()
                    {
                        double w = 7;
                        double l = 8;

                        if (DateTime.Now.Day == 3)
                        {
                            Console.WriteLine(""stuff"");
                            Console.WriteLine(""stuff"");
                        }
                        double area = l*w;
                    }
                    void Bar()
                    {
                        Console.WriteLine(""stuff"");
                    }
                }";
            var code_text_ast = AstMatchHelper.ParseToCompilationUnit(codeText);

            IndexableMethodFinderVisitor v = new IndexableMethodFinderVisitor();
            code_text_ast.AcceptVisitor(v, null);
            MethodDeclaration method = v.Methods["Foo"];

            FindFirstIfElseVisitor v2 = new FindFirstIfElseVisitor();
            method.AcceptVisitor(v2, null);
            IfElseStatement ifelse_stmt = v2.IfElse;

            List<Statement> statements = ifelse_stmt.TrueStatement;
            Assert.AreEqual(1, statements.Count,
                            "Expect TrueStatement to always return a single element, and it's a block.");
            Assert.IsInstanceOf<BlockStatement>(statements[0], "Expect TrueStatement to always return a single element, and it's a block.");

            BlockStatement block = (BlockStatement) statements[0];

            CSharpMethodExtractor extractor = new CSharpMethodExtractor();
            var success = extractor.Extract(method, new Window(0, 0), block.Children);
            Assert.IsTrue(success);

            Console.WriteLine(extractor.ExtractedMethod.Print());

            MethodDeclaration expected_method = v.BarMethod;
            Assert.IsTrue(expected_method.Matches(extractor.ExtractedMethod),
                          "The expected AST did not match the actual extracted AST.\nExpected: {0} \nActual:{1}",
                          expected_method.Print(), extractor.ExtractedMethod.Print());
        }