public void GetDepth()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // For each node in the tree assert that 'GetDepth' returns the correct elements.
            Assert.Equal(
                0,
                walker.GetDepth(tree));
            Assert.Equal(
                1,
                walker.GetDepth(tree[0]));
            Assert.Equal(
                2,
                walker.GetDepth(tree[0][0]));
            Assert.Equal(
                2,
                walker.GetDepth(tree[0][1]));
            Assert.Equal(
                1,
                walker.GetDepth(tree[1]));
            Assert.Equal(
                2,
                walker.GetDepth(tree[1][0]));
            Assert.Equal(
                3,
                walker.GetDepth(tree[1][0][0]));
        }
        public void LevelOrderTraversal()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Create arrays of the results expected from each node.
            int[] node0ExpectedResult = new int[] { 0, 1, 4, 2, 3, 5, 6 };
            int[] node1ExpectedResult = new int[] { 1, 2, 3 };
            int[] node2ExpectedResult = new int[] { 2 };
            int[] node3ExpectedResult = new int[] { 3 };
            int[] node4ExpectedResult = new int[] { 4, 5, 6 };
            int[] node5ExpectedResult = new int[] { 5, 6 };
            int[] node6ExpectedResult = new int[] { 6 };

            // For each node in the tree assert that 'LevelOrderTraversal' returns the correct
            // elements.

            // Node 0:
            Assert.Equal(
                node0ExpectedResult,
                walker.LevelOrderTraversal(tree).Select(x => x.Value));

            // Node 1:
            Assert.Equal(
                node1ExpectedResult,
                walker.LevelOrderTraversal(tree[0]).Select(x => x.Value));

            // Node 2:
            Assert.Equal(
                node2ExpectedResult,
                walker.LevelOrderTraversal(tree[0][0]).Select(x => x.Value));

            // Node 3:
            Assert.Equal(
                node3ExpectedResult,
                walker.LevelOrderTraversal(tree[0][1]).Select(x => x.Value));

            // Node 4:
            Assert.Equal(
                node4ExpectedResult,
                walker.LevelOrderTraversal(tree[1]).Select(x => x.Value));

            // Node 5:
            Assert.Equal(
                node5ExpectedResult,
                walker.LevelOrderTraversal(tree[1][0]).Select(x => x.Value));

            // Node 6:
            Assert.Equal(
                node6ExpectedResult,
                walker.LevelOrderTraversal(tree[1][0][0]).Select(x => x.Value));
        }
Exemple #3
0
        public void GetLevel_NegativeDepth_ArgumentExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that 'GetLevel' throws an 'ArgumentNullException' when the node is null.
            Assert.Throws <ArgumentException>("depth", () => walker.GetLevel(tree, -1).ToArray());
        }
        public void GetDepth_NullWalker_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a null ITreeWalker.
            NodeWalker <int> walker = null;

            // Assert that 'GetDepth' throws an 'ArgumentNullException' when the tree walker
            // is null.
            Assert.Throws <ArgumentNullException>("walker", () => walker.GetDepth(tree));
        }
        public void GetPrecedingSiblingsAndSelf_NullWalker_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a null ITreeWalker.
            NodeWalker <int> walker = null;

            // Assert that 'GetPrecedingSiblingsAndSelf' throws an 'ArgumentNullException' when the tree walker
            // is null.
            Assert.Throws <ArgumentNullException>("walker", () => walker.GetPrecedingSiblingsAndSelf(tree).ToArray());
        }
