Ejemplo n.º 1
0
    def test_with_HSM_instance(self):
        states = {
            'root': State({
                'left': State({
                    'left_A': State(),
                    'left_B': State(),
                }),
                'middle': State({
                    'middle_A': State(),
                    'middle_B': State(),
                    'middle_C': State(),
                }),
                'right': State({
                    'right_A': State({
                        'right_A_1': State(),
                        'deep': State(),
                        'right_A_2': State(),
                    }),
                    'right_B': State(),
                })
            })
        }

        flattened = HSM(states, {}, skip_validation=True).flattened

        left_B = get_state_by_sig(('left_B',), flattened)
        deep = get_state_by_sig(('deep',), flattened)

        exits, parent, entries = get_path(deep, left_B)
        exits = [st.name for st in exits]
        entries = [st.name for st in entries]

        assert exits == ['deep', 'right_A', 'right']
        assert parent.name == 'root'
        assert entries == ['left', 'left_B']
Ejemplo n.º 2
0
    def test_branching(self):
        root = MockState(parent=None)

        left = MockState(parent=root)
        left_A = MockState(parent=left)
        left_B = MockState(parent=left)

        middle = MockState(parent=root)
        middle_A = MockState(parent=middle)

        right = MockState(parent=root)
        right_A = MockState(parent=right)
        right_A_1 = MockState(parent=right_A)
        right_A_2 = MockState(parent=right_A)

        assert get_path(root, root) == ([], root, [])
        assert get_path(left, left) == ([], left, [])
        assert get_path(left_A, left_B) == ([left_A], left, [left_B])
        assert get_path(left_B, left_A) == ([left_B], left, [left_A])
        assert get_path(middle, root) == ([middle], root, [])
        assert get_path(root, middle) == ([], root, [middle])
        assert get_path(middle_A, left_A) == ([middle_A, middle],
                                              root, [left, left_A])
        assert get_path(right_A_1, left) == ([right_A_1, right_A, right],
                                             root, [left])
        assert get_path(right_A_2, left_B) == ([right_A_2, right_A, right],
                                               root, [left, left_B])
        assert get_path(left_B, right_A_2) == ([left_B, left], root,
                                               [right, right_A, right_A_2])
        assert get_path(right_A, root) == ([right_A, right], root, [])
        assert get_path(root, right_A) == ([], root, [right, right_A])