Clover icon

jalviewX

  1. Project Clover database Wed Oct 31 2018 15:13:58 GMT
  2. Package jalview.analysis.scoremodels

File ScoreMatrixTest.java

 

Code metrics

18
233
23
1
588
416
33
0.14
10.13
23
1.43

Classes

Class Line # Actions
ScoreMatrixTest 25 233 33 0
1.0100%
 

Contributing tests

This file is covered by 21 tests. .

Source view

1    package jalview.analysis.scoremodels;
2   
3    import static org.testng.Assert.assertEquals;
4    import static org.testng.Assert.assertFalse;
5    import static org.testng.Assert.assertNotEquals;
6    import static org.testng.Assert.assertNotNull;
7    import static org.testng.Assert.assertNotSame;
8    import static org.testng.Assert.assertNull;
9    import static org.testng.Assert.assertTrue;
10    import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;
11   
12    import jalview.api.analysis.SimilarityParamsI;
13    import jalview.io.DataSourceType;
14    import jalview.io.FileParse;
15    import jalview.io.ScoreMatrixFile;
16    import jalview.math.MatrixI;
17    import jalview.schemes.ResidueProperties;
18   
19    import java.io.IOException;
20    import java.net.MalformedURLException;
21    import java.util.Arrays;
22   
23    import org.testng.annotations.Test;
24   
 
25    public class ScoreMatrixTest
26    {
 
27  1 toggle @Test(groups = "Functional")
28    public void testConstructor()
29    {
30    // note score matrix does not have to be symmetric (though it should be!)
31  1 float[][] scores = new float[3][];
32  1 scores[0] = new float[] { 1f, 2f, 3f };
33  1 scores[1] = new float[] { -4f, 5f, 6f };
34  1 scores[2] = new float[] { 7f, 8f, 9f };
35  1 ScoreMatrix sm = new ScoreMatrix("Test", "ABC".toCharArray(), scores);
36  1 assertEquals(sm.getSize(), 3);
37  1 assertArrayEquals(scores, sm.getMatrix());
38  1 assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
39  1 assertEquals(sm.getPairwiseScore('b', 'c'), 6f);
40  1 assertEquals(sm.getPairwiseScore('c', 'b'), 8f);
41  1 assertEquals(sm.getMatrixIndex('c'), 2);
42  1 assertEquals(sm.getMatrixIndex(' '), -1);
43   
44    // substitution to or from unknown symbol gets minimum score
45  1 assertEquals(sm.getPairwiseScore('A', 'D'), -4f);
46  1 assertEquals(sm.getPairwiseScore('D', 'A'), -4f);
47    // unknown-to-self gets a score of 1
48  1 assertEquals(sm.getPairwiseScore('D', 'D'), 1f);
49    }
50   
 
51  1 toggle @Test(
52    groups = "Functional",
53    expectedExceptions = { IllegalArgumentException.class })
54    public void testConstructor_matrixTooSmall()
55    {
56  1 float[][] scores = new float[2][];
57  1 scores[0] = new float[] { 1f, 2f };
58  1 scores[1] = new float[] { 3f, 4f };
59  1 new ScoreMatrix("Test", "ABC".toCharArray(), scores);
60    }
61   
 
62  1 toggle @Test(
63    groups = "Functional",
64    expectedExceptions = { IllegalArgumentException.class })
65    public void testConstructor_matrixTooBig()
66    {
67  1 float[][] scores = new float[2][];
68  1 scores[0] = new float[] { 1f, 2f };
69  1 scores[1] = new float[] { 3f, 4f };
70  1 new ScoreMatrix("Test", "A".toCharArray(), scores);
71    }
72   
 
73  1 toggle @Test(
74    groups = "Functional",
75    expectedExceptions = { IllegalArgumentException.class })
76    public void testConstructor_matrixNotSquare()
77    {
78  1 float[][] scores = new float[2][];
79  1 scores[0] = new float[] { 1f, 2f };
80  1 scores[1] = new float[] { 3f };
81  1 new ScoreMatrix("Test", "AB".toCharArray(), scores);
82    }
83   
 
84  1 toggle @Test(groups = "Functional")
85    public void testBuildSymbolIndex()
86    {
87  1 float[][] scores = new float[2][];
88  1 scores[0] = new float[] { 1f, 2f };
89  1 scores[1] = new float[] { 3f, 4f };
90  1 ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '.' },
91    scores);
92  1 short[] index = sm.buildSymbolIndex("AX-yxYp".toCharArray());
93   
94  1 assertEquals(index.length, 128); // ASCII character set size
95   
96  1 assertEquals(index['A'], 0);
97  1 assertEquals(index['a'], 0); // lower-case mapping added
98  1 assertEquals(index['X'], 1);
99  1 assertEquals(index['-'], 2);
100  1 assertEquals(index['y'], 3); // lower-case override
101  1 assertEquals(index['x'], 4); // lower-case override
102  1 assertEquals(index['Y'], 5);
103  1 assertEquals(index['p'], 6);
104  1 assertEquals(index['P'], -1); // lower-case doesn't map upper-case
105   
106    /*
107    * check all unmapped symbols have index for unmapped
108    */
109  129 for (int c = 0; c < index.length; c++)
110    {
111  128 if (!"AaXx-. Yyp".contains(String.valueOf((char) c)))
112    {
113  118 assertEquals(index[c], -1);
114    }
115    }
116    }
117   
118    /**
119    * check that characters not in the basic ASCII set are simply ignored
120    */
 