Exemple #6
0
        public void GetRoot()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // For each node in the tree assert the 'GetRoot' returns the root of the tree.
            foreach (Node <int> node in walker.PreOrderTraversal(tree))
            {
                Assert.Equal(tree.Value, walker.GetRoot(node).Value);
            }
        }
        public void LevelOrderTraversal_NullWalker_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a null ITreeWalker.
            NodeWalker <int> walker = null;

            // Assert that 'LevelOrderTraversal' throws an 'ArgumentNullException' when the tree
            // walker is null.
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.LevelOrderTraversal(tree).ToArray());
        }
        public void GetDegree()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // For each node in the tree assert the 'GetDegree' returns the number of children
            // that the node has.
            foreach (Node <int> node in walker.PreOrderTraversal(tree))
            {
                Assert.Equal(node.Children.Count, walker.GetDegree(node));
            }
        }
        public void PreOrderTraversal_ShortCircuitRootNode(
            ExcludeOption excludeOption,
            int[] expectedResults)
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that the correct sequence is returned.
            Assert.Equal(
                expectedResults,
                walker.PreOrderTraversal(tree, (n, i) => n.Value == 0, excludeOption).Select(x => x.Value));
        }
        public void GetDescendants_ByKey_NullComparer()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            foreach (Node <int> key in walker.PreOrderTraversal(tree).Skip(1))
            {
                IEnumerable <Node <int> > result = walker.GetDescendants(tree, key);
                Assert.Equal(1, result.Count());
                Assert.Equal(key, result.First());
            }
        }
Exemple #11
0
        public void GetChildrenByPredicate_NullPredicate_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that 'GetChildren' throws an 'ArgumentNullException' when the predicate
            // is null.
            Assert.Throws <ArgumentNullException>(
                "predicate",
                () => walker.GetChildren(new Node <int>[] { tree }, (Func <Node <int>, bool>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "predicate",
                () => walker.GetChildren(tree, (Func <Node <int>, bool>)null).ToArray());
        }
Exemple #12
0
        public void GetChildrenByPredicate_NullWalker_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a null ITreeWalker.
            NodeWalker <int> walker = null;

            // Assert that 'GetChildren' throws an 'ArgumentNullException' when the tree
            // walker is null.
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetChildren(new Node <int>[] { tree }, (n) => true).ToArray());
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetChildren(tree, (n) => true).ToArray());
        }
Exemple #13
0
        public void HasChildren()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // For each node in the tree assert the 'HasChildren' returns the correct value.
            Assert.Equal(true, walker.HasChildren(tree));
            Assert.Equal(true, walker.HasChildren(tree[0]));
            Assert.Equal(false, walker.HasChildren(tree[0][0]));
            Assert.Equal(false, walker.HasChildren(tree[0][1]));
            Assert.Equal(true, walker.HasChildren(tree[1]));
            Assert.Equal(true, walker.HasChildren(tree[1][0]));
            Assert.Equal(false, walker.HasChildren(tree[1][0][0]));
        }
        public void GetPrecedingSiblingsAndSelf(int[] path, int[] expectedResult)
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            foreach (int i in path)
            {
                tree = tree[i];
            }

            // For each node in the tree assert that 'GetPrecedingSiblingsAndSelf' returns the
            // correct elements.
            Assert.Equal(
                expectedResult,
                walker.GetPrecedingSiblingsAndSelf(tree).Select(x => x.Value));
        }
Exemple #15
0
        public void GetLeaves(int[] testPath, int[] expected)
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            var node = tree;

            foreach (int i in testPath)
            {
                node = walker.GetChildAt(node, i);
            }

            Assert.Equal(
                expected,
                walker.GetLeaves(node).Select(x => x.Value));
        }
        public void GetBranches_MultipleBranches()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert.
            Assert.Equal(
                walker
                .GetLeaves(tree)
                .Select(x =>
                        EnumerableEx
                        .Return(x)
                        .Concat(walker.GetAncestors(x))
                        .Reverse()
                        .ToArray())
                .ToArray(),
                walker.GetBranches(tree).Select(x => x.ToArray()).ToArray());
        }
