create method to test HMM model as string
[jalview.git] / test / jalview / datamodel / AlignmentAnnotationTests.java
1 /*
2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
4  * 
5  * This file is part of Jalview.
6  * 
7  * Jalview is free software: you can redistribute it and/or
8  * modify it under the terms of the GNU General Public License 
9  * as published by the Free Software Foundation, either version 3
10  * of the License, or (at your option) any later version.
11  *  
12  * Jalview is distributed in the hope that it will be useful, but 
13  * WITHOUT ANY WARRANTY; without even the implied warranty 
14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR 
15  * PURPOSE.  See the GNU General Public License for more details.
16  * 
17  * You should have received a copy of the GNU General Public License
18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
19  * The Jalview Authors are detailed in the 'AUTHORS' file.
20  */
21 package jalview.datamodel;
22
23 import static org.testng.AssertJUnit.assertEquals;
24 import static org.testng.AssertJUnit.assertNull;
25
26 import jalview.analysis.AlignSeq;
27 import jalview.gui.JvOptionPane;
28 import jalview.io.AppletFormatAdapter;
29 import jalview.io.FileFormat;
30
31 import org.testng.Assert;
32 import org.testng.annotations.BeforeClass;
33 import org.testng.annotations.Test;
34
35 public class AlignmentAnnotationTests
36 {
37
38   @BeforeClass(alwaysRun = true)
39   public void setUpJvOptionPane()
40   {
41     JvOptionPane.setInteractiveMode(false);
42     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
43   }
44
45   @Test(groups = { "Functional" })
46   public void testCopyConstructor()
47   {
48     SequenceI sq = new Sequence("Foo", "ARAARARARAWEAWEAWRAWEAWE");
49     createAnnotation(sq);
50     AlignmentAnnotation alc, alo = sq.getAnnotation()[0];
51     alc = new AlignmentAnnotation(alo);
52     for (String key : alo.getProperties())
53     {
54       assertEquals("Property mismatch", alo.getProperty(key),
55               alc.getProperty(key));
56     }
57   }
58
59   /**
60    * create some dummy annotation derived from the sequence
61    * 
62    * @param sq
63    */
64   public static void createAnnotation(SequenceI sq)
65   {
66     Annotation[] al = new Annotation[sq.getLength()];
67     for (int i = 0; i < al.length; i++)
68     {
69       al[i] = new Annotation(new Annotation("" + sq.getCharAt(i), "",
70               (char) 0, sq.findPosition(i)));
71     }
72     AlignmentAnnotation alan = new AlignmentAnnotation("For "
73             + sq.getName(), "Fake alignment annot", al);
74     // create a sequence mapping for the annotation vector in its current state
75     alan.createSequenceMapping(sq, sq.getStart(), false);
76     alan.setProperty("CreatedBy", "createAnnotation");
77     sq.addAlignmentAnnotation(alan);
78   }
79
80   /**
81    * use this to test annotation derived from method above as it is transferred
82    * across different sequences derived from same dataset coordinate frame
83    * 
84    * @param ala
85    */
86   public static void testAnnotTransfer(AlignmentAnnotation ala)
87   {
88     assertEquals(
89             "Failed - need annotation created by createAnnotation method",
90             ala.description, "Fake alignment annot");
91     ala.adjustForAlignment();
92     for (int p = 0; p < ala.annotations.length; p++)
93     {
94       if (ala.annotations[p] != null)
95       {
96         assertEquals("Mismatch at position " + p
97                 + " between annotation position value and sequence"
98                 + ala.annotations[p], (int) ala.annotations[p].value,
99                 ala.sequenceRef.findPosition(p));
100       }
101     }
102   }
103
104   /**
105    * Tests the liftOver method and also exercises the functions for remapping
106    * annotation across different reference sequences. Here, the test is between
107    * different dataset frames (annotation transferred by mapping between
108    * sequences)
109    */
110   @Test(groups = { "Functional" })
111   public void testLiftOver()
112   {
113     SequenceI sqFrom = new Sequence("fromLong", "QQQCDEWGH");
114     sqFrom.setStart(10);
115     sqFrom.setEnd(sqFrom.findPosition(sqFrom.getLength() - 1));
116     SequenceI sqTo = new Sequence("toShort", "RCDEW");
117     sqTo.setStart(20);
118     sqTo.setEnd(sqTo.findPosition(sqTo.getLength() - 1));
119     createAnnotation(sqTo);
120     AlignmentAnnotation origTo = sqTo.getAnnotation()[0];
121     createAnnotation(sqFrom);
122     AlignmentAnnotation origFrom = sqFrom.getAnnotation()[0];
123     AlignSeq align = AlignSeq.doGlobalNWAlignment(sqFrom, sqTo,
124             AlignSeq.PEP);
125     SequenceI alSeq1 = new Sequence(sqFrom.getName(), align.getAStr1());
126     alSeq1.setStart(sqFrom.getStart() + align.getSeq1Start() - 1);
127     alSeq1.setEnd(sqFrom.getStart() + align.getSeq1End() - 1);
128     alSeq1.setDatasetSequence(sqFrom);
129     SequenceI alSeq2 = new Sequence(sqTo.getName(), align.getAStr2());
130     alSeq2.setStart(sqTo.getStart() + align.getSeq2Start() - 1);
131     alSeq2.setEnd(sqTo.getStart() + align.getSeq2End() - 1);
132     alSeq2.setDatasetSequence(sqTo);
133     System.out.println(new AppletFormatAdapter()
134 .formatSequences(
135             FileFormat.Stockholm, new Alignment(new SequenceI[] { sqFrom,
136                 alSeq1, sqTo, alSeq2 }), true));
137
138     Mapping mp = align.getMappingFromS1(false);
139
140     AlignmentAnnotation almap1 = new AlignmentAnnotation(
141             sqTo.getAnnotation()[0]);
142     almap1.liftOver(sqFrom, mp);
143     assertEquals(almap1.sequenceRef, sqFrom);
144     alSeq1.addAlignmentAnnotation(almap1);
145     almap1.setSequenceRef(alSeq1);
146     almap1.adjustForAlignment();
147     AlignmentAnnotation almap2 = new AlignmentAnnotation(
148             sqFrom.getAnnotation()[0]);
149     almap2.liftOver(sqTo, mp);
150     assertEquals(almap2.sequenceRef, sqTo);
151
152     alSeq2.addAlignmentAnnotation(almap2);
153     almap2.setSequenceRef(alSeq2);
154     almap2.adjustForAlignment();
155
156     AlignmentI all = new Alignment(new SequenceI[] { alSeq1, alSeq2 });
157     all.addAnnotation(almap1);
158     all.addAnnotation(almap2);
159     System.out.println(new AppletFormatAdapter().formatSequences(
160             FileFormat.Stockholm,
161             all, true));
162
163     for (int p = 0; p < alSeq1.getLength(); p++)
164     {
165       Annotation orig1, trans1, orig2, trans2;
166       trans2 = almap2.annotations[p];
167       orig2 = origFrom.annotations[alSeq1.findPosition(p)
168               - sqFrom.getStart()];
169       orig1 = origTo.annotations[alSeq2.findPosition(p) - sqTo.getStart()];
170       trans1 = almap1.annotations[p];
171       if (trans1 == trans2)
172       {
173         System.out.println("Pos " + p + " mismatch");
174         continue;
175       }
176       assertEquals(
177               "Mismatch on Original From and transferred annotation on 2",
178               (orig2 != null) ? orig2.toString() : null,
179               (trans2 != null) ? trans2.toString() : null);
180       assertEquals(
181               "Mismatch on Original To and transferred annotation on 1",
182               (orig1 != null) ? orig1.toString() : null,
183               (trans1 != null) ? trans1.toString() : null);
184       String alm1 = ""
185               + (almap1.annotations.length > p ? almap1.annotations[p].displayCharacter
186                       : "Out of range");
187       String alm2 = ""
188               + (almap2.annotations.length > p ? almap2.annotations[p].displayCharacter
189                       : "Out of range");
190       assertEquals("Position " + p + " " + alm1 + " " + alm2, alm1, alm2);
191     }
192   }
193
194   @Test(groups = { "Functional" })
195   public void testAdjustForAlignment()
196   {
197     SequenceI seq = new Sequence("TestSeq", "ABCDEFG");
198     seq.createDatasetSequence();
199
200     /*
201      * Annotate positions 3/4/5 (CDE) with values 1/2/3
202      */
203     Annotation[] anns = new Annotation[] { null, null, new Annotation(1),
204         new Annotation(2), new Annotation(3) };
205     AlignmentAnnotation ann = new AlignmentAnnotation("SS",
206             "secondary structure", anns);
207     seq.addAlignmentAnnotation(ann);
208
209     /*
210      * Check annotation map before modifying aligned sequence
211      */
212     assertNull(ann.getAnnotationForPosition(1));
213     assertNull(ann.getAnnotationForPosition(2));
214     assertNull(ann.getAnnotationForPosition(6));
215     assertNull(ann.getAnnotationForPosition(7));
216     assertEquals(1, ann.getAnnotationForPosition(3).value, 0.001d);
217     assertEquals(2, ann.getAnnotationForPosition(4).value, 0.001d);
218     assertEquals(3, ann.getAnnotationForPosition(5).value, 0.001d);
219
220     /*
221      * Trim the displayed sequence to BCD and adjust annotations
222      */
223     seq.setSequence("BCD");
224     seq.setStart(2);
225     seq.setEnd(4);
226     ann.adjustForAlignment();
227
228     /*
229      * Should now have annotations for aligned positions 2, 3Q (CD) only
230      */
231     assertEquals(3, ann.annotations.length);
232     assertNull(ann.annotations[0]);
233     assertEquals(1, ann.annotations[1].value, 0.001);
234     assertEquals(2, ann.annotations[2].value, 0.001);
235   }
236
237   /**
238    * Test the method that defaults rna symbol to the one matching the preceding
239    * unmatched opening bracket (if any)
240    */
241   @Test(groups = { "Functional" })
242   public void testGetDefaultRnaHelixSymbol()
243   {
244     AlignmentAnnotation ann = new AlignmentAnnotation("SS",
245             "secondary structure", null);
246     assertEquals("(", ann.getDefaultRnaHelixSymbol(4));
247
248     Annotation[] anns = new Annotation[20];
249     ann.annotations = anns;
250     assertEquals("(", ann.getDefaultRnaHelixSymbol(4));
251
252     anns[1] = new Annotation("(", "S", '(', 0f);
253     assertEquals("(", ann.getDefaultRnaHelixSymbol(0));
254     assertEquals("(", ann.getDefaultRnaHelixSymbol(1));
255     assertEquals(")", ann.getDefaultRnaHelixSymbol(2));
256     assertEquals(")", ann.getDefaultRnaHelixSymbol(3));
257
258     /*
259      * .(.[.{.<.}.>.).].
260      */
261     anns[1] = new Annotation("(", "S", '(', 0f);
262     anns[3] = new Annotation("[", "S", '[', 0f);
263     anns[5] = new Annotation("{", "S", '{', 0f);
264     anns[7] = new Annotation("<", "S", '<', 0f);
265     anns[9] = new Annotation("}", "S", '}', 0f);
266     anns[11] = new Annotation(">", "S", '>', 0f);
267     anns[13] = new Annotation(")", "S", ')', 0f);
268     anns[15] = new Annotation("]", "S", ']', 0f);
269
270     String expected = "(())]]}}>>>>]]]](";
271     for (int i = 0; i < expected.length(); i++)
272     {
273       assertEquals("column " + i, String.valueOf(expected.charAt(i)),
274               ann.getDefaultRnaHelixSymbol(i));
275     }
276
277     /*
278      * .(.[.(.).{.}.<.].D.
279      */
280     anns[1] = new Annotation("(", "S", '(', 0f);
281     anns[3] = new Annotation("[", "S", '[', 0f);
282     anns[5] = new Annotation("(", "S", '(', 0f);
283     anns[7] = new Annotation(")", "S", ')', 0f);
284     anns[9] = new Annotation("{", "S", '{', 0f);
285     anns[11] = new Annotation("}", "S", '}', 0f);
286     anns[13] = new Annotation("<", "S", '>', 0f);
287     anns[15] = new Annotation("]", "S", ']', 0f);
288     anns[17] = new Annotation("D", "S", 'D', 0f);
289
290     expected = "(())]]))]]}}]]>>>>dd";
291     for (int i = 0; i < expected.length(); i++)
292     {
293       assertEquals("column " + i, String.valueOf(expected.charAt(i)),
294               ann.getDefaultRnaHelixSymbol(i));
295     }
296   }
297
298   public static Annotation newAnnotation(String ann)
299   {
300     float val = 0f;
301     try
302     {
303       val = Float.parseFloat(ann);
304     } catch (NumberFormatException q)
305     {
306     }
307     ;
308     return new Annotation(ann, ann, '\0', val);
309   }
310
311   @Test(groups = { "Functional" })
312   public void testIsQuantitative()
313   {
314     AlignmentAnnotation ann = null;
315
316     ann = new AlignmentAnnotation("an", "some an", null);
317     Assert.assertFalse(ann.isQuantitative(),
318             "Empty annotation set should not be quantitative.");
319
320     ann = new AlignmentAnnotation("an", "some an", new Annotation[] {
321         newAnnotation("4"), newAnnotation("1"), newAnnotation("1"),
322         newAnnotation("0.1"), newAnnotation("0.3") });
323     Assert.assertTrue(ann.isQuantitative(),
324             "All numbers annotation set should be quantitative.");
325
326     ann = new AlignmentAnnotation("an", "some an", new Annotation[] {
327         newAnnotation("E"), newAnnotation("E"), newAnnotation("E"),
328         newAnnotation("E"), newAnnotation("E") });
329     Assert.assertFalse(ann.isQuantitative(),
330             "All 'E' annotation set should not be quantitative.");
331
332     ann = new AlignmentAnnotation("an", "some an", new Annotation[] {
333         newAnnotation("E"), newAnnotation("1"), newAnnotation("2"),
334         newAnnotation("3"), newAnnotation("E") });
335     Assert.assertTrue(ann.isQuantitative(),
336             "Mixed 'E' annotation set should be quantitative.");
337   }
338 }