Esempio n. 1
0
    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")
Esempio n. 2
0
 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))
Esempio n. 3
0
    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, "")
Esempio n. 4
0
    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, "")
Esempio n. 5
0
    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))
Esempio n. 6
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)
Esempio n. 7
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)
Esempio n. 8
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)
Esempio n. 9
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)
Esempio n. 10
0
 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)
Esempio n. 11
0
 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, "")
Esempio n. 12
0
    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)
Esempio n. 13
0
    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)
Esempio n. 14
0
 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)
Esempio n. 15
0
 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)        
Esempio n. 16
0
 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)        
Esempio n. 17
0
 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)
Esempio n. 18
0
    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)
Esempio n. 19
0
    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)
Esempio n. 20
0
 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
Esempio n. 21
0
    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
Esempio n. 22
0
 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])
Esempio n. 23
0
    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])
Esempio n. 24
0
    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)
Esempio n. 25
0
    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)
Esempio n. 26
0
    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)
Esempio n. 27
0
    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))
Esempio n. 28
0
 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)
Esempio n. 29
0
    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)
Esempio n. 30
0
    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)
Esempio n. 31
0
    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)
Esempio n. 32
0
    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")
Esempio n. 33
0
    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, "")
Esempio n. 34
0
    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)
Esempio n. 35
0
    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)
Esempio n. 36
0
    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)
Esempio n. 37
0
    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)
Esempio n. 38
0
    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)            
Esempio n. 39
0
 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)            
Esempio n. 40
0
    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")
Esempio n. 41
0
    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)
Esempio n. 42
0
    def test_value_empty(self):
        """Should return empty string when path is empty"""

        test = SearchPath(SearchPathHelper.alphabets)
        self.assertEquals(test.Value, "")
Esempio n. 43
0
    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")
Esempio n. 44
0
 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)
Esempio n. 45
0
    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)
Esempio n. 46
0
    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)