Esempio n. 1
0
 private static void FindWay(string path)
 {
     var graph = new GraphProvider().Load<DijkstraGraph>(path);
     graph.Validate();
     graph.Markup();
     var way = new Dijkstra.Dijkstra()
                           .Compute(graph)
                           .GetShortestWay(graph);
     PrintResults(way);
 }
        public void Validate_Failure_Test(string xml)
        {
            // Arrange
            var graph = new GraphProvider().Load<DijkstraGraph>(xml);
            graph.Validate();
            graph.Markup();
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Assert
            dijkstra.Compute(graph).GetShortestWay(graph);
        }
        public void Compute_MarkCurrentNodeAsVisited_Test()
        {
            // Arrange
            var current = Mock.Of<DijkstraNode>();
            var graph = Mock.Of<DijkstraGraph>(t => t.HasUnvisited() == true
                                                 && t.Linked(current) == new DijkstraNode[0]);
            Mock.Get(graph).Setup(t => t.NearestUnvisited()).Returns(current).Callback(() =>
                Mock.Get(graph).Setup(t => t.HasUnvisited()).Returns(false));
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            dijkstra.Compute(graph);

            // Assert
            Assert.True(current.IsVisited);
        }
        public void Compute_ChangeLinkedPreviousByCurrent_IfThisWayShorter_Test()
        {
            // Arrange
            var linked = Mock.Of<DijkstraNode>(t => t.TotalWeigth == 30);
            var current = Mock.Of<DijkstraNode>(t => t.TotalWeigth == 10 && t.LinkWeight(linked) == 10);
            var graph = Mock.Of<DijkstraGraph>(t => t.HasUnvisited() == true
                                                 && t.Linked(current) == new[] { linked });
            Mock.Get(graph).Setup(t => t.NearestUnvisited()).Returns(current).Callback(() =>
                Mock.Get(graph).Setup(t => t.HasUnvisited()).Returns(false));
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            dijkstra.Compute(graph);

            // Assert
            Assert.AreEqual(linked.Previous, current);
        }
        public void SimpleSample_Test()
        {
            // Arrange
            var graph = new GraphProvider().Load<DijkstraGraph>(@"xml\simple-valid.xml");
            graph.Validate();
            graph.Markup();
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            var way = dijkstra.Compute(graph)
                              .GetShortestWay(graph);

            // Assert
            Assert.AreEqual(way[0].Id, 1);
            Assert.AreEqual(way[1].Id, 3);
            Assert.AreEqual(way[2].Id, 5);

            Assert.AreEqual(way.Count, 3);
            Assert.AreEqual((way[2] as DijkstraNode).TotalWeigth, 20);
        }
        public void AcceptanceSample_Test()
        {
            // Arrange
            var graph = new GraphProvider().Load<DijkstraGraph>(@"xml\shortestway-sample.xml");
            graph.Validate();
            graph.Markup();
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            var way = dijkstra.Compute(graph)
                              .GetShortestWay(graph);

            // Assert
            Assert.AreEqual(way[0].Id, 1);
            Assert.AreEqual(way[1].Id, 6);
            Assert.AreEqual(way[2].Id, 8);
            Assert.AreEqual(way[3].Id, 9);
            Assert.AreEqual(way[4].Id, 10);

            Assert.AreEqual(way.Count, 5);
            Assert.AreEqual((way[4] as DijkstraNode).TotalWeigth, 22);
        }
        public void Find_ThrowsIfFinishNodeMarkIsinfinity_Test()
        {
            // Arrange
            var finish = Mock.Of<DijkstraNode>(d => d.TotalWeigth == null && d.Previous == Mock.Of<DijkstraNode>());
            var graph = Mock.Of<DijkstraGraph>(t => t.FinishNode() == finish);
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Assert
            Assert.Throws<NoRouteFromStartToFinishException>(() => dijkstra.GetShortestWay(graph));
        }
        public void Find_ReturnsWayNodeListByPrevious_Test()
        {
            // Arrange
            var prevPrev = Mock.Of<DijkstraNode>();
            var prev = Mock.Of<DijkstraNode>(t => t.Previous == prevPrev);
            var finishNode = Mock.Of<DijkstraNode>(t => t.Previous == prev && t.TotalWeigth == 100500);
            var graph = Mock.Of<DijkstraGraph>(t => t.FinishNode() == finishNode);
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            var way = dijkstra.GetShortestWay(graph);

            // Assert
            Assert.AreEqual(way[0], prevPrev);
            Assert.AreEqual(way[1], prev);
            Assert.AreEqual(way[2], finishNode);
        }
        public void Compute_UpdateLinkedMark_IfLinkedMarkIsinfinity_Test()
        {
            // Arrange
            var linked = Mock.Of<DijkstraNode>(t => t.TotalWeigth == null);
            var current = Mock.Of<DijkstraNode>(t => t.TotalWeigth == 10 && t.LinkWeight(linked) == 10);
            var graph = Mock.Of<DijkstraGraph>(t => t.HasUnvisited() == true
                                                 && t.Linked(current) == new[] { linked });
            Mock.Get(graph).Setup(t => t.NearestUnvisited()).Returns(current).Callback(() =>
                Mock.Get(graph).Setup(t => t.HasUnvisited()).Returns(false));
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Act
            dijkstra.Compute(graph);

            // Assert
            Assert.AreEqual(linked.TotalWeigth, 20);
        }
        public void Compute_ReturnsItSelf_WhenGraphHasNotUnvisited_Test()
        {
            // Arrange
            var graph = Mock.Of<DijkstraGraph>(t => t.HasUnvisited() == false);
            var dijkstra = new ShortestWay.Dijkstra.Dijkstra();

            // Assert
            Assert.AreEqual(dijkstra, dijkstra.Compute(graph));
        }