Exemple #17
0
        public void GetChildrenByPredicate_PredicateTests()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Create test predicates and the expected results.
            var testCases = new[]
            {
                new {
                    Predicate       = new Func <Node <int>, bool>(i => i.Value % 2 == 0),
                    ExpectedResults = new int[] { 4 }
                },
                new {
                    Predicate       = new Func <Node <int>, bool>(i => i.Value % 2 == 1),
                    ExpectedResults = new int[] { 1 }
                },
                new {
                    Predicate       = new Func <Node <int>, bool>(i => i.Value >= 2),
                    ExpectedResults = new int[] { 4 }
                },
            };

            // Assert that 'GetChildren' returns the expected results for each predicate.
            foreach (var testCase in testCases)
            {
                Assert.Equal(
                    walker
                    .GetChildren(tree, testCase.Predicate)
                    .Select(x => x.Value),
                    testCase.ExpectedResults);
                Assert.Equal(
                    walker
                    .GetChildren(new Node <int>[] { tree }, testCase.Predicate)
                    .Select(x => x.Value),
                    testCase.ExpectedResults);
            }
        }
Exemple #18
0
        public void GetLevel()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // For each node in the tree assert that 'GetLevel' returns the correct elements.
            Assert.Equal(
                new int[] { 0 },
                walker.GetLevel(tree, 0).Select(x => x.Value));
            Assert.Equal(
                new int[] { 1, 4 },
                walker.GetLevel(tree, 1).Select(x => x.Value));
            Assert.Equal(
                new int[] { 2, 3, 5 },
                walker.GetLevel(tree, 2).Select(x => x.Value));
            Assert.Equal(
                new int[] { 6 },
                walker.GetLevel(tree, 3).Select(x => x.Value));
        }
        public void GetDescendants_ValuePredicateTests(
            Func <Node <int>, bool> predicate,
            int[] expectedResult)
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that 'GetDescendants' returns the expected results for each predicate.
            Assert.Equal(
                expectedResult,
                walker
                .GetDescendants(tree, predicate)
                .Select(x => x.Value));
            Assert.Equal(
                expectedResult,
                walker
                .GetDescendants(new Node <int>[] { tree }, predicate)
                .Select(x => x.Value));
        }
