Python searchpath.SearchPath类代码示例

    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_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_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_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_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_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_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_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 _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_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_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")