public void Exceptions()
        {
            ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
            {
                A, B, C, D
            }.ToImmutableHashSet();
            ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
            {
                new TestEdge(A, B, W2),
                new TestEdge(B, A, W1),
                new TestEdge(A, A, W3),
                new TestEdge(A, C, NW1),
                new TestEdge(C, D, W3),
            }.ToImmutableHashSet();

            Graph = new TestAdjacencyListsGraph(set1, set2);
            TestAbstractGraphPathSearch          gs    = GraphSearch;
            ISet <IPath <TestVertex, TestEdge> > paths = gs.Search(Graph, A, D, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;

            PrintPaths(paths);
            Assert.Equal(0, paths.Count);

            paths = gs.Search(Graph, A, A, Weigher, 5).Paths;
            // Should find no paths between the same vertices.
            Assert.Equal(0, paths.Count);
            // Invalid operation since there should be no paths.
            Assert.Throws <InvalidOperationException>(() => paths.First().Cost);
        }
        public void NoPath()
        {
            ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
            {
                A, B, C, D
            }.ToImmutableHashSet();
            ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
            {
                new TestEdge(A, B, W1),
                new TestEdge(B, A, W1),
                new TestEdge(C, D, W1),
                new TestEdge(D, C, W1),
            }.ToImmutableHashSet();

            Graph = new TestAdjacencyListsGraph(set1, set2);
            TestAbstractGraphPathSearch          gs    = GraphSearch;
            ISet <IPath <TestVertex, TestEdge> > paths = gs.Search(Graph, A, B, Weigher, 1).Paths;

            PrintPaths(paths);
            Assert.Equal(1, paths.Count);
            Assert.Equal(new TestDoubleWeight(1.0), paths.First().Cost);

            paths = gs.Search(Graph, A, D, Weigher, 1).Paths;
            PrintPaths(paths);
            Assert.Equal(0, paths.Count);

            paths = gs.Search(Graph, A, null, Weigher, 1).Paths;
            PrintPaths(paths);
            Assert.Equal(1, paths.Count);
            Assert.Equal(new TestDoubleWeight(1.0), paths.First().Cost);
        }
        public void DualEdgeMultiplePath()
        {
            ImmutableHashSet <TestVertex> set1 = new HashSet <TestVertex>()
            {
                A, B, C, D, E, F, G, H
            }.ToImmutableHashSet();
            ImmutableHashSet <TestEdge> set2 = new HashSet <TestEdge>()
            {
                new TestEdge(A, B, W1),
                new TestEdge(A, C, W3),
                new TestEdge(B, D, W2),
                new TestEdge(B, C, W1),
                new TestEdge(B, E, W4),
                new TestEdge(C, E, W1),
                new TestEdge(D, H, W5),
                new TestEdge(D, E, W1),
                new TestEdge(E, F, W1),
                new TestEdge(F, D, W1),
                new TestEdge(F, G, W1),
                new TestEdge(F, H, W1),
                new TestEdge(A, E, W3),
                new TestEdge(B, D, W1),
            }.ToImmutableHashSet();

            Graph = new TestAdjacencyListsGraph(set1, set2);
            ExecuteSearch(GraphSearch, Graph, A, E, Weigher, 3, W3);
            ExecuteSinglePathSearch(GraphSearch, Graph, A, E, Weigher, 1, W3);

            TestAbstractGraphPathSearch          gs    = GraphSearch;
            ISet <IPath <TestVertex, TestEdge> > pathF = gs.Search(Graph, A, F, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;
            ISet <IPath <TestVertex, TestEdge> > pathE = gs.Search(Graph, A, E, Weigher, TestAbstractGraphPathSearch.AllPaths).Paths;

            Assert.Equal(0, pathF.Count - pathE.Count);
            Assert.Equal(new TestDoubleWeight(1.0), pathF.First().Cost.Subtract(pathE.First().Cost));
        }
        public void ExecuteBroadSearch()
        {
            Graph = new TestAdjacencyListsGraph(Vertices, Edges);
            TestAbstractGraphPathSearch search = GraphSearch;
            SpanningTreeResult          result = (SpanningTreeResult)search.Search(Graph, A, null, Weigher, TestAbstractGraphPathSearch.AllPaths);

            Assert.Equal(7, result.Paths.Count);

            int[] types = new int[] { 0, 0, 0, 0 };
            foreach (EdgeType type in result.Edges.Values)
            {
                types[(int)type] += 1;
            }
            Assert.Equal(7, types[(int)EdgeType.TreeEdge]);
            Assert.Equal(1, types[(int)EdgeType.BackEdge]);
            Assert.Equal(4, types[(int)EdgeType.ForwardEdge] + types[(int)EdgeType.CrossEdge]);
        }
        protected void ExecuteDefaultTest(int minLength, int maxLength, IWeight minCost, IWeight maxCost)
        {
            Graph = new TestAdjacencyListsGraph(Vertices, Edges);
            TestAbstractGraphPathSearch          search = GraphSearch;
            SpanningTreeResult                   result = (SpanningTreeResult)search.Search(Graph, A, H, Weigher, 1);
            ISet <IPath <TestVertex, TestEdge> > paths  = result.Paths;

            Assert.Equal(1, paths.Count);

            IPath <TestVertex, TestEdge> path = paths.First();

            Console.WriteLine(path);
            Assert.Equal(A, path.Src);
            Assert.Equal(H, path.Dst);

            int l = path.Edges.Count;

            Assert.True(minLength <= l && l <= maxLength);
            Assert.True(path.Cost.CompareTo(minCost) >= 0 && path.Cost.CompareTo(maxCost) <= 0);

            Console.WriteLine(result.Edges);
            PrintPaths(paths);
        }