121  1 toggle @Test(groups = "Functional")
122    public void testBuildSymbolIndex_nonAscii()
123    {
124  1 float[][] scores = new float[2][];
125  1 scores[0] = new float[] { 1f, 2f };
126  1 scores[1] = new float[] { 3f, 4f };
127  1 ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '.' },
128    scores);
129  1 char[] weird = new char[] { 128, 245, 'P' };
130  1 short[] index = sm.buildSymbolIndex(weird);
131  1 assertEquals(index.length, 128);
132  1 assertEquals(index['P'], 2);
133  1 assertEquals(index['p'], 2);
134  129 for (int c = 0; c < index.length; c++)
135    {
136  128 if (c != 'P' && c != 'p')
137    {
138  126 assertEquals(index[c], -1);
139    }
140    }
141    }
142   
 
143  1 toggle @Test(groups = "Functional")
144    public void testGetMatrix()
145    {
146  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
147  1 float[][] m = sm.getMatrix();
148  1 assertEquals(m.length, sm.getSize());
149  1 assertEquals(m[2][4], -3f);
150    // verify a defensive copy is returned
151  1 float[][] m2 = sm.getMatrix();
152  1 assertNotSame(m, m2);
153  1 assertTrue(Arrays.deepEquals(m, m2));
154    }
155   
 
156  1 toggle @Test(groups = "Functional")
157    public void testGetMatrixIndex()
158    {
159  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
160  1 assertEquals(sm.getMatrixIndex('A'), 0);
161  1 assertEquals(sm.getMatrixIndex('R'), 1);
162  1 assertEquals(sm.getMatrixIndex('r'), 1);
163  1 assertEquals(sm.getMatrixIndex('N'), 2);
164  1 assertEquals(sm.getMatrixIndex('D'), 3);
165  1 assertEquals(sm.getMatrixIndex('X'), 22);
166  1 assertEquals(sm.getMatrixIndex('x'), 22);
167  1 assertEquals(sm.getMatrixIndex('-'), -1);
168  1 assertEquals(sm.getMatrixIndex('*'), 23);
169  1 assertEquals(sm.getMatrixIndex('.'), -1);
170  1 assertEquals(sm.getMatrixIndex(' '), -1);
171  1 assertEquals(sm.getMatrixIndex('?'), -1);
172  1 assertEquals(sm.getMatrixIndex((char) 128), -1);
173    }
174   
 
175  1 toggle @Test(groups = "Functional")
176    public void testGetSize()
177    {
178  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
179  1 assertEquals(sm.getMatrix().length, sm.getSize());
180    }
181   
 
