def test_removeEdge_unsafe(self):
self._removeEdge(False)
# try to remove an inexistent edge
for edge in GraphEdge(2,5), GraphEdge(2,'a'), GraphEdge('a',5):
g = self.getGraph(); g.removeEdge(edge, safe=False)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges)
def test_iterEdges(self):
iterEdges = self.getGraph().iterEdges
self.failUnless(GraphEdge(1,2) in iterEdges())
self.failIf(GraphEdge(2,1) in iterEdges())
it = iterEdges()
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
def test_nextEdges(self, nextEdges=None):
if nextEdges is None:
nextEdges = self.getGraph().nextEdges
self.assertEqualSets(nextEdges(1), [GraphEdge(1,2), GraphEdge(1,3)])
self.assertEqualSets(nextEdges(2), self.next_edges_2)
self.assertEqualSets(nextEdges(3), [])
self.assertEqualSets(nextEdges(4), [GraphEdge(4,2)])
self.assertEqualSets(nextEdges(5), [GraphEdge(5,5)])
self.assertEqualSets(nextEdges(6), [])
self.assertRaises(KeyError,nextEdges,'a')
def test_previousEdges(self, previousEdges=None):
if previousEdges is None:
previousEdges = self.getGraph().previousEdges
self.assertEqualSets(previousEdges(1), [])
self.assertEqualSets(previousEdges(2), [GraphEdge(1,2),
GraphEdge(4,2)])
self.assertEqualSets(previousEdges(3), [GraphEdge(1,3),
GraphEdge(2,3)])
self.assertEqualSets(previousEdges(4), self.previous_edges_4)
self.assertEqualSets(previousEdges(5), [GraphEdge(5,5)])
self.assertEqualSets(previousEdges(6), [])
self.assertRaises(KeyError,previousEdges,'a')
def test_addEdge_new(self):
safe = False
# add a new edge among the existing nodes
g = self.getGraph(); g.addEdge((1,5), safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,5)])
# add a new edge and one new node
g = self.getGraph(); g.addEdge((1,'a'), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,'a')])
g = self.getGraph(); g.addEdge(('a',5), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge('a',5)])
# add a new edge and two new nodes
g = self.getGraph(); g.addEdge(('a','b'), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a','b'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge('a','b')])
def test_eq(self):
g1 = self.getGraph()
g2 = self.getGraph()
self.assertEquals(g1,g2)
self.assertNotEquals(g1,self.graph_class())
edges = [(1,2),(1,3),(2,3),(2,4)]
self.assertEquals(Digraph(edges), MultiDigraph(edges))
edges.append(GraphEdge(2,3))
self.assertNotEquals(Digraph(edges), MultiDigraph(edges))
class DigraphTestCase(GraphTestCase, unittest.TestCase):
graph_class = MultiDigraph
edges = GraphTestCase.all_edges
next_edges_2 = (GraphEdge(2,4), GraphEdge(2,3), GraphEdge(2,4))
previous_edges_4 = (GraphEdge(2,4), GraphEdge(2,4))
def test_addEdge_existing(self):
for safe in False,True:
g = self.getGraph(); g.addEdge((1,2),safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,2)])
def _restEdges_removedEdges(self, *removedEdges):
# remove only one duplicate of each removedEdge
rest = list(self.edges)
for removedEdge in removedEdges:
rest.remove(removedEdge)
return rest
def test_addEdge_new_safe(self):
safe = True
# add a new edge among the existing nodes
g = self.getGraph(); g.addEdge((1,5), safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,5)])
# try to a new edge to an inexistent node
self.assertRaises(KeyError, self.getGraph().addEdge, (1,'a'), safe)
self.assertRaises(KeyError, self.getGraph().addEdge, ('a',5), safe)
self.assertRaises(KeyError, self.getGraph().addEdge, ('a','b'), safe)
def test_hasEdge(self):
hasEdge = self.getGraph().hasEdge
self.failUnless(hasEdge(GraphEdge(1,2)))
self.failUnless(hasEdge((1,2)))
self.failUnless(hasEdge((5,5)))
self.failIf(hasEdge((2,1)))
def test_addEdge_existing(self):
for safe in False,True:
g = self.getGraph(); g.addEdge((1,2),safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,2)])
def _removeEdge(self, safe):
for edge in GraphEdge(1,2), GraphEdge(2,4):
g = self.getGraph(); g.removeEdge(edge,safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self._restEdges_removedEdges(edge))
def test_removeEdge(self):
self._removeEdge(True)
# try to remove an inexistent edge
for edge in GraphEdge(2,5), GraphEdge(2,'a'), GraphEdge('a',5):
self.assertRaises(KeyError, self.getGraph().removeEdge, edge)
class GraphTestCase(unittest.TestCase):
graph_class = Digraph
all_edges = [GraphEdge(i,j) for (i,j) in
(1,2),(1,3),(2,4),(2,3),(4,2),(5,5),(2,4)]
edges = uniq(all_edges)
extra_nodes = [3,6]
nodes = uniq(extra_nodes + [e.startNode for e in edges] +
[e.endNode for e in edges])
next_edges_2 = (GraphEdge(2,4), GraphEdge(2,3))
previous_edges_4 = [GraphEdge(2,4)]
def getGraph(self):
return self.graph_class(nodes=self.extra_nodes, edges=self.all_edges)
#------- node accesor tests ----------------------------------------------
def test_numNodes(self):
self.assertEquals(self.getGraph().numNodes(), 6)
def test_hasNode(self):
hasNode = self.getGraph().hasNode
self.failUnless(hasNode(5))
self.failUnless(hasNode(6))
self.failIf(hasNode('a'))
def test_nodes(self):
self.assertEqualSets(self.getGraph().nodes(), self.nodes)
def test_iterNodes(self):
iterNodes = self.getGraph().iterNodes
self.failUnless(3 in iterNodes())
self.failIf('a' in iterNodes())
it = iterNodes()
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
def test_nextNodes(self, nextNodes=None):
if nextNodes is None:
nextNodes = self.getGraph().nextNodes
self.assertEqualSets(nextNodes(1), [2,3])
self.assertEqualSets(nextNodes(2), [3,4])
self.assertEqualSets(nextNodes(3), [])
self.assertEqualSets(nextNodes(4), [2])
self.assertEqualSets(nextNodes(5), [5])
self.assertEqualSets(nextNodes(6), [])
self.assertRaises(KeyError,nextNodes,'a')
def test_iterNextNodes(self):
iterNextNodes = self.getGraph().iterNextNodes
it = iterNextNodes(2)
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
# assert that list(iterNextNodes) == nextNodes
self.test_nextNodes(lambda node: list(iterNextNodes(node)))
def test_previousNodes(self, previousNodes=None):
if previousNodes is None:
previousNodes = self.getGraph().previousNodes
self.assertEqualSets(previousNodes(1), [])
self.assertEqualSets(previousNodes(2), [1,4])
self.assertEqualSets(previousNodes(3), [1,2])
self.assertEqualSets(previousNodes(4), [2])
self.assertEqualSets(previousNodes(5), [5])
self.assertEqualSets(previousNodes(6), [])
self.assertRaises(KeyError,previousNodes,'a')
def test_iterPreviousNodes(self):
iterPreviousNodes = self.getGraph().iterPreviousNodes
it = iterPreviousNodes(3)
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
# assert that list(iterPreviousNodes) == previousNodes
self.test_previousNodes(lambda node: list(iterPreviousNodes(node)))
#------- edge accesor tests ----------------------------------------------
def test_numEdges(self):
self.assertEquals(self.getGraph().numEdges(), len(self.edges))
def test_hasEdge(self):
hasEdge = self.getGraph().hasEdge
self.failUnless(hasEdge(GraphEdge(1,2)))
self.failUnless(hasEdge((1,2)))
self.failUnless(hasEdge((5,5)))
self.failIf(hasEdge((2,1)))
def test_edges(self):
self.assertEqualSets(self.getGraph().edges(), self.edges)
def test_iterEdges(self):
iterEdges = self.getGraph().iterEdges
self.failUnless(GraphEdge(1,2) in iterEdges())
self.failIf(GraphEdge(2,1) in iterEdges())
it = iterEdges()
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
def test_nextEdges(self, nextEdges=None):
if nextEdges is None:
nextEdges = self.getGraph().nextEdges
self.assertEqualSets(nextEdges(1), [GraphEdge(1,2), GraphEdge(1,3)])
self.assertEqualSets(nextEdges(2), self.next_edges_2)
self.assertEqualSets(nextEdges(3), [])
self.assertEqualSets(nextEdges(4), [GraphEdge(4,2)])
self.assertEqualSets(nextEdges(5), [GraphEdge(5,5)])
self.assertEqualSets(nextEdges(6), [])
self.assertRaises(KeyError,nextEdges,'a')
def test_iterNextEdges(self):
iterNextEdges = self.getGraph().iterNextEdges
it = iterNextEdges(2)
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
# assert that list(iterNextEdges) == nextEdges
self.test_nextEdges(lambda node: list(iterNextEdges(node)))
def test_previousEdges(self, previousEdges=None):
if previousEdges is None:
previousEdges = self.getGraph().previousEdges
self.assertEqualSets(previousEdges(1), [])
self.assertEqualSets(previousEdges(2), [GraphEdge(1,2),
GraphEdge(4,2)])
self.assertEqualSets(previousEdges(3), [GraphEdge(1,3),
GraphEdge(2,3)])
self.assertEqualSets(previousEdges(4), self.previous_edges_4)
self.assertEqualSets(previousEdges(5), [GraphEdge(5,5)])
self.assertEqualSets(previousEdges(6), [])
self.assertRaises(KeyError,previousEdges,'a')
def test_iterPreviousEdges(self):
iterPreviousEdges = self.getGraph().iterPreviousEdges
it = iterPreviousEdges(4)
self.failUnless(list(it))
# iterator is exhausted
self.failIf(list(it))
# assert that list(iterPreviousEdges) == previousEdges
self.test_previousEdges(lambda node: list(iterPreviousEdges(node)))
#------- (in)equality, copy tests ----------------------------------------
def test_eq(self):
g1 = self.getGraph()
g2 = self.getGraph()
self.assertEquals(g1,g2)
self.assertNotEquals(g1,self.graph_class())
edges = [(1,2),(1,3),(2,3),(2,4)]
self.assertEquals(Digraph(edges), MultiDigraph(edges))
edges.append(GraphEdge(2,3))
self.assertNotEquals(Digraph(edges), MultiDigraph(edges))
def test_copy(self):
g = self.getGraph()
c = copy.copy(g)
self.assertEquals(c,g)
def test_copy_modify(self):
mutations = [('addNode', 'a'), ('removeNode', 4),
('addEdge', (1,5)), ('addEdge', (1,2)),
('removeEdge', (1,2)), ('removeEdge', (2,4))]
# assert that the clone does not change after mutating the original
for method,arg in mutations:
orig = self.getGraph()
clone = copy.copy(orig)
getattr(orig,method)(arg,False)
self.assertEqualSets(clone.nodes(), self.nodes)
self.assertEqualSets(clone.edges(), self.edges)
# assert that the original does not change after mutating the clone
for method,arg in mutations:
orig = self.getGraph()
clone = copy.copy(orig)
getattr(clone,method)(arg,False)
self.assertEqualSets(orig.nodes(), self.nodes)
self.assertEqualSets(orig.edges(), self.edges)
#def test_deepcopy(self):
# warnings.warn("missing test for deepcopy")
#------- node mutator tests ----------------------------------------------
def test_addNode(self):
safe = False
self._addNode(safe)
# add an existing node; nothing changes
g=self.getGraph(); g.addNode(3,safe)
self.assertEqualSets(g.edges(), self.edges)
self.assertEqualSets(g.nodes(), self.nodes)
def test_addNode_safe(self):
safe = True
self._addNode(safe)
# try to add an exsting node
self.assertRaises(KeyError, self.getGraph().addNode, 3, safe)
def test_removeNode(self):
self._removeNode(True)
# try to remove an inexistent node
self.assertRaises(KeyError, self.getGraph().removeNode, 'a')
def test_removeNode_unsafe(self):
self._removeNode(False)
# try to remove an inexistent node
g=self.getGraph(); g.removeNode('a', safe=False)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges)
def test_popNode(self):
g = self.getGraph()
node = g.popNode()
self.assertEqualSets(g.nodes(), self._restNodes(node))
self.assertEqualSets(g.edges(), self._restEdges_removedNodes(node))
# try to pop from an empty graph
self.assertRaises(KeyError, self.graph_class().popNode)
def test_clearNodes(self):
g = self.getGraph()
g.clearNodes()
self.failIf(g.nodes())
self.failIf(g.edges())
self.assertEquals(g, self.graph_class())
#------- edge mutator tests ----------------------------------------------
def test_addEdge_new(self):
safe = False
# add a new edge among the existing nodes
g = self.getGraph(); g.addEdge((1,5), safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,5)])
# add a new edge and one new node
g = self.getGraph(); g.addEdge((1,'a'), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,'a')])
g = self.getGraph(); g.addEdge(('a',5), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge('a',5)])
# add a new edge and two new nodes
g = self.getGraph(); g.addEdge(('a','b'), safe)
self.assertEqualSets(g.nodes(), self.nodes + ['a','b'])
self.assertEqualSets(g.edges(), self.edges + [GraphEdge('a','b')])
def test_addEdge_new_safe(self):
safe = True
# add a new edge among the existing nodes
g = self.getGraph(); g.addEdge((1,5), safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges + [GraphEdge(1,5)])
# try to a new edge to an inexistent node
self.assertRaises(KeyError, self.getGraph().addEdge, (1,'a'), safe)
self.assertRaises(KeyError, self.getGraph().addEdge, ('a',5), safe)
self.assertRaises(KeyError, self.getGraph().addEdge, ('a','b'), safe)
def test_addEdge_existing(self):
g = self.getGraph(); g.addEdge((1,2), False)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges)
self.assertRaises(KeyError, self.getGraph().addEdge, (1,2), True)
def test_removeEdge(self):
self._removeEdge(True)
# try to remove an inexistent edge
for edge in GraphEdge(2,5), GraphEdge(2,'a'), GraphEdge('a',5):
self.assertRaises(KeyError, self.getGraph().removeEdge, edge)
def test_removeEdge_unsafe(self):
self._removeEdge(False)
# try to remove an inexistent edge
for edge in GraphEdge(2,5), GraphEdge(2,'a'), GraphEdge('a',5):
g = self.getGraph(); g.removeEdge(edge, safe=False)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self.edges)
def test_popEdge(self):
g = self.getGraph()
edge = g.popEdge()
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self._restEdges_removedEdges(edge))
# try to pop from an empty graph
self.assertRaises(KeyError, self.graph_class().popNode)
def test_clearEdges(self):
g = self.getGraph()
g.clearEdges()
self.assertEqualSets(g.nodes(), self.nodes)
self.failIf(g.edges())
#------- helpers ---------------------------------------------------------
def assertEqualSets(self,c1,c2):
#self.assertEquals(list(c1), list(c2))
self.assertEquals(sorted(c1), sorted(c2))
def _addNode(self,safe):
# add a new node
g = self.getGraph(); g.addNode('a',safe)
self.assertEqualSets(g.edges(), self.edges)
self.assertEqualSets(g.nodes(), list(self.nodes) + ['a'])
def _removeNode(self, safe):
g = self.getGraph(); g.removeNode(4,safe)
self.assertEqualSets(g.nodes(), self._restNodes(4))
self.assertEqualSets(g.edges(), self._restEdges_removedNodes(4))
def _removeEdge(self, safe):
for edge in GraphEdge(1,2), GraphEdge(2,4):
g = self.getGraph(); g.removeEdge(edge,safe)
self.assertEqualSets(g.nodes(), self.nodes)
self.assertEqualSets(g.edges(), self._restEdges_removedEdges(edge))
def _restNodes(self,*removedNodes):
rest = list(self.nodes)
for removedNode in removedNodes:
rest.remove(removedNode)
return rest
def _restEdges_removedNodes(self, *removedNodes):
return filter(lambda edge: (edge.startNode not in removedNodes
and edge.endNode not in removedNodes),
self.edges)
def _restEdges_removedEdges(self, *removedEdges):
# remove all duplicates of each removedEdge
return filter(lambda edge: edge not in removedEdges, self.edges)