def test_generate_correctAlph(self):
"""Should get correct alphabet even if node is popped then readded"""
test_alphs = {
0: "A",
1: "BC",
2: "D",
3: "E",
SearchPath.DEFAULT_KEY: "X"
}
forbidden_seqs = ["CD"]
test = SearchPath(test_alphs, forbidden_seqs)
#given these position alphabets and this forbidden seq,
#the only legal 3-node searchpath should be ABD. Make
#a hundred searchpaths and make sure this is the only one
#that actually shows up.
found_paths = {}
for i in xrange(100):
curr_path = test.generate(3)
found_paths[curr_path] = True
test.clearNodes()
#next
#make sure there is only one path found and that it is the right one
found_path_str = str("".join(found_paths.keys()))
self.assertEquals(len(found_paths), 1)
self.assertEquals(found_path_str, "ABD")
def test_get_alphabet_default(self):
"""Should return default alphabet if none defined for position"""
#SearchPathHelper.alphabets has only a default entry
test = SearchPath(SearchPathHelper.alphabets)
real_alph = test._get_alphabet(0)
correct_alph = SearchPathHelper.alphabets[SearchPath.DEFAULT_KEY]
self.assertEquals(str(real_alph), str(correct_alph))
def test_get_nmer_len0(self):
"""get_nmer should return an empty string if n is 0"""
#if n is zero, this should return "" even when stack is empty
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
real_result = test_path._get_nmer(0)
self.assertEquals(real_result, "")
def test_get_nmer_len0(self):
"""get_nmer should return an empty string if n is 0"""
#if n is zero, this should return "" even when stack is empty
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
real_result = test_path._get_nmer(0)
self.assertEquals(real_result, "")
def test_get_alphabet_default(self):
"""Should return default alphabet if none defined for position"""
#SearchPathHelper.alphabets has only a default entry
test = SearchPath(SearchPathHelper.alphabets)
real_alph = test._get_alphabet(0)
correct_alph = SearchPathHelper.alphabets[SearchPath.DEFAULT_KEY]
self.assertEquals(str(real_alph), str(correct_alph))
def test_add_node_first(self):
"""add_node should correctly add first node and increase top index."""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test._add_node(test_node)
self.assertEquals(len(test._path_stack), 1)
self.assertEquals(test._top_index, 0)
def test_add_node_first(self):
"""add_node should correctly add first node and increase top index."""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test._add_node(test_node)
self.assertEquals(len(test._path_stack), 1)
self.assertEquals(test._top_index, 0)
def test_findAllowedOption_currentAllowed(self):
"""Should return true when current option is allowed"""
#searchpath with no forbidden seqs, so anything should work
test = SearchPath(SearchPathHelper.alphabets)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
allowed_found = test.findAllowedOption()
self.assertEquals(allowed_found, True)
def test_findAllowedOption_currentAllowed(self):
"""Should return true when current option is allowed"""
#searchpath with no forbidden seqs, so anything should work
test = SearchPath(SearchPathHelper.alphabets)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
allowed_found = test.findAllowedOption()
self.assertEquals(allowed_found, True)
def test_get_nmer_len1(self):
"""get_nmer should return correct result for nmer 1 on full stack"""
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(test_node)
correct_result = test_node.Value
real_result = test_path._get_nmer(1)
self.assertEquals(real_result, correct_result)
def test_clearNodes(self):
"""Should empty path stack and variable forbidden"""
#create a searchpath and add just one node
test = SearchPath(SearchPathHelper.alphabets)
test.generate(1)
#now call clear and make sure path value is "" (empty)
test.clearNodes()
self.assertEquals(test.Value, "")
def test_get_nmer_len1(self):
"""get_nmer should return correct result for nmer 1 on full stack"""
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(test_node)
correct_result = test_node.Value
real_result = test_path._get_nmer(1)
self.assertEquals(real_result, correct_result)
def test_get_alphabet_exists(self):
"""Should return alphabet for position when one exists"""
alph1 = "G"
alph2 = "ACGT"
test_alphs = {0: alph1, 2: alph1, SearchPath.DEFAULT_KEY: alph2}
test = SearchPath(test_alphs)
real_alph = test._get_alphabet(2)
self.assertEquals(str(real_alph), alph1)
def test_get_alphabet_exists(self):
"""Should return alphabet for position when one exists"""
alph1 = "G"
alph2 = "ACGT"
test_alphs = {0:alph1, 2:alph1, SearchPath.DEFAULT_KEY:alph2}
test = SearchPath(test_alphs)
real_alph = test._get_alphabet(2)
self.assertEquals(str(real_alph), alph1)
def test_get_nmer_tooLong(self):
"""get_nmer should return None for n > length of stack"""
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(test_node)
#stack is 1 long. Ask for a 2 mer
real_result = test_path._get_nmer(2)
self.assertEquals(real_result, None)
def test_add_node_subsequent(self):
"""add_node should correctly add additional nodes and up top index."""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_node2 = SearchNode(SearchNodeHelper.alphabet)
test._add_node(test_node)
test._add_node(test_node2)
self.assertEquals(len(test._path_stack), 2)
self.assertEquals(test._top_index, 1)
def test_generate_nonePossible(self):
"""Should return null if no path can match constraints"""
alphabet = {SearchPath.DEFAULT_KEY:"AB"}
#forbid all combinations of alphabet
forbidden_seqs = ["AA", "AB", "BB", "BA"]
test = SearchPath(alphabet, forbidden_seqs)
output = test.generate(2)
self.assertEquals(output, None)
def test_get_nmer_tooLong(self):
"""get_nmer should return None for n > length of stack"""
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(test_node)
#stack is 1 long. Ask for a 2 mer
real_result = test_path._get_nmer(2)
self.assertEquals(real_result, None)
def test_generate_nonePossible(self):
"""Should return null if no path can match constraints"""
alphabet = {SearchPath.DEFAULT_KEY: "AB"}
#forbid all combinations of alphabet
forbidden_seqs = ["AA", "AB", "BB", "BA"]
test = SearchPath(alphabet, forbidden_seqs)
output = test.generate(2)
self.assertEquals(output, None)
def _fill_path(self, num_nodes, node_vals = []):
"""create a searchpath and add searchnodes; return path"""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
for i in xrange(num_nodes):
curr_node = SearchNode(SearchNodeHelper.alphabet)
node_vals.append(curr_node.Value)
test._add_node(curr_node)
#next i
return test
def _fill_path(self, num_nodes, node_vals=[]):
"""create a searchpath and add searchnodes; return path"""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
for i in xrange(num_nodes):
curr_node = SearchNode(SearchNodeHelper.alphabet)
node_vals.append(curr_node.Value)
test._add_node(curr_node)
#next i
return test
def test_generate_multiple(self):
"""Should be able to call generate multiple times to extend path"""
test = SearchPath(SearchPathHelper.alphabets)
output1 = test.generate(2)
output2 = test.generate(3)
#make sure that the length of the path is now three
self.assertEquals(len(output2), 3)
#make sure that the new path is a superset of the old one
self.assertEquals(output1, output2[:2])
def test_generate_multiple(self):
"""Should be able to call generate multiple times to extend path"""
test = SearchPath(SearchPathHelper.alphabets)
output1 = test.generate(2)
output2 = test.generate(3)
#make sure that the length of the path is now three
self.assertEquals(len(output2), 3)
#make sure that the new path is a superset of the old one
self.assertEquals(output1, output2[:2])
def test_get_forbidden_lengths(self):
"""get_forbidden_lengths should return dict of forbidden seq lens"""
correct_result = str([3, 4, 9])
user_input = SearchPathHelper.standard_forbid_seq[:]
user_input.extend(["AUG", "aaaaccuag"])
test = SearchPath(SearchPathHelper.alphabets, user_input)
real_dict = test._get_forbidden_lengths()
real_list = real_dict.keys()
real_list.sort()
real_result = str(real_list)
self.assertEquals(real_result, correct_result)
def test_get_forbidden_lengths(self):
"""get_forbidden_lengths should return dict of forbidden seq lens"""
correct_result = str([3, 4, 9])
user_input = SearchPathHelper.standard_forbid_seq[:]
user_input.extend(["AUG", "aaaaccuag"])
test = SearchPath(SearchPathHelper.alphabets, user_input)
real_dict = test._get_forbidden_lengths()
real_list = real_dict.keys()
real_list.sort()
real_result = str(real_list)
self.assertEquals(real_result, correct_result)
def test_get_nmer(self):
"""get_nmer should return correct nmer for n <= length of stack"""
node_values = []
n = 4
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
for i in xrange(n + 1):
curr_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(curr_node)
node_values.append(curr_node.Value)
#next
#get a nmer, and get the last n values that were put on stack;
#should be the same
real_result = test_path._get_nmer(n)
correct_result = "".join(node_values[-n:])
self.assertEquals(real_result, correct_result)
def test_init_withForbid(self):
"""Init should correctly set private properties, w/forbid list"""
user_input = SearchPathHelper.standard_forbid_seq[:]
user_input.extend(["AUG", "aaaaccuag"])
test = SearchPath(SearchPathHelper.alphabets, user_input)
user_input = [i.upper() for i in user_input]
user_input.sort()
real_result = test._fixed_forbidden.keys()
real_result.sort()
self.assertEquals(str(real_result), str(user_input))
def test_get_nmer(self):
"""get_nmer should return correct nmer for n <= length of stack"""
node_values = []
n = 4
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
for i in xrange(n+1):
curr_node = SearchNode(SearchNodeHelper.alphabet)
test_path._add_node(curr_node)
node_values.append(curr_node.Value)
#next
#get a nmer, and get the last n values that were put on stack;
#should be the same
real_result = test_path._get_nmer(n)
correct_result = "".join(node_values[-n:])
self.assertEquals(real_result, correct_result)
def test_generate_fullCoverage(self):
"""With no constraints, should produce all possible triplets"""
path_length = 20
test = SearchPath(SearchPathHelper.alphabets)
#make a hundred random searchpaths and see what triplets produced
found_triplets = self.tripletGenerator(test, path_length)
num_found = len(found_triplets.keys())
self.assertEquals(num_found, 64)
def test_get_top(self):
"""Should return a reference to top node on stack if there is one"""
test = SearchPath(SearchPathHelper.alphabets)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
topnode = SearchNode(SearchNodeHelper.alphabet)
test._add_node(topnode)
resultnode = test._get_top()
self.assertEquals(resultnode, topnode)
def test_generate_withForbidden(self):
"""With 2 triplet constraints, should produce all others"""
forbidden_triplet = ["ATG", "CCT"]
path_length = 20
test = SearchPath(SearchPathHelper.alphabets, forbidden_triplet)
#make a hundred random searchpaths and see what triplets produced
found_triplets = self.tripletGenerator(test, path_length)
num_found = len(found_triplets.keys())
self.assertEquals(num_found, 62)
def test_generate_correctAlph(self):
"""Should get correct alphabet even if node is popped then readded"""
test_alphs = {0:"A",1:"BC",2:"D",3:"E",SearchPath.DEFAULT_KEY:"X"}
forbidden_seqs = ["CD"]
test = SearchPath(test_alphs, forbidden_seqs)
#given these position alphabets and this forbidden seq,
#the only legal 3-node searchpath should be ABD. Make
#a hundred searchpaths and make sure this is the only one
#that actually shows up.
found_paths = {}
for i in xrange(100):
curr_path = test.generate(3)
found_paths[curr_path] = True
test.clearNodes()
#next
#make sure there is only one path found and that it is the right one
found_path_str = str("".join(found_paths.keys()))
self.assertEquals(len(found_paths), 1)
self.assertEquals(found_path_str, "ABD")
def test_clearNodes(self):
"""Should empty path stack and variable forbidden"""
#create a searchpath and add just one node
test = SearchPath(SearchPathHelper.alphabets)
test.generate(1)
#now call clear and make sure path value is "" (empty)
test.clearNodes()
self.assertEquals(test.Value, "")
def test_get_top(self):
"""Should return a reference to top node on stack if there is one"""
test = SearchPath(SearchPathHelper.alphabets)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
topnode = SearchNode(SearchNodeHelper.alphabet)
test._add_node(topnode)
resultnode = test._get_top()
self.assertEquals(resultnode, topnode)
def test_add_node_subsequent(self):
"""add_node should correctly add additional nodes and up top index."""
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test_node = SearchNode(SearchNodeHelper.alphabet)
test_node2 = SearchNode(SearchNodeHelper.alphabet)
test._add_node(test_node)
test._add_node(test_node2)
self.assertEquals(len(test._path_stack), 2)
self.assertEquals(test._top_index, 1)
def test_check_forbidden_seqs_none(self):
"""Should return False if path includes no forbidden seqs"""
#a seq that isn't in the standard fixed forbidden lib
allowed_seq = ["C", "U", "A", "T"]
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
#add more values, and cheat so as to make them something known
for known_val in allowed_seq:
curr_node = SearchNode(SearchNodeHelper.alphabet)
curr_node._options[0] = known_val #torque the node's innards
test._add_node(curr_node)
#next bad_val
real_result = test._check_forbidden_seqs()
self.assertEquals(real_result, False)
def test_check_forbidden_seqs_fixed(self):
"""Should return True if path includes a fixed forbidden seq"""
forbidden_seq = ["G", "U", "A"]
user_input = ["".join(forbidden_seq)]
user_input.extend(SearchPathHelper.standard_forbid_seq)
test = SearchPath(SearchPathHelper.alphabets, user_input)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
#add more values, and cheat so as to make them something forbidden
for bad_val in forbidden_seq:
curr_node = SearchNode(SearchNodeHelper.alphabet)
curr_node._options[0] = bad_val #torque the node's innards
test._add_node(curr_node)
#next bad_val
real_result = test._check_forbidden_seqs()
self.assertEquals(real_result, True)
def test_check_forbidden_seqs_none(self):
"""Should return False if path includes no forbidden seqs"""
#a seq that isn't in the standard fixed forbidden lib
allowed_seq = ["C", "U", "A", "T"]
test = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
#add more values, and cheat so as to make them something known
for known_val in allowed_seq:
curr_node = SearchNode(SearchNodeHelper.alphabet)
curr_node._options[0] = known_val #torque the node's innards
test._add_node(curr_node)
#next bad_val
real_result = test._check_forbidden_seqs()
self.assertEquals(real_result, False)
def test_check_forbidden_seqs_fixed(self):
"""Should return True if path includes a fixed forbidden seq"""
forbidden_seq = ["G", "U", "A"]
user_input = ["".join(forbidden_seq)]
user_input.extend(SearchPathHelper.standard_forbid_seq)
test = SearchPath(SearchPathHelper.alphabets, user_input)
test._add_node(SearchNode(SearchNodeHelper.alphabet))
#add more values, and cheat so as to make them something forbidden
for bad_val in forbidden_seq:
curr_node = SearchNode(SearchNodeHelper.alphabet)
curr_node._options[0] = bad_val #torque the node's innards
test._add_node(curr_node)
#next bad_val
real_result = test._check_forbidden_seqs()
self.assertEquals(real_result, True)
def test_get_alphabet_badPosition(self):
"""Should raise error if input isn't castable to nonneg int"""
test = SearchPath(SearchPathHelper.alphabets)
self.assertRaises(NonnegIntError, test._get_alphabet, "blue")
def test_init_noForbid(self):
"""Init should correctly set private properties w/o forbid list"""
test = SearchPath(SearchPathHelper.alphabets)
real_result = len(test._fixed_forbidden.keys())
self.assertEquals(real_result, 0)
def test_value_empty(self):
"""Should return empty string when path is empty"""
test = SearchPath(SearchPathHelper.alphabets)
self.assertEquals(test.Value, "")
def test_get_nmer_badArg(self):
"""get_nmer should error if given a non integer-castable n"""
test_path = SearchPath(SearchPathHelper.alphabets, \
SearchPathHelper.standard_forbid_seq)
self.assertRaises(NonnegIntError, test_path._get_nmer, "blue")
def test_get_top_None(self):
"""Should return None if stack is empty"""
test = SearchPath(SearchPathHelper.alphabets)
topnode = test._get_top()
self.assertEquals(topnode, None)
def test_top_index_None(self):
"""Should return None when stack has no entries"""
test = SearchPath(SearchPathHelper.alphabets)
top_index = test._top_index
self.assertEquals(top_index, None)
def test_get_top_None(self):
"""Should return None if stack is empty"""
test = SearchPath(SearchPathHelper.alphabets)
topnode = test._get_top()
self.assertEquals(topnode, None)