public void IntermediateNodeWalker_Visit_TraversesEntireGraph()
        {
            // Arrange
            var walker = new DerivedIntermediateNodeWalker();

            var nodes = new IntermediateNode[]
            {
                new BasicIntermediateNode("Root"),
                new BasicIntermediateNode("Root->A"),
                new BasicIntermediateNode("Root->B"),
                new BasicIntermediateNode("Root->B->1"),
                new BasicIntermediateNode("Root->B->2"),
                new BasicIntermediateNode("Root->C"),
            };

            var builder = new DefaultRazorIntermediateNodeBuilder();

            builder.Push(nodes[0]);
            builder.Add(nodes[1]);
            builder.Push(nodes[2]);
            builder.Add(nodes[3]);
            builder.Add(nodes[4]);
            builder.Pop();
            builder.Add(nodes[5]);

            var root = builder.Pop();

            // Act
            walker.Visit(root);

            // Assert
            Assert.Equal(nodes, walker.Visited.ToArray());
        }
        public void Ctor_CreatesEmptyBuilder()
        {
            // Arrange & Act
            var builder = new DefaultRazorIntermediateNodeBuilder();
            var current = builder.Current;

            // Assert
            Assert.Null(current);
        }
        public void Pop_ThrowsWhenEmpty()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();

            // Act & Assert
            ExceptionAssert.Throws <InvalidOperationException>(
                () => builder.Pop(),
                "The 'Pop' operation is not valid when the builder is empty.");
        }
        public static IntermediateNodeBuilder Create(IntermediateNode root)
        {
            if (root == null)
            {
                throw new ArgumentNullException(nameof(root));
            }

            var builder = new DefaultRazorIntermediateNodeBuilder();

            builder.Push(root);
            return(builder);
        }
        public void Push_WhenEmpty_AddsNode()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();
            var node    = new BasicIntermediateNode();

            // Act
            builder.Push(node);

            // Assert
            Assert.Same(node, builder.Current);
        }
        public void Pop_SingleNodeDepth_RemovesAndReturnsNode()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();

            var node = new BasicIntermediateNode();

            builder.Push(node);

            // Act
            var result = builder.Pop();

            // Assert
            Assert.Same(node, result);
            Assert.Null(builder.Current);
        }
        public void IntermediateNodeWalker_Visit_SetsParentAndAncestors()
        {
            // Arrange
            var walker = new DerivedIntermediateNodeWalker();

            var nodes = new IntermediateNode[]
            {
                new BasicIntermediateNode("Root"),
                new BasicIntermediateNode("Root->A"),
                new BasicIntermediateNode("Root->B"),
                new BasicIntermediateNode("Root->B->1"),
                new BasicIntermediateNode("Root->B->2"),
                new BasicIntermediateNode("Root->C"),
            };

            var ancestors = new Dictionary <string, string[]>()
            {
                { "Root", new string[] { } },
                { "Root->A", new string[] { "Root" } },
                { "Root->B", new string[] { "Root" } },
                { "Root->B->1", new string[] { "Root->B", "Root" } },
                { "Root->B->2", new string[] { "Root->B", "Root" } },
                { "Root->C", new string[] { "Root" } },
            };

            walker.OnVisiting = (n) =>
            {
                Assert.Equal(ancestors[((BasicIntermediateNode)n).Name], walker.Ancestors.Cast <BasicIntermediateNode>().Select(b => b.Name));
                Assert.Equal(ancestors[((BasicIntermediateNode)n).Name].FirstOrDefault(), ((BasicIntermediateNode)walker.Parent)?.Name);
            };

            var builder = new DefaultRazorIntermediateNodeBuilder();

            builder.Push(nodes[0]);
            builder.Add(nodes[1]);
            builder.Push(nodes[2]);
            builder.Add(nodes[3]);
            builder.Add(nodes[4]);
            builder.Pop();
            builder.Add(nodes[5]);

            var root = builder.Pop();

            // Act & Assert
            walker.Visit(root);
        }
        public void Push_WhenNonEmpty_SetsUpChild()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();

            var parent = new BasicIntermediateNode();

            builder.Push(parent);

            var node = new BasicIntermediateNode();

            // Act
            builder.Push(node);

            // Assert
            Assert.Same(node, builder.Current);
            Assert.Collection(parent.Children, n => Assert.Same(node, n));
        }
        public void Insert_AddsToChildren_EmptyCollection()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();

            var parent = new BasicIntermediateNode();

            builder.Push(parent);

            var node = new BasicIntermediateNode();

            // Act
            builder.Insert(0, node);

            // Assert
            Assert.Same(parent, builder.Current);
            Assert.Collection(parent.Children, n => Assert.Same(node, n));
        }
        public void Build_PopsMultipleLevels()
        {
            // Arrange
            var builder = new DefaultRazorIntermediateNodeBuilder();

            var document = new DocumentIntermediateNode();

            builder.Push(document);

            var node = new BasicIntermediateNode();

            builder.Push(node);

            // Act
            var result = builder.Build();

            // Assert
            Assert.Same(document, result);
            Assert.Null(builder.Current);
        }