def test_generate_alphe_list():
english_words = load_words()
wl = WordLadder('cat', 'hat', english_words[len('cat')])
assert wl.generate_alphe_list() == [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
def test_make_ladder():
"""test make_ladder method of WordLadder class"""
wordlist = [
"love", "hove", "have", "hate", "lone", "hone", "hale", "bate", "life"
]
world_ladder = WordLadder("love", "hate", wordlist)
res = world_ladder.make_ladder()
assert res == "love\thove\thave\thate\t"
def test_find_path_if_words_are_defined_trough_instance_variables(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.start = 'sail'
word_ladder.end = 'fear'
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
def test_make_ladder():
english_words = load_words()
w1, w2 = 'love', 'hate'
wl = WordLadder(w1, w2, english_words[len(w1)])
word_ladder = wl.make_ladder()
expected = ['love', 'hove', 'have', 'hate']
flag = True
for i in reversed(range(len(expected))):
if expected[i] != word_ladder.pop():
flag = False
assert flag
def main():
"""Run an interactive command line to let the user
input word pairs and generate word ladders"""
english_words = load_words()
# print(english_words[len('hel')])
while True:
w1, w2 = input("> ").split()
# Create a WordLadder object
wl = WordLadder(w1, w2, english_words[len(w1)])
# Generate the word ladder
word_ladder = wl.make_ladder()
print("Ladder: ", word_ladder)
def test_make_ladder():
w1 = "angel"
w2 = "devil"
assert WordLadder(w1, w2, wordlist[len(w1)]).make_ladder().items == ["angel",
"anger", "aeger","leger","lever", "level", "devel", "devil"]
w1 = "cat"
w2 = "hat"
assert WordLadder(w1, w2, wordlist[len(w1)]).make_ladder().items == ["cat",
"hat"]
w1 = "love"
w2 = "hate"
assert WordLadder(w1, w2, wordlist[len(w1)]).make_ladder().items == ["love",
"hove", "have", "hate"]
def test_graph_is_reused_among_executions(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
_id = id(word_ladder.graph)
word_ladder.find_path('Jeanne', 'sail')
eq_(_id, id(word_ladder.graph))
word_ladder.find_path('fear', 'sail')
_id = id(word_ladder.graph)
word_ladder.find_path('flux', 'fear')
eq_(_id, id(word_ladder.graph))
def test_words_has_same_length_method(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(word_ladder.words_has_same_length(), None)
word_ladder.start = '1234'
eq_(word_ladder.words_has_same_length(), None)
word_ladder.end = '1234'
eq_(word_ladder.words_has_same_length(), True)
word_ladder.start = '12345'
eq_(word_ladder.words_has_same_length(), False)
def main():
"""Run an interactive command line to let the user
input word pairs and generate word ladders"""
english_words = load_words()
while True:
w1, w2 = input("> ").split()
start_time = time.time()
# Create a WordLadder object
wl = WordLadder(w1, w2, english_words[len(w1)])
# Generate the word ladder
word_ladder = wl.make_ladder()
print("Ladder: ", word_ladder)
print("Entire execution tooke %s seconds ---" %
(time.time() - start_time))
def test_find_path_caching(self):
self.clean_tmp_files()
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'scratch')
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'memory')
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'pickling')
def test_word_ladder():
"""test WordLadder constructor"""
wordlist = []
world_ladder = WordLadder("cat", "hat", wordlist)
assert world_ladder.alphabet == [
'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n',
'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z'
]
def main():
"""Run an interactive command line to let the user
input word pairs and generate word ladders"""
english_words = load_words()
# print(english_words[len('hel')])
while True:
w1, w2 = input("> ").split()
# Create a WordLadder object
if len(w1) < len(w2):
vary_length_words = {w1}
for i in range(len(w1), len(w2) + 1):
vary_length_words = vary_length_words | english_words[i]
elif len(w1) > len(w2):
vary_length_words = {w2}
for i in range(len(w2), len(w1) + 1):
vary_length_words = vary_length_words | english_words[i]
else:
vary_length_words = english_words[len(w1)]
wl = WordLadder(w1, w2, vary_length_words)
# Generate the word ladder
word_ladder = wl.make_ladder()
print("Ladder: ", word_ladder)
def main():
"""Run an interactive command line to let the user
input word pairs and generate word ladders"""
english_words = load_words()
while True:
w1, w2 = input("> ").split()
if len(w1) == len(w2):
# Everything same with word_ladder_app
wl = WordLadder(w1, w2, english_words[len(w1)])
word_ladder = wl.make_ladder()
print("Ladder: ", word_ladder)
else:
# a set of words for adding later
check_words_set = set()
diff = abs(len(w1) - len(w2))
initial_insertion = "a"
if len(w1) < len(w2):
shorter = len(w1)
longer = len(w2)
start = w1
end = w2
else:
shorter = len(w2)
longer = len(w1)
start = w2
end = w1
# add words with length in range of shorter to longer
for i in range(shorter, longer + 1):
for j in english_words[i]:
check_words_set.add(j)
ec = ExtraCredit(start, end, check_words_set)
word_ladder = ec.make_ladder()
# normal print if start with w1
if start == w1:
print("Ladder: ", word_ladder)
# reverse if start with w2
elif start == w2:
print("Ladder: ", reverse_ladder(word_ladder))
def test_graph_property(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
eq_(id(word_ladder._graph_diff_length), id(word_ladder.graph))
word_ladder.find_path('flux', 'sail')
eq_(id(word_ladder._graph_same_length), id(word_ladder.graph))
def test_make_ladder():
english_words = load_words()
wl = WordLadder('cat', 'hat', english_words[len('cat')])
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "cat" + "\t" + "hat" + "\t"
wl = WordLadder('love', 'hate', english_words[len('love')])
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "love" + "\t" + "hove" + "\t"\
+ "have" + "\t" + "hate" + "\t"
wl = WordLadder('earth', 'ocean', english_words[len('earth')])
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "earth" + "\t" + "barth" + "\t"\
+ "barih" + "\t" + "baris" + "\t"\
+ "batis" + "\t" + "bitis" + "\t"\
+ "aitis" + "\t" + "antis" + "\t"\
+ "antas" + "\t" + "antal" + "\t"\
+ "ontal" + "\t" + "octal" + "\t"\
+ "octan" + "\t" + "ocean" + "\t"
def test_make_ladder():
wordlist = set()
with open('words_alpha.txt') as word_file:
for line in word_file:
word = line.strip().split()
wordlist.add(word[0])
ladder = WordLadder("cat", "hat", wordlist)
assert repr(ladder.make_ladder()) == "cat\that\t"
ladder = WordLadder("love", "hate", wordlist)
assert repr(ladder.make_ladder()) == "love\thove\thave\thate\t"
def setUp(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
def test_make_ladder():
english_words = load_words()
wl = WordLadder('dog', 'puppy', english_words)
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "dog" + "\t" + "cog" + "\t" + "cop" + "\t"\
+ "copy" + "\t" + "coppy" + "\t"\
+ "poppy" + "\t" + "puppy" + "\t"
wl = WordLadder('sad', 'happy', english_words)
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "sad" + "\t" + "gad" + "\t"\
+ "gap" + "\t" + "gapy" + "\t"\
+ "gappy" + "\t" + "happy" + "\t"
wl = WordLadder('red', 'yellow', english_words)
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "red" + "\t" + "bed" + "\t"\
+ "bel" + "\t" + "bell" + "\t"\
+ "bello" + "\t" + "bellow" + "\t"\
+ "yellow" + "\t"
wl = WordLadder('command', 'line', english_words)
word_ladder = wl.make_ladder()
assert repr(word_ladder) == "command" + "\t" + "commend" + "\t"\
+ "compend" + "\t" + "comped" + "\t"\
+ "coped" + "\t" + "loped" + "\t"\
+ "lope" + "\t" + "lone" + "\t"\
+ "line" + "\t"
def test_make_ladder():
test_ladder1 = WordLadder('cat', 'hat', valid_words[3])
test_ladder2 = WordLadder('love', 'hate', valid_words[4])
test_ladder3 = WordLadder('angel', 'devil', valid_words[5])
test_ladder4 = WordLadder('earth', 'ocean', valid_words[5])
assert test_ladder1.make_ladder().size() == 2
assert test_ladder2.make_ladder().size() == 4
assert test_ladder3.make_ladder().size() == 8
assert test_ladder4.make_ladder().size() == 14
class TestWordLadder(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.clean_tmp_files()
cls.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
@classmethod
def clean_tmp_files(cls):
for f in os.listdir(WordLadder.tmp):
if re.search('.*_(SAME|DIFF)', f):
os.remove(os.path.join(WordLadder.tmp, f))
def test_find_path_caching(self):
self.clean_tmp_files()
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'scratch')
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'memory')
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.find_path('fear', 'fear'), ['fear']
eq_(word_ladder._retrieval_method, 'pickling')
def test_word_list_is_created(self):
ok_(isinstance(self.word_ladder.words, list))
def test_find_path_same_length(self):
eq_(self.word_ladder.find_path('fear', 'fear'), ['fear'])
eq_(self.word_ladder.find_path('fear', 'sail'),
['fear', 'hear', 'heir', 'hair', 'hail', 'sail'])
def test_find_path_different_length(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(self.word_ladder.find_path('Abe', 'Abel'), ['Abe', 'Abel'])
def test_find_path_not_found(self):
eq_(self.word_ladder.find_path('Abelardo', 'Abel'), None)
def test_find_path_different_length_going_up_and_down(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'fixture.1'))
eq_(self.word_ladder.find_path('a', 'eoha'),
['a', 'ai', 'aie', 'wie', 'wieo', 'ieo', 'eo', 'eoh', 'eoha'])
def test_words_has_same_length_method(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(word_ladder.words_has_same_length(), None)
word_ladder.start = '1234'
eq_(word_ladder.words_has_same_length(), None)
word_ladder.end = '1234'
eq_(word_ladder.words_has_same_length(), True)
word_ladder.start = '12345'
eq_(word_ladder.words_has_same_length(), False)
@raises(WordsNotDefined)
def test_start_or_end_not_defined_raises_words_not_defined_exception(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path()
def test_graph_is_reused_among_executions(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
_id = id(word_ladder.graph)
word_ladder.find_path('Jeanne', 'sail')
eq_(_id, id(word_ladder.graph))
word_ladder.find_path('fear', 'sail')
_id = id(word_ladder.graph)
word_ladder.find_path('flux', 'fear')
eq_(_id, id(word_ladder.graph))
def test_graph_property(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
eq_(id(word_ladder._graph_diff_length), id(word_ladder.graph))
word_ladder.find_path('flux', 'sail')
eq_(id(word_ladder._graph_same_length), id(word_ladder.graph))
def test_find_path_if_words_are_defined_trough_instance_variables(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.start = 'sail'
word_ladder.end = 'fear'
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
def test_find_path_if_words_are_defined_at_instance_declaration_time(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'), 'sail', 'fear')
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
def test_start_or_end_not_defined_raises_words_not_defined_exception(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path()
def setUpClass(cls):
cls.clean_tmp_files()
cls.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
def test_find_path_different_length_going_up_and_down(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'fixture.1'))
eq_(self.word_ladder.find_path('a', 'eoha'),
['a', 'ai', 'aie', 'wie', 'wieo', 'ieo', 'eo', 'eoh', 'eoha'])
def test_find_path_different_length(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(self.word_ladder.find_path('Abe', 'Abel'), ['Abe', 'Abel'])
class TestWordLadder(unittest.TestCase):
def setUp(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
def test_word_list_is_created(self):
ok_(isinstance(self.word_ladder.words, list))
def test_find_path_same_length(self):
eq_(self.word_ladder.find_path('fear', 'fear'), ['fear'])
eq_(self.word_ladder.find_path('fear', 'sail'),
['fear', 'hear', 'heir', 'hair', 'hail', 'sail'])
def test_find_path_different_length(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(self.word_ladder.find_path('Abe', 'Abel'), ['Abe', 'Abel'])
def test_find_path_not_found(self):
eq_(self.word_ladder.find_path('Abelardo', 'Abel'), None)
def test_find_path_different_length_going_up_and_down(self):
self.word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'fixture.1'))
eq_(self.word_ladder.find_path('a', 'eoha'),
['a', 'ai', 'aie', 'wie', 'wieo', 'ieo', 'eo', 'eoh', 'eoha'])
def test_words_has_same_length_method(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
eq_(word_ladder.words_has_same_length(), None)
word_ladder.start = '1234'
eq_(word_ladder.words_has_same_length(), None)
word_ladder.end = '1234'
eq_(word_ladder.words_has_same_length(), True)
word_ladder.start = '12345'
eq_(word_ladder.words_has_same_length(), False)
@raises(WordsNotDefined)
def test_start_or_end_not_defined_raises_words_not_defined_exception(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path()
def test_graph_is_reused_among_executions(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
_id = id(word_ladder.graph)
word_ladder.find_path('Jeanne', 'sail')
eq_(_id, id(word_ladder.graph))
word_ladder.find_path('fear', 'sail')
_id = id(word_ladder.graph)
word_ladder.find_path('flux', 'fear')
eq_(_id, id(word_ladder.graph))
def test_graph_property(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists', 'linux_english_words'))
word_ladder.find_path('Abe', 'Abel')
eq_(id(word_ladder._graph_diff_length), id(word_ladder.graph))
word_ladder.find_path('flux', 'sail')
eq_(id(word_ladder._graph_same_length), id(word_ladder.graph))
def test_find_path_if_words_are_defined_trough_instance_variables(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'))
word_ladder.start = 'sail'
word_ladder.end = 'fear'
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
def test_find_path_if_words_are_defined_at_instance_declaration_time(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'), 'sail', 'fear')
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
def _run(args):
result = WordLadder(args['<dict_file>']).find_path(
args['<from>'], args['<to>'], bool(args['--all-paths']))
return result
def test_make_ladder():
word_list = load_words("cat", "hat")
ladder = WordLadder("cat", "hat", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == ["cat", "hat"]
word_list = load_words("love", "hate")
ladder = WordLadder("love", "hate", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == ["love", "hove", "have", "hate"]
word_list = load_words("angel", "devil")
ladder = WordLadder("angel", "devil", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == [
"angel", "anger", "aeger", "leger", "lever", "level", "devel", "devil"
]
word_list = load_words("earth", "ocean")
ladder = WordLadder("earth", "ocean", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == [
"earth", "barth", "barih", "baris", "batis", "bitis", "aitis", "antis",
"antas", "antal", "ontal", "octal", "octan", "ocean"
]
# Different length test cases
word_list = load_words("cat", "five")
ladder = WordLadder("cat", "five", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == ["cat", "fat", "fit", "fie", "five"]
word_list = load_words("five", "cat")
ladder = WordLadder("five", "cat", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == ["five", "cive", "cave", "cate", "cat"]
word_list = load_words("dog", "puppy")
ladder = WordLadder("dog", "puppy", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == [
"dog", "cog", "cop", "copy", "coppy", "poppy", "puppy"
]
word_list = load_words("sad", "happy")
ladder = WordLadder("sad", "happy", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == ["sad", "gad", "gap", "gapy", "gappy", "happy"]
word_list = load_words("red", "yellow")
ladder = WordLadder("red", "yellow", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == [
"red", "bed", "bel", "bell", "bello", "bellow", "yellow"
]
word_list = load_words("command", "line")
ladder = WordLadder("command", "line", word_list)
word_ladder = ladder.make_ladder()
assert word_ladder.items == [
"command", "commend", "compend", "comped", "coped", "loped", "lope",
"lone", "line"
]
def test_make_ladder():
valid_words = {}
with open('words_alpha.txt') as word_file:
for w in word_file.read().split():
if len(w) in valid_words.keys():
# Add to an existing set
valid_words[len(w)].add(w)
else:
# Initialize a set with one element
valid_words[len(w)] = {w}
wl = WordLadder("cat", "hat", valid_words[len("cat")])
assert wl.make_ladder().items[0] == "cat"
wl = WordLadder("love", "hate", valid_words[len("love")])
assert wl.make_ladder().items[-1] == "hate"
wl = WordLadder("data", "code", valid_words[len("data")])
assert len(wl.make_ladder().items) == 5
wl = WordLadder("angel", "devil", valid_words[len("angel")])
assert "anger" in wl.make_ladder().items
def test_find_path_if_words_are_defined_at_instance_declaration_time(self):
word_ladder = WordLadder(
os.path.join(word_lists_dir, 'word_lists',
'linux_english_words_length_4'), 'sail', 'fear')
eq_(word_ladder.find_path(),
['sail', 'hail', 'hair', 'heir', 'hear', 'fear'])