Exemple #20
0
        public void GetChildrenByKey_NullKey_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that 'GetChildren' throws an 'ArgumentNullException' when the key
            // is null.
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetChildren(new Node <int>[] { tree }, (Node <int>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetChildren(tree, (Node <int>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetChildren(new Node <int>[] { tree }, (Node <int>)null, EqualityComparer <Node <int> > .Default).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetChildren(tree, (Node <int>)null, EqualityComparer <Node <int> > .Default).ToArray());
        }
        public void GetDescendants_ByKey_NullWalker_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a null ITreeWalker.
            NodeWalker <int> walker = null;

            // Assert that 'GetDescendants' throws an 'ArgumentNullException' when the tree
            // walker is null.
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetDescendants(new Node <int>[] { tree }, default(Node <int>)));
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetDescendants(new Node <int>[] { tree }, default(Node <int>), EqualityComparer <Node <int> > .Default));
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetDescendants(tree, default(Node <int>)).ToArray());
            Assert.Throws <ArgumentNullException>(
                "walker",
                () => walker.GetDescendants(tree, default(Node <int>), EqualityComparer <Node <int> > .Default).ToArray());
        }
        public void GetDescendants_ByKey_NullKey_ArgumentNullExceptionThrown()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Assert that 'GetDescendants' throws an 'ArgumentNullException' when the predicate
            // is null.
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetDescendants(new Node <int>[] { tree }, (Node <int>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetDescendants(new Node <int>[] { tree }, (Node <int>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetDescendants(tree, (Node <int>)null).ToArray());
            Assert.Throws <ArgumentNullException>(
                "key",
                () => walker.GetDescendants(tree, (Node <int>)null).ToArray());
        }
        public void Descendants_ByKey_ArgumentComparerIsInvoked()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a mock IComparer.
            Mock <IEqualityComparer <Node <int> > > mockComparer = new Mock <IEqualityComparer <Node <int> > >();

            mockComparer
            .Setup(mock => mock.Equals(It.IsAny <Node <int> >(), It.IsAny <Node <int> >()))
            .Returns(true);

            // Create a VirtualForest.
            IVirtualForest <Node <int> > vt = VirtualForest.New(new NodeWalker <int>(), tree);

            // Create a key to use for comparison.  Any key is fine.
            Node <int> key = new Node <int>(0);

            // Execute Descendants.
            vt.Descendants(key, mockComparer.Object).Roots.ToArray();

            // Verify that the VirtualForest's comparer was used.
            //mockComparer.Verify(x => x.Equals(It.IsAny<Node<int>>(), It.IsAny<Node<int>>()), Times.Exactly(vt.GetDegree()));
        }
        public void LevelOrderTraversal_ShortCircuitOddNumbers(
            int[] traversalToStartNode,
            ExcludeOption excludeOption,
            int[] expectedResults)
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Get a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Get the node to begin traversing from.
            var startNode = tree;

            foreach (int i in traversalToStartNode)
            {
                startNode = startNode[i];
            }

            // Assert that the correct sequence is returned.
            Assert.Equal(
                expectedResults,
                walker.LevelOrderTraversal(startNode, (n, i) => n.Value % 2 == 1, excludeOption).Select(x => x.Value));
        }
        public void GetChildrenByKey_ArgumentComparerIsInvoked()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a mock IComparer.
            Mock <IEqualityComparer <Node <int> > > mockComparer = new Mock <IEqualityComparer <Node <int> > >();

            mockComparer
            .Setup(mock => mock.Equals(It.IsAny <Node <int> >(), It.IsAny <Node <int> >()))
            .Returns(true);

            // Create a VirtualTree.
            VirtualTree <Node <int> > vt = VirtualTree.New(new NodeWalker <int>(), tree);

            // Create a key to use for comparison.  Any key is fine.
            Node <int> key = new Node <int>(0);

            // Execute the GetChildren.
            vt.GetChildren(key, mockComparer.Object).ToArray();

            // Verify that the comparer argument was used.
            mockComparer.Verify(x => x.Equals(key, It.IsAny <Node <int> >()), Times.AtLeastOnce);
        }
        public void GetDescendants_ByKey_ComparerIsInvoked()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            // Create a mock IComparer.
            Mock <IEqualityComparer <Node <int> > > mockComparer = new Mock <IEqualityComparer <Node <int> > >();

            mockComparer
            .Setup(mock => mock.Equals(It.IsAny <Node <int> >(), It.IsAny <Node <int> >()))
            .Returns(true);

            // Create a key to use for comparison.  Any key is fine.
            Node <int> key = new Node <int>(0);

            // Execute GetDescendants.
            walker.GetDescendants(tree, key, mockComparer.Object).ToArray();

            // It should be called the same number of times as children of the node being evaluated.
            mockComparer.Verify(x => x.Equals(It.IsAny <Node <int> >(), It.IsAny <Node <int> >()), Times.Exactly(walker.GetDegree(tree)));
        }
Exemple #27
0
        public void GetChildrenByKey_ByKeyTests()
        {
            // Get a valid tree.
            var tree = TestTreeFactory.GetSimpleTree();

            // Create a valid ITreeWalker.
            NodeWalker <int> walker = new NodeWalker <int>();

            foreach (Node <int> node in walker.PreOrderTraversal(tree))
            {
                foreach (Node <int> key in walker.PreOrderTraversal(tree))
                {
                    IEnumerable <Node <int> > result = walker.GetChildren(node, key).ToArray();
                    if (walker.GetChildren(node).Contains(key))
                    {
                        Assert.Equal(result, new Node <int>[] { key });
                    }
                    else
                    {
                        Assert.Empty(result);
                    }
                }
            }
        }