def test_get_bottom_node_single_char(self):
"""Input fragement is a single character.
"""
fragment = 'a'
correct_answer = auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 0)
output = auto.get_bottom_node(fragment, self.abc_memory)
self.assertEqual(output, correct_answer)
def setUp(self):
self.abc_memory = {
'a':
auto.MemoryNode(
{
'b': # memory of the word abc
auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)
},
0)
}
def test_memorize_same_prefix(self):
"""Tests memorize function when a word is passed that is a prefix of a
word already in the memory.
"""
word = 'ab'
correct_answer = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 1)}, 0)
}
output = auto.memorize(self.abc_memory, word)
self.assertEqual(output, correct_answer)
def test_get_candidates_one_good_bottom(self):
"""One good candidate at bottom level of memmory.
"""
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 2)}, 0)}, 0)
}
fragment = 'prefix'
correct_answer = [cand.Candidate('prefixabc', 2)]
output = auto.get_candidates(fragment, memory)
self.assertEqual(output, correct_answer)
def test_get_candidates_none(self):
"""No good candidates in memory.
"""
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 0)}, 0)}, 0)
}
fragment = 'a'
correct_answer = []
output = auto.get_candidates(fragment, memory)
self.assertEqual(output, correct_answer)
def test_memorize_non_empty_memory(self):
"""Tests memorize function when memory already exists.
"""
word = 'adc'
correct_answer = {
'a':
auto.MemoryNode(
{
'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0),
'd': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)
}, 0)
}
output = auto.memorize(self.abc_memory, word)
self.assertEqual(output, correct_answer)
def test_getWords_no_candidates(self):
"""No good candidates in memory for passed fragment.
"""
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 0)
}
fragment = 'ad'
correct_answer = []
alg = auto.AutocompleteProvider()
alg.memory = memory
output = alg.getWords(fragment)
self.assertEqual(output, correct_answer)
def test_getWords_not_all_good_candidates(self):
"""Given the fragment and memory, getWords should not return every
candidate with a postive confidence in memory.
"""
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 1)
}
fragment = 'aB' # contains uppercase
correct_answer = [cand.Candidate('abc', 1)]
alg = auto.AutocompleteProvider()
alg.memory = memory
output = alg.getWords(fragment)
self.assertEqual(output, correct_answer)
def test_get_candidates_two_good_diff_lvl(self):
"""Two good candidates at different levels of memmory.
"""
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 2)
}
fragment = 'prefix'
correct_answer = [
cand.Candidate('prefixa', 2),
cand.Candidate('prefixabc', 1)
]
output = auto.get_candidates(fragment, memory)
self.assertEqual(output, correct_answer)
def test_get_bottom_node_bottom(self):
"""Input fragement should return a node at the bottom of memory.
"""
fragment = 'abc'
correct_answer = auto.MemoryNode({}, 1)
output = auto.get_bottom_node(fragment, self.abc_memory)
self.assertEqual(output, correct_answer)
def test_train_has_memory(self):
"""Test the train method when there are previous memories.
"""
passage = 'ab abc abd'
memory = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 0)
}
correct_answer = {
'a':
auto.MemoryNode(
{
'b':
auto.MemoryNode(
{
'c': auto.MemoryNode({}, 2),
'd': auto.MemoryNode({}, 1)
}, 1)
}, 0)
}
algorithm = auto.AutocompleteProvider()
algorithm.memory = memory
algorithm.train(passage)
self.assertEqual(algorithm.memory, correct_answer)
def test_get_candidates_diff_branches(self):
"""Two good candidates down different branches of memmory.
"""
memory = {
'a':
auto.MemoryNode(
{
'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0),
'd': auto.MemoryNode({'e': auto.MemoryNode({}, 3)}, 0)
}, 0)
}
fragment = 'prefix'
correct_answer = [
cand.Candidate('prefixabc', 1),
cand.Candidate('prefixade', 3)
]
output = auto.get_candidates(fragment, memory)
self.assertEqual(output, correct_answer)
def test_train_no_memory(self):
"""Tests the train method when there are no previous memories.
"""
passage = 'Abc d-ef' # contains uppercase and special characters
correct_answer = {
'a':
auto.MemoryNode(
{'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0)}, 0),
'd':
auto.MemoryNode(
{'e': auto.MemoryNode({'f': auto.MemoryNode({}, 1)}, 0)}, 0)
}
algorithm = auto.AutocompleteProvider()
algorithm.train(passage)
self.assertEqual(algorithm.memory, correct_answer)
def test_get_bottom_node_branches(self):
"""Input memory has branches and function must choose correct branch.
"""
memory = {
'a':
auto.MemoryNode(
{
'b': auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0),
'd': auto.MemoryNode({'e': auto.MemoryNode({}, 2)}, 0)
}, 0)
}
fragment = 'ade'
correct_answer = auto.MemoryNode({}, 2)
output = auto.get_bottom_node(fragment, memory)
self.assertEqual(output, correct_answer)
def test_getWords_different_branches(self):
"""Two good candidates in different branches.
"""
memory = {
'a':
auto.MemoryNode(
{
'b':
auto.MemoryNode({'c': auto.MemoryNode({}, 1)}, 0),
'd':
auto.MemoryNode(
{
'e': auto.MemoryNode({'f': auto.MemoryNode({}, 2)},
0)
}, 0)
}, 0),
}
fragment = 'a'
correct_answer = [cand.Candidate('adef', 2), cand.Candidate('abc', 1)]
alg = auto.AutocompleteProvider()
alg.memory = memory
output = alg.getWords(fragment)
self.assertEqual(output, correct_answer)
