예제 #1
0
    def test_that_districts_correct(self):

        vertices = ['A', 'B', 'C', 'D', 'Y']
        di_edges = [('A', 'B'), ('A', 'D'), ('B', 'C'), ('C', 'Y'), ('B', 'D'), ('D', 'Y')]
        bi_edges = [('A', 'C'), ('B', 'Y'), ('B', 'D')]
        G = SG(vertices, di_edges, bi_edges)
        self.assertCountEqual(([{'A', 'C'}, {'D', 'Y', 'B'}]), G.districts)
        self.assertEqual({'A', 'C'}, G.district('A'))
예제 #2
0
 def test_directed_cycle_graph_raises_error(self):
     # directed cycle graph
     vertices = ['A', 'B', 'C']
     bi_edges = [('A', 'B')]
     di_edges = [('A', 'B'), ('B', 'C'), ('C', 'A')]
     with self.assertRaises(TypeError):
         G = SG(vertices, bi_edges=bi_edges, di_edges=di_edges)
예제 #3
0
 def test_districts_is_a_property(self, mock1):
     vertices = ["X_1", "X_2", "W", "Y"]
     di_edges = [("X_1", "W"), ("W", "Y"), ("X_2", "Y")]
     bi_edges = [("X_1", "W"), ("X_2", "Y"), ("X_1", "X_2")]
     G = SG(vertices, di_edges=di_edges, bi_edges=bi_edges)
     self.assertEqual(0, mock1.call_count)
     G.districts
     self.assertEqual(1, mock1.call_count)
예제 #4
0
    def test_blocks_is_a_property(self, mock1):
        vertices = ["X_1", "X_2", "W", "Y"]
        di_edges = [("X_1", "W"), ("W", "Y"), ("X_2", "Y")]
        ud_edges = [("X_1", "W")]
        G = SG(vertices, di_edges=di_edges, ud_edges=ud_edges)

        self.assertEqual(0, mock1.call_count)
        G.blocks
        self.assertEqual(1, mock1.call_count)
예제 #5
0
 def test_udedge(self):
     vertices = ["X_1", "X_2", "W", "Y"]
     di_edges = [("X_1", "Y"), ("X_2", "W")]
     ud_edges = [("X_1", "X_2")]
     G = SG(vertices=vertices, di_edges=di_edges, ud_edges=ud_edges)
     G.add_udedge("W", "Y")
     self.assertTrue("W" in G.neighbors(["Y"]))
     self.assertTrue("Y" in G.neighbors(["W"]))
     G.delete_udedge("W", "Y")
     self.assertFalse("W" in G.neighbors(["Y"]))
     self.assertFalse("Y" in G.neighbors(["W"]))
예제 #6
0
 def test_biedge(self):
     vertices = ["X_1", "X_2", "W", "Y"]
     di_edges = [("X_1", "Y"), ("X_2", "W")]
     ud_edges = [("X_1", "X_2")]
     G = SG(vertices=vertices, di_edges=di_edges, ud_edges=ud_edges)
     G.add_biedge("X_1", "X_2")
     self.assertTrue("X_2" in G.siblings(["X_1"]))
     self.assertTrue("X_1" in G.siblings(["X_2"]))
     G.delete_biedge("X_1", "X_2")
     self.assertFalse("X_2" in G.siblings(["X_1"]))
     self.assertFalse("X_1" in G.siblings(["X_2"]))
예제 #7
0
    def test_sg_does_not_raise_error(self):
        """
        This properly formed SG should not raise an AssertionError

        :return:
        """

        try:
            vertices = ['A', 'B', 'C']
            bi_edges = []
            ud_edges = [('A', 'B'), ('B', 'C'), ('C', 'A')]
            G = SG(vertices, bi_edges=bi_edges, ud_edges=ud_edges)
        except TypeError:
            self.fail("Correctly formed SG raised AssertionError")
예제 #8
0
    def test_fix_gives_correct_graph(self):

        vertices = ["X_1", "X_2", "W", "Y"]
        di_edges = [("X_1", "W"), ("W", "Y"), ("X_2", "Y")]
        bi_edges = [("X_1", "W"), ("X_2", "Y"), ("X_1", "X_2")]
        G = SG(vertices, di_edges, bi_edges)
        G.fix(["X_1"])
        self.assertTrue(G.vertices["X_1"].fixed)
        G_dis = {frozenset(s) for s in G.districts}

        self.assertEqual({frozenset({"X_2", "Y"}), frozenset({"W"})}, G_dis)
        self.assertEqual(sorted([("X_1", "W"), ("W", "Y"), ("X_2", "Y")]), sorted(list(G.di_edges)))

        G.fix(["Y"])
        self.assertTrue(G.vertices["Y"].fixed)
        self.assertTrue("W" not in G.parents(["Y"]))
        self.assertTrue("X_2" not in G.siblings(["Y"]))
예제 #9
0
 def test_genealogical_sets_correct(self):
     vertices = ['X1', 'U', 'X2', 'A1', 'A2', 'Y1', 'Y2']
     di_edges = [('X1', 'A1'), ('X1', 'Y1'), ('A1', 'Y1'), ('X2', 'A2'), ('X2', 'Y2'), ('A2', 'Y2'),
                 ('U', 'A1'), ('U', 'Y1'), ('U', 'A2'), ('U', 'Y2'), ('A2', 'Y1'), ('A1', 'Y2')]
     bi_edges = [('X1', 'U'), ('U', 'X2'), ('X1', 'X2'), ('Y1', 'Y2')]
     G = SG(vertices, di_edges, bi_edges)
     self.assertCountEqual((G.districts), [{'X2', 'X1', 'U'}, {'A1'}, {'A2'}, {'Y2', 'Y1'}])
     self.assertEqual(G.district('X2'), {'X2', 'X1', 'U'})
     self.assertEqual(G.ancestors(['A2']), {'X2', 'A2', 'U'})
     self.assertEqual(G.ancestors(['A1']), {'X1', 'A1', 'U'})
     self.assertEqual(G.ancestors(['A1', 'A2']), {'X2', 'A1', 'X1', 'U', 'A2'})
     self.assertEqual(G.descendants(['A1', 'A2']), {'Y2', 'Y1', 'A1', 'A2'})
예제 #10
0
 def test_non_segregated_graph_raises_error(self):
     vertices = ['A', 'B', 'C']
     bi_edges = [('A', 'B')]
     ud_edges = [('B', 'C')]
     with self.assertRaises(TypeError):
         G = SG(vertices, bi_edges=bi_edges, ud_edges=ud_edges)
예제 #11
0
 def test_blocks(self):
     vertices = ["X_1", "X_2", "W", "Y"]
     di_edges = [("X_1", "Y"), ("X_2", "W")]
     ud_edges = [("X_1", "X_2")]
     G = SG(vertices=vertices, di_edges=di_edges, ud_edges=ud_edges)
     self.assertEqual({frozenset({"X_1", "X_2"}), frozenset({"W"}), frozenset({"Y"})}, {frozenset(i) for i in G.blocks})
예제 #12
0
 def test_block(self):
     vertices = ["X_1", "X_2", "W", "Y"]
     di_edges = [("X_1", "Y"), ("X_2", "W")]
     ud_edges = [("X_1", "X_2")]
     G = SG(vertices=vertices, di_edges=di_edges, ud_edges=ud_edges)
     self.assertEqual({"X_1", "X_2"}, G.block("X_1"))