182  1 toggle @Test(groups = "Functional")
183    public void testComputePairwiseScores()
184    {
185    /*
186    * NB score matrix expects '-' for gap
187    */
188  1 String[] seqs = new String[] { "FKL", "R-D", "QIA", "GWC" };
189  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
190   
191  1 MatrixI pairwise = sm.findSimilarities(seqs, SimilarityParams.Jalview);
192   
193    /*
194    * should be NxN where N = number of sequences
195    */
196  1 assertEquals(pairwise.height(), 4);
197  1 assertEquals(pairwise.width(), 4);
198   
199    /*
200    * should be symmetrical (because BLOSUM62 is)
201    */
202  5 for (int i = 0; i < pairwise.height(); i++)
203    {
204  10 for (int j = i + 1; j < pairwise.width(); j++)
205    {
206  6 assertEquals(pairwise.getValue(i, j), pairwise.getValue(j, i),
207    String.format("Not symmetric at [%d, %d]", i, j));
208    }
209    }
210    /*
211    * verify expected BLOSUM dot product scores
212    */
213    // F.F + K.K + L.L = 6 + 5 + 4 = 15
214  1 assertEquals(pairwise.getValue(0, 0), 15d);
215    // R.R + -.- + D.D = 5 + 1 + 6 = 12
216  1 assertEquals(pairwise.getValue(1, 1), 12d);
217    // Q.Q + I.I + A.A = 5 + 4 + 4 = 13
218  1 assertEquals(pairwise.getValue(2, 2), 13d);
219    // G.G + W.W + C.C = 6 + 11 + 9 = 26
220  1 assertEquals(pairwise.getValue(3, 3), 26d);
221    // F.R + K.- + L.D = -3 + -4 + -4 = -11
222  1 assertEquals(pairwise.getValue(0, 1), -11d);
223    // F.Q + K.I + L.A = -3 + -3 + -1 = -7
224  1 assertEquals(pairwise.getValue(0, 2), -7d);
225    // F.G + K.W + L.C = -3 + -3 + -1 = -7
226  1 assertEquals(pairwise.getValue(0, 3), -7d);
227    // R.Q + -.I + D.A = 1 + -4 + -2 = -5
228  1 assertEquals(pairwise.getValue(1, 2), -5d);
229    // R.G + -.W + D.C = -2 + -4 + -3 = -9
230  1 assertEquals(pairwise.getValue(1, 3), -9d);
231    // Q.G + I.W + A.C = -2 + -3 + 0 = -5
232  1 assertEquals(pairwise.getValue(2, 3), -5d);
233    }
234   
235    /**
236    * Test that the result of outputMatrix can be reparsed to give an identical
237    * ScoreMatrix
238    *
239    * @throws IOException
240    * @throws MalformedURLException
241    */
 
242  1 toggle @Test(groups = "Functional")
243    public void testOutputMatrix_roundTrip() throws MalformedURLException,
244    IOException
245    {
246  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
247  1 String output = sm.outputMatrix(false);
248  1 FileParse fp = new FileParse(output, DataSourceType.PASTE);
249  1 ScoreMatrixFile parser = new ScoreMatrixFile(fp);
250  1 ScoreMatrix sm2 = parser.parseMatrix();
251  1 assertNotNull(sm2);
252  1 assertTrue(sm2.equals(sm));
253    }
254   
 
255  1 toggle @Test(groups = "Functional")
256    public void testEqualsAndHashCode()
257    {
258  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
259  1 ScoreMatrix sm2 = new ScoreMatrix(sm.getName(), sm.getSymbols()
260    .toCharArray(), sm.getMatrix());
261  1 assertTrue(sm.equals(sm2));
262  1 assertEquals(sm.hashCode(), sm2.hashCode());
263   
264  1 sm2 = ScoreModels.getInstance().getPam250();
265  1 assertFalse(sm.equals(sm2));
266  1 assertNotEquals(sm.hashCode(), sm2.hashCode());
267   
268  1 assertFalse(sm.equals("hello"));
269    }
270   
271    /**
272    * Tests for scoring options where the longer length of two sequences is used
273    */
 
