def test_SpecifyThatRetrievingAnInvalidNodeRaisesAnException(self):
        sparseGraph = SparseGraph(isDigraph=False)
        node = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node)

        self.assertRaises(Exception, sparseGraph.GetNode, -1)
        self.assertRaises(Exception, sparseGraph.GetNode, 1)
    def test_SpecifyThatANodeCanBeRetrievedFromTheGraph(self):
        sparseGraph = SparseGraph(isDigraph=False)
        node = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node)

        retrievedNode = sparseGraph.GetNode(0)

        self.assertEqual(node, retrievedNode)
    def test_SpecifyThatSparseGraphCanBeConstructed(self):
        sparseGraph = SparseGraph(isDigraph=True)

        self.assertEqual(0, len(sparseGraph._nodes), "_nodes")
        self.assertEqual(0, len(sparseGraph._edgeListVector),
                         "_edgeListVector")
        self.assertEqual(0, sparseGraph.GetNextFreeNodeIndex(),
                         "GetNextFreeNodeIndex")
        self.assertEqual(True, sparseGraph.IsDigraph, "IsDigraph")
        self.assertEqual(True, sparseGraph.IsEmpty, "IsEmpty")
    def test_SpecifyThatANodeCanBeAddedToTheGraph(self):
        sparseGraph = SparseGraph(isDigraph=False)
        node = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())

        sparseGraph.AddNode(node)

        self.assertEqual(1, len(sparseGraph._nodes), "_nodes")
        self.assertEqual(1, len(sparseGraph._edgeListVector),
                         "_edgeListVector")
        self.assertEqual(0, len(sparseGraph._edgeListVector[0]),
                         "_edgeListVector")
        self.assertEqual(1, sparseGraph._nextNodeIndex, "_nextNodeIndex")
 def CreateGraphGrid():
     graph = SparseGraph.CreateNavGraph(isDigraph=False)
     GraphTools.CreateGrid(graph, cxSize=50 * 3, cySize=50 * 3, numCellsX=3, numCellsY=3)
     GraphTools.WeightNavGraphNodeEdges(graph, nodeIndex=1, weight=2.5)
     GraphTools.WeightNavGraphNodeEdges(graph, nodeIndex=4, weight=2.5)
     GraphTools.WeightNavGraphNodeEdges(graph, nodeIndex=6, weight=2.5)
     return graph
    def test_SpecifyThatAnExceptionIsRaiseWhenAddingANodeInplaceOfACurrentlyActivatedNode(
            self):
        sparseGraph = SparseGraph(isDigraph=False)
        nodeIndex = sparseGraph.GetNextFreeNodeIndex()
        node = GraphNode(nodeIndex)

        sparseGraph.AddNode(node)

        self.assertEqual(1, len(sparseGraph._nodes), "_nodes 1")
        self.assertEqual(0, sparseGraph._nodes[nodeIndex].Index,
                         "node.Index 1")

        # Add a new node in place of a active node in the graph
        newNode = GraphNode(nodeIndex)

        self.assertRaises(Exception, sparseGraph.AddNode, newNode)
 def CreateGraphGrid(size=3):
     graph = SparseGraph.CreateNavGraph(isDigraph=False)
     GraphTools.CreateGrid(graph,
                           cxSize=50 * size,
                           cySize=50 * size,
                           numCellsX=size,
                           numCellsY=size)
     return graph
 def CreateGraphGrid():
     graph = SparseGraph.CreateNavGraph(isDigraph=False)
     GraphTools.CreateGrid(graph,
                           cxSize=50 * 3,
                           cySize=50 * 3,
                           numCellsX=3,
                           numCellsY=3)
     return graph
    def test_SpecifyThatAnEdgeCanBeAddedBetweenNodesOnADirectedGraph(self):
        sparseGraph = SparseGraph(isDigraph=True)

        node0 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node0)

        node1 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node1)

        edge = GraphEdge(fromNodeIndex=node0.Index, toNodeIndex=node1.Index)
        sparseGraph.AddEdge(edge)

        self.assertEqual(2, len(sparseGraph._nodes), "_nodes")
        self.assertEqual(2, len(sparseGraph._edgeListVector),
                         "_edgeListVector")
        self.assertEqual(2, sparseGraph._nextNodeIndex, "_nextNodeIndex")

        self.assertEqual(1, len(sparseGraph._edgeListVector[0]),
                         "_edgeListVector[0]")
        self.assertEqual(0, sparseGraph._edgeListVector[0][0].From,
                         "_edgeListVector[0][0].From")
        self.assertEqual(1, sparseGraph._edgeListVector[0][0].To,
                         "_edgeListVector[0][0].To")

        self.assertEqual(0, len(sparseGraph._edgeListVector[1]),
                         "_edgeListVector[1]")
    def test_SpecifyThatNodeCanHaveEdgeOnToItselfOnAnUndirectedGraph(self):
        sparseGraph = SparseGraph(isDigraph=False)

        node0 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node0)

        edge = GraphEdge(fromNodeIndex=node0.Index, toNodeIndex=node0.Index)
        sparseGraph.AddEdge(edge)

        self.assertEqual(1, len(sparseGraph._nodes), "_nodes")
        self.assertEqual(1, len(sparseGraph._edgeListVector),
                         "_edgeListVector")
        self.assertEqual(1, sparseGraph._nextNodeIndex, "_nextNodeIndex")

        self.assertEqual(1, len(sparseGraph._edgeListVector[0]),
                         "_edgeListVector[0]")
        self.assertEqual(0, sparseGraph._edgeListVector[0][0].From,
                         "_edgeListVector[0][0].From")
        self.assertEqual(0, sparseGraph._edgeListVector[0][0].To,
                         "_edgeListVector[0][0].To")
    def test_SpecifyThatANodeCanAddedInplaceOfACurrentlyDeactivatedNode(self):
        sparseGraph = SparseGraph(isDigraph=False)
        nodeIndex = sparseGraph.GetNextFreeNodeIndex()
        node = GraphNode(nodeIndex)

        sparseGraph.AddNode(node)

        self.assertEqual(1, len(sparseGraph._nodes), "_nodes 1")
        self.assertEqual(0, sparseGraph._nodes[nodeIndex].Index,
                         "node.Index 1")

        # Deactivate the node
        node.Index = NodeType.InvalidNodeIndex
        self.assertEqual(NodeType.InvalidNodeIndex.value,
                         sparseGraph._nodes[nodeIndex].Index, "node.Index 2")

        # Add a new node in place of a deactivate node in the graph
        newNode = GraphNode(nodeIndex)
        sparseGraph.AddNode(newNode)

        self.assertEqual(1, len(sparseGraph._nodes), "_nodes 3")
        self.assertEqual(0, sparseGraph._nodes[nodeIndex].Index,
                         "node.Index 3")
    def test_SpecifyThatAGraphCanBeSavedAndLoadedFromFile(self):
        graph = TestFactory.CreateDigraph()

        self.assertEqual(7, len(graph._nodes), "_nodes 1")
        self.assertEqual(7, len(graph._edgeListVector), "_edgeListVector 1")
        self.assertEqual(7, graph._nextNodeIndex, "_nextNodeIndex 1")
        self.assertEqual(8, graph.NumberOfEdges(), "NumberOfEdges 1")

        self.assertEqual(-1, graph._nodes[0].Index, "_nodes[0].Index 1")
        self.assertEqual(1, graph._nodes[1].Index, "_nodes[1].Index 1")
        self.assertEqual(2, graph._nodes[2].Index, "_nodes[2].Index 1")
        self.assertEqual(3, graph._nodes[3].Index, "_nodes[3].Index 1")
        self.assertEqual(4, graph._nodes[4].Index, "_nodes[4].Index 1")
        self.assertEqual(5, graph._nodes[5].Index, "_nodes[5].Index 1")
        self.assertEqual(6, graph._nodes[6].Index, "_nodes[6].Index 1")

        self.assertEqual(0, len(graph._edgeListVector[0]),
                         "_edgeListVector[0] 1")
        self.assertEqual(2, len(graph._edgeListVector[1]),
                         "_edgeListVector[1] 1")
        self.assertEqual(1, len(graph._edgeListVector[2]),
                         "_edgeListVector[2] 1")
        self.assertEqual(1, len(graph._edgeListVector[3]),
                         "_edgeListVector[3] 1")
        self.assertEqual(1, len(graph._edgeListVector[4]),
                         "_edgeListVector[4] 1")
        self.assertEqual(2, len(graph._edgeListVector[5]),
                         "_edgeListVector[5] 1")
        self.assertEqual(1, len(graph._edgeListVector[6]),
                         "_edgeListVector[6] 1")

        self.assertEqual(5, graph._edgeListVector[1][0].To,
                         "graph._edgeListVector[1][0].To 1")
        self.assertEqual(6, graph._edgeListVector[1][1].To,
                         "graph._edgeListVector[1][1].To 1")
        self.assertEqual(3, graph._edgeListVector[2][0].To,
                         "graph._edgeListVector[2][0].To 1")
        self.assertEqual(5, graph._edgeListVector[3][0].To,
                         "graph._edgeListVector[3][0].To 1")
        self.assertEqual(3, graph._edgeListVector[4][0].To,
                         "graph._edgeListVector[4][0].To 1")
        self.assertEqual(2, graph._edgeListVector[5][0].To,
                         "graph._edgeListVector[5][0].To 1")
        self.assertEqual(6, graph._edgeListVector[5][1].To,
                         "graph._edgeListVector[5][1].To 1")
        self.assertEqual(4, graph._edgeListVector[6][0].To,
                         "graph._edgeListVector[6][0].To 1")

        graph.Save("testGraph.map")

        graph = SparseGraph(isDigraph=False)

        graph.Load("testGraph.map")

        self.assertEqual(7, len(graph._nodes), "_nodes 2")
        self.assertEqual(7, len(graph._edgeListVector), "_edgeListVector 2")
        self.assertEqual(7, graph._nextNodeIndex, "_nextNodeIndex 2")
        self.assertEqual(8, graph.NumberOfEdges(), "NumberOfEdges 2")

        self.assertEqual(-1, graph._nodes[0].Index, "_nodes[0].Index 2")
        self.assertEqual(1, graph._nodes[1].Index, "_nodes[1].Index 2")
        self.assertEqual(2, graph._nodes[2].Index, "_nodes[2].Index 2")
        self.assertEqual(3, graph._nodes[3].Index, "_nodes[3].Index 2")
        self.assertEqual(4, graph._nodes[4].Index, "_nodes[4].Index 2")
        self.assertEqual(5, graph._nodes[5].Index, "_nodes[5].Index 2")
        self.assertEqual(6, graph._nodes[6].Index, "_nodes[6].Index 2")

        self.assertEqual(0, len(graph._edgeListVector[0]),
                         "_edgeListVector[0] 2")
        self.assertEqual(2, len(graph._edgeListVector[1]),
                         "_edgeListVector[1] 2")
        self.assertEqual(1, len(graph._edgeListVector[2]),
                         "_edgeListVector[2] 2")
        self.assertEqual(1, len(graph._edgeListVector[3]),
                         "_edgeListVector[3] 2")
        self.assertEqual(1, len(graph._edgeListVector[4]),
                         "_edgeListVector[4] 2")
        self.assertEqual(2, len(graph._edgeListVector[5]),
                         "_edgeListVector[5] 2")
        self.assertEqual(1, len(graph._edgeListVector[6]),
                         "_edgeListVector[6] 2")

        self.assertEqual(5, graph._edgeListVector[1][0].To,
                         "graph._edgeListVector[1][0].To 2")
        self.assertEqual(6, graph._edgeListVector[1][1].To,
                         "graph._edgeListVector[1][1].To 2")
        self.assertEqual(3, graph._edgeListVector[2][0].To,
                         "graph._edgeListVector[2][0].To 2")
        self.assertEqual(5, graph._edgeListVector[3][0].To,
                         "graph._edgeListVector[3][0].To 2")
        self.assertEqual(3, graph._edgeListVector[4][0].To,
                         "graph._edgeListVector[4][0].To 2")
        self.assertEqual(2, graph._edgeListVector[5][0].To,
                         "graph._edgeListVector[5][0].To 2")
        self.assertEqual(6, graph._edgeListVector[5][1].To,
                         "graph._edgeListVector[5][1].To 2")
        self.assertEqual(4, graph._edgeListVector[6][0].To,
                         "graph._edgeListVector[6][0].To 2")
    def test_SpecifyThatAnExceptionIsRaisedWhenAddingAThatDoesNotMatchTheGraphNextNodeIndex(
            self):
        sparseGraph = SparseGraph(isDigraph=False)
        node = GraphNode(index=999)

        self.assertRaises(Exception, sparseGraph.AddNode, node)
