def test_daul_letter_left_right(self):
""" Handle two letter strokes with extra keys. """
word = b.Brief(name="ChCh", keys="ChCh")
left = {l for l in "KH"}
right = {l for l in "FP"}
self.validate_missing(word, left, right, starred=False)
def test_daul_letter_left_twice(self):
""" Handle two letter strokes with extra keys. """
word = b.Brief(name="ChB", keys="ChB")
left = {l for l in "KHPW"}
right = set()
self.validate_missing(word, left, right, starred=False)
def test_daul_letter(self):
""" Handle two letter strokes. """
word = b.Brief(name="Ch", keys="Ch")
left = {l for l in "KH"}
right = set()
self.validate_missing(word, left, right, starred=False)
def test_add_starred_letter_both(self):
""" Handle right hand letters with a star. """
word = b.Brief(name="ZV", keys="Z-V")
left = set("S")
right = set("F")
self.validate_missing(word, left, right, starred=True)
def test_complex_stoke(self):
""" Test a mixture of both. """
word = b.Brief(name="", keys="NVOENS")
left = {l for l in "TPHSRO"}
right = {l for l in "EPBS"}
self.validate_missing(word, left, right)
def test_daul_letter_star(self):
""" Handle two letter strokes with extra keys. """
word = b.Brief(name="Th", keys="ITh")
left = set()
right = {l for l in "EUT"}
self.validate_missing(word, left, right, starred=True)
def test_parse_double(self):
""" Parse the left and right stroke of a letter """
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.n)
word._parse_key_stroke(l.n)
self.validate_missing(word, {l for l in "TPH"}, {l for l in "PB"})
def test_double_stoke(self):
""" Test parsing of left and right stroke. """
word = b.Brief(name="", keys="NN")
left = {l for l in "TPH"}
right = {l for l in "PB"}
self.validate_missing(word, left, right)
def test_triple_len(self):
""" Get the number of keys in a triple stroke. """
word = b.Brief(name="Double", keys="L-Th/-G/KWRO-NG")
n_strokes_test = len(word)
n_strokes_expected = 3
self.assertEqual(n_strokes_test, n_strokes_expected)
def test_vowel_simple(self):
""" Adding a simple stroke that requires both sides of the keyboard. """
word = b.Brief("Vowel", "Aw")
left = {"A"}
right = {"U"}
self.validate_missing(word, left, right)
def test_single_len(self):
""" Get the number of keys in single stroke. """
word = b.Brief(name="Single", keys="-G")
n_strokes_test = len(word)
n_strokes_expected = 1
self.assertEqual(n_strokes_test, n_strokes_expected)
def test_left_stoke(self):
""" Test parsing right with dash stroke. """
word = b.Brief(name="", keys="S")
left = {l for l in "S"}
right = set()
self.validate_missing(word, left, right)
def test_add_right_left(self):
"""" We should get an error on trying left key after right. """
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.e)
word._parse_key_stroke(l.n)
with self.assertRaises(ValueError):
word._parse_key_stroke(l.o)
def test_parse_dash(self):
""" Providing a dash should starting parsing on the right side. """
word = b.Brief(name="", keys="")
word._parse_key_stroke("-")
word._parse_key_stroke(l.s)
self.validate_missing(word, set(), {"S"})
def test_vowel_complex(self):
""" Adding a vowel stroke along with other chars. """
word = b.Brief("Vowel", "NAwCh")
left = {l for l in "TPHA"}
right = {l for l in "UFP"}
self.validate_missing(word, left, right)
def test_add_right_mult(self):
"""" Add a right hand letter followed by an ambigious letter"""
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.e)
word._parse_key_stroke(l.s)
self.validate_missing(word, set(), {l for l in "ES"})
def test_valid_left(self):
word = b.Brief(name="", keys="")
word.left_letters = {"T", "K"}
remaining_letters_expected = left_set - {"T", "K"}
remaining_letters_test = word.remaining_left
self.assertEqual(remaining_letters_expected, remaining_letters_test)
def test_splitting(self):
names = ["Think", "Now", "Function"]
strokes = ["ThI", "NOE", "FUKS"]
briefs = [
b.Brief(name, stroke) for name, stroke in zip(names, strokes)
]
b.brief_grid(briefs)
def test_clusers(self, keys, left, right, starred):
""" Handle two letter strokes with mixtures of dashes and stars keys. """
word = b.Brief(name="Th", keys=keys)
left = {l for l in left} if left else set()
right = {l for l in right} if right else set()
self.validate_missing(word, left, right, starred=starred)
def test_add_left_letter_mult(self):
"""" Add multiple keys to the array """
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.f)
word._parse_key_stroke(l.v)
word._parse_key_stroke(l.o)
left_keys = {l for l in "TPSRO"}
self.validate_missing(word, left_keys, set())
def test_add_left_letter(self):
"""" Add a key to the array """
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.n)
remaining_letters_expeceted = left_set - {"T", "H", "P"}
remaining_letters_actual = word.remaining_left
self.assertEqual(remaining_letters_expeceted, remaining_letters_actual)
def test_double_simple(self):
""" Test the keys in a simple double brief. """
word = b.Brief(name="Double", keys="T/-S")
left = {l for l in "T"}
right = set()
self.validate_missing(word, left, right)
child = word.next_
self.validate_missing(child, set(), {l for l in "S"})
def test_splitting_multiline(self):
names = ["Think", "Now", "Function", "Yours", "Have", "Do"]
strokes = ["ThI", "NOE", "FUKS", "URS", "V", "DO"]
briefs = [
b.Brief(name, stroke) for name, stroke in zip(names, strokes)
]
b.brief_grid(briefs)
self.assertTrue(False)
def test_double_complex(self):
""" Test the keys in a complex double brief. """
word = b.Brief(name="Double", keys="L-Th/-G")
left = {l for l in "HR"}
right = {l for l in "T"}
self.validate_missing(word, left, right, starred=True)
child = word.next_
self.validate_missing(child, set(), {"G"})
def test_triple_stroke(self):
""" Test the keys in a complex triple stroke. """
word = b.Brief(name="Double", keys="L-Th/-G/KWRO-NG")
self.validate_missing(word, {l for l in "HR"}, {"T"}, starred=True)
word = word.next_
self.validate_missing(word, set(), {"G"}, starred=False)
word = word.next_
self.validate_missing(word, {l
for l in "KWRO"}, {l
for l in "PBG"},
starred=False)
def test_breaking_sting(self):
""" Raise an appropriate error if things are out of order. """
with self.assertRaises(ValueError):
word = b.Brief("Vowel", "-FAw")
def test_add_right_letter(self):
"""" Add a single right hand letter """
word = b.Brief(name="", keys="")
word._parse_key_stroke(l.e)
self.validate_missing(word, set(), {"E"})
