예제 #1
0
    def test_transitive_closure_of_a_node_on_a_graph_with_loops_should_still_terminate(
            self):
        dep_graph = DepGraph()

        # A -> B, B -> C, C -> D, D -> A
        A = _a_mock_definition()
        B = _a_mock_definition()
        C = _a_mock_definition()
        D = _a_mock_definition()
        uses = [
            (A, B),
            (B, C),
            (C, D),
            (D, A),
        ]

        for use in uses:
            dep_graph.add_edge(*use)

        result = dep_graph.transitive_closure(C)
        result_nodes = set(result.nodes)
        result_edges = set(result.edges)

        self.assertSetEqual(result_nodes, {A, B, C, D})
        self.assertSetEqual(result_edges, {(A, B), (B, C), (C, D), (D, A)})
예제 #2
0
def test_delegate_add_edge_to_the_underlying_graph_object(digraph_add_edge_mock):
    use = (_a_mock_definition(), _a_mock_definition())
    labels = { 'attribute1': 'value1', 'attribute2': 'value2' }

    dep_graph = DepGraph()
    dep_graph.add_edge(*use, **labels)

    digraph_add_edge_mock.assert_called_once_with(*use, **labels)
예제 #3
0
    def test_delegate_add_edge_to_the_underlying_graph_object(self):
        with mock.patch.object(networkx.DiGraph,
                               'add_edge') as digraph_add_edge_mock:
            use = (_a_mock_definition(), _a_mock_definition())
            labels = {'attribute1': 'value1', 'attribute2': 'value2'}

            dep_graph = DepGraph()
            dep_graph.add_edge(*use, **labels)

            digraph_add_edge_mock.assert_called_once_with(*use, **labels)
예제 #4
0
def test_transitive_closure_of_a_node_should_copy_labels_from_original_graph():
    dep_graph = DepGraph()

    # A -> B
    A = _a_mock_definition()
    B = _a_mock_definition()
    uses = [(A, B)]

    for use in uses:
        dep_graph.add_edge(*use, label='some data')

    result = dep_graph.transitive_closure(B).get_edge_data(A, B)['label']

    nose.tools.assert_equals(result, 'some data')
예제 #5
0
    def test_contains_atom_returns_false_if_the_dependency_graph_does_not_contain_a_definition_of_the_given_atom(
            self):
        dep_graph = DepGraph()

        # A -> B
        A = _a_mock_definition()
        B = _a_mock_definition()

        uses = [(A, B)]

        for use in uses:
            dep_graph.add_edge(*use)

        result = dep_graph.contains_atom(Register(8, 4))
        self.assertFalse(result)
예제 #6
0
    def test_contains_atom_returns_true_if_the_dependency_graph_contains_a_definition_of_the_given_atom(
            self):
        dep_graph = DepGraph()

        r0 = Register(8, 4)

        # A -> B
        A = _a_mock_definition(r0)
        B = _a_mock_definition()

        uses = [(A, B)]

        for use in uses:
            dep_graph.add_edge(*use)

        result = dep_graph.contains_atom(r0)
        self.assertTrue(result)
예제 #7
0
def test_top_predecessors():
    dep_graph = DepGraph()

    # A -> B, B -> D, C -> D
    A = _a_mock_definition()
    B = _a_mock_definition()
    C = _a_mock_definition()
    D = _a_mock_definition()
    uses = [
        (A, B),
        (B, D),
        (C, D),
    ]

    for use in uses:
        dep_graph.add_edge(*use)

    result = dep_graph.top_predecessors(D)

    nose.tools.assert_list_equal(result, [A, C])
예제 #8
0
    def test_transitive_closure_includes_beginning_node_with_memoized_content(
            self):
        dep_graph = DepGraph()
        # A -> B
        # B -> C
        # C -> D
        A = _a_mock_definition()
        B = _a_mock_definition()
        C = _a_mock_definition()
        D = _a_mock_definition()
        uses = [(A, B), (B, C), (C, D)]
        for use in uses:
            dep_graph.add_edge(*use)

        closure_0 = dep_graph.transitive_closure(C)
        self.assertNotIn(D, closure_0)

        closure_1 = dep_graph.transitive_closure(D)
        self.assertIn(D, closure_1)
        self.assertTrue(closure_1.has_edge(A, B))
        self.assertTrue(closure_1.has_edge(B, C))
        self.assertTrue(closure_1.has_edge(C, D))
예제 #9
0
    def test_transitive_closure_of_a_node(self):
        dep_graph = DepGraph()

        # A -> B, B -> D, C -> D
        A = _a_mock_definition()
        B = _a_mock_definition()
        C = _a_mock_definition()
        D = _a_mock_definition()
        uses = [
            (A, B),
            (B, D),
            (C, D),
        ]

        for use in uses:
            dep_graph.add_edge(*use)

        result = dep_graph.transitive_closure(D)
        result_nodes = set(result.nodes)
        result_edges = set(result.edges)

        self.assertSetEqual(result_nodes, {D, B, C, A})
        self.assertSetEqual(result_edges, {(B, D), (C, D), (A, B)})