274  1 toggle @Test(groups = "Functional")
275    public void testcomputeSimilarity_matchLongestSequence()
276    {
277    /*
278    * ScoreMatrix expects '-' for gaps
279    */
280  1 String s1 = "FR-K-S";
281  1 String s2 = "FS--L";
282  1 ScoreMatrix blosum = ScoreModels.getInstance().getBlosum62();
283   
284    /*
285    * score gap-gap and gap-char
286    * shorter sequence treated as if with trailing gaps
287    * score = F^F + R^S + -^- + K^- + -^L + S^-
288    * = 6 + -1 + 1 + -4 + -4 + -4 = -6
289    */
290  1 SimilarityParamsI params = new SimilarityParams(true, true, true, false);
291  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -6d);
292    // matchGap (arg2) is ignored:
293  1 params = new SimilarityParams(true, false, true, false);
294  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -6d);
295   
296    /*
297    * score gap-char but not gap-gap
298    * score = F^F + R^S + 0 + K^- + -^L + S^-
299    * = 6 + -1 + 0 + -4 + -4 + -4 = -7
300    */
301  1 params = new SimilarityParams(false, true, true, false);
302  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -7d);
303    // matchGap (arg2) is ignored:
304  1 params = new SimilarityParams(false, false, true, false);
305  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -7d);
306   
307    /*
308    * score gap-gap but not gap-char
309    * score = F^F + R^S + -^- + 0 + 0 + 0
310    * = 6 + -1 + 1 = 6
311    */
312  1 params = new SimilarityParams(true, false, false, false);
313  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
314    // matchGap (arg2) is ignored:
315  1 params = new SimilarityParams(true, true, false, false);
316  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
317   
318    /*
319    * score neither gap-gap nor gap-char
320    * score = F^F + R^S + 0 + 0 + 0 + 0
321    * = 6 + -1 = 5
322    */
323  1 params = new SimilarityParams(false, false, false, false);
324  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
325    // matchGap (arg2) is ignored:
326  1 params = new SimilarityParams(false, true, false, false);
327  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
328    }
329   
330    /**
331    * Tests for scoring options where only the shorter length of two sequences is
332    * used
333    */
 
334  1 toggle @Test(groups = "Functional")
335    public void testcomputeSimilarity_matchShortestSequence()
336    {
337    /*
338    * ScoreMatrix expects '-' for gaps
339    */
340  1 String s1 = "FR-K-S";
341  1 String s2 = "FS--L";
342  1 ScoreMatrix blosum = ScoreModels.getInstance().getBlosum62();
343   
344    /*
345    * score gap-gap and gap-char
346    * match shorter sequence only
347    * score = F^F + R^S + -^- + K^- + -^L
348    * = 6 + -1 + 1 + -4 + -4 = -2
349    */
350  1 SimilarityParamsI params = new SimilarityParams(true, true, true, true);
351  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -2d);
352    // matchGap (arg2) is ignored:
353  1 params = new SimilarityParams(true, false, true, true);
354  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -2d);
355   
356    /*
357    * score gap-char but not gap-gap
358    * score = F^F + R^S + 0 + K^- + -^L
359    * = 6 + -1 + 0 + -4 + -4 = -3
360    */
361  1 params = new SimilarityParams(false, true, true, true);
362  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -3d);
363    // matchGap (arg2) is ignored:
364  1 params = new SimilarityParams(false, false, true, true);
365  1 assertEquals(blosum.computeSimilarity(s1, s2, params), -3d);
366   
367    /*
368    * score gap-gap but not gap-char
369    * score = F^F + R^S + -^- + 0 + 0
370    * = 6 + -1 + 1 = 6
371    */
372  1 params = new SimilarityParams(true, false, false, true);
373  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
374    // matchGap (arg2) is ignored:
375  1 params = new SimilarityParams(true, true, false, true);
376  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
377   
378    /*
379    * score neither gap-gap nor gap-char
380    * score = F^F + R^S + 0 + 0 + 0
381    * = 6 + -1 = 5
382    */
383  1 params = new SimilarityParams(false, false, false, true);
384  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
385    // matchGap (arg2) is ignored:
386  1 params = new SimilarityParams(false, true, false, true);
387  1 assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
388    }
389   
 