Esempio n. 14
0
    def CreateDigraph():
        from HorizonCore.Graph.SparseGraph import SparseGraph
        from HorizonCore.Graph.GraphEdge import GraphEdge
        from HorizonCore.Graph.GraphNode import GraphNode

        sparseGraph = SparseGraph(isDigraph=True)

        node0 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node0)
        node0.Index = -1

        node1 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node1)

        node2 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node2)

        node3 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node3)

        node4 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node4)

        node5 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node5)

        node6 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node6)

        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node1.Index,
                      toNodeIndex=node5.Index,
                      cost=2.9))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node1.Index,
                      toNodeIndex=node6.Index,
                      cost=1.0))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node2.Index,
                      toNodeIndex=node3.Index,
                      cost=3.1))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node3.Index,
                      toNodeIndex=node5.Index,
                      cost=0.8))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node4.Index,
                      toNodeIndex=node3.Index,
                      cost=3.7))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index,
                      toNodeIndex=node2.Index,
                      cost=1.9))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index,
                      toNodeIndex=node6.Index,
                      cost=3.0))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node6.Index,
                      toNodeIndex=node4.Index,
                      cost=1.1))

        return sparseGraph
Esempio n. 15
0
    def CreateUniGraph():
        from HorizonCore.Graph.SparseGraph import SparseGraph
        from HorizonCore.Graph.GraphEdge import GraphEdge
        from HorizonCore.Graph.GraphNode import GraphNode

        sparseGraph = SparseGraph(isDigraph=False)

        node0 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node0)
        node0.Index = -1

        node1 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node1)

        node2 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node2)

        node3 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node3)

        node4 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node4)

        node5 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node5)

        node6 = GraphNode(index=sparseGraph.GetNextFreeNodeIndex())
        sparseGraph.AddNode(node6)

        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node1.Index, toNodeIndex=node5.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node1.Index, toNodeIndex=node6.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node2.Index, toNodeIndex=node3.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node2.Index, toNodeIndex=node5.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node3.Index, toNodeIndex=node2.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node3.Index, toNodeIndex=node4.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node3.Index, toNodeIndex=node5.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node4.Index, toNodeIndex=node3.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node4.Index, toNodeIndex=node6.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index, toNodeIndex=node1.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index, toNodeIndex=node2.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index, toNodeIndex=node3.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node5.Index, toNodeIndex=node6.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node6.Index, toNodeIndex=node1.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node6.Index, toNodeIndex=node4.Index))
        sparseGraph.AddEdge(
            GraphEdge(fromNodeIndex=node6.Index, toNodeIndex=node5.Index))

        return sparseGraph
    def test_SpecifyThatAConnectedGridCanBeConstructedOnAUniGraph(self):
        graph = SparseGraph.CreateNavGraph(isDigraph=False)

        GraphTools.CreateGrid(graph,
                              cxSize=50 * 3,
                              cySize=50 * 3,
                              numCellsX=3,
                              numCellsY=3)

        self.assertEqual(9, len(graph._nodes), "_nodes")
        self.assertEqual(9, len(graph._edgeListVector), "_edgeListVector")
        self.assertEqual(9, graph._nextNodeIndex, "_nextNodeIndex")
        self.assertEqual(40, graph.NumberOfEdges(), "NumberOfEdges")

        self.assertEqual(0, graph._nodes[0].Index, "_nodes[0].Index")
        self.assertEqual(1, graph._nodes[1].Index, "_nodes[1].Index")
        self.assertEqual(2, graph._nodes[2].Index, "_nodes[2].Index")
        self.assertEqual(3, graph._nodes[3].Index, "_nodes[3].Index")
        self.assertEqual(4, graph._nodes[4].Index, "_nodes[4].Index")
        self.assertEqual(5, graph._nodes[5].Index, "_nodes[5].Index")
        self.assertEqual(6, graph._nodes[6].Index, "_nodes[6].Index")
        self.assertEqual(7, graph._nodes[7].Index, "_nodes[7].Index")
        self.assertEqual(8, graph._nodes[8].Index, "_nodes[8].Index")

        self.assertEqual(3, len(graph._edgeListVector[0]),
                         "_edgeListVector[0]")
        self.assertEqual(5, len(graph._edgeListVector[1]),
                         "_edgeListVector[1]")
        self.assertEqual(3, len(graph._edgeListVector[2]),
                         "_edgeListVector[2]")
        self.assertEqual(5, len(graph._edgeListVector[3]),
                         "_edgeListVector[3]")
        self.assertEqual(8, len(graph._edgeListVector[4]),
                         "_edgeListVector[4]")
        self.assertEqual(5, len(graph._edgeListVector[5]),
                         "_edgeListVector[5]")
        self.assertEqual(3, len(graph._edgeListVector[6]),
                         "_edgeListVector[6]")
        self.assertEqual(5, len(graph._edgeListVector[7]),
                         "_edgeListVector[6]")
        self.assertEqual(3, len(graph._edgeListVector[8]),
                         "_edgeListVector[6]")

        self.assertEqual(1, graph._edgeListVector[0][0].To,
                         "graph._edgeListVector[0][0].To")
        self.assertEqual(3, graph._edgeListVector[0][1].To,
                         "graph._edgeListVector[0][1].To")
        self.assertEqual(4, graph._edgeListVector[0][2].To,
                         "graph._edgeListVector[0][2].To")

        self.assertEqual(0, graph._edgeListVector[1][0].To,
                         "graph._edgeListVector[1][0].To")
        self.assertEqual(2, graph._edgeListVector[1][1].To,
                         "graph._edgeListVector[1][1].To")
        self.assertEqual(3, graph._edgeListVector[1][2].To,
                         "graph._edgeListVector[1][2].To")
        self.assertEqual(4, graph._edgeListVector[1][3].To,
                         "graph._edgeListVector[1][3].To")
        self.assertEqual(5, graph._edgeListVector[1][4].To,
                         "graph._edgeListVector[1][4].To")

        self.assertEqual(1, graph._edgeListVector[2][0].To,
                         "graph._edgeListVector[2][0].To")
        self.assertEqual(4, graph._edgeListVector[2][1].To,
                         "graph._edgeListVector[2][1].To")
        self.assertEqual(5, graph._edgeListVector[2][2].To,
                         "graph._edgeListVector[2][2].To")

        self.assertEqual(0, graph._edgeListVector[3][0].To,
                         "graph._edgeListVector[3][0].To")
        self.assertEqual(1, graph._edgeListVector[3][1].To,
                         "graph._edgeListVector[3][1].To")
        self.assertEqual(4, graph._edgeListVector[3][2].To,
                         "graph._edgeListVector[3][2].To")
        self.assertEqual(6, graph._edgeListVector[3][3].To,
                         "graph._edgeListVector[3][3].To")
        self.assertEqual(7, graph._edgeListVector[3][4].To,
                         "graph._edgeListVector[3][4].To")

        self.assertEqual(0, graph._edgeListVector[4][0].To,
                         "graph._edgeListVector[4][0].To")
        self.assertEqual(1, graph._edgeListVector[4][1].To,
                         "graph._edgeListVector[4][1].To")
        self.assertEqual(2, graph._edgeListVector[4][2].To,
                         "graph._edgeListVector[4][2].To")
        self.assertEqual(3, graph._edgeListVector[4][3].To,
                         "graph._edgeListVector[4][3].To")
        self.assertEqual(5, graph._edgeListVector[4][4].To,
                         "graph._edgeListVector[4][4].To")
        self.assertEqual(6, graph._edgeListVector[4][5].To,
                         "graph._edgeListVector[4][5].To")
        self.assertEqual(7, graph._edgeListVector[4][6].To,
                         "graph._edgeListVector[4][6].To")
        self.assertEqual(8, graph._edgeListVector[4][7].To,
                         "graph._edgeListVector[4][7].To")

        self.assertEqual(1, graph._edgeListVector[5][0].To,
                         "graph._edgeListVector[5][0].To")
        self.assertEqual(2, graph._edgeListVector[5][1].To,
                         "graph._edgeListVector[5][1].To")
        self.assertEqual(4, graph._edgeListVector[5][2].To,
                         "graph._edgeListVector[5][2].To")
        self.assertEqual(7, graph._edgeListVector[5][3].To,
                         "graph._edgeListVector[5][3].To")
        self.assertEqual(8, graph._edgeListVector[5][4].To,
                         "graph._edgeListVector[5][4].To")

        self.assertEqual(3, graph._edgeListVector[6][0].To,
                         "graph._edgeListVector[6][0].To")
        self.assertEqual(4, graph._edgeListVector[6][1].To,
                         "graph._edgeListVector[6][1].To")
        self.assertEqual(7, graph._edgeListVector[6][2].To,
                         "graph._edgeListVector[6][2].To")

        self.assertEqual(3, graph._edgeListVector[7][0].To,
                         "graph._edgeListVector[7][0].To")
        self.assertEqual(4, graph._edgeListVector[7][1].To,
                         "graph._edgeListVector[7][1].To")
        self.assertEqual(5, graph._edgeListVector[7][2].To,
                         "graph._edgeListVector[7][2].To")
        self.assertEqual(6, graph._edgeListVector[7][3].To,
                         "graph._edgeListVector[7][3].To")
        self.assertEqual(8, graph._edgeListVector[7][4].To,
                         "graph._edgeListVector[7][4].To")

        self.assertEqual(4, graph._edgeListVector[8][0].To,
                         "graph._edgeListVector[8][0].To")
        self.assertEqual(5, graph._edgeListVector[8][1].To,
                         "graph._edgeListVector[8][1].To")
        self.assertEqual(7, graph._edgeListVector[8][2].To,
                         "graph._edgeListVector[8][2].To")