def check(hsm, state_name, Event, foo_before, foo_expected, expected_leaf_state, expected_exits, expected_entries): mock_hsm = MockHSM() mock_hsm.data.foo = foo_before # state set and expected state set are not specified in the parameters list # so we'll build them on the fly - knowing the leaf states, state set is # path from root to that leaf state state_set = set( get_path_from_root( get_state_by_sig((state_name,), hsm.flattened))) expected_state_set = set( get_path_from_root( get_state_by_sig((expected_leaf_state,), hsm.flattened))) exit_actions, entry_actions, new_state_set = get_merged_sequences( state_set, Event(), hsm.trans, hsm.flattened, mock_hsm) exit_action_names = [str(act) for act in exit_actions] entry_action_names = [str(act) for act in entry_actions] assert exit_action_names == expected_exits assert entry_action_names == expected_entries assert new_state_set == expected_state_set # perform actions to update 'foo' value in mock_hsm.data [exit_act(None, mock_hsm) for exit_act in exit_actions] [entry_act(None, mock_hsm) for entry_act in entry_actions] if foo_expected != _: # only if we care about the value of 'foo' assert mock_hsm.data.foo == foo_expected
def test_multiple_nested(self): root = MockState(parent=None) ch_1 = MockState(parent=root) ch_2 = MockState(parent=ch_1) ch_3 = MockState(parent=ch_2) ch_4 = MockState(parent=ch_3) assert get_path_from_root(root) == [root] assert get_path_from_root(ch_1) == [root, ch_1] assert get_path_from_root(ch_2) == [root, ch_1, ch_2] assert get_path_from_root(ch_3) == [root, ch_1, ch_2, ch_3] assert get_path_from_root(ch_4) == [root, ch_1, ch_2, ch_3, ch_4]
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 deep = get_state_by_sig(('deep',), flattened) state_names = [state.name for state in get_path_from_root(deep)] assert state_names == ['root', 'right', 'right_A', 'deep']
def assert_curr_state(hsm, leaf_name): """Check that HSM's state set is same as set of states from root to leaf""" exp_set = set( get_path_from_root( get_state_by_sig((leaf_name,), hsm.flattened))) assert hsm.current_state_set == exp_set
def test_one_nested(self): root = MockState(parent=None) ch_1 = MockState(parent=root) assert get_path_from_root(root) == [root] assert get_path_from_root(ch_1) == [root, ch_1]
def test_single_node(self): root = MockState(parent=None) assert get_path_from_root(root) == [root]
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) middle_B = MockState(parent=middle) middle_C = MockState(parent=middle) right = MockState(parent=root) right_A = MockState(parent=right) right_B = MockState(parent=right) right_A_1 = MockState(parent=right_A) right_A_2 = MockState(parent=right_A) assert get_path_from_root(left) == [root, left] assert get_path_from_root(left_A) == [root, left, left_A] assert get_path_from_root(left_B) == [root, left, left_B] assert get_path_from_root(middle) == [root, middle] assert get_path_from_root(middle_A) == [root, middle, middle_A] assert get_path_from_root(middle_B) == [root, middle, middle_B] assert get_path_from_root(middle_C) == [root, middle, middle_C] assert get_path_from_root(right) == [root, right] assert get_path_from_root(right_A) == [root, right, right_A] assert get_path_from_root(right_B) == [root, right, right_B] assert get_path_from_root(right_A_1) == [root, right, right_A, right_A_1] assert get_path_from_root(right_A_2) == [root, right, right_A, right_A_2]