390  1 toggle @Test(groups = "Functional")
391    public void testSymmetric()
392    {
393  1 verifySymmetric(ScoreModels.getInstance().getBlosum62());
394  1 verifySymmetric(ScoreModels.getInstance().getPam250());
395  1 verifySymmetric(ScoreModels.getInstance().getDefaultModel(false)); // dna
396    }
397   
 
398  3 toggle private void verifySymmetric(ScoreMatrix sm)
399    {
400  3 float[][] m = sm.getMatrix();
401  3 int rows = m.length;
402  62 for (int row = 0; row < rows; row++)
403    {
404  59 assertEquals(m[row].length, rows);
405  1332 for (int col = 0; col < rows; col++)
406    {
407  1273 assertEquals(m[row][col], m[col][row], String.format("%s [%s, %s]",
408    sm.getName(), ResidueProperties.aa[row],
409    ResidueProperties.aa[col]));
410    }
411    }
412    }
413   
414    /**
415    * A test that just asserts the expected values in the Blosum62 score matrix
416    */
 
417  1 toggle @Test(groups = "Functional")
418    public void testBlosum62_values()
419    {
420  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
421   
422  1 assertTrue(sm.isProtein());
423  1 assertFalse(sm.isDNA());
424  1 assertNull(sm.getDescription());
425   
426    /*
427    * verify expected scores against ARNDCQEGHILKMFPSTWYVBZX
428    * scraped from https://www.ncbi.nlm.nih.gov/Class/FieldGuide/BLOSUM62.txt
429    */
430  1 verifyValues(sm, 'A', new float[] { 4, -1, -2, -2, 0, -1, -1, 0, -2,
431    -1,
432    -1, -1, -1, -2, -1, 1, 0, -3, -2, 0, -2, -1, 0 });
433  1 verifyValues(sm, 'R', new float[] { -1, 5, 0, -2, -3, 1, 0, -2, 0, -3,
434    -2, 2, -1, -3, -2, -1, -1, -3, -2, -3, -1, 0, -1 });
435  1 verifyValues(sm, 'N', new float[] { -2, 0, 6, 1, -3, 0, 0, 0, 1, -3,
436    -3,
437    0, -2, -3, -2, 1, 0, -4, -2, -3, 3, 0, -1 });
438  1 verifyValues(sm, 'D', new float[] { -2, -2, 1, 6, -3, 0, 2, -1, -1, -3,
439    -4, -1, -3, -3, -1, 0, -1, -4, -3, -3, 4, 1, -1 });
440  1 verifyValues(sm, 'C', new float[] { 0, -3, -3, -3, 9, -3, -4, -3, -3,
441    -1,
442    -1, -3, -1, -2, -3, -1, -1, -2, -2, -1, -3, -3, -2 });
443  1 verifyValues(sm, 'Q', new float[] { -1, 1, 0, 0, -3, 5, 2, -2, 0, -3,
444    -2,
445    1, 0, -3, -1, 0, -1, -2, -1, -2, 0, 3, -1 });
446  1 verifyValues(sm, 'E', new float[] { -1, 0, 0, 2, -4, 2, 5, -2, 0, -3,
447    -3,
448    1, -2, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1 });
449  1 verifyValues(sm, 'G', new float[] { 0, -2, 0, -1, -3, -2, -2, 6, -2,
450    -4,
451    -4, -2, -3, -3, -2, 0, -2, -2, -3, -3, -1, -2, -1 });
452  1 verifyValues(sm, 'H', new float[] { -2, 0, 1, -1, -3, 0, 0, -2, 8, -3,
453    -3, -1, -2, -1, -2, -1, -2, -2, 2, -3, 0, 0, -1 });
454  1 verifyValues(sm, 'I', new float[] { -1, -3, -3, -3, -1, -3, -3, -4, -3,
455    4, 2, -3, 1, 0, -3, -2, -1, -3, -1, 3, -3, -3, -1 });
456  1 verifyValues(sm, 'L', new float[] { -1, -2, -3, -4, -1, -2, -3, -4, -3,
457    2, 4, -2, 2, 0, -3, -2, -1, -2, -1, 1, -4, -3, -1 });
458  1 verifyValues(sm, 'K', new float[] { -1, 2, 0, -1, -3, 1, 1, -2, -1, -3,
459    -2, 5, -1, -3, -1, 0, -1, -3, -2, -2, 0, 1, -1 });
460  1 verifyValues(sm, 'M', new float[] { -1, -1, -2, -3, -1, 0, -2, -3, -2,
461    1,
462    2, -1, 5, 0, -2, -1, -1, -1, -1, 1, -3, -1, -1 });
463  1 verifyValues(sm, 'F', new float[] { -2, -3, -3, -3, -2, -3, -3, -3, -1,
464    0, 0, -3, 0, 6, -4, -2, -2, 1, 3, -1, -3, -3, -1 });
465  1 verifyValues(sm, 'P', new float[] { -1, -2, -2, -1, -3, -1, -1, -2, -2,
466    -3, -3, -1, -2, -4, 7, -1, -1, -4, -3, -2, -2, -1, -2 });
467  1 verifyValues(sm, 'S', new float[] { 1, -1, 1, 0, -1, 0, 0, 0, -1, -2,
468    -2,
469    0, -1, -2, -1, 4, 1, -3, -2, -2, 0, 0, 0 });
470  1 verifyValues(sm, 'T', new float[] { 0, -1, 0, -1, -1, -1, -1, -2, -2,
471    -1,
472    -1, -1, -1, -2, -1, 1, 5, -2, -2, 0, -1, -1, 0 });
473  1 verifyValues(sm, 'W', new float[] { -3, -3, -4, -4, -2, -2, -3, -2, -2,
474    -3, -2, -3, -1, 1, -4, -3, -2, 11, 2, -3, -4, -3, -2 });
475  1 verifyValues(sm, 'Y', new float[] { -2, -2, -2, -3, -2, -1, -2, -3, 2,
476    -1, -1, -2, -1, 3, -3, -2, -2, 2, 7, -1, -3, -2, -1 });
477  1 verifyValues(sm, 'V', new float[] { 0, -3, -3, -3, -1, -2, -2, -3, -3,
478    3,
479    1, -2, 1, -1, -2, -2, 0, -3, -1, 4, -3, -2, -1 });
480  1 verifyValues(sm, 'B', new float[] { -2, -1, 3, 4, -3, 0, 1, -1, 0, -3,
481    -4, 0, -3, -3, -2, 0, -1, -4, -3, -3, 4, 1, -1 });
482  1 verifyValues(sm, 'Z', new float[] { -1, 0, 0, 1, -3, 3, 4, -2, 0, -3,
483    -3,
484    1, -1, -3, -1, 0, -1, -3, -2, -2, 1, 4, -1 });
485  1 verifyValues(sm, 'X', new float[] { 0, -1, -1, -1, -2, -1, -1, -1, -1,
486    -1, -1, -1, -1, -1, -2, 0, 0, -2, -1, -1, -1, -1, -1 });
487    }
488   
489    /**
490    * Helper method to check pairwise scores for one residue
491    *
492    * @param sm
493    * @param res
494    * @param expected
495    * score values against 'res', in ResidueProperties.aaIndex order
496    */
 
