def test_get_domain_tuple(self):
     v_aA = Vertex('A', None, (0,1))
     v_aB = Vertex('B', None, (0,1))
     v_bA = Vertex('A', None, (0,2))
     v_cA = Vertex('A', None, (1,1))
     v_cB = Vertex('B', None, (1,1))
     g = Graph([v_aA, v_aB, v_bA, v_cA, v_cB], Edge(v_aA, v_bA))
     self.assertItemsEqual(g.get_domain((0,1)), [v_aA, v_aB])
     self.assertItemsEqual(g.get_domain((0,2)), [v_bA])
     self.assertItemsEqual(g.get_domain((1,1)), [v_cA, v_cB])
 def test_get_domain(self):
     v_aA = Vertex('A', None, 'a')
     v_aB = Vertex('B', None, 'a')
     v_bA = Vertex('A', None, 'b')
     v_bB = Vertex('B', None, 'b')
     v_bC = Vertex('C', None, 'b')
     g = Graph([v_aA, v_aB, v_bA, v_bB, v_bC], Edge(v_aA, v_bB))
     self.assertItemsEqual(g.get_domain('a'), [v_aA, v_aB])
     self.assertItemsEqual(g.get_domain('b'), [v_bA, v_bB, v_bC])
    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())