def test_delete_corrupted(self):
"""
a b
___
/ / \
1 A,B C
|/ |
2 D --- E
"""
A = Vertex(domain=(1,'a'))
B = Vertex(domain=(1,'a'))
D = Vertex(domain=(2,'a'))
C = Vertex(domain=(1,'b'))
E = Vertex(domain=(2,'b'))
AD = Edge(A, D)
AC = Edge(A, C)
BC = Edge(B, C)
BD = Edge(B, D)
DE = Edge(D, E)
CE = Edge(C, E)
g = Graph([A, B, C, D, E], [AD, AC, BC, BD, DE, CE])
g.prepare()
self.assertItemsEqual(g.get_vertices(), [A, B, C, D, E])
self.assertItemsEqual(g.get_edges(), [AD, AC, BC, BD, DE, CE])
g.delete_edge(BD, True)
g.delete_corrupted()
self.assertItemsEqual(g.get_vertices(), [A, C, D, E])
self.assertItemsEqual(g.get_edges(), [AD, AC, DE, CE])
self.assertFalse(g.is_neighborhood_corrupted())
def test_delete_edge(self):
"""
a - b
-----
B
\
C
"""
v_aB = Vertex(domain='a')
v_bC = Vertex(domain='b')
e_aB_bC = Edge(v_aB, v_bC)
g = Graph([v_aB, v_bC],
[e_aB_bC])
g.prepare()
g.delete_edge(e_aB_bC)
self.assertItemsEqual(g.get_edges(), [])
self.assertItemsEqual(g.get_vertices(), [])
self.assertTrue(g.is_neighborhood_corrupted())
"""
def test_deep_copy(self):
v_a = Vertex()
v_b = Vertex()
e = Edge(v_a, v_b)
g = Graph([v_a, v_b], [e])
g_copy = deepcopy(g)
self.assertIsNot(g, g_copy)
e = g.get_edges().pop()
e_copy = g_copy.E.pop()
self.assertIsNot(e, e_copy)
self.assertEqual(e.get_value(), e_copy.get_value())
self.assertIsNot(e.get_vertices(), e_copy.get_vertices())
self.assertEqual([v.get_value() for v in e.get_vertices()],
[v.get_value() for v in e_copy.get_vertices()])
[v.set_value(1) for v in e.get_vertices()]
[v.set_value(2) for v in e_copy.get_vertices()]
self.assertNotEqual([v.get_value() for v in e.get_vertices()],
[v.get_value() for v in e_copy.get_vertices()])
e.set_value(1)
e_copy.set_value(2)
self.assertEqual(e.get_value(), 1)
self.assertEqual(e_copy.get_value(), 2)
self.assertEqual(len(g.get_vertices().intersection(g_copy.V)), 0)
def test_delete_vertex(self):
"""
a - b - c
-----
A - A - A
/
B - B
\
C
"""
v_aA = Vertex(domain='a')
v_aB = Vertex(domain='a')
v_bA = Vertex(domain='b')
v_bB = Vertex(domain='b')
v_bC = Vertex(domain='b')
v_cA = Vertex(domain='c')
e_aA_bA = Edge(v_aA, v_bA)
e_aB_bB = Edge(v_aB, v_bB)
e_aB_bC = Edge(v_aB, v_bC)
e_bA_cA = Edge(v_bA, v_cA)
e_bB_cA = Edge(v_bB, v_cA)
g = Graph([v_aA, v_aB, v_bA, v_bB, v_bC, v_cA],
[e_aA_bA, e_aB_bB, e_bA_cA, e_bB_cA, e_aB_bC])
g.prepare()
self.assertItemsEqual(g.get_edges(), [e_aA_bA, e_aB_bB, e_aB_bC,
e_bA_cA, e_bB_cA])
self.assertItemsEqual(g.get_vertices(), [v_aA, v_aB, v_bA,
v_bB, v_bC, v_cA])
self.assertFalse(g.is_neighborhood_corrupted())
"""
a - b - c
-----
X x A
/
B - B
\
C
"""
g.delete_vertex(v_aA)
self.assertItemsEqual(g.get_edges(), [e_aB_bB, e_aB_bC, e_bB_cA])
self.assertItemsEqual(g.get_vertices(), [v_aB, v_bB, v_bC, v_cA])
self.assertFalse(g.is_neighborhood_corrupted())
self.assertItemsEqual(g.get_domain('b'), [v_bB, v_bC])
"""
a - b - c
-----
x
B X
\
C
"""
g.delete_vertex(v_bB)
self.assertItemsEqual(g.get_edges(), [e_aB_bC])
self.assertItemsEqual(g.get_vertices(), [v_aB, v_bC])
self.assertTrue(g.is_neighborhood_corrupted())
self.assertItemsEqual(g.get_domain('a'), [v_aB])
self.assertItemsEqual(g.get_domain('b'), [v_bC])
"""
a - b - c
-----
x
X
"""
g.delete_vertex(v_bC)
self.assertEqual(g.get_edges(), set())
self.assertEqual(g.get_vertices(), set())
self.assertTrue(g.is_neighborhood_corrupted())
g.restore()
self.assertItemsEqual(g.get_edges(), [e_aA_bA, e_aB_bB, e_aB_bC,
e_bA_cA, e_bB_cA])
self.assertItemsEqual(g.get_vertices(), [v_aA, v_aB, v_bA,
v_bB, v_bC, v_cA])
self.assertFalse(g.is_neighborhood_corrupted())
