def test_dictionary_collection(self):
dc = StenoDictionaryCollection()
d1 = StenoDictionary()
d1[('S', )] = 'a'
d1[('T', )] = 'b'
d2 = StenoDictionary()
d2[('S', )] = 'c'
d2[('W', )] = 'd'
dc.set_dicts([d1, d2])
self.assertEqual(dc.lookup(('S', )), 'c')
self.assertEqual(dc.lookup(('W', )), 'd')
self.assertEqual(dc.lookup(('T', )), 'b')
f = lambda k, v: v == 'c'
dc.add_filter(f)
self.assertIsNone(dc.lookup(('S', )))
self.assertEqual(dc.raw_lookup(('S', )), 'c')
self.assertEqual(dc.lookup(('W', )), 'd')
self.assertEqual(dc.lookup(('T', )), 'b')
self.assertEqual(dc.reverse_lookup('c'), [('S', )])
dc.remove_filter(f)
self.assertEqual(dc.lookup(('S', )), 'c')
self.assertEqual(dc.lookup(('W', )), 'd')
self.assertEqual(dc.lookup(('T', )), 'b')
self.assertEqual(dc.reverse_lookup('c'), [('S', )])
dc.set(('S', ), 'e')
self.assertEqual(dc.lookup(('S', )), 'e')
self.assertEqual(d2[('S', )], 'e')
def test_dictionary_collection(self):
dc = StenoDictionaryCollection()
d1 = StenoDictionary()
d1[('S',)] = 'a'
d1[('T',)] = 'b'
d2 = StenoDictionary()
d2[('S',)] = 'c'
d2[('W',)] = 'd'
dc.set_dicts([d1, d2])
self.assertEqual(dc.lookup(('S',)), 'c')
self.assertEqual(dc.lookup(('W',)), 'd')
self.assertEqual(dc.lookup(('T',)), 'b')
f = lambda k, v: v == 'c'
dc.add_filter(f)
self.assertIsNone(dc.lookup(('S',)))
self.assertEqual(dc.raw_lookup(('S',)), 'c')
self.assertEqual(dc.lookup(('W',)), 'd')
self.assertEqual(dc.lookup(('T',)), 'b')
self.assertEqual(dc.reverse_lookup('c'), [('S',)])
dc.remove_filter(f)
self.assertEqual(dc.lookup(('S',)), 'c')
self.assertEqual(dc.lookup(('W',)), 'd')
self.assertEqual(dc.lookup(('T',)), 'b')
self.assertEqual(dc.reverse_lookup('c'), [('S',)])
dc.set(('S',), 'e')
self.assertEqual(dc.lookup(('S',)), 'e')
self.assertEqual(d2[('S',)], 'e')
class TranslatorStateSizeTestCase(unittest.TestCase):
class FakeState(_State):
def __init__(self):
_State.__init__(self)
self.restrict_calls = []
def restrict_size(self, n):
self.restrict_calls.append(n)
def assert_size_call(self, size):
self.assertEqual(self.s.restrict_calls[-1], size)
def assert_no_size_call(self):
self.assertEqual(self.s.restrict_calls, [])
def clear(self):
self.s.restrict_calls = []
def setUp(self):
self.t = Translator()
self.s = type(self).FakeState()
self.t._state = self.s
self.d = StenoDictionary()
self.dc = StenoDictionaryCollection()
self.dc.set_dicts([self.d])
self.t.set_dictionary(self.dc)
def test_dictionary_update_grows_size1(self):
self.d[('S', )] = '1'
self.assert_size_call(1)
def test_dictionary_update_grows_size4(self):
self.d[('S', 'PT', '-Z', 'TOP')] = 'hi'
self.assert_size_call(4)
def test_dictionary_update_no_grow(self):
self.t.set_min_undo_length(4)
self.assert_size_call(4)
self.clear()
self.d[('S', 'T')] = 'nothing'
self.assert_size_call(4)
def test_dictionary_update_shrink(self):
self.d[('S', 'T', 'P', '-Z', '-D')] = '1'
self.assert_size_call(5)
self.clear()
self.d[('A', 'P')] = '2'
self.assert_no_size_call()
del self.d[('S', 'T', 'P', '-Z', '-D')]
self.assert_size_call(2)
def test_dictionary_update_no_shrink(self):
self.t.set_min_undo_length(7)
self.d[('S', 'T', 'P', '-Z', '-D')] = '1'
del self.d[('S', 'T', 'P', '-Z', '-D')]
self.assert_size_call(7)
def test_translation_calls_restrict(self):
self.t.translate(stroke('S'))
self.assert_size_call(0)
class TranslatorStateSizeTestCase(unittest.TestCase):
class FakeState(_State):
def __init__(self):
_State.__init__(self)
self.restrict_calls = []
def restrict_size(self, n):
self.restrict_calls.append(n)
def assert_size_call(self, size):
self.assertEqual(self.s.restrict_calls[-1], size)
def assert_no_size_call(self):
self.assertEqual(self.s.restrict_calls, [])
def clear(self):
self.s.restrict_calls = []
def setUp(self):
self.t = Translator()
self.s = type(self).FakeState()
self.t._state = self.s
self.d = StenoDictionary()
self.dc = StenoDictionaryCollection()
self.dc.set_dicts([self.d])
self.t.set_dictionary(self.dc)
def test_dictionary_update_grows_size1(self):
self.d[('S',)] = '1'
self.assert_size_call(1)
def test_dictionary_update_grows_size4(self):
self.d[('S', 'PT', '-Z', 'TOP')] = 'hi'
self.assert_size_call(4)
def test_dictionary_update_no_grow(self):
self.t.set_min_undo_length(4)
self.assert_size_call(4)
self.clear()
self.d[('S', 'T')] = 'nothing'
self.assert_size_call(4)
def test_dictionary_update_shrink(self):
self.d[('S', 'T', 'P', '-Z', '-D')] = '1'
self.assert_size_call(5)
self.clear()
self.d[('A', 'P')] = '2'
self.assert_no_size_call()
del self.d[('S', 'T', 'P', '-Z', '-D')]
self.assert_size_call(2)
def test_dictionary_update_no_shrink(self):
self.t.set_min_undo_length(7)
self.d[('S', 'T', 'P', '-Z', '-D')] = '1'
del self.d[('S', 'T', 'P', '-Z', '-D')]
self.assert_size_call(7)
def test_translation_calls_restrict(self):
self.t.translate(stroke('S'))
self.assert_size_call(0)
def test_changing_state(self):
output = []
def listener(undo, do, prev):
output.append((undo, do, prev))
d = StenoDictionary()
d[('S', 'P')] = 'hi'
dc = StenoDictionaryCollection()
dc.set_dicts([d])
t = Translator()
t.set_dictionary(dc)
t.translate(stroke('T'))
t.translate(stroke('S'))
s = copy.deepcopy(t.get_state())
t.add_listener(listener)
expected = [([Translation([stroke('S')], None)],
[Translation([stroke('S'), stroke('P')],
'hi')], Translation([stroke('T')], None))]
t.translate(stroke('P'))
self.assertEqual(output, expected)
del output[:]
t.set_state(s)
t.translate(stroke('P'))
self.assertEqual(output, expected)
del output[:]
t.clear_state()
t.translate(stroke('P'))
self.assertEqual(output,
[([], [Translation([stroke('P')], None)], None)])
del output[:]
t.set_state(s)
t.translate(stroke('P'))
self.assertEqual(output,
[([], [Translation([stroke('P')], None)],
Translation([stroke('S'), stroke('P')], 'hi'))])
def test_changing_state(self):
output = []
def listener(undo, do, prev):
output.append((undo, do, prev))
d = StenoDictionary()
d[('S', 'P')] = 'hi'
dc = StenoDictionaryCollection()
dc.set_dicts([d])
t = Translator()
t.set_dictionary(dc)
t.translate(stroke('T'))
t.translate(stroke('S'))
s = copy.deepcopy(t.get_state())
t.add_listener(listener)
expected = [([Translation([stroke('S')], None)],
[Translation([stroke('S'), stroke('P')], 'hi')],
Translation([stroke('T')], None))]
t.translate(stroke('P'))
self.assertEqual(output, expected)
del output[:]
t.set_state(s)
t.translate(stroke('P'))
self.assertEqual(output, expected)
del output[:]
t.clear_state()
t.translate(stroke('P'))
self.assertEqual(output, [([], [Translation([stroke('P')], None)], None)])
del output[:]
t.set_state(s)
t.translate(stroke('P'))
self.assertEqual(output,
[([],
[Translation([stroke('P')], None)],
Translation([stroke('S'), stroke('P')], 'hi'))])
class TranslateStrokeTestCase(unittest.TestCase):
class CaptureOutput(object):
output = namedtuple('output', 'undo do prev')
def __init__(self):
self.output = []
def __call__(self, undo, new, prev):
self.output = type(self).output(undo, new, prev)
def t(self, strokes):
"""A quick way to make a translation."""
strokes = [stroke(x) for x in strokes.split('/')]
return Translation(strokes, _lookup(strokes, self.dc, []))
def lt(self, translations):
"""A quick way to make a list of translations."""
return [self.t(x) for x in translations.split()]
def define(self, key, value):
key = normalize_steno(key)
self.d[key] = value
def translate(self, stroke):
_translate_stroke(stroke, self.s, self.dc, self.o)
def assertTranslations(self, expected):
self.assertEqual(self.s.translations, expected)
def assertOutput(self, undo, do, prev):
self.assertEqual(self.o.output, (undo, do, prev))
def setUp(self):
self.d = StenoDictionary()
self.dc = StenoDictionaryCollection()
self.dc.set_dicts([self.d])
self.s = _State()
self.o = type(self).CaptureOutput()
def test_first_stroke(self):
self.translate(stroke('-B'))
self.assertTranslations(self.lt('-B'))
self.assertOutput([], self.lt('-B'), None)
def test_second_stroke(self):
self.define('S/P', 'spiders')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
def test_second_stroke_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('-E'))
self.assertTranslations(self.lt('E'))
self.assertOutput([], self.lt('E'), self.t('T/A/I/L'))
def test_with_translation(self):
self.define('S', 'is')
self.define('-T', 'that')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
self.assertEqual(self.o.output.do[0].english, 'that')
def test_finish_two_translation(self):
self.define('S/T', 'hello')
self.s.translations = self.lt('S')
self.translate(stroke('T'))
self.assertTranslations(self.lt('S/T'))
self.assertOutput(self.lt('S'), self.lt('S/T'), None)
self.assertEqual(self.o.output.do[0].english, 'hello')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S'))
def test_finish_three_translation(self):
self.define('S/T/-B', 'bye')
self.s.translations = self.lt('S T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'bye')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S T'))
def test_replace_translation(self):
self.define('S/T/-B', 'longer')
self.s.translations = self.lt('S/T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S/T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'longer')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S/T'))
def test_undo(self):
self.s.translations = self.lt('POP')
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput(self.lt('POP'), [], None)
def test_empty_undo(self):
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput([], [], None)
def test_undo_translation(self):
self.define('P/P', 'pop')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P'))
self.assertOutput(self.lt('P/P'), self.lt('P'), None)
def test_undo_longer_translation(self):
self.define('P/P/-D', 'popped')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('-D'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P P'))
self.assertOutput(self.lt('P/P/-D'), self.lt('P P'), None)
def test_undo_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput([], [], self.t('T/A/I/L'))
def test_suffix_folding(self):
self.define('K-L', 'look')
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
lt[0].english = 'look {^ing}'
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_multi_stroke(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he will {^s}')
def test_suffix_folding_doesnt_interfere(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.define('E', 'he')
self.define('HR-S', 'also')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he also')
def test_suffix_folding_no_suffix(self):
self.define('K-L', 'look')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_no_main(self):
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_translator(self):
# It's not clear that this test is needed anymore. There are separate
# tests for _translate_stroke and test_translate_calls_translate_stroke
# makes sure that translate calls it properly. But since I already wrote
# this test I'm going to keep it.
class Output(object):
def __init__(self):
self._output = []
def write(self, undo, do, prev):
for t in undo:
self._output.pop()
for t in do:
if t.english:
self._output.append(t.english)
else:
self._output.append('/'.join(t.rtfcre))
def get(self):
return ' '.join(self._output)
def clear(self):
del self._output[:]
d = StenoDictionary()
out = Output()
t = Translator()
dc = StenoDictionaryCollection()
dc.set_dicts([d])
t.set_dictionary(dc)
t.add_listener(out.write)
t.translate(stroke('S'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('T'))
self.assertEqual(out.get(), 'S T')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S') # Undo buffer ran out.
t.set_min_undo_length(3)
out.clear()
t.translate(stroke('S'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('T'))
self.assertEqual(out.get(), 'S T')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('*'))
self.assertEqual(out.get(), '')
t.translate(stroke('*'))
self.assertEqual(out.get(), '') # Undo buffer ran out.
out.clear()
d[('S',)] = 't1'
d[('T',)] = 't2'
d[('S', 'T')] = 't3'
t.translate(stroke('S'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't3 t2 t1')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('*'))
self.assertEqual(out.get(), '')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3 t2')
d[('S', 'T', 'T')] = 't4'
d[('S', 'T', 'T', 'S')] = 't5'
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't4')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5 t1')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't4')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('*'))
self.assertEqual(out.get(), '')
d.clear()
s = stroke('S')
t.translate(s)
t.translate(s)
t.translate(s)
t.translate(s)
s = stroke('*')
t.translate(s)
t.translate(s)
t.translate(s)
t.translate(s)
self.assertEqual(out.get(), 'S') # Not enough undo to clear output.
out.clear()
t.remove_listener(out.write)
t.translate(stroke('S'))
self.assertEqual(out.get(), '')
class TranslateStrokeTestCase(unittest.TestCase):
class CaptureOutput(object):
output = namedtuple('output', 'undo do prev')
def __init__(self):
self.output = []
def __call__(self, undo, new, prev):
self.output = type(self).output(undo, new, prev)
def t(self, strokes):
"""A quick way to make a translation."""
strokes = [stroke(x) for x in strokes.split('/')]
return Translation(strokes, _lookup(strokes, self.dc, []))
def lt(self, translations):
"""A quick way to make a list of translations."""
return [self.t(x) for x in translations.split()]
def define(self, key, value):
key = normalize_steno(key)
self.d[key] = value
def translate(self, stroke):
_translate_stroke(stroke, self.s, self.dc, self.o)
def assertTranslations(self, expected):
self.assertEqual(self.s.translations, expected)
def assertOutput(self, undo, do, prev):
self.assertEqual(self.o.output, (undo, do, prev))
def setUp(self):
self.d = StenoDictionary()
self.dc = StenoDictionaryCollection()
self.dc.set_dicts([self.d])
self.s = _State()
self.o = type(self).CaptureOutput()
def test_first_stroke(self):
self.translate(stroke('-B'))
self.assertTranslations(self.lt('-B'))
self.assertOutput([], self.lt('-B'), None)
def test_second_stroke(self):
self.define('S/P', 'spiders')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
def test_second_stroke_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('-E'))
self.assertTranslations(self.lt('E'))
self.assertOutput([], self.lt('E'), self.t('T/A/I/L'))
def test_with_translation(self):
self.define('S', 'is')
self.define('-T', 'that')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
self.assertEqual(self.o.output.do[0].english, 'that')
def test_finish_two_translation(self):
self.define('S/T', 'hello')
self.s.translations = self.lt('S')
self.translate(stroke('T'))
self.assertTranslations(self.lt('S/T'))
self.assertOutput(self.lt('S'), self.lt('S/T'), None)
self.assertEqual(self.o.output.do[0].english, 'hello')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S'))
def test_finish_three_translation(self):
self.define('S/T/-B', 'bye')
self.s.translations = self.lt('S T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'bye')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S T'))
def test_replace_translation(self):
self.define('S/T/-B', 'longer')
self.s.translations = self.lt('S/T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S/T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'longer')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S/T'))
def test_undo(self):
self.s.translations = self.lt('POP')
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput(self.lt('POP'), [], None)
def test_empty_undo(self):
self.translate(stroke('*'))
self.assertEquals(self.s.translations[0].english, _back_string())
self.assertOutput([], [Translation([Stroke('*')], _back_string())], None)
def test_undo_translation(self):
self.define('P/P', 'pop')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P'))
self.assertOutput(self.lt('P/P'), self.lt('P'), None)
def test_undo_longer_translation(self):
self.define('P/P/-D', 'popped')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('-D'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P P'))
self.assertOutput(self.lt('P/P/-D'), self.lt('P P'), None)
def test_undo_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('*'))
self.assertEquals(self.s.translations[0].english, _back_string())
self.assertOutput([], [Translation([Stroke('*')], _back_string())], self.t('T/A/I/L'))
def test_suffix_folding(self):
self.define('K-L', 'look')
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
lt[0].english = 'look {^ing}'
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_multi_stroke(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he will {^s}')
def test_suffix_folding_doesnt_interfere(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.define('E', 'he')
self.define('HR-S', 'also')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he also')
def test_suffix_folding_no_suffix(self):
self.define('K-L', 'look')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_no_main(self):
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_retrospective_insert_space(self):
self.define('T/E/S/T', 'a longer key')
self.define('PER', 'perfect')
self.define('SWAEUGS', 'situation')
self.define('PER/SWAEUGS', 'persuasion')
self.define('SP*', '{*?}')
self.translate(stroke('PER'))
self.translate(stroke('SWAEUGS'))
self.translate(stroke('SP*'))
lt = self.lt('PER')
undo = self.lt('PER/SWAEUGS')
undo[0].replaced = lt
do = self.lt('SP*')
do[0].english = 'perfect situation'
do[0].is_retrospective_command = True
do[0].replaced = undo
self.assertTranslations(do)
self.assertOutput(undo, do, None)
def test_retrospective_delete_space(self):
self.define('T/E/S/T', 'a longer key')
self.define('K', 'kick')
self.define('B', 'back')
self.define('SP*', '{*!}')
self.translate(stroke('K'))
self.translate(stroke('B'))
self.translate(stroke('SP*'))
undo = self.lt('K B')
do = self.lt('SP*')
do[0].english = 'kickback'
do[0].is_retrospective_command = True
do[0].replaced = undo
self.assertTranslations(do)
self.assertOutput(undo, do, None)
def test_retrospective_toggle_asterisk(self):
self.define('T/E/S/T', 'a longer key')
self.define('S', 'see')
self.define('S*', 'sea')
self.define('A*', '{*}')
self.translate(stroke('S'))
self.translate(stroke('A*'))
undo = self.lt('S')
do = self.lt('S*')
self.assertTranslations(do)
self.assertOutput(undo, do, None)
def test_repeat_last_stroke1(self):
self.define('T/E/S/T', 'a longer key')
self.define('TH', 'this')
self.define('R*', '{*+}')
self.translate(stroke('TH'))
self.translate(stroke('R*'))
undo = []
do = self.lt('TH')
state = self.lt('TH TH')
self.assertTranslations(state)
self.assertOutput(undo, do, do[0])
def test_repeat_last_stroke2(self):
self.define('T/E/S/T', 'a longer key')
self.define('THA', 'that')
self.define('R*', '{*+}')
self.translate(stroke('THA'))
self.translate(stroke('R*'))
undo = []
do = self.lt('THA')
state = self.lt('THA THA')
self.assertTranslations(state)
self.assertOutput(undo, do, do[0])
def test_translator(self):
# It's not clear that this test is needed anymore. There are separate
# tests for _translate_stroke and test_translate_calls_translate_stroke
# makes sure that translate calls it properly. But since I already wrote
# this test I'm going to keep it.
class Output(object):
def __init__(self):
self._output = []
def write(self, undo, do, prev):
for t in undo:
self._output.pop()
for t in do:
if t.english:
self._output.append(t.english)
else:
self._output.append('/'.join(t.rtfcre))
def get(self):
return ' '.join(self._output)
def clear(self):
del self._output[:]
d = StenoDictionary()
out = Output()
t = Translator()
dc = StenoDictionaryCollection()
dc.set_dicts([d])
t.set_dictionary(dc)
t.add_listener(out.write)
t.translate(stroke('S'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('T'))
self.assertEqual(out.get(), 'S T')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S ' + _back_string()) # Undo buffer ran out.
t.set_min_undo_length(3)
out.clear()
t.translate(stroke('S'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('T'))
self.assertEqual(out.get(), 'S T')
t.translate(stroke('*'))
self.assertEqual(out.get(), 'S')
t.translate(stroke('*'))
self.assertEqual(out.get(), '' )
out.clear()
d[('S',)] = 't1'
d[('T',)] = 't2'
d[('S', 'T')] = 't3'
t.translate(stroke('S'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't3 t2 t1')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('*'))
self.assertEqual(out.get(), '')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't3 t2')
d[('S', 'T', 'T')] = 't4'
d[('S', 'T', 'T', 'S')] = 't5'
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3 t2')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('T'))
self.assertEqual(out.get(), 't4')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('S'))
self.assertEqual(out.get(), 't5 t1')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't5')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't4')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't3')
t.translate(stroke('*'))
self.assertEqual(out.get(), 't1')
t.translate(stroke('*'))
self.assertEqual(out.get(), '')
d.clear()
s = stroke('S')
t.translate(s)
t.translate(s)
t.translate(s)
t.translate(s)
s = stroke('*')
t.translate(s)
t.translate(s)
t.translate(s)
t.translate(s)
self.assertEqual(out.get(), 'S ' + _back_string()) # Not enough undo to clear output.
out.clear()
t.remove_listener(out.write)
t.translate(stroke('S'))
self.assertEqual(out.get(), '')
class TranslateStrokeTestCase(unittest.TestCase):
class CaptureOutput(object):
output = namedtuple('output', 'undo do prev')
def __init__(self):
self.output = []
def __call__(self, undo, new, prev):
self.output = type(self).output(undo, new, prev)
def t(self, strokes):
"""A quick way to make a translation."""
strokes = [stroke(x) for x in strokes.split('/')]
return Translation(strokes, _lookup(strokes, self.dc, []))
def lt(self, translations):
"""A quick way to make a list of translations."""
return [self.t(x) for x in translations.split()]
def define(self, key, value):
key = normalize_steno(key)
self.d[key] = value
def translate(self, stroke):
_translate_stroke(stroke, self.s, self.dc, self.o)
def assertTranslations(self, expected):
self.assertEqual(self.s.translations, expected)
def assertOutput(self, undo, do, prev):
self.assertEqual(self.o.output, (undo, do, prev))
def setUp(self):
self.d = StenoDictionary()
self.dc = StenoDictionaryCollection()
self.dc.set_dicts([self.d])
self.s = _State()
self.o = type(self).CaptureOutput()
def test_first_stroke(self):
self.translate(stroke('-B'))
self.assertTranslations(self.lt('-B'))
self.assertOutput([], self.lt('-B'), None)
def test_second_stroke(self):
self.define('S/P', 'spiders')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
def test_second_stroke_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('-E'))
self.assertTranslations(self.lt('E'))
self.assertOutput([], self.lt('E'), self.t('T/A/I/L'))
def test_with_translation(self):
self.define('S', 'is')
self.define('-T', 'that')
self.s.translations = self.lt('S')
self.translate(stroke('-T'))
self.assertTranslations(self.lt('S -T'))
self.assertOutput([], self.lt('-T'), self.t('S'))
self.assertEqual(self.o.output.do[0].english, 'that')
def test_finish_two_translation(self):
self.define('S/T', 'hello')
self.s.translations = self.lt('S')
self.translate(stroke('T'))
self.assertTranslations(self.lt('S/T'))
self.assertOutput(self.lt('S'), self.lt('S/T'), None)
self.assertEqual(self.o.output.do[0].english, 'hello')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S'))
def test_finish_three_translation(self):
self.define('S/T/-B', 'bye')
self.s.translations = self.lt('S T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'bye')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S T'))
def test_replace_translation(self):
self.define('S/T/-B', 'longer')
self.s.translations = self.lt('S/T')
self.translate(stroke('-B'))
self.assertTranslations(self.lt('S/T/-B'))
self.assertOutput(self.lt('S/T'), self.lt('S/T/-B'), None)
self.assertEqual(self.o.output.do[0].english, 'longer')
self.assertEqual(self.o.output.do[0].replaced, self.lt('S/T'))
def test_undo(self):
self.s.translations = self.lt('POP')
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput(self.lt('POP'), [], None)
def test_empty_undo(self):
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput([], [], None)
def test_undo_translation(self):
self.define('P/P', 'pop')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P'))
self.assertOutput(self.lt('P/P'), self.lt('P'), None)
def test_undo_longer_translation(self):
self.define('P/P/-D', 'popped')
self.translate(stroke('P'))
self.translate(stroke('P'))
self.translate(stroke('-D'))
self.translate(stroke('*'))
self.assertTranslations(self.lt('P P'))
self.assertOutput(self.lt('P/P/-D'), self.lt('P P'), None)
def test_undo_tail(self):
self.s.tail = self.t('T/A/I/L')
self.translate(stroke('*'))
self.assertTranslations([])
self.assertOutput([], [], self.t('T/A/I/L'))
def test_suffix_folding(self):
self.define('K-L', 'look')
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
lt[0].english = 'look {^ing}'
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_multi_stroke(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he will {^s}')
def test_suffix_folding_doesnt_interfere(self):
self.define('E/HR', 'he will')
self.define('-S', '{^s}')
self.define('E', 'he')
self.define('HR-S', 'also')
self.translate(stroke('E'))
self.translate(stroke('HR-S'))
output = ' '.join(t.english for t in self.s.translations)
self.assertEqual(output, 'he also')
def test_suffix_folding_no_suffix(self):
self.define('K-L', 'look')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)
def test_suffix_folding_no_main(self):
self.define('-G', '{^ing}')
lt = self.lt('K-LG')
self.assertEqual(lt[0].english, None)
self.translate(stroke('K-LG'))
self.assertTranslations(lt)