def test_word_proximity_search(self):
"""Test proximity search which is default"""
search = WordSearch()
match = search.perform_search(TEST_BLOCK1, SEARCH1)
self.assertTrue(match)
with self.assertRaises(type(PARAMETER_EXCEPTION)):
search.perform_search(TEST_BLOCK1, EMPTY)
def test_should_fail_to_locate_words_that_are_not_on_horizontal_vertical_or_diagonal_lines(
self, ):
puzzle = WordSearch(["abc", "def"])
self.assertIsNone(puzzle.search("aef"))
self.assertIsNone(puzzle.search("ced"))
self.assertIsNone(puzzle.search("abf"))
self.assertIsNone(puzzle.search("cbd"))
def test_multiple_words(self):
puzzle = [
'jefblpepre', 'camdcimgtc', 'oivokprjsm', 'pbwasqroua',
'rixilelhrs', 'wolcqlirpc', 'fortranftw', 'alxhpburyi',
'jalaycalmp', 'clojurermt'
]
searchAnswer = WordSearch(puzzle).search('fortran')
self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(0, 9), Point(6, 9)))
def setUpClass(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'screeaumgr\n'
'alxhpburyi\n'
'jalaycalmp\n'
'clojurermt')
self.example = WordSearch(puzzle)
def main(word_list_filename, grid):
"""The main function of word_search_app program.
Args:
word_list_filename (str) - full path input word-list text file
grid (list) - letters grid as list of n m-letters str
Returns:
none
"""
word_search = WordSearch(grid, word_list_filename)
word_search.print_found_words()
print(word_search.found_words(), "words found")
def test_should_locate_a_left_to_right_word_in_ten_line_grid(self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"screeaumgr",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
class WordSearchTests(unittest.TestCase):
@classmethod
def setUpClass(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'screeaumgr\n'
'alxhpburyi\n'
'jalaycalmp\n'
'clojurermt')
self.example = WordSearch(puzzle)
def test_horizontal_words_left_to_right(self):
self.assertEqual(self.example.search('clojure'),
(Point(0, 9), Point(6, 9)))
def test_horizontal_words_right_to_left(self):
self.assertEqual(self.example.search('elixir'),
(Point(5, 4), Point(0, 4)))
def test_vertical_words_top_to_bottom(self):
self.assertEqual(self.example.search('ecmascript'),
(Point(9, 0), Point(9, 9)))
def test_vertical_words_bottom_to_top(self):
self.assertEqual(self.example.search('rust'),
(Point(8, 4), Point(8, 1)))
def test_diagonal_words_top_left_to_bottom_right(self):
self.assertEqual(self.example.search('java'),
(Point(0, 0), Point(3, 3)))
def test_diagonal_upper_bottom_right_to_top_left(self):
self.assertEqual(self.example.search('lua'),
(Point(7, 8), Point(5, 6)))
def test_diagonal_upper_bottom_left_to_top_right(self):
self.assertEqual(self.example.search('lisp'),
(Point(2, 5), Point(5, 2)))
def test_diagonal_upper_top_right_to_bottom_left(self):
self.assertEqual(self.example.search('ruby'),
(Point(7, 5), Point(4, 8)))
def test_words_that_are_not_in_the_puzzle(self):
self.assertIsNone(self.example.search('haskell'))
def test_search_differently_sized_puzzles(self):
puzzle = ('qwertyuiopz\n' 'luamsicrexe\n' 'abcdefghijk')
self.assertEqual(
WordSearch(puzzle).search('exercism'), (Point(10, 1), Point(3, 1)))
def test_multiple_words(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'fortranftw\n'
'alxhpburyi\n'
'jalaycalmp\n'
'clojurermt\n')
searchAnswer = WordSearch(puzzle).search('fortran')
self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(0, 9), Point(6, 9)))
def test_should_locate_multiple_words(self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"fortranftw",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("fortran"), (Point(0, 6), Point(6, 6)))
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
def test_should_locate_multiple_words_written_in_different_horizontal_directions(
self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"screeaumgr",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("elixir"), (Point(5, 4), Point(0, 4)))
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
def setUpClass(cls):
puzzle = [
'jefblpepre', 'camdcimgtc', 'oivokprjsm', 'pbwasqroua',
'rixilelhrs', 'wolcqlirpc', 'screeaumgr', 'alxhpburyi',
'jalaycalmp', 'clojurermt'
]
cls.example = WordSearch(puzzle)
class WordSearchTests(unittest.TestCase):
def setUp(self):
self.word_search = WordSearch("puzzle.txt")
def test_reading_words_from_text_file(self):
self.assertEqual(self.word_search.words,['BONES', 'KHAN', 'KIRK', 'SCOTTY', 'SPOCK', 'SULU', 'UHURA'])
def test_reading_puzzle_from_text_file(self):
self.word_search_2 = WordSearch("puzzle_test.txt")
self.assertEqual(self.word_search_2.puzzle, [['U','M','K','H'],['L','L','S','H'],
['H','S','U','P'],['B','R','J','S']])
def test_getting_first_letter_of_first_word(self):
self.word_search.get_next_letter()
self.assertEqual(self.word_search.current_letter,'B')
def test_should_locate_words_written_top_to_bottom(self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"screeaumgr",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
self.assertEqual(puzzle.search("elixir"), (Point(5, 4), Point(0, 4)))
self.assertEqual(puzzle.search("ecmascript"),
(Point(9, 0), Point(9, 9)))
def test_different_left_to_right_word_ten_lines(self):
puzzle = [
'jefblpepre', 'camdcimgtc', 'oivokprjsm', 'pbwasqroua',
'rixilelhrs', 'wolcqlirpc', 'fortranftw', 'alxhpburyi',
'clojurermt', 'jalaycalmp'
]
searchAnswer = WordSearch(puzzle).search('fortran')
self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
def setUpClass(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'screeaumgr\n'
'alxhpburyi\n'
'jalaycalmp\n'
'clojurermt')
self.example = WordSearch(puzzle)
def test_different_left_to_right_word_ten_lines(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'fortranftw\n'
'alxhpburyi\n'
'clojurermt\n'
'jalaycalmp\n')
searchAnswer = WordSearch(puzzle).search('fortran')
self.assertEqual(searchAnswer, (Point(0, 6), Point(6, 6)))
def wordsearch(matrix, words, train_data, train_labels):
"""
This is the function that we have been asked to write for the assignment. This function takes a word search image
(as pixels), a list of words and some training data and labels and will output the solved word search.
:param matrix: A matrix representing an image of the word search grid to be processed.
:param words: A list of words to be found in the word search.
:param train_data: Training data to classify letters in the word search.
:param train_labels: Training labels for the training data.
:return:
"""
word_search = WordSearch(matrix, letter_size, words, train_data,
train_labels,
True) # true for dimension reduction
word_search.solve()
#word_search.find_word("DON")
word_search.print()
word_search.show()
def test_should_fail_to_locate_a_word_that_is_not_in_the_puzzle(self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"screeaumgr",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
self.assertEqual(puzzle.search("elixir"), (Point(5, 4), Point(0, 4)))
self.assertEqual(puzzle.search("ecmascript"),
(Point(9, 0), Point(9, 9)))
self.assertEqual(puzzle.search("rust"), (Point(8, 4), Point(8, 1)))
self.assertEqual(puzzle.search("java"), (Point(0, 0), Point(3, 3)))
self.assertEqual(puzzle.search("lua"), (Point(7, 8), Point(5, 6)))
self.assertEqual(puzzle.search("lisp"), (Point(2, 5), Point(5, 2)))
self.assertEqual(puzzle.search("ruby"), (Point(7, 5), Point(4, 8)))
self.assertIsNone(puzzle.search("haskell"))
def test420_when_word_search_is_created_with_bad_grid_error_is_raised(self):
method = "test420_when_word_search_is_created_with_bad_grid_error_is_raised"
csv_file = CSV_BAD_GRID
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Started ------------------")
)
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Expecting GridDimensionException")
)
with self.assertRaises(GridDimensionException, msg=f"GridDimensionException should have been triggered"):
_ = WordSearch(word_search_csv=csv_file)
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Completed ----------------")
)
return
def test410_when_word_search_is_created_with_empty_file_error_is_raised(self):
method = "test410_when_word_search_is_created_with_empty_file_error_is_raised"
csv_file = CSV_EMPTY
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Started ------------------")
)
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Expecting FileFormatException")
)
with self.assertRaises(FileFormatException, msg=f"FileFormatException should have been triggered"):
_ = WordSearch(word_search_csv=csv_file)
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Completed ----------------")
)
return
def test_should_locate_words_written_bottom_left_to_top_right(self):
puzzle = WordSearch([
"jefblpepre",
"camdcimgtc",
"oivokprjsm",
"pbwasqroua",
"rixilelhrs",
"wolcqlirpc",
"screeaumgr",
"alxhpburyi",
"jalaycalmp",
"clojurermt",
])
self.assertEqual(puzzle.search("clojure"), (Point(0, 9), Point(6, 9)))
self.assertEqual(puzzle.search("elixir"), (Point(5, 4), Point(0, 4)))
self.assertEqual(puzzle.search("ecmascript"),
(Point(9, 0), Point(9, 9)))
self.assertEqual(puzzle.search("rust"), (Point(8, 4), Point(8, 1)))
self.assertEqual(puzzle.search("java"), (Point(0, 0), Point(3, 3)))
self.assertEqual(puzzle.search("lua"), (Point(7, 8), Point(5, 6)))
self.assertEqual(puzzle.search("lisp"), (Point(2, 5), Point(5, 2)))
def test440_when_word_search_searches_for_notfound_words_no_coordinates_are_returned(self):
method = "test440_when_word_search_searches_for_notfound_words_no_coordinates_are_returned"
csv_file = CSV_NOTFOUND_WORDS
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Started ------------------")
)
word_search = WordSearch(word_search_csv=csv_file)
result_dict = word_search.get_solution()
for w_str in word_search.get_word_list_as_strings():
self.assertTrue(w_str in result_dict, msg=f"{w_str} is not in results with {len(result_dict)}")
self.assertFalse(len(result_dict[w_str]), msg=f"{w_str} has no value so nothing was found")
for w in result_dict:
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg=f"{w} {result_dict[w]}")
)
self.log.info(
logger_helper.format_log(classname=self.classname, method=method, msg="Completed ----------------")
)
return
class TestWordSearch(unittest.TestCase):
ws = WordSearch("test_puzzle.txt")
ws.solve_puzzle()
def testIfPuzzleDataWasExtractedFromFile(self):
expected_words = [
"APE", "ART", "AIR", "ANT", "AXE", "ACE", "ALE", "ARK"
]
expected_board = [['K','B','E','D','T'], \
['F','R','P','R','G'], \
['E','L','A','I','R'], \
['H','C','X','N','J'], \
['E','M','E','O','T']]
self.assertListEqual(self.ws.words, expected_words)
self.assertListEqual(self.ws.board, expected_board)
def testIfPuzzleBoardIsSquare(self):
board_row_len = len(self.ws.board)
board_col_len = len(self.ws.board[0])
self.assertEqual(board_row_len, board_col_len)
def testFindWordNorth(self):
test_word = "APE"
expected_output = [[2, 2], [2, 1], [2, 0]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordSouth(self):
test_word = "AXE"
expected_output = [[2, 2], [2, 3], [2, 4]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordEast(self):
test_word = "AIR"
expected_output = [[2, 2], [3, 2], [4, 2]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordWest(self):
test_word = "ALE"
expected_output = [[2, 2], [1, 2], [0, 2]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordNorthEast(self):
test_word = "ART"
expected_output = [[2, 2], [3, 1], [4, 0]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordSouthEast(self):
test_word = "ANT"
expected_output = [[2, 2], [3, 3], [4, 4]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordSouthWest(self):
test_word = "ACE"
expected_output = [[2, 2], [1, 3], [0, 4]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
def testFindWordNorthWest(self):
test_word = "ARK"
expected_output = [[2, 2], [1, 1], [0, 0]]
actual_output = self.ws.answers[test_word]
self.assertListEqual(actual_output, expected_output)
class WordSearchTests(unittest.TestCase):
@classmethod
def setUpClass(self):
puzzle = ('jefblpepre\n'
'camdcimgtc\n'
'oivokprjsm\n'
'pbwasqroua\n'
'rixilelhrs\n'
'wolcqlirpc\n'
'screeaumgr\n'
'alxhpburyi\n'
'jalaycalmp\n'
'clojurermt')
self.example = WordSearch(puzzle)
def test_horizontal_words_left_to_right(self):
self.assertEqual(
self.example.search('clojure'),
(Point(0, 9), Point(6, 9))
)
def test_horizontal_words_right_to_left(self):
self.assertEqual(
self.example.search('elixir'),
(Point(5, 4), Point(0, 4))
)
def test_vertical_words_top_to_bottom(self):
self.assertEqual(
self.example.search('ecmascript'),
(Point(9, 0), Point(9, 9))
)
def test_vertical_words_bottom_to_top(self):
self.assertEqual(
self.example.search('rust'),
(Point(8, 4), Point(8, 1))
)
def test_diagonal_words_top_left_to_bottom_right(self):
self.assertEqual(
self.example.search('java'),
(Point(0, 0), Point(3, 3))
)
def test_diagonal_upper_bottom_right_to_top_left(self):
self.assertEqual(
self.example.search('lua'),
(Point(7, 8), Point(5, 6))
)
def test_diagonal_upper_bottom_left_to_top_right(self):
self.assertEqual(
self.example.search('lisp'),
(Point(2, 5), Point(5, 2))
)
def test_diagonal_upper_top_right_to_bottom_left(self):
self.assertEqual(
self.example.search('ruby'),
(Point(7, 5), Point(4, 8))
)
def test_words_that_are_not_in_the_puzzle(self):
self.assertIsNone(self.example.search('haskell'))
def test_search_differently_sized_puzzles(self):
puzzle = ('qwertyuiopz\n'
'luamsicrexe\n'
'abcdefghijk')
self.assertEqual(
WordSearch(puzzle).search('exercism'),
(Point(10, 1), Point(3, 1))
)
def test_single_word_right_to_left(self):
puzzle = ['rixilelhrs']
searchAnswer = WordSearch(puzzle).search('elixir')
self.assertEqual(searchAnswer, (Point(5, 0), Point(0, 0)))
def test_initial_game_grid(self):
puzzle = ['jefblpepre']
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertIsNone(searchAnswer)
def test_left_to_right_word_three_lines(self):
puzzle = ['camdcimgtc', 'jefblpepre', 'clojurermt']
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(0, 2), Point(6, 2)))
def test_left_to_right_word_two_lines(self):
puzzle = ['jefblpepre', 'tclojurerm']
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(1, 1), Point(7, 1)))
def test_different_left_to_right_word_different_position(self):
puzzle = ['xcoffeezlp']
searchAnswer = WordSearch(puzzle).search('coffee')
self.assertEqual(searchAnswer, (Point(1, 0), Point(6, 0)))
def test_different_left_to_right_word(self):
puzzle = ['coffeelplx']
searchAnswer = WordSearch(puzzle).search('coffee')
self.assertEqual(searchAnswer, (Point(0, 0), Point(5, 0)))
def test_left_to_right_word_different_position(self):
puzzle = ['mtclojurer']
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(2, 0), Point(8, 0)))
def test_left_to_right_word(self):
puzzle = ['clojurermt']
searchAnswer = WordSearch(puzzle).search('clojure')
self.assertEqual(searchAnswer, (Point(0, 0), Point(6, 0)))
