JAL-2793 cancelling font changed dialog didn't call ap.fontChanged() to reset layout
[jalview.git] / test / jalview / analysis / scoremodels / ScoreMatrixTest.java
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   @Test(groups = "Functional")
28   public void testConstructor()
29   {
30     // note score matrix does not have to be symmetric (though it should be!)
31     float[][] scores = new float[3][];
32     scores[0] = new float[] { 1f, 2f, 3f };
33     scores[1] = new float[] { -4f, 5f, 6f };
34     scores[2] = new float[] { 7f, 8f, 9f };
35     ScoreMatrix sm = new ScoreMatrix("Test", "ABC".toCharArray(), scores);
36     assertEquals(sm.getSize(), 3);
37     assertArrayEquals(scores, sm.getMatrix());
38     assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
39     assertEquals(sm.getPairwiseScore('b', 'c'), 6f);
40     assertEquals(sm.getPairwiseScore('c', 'b'), 8f);
41     assertEquals(sm.getMatrixIndex('c'), 2);
42     assertEquals(sm.getMatrixIndex(' '), -1);
43
44     // substitution to or from unknown symbol gets minimum score
45     assertEquals(sm.getPairwiseScore('A', 'D'), -4f);
46     assertEquals(sm.getPairwiseScore('D', 'A'), -4f);
47     // unknown-to-self gets a score of 1
48     assertEquals(sm.getPairwiseScore('D', 'D'), 1f);
49   }
50
51   @Test(
52     groups = "Functional",
53     expectedExceptions = { IllegalArgumentException.class })
54   public void testConstructor_matrixTooSmall()
55   {
56     float[][] scores = new float[2][];
57     scores[0] = new float[] { 1f, 2f };
58     scores[1] = new float[] { 3f, 4f };
59     new ScoreMatrix("Test", "ABC".toCharArray(), scores);
60   }
61
62   @Test(
63     groups = "Functional",
64     expectedExceptions = { IllegalArgumentException.class })
65   public void testConstructor_matrixTooBig()
66   {
67     float[][] scores = new float[2][];
68     scores[0] = new float[] { 1f, 2f };
69     scores[1] = new float[] { 3f, 4f };
70     new ScoreMatrix("Test", "A".toCharArray(), scores);
71   }
72
73   @Test(
74     groups = "Functional",
75     expectedExceptions = { IllegalArgumentException.class })
76   public void testConstructor_matrixNotSquare()
77   {
78     float[][] scores = new float[2][];
79     scores[0] = new float[] { 1f, 2f };
80     scores[1] = new float[] { 3f };
81     new ScoreMatrix("Test", "AB".toCharArray(), scores);
82   }
83
84   @Test(groups = "Functional")
85   public void testBuildSymbolIndex()
86   {
87     float[][] scores = new float[2][];
88     scores[0] = new float[] { 1f, 2f };
89     scores[1] = new float[] { 3f, 4f };
90     ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '.' },
91             scores);
92     short[] index = sm.buildSymbolIndex("AX-yxYp".toCharArray());
93
94     assertEquals(index.length, 128); // ASCII character set size
95
96     assertEquals(index['A'], 0);
97     assertEquals(index['a'], 0); // lower-case mapping added
98     assertEquals(index['X'], 1);
99     assertEquals(index['-'], 2);
100     assertEquals(index['y'], 3); // lower-case override
101     assertEquals(index['x'], 4); // lower-case override
102     assertEquals(index['Y'], 5);
103     assertEquals(index['p'], 6);
104     assertEquals(index['P'], -1); // lower-case doesn't map upper-case
105
106     /*
107      * check all unmapped symbols have index for unmapped
108      */
109     for (int c = 0; c < index.length; c++)
110     {
111       if (!"AaXx-. Yyp".contains(String.valueOf((char) c)))
112       {
113         assertEquals(index[c], -1);
114       }
115     }
116   }
117
118   /**
119    * check that characters not in the basic ASCII set are simply ignored
120    */
121   @Test(groups = "Functional")
122   public void testBuildSymbolIndex_nonAscii()
123   {
124     float[][] scores = new float[2][];
125     scores[0] = new float[] { 1f, 2f };
126     scores[1] = new float[] { 3f, 4f };
127     ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '.' },
128             scores);
129     char[] weird = new char[] { 128, 245, 'P' };
130     short[] index = sm.buildSymbolIndex(weird);
131     assertEquals(index.length, 128);
132     assertEquals(index['P'], 2);
133     assertEquals(index['p'], 2);
134     for (int c = 0; c < index.length; c++)
135     {
136       if (c != 'P' && c != 'p')
137       {
138         assertEquals(index[c], -1);
139       }
140     }
141   }
142
143   @Test(groups = "Functional")
144   public void testGetMatrix()
145   {
146     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
147     float[][] m = sm.getMatrix();
148     assertEquals(m.length, sm.getSize());
149     assertEquals(m[2][4], -3f);
150     // verify a defensive copy is returned
151     float[][] m2 = sm.getMatrix();
152     assertNotSame(m, m2);
153     assertTrue(Arrays.deepEquals(m, m2));
154   }
155
156   @Test(groups = "Functional")
157   public void testGetMatrixIndex()
158   {
159     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
160     assertEquals(sm.getMatrixIndex('A'), 0);
161     assertEquals(sm.getMatrixIndex('R'), 1);
162     assertEquals(sm.getMatrixIndex('r'), 1);
163     assertEquals(sm.getMatrixIndex('N'), 2);
164     assertEquals(sm.getMatrixIndex('D'), 3);
165     assertEquals(sm.getMatrixIndex('X'), 22);
166     assertEquals(sm.getMatrixIndex('x'), 22);
167     assertEquals(sm.getMatrixIndex('-'), -1);
168     assertEquals(sm.getMatrixIndex('*'), 23);
169     assertEquals(sm.getMatrixIndex('.'), -1);
170     assertEquals(sm.getMatrixIndex(' '), -1);
171     assertEquals(sm.getMatrixIndex('?'), -1);
172     assertEquals(sm.getMatrixIndex((char) 128), -1);
173   }
174
175   @Test(groups = "Functional")
176   public void testGetSize()
177   {
178     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
179     assertEquals(sm.getMatrix().length, sm.getSize());
180   }
181
182   @Test(groups = "Functional")
183   public void testComputePairwiseScores()
184   {
185     /*
186      * NB score matrix expects '-' for gap
187      */
188     String[] seqs = new String[] { "FKL", "R-D", "QIA", "GWC" };
189     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
190
191     MatrixI pairwise = sm.findSimilarities(seqs, SimilarityParams.Jalview);
192
193     /*
194      * should be NxN where N = number of sequences
195      */
196     assertEquals(pairwise.height(), 4);
197     assertEquals(pairwise.width(), 4);
198
199     /*
200      * should be symmetrical (because BLOSUM62 is)
201      */
202     for (int i = 0; i < pairwise.height(); i++)
203     {
204       for (int j = i + 1; j < pairwise.width(); j++)
205       {
206         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     assertEquals(pairwise.getValue(0, 0), 15d);
215     // R.R + -.- + D.D = 5 + 1 + 6 = 12
216     assertEquals(pairwise.getValue(1, 1), 12d);
217     // Q.Q + I.I + A.A = 5 + 4 + 4 = 13
218     assertEquals(pairwise.getValue(2, 2), 13d);
219     // G.G + W.W + C.C = 6 + 11 + 9 = 26
220     assertEquals(pairwise.getValue(3, 3), 26d);
221     // F.R + K.- + L.D = -3 + -4 + -4 = -11
222     assertEquals(pairwise.getValue(0, 1), -11d);
223     // F.Q + K.I + L.A = -3 + -3 + -1 = -7
224     assertEquals(pairwise.getValue(0, 2), -7d);
225     // F.G + K.W + L.C = -3 + -3 + -1 = -7
226     assertEquals(pairwise.getValue(0, 3), -7d);
227     // R.Q + -.I + D.A = 1 + -4 + -2 = -5
228     assertEquals(pairwise.getValue(1, 2), -5d);
229     // R.G + -.W + D.C = -2 + -4 + -3 = -9
230     assertEquals(pairwise.getValue(1, 3), -9d);
231     // Q.G + I.W + A.C = -2 + -3 + 0 = -5
232     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   @Test(groups = "Functional")
243   public void testOutputMatrix_roundTrip() throws MalformedURLException,
244           IOException
245   {
246     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
247     String output = sm.outputMatrix(false);
248     FileParse fp = new FileParse(output, DataSourceType.PASTE);
249     ScoreMatrixFile parser = new ScoreMatrixFile(fp);
250     ScoreMatrix sm2 = parser.parseMatrix();
251     assertNotNull(sm2);
252     assertTrue(sm2.equals(sm));
253   }
254
255   @Test(groups = "Functional")
256   public void testEqualsAndHashCode()
257   {
258     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
259     ScoreMatrix sm2 = new ScoreMatrix(sm.getName(), sm.getSymbols()
260             .toCharArray(), sm.getMatrix());
261     assertTrue(sm.equals(sm2));
262     assertEquals(sm.hashCode(), sm2.hashCode());
263
264     sm2 = ScoreModels.getInstance().getPam250();
265     assertFalse(sm.equals(sm2));
266     assertNotEquals(sm.hashCode(), sm2.hashCode());
267
268     assertFalse(sm.equals("hello"));
269   }
270
271   /**
272    * Tests for scoring options where the longer length of two sequences is used
273    */
274   @Test(groups = "Functional")
275   public void testcomputeSimilarity_matchLongestSequence()
276   {
277     /*
278      * ScoreMatrix expects '-' for gaps
279      */
280     String s1 = "FR-K-S";
281     String s2 = "FS--L";
282     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     SimilarityParamsI params = new SimilarityParams(true, true, true, false);
291     assertEquals(blosum.computeSimilarity(s1, s2, params), -6d);
292     // matchGap (arg2) is ignored:
293     params = new SimilarityParams(true, false, true, false);
294     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     params = new SimilarityParams(false, true, true, false);
302     assertEquals(blosum.computeSimilarity(s1, s2, params), -7d);
303     // matchGap (arg2) is ignored:
304     params = new SimilarityParams(false, false, true, false);
305     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     params = new SimilarityParams(true, false, false, false);
313     assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
314     // matchGap (arg2) is ignored:
315     params = new SimilarityParams(true, true, false, false);
316     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     params = new SimilarityParams(false, false, false, false);
324     assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
325     // matchGap (arg2) is ignored:
326     params = new SimilarityParams(false, true, false, false);
327     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   @Test(groups = "Functional")
335   public void testcomputeSimilarity_matchShortestSequence()
336   {
337     /*
338      * ScoreMatrix expects '-' for gaps
339      */
340     String s1 = "FR-K-S";
341     String s2 = "FS--L";
342     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     SimilarityParamsI params = new SimilarityParams(true, true, true, true);
351     assertEquals(blosum.computeSimilarity(s1, s2, params), -2d);
352     // matchGap (arg2) is ignored:
353     params = new SimilarityParams(true, false, true, true);
354     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     params = new SimilarityParams(false, true, true, true);
362     assertEquals(blosum.computeSimilarity(s1, s2, params), -3d);
363     // matchGap (arg2) is ignored:
364     params = new SimilarityParams(false, false, true, true);
365     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     params = new SimilarityParams(true, false, false, true);
373     assertEquals(blosum.computeSimilarity(s1, s2, params), 6d);
374     // matchGap (arg2) is ignored:
375     params = new SimilarityParams(true, true, false, true);
376     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     params = new SimilarityParams(false, false, false, true);
384     assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
385     // matchGap (arg2) is ignored:
386     params = new SimilarityParams(false, true, false, true);
387     assertEquals(blosum.computeSimilarity(s1, s2, params), 5d);
388   }
389
390   @Test(groups = "Functional")
391   public void testSymmetric()
392   {
393     verifySymmetric(ScoreModels.getInstance().getBlosum62());
394     verifySymmetric(ScoreModels.getInstance().getPam250());
395     verifySymmetric(ScoreModels.getInstance().getDefaultModel(false)); // dna
396   }
397
398   private void verifySymmetric(ScoreMatrix sm)
399   {
400     float[][] m = sm.getMatrix();
401     int rows = m.length;
402     for (int row = 0; row < rows; row++)
403     {
404       assertEquals(m[row].length, rows);
405       for (int col = 0; col < rows; col++)
406       {
407         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   @Test(groups = "Functional")
418   public void testBlosum62_values()
419   {
420     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
421
422     assertTrue(sm.isProtein());
423     assertFalse(sm.isDNA());
424     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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     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   private void verifyValues(ScoreMatrix sm, char res, float[] expected)
498   {
499     for (int j = 0; j < expected.length; j++)
500     {
501       char c2 = ResidueProperties.aa[j].charAt(0);
502       assertEquals(sm.getPairwiseScore(res, c2), expected[j],
503               String.format("%s->%s", res, c2));
504     }
505   }
506
507   @Test(groups = "Functional")
508   public void testConstructor_gapDash()
509   {
510     float[][] scores = new float[2][];
511     scores[0] = new float[] { 1f, 2f };
512     scores[1] = new float[] { 4f, 5f };
513     ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', '-' },
514             scores);
515     assertEquals(sm.getSize(), 2);
516     assertArrayEquals(scores, sm.getMatrix());
517     assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
518     assertEquals(sm.getPairwiseScore('A', 'A'), 1f);
519     assertEquals(sm.getPairwiseScore('a', '-'), 2f);
520     assertEquals(sm.getPairwiseScore('-', 'A'), 4f);
521     assertEquals(sm.getMatrixIndex('a'), 0);
522     assertEquals(sm.getMatrixIndex('A'), 0);
523     assertEquals(sm.getMatrixIndex('-'), 1);
524     assertEquals(sm.getMatrixIndex(' '), -1);
525     assertEquals(sm.getMatrixIndex('.'), -1);
526   }
527
528   @Test(groups = "Functional")
529   public void testGetPairwiseScore()
530   {
531     float[][] scores = new float[2][];
532     scores[0] = new float[] { 1f, 2f };
533     scores[1] = new float[] { -4f, 5f };
534     ScoreMatrix sm = new ScoreMatrix("Test", new char[] { 'A', 'B' },
535             scores);
536     assertEquals(sm.getPairwiseScore('A', 'A'), 1f);
537     assertEquals(sm.getPairwiseScore('A', 'a'), 1f);
538     assertEquals(sm.getPairwiseScore('A', 'B'), 2f);
539     assertEquals(sm.getPairwiseScore('b', 'a'), -4f);
540     assertEquals(sm.getPairwiseScore('B', 'b'), 5f);
541
542     /*
543      * unknown symbols currently score minimum score
544      * or 1 for identity with self
545      */
546     assertEquals(sm.getPairwiseScore('A', '-'), -4f);
547     assertEquals(sm.getPairwiseScore('-', 'A'), -4f);
548     assertEquals(sm.getPairwiseScore('-', '-'), 1f);
549     assertEquals(sm.getPairwiseScore('Q', 'W'), -4f);
550     assertEquals(sm.getPairwiseScore('Q', 'Q'), 1f);
551
552     /*
553      * symbols not in basic ASCII set score zero
554      */
555     char c = (char) 200;
556     assertEquals(sm.getPairwiseScore('Q', c), 0f);
557     assertEquals(sm.getPairwiseScore(c, 'Q'), 0f);
558   }
559
560   @Test(groups = "Functional")
561   public void testGetMinimumScore()
562   {
563     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
564     assertEquals(sm.getMinimumScore(), -4f);
565   }
566
567   @Test(groups = "Functional")
568   public void testGetMaximumScore()
569   {
570     ScoreMatrix sm = ScoreModels.getInstance().getBlosum62();
571     assertEquals(sm.getMaximumScore(), 11f);
572   }
573
574   @Test(groups = "Functional")
575   public void testOutputMatrix_html()
576   {
577     float[][] scores = new float[2][];
578     scores[0] = new float[] { 1f, 2f };
579     scores[1] = new float[] { 4f, -5.3E-10f };
580     ScoreMatrix sm = new ScoreMatrix("Test", "AB".toCharArray(), scores);
581     String html = sm.outputMatrix(true);
582     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     assertEquals(html, expected);
587   }
588 }