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]
