def setUp(self): """Define a few standard models and motifs""" ile_mod_0 = Module('NNNCUACNNNNN', '(((((..(((((') ile_mod_1 = Module('NNNNNUAUUGGGGNNN', ')))))......)))))') ile_rule_0 = Rule(0, 0, 1, 15, 5) ile_rule_1 = Rule(0, 7, 1, 4, 5) ile_motif = Motif([ile_mod_0, ile_mod_1], \ [ile_rule_0, ile_rule_1]) helices = [PairedRegion('NNN'), PairedRegion('NNNNN')] constants = [ConstantRegion('CUAC'), ConstantRegion('UAUUGGGG')] order = "H0 C0 H1 - H1 C1 H0" ile_model = SequenceModel(order=order, constants=constants, \ helices=helices, composition=BaseFrequency('UCAG')) self.ile_embedder = SequenceEmbedder(length=50, num_to_do=10, \ motif=ile_motif, model=ile_model, composition=BaseFrequency('UCAG')) short_ile_mod_0 = Module('NCUACNN', '(((..((') short_ile_mod_1 = Module('NNUAUUGGGGN', '))......)))') short_ile_rule_0 = Rule(0, 0, 1, 10, 3) short_ile_rule_1 = Rule(0, 5, 1, 1, 2) short_ile_motif = Motif([short_ile_mod_0, short_ile_mod_1], \ [short_ile_rule_0, short_ile_rule_1]) short_helices = [PairedRegion('N'), PairedRegion('NN')] short_constants = [ConstantRegion('CUAC'), ConstantRegion('UAUUGGGG')] short_order = "H0 C0 H1 - H1 C1 H0" short_ile_model = SequenceModel(order=short_order, \ constants=short_constants, \ helices=short_helices, composition=BaseFrequency('UCAG')) self.short_ile_embedder = SequenceEmbedder(length=50, num_to_do=10, \ motif=short_ile_motif, model=short_ile_model, \ composition=BaseFrequency('UCAG'))
class RuleTests_compatibility(TestCase): """Tests to see whether the Rule compatibility code works""" def setUp(self): """Sets up some standard rules""" self.x = Rule(1, 5, 2, 10, 3) self.x_ok = Rule(1, 8, 2, 14, 4) self.x_ok_diff_sequences = Rule(3, 5, 5, 10, 3) self.x_bad_first = Rule(1, 0, 3, 10, 10) self.x_bad_first_2 = Rule(0, 0, 1, 8, 2) self.x_bad_second = Rule(1, 15, 2, 15, 8) self.x_bad_second_2 = Rule(1, 14, 2, 8, 4) def test_is_compatible_ok(self): """Rule.isCompatible should return True if rules don't overlap""" self.assertEqual(self.x.isCompatible(self.x_ok), True) #no return value self.assertEqual(self.x.isCompatible(self.x_ok_diff_sequences), True) #check that it's transitive self.assertEqual(self.x_ok.isCompatible(self.x), True) self.assertEqual(self.x_ok_diff_sequences.isCompatible(self.x), True) def test_is_compatible_bad(self): """Rule.isComaptible should return False if rules overlap""" tests = [ (self.x, self.x_bad_first), (self.x, self.x_bad_first_2), (self.x, self.x_bad_second), (self.x, self.x_bad_second_2), ] for first, second in tests: self.assertEqual(first.isCompatible(second), False) #check that it's transitive self.assertEqual(second.isCompatible(first), False) def test_fits_in_sequence(self): """Rule.fitsInSequence should return True if sequence long enough""" sequences = map('x'.__mul__, range(21)) #0 to 20 copies of 'x' rules = [self.x, self.x_ok, self.x_ok_diff_sequences, self.x_bad_first, self.x_bad_first_2, self.x_bad_second, self.x_bad_second_2] #test a bunch of values for all the rules we have handy for s in sequences: for r in rules: if r.UpstreamPosition + r.Length > len(s): self.assertEqual(r.fitsInSequence(s), False) else: self.assertEqual(r.fitsInSequence(s), True) #test a couple of specific boundary cases #length-1 helix r = Rule(0, 0, 1, 0, 1) self.assertEqual(r.fitsInSequence(''), False) self.assertEqual(r.fitsInSequence('x'), True) self.assertEqual(r.fitsInSequence('xx'), True) #length-2 helix starting one base from the start r = Rule(1, 1, 2, 2, 2) self.assertEqual(r.fitsInSequence(''), False) self.assertEqual(r.fitsInSequence('x'), False) self.assertEqual(r.fitsInSequence('xx'), False) self.assertEqual(r.fitsInSequence('xxx'), True) self.assertEqual(r.fitsInSequence('xxxx'), True)
def setUp(self): """Sets up some standard rules""" self.x = Rule(1, 5, 2, 10, 3) self.x_ok = Rule(1, 8, 2, 14, 4) self.x_ok_diff_sequences = Rule(3, 5, 5, 10, 3) self.x_bad_first = Rule(1, 0, 3, 10, 10) self.x_bad_first_2 = Rule(0, 0, 1, 8, 2) self.x_bad_second = Rule(1, 15, 2, 15, 8) self.x_bad_second_2 = Rule(1, 14, 2, 8, 4)
def test_init_ok_length(self): """Rule should init OK if helix extends to exactly downstream start""" x = Rule(0, 0, 1, 0, 1) self.assertEqual(str(x), \ "Up Seq: 0 Up Pos: 0 Down Seq: 1 Down Pos: 0 Length: 1") #check adjacent bases x = Rule(0, 0, 0, 1, 1) self.assertEqual(str(x), \ "Up Seq: 0 Up Pos: 0 Down Seq: 0 Down Pos: 1 Length: 1") x = Rule(1, 10, 2, 8, 7) #check rule that would cause overlap if motifs weren't different self.assertEqual(str(x), \ "Up Seq: 1 Up Pos: 10 Down Seq: 2 Down Pos: 8 Length: 7")
def test_refresh_primers(self): """Module should appear in correct location with primers""" first_module = Module('AAAAA', '(((((') second_module = Module('UUUUU', ')))))') rule_1 = Rule(0, 0, 1, 4, 5) helix = Motif([first_module, second_module], [rule_1]) model = SequenceModel(constants=[ConstantRegion('AAAAA'), \ ConstantRegion('UUUUU')], order='C0 - C1', \ composition=BaseFrequency('A')) embedder = SequenceEmbedder(length=30, num_to_do=100, \ motif=helix, model=model, composition=BaseFrequency('CG'), \ positions=[3, 6], primer_5 = 'UUU', primer_3 = 'AAA') last = '' for i in range(100): embedder.refresh() curr = str(embedder) self.assertEqual(curr[0:3], 'UUU') self.assertEqual(curr[6:11], 'AAAAA') self.assertEqual(curr[14:19], 'UUUUU') self.assertEqual(curr.count('A'), 8) self.assertEqual(curr.count('U'), 8) self.assertEqual(curr[-3:], 'AAA') self.assertNotEqual(last, curr) last = curr
def test_refresh_specific_position(self): """Should always find the module in the same position if specified""" first_module = Module('AAAAA', '(((((') second_module = Module('UUUUU', ')))))') rule_1 = Rule(0, 0, 1, 4, 5) helix = Motif([first_module, second_module], [rule_1]) model = SequenceModel(constants=[ConstantRegion('AAAAA'), \ ConstantRegion('UUUUU')], order='C0 - C1', \ composition=BaseFrequency('A')) embedder = SequenceEmbedder(length=30, num_to_do=100, \ motif=helix, model=model, composition=BaseFrequency('CG'), \ positions=[3, 6]) last = '' for i in range(100): embedder.refresh() curr = str(embedder) self.assertEqual(curr[3:8], 'AAAAA') self.assertEqual(curr[11:16], 'UUUUU') self.assertEqual(curr.count('A'), 5) self.assertEqual(curr.count('U'), 5) self.assertNotEqual(last, curr) last = curr
def setUp(self): """Defines a few standard motifs""" self.ile_mod_0 = Module('NNNCUACNNNNN', '(((((..(((((') self.ile_mod_1 = Module('NNNNNUAUUGGGGNNN', ')))))......)))))') self.ile_rule_0 = Rule(0, 0, 1, 15, 3) self.ile_rule_1 = Rule(0, 7, 1, 4, 5) self.ile = Motif([self.ile_mod_0, self.ile_mod_1], \ [self.ile_rule_0, self.ile_rule_1]) self.hh_mod_0 = Module('NNNNUNNNNN', '(((((.((((') self.hh_mod_1 = Module('NNNNCUGANGAGNNN', ')))).......((((') self.hh_mod_2 = Module('NNNCGAAANNNN', '))))...)))))') self.hh_rule_0 = Rule(0, 0, 2, 11, 5) self.hh_rule_1 = Rule(0, 6, 1, 3, 4) self.hh_rule_2 = Rule(1, 11, 2, 3, 4) self.hh = Motif([self.hh_mod_0, self.hh_mod_1, self.hh_mod_2], \ [self.hh_rule_0, self.hh_rule_1, self.hh_rule_2]) self.simple_0 = Module('CCCCC', '(((..') self.simple_1 = Module('GGGGG', '..)))') self.simple_r = Rule(0, 0, 1, 4, 3) self.simple = Motif([self.simple_0, self.simple_1], [self.simple_r])
def test_init_conflicting_rules(self): """Motif init should fail if rules overlap""" interferer = Rule(0, 2, 2, 20, 4) self.assertRaises(ValueError, Motif, [self.ile_mod_0, self.ile_mod_1, \ self.ile_mod_0], [self.ile_rule_0, interferer])
def test_init_bad_rule_lengths(self): """Motif init should fail if rules don't match module lengths""" bad_rule = Rule(0, 0, 1, 8, 6) self.assertRaises(ValueError, Motif, [self.simple_0, self.simple_1], \ [bad_rule])
def test_fits_in_sequence(self): """Rule.fitsInSequence should return True if sequence long enough""" sequences = map('x'.__mul__, range(21)) #0 to 20 copies of 'x' rules = [self.x, self.x_ok, self.x_ok_diff_sequences, self.x_bad_first, self.x_bad_first_2, self.x_bad_second, self.x_bad_second_2] #test a bunch of values for all the rules we have handy for s in sequences: for r in rules: if r.UpstreamPosition + r.Length > len(s): self.assertEqual(r.fitsInSequence(s), False) else: self.assertEqual(r.fitsInSequence(s), True) #test a couple of specific boundary cases #length-1 helix r = Rule(0, 0, 1, 0, 1) self.assertEqual(r.fitsInSequence(''), False) self.assertEqual(r.fitsInSequence('x'), True) self.assertEqual(r.fitsInSequence('xx'), True) #length-2 helix starting one base from the start r = Rule(1, 1, 2, 2, 2) self.assertEqual(r.fitsInSequence(''), False) self.assertEqual(r.fitsInSequence('x'), False) self.assertEqual(r.fitsInSequence('xx'), False) self.assertEqual(r.fitsInSequence('xxx'), True) self.assertEqual(r.fitsInSequence('xxxx'), True)
def test_str(self): """Rule str method should give expected results""" x = Rule(1, 10, 2, 8, 7) self.assertEqual(str(x), \ "Up Seq: 1 Up Pos: 10 Down Seq: 2 Down Pos: 8 Length: 7")