497  23 toggle private void verifyValues(ScoreMatrix sm, char res, float[] expected)
498    {
499  552 for (int j = 0; j < expected.length; j++)
500    {
501  529 char c2 = ResidueProperties.aa[j].charAt(0);
502  529 assertEquals(sm.getPairwiseScore(res, c2), expected[j],
503    String.format("%s->%s", res, c2));
504    }
505    }
506   
 
507  1 toggle @Test(groups = "Functional")
508    public void testConstructor_gapDash()
509    {
510  1 float[][] scores = new float[2][];
511  1 scores[0] = new float[] { 1f, 2f };
512  1 scores[1] = new float[] { 4f, 5f };
513  1 ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '-' },
514    scores);
515  1 assertEquals(sm.getSize(), 2);
516  1 assertArrayEquals(scores, sm.getMatrix());
517  1 assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
518  1 assertEquals(sm.getPairwiseScore('A', 'A'), 1f);
519  1 assertEquals(sm.getPairwiseScore('a', '-'), 2f);
520  1 assertEquals(sm.getPairwiseScore('-', 'A'), 4f);
521  1 assertEquals(sm.getMatrixIndex('a'), 0);
522  1 assertEquals(sm.getMatrixIndex('A'), 0);
523  1 assertEquals(sm.getMatrixIndex('-'), 1);
524  1 assertEquals(sm.getMatrixIndex(' '), -1);
525  1 assertEquals(sm.getMatrixIndex('.'), -1);
526    }
527   
 
528  1 toggle @Test(groups = "Functional")
529    public void testGetPairwiseScore()
530    {
531  1 float[][] scores = new float[2][];
532  1 scores[0] = new float[] { 1f, 2f };
533  1 scores[1] = new float[] { -4f, 5f };
534  1 ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', 'B' },
535    scores);
536  1 assertEquals(sm.getPairwiseScore('A', 'A'), 1f);
537  1 assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
538  1 assertEquals(sm.getPairwiseScore('A', 'B'), 2f);
539  1 assertEquals(sm.getPairwiseScore('b', 'a'), -4f);
540  1 assertEquals(sm.getPairwiseScore('B', 'b'), 5f);
541   
542    /*
543    * unknown symbols currently score minimum score
544    * or 1 for identity with self
545    */
546  1 assertEquals(sm.getPairwiseScore('A', '-'), -4f);
547  1 assertEquals(sm.getPairwiseScore('-', 'A'), -4f);
548  1 assertEquals(sm.getPairwiseScore('-', '-'), 1f);
549  1 assertEquals(sm.getPairwiseScore('Q', 'W'), -4f);
550  1 assertEquals(sm.getPairwiseScore('Q', 'Q'), 1f);
551   
552    /*
553    * symbols not in basic ASCII set score zero
554    */
555  1 char c = (char) 200;
556  1 assertEquals(sm.getPairwiseScore('Q', c), 0f);
557  1 assertEquals(sm.getPairwiseScore(c, 'Q'), 0f);
558    }
559   
 
560  1 toggle @Test(groups = "Functional")
561    public void testGetMinimumScore()
562    {
563  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
564  1 assertEquals(sm.getMinimumScore(), -4f);
565    }
566   
 
567  1 toggle @Test(groups = "Functional")
568    public void testGetMaximumScore()
569    {
570  1 ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
571  1 assertEquals(sm.getMaximumScore(), 11f);
572    }
573   
 
574  1 toggle @Test(groups = "Functional")
575    public void testOutputMatrix_html()
576    {
577  1 float[][] scores = new float[2][];
578  1 scores[0] = new float[] { 1f, 2f };
579  1 scores[1] = new float[] { 4f, -5.3E-10f };
580  1 ScoreMatrix sm = new ScoreMatrix("Test", "AB".toCharArray(), scores);
581  1 String html = sm.outputMatrix(true);
582  1 String expected = "<table border=\"1\"><tr><th></th><th>&nbsp;A&nbsp;</th><th>&nbsp;B&nbsp;</th></tr>\n"
583    + "<tr><td>A</td><td>1.0</td><td>2.0</td></tr>\n"
584    + "<tr><td>B</td><td>4.0</td><td>-5.3E-10</td></tr>\n"
585    + "</table>";
586  1 assertEquals(html, expected);
587    }
588    }
  • Report generated by OpenClover v 4.2.1 on Wed Oct 31 2018 15:15:54 GMT using coverage data from Wed Oct 31 2018 15:15:47 GMT.
  • Clover free edition.