def test_search_grid_for_words(self):
'''
Ensure that certain patterns can be found in a path_to_word
'''
# Create a mock grid with letters A, B, C and D so we can control our letters
grid = {
(0, 0): 'A',
(0, 1): 'B',
(1, 0): 'C',
(1, 1): 'D',
}
# Define a dictionary of three words - two in the grid and should be found, one not in the grid and should not be found
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
# ***CHANGED AFTER PRUNING TO INCLUDE BOTH FULL WORDS AND STEMS***
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Ensure that certain patterns can be found in a path_to_word
"""
grid = {(0, 0): "A", (0, 1): "B", (1, 0): "C", (1, 1): "D"}
twoLetterWord = "AB"
threeLetterWord = "ABC"
notThereWord = "EEE"
print("twoLeterWord = ", twoLetterWord, "threeLetterWord = ",
threeLetterWord, "notThereWord = ", notThereWord)
full_words = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = full_words, stems
print("full_words = ", full_words)
print("stems = ", stems)
print("dictionary = ", dictionary)
foundWords = boggle.search(grid, dictionary)
print("foundWords = ", foundWords)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_converting_a_path_to_a_word(self):
"""
Ensure that paths can be converted to words
"""
grid = boggle.make_grid(2,2)
oneLetterWord = boggle.path_to_word(grid, [(0,0)])
twoLetterWord = boggle. path_to_word(grid, [(0,0), (1,1)])
self. assertEqual(oneLetterWord, grid[(0,0)])
self.assertEqual(twoLetterWord, grid[(0,0)] + grid[(1, 1)]
def test_search_grid_for_words(self)
"""
Ensure that certain patterns can be found in a path_to_word
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D' }
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_load_dictionary(self):
"""
Test that the 'get_dictionary' function returns a dictionary
that has a length greater than 0
"""
dictionary = boggle.get_dictionary('words.txt')
self. assertGreater(len(dictionary), 0)
def test_search_grid_for_words(self):
"""
Ensure that certain patterns can be found in a `path_to_word`
For this test we will create a mock grid so that we can control the letters.
We also define a dictionary of three words. So ab, abc and eee. Two of those
words are in the grid and should be found. One of those words is not in the
grid and should not be found. In this case we're using the assert true for
all three of the words
"""
"""
test creates a mock dictionary that no longer
matches the tuple of two sets that the program now uses. A simple fix, although
not the best one, is to modify the test to include the stems of the test word
now if we rerun the unit tests you will see that they pass with.
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = "EEE"
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
two_letter_word = 'AB'
three_letter_word = 'ABC'
not_there_word = 'EEE'
dictionary = [two_letter_word, three_letter_word, not_there_word]
found_words = boggle.search(grid, dictionary)
self.assertTrue(two_letter_word in found_words)
self.assertTrue(three_letter_word in found_words)
self.assertTrue(not_there_word not in found_words)
def test_search_grid_for_words(self):
# Esure that certain patterns can be found in a path_to_word
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
ensure that certain patterns can be found in a path_to_word
"""
grid = {(0, 0) : "A", (0, 1) : "B", (1, 0) : "C", (1, 1) : "D"}
twoLetterWord = "AB"
threeLetterWord = "ABC"
notThereWord = "EEE"
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
#ensure that certain patterns can be found in a path_to_word
#create mock grid so we can control the letters. `2x2 grid containing a,b,c,d
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
grid = {(1, 0): 'C', (1, 1): 'D', (0, 0): 'A', (0, 1): 'B'}
twoLetterWord = 'AB'
threeLetterWord = 'BAD'
notThereWord = 'EEE'
fullWords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'B', 'BA', 'E', 'EE']
dictionary = fullWords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
grid = {(0, 0): "A", (0, 1): "B", (1, 0): "C", (1, 1): "D"}
twoLetterWord = "AB"
threeLetterWord = "ABC"
notThereWord = "EEE"
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Ensure that certain patterns can be found in a `path_to_word`
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A','AB','E','EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
#ensure certain patterns can be found in a path_to_word
#create mock grid so we can control the letters
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'} #2x2 grid
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Test case to verify that a pattern of words can be found
"""
grid = {(0, 0): "A", (0, 1): "B", (1, 0): "C", (1, 1): "D"}
twoLetterWord = "AB"
threeLetterWord = "ABC"
wordNotInGrid = "EEE"
full_words = [twoLetterWord, threeLetterWord, wordNotInGrid]
stems = ["A", "AB", "E", "EE"]
dictionary = full_words, stems
wordMatch = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in wordMatch)
self.assertTrue(threeLetterWord in wordMatch)
self.assertTrue(wordNotInGrid not in wordMatch)
def test_search_grid_for_words(self):
"""
ENSURE THAT CERTAIN PATTERNS CAN BE FOUND IN path_to_word
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundwords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundwords)
self.assertTrue(threeLetterWord in foundwords)
self.assertTrue(notThereWord not in foundwords)
def test_search_grid_for_words(self):
"""
Ensure That Certain Patterns Can Be Found In A Path_To_Word
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Ensure that certain pattersn can be found in path_to_word
"""
grid = {
(0, 0): "A",
(0, 1): "B",
(1, 0): "C",
(1, 1): "D"
} # Define a mock grid to control the letters
twoLetterWord = "AB"
threeLetterWord = "ABC" # We also define a dictionary of three words
notThereWord = "EEE"
dictionary = [twoLetterWord, threeLetterWord, notThereWord]
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Ensure that certain patterns can be found in a `path_to_word`
For this test we will create a mock grid so that we can control the letters.
We also define a dictionary of three words.
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
"""
Ensure that certain patterns can be found in a path_to_word
"""
# So for this test we will create a mock grid so that we can control the letters.
# In this case it's a 2x2 grid containing the letters a b c and d
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = ['A', 'AB', 'E', 'EE']
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(self):
#ensure certain patterns can be found in path_to_Word
grid = {(0, 0): 'A' , (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterword = 'AB'
threeLetterword = 'ABC'
notThereWord= 'EEE'
dictionary = [twoLetterword, threeLetterword, notThereWord
foundwords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterword in foundwords)
self.assertTrue(threeLetterword in foundwords)
self.assertTrue(not notThereWord in foundwords)
def test_load_dictionary(self):
#test that the 'get_dictionary' function returns a dictionary that has length greater than 0
dictionary = boggle.get_dictionary('words.txt'
self.assertGreater(len(dictionary), 0)
def test_search_grid_for_words(self):
'''
make sure that certain words can be found in certain path patterns
within the grid
'''
grid = {(0, 0): "A", (0, 1): "B", (1, 0): "C", (1, 1): "D"}
oneLetterWord = "A"
twoLetterWord = "AB"
threeLetterWord = "ABC"
notThereWord = "EEE"
fullWords = [
oneLetterWord, twoLetterWord, threeLetterWord, notThereWord
]
partialWords = ["A", "AB", "E", "EE"]
dictionary = fullWords, partialWords
foundWords = boggle.search(grid, dictionary)
self.assertTrue(oneLetterWord in foundWords)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
def test_search_grid_for_words(
self
): # need to find words in the grid. need to ensure that certain patterns can be found in a path
"""
Ensure that certain patterns can be found in a path_to_word
"""
grid = {(0, 0): 'A', (0, 1): 'B', (1, 0): 'C', (1, 1): 'D'}
twoLetterWord = 'AB'
threeLetterWord = 'ABC'
notThereWord = 'EEE'
#dictionary = [twoLetterWord, threeLetterWord, notThereWord]
fullwords = [twoLetterWord, threeLetterWord, notThereWord]
stems = [
'A', 'AB', 'E', 'EE'
] # a fix not the best one is to include the stems of the test word
dictionary = fullwords, stems
foundWords = boggle.search(grid, dictionary)
self.assertTrue(twoLetterWord in foundWords)
self.assertTrue(threeLetterWord in foundWords)
self.assertTrue(notThereWord not in foundWords)
