create method to test HMM model as string
[jalview.git] / test / jalview / datamodel / HiddenSequencesTest.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.assertFalse;
25 import static org.testng.AssertJUnit.assertNotNull;
26 import static org.testng.AssertJUnit.assertNotSame;
27 import static org.testng.AssertJUnit.assertNull;
28 import static org.testng.AssertJUnit.assertSame;
29 import static org.testng.AssertJUnit.assertTrue;
30 import static org.testng.internal.junit.ArrayAsserts.assertArrayEquals;
31
32 import jalview.gui.AlignViewport;
33 import jalview.gui.JvOptionPane;
34
35 import java.util.List;
36
37 import org.testng.annotations.BeforeClass;
38 import org.testng.annotations.BeforeTest;
39 import org.testng.annotations.Test;
40
41 @Test(singleThreaded = true)
42 public class HiddenSequencesTest
43 {
44
45   @BeforeClass(alwaysRun = true)
46   public void setUpJvOptionPane()
47   {
48     JvOptionPane.setInteractiveMode(false);
49     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
50   }
51
52   static int SEQ_COUNT = 25;
53
54   SequenceI[] seqs;
55
56   /**
57    * Set up an alignment of 10 sequences
58    */
59   @BeforeTest(alwaysRun = true)
60   public void setUp()
61   {
62     seqs = new SequenceI[SEQ_COUNT];
63     for (int i = 0; i < SEQ_COUNT; i++)
64     {
65       // sequence lengths are 1, 2, ... 25
66       seqs[i] = new Sequence("Seq" + i,
67               "abcdefghijklmnopqrstuvwxy".substring(0, i + 1));
68     }
69   }
70
71   /**
72    * Test the method that converts sequence alignment index to what it would be
73    * if all sequences were unhidden
74    */
75   @Test(groups = "Functional")
76   public void testAdjustForHiddenSeqs()
77   {
78     AlignmentI al = new Alignment(seqs);
79     HiddenSequences hs = al.getHiddenSequences();
80     for (int i = 0; i < SEQ_COUNT; i++)
81     {
82       assertEquals(i, hs.adjustForHiddenSeqs(i));
83     }
84
85     // hide seq1 and seq5 and seq6
86     hs.hideSequence(seqs[1]);
87     hs.hideSequence(seqs[5]);
88     hs.hideSequence(seqs[6]);
89
90     /*
91      * alignment is now seq0/2/3/4/7/8/9
92      */
93     assertEquals(SEQ_COUNT - 3, al.getHeight());
94     assertEquals(0, hs.adjustForHiddenSeqs(0));
95     assertEquals(2, hs.adjustForHiddenSeqs(1));
96     assertEquals(3, hs.adjustForHiddenSeqs(2));
97     assertEquals(4, hs.adjustForHiddenSeqs(3));
98     assertEquals(7, hs.adjustForHiddenSeqs(4));
99     assertEquals(8, hs.adjustForHiddenSeqs(5));
100     assertEquals(9, hs.adjustForHiddenSeqs(6));
101   }
102
103   /**
104    * Test the method that increments the internal array size if a sequence is
105    * added to the alignment (ugh this should not be exposed to the light of day)
106    */
107   @Test(groups = "Functional")
108   public void testAdjustHeightSequenceAdded()
109   {
110     AlignmentI al = new Alignment(seqs);
111     assertEquals(SEQ_COUNT, al.getHeight());
112
113     HiddenSequences hs = al.getHiddenSequences();
114     // initially does nothing
115     hs.adjustHeightSequenceAdded();
116     assertNull(hs.hiddenSequences);
117
118     // hide one sequence
119     hs.hideSequence(seqs[3]);
120     assertEquals(1, hs.getSize());
121     assertEquals(SEQ_COUNT - 1, al.getHeight());
122     assertEquals(SEQ_COUNT, hs.hiddenSequences.length);
123
124     /*
125      * add a sequence to the alignment
126      * - the safe way to call hs.adjustHeightSequenceAdded!
127      * (implementation depends on alignment height having
128      * been already updated for the added sequence)
129      */
130     al.addSequence(new Sequence("a", "b"));
131     assertEquals(1, hs.getSize());
132     assertEquals(SEQ_COUNT, al.getHeight());
133     assertEquals(SEQ_COUNT + 1, hs.hiddenSequences.length);
134   }
135
136   /**
137    * Test the method that decrements the internal array size if a sequence is
138    * deleted from the alignment (ugh this should not be exposed to the light of
139    * day)
140    */
141   @Test(groups = "Functional")
142   public void testAdjustHeightSequenceDeleted()
143   {
144     AlignmentI al = new Alignment(seqs);
145     assertEquals(SEQ_COUNT, al.getHeight());
146
147     HiddenSequences hs = al.getHiddenSequences();
148     // initially does nothing
149     hs.adjustHeightSequenceAdded();
150     assertNull(hs.hiddenSequences);
151
152     // hide two sequences
153     hs.hideSequence(seqs[3]);
154     hs.hideSequence(seqs[5]);
155     assertEquals(2, hs.getSize());
156     assertTrue(hs.isHidden(seqs[3]));
157     assertTrue(hs.isHidden(seqs[5]));
158     assertEquals(SEQ_COUNT - 2, al.getHeight());
159     assertEquals(SEQ_COUNT, hs.hiddenSequences.length);
160
161     /*
162      * delete a visible sequence from the alignment
163      * - the safe way to call hs.adjustHeightSequenceDeleted!
164      * (implementation depends on alignment height having
165      * been already updated for the removed sequence)
166      */
167     al.deleteSequence(seqs[2]);
168     assertEquals(2, hs.getSize());
169     // the visible alignment is unchanged:
170     assertEquals(SEQ_COUNT - 3, al.getHeight());
171     // sequences array size has decremented:
172     assertEquals(SEQ_COUNT - 1, hs.hiddenSequences.length);
173   }
174
175   /**
176    * Test the method that converts a 'full alignment' sequence index into the
177    * equivalent in the alignment with sequences hidden
178    */
179   @Test(groups = "Functional")
180   public void testFindIndexWithoutHiddenSeqs()
181   {
182     AlignmentI al = new Alignment(seqs);
183     HiddenSequences hs = al.getHiddenSequences();
184     for (int i = 0; i < SEQ_COUNT; i++)
185     {
186       assertEquals(i, hs.findIndexWithoutHiddenSeqs(i));
187     }
188
189     // hide seq1 and seq5 and seq6
190     hs.hideSequence(seqs[1]);
191     hs.hideSequence(seqs[5]);
192     hs.hideSequence(seqs[6]);
193
194     /*
195      * alignment is now seq0/2/3/4/7/8/9
196      */
197     assertEquals(SEQ_COUNT - 3, al.getHeight());
198     assertEquals(0, hs.findIndexWithoutHiddenSeqs(0));
199     assertEquals(0, hs.findIndexWithoutHiddenSeqs(1));
200     assertEquals(1, hs.findIndexWithoutHiddenSeqs(2));
201     assertEquals(2, hs.findIndexWithoutHiddenSeqs(3));
202     assertEquals(3, hs.findIndexWithoutHiddenSeqs(4));
203     assertEquals(3, hs.findIndexWithoutHiddenSeqs(5));
204     assertEquals(3, hs.findIndexWithoutHiddenSeqs(6));
205     assertEquals(4, hs.findIndexWithoutHiddenSeqs(7));
206     assertEquals(5, hs.findIndexWithoutHiddenSeqs(8));
207     assertEquals(6, hs.findIndexWithoutHiddenSeqs(9));
208   }
209
210   /**
211    * Test the method that finds the visible row position a given distance before
212    * another row
213    */
214   @Test(groups = { "Functional" })
215   public void testFindIndexNFromRow()
216   {
217     AlignmentI al = new Alignment(seqs);
218     HiddenSequences hs = new HiddenSequences(al);
219
220     // test that without hidden rows, findIndexNFromRow returns
221     // position n above provided position
222     int pos = hs.subtractVisibleRows(3, 10);
223     assertEquals(7, pos);
224
225     // 0 returns same position
226     pos = hs.subtractVisibleRows(0, 10);
227     assertEquals(10, pos);
228
229     // overflow to top returns negative number
230     pos = hs.subtractVisibleRows(3, 0);
231     assertEquals(-3, pos);
232
233     // test that with hidden rows above result row
234     // behaviour is the same as above
235     hs.hideSequence(seqs[1]);
236     hs.hideSequence(seqs[2]);
237     hs.hideSequence(seqs[3]);
238
239     // position n above provided position
240     pos = hs.subtractVisibleRows(3, 10);
241     assertEquals(7, pos);
242
243     // 0 returns same position
244     pos = hs.subtractVisibleRows(0, 10);
245     assertEquals(10, pos);
246
247     // test with one set of hidden rows between start and required position
248     hs.hideSequence(seqs[12]);
249     hs.hideSequence(seqs[13]);
250     hs.hideSequence(seqs[14]);
251     hs.hideSequence(seqs[15]);
252     pos = hs.subtractVisibleRows(8, 17);
253     assertEquals(5, pos);
254
255     // test with two sets of hidden rows between start and required position
256     hs.hideSequence(seqs[20]);
257     hs.hideSequence(seqs[21]);
258     pos = hs.subtractVisibleRows(8, 23);
259     assertEquals(9, pos);
260
261     // repeat last 2 tests with no hidden columns to left of required position
262     hs.showAll(null);
263
264     // test with one set of hidden rows between start and required position
265     hs.hideSequence(seqs[12]);
266     hs.hideSequence(seqs[13]);
267     hs.hideSequence(seqs[14]);
268     hs.hideSequence(seqs[15]);
269     pos = hs.subtractVisibleRows(8, 17);
270     assertEquals(5, pos);
271
272     // test with two sets of hidden rows between start and required position
273     hs.hideSequence(seqs[20]);
274     hs.hideSequence(seqs[21]);
275     pos = hs.subtractVisibleRows(8, 23);
276     assertEquals(9, pos);
277
278   }
279
280   /**
281    * Test the method that reconstructs (sort of) the full alignment including
282    * hidden sequences
283    */
284   @Test(groups = "Functional")
285   public void testGetFullAlignment()
286   {
287     AlignmentI al = new Alignment(seqs);
288     assertArrayEquals(seqs, al.getSequencesArray());
289     al.setProperty("a", "b");
290     al.addAnnotation(new AlignmentAnnotation("ann", "label", 12f));
291     al.setSeqrep(seqs[4]);
292     SequenceGroup sg = new SequenceGroup();
293     sg.addSequence(seqs[8], false);
294     al.addGroup(sg);
295     ((Alignment) al).hasRNAStructure = true;
296
297     HiddenSequences hs = al.getHiddenSequences();
298     AlignmentI al2 = hs.getFullAlignment();
299     // new alignment but with original sequences
300     assertNotSame(al, al2);
301     assertArrayEquals(al.getSequencesArray(), al2.getSequencesArray());
302
303     hs.hideSequence(seqs[4]);
304     hs.hideSequence(seqs[9]);
305     al2 = hs.getFullAlignment();
306     assertNotSame(al, al2);
307     assertArrayEquals(seqs, al2.getSequencesArray());
308     assertNotNull(al2.getProperties());
309     assertSame(al.getProperties(), al2.getProperties());
310     assertNotNull(al2.getAlignmentAnnotation());
311     assertSame(al.getAlignmentAnnotation(), al2.getAlignmentAnnotation());
312     assertSame(seqs[4], al2.getSeqrep());
313     assertNotNull(al2.getGroups());
314     assertSame(al.getGroups(), al2.getGroups());
315     assertTrue(al2.hasRNAStructure());
316   }
317
318   /**
319    * Test the method that returns the hidden sequence at a given index in the
320    * full alignment
321    * 
322    * @return either the sequence (if hidden) or null (if not hidden)
323    */
324   @Test(groups = "Functional")
325   public void testGetHiddenSequence()
326   {
327     AlignmentI al = new Alignment(seqs);
328     HiddenSequences hs = al.getHiddenSequences();
329     assertNull(hs.getHiddenSequence(0));
330     hs.hideSequence(seqs[3]);
331     assertSame(seqs[3], hs.getHiddenSequence(3));
332     assertNull(hs.getHiddenSequence(2));
333     assertNull(hs.getHiddenSequence(4));
334   }
335
336   @Test(groups = "Functional")
337   public void testGetSize()
338   {
339   }
340
341   @Test(groups = "Functional")
342   public void testGetWidth()
343   {
344     AlignmentI al = new Alignment(seqs);
345     HiddenSequences hs = al.getHiddenSequences();
346     assertEquals(0, hs.getWidth());
347     hs.hideSequence(seqs[6]);
348     hs.hideSequence(seqs[8]);
349     assertEquals(9, hs.getWidth());
350   }
351
352   /**
353    * Test the method that adds a sequence to the hidden sequences and deletes it
354    * from the alignment, and its converse
355    */
356   @Test(groups = "Functional")
357   public void testHideShowSequence()
358   {
359     AlignmentI al = new Alignment(seqs);
360     assertTrue(al.getSequences().contains(seqs[1]));
361     HiddenSequences hs = al.getHiddenSequences();
362     assertEquals(0, hs.getSize());
363     assertEquals(SEQ_COUNT, al.getHeight());
364
365     /*
366      * hide the second sequence in the alignment
367      */
368     hs.hideSequence(seqs[1]);
369     assertFalse(hs.isHidden(seqs[0]));
370     assertTrue(hs.isHidden(seqs[1]));
371     assertFalse(al.getSequences().contains(seqs[1]));
372     assertEquals(1, hs.getSize());
373     assertEquals(SEQ_COUNT - 1, al.getHeight());
374     assertSame(seqs[2], al.getSequenceAt(1));
375
376     /*
377      * hide what is now the second sequence in the alignment
378      */
379     hs.hideSequence(seqs[2]);
380     assertFalse(hs.isHidden(seqs[0]));
381     assertTrue(hs.isHidden(seqs[1]));
382     assertTrue(hs.isHidden(seqs[2]));
383     assertFalse(al.getSequences().contains(seqs[1]));
384     assertFalse(al.getSequences().contains(seqs[2]));
385     assertEquals(2, hs.getSize());
386     assertEquals(SEQ_COUNT - 2, al.getHeight());
387
388     /*
389      * perform 'reveal' on what is now the second sequence in the alignment
390      * this should unhide the two sequences that precede it
391      */
392     List<SequenceI> revealed = hs.showSequence(1, null);
393     assertEquals(2, revealed.size());
394     assertTrue(revealed.contains(seqs[1]));
395     assertTrue(revealed.contains(seqs[2]));
396     assertEquals(0, hs.getSize());
397     assertEquals(SEQ_COUNT, al.getHeight());
398   }
399
400   /**
401    * Test the method that adds a sequence to the hidden sequences and deletes it
402    * from the alignment, and its converse, where the first hidden sequences are
403    * at the bottom of the alignment (JAL-2437)
404    */
405   @Test(groups = "Functional")
406   public void testHideShowLastSequences()
407   {
408     AlignmentI al = new Alignment(seqs);
409     assertTrue(al.getSequences().contains(seqs[1]));
410     HiddenSequences hs = al.getHiddenSequences();
411     assertEquals(0, hs.getSize());
412     assertEquals(SEQ_COUNT, al.getHeight());
413
414     /*
415      * hide the last sequence in the alignment
416      */
417     hs.hideSequence(seqs[SEQ_COUNT - 1]);
418     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2]));
419     assertTrue(hs.isHidden(seqs[SEQ_COUNT - 1]));
420     assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 1]));
421     assertEquals(1, hs.getSize());
422     assertEquals(SEQ_COUNT - 1, al.getHeight());
423
424     /*
425      * hide the third last sequence in the alignment
426      */
427     hs.hideSequence(seqs[SEQ_COUNT - 3]);
428     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2]));
429     assertTrue(hs.isHidden(seqs[SEQ_COUNT - 3]));
430     assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 3]));
431     assertEquals(2, hs.getSize());
432     assertEquals(SEQ_COUNT - 2, al.getHeight());
433
434     /*
435      * reveal all the sequences, which should be reinstated in the same order as they started in
436      */
437     hs.showAll(null);
438     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 3]));
439     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 1]));
440     assertEquals(seqs[SEQ_COUNT - 3], al.getSequences().get(SEQ_COUNT - 3));
441     assertEquals(seqs[SEQ_COUNT - 2], al.getSequences().get(SEQ_COUNT - 2));
442     assertEquals(seqs[SEQ_COUNT - 1], al.getSequences().get(SEQ_COUNT - 1));
443     assertEquals(0, hs.getSize());
444     assertEquals(SEQ_COUNT, al.getHeight());
445   }
446
447   @Test(groups = "Functional")
448   public void testIsHidden()
449   {
450     AlignmentI al = new Alignment(seqs);
451     HiddenSequences hs = al.getHiddenSequences();
452     hs.hideSequence(seqs[7]);
453     hs.hideSequence(seqs[4]);
454     assertTrue(hs.isHidden(seqs[4]));
455     assertFalse(hs.isHidden(seqs[5]));
456     assertFalse(hs.isHidden(seqs[6]));
457     assertTrue(hs.isHidden(seqs[7]));
458     assertFalse(hs.isHidden(null));
459     assertFalse(hs.isHidden(new Sequence("", "")));
460   }
461
462   /**
463    * Test hiding and unhiding a group with a representative sequence. The
464    * representative should be left visible when the group is hidden, and
465    * included in the selected group when it is unhidden.
466    */
467   @Test(groups = "Functional")
468   public void testHideShowSequence_withHiddenRepSequence()
469   {
470     AlignmentI al = new Alignment(seqs);
471
472     /*
473      * represent seqs 2-4 with seq3
474      * this hides seq2 and seq4 but not seq3
475      */
476     AlignViewport av = new AlignViewport(al);
477     SequenceGroup sg = new SequenceGroup();
478     sg.addSequence(seqs[1], false);
479     sg.addSequence(seqs[2], false);
480     sg.addSequence(seqs[3], false);
481     av.setSelectionGroup(sg);
482
483     /*
484      * hiding group with reference sequence is done via AlignViewport
485      */
486     av.hideSequences(seqs[2], true);
487     HiddenSequences hs = al.getHiddenSequences();
488     assertEquals(2, hs.getSize());
489     assertTrue(hs.isHidden(seqs[1]));
490     assertFalse(hs.isHidden(seqs[2]));
491     assertTrue(hs.isHidden(seqs[3]));
492
493     /*
494      * should now be no sequences selected in the alignment
495      */
496     assertNull(av.getSelectionGroup());
497
498     /*
499      * visible alignment is now seq0/2/4/5/6/7/8/9
500      * 'reveal sequences' at the representative sequence (index = 1)
501      * this should unhide the one above i.e. seq1
502      * and return a selection list including seq2
503      * 
504      * note have to call via AlignViewport to get the expected
505      * resulting sequence selection
506      */
507     av.showSequence(1);
508
509     /*
510      * only seq3 is now hidden
511      */
512     assertEquals(1, hs.getSize());
513     assertTrue(hs.isHidden(seqs[3]));
514     assertEquals(SEQ_COUNT - 1, al.getHeight());
515     sg = av.getSelectionGroup();
516
517     /*
518      * unhidden and representative sequence selected
519      * (this behaviour may change! JAL-2133)
520      */
521     assertEquals(2, sg.getSize());
522     assertTrue(sg.getSequences().contains(seqs[1]));
523     assertTrue(sg.getSequences().contains(seqs[2]));
524     assertFalse(sg.getSequences().contains(seqs[3]));
525   }
526 }