Beispiel #1
0
    def test_with_different_subclasses(self):
        class SubState(State):
            pass

        s1 = State()
        s2 = SubState()
        assert not s1 == s2

        s1 = SubState()
        s2 = SubState()
        assert s1 == s2

        s1.states = {
            'a': State({
                's': State(),
                's2': State() }),
            'b': State()
        }
        s2.states = {
            'a': State({
                's': SubState(),
                's2': State() }),
            'b': State()
        }
        assert not s1 == s2
        s1.states = {
            'a': State({
                's': SubState(),
                's2': State() }),
            'b': State()
        }
        assert s1 == s2
Beispiel #2
0
 def test_names(self):
     s1 = State()
     s1.name = 'asd'
     s2 = State()
     assert not s1 == s2
     s2.name = 'asd'
     assert s1 == s2
Beispiel #3
0
    def test_children_empty(self):
        s1 = State()
        s2 = State()

        s1.states = []
        assert not s1 == s2  # s2 has {}
        s2.states = []
        assert s1 == s2
Beispiel #4
0
    def test_run(self, state_name, Event, foo_before, foo_expected,
                 exp_responding_state, exp_transition_target):
        mock_hsm = MockHSM()
        mock_hsm.data.foo = foo_before
        state = get_state_by_sig((state_name,), self.hsm.flattened)
        tree = tree_from_state_set(set([state]))

        resps = get_responses(tree, Event(), self.hsm.trans, mock_hsm)

        if exp_responding_state is None:
            assert resps == []
        else:
            assert len(resps) == 1  # no orthogonal regions in this HSM
            resp_subtrees, trans = zip(*resps)
            assert resp_subtrees[0][0].name == exp_responding_state
            tran = trans[0]

            if exp_transition_target is not None:
                assert State.sig_to_name(tran.target) == exp_transition_target
            else:
                assert tran.target is None

            tran.action(None, mock_hsm)  # this call might change 'foo' value
                                         # event is not relevant

        if foo_expected != 'ignored':
            assert mock_hsm.data.foo == foo_expected
Beispiel #5
0
 def test_children_list_nested(self):
     s1 = State()
     s2 = State()
     s1.states = [
         State([State(), State()]),
         State([State(), State()]),
     ]
     s2.states = [
         State([State()]),
         State([State(), State()]),
     ]
     assert not s1 == s2
     s2.states = [
         State([State(), State()]),
         State([State(), State()]),
     ]
     assert s1 == s2
Beispiel #6
0
 def test_children_dict_nested(self):
     s1 = State()
     s2 = State()
     s1.states = {
         'a': State({
             's': State(),
             's2': State() }),
         'b': State()
     }
     assert not s1 == s2
     s2.states = {
         'a': State({
             's': State(),
             's2': State() }),
         'b': State()
     }
     assert s1 == s2
Beispiel #7
0
    def test_children_dict(self):
        s1 = State()
        s2 = State()
        s1.states = {1: 'a', 2: {}}
        s2.states = {1: 'a', 2: {}}
        assert s1 == s2
        s1.states = {1: 'a', 2: {3: {}}}
        assert not s1 == s2

        s1.states = [State(), State()]
        s2.states = [State(), State()]
        assert s1 == s2

        s1.states = { 'a': State(), 'b': State() }
        s2.states = { 'a': State(), 'b': State() }
        assert s1 == s2
Beispiel #8
0
 def test_find_invalid_choice_transitions(self):
     func = find_invalid_choice_transitions
     res = sorted((State.sig_to_name(sig), evt)
                  for sig, evt in func(self.hsm.flattened, self.hsm.trans))
     assert sorted(res) == sorted([
         ('choice_placeholder_1', A),
         ('choice_placeholder_1', B),
         ('choice_placeholder_1', C),
         ('right_A', A),
         ('right_A', C),
         ('choice_test_1', Initial),
         #('right_A', Initial),  # these two are valid Choices, but not
         #('right_B', Initial),  # valid initial transitions
     ])
Beispiel #9
0
 def test_children_list_different_order(self):
     s1 = State()
     s2 = State()
     s1.states = [leaf('1'), leaf('2'), leaf('3')]
     s2.states = [leaf('1'), leaf('2'), leaf('3')]
     assert s1 == s2
     s2.states = [leaf('3'), leaf('1'), leaf('2')]
     assert s1 == s2
     s2.states = [leaf('3'), leaf('999'), leaf('2')]
     assert not s1 == s2
Beispiel #10
0
    def test_choice(self, states, event, exp_resp_states, exp_tran_targets):
        state_set = set([get_state_by_sig((name,), self.hsm.flattened)
                         for name in states])
        tree = tree_from_state_set(state_set)
        resps = get_responses(tree, event, self.hsm.trans, None)
        print resps

        if exp_resp_states or exp_tran_targets:
            resp_subtrees, trans = zip(*resps)
            assert len(resp_subtrees) == len(exp_resp_states)
            resp_names = set([st.name for st, _ in resp_subtrees])
            assert resp_names == set(exp_resp_states)

            assert len(trans) == len(exp_tran_targets)
            target_ids = set([State.sig_to_name(tr.target) for tr in trans])
            assert target_ids == set(exp_tran_targets)
        else:
            assert resps == []
Beispiel #11
0
 def test_children_list_different_order_nested(self):
     s1 = State()
     s2 = State()
     s1.states = [
         composite('A', [leaf('1'), leaf('2')]),
         composite('B', [leaf('3'), leaf('4')]),
     ]
     s2.states = [
         composite('A', [leaf('2'), leaf('1')]),
         composite('B', [leaf('4'), leaf('3')]),
     ]
     assert s1 == s2
     s2.states = [
         composite('B', [leaf('4'), leaf('3')]),
         composite('A', [leaf('2'), leaf('1')]),
     ]
     assert s1 == s2
     s2.states = [
         composite('B', [leaf('4'), leaf('3')]),
         composite('A', [leaf('999'), leaf('1')]),
     ]
     assert not s1 == s2
Beispiel #12
0
 def test_sig_to_name(self, sig, name):
     assert State.sig_to_name(sig) == name
Beispiel #13
0
    def test_all_attribs(self):
        par1 = State()
        par1.name = 'parent'
        par2 = State()
        par2.name = 'parent'
        assert par1 == par2

        # lambdas must be same instance
        action = lambda a, b: a + b

        s1 = State()
        s1.name = 'name'
        s1.parent = par1
        s1.kind = 'leaf'
        s1.on_enter = action
        s1.on_exit = action

        s2 = State()
        assert not s1 == s2
        s2.name = 'name'
        assert not s1 == s2
        s2.parent = par1
        assert not s1 == s2
        s2.kind = 'leaf'
        assert not s1 == s2
        s2.on_enter = action
        assert not s1 == s2
        s2.on_exit = action
        assert s1 == s2  # now it's same
Beispiel #14
0

def clear_marquee_rect(evt, hsm):
    _, _, rect_id = hsm.data.canvas_marquee
    canvas.delete(rect_id)


# define HSM state structure and transitions between states:

states = {
    'app': State({
        'select_tool_chosen': State({
            'select_tool_hovering': State(),
            'dragging_marquee': State(on_enter=create_marquee_rect,
                                      on_exit=clear_marquee_rect),
            'moving_elements': State(on_enter=select_under_cursor),
        }),
        'draw_tool_chosen': State({
            'draw_tool_hovering': State(),
            'drawing': State(),
        })
    })
}

transitions = {
    'app': {
        Initial: T('draw_tool_chosen'),
        Tool_Changed: Choice({
            Selection_tool: 'select_tool_chosen',
            Drawing_tool: 'draw_tool_chosen' },
            default='select_tool_chosen',
            action=update_chosen_tool)
Beispiel #15
0
 def test_name_to_sig(self, sig, name):
     assert State.name_to_sig(name) == sig
Beispiel #16
0
 def test_name_to_sig_malformed(self, name):
     with pytest.raises(ValueError):
         res = State.name_to_sig(name)
         print res
Beispiel #17
0
def get_state(kind, name, states):
    st = State(states)
    st.name = name
    st.kind = kind
    return st