def _new_stm(reset_mocks=True):
'''Make a new STM object with pre-filled states.'''
coqtop = Mock()
view = Mock()
coqtop.get_response.side_effect = [('value', ({
'init_state_id':
StateID(1)
}, None)),
('value', ({
'state_id': StateID(2),
'closed_proof': None
}, None)),
('value', ({
'state_id': StateID(3),
'closed_proof': None
}, None)),
('value', ({
'goals': None
}, None))]
stm = STM(coqtop, view, None)
stm.init()
stm.add([
Sentence('Theorem a:\n1 = 1.\n', Mark(1, 1), Mark(3, 1)),
Sentence('Proof.\n', Mark(3, 1), Mark(4, 1))
])
if reset_mocks:
coqtop.reset_mock(return_value=True, side_effect=True)
view.reset_mock(return_value=True, side_effect=True)
return stm, coqtop, view
def test_add_sentences(self):
'''Test method `add` on adding a list of sentences.'''
stm, coqtop, view = self._new_stm(reset_mocks=False)
self.assertEqual(stm.get_tip_stop(), Mark(4, 1))
self.assertListEqual(coqtop.call.call_args_list, [
call('init', {}),
call(
'add', {
'command': 'Theorem a:\n1 = 1.\n',
'edit_id': -1,
'state_id': StateID(1),
'verbose': True
}),
call(
'add', {
'command': 'Proof.\n',
'edit_id': -1,
'state_id': StateID(2),
'verbose': True
}),
call('goal', {})
])
self.assertListEqual(view.new_match.call_args_list, [
call((StateID(2), 1), Mark(1, 1), Mark(3, 1), 'sent'),
call((StateID(3), 1), Mark(3, 1), Mark(4, 1), 'sent')
])
def _test_set_flag_simple(self, flag):
'''Test setting the flag to `flag` without `loc`.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
state.set_flag(flag)
view_mock.new_match.assert_called_once_with(
(StateID(3), 1), Mark(1, 1), Mark(2, 8), flag)
def test_add_inactive(self):
'''Test method `add` when the view is inactive.'''
vim = Mock()
vim.in_winid = MagicMock()
view = _MatchView(vim)
view.add(42, Mark(1, 1), Mark(2, 4), 'sent')
view.add(43, Mark(2, 4), Mark(2, 7), 'verified')
view.draw()
vim.add_match.assert_not_called()
vim.in_winid.assert_not_called()
def test_insert_middle(self):
'''Test inserting in the middle.'''
slist = _StateList()
sta1 = _State.initial(StateID(1))
slist.init(sta1)
sta2 = _State(StateID(2), Sentence('', Mark(1, 1), Mark(2, 3)), None)
slist.insert(sta1, sta2)
sta3 = _State(StateID(3), Sentence('', Mark(2, 3), Mark(2, 10)), None)
slist.insert(sta1, sta3)
self.assertEqual(list(slist.iter_after(sta1)), [sta3, sta2])
def test_set_flag_twice(self):
'''Test setting the flag when there is another flag.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
state.set_flag('sent')
view_mock.new_match.assert_called_once_with(
(StateID(3), 1), Mark(1, 1), Mark(2, 8), 'sent')
state.set_flag('verified')
view_mock.remove_match.assert_called_once_with((StateID(3), 1))
view_mock.new_match.assert_called_with((StateID(3), 2), Mark(1, 1),
Mark(2, 8), 'verified')
def test_redraw_shown(self):
'''Test method `redraw` when the match is shown.'''
vim = Mock()
arg = _MatchArg(Mark(1, 3), Mark(5, 9), 'sent')
match = _Match(arg, vim)
vim.add_match.side_effect = [12, 13]
match.show(3)
match.redraw(3)
vim.del_match.assert_called_once_with(12)
vim.add_match.assert_called_with(Mark(1, 3), Mark(5, 9), 'CoqStcSent')
def test_remove_after(self):
'''Test method `remove_after`.'''
slist = _StateList()
sta1 = _State.initial(StateID(1))
slist.init(sta1)
sta2 = _State(StateID(2), Sentence('', Mark(1, 1), Mark(2, 3)), None)
slist.insert(sta1, sta2)
sta3 = _State(StateID(3), Sentence('', Mark(2, 3), Mark(2, 10)), None)
slist.insert(sta2, sta3)
slist.remove_after(sta1)
self.assertEqual(list(slist.iter_after(sta1)), [])
def test_show_hide(self):
'''Test method `show`.'''
vim = Mock()
arg = _MatchArg(Mark(1, 3), Mark(5, 9), 'sent')
match = _Match(arg, vim)
vim.add_match.side_effect = [12]
match.show(3)
vim.add_match.assert_called_once_with(Mark(1, 3), Mark(5, 9),
'CoqStcSent')
match.hide(3)
vim.del_match.assert_called_once_with(12)
def test_offset_to_mark(self):
'''Test the function transforming offsets in the sentence to marks.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
mark = state.offset_to_mark(3)
self.assertEqual(mark, Mark(1, 4))
mark = state.offset_to_mark(12)
self.assertEqual(mark, Mark(2, 2))
mark = state.offset_to_mark(18)
self.assertEqual(mark, Mark(2, 8))
def test_to_cursor_backward(self, STM, _):
'''Test method `to_cursor` on going backward.'''
stm = STM.return_value
view = Mock()
vim = Mock()
worker = self._worker_mock()
session = Session(view, vim, worker)
stm.get_tip_stop.side_effect = [Mark(4, 9)]
stm.get_end_stop.side_effect = [Mark(4, 9)]
vim.get_cursor.side_effect = [Mark(2, 3)]
session.to_cursor()
stm.edit_at.assert_called_once_with(Mark(2, 3))
class TestState(TestCase):
'''Test class `coqide.stm._State`.'''
_SENTENCE_EX = Sentence('Theorem a:\n 1 = 1.', Mark(1, 1), Mark(2, 8))
def _test_set_flag_simple(self, flag):
'''Test setting the flag to `flag` without `loc`.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
state.set_flag(flag)
view_mock.new_match.assert_called_once_with(
(StateID(3), 1), Mark(1, 1), Mark(2, 8), flag)
def test_set_sent_flag(self):
'''Test setting the flag to "sent".'''
self._test_set_flag_simple('sent')
def test_set_axiom_flag(self):
'''Test setting the flag to "axiom".'''
self._test_set_flag_simple('axiom')
def test_set_verified_flag(self):
'''Test setting the flag to "verified".'''
self._test_set_flag_simple('verified')
def test_set_flag_twice(self):
'''Test setting the flag when there is another flag.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
state.set_flag('sent')
view_mock.new_match.assert_called_once_with(
(StateID(3), 1), Mark(1, 1), Mark(2, 8), 'sent')
state.set_flag('verified')
view_mock.remove_match.assert_called_once_with((StateID(3), 1))
view_mock.new_match.assert_called_with((StateID(3), 2), Mark(1, 1),
Mark(2, 8), 'verified')
def test_offset_to_mark(self):
'''Test the function transforming offsets in the sentence to marks.'''
view_mock = Mock()
state = _State(StateID(3), self._SENTENCE_EX, view_mock)
mark = state.offset_to_mark(3)
self.assertEqual(mark, Mark(1, 4))
mark = state.offset_to_mark(12)
self.assertEqual(mark, Mark(2, 2))
mark = state.offset_to_mark(18)
self.assertEqual(mark, Mark(2, 8))
def test_add_match(self):
'''Test method `add_match`.'''
def _eval(cmd):
if cmd == 'matchaddpos("CoqStcSent", [[1, 5, 3], 2, [3, 1, 2]])':
return 1
return None
api = Mock()
api.eval.side_effect = _eval
api.current.buffer = [
'aaaa333',
'32414',
'33aaa']
vim = VimSupport(api)
self.assertEqual(vim.add_match(Mark(1, 5), Mark(3, 3), 'CoqStcSent'),
[1])
def test_forward_one(self, STM, _):
'''Test method `forward_one`.'''
stm = STM.return_value
view = Mock()
vim = Mock()
worker = self._worker_mock()
session = Session(view, vim, worker)
sentence = Sentence('Proof.\n', Mark(1, 1), Mark(2, 1))
stm.get_tip_stop.side_effect = [Mark(1, 1)]
vim.get_sentence_after.side_effect = [sentence]
session.forward_one()
stm.add.assert_called_once_with([sentence])
def test_process_verified(self):
'''Test method `process_feedback` on feedback "processed".'''
stm, _, view = self._new_stm()
match2_new = Mock()
view.new_match.side_effect = [match2_new]
stm.process_feedback({
'type': 'processed',
'state_id': StateID(2),
'content': {}
})
view.remove_match.assert_called_once_with((StateID(2), 1))
view.new_match.assert_called_once_with((StateID(2), 2), Mark(1, 1),
Mark(3, 1), 'verified')
def test_get_cursor(self):
'''Test method `get_cursor`.'''
api = Mock()
api.eval.side_effect = \
lambda x: [None, 3, 6, None] if x == 'getpos(".")' else None
vim = VimSupport(api)
self.assertEqual(vim.get_cursor(), Mark(3, 6))
def test_set_inactive(self):
'''Test method `set_inactive` with matches.'''
vim = Mock()
vim.in_winid = MagicMock()
vim.add_match.side_effect = ['x', 'y']
view = _MatchView(vim)
view.set_active(3)
view.add(42, Mark(1, 1), Mark(2, 4), 'sent')
view.add(43, Mark(2, 4), Mark(2, 7), 'verified')
view.draw()
vim.reset_mock()
view.set_inactive(3)
vim.in_winid.assert_called_once_with(3)
self.assertListEqual(vim.del_match.call_args_list,
[call('x'), call('y')])
def test_init(self):
'''Test method `init`.'''
slist = _StateList()
inits = _State.initial(StateID(1))
slist.init(inits)
self.assertEqual(slist.find_by_id(StateID(1)), inits)
self.assertEqual(slist.find_by_mark(Mark(1, 1)), inits)
self.assertEqual(list(slist.iter_after(inits)), [])
def test_edit_at(self):
'''Test method `edit_at` on editing at a specific mark.'''
stm, coqtop, view = self._new_stm(reset_mocks=False)
coqtop.reset_mock(side_effect=True)
coqtop.get_response.side_effect = [('value', ({
'focused_proof': None
}, None)), ('value', ({
'goals': None
}, None))]
stm.edit_at(Mark(3, 3))
self.assertEqual(stm.get_tip_stop(), Mark(3, 1))
self.assertListEqual(
coqtop.call.call_args_list,
[call('edit_at', {'state_id': StateID(2)}),
call('goal', {})])
view.remove_match.assert_called_once_with((StateID(3), 1))
def test_init(self):
'''Test method `init`.'''
coqtop = Mock()
view = Mock()
coqtop.get_response.side_effect = [('value', ({
'init_state_id':
StateID(3)
}, None))]
stm = STM(coqtop, view, None)
stm.init()
coqtop.call.assert_called_once_with('init', {})
self.assertEqual(stm.get_tip_stop(), Mark(1, 1))
def test_add_active(self):
'''Test method `add` when the view is active.'''
vim = Mock()
vim.in_winid = MagicMock()
view = _MatchView(vim)
view.set_active(3)
view.add(42, Mark(1, 1), Mark(2, 4), 'sent')
view.add(43, Mark(2, 4), Mark(2, 7), 'verified')
view.draw()
self.assertListEqual(vim.add_match.call_args_list, [
call(Mark(1, 1), Mark(2, 4), 'CoqStcSent'),
call(Mark(2, 4), Mark(2, 7), 'CoqStcVerified'),
])
vim.in_winid.assert_called_with(3)
def test_to_cursor_forward(self, STM, _):
'''Test method `to_cursor` on going forward.'''
stm = STM.return_value
view = Mock()
vim = Mock()
worker = self._worker_mock()
session = Session(view, vim, worker)
sentences = [
Sentence('', Mark(2, 3), Mark(3, 5)),
Sentence('', Mark(3, 5), Mark(4, 1)),
Sentence('', Mark(4, 1), Mark(4, 9)), None
]
stm.get_tip_stop.side_effect = [Mark(2, 3)]
stm.get_end_stop.side_effect = [Mark(2, 3)]
vim.get_cursor.side_effect = [Mark(4, 9)]
vim.get_sentence_after.side_effect = sentences
session.to_cursor()
stm.add.assert_called_once_with(sentences[:-1])
def test_find_by_mark(self):
'''Test method `find_by_mark`.'''
slist = _StateList()
sta1 = _State.initial(StateID(1))
slist.init(sta1)
sta2 = _State(StateID(2), Sentence('', Mark(1, 1), Mark(2, 3)), None)
slist.insert(sta1, sta2)
sta3 = _State(StateID(3), Sentence('', Mark(2, 3), Mark(2, 10)), None)
slist.insert(sta2, sta3)
self.assertEqual(slist.find_by_mark(Mark(2, 4)), sta2)
self.assertEqual(slist.find_by_mark(Mark(3, 1)), sta3)
def test_get_sentence_after(self):
'''Test method `get_sentence_after`.'''
api = Mock()
api.current.buffer = [
'Proof. simpl.',
' reflexivity.',
'Qed.']
vim = VimSupport(api)
sentence = vim.get_sentence_after(Mark(1, 1))
self.assertEqual(sentence,
Sentence('Proof.', Mark(1, 1), Mark(1, 7)))
sentence = vim.get_sentence_after(Mark(1, 7))
self.assertEqual(sentence,
Sentence(' simpl.', Mark(1, 7), Mark(1, 14)))
sentence = vim.get_sentence_after(Mark(1, 14))
self.assertEqual(sentence,
Sentence('\n reflexivity.', Mark(1, 14), Mark(2, 15)))
sentence = vim.get_sentence_after(Mark(2, 15))
self.assertEqual(sentence,
Sentence('\nQed.', Mark(2, 15), Mark(3, 5)))