| 1 |
import csb.test as test |
| 2 |
|
| 3 |
from csb.bio.sequence import RichSequence, SequenceTypes |
| 4 |
from csb.bio.sequence.alignment import IdentityMatrix, SimilarityMatrix |
| 5 |
from csb.bio.sequence.alignment import GlobalAlignmentAlgorithm, LocalAlignmentAlgorithm, AlignmentResult |
| 6 |
|
| 7 |
|
| 8 |
@test.unit |
| 9 |
class TestIdentityMatrix(test.Case): |
| 10 |
|
| 11 |
def setUp(self): |
| 12 |
|
| 13 |
super(TestIdentityMatrix, self).setUp() |
| 14 |
self.matrix = IdentityMatrix(2, -3) |
| 15 |
|
| 16 |
def testScore(self): |
| 17 |
self.assertEqual(self.matrix.score("a", "a"), 2) |
| 18 |
self.assertEqual(self.matrix.score("a", "b"), -3) |
| 19 |
|
| 20 |
@test.unit |
| 21 |
class TestSimilarityMatrix(test.Case): |
| 22 |
|
| 23 |
def setUp(self): |
| 24 |
|
| 25 |
super(TestSimilarityMatrix, self).setUp() |
| 26 |
self.matrix = SimilarityMatrix(SimilarityMatrix.BLOSUM62) |
| 27 |
|
| 28 |
def testScore(self): |
| 29 |
self.assertEqual(self.matrix.score("A", "A"), 4) |
| 30 |
self.assertEqual(self.matrix.score("A", "R"), -1) |
| 31 |
self.assertEqual(self.matrix.score("R", "A"), -1) |
| 32 |
|
| 33 |
|
| 34 |
@test.unit |
| 35 |
class TestGlobalAlignmentAlgorithm(test.Case): |
| 36 |
|
| 37 |
def setUp(self): |
| 38 |
|
| 39 |
super(TestGlobalAlignmentAlgorithm, self).setUp() |
| 40 |
|
| 41 |
self.seq1 = RichSequence('s1', '', 'CCABBBCBBCABAABCCEAAAAAAAAAAAAFAA', SequenceTypes.Protein) |
| 42 |
self.seq2 = RichSequence('s1', '', 'AZCBBABAABCCEF', SequenceTypes.Protein) |
| 43 |
self.algorithm = GlobalAlignmentAlgorithm(scoring=IdentityMatrix(1, -1), gap=0) |
| 44 |
|
| 45 |
def testAlign(self): |
| 46 |
|
| 47 |
ali = self.algorithm.align(self.seq1, self.seq2) |
| 48 |
|
| 49 |
self.assertEqual(ali.query.sequence, "CCA-BBBCBBCABAABCCEAAAAAAAAAAAAFAA") |
| 50 |
self.assertEqual(ali.subject.sequence, "--AZ---CBB-ABAABCCE------------F--") |
| 51 |
|
| 52 |
self.assertEqual(ali.query.residues[3], self.seq1.residues[3]) |
| 53 |
self.assertTrue(ali.query.residues[3] is self.seq1.residues[3]) |
| 54 |
|
| 55 |
self.assertEqual(ali.qstart, 1) |
| 56 |
self.assertEqual(ali.qend, 33) |
| 57 |
self.assertEqual(ali.start, 1) |
| 58 |
self.assertEqual(ali.end, 14) |
| 59 |
|
| 60 |
self.assertEqual(ali.length, 34) |
| 61 |
self.assertEqual(ali.gaps, 21) |
| 62 |
self.assertEqual(ali.identicals, 13) |
| 63 |
self.assertEqual(ali.identity, 13 / 34.0 ) |
| 64 |
self.assertEqual(ali.score, 13) |
| 65 |
|
| 66 |
def testEmptyAlignment(self): |
| 67 |
|
| 68 |
seq1 = RichSequence('s1', '', 'AAAA', SequenceTypes.Protein) |
| 69 |
seq2 = RichSequence('s2', '', 'BBBB', SequenceTypes.Protein) |
| 70 |
|
| 71 |
ali = self.algorithm.align(seq1, seq2) |
| 72 |
self.assertTrue(ali.is_empty) |
| 73 |
|
| 74 |
@test.unit |
| 75 |
class TestLocalAlignmentAlgorithm(test.Case): |
| 76 |
|
| 77 |
def setUp(self): |
| 78 |
|
| 79 |
super(TestLocalAlignmentAlgorithm, self).setUp() |
| 80 |
|
| 81 |
self.seq1 = RichSequence('s1', '', 'CCABBBCBBCABAABCCEAAAAAAAAAAAAFAA', SequenceTypes.Protein) |
| 82 |
self.seq2 = RichSequence('s1', '', 'AZCBBABAACBCCEF', SequenceTypes.Protein) |
| 83 |
self.algorithm = LocalAlignmentAlgorithm(scoring=IdentityMatrix(1, -1), gap=-1) |
| 84 |
|
| 85 |
def testAlign(self): |
| 86 |
|
| 87 |
ali = self.algorithm.align(self.seq1, self.seq2) |
| 88 |
|
| 89 |
self.assertEqual(ali.query.sequence, "CBBCABAA-BCCE") |
| 90 |
self.assertEqual(ali.subject.sequence, "CBB-ABAACBCCE") |
| 91 |
|
| 92 |
self.assertEqual(ali.qstart, 7) |
| 93 |
self.assertEqual(ali.qend, 18) |
| 94 |
self.assertEqual(ali.start, 3) |
| 95 |
self.assertEqual(ali.end, 14) |
| 96 |
|
| 97 |
self.assertEqual(ali.length, 13) |
| 98 |
self.assertEqual(ali.gaps, 2) |
| 99 |
self.assertEqual(ali.identicals, 11) |
| 100 |
self.assertEqual(ali.identity, 11 / 13.0 ) |
| 101 |
self.assertEqual(ali.score, 9) |
| 102 |
|
| 103 |
def testEmptyAlignment(self): |
| 104 |
|
| 105 |
seq1 = RichSequence('s1', '', 'AAAA', SequenceTypes.Protein) |
| 106 |
seq2 = RichSequence('s2', '', 'BBBB', SequenceTypes.Protein) |
| 107 |
|
| 108 |
ali = self.algorithm.align(seq1, seq2) |
| 109 |
self.assertTrue(ali.is_empty) |
| 110 |
|
| 111 |
|
| 112 |
@test.unit |
| 113 |
class TestAlignmentResult(test.Case): |
| 114 |
|
| 115 |
def setUp(self): |
| 116 |
|
| 117 |
super(TestAlignmentResult, self).setUp() |
| 118 |
|
| 119 |
self.seq1 = RichSequence('s1', '', 'AB-D', SequenceTypes.Protein) |
| 120 |
self.seq2 = RichSequence('s2', '', 'A-CD', SequenceTypes.Protein) |
| 121 |
self.ali = AlignmentResult(5.5, self.seq1, self.seq2, 10, 12, 20, 22) |
| 122 |
|
| 123 |
self.es = RichSequence('s1', '', '') |
| 124 |
self.empty = AlignmentResult(0, self.es, self.es, 0, 0, 0, 0) |
| 125 |
|
| 126 |
def testConstructor(self): |
| 127 |
|
| 128 |
self.assertRaises(ValueError, AlignmentResult, 1, self.es, self.es, 0, 0, 0, 0) |
| 129 |
self.assertRaises(ValueError, AlignmentResult, 0, self.es, self.es, 1, 0, 0, 0) |
| 130 |
self.assertRaises(ValueError, AlignmentResult, 0, self.es, self.es, 0, 1, 0, 0) |
| 131 |
self.assertRaises(ValueError, AlignmentResult, 0, self.es, self.es, 0, 0, 1, 0) |
| 132 |
self.assertRaises(ValueError, AlignmentResult, 0, self.es, self.es, 0, 0, 0, 1) |
| 133 |
|
| 134 |
self.assertRaises(ValueError, AlignmentResult, 1, self.seq1, self.seq2, 0, 0, 0, 0) |
| 135 |
|
| 136 |
def testStr(self): |
| 137 |
|
| 138 |
string = r""" |
| 139 |
10 AB-D 12 |
| 140 |
20 A-CD 22 """.strip("\r\n") |
| 141 |
self.assertEqual(string, str(self.ali)) |
| 142 |
|
| 143 |
def testAlignment(self): |
| 144 |
|
| 145 |
ali = self.ali.alignment() |
| 146 |
self.assertEqual(ali.rows[1].sequence, self.seq1.sequence) |
| 147 |
self.assertEqual(ali.rows[2].sequence, self.seq2.sequence) |
| 148 |
|
| 149 |
def testQuery(self): |
| 150 |
self.assertEqual(self.ali.query.sequence, self.seq1.sequence) |
| 151 |
self.assertEqual(self.ali.query.residues[2], self.seq1.residues[2]) |
| 152 |
self.assertTrue(self.ali.query.residues[2] is self.seq1.residues[2]) |
| 153 |
|
| 154 |
def testSubject(self): |
| 155 |
self.assertEqual(self.ali.subject.sequence, self.seq2.sequence) |
| 156 |
self.assertEqual(self.ali.subject.residues[3], self.seq2.residues[3]) |
| 157 |
self.assertTrue(self.ali.subject.residues[3] is self.seq2.residues[3]) |
| 158 |
|
| 159 |
def testQstart(self): |
| 160 |
self.assertEqual(self.ali.qstart, 10) |
| 161 |
|
| 162 |
def testQend(self): |
| 163 |
self.assertEqual(self.ali.qend, 12) |
| 164 |
|
| 165 |
def testStart(self): |
| 166 |
self.assertEqual(self.ali.start, 20) |
| 167 |
|
| 168 |
def testEnd(self): |
| 169 |
self.assertEqual(self.ali.end, 22) |
| 170 |
|
| 171 |
def testLength(self): |
| 172 |
self.assertEqual(self.ali.length, 4) |
| 173 |
|
| 174 |
def testScore(self): |
| 175 |
self.assertEqual(self.ali.score, 5.5) |
| 176 |
|
| 177 |
def testGaps(self): |
| 178 |
self.assertEqual(self.ali.gaps, 2) |
| 179 |
|
| 180 |
def testIdenticals(self): |
| 181 |
self.assertEqual(self.ali.identicals, 2) |
| 182 |
|
| 183 |
def testIdentity(self): |
| 184 |
self.assertEqual(self.ali.identity, 0.5) |
| 185 |
|
| 186 |
def testIsEmpty(self): |
| 187 |
self.assertFalse(self.ali.is_empty) |
| 188 |
|
| 189 |
es = RichSequence('s1', '', '') |
| 190 |
empty = AlignmentResult(0, es, es, 0, 0, 0, 0) |
| 191 |
self.assertTrue(empty.is_empty) |
| 192 |
|
| 193 |
|
| 194 |
if __name__ == '__main__': |
| 195 |
|
| 196 |
test.Console() |