JFrame fix for Window->JComponent
[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     int height = al.getHeight();
185     for (int i = 0; i < height; i++)
186     {
187       assertEquals(i, hs.findIndexWithoutHiddenSeqs(i));
188     }
189
190     // hide seq1 and seq5 and seq6
191     hs.hideSequence(seqs[1]);
192     hs.hideSequence(seqs[5]);
193     hs.hideSequence(seqs[6]);
194
195     /*
196      * alignment is now seq0/2/3/4/7/8/9
197      */
198     assertEquals(height - 3, al.getHeight());
199     assertEquals(0, hs.findIndexWithoutHiddenSeqs(0));
200     assertEquals(0, hs.findIndexWithoutHiddenSeqs(1));
201     assertEquals(1, hs.findIndexWithoutHiddenSeqs(2));
202     assertEquals(2, hs.findIndexWithoutHiddenSeqs(3));
203     assertEquals(3, hs.findIndexWithoutHiddenSeqs(4));
204     assertEquals(3, hs.findIndexWithoutHiddenSeqs(5));
205     assertEquals(3, hs.findIndexWithoutHiddenSeqs(6));
206     assertEquals(4, hs.findIndexWithoutHiddenSeqs(7));
207     assertEquals(5, hs.findIndexWithoutHiddenSeqs(8));
208     assertEquals(6, hs.findIndexWithoutHiddenSeqs(9));
209
210     /*
211      * hide first two sequences
212      */
213     hs.showAll(null);
214     hs.hideSequence(seqs[0]);
215     hs.hideSequence(seqs[1]);
216     assertEquals(-1, hs.findIndexWithoutHiddenSeqs(0));
217     assertEquals(-1, hs.findIndexWithoutHiddenSeqs(1));
218     for (int i = 2; i < height; i++)
219     {
220       assertEquals(i - 2, hs.findIndexWithoutHiddenSeqs(i));
221     }
222   }
223
224   /**
225    * Test the method that finds the visible row position a given distance before
226    * another row
227    */
228   @Test(groups = { "Functional" })
229   public void testFindIndexNFromRow()
230   {
231     AlignmentI al = new Alignment(seqs);
232     HiddenSequences hs = new HiddenSequences(al);
233
234     // test that without hidden rows, findIndexNFromRow returns
235     // position n above provided position
236     int pos = hs.subtractVisibleRows(3, 10);
237     assertEquals(7, pos);
238
239     // 0 returns same position
240     pos = hs.subtractVisibleRows(0, 10);
241     assertEquals(10, pos);
242
243     // overflow to top returns negative number
244     pos = hs.subtractVisibleRows(3, 0);
245     assertEquals(-3, pos);
246
247     // test that with hidden rows above result row
248     // behaviour is the same as above
249     hs.hideSequence(seqs[1]);
250     hs.hideSequence(seqs[2]);
251     hs.hideSequence(seqs[3]);
252
253     // position n above provided position
254     pos = hs.subtractVisibleRows(3, 10);
255     assertEquals(7, pos);
256
257     // 0 returns same position
258     pos = hs.subtractVisibleRows(0, 10);
259     assertEquals(10, pos);
260
261     // test with one set of hidden rows between start and required position
262     hs.hideSequence(seqs[12]);
263     hs.hideSequence(seqs[13]);
264     hs.hideSequence(seqs[14]);
265     hs.hideSequence(seqs[15]);
266     pos = hs.subtractVisibleRows(8, 17);
267     assertEquals(5, pos);
268
269     // test with two sets of hidden rows between start and required position
270     hs.hideSequence(seqs[20]);
271     hs.hideSequence(seqs[21]);
272     pos = hs.subtractVisibleRows(8, 23);
273     assertEquals(9, pos);
274
275     // repeat last 2 tests with no hidden columns to left of required position
276     hs.showAll(null);
277
278     // test with one set of hidden rows between start and required position
279     hs.hideSequence(seqs[12]);
280     hs.hideSequence(seqs[13]);
281     hs.hideSequence(seqs[14]);
282     hs.hideSequence(seqs[15]);
283     pos = hs.subtractVisibleRows(8, 17);
284     assertEquals(5, pos);
285
286     // test with two sets of hidden rows between start and required position
287     hs.hideSequence(seqs[20]);
288     hs.hideSequence(seqs[21]);
289     pos = hs.subtractVisibleRows(8, 23);
290     assertEquals(9, pos);
291
292   }
293
294   /**
295    * Test the method that reconstructs (sort of) the full alignment including
296    * hidden sequences
297    */
298   @Test(groups = "Functional")
299   public void testGetFullAlignment()
300   {
301     AlignmentI al = new Alignment(seqs);
302     assertArrayEquals(seqs, al.getSequencesArray());
303     al.setProperty("a", "b");
304     al.addAnnotation(new AlignmentAnnotation("ann", "label", 12f));
305     al.setSeqrep(seqs[4]);
306     SequenceGroup sg = new SequenceGroup();
307     sg.addSequence(seqs[8], false);
308     al.addGroup(sg);
309     ((Alignment) al).hasRNAStructure = true;
310
311     HiddenSequences hs = al.getHiddenSequences();
312     AlignmentI al2 = hs.getFullAlignment();
313     // new alignment but with original sequences
314     assertNotSame(al, al2);
315     assertArrayEquals(al.getSequencesArray(), al2.getSequencesArray());
316
317     hs.hideSequence(seqs[4]);
318     hs.hideSequence(seqs[9]);
319     al2 = hs.getFullAlignment();
320     assertNotSame(al, al2);
321     assertArrayEquals(seqs, al2.getSequencesArray());
322     assertNotNull(al2.getProperties());
323     assertSame(al.getProperties(), al2.getProperties());
324     assertNotNull(al2.getAlignmentAnnotation());
325     assertSame(al.getAlignmentAnnotation(), al2.getAlignmentAnnotation());
326     assertSame(seqs[4], al2.getSeqrep());
327     assertNotNull(al2.getGroups());
328     assertSame(al.getGroups(), al2.getGroups());
329     assertTrue(al2.hasRNAStructure());
330   }
331
332   /**
333    * Test the method that returns the hidden sequence at a given index in the
334    * full alignment
335    * 
336    * @return either the sequence (if hidden) or null (if not hidden)
337    */
338   @Test(groups = "Functional")
339   public void testGetHiddenSequence()
340   {
341     AlignmentI al = new Alignment(seqs);
342     HiddenSequences hs = al.getHiddenSequences();
343     assertNull(hs.getHiddenSequence(0));
344     hs.hideSequence(seqs[3]);
345     assertSame(seqs[3], hs.getHiddenSequence(3));
346     assertNull(hs.getHiddenSequence(2));
347     assertNull(hs.getHiddenSequence(4));
348   }
349
350   @Test(groups = "Functional")
351   public void testGetSize()
352   {
353   }
354
355   @Test(groups = "Functional")
356   public void testGetWidth()
357   {
358     AlignmentI al = new Alignment(seqs);
359     HiddenSequences hs = al.getHiddenSequences();
360     assertEquals(0, hs.getWidth());
361     hs.hideSequence(seqs[6]);
362     hs.hideSequence(seqs[8]);
363     assertEquals(9, hs.getWidth());
364   }
365
366   /**
367    * Test the method that adds a sequence to the hidden sequences and deletes it
368    * from the alignment, and its converse
369    */
370   @Test(groups = "Functional")
371   public void testHideShowSequence()
372   {
373     AlignmentI al = new Alignment(seqs);
374     assertTrue(al.getSequences().contains(seqs[1]));
375     HiddenSequences hs = al.getHiddenSequences();
376     assertEquals(0, hs.getSize());
377     assertEquals(SEQ_COUNT, al.getHeight());
378
379     /*
380      * hide the second sequence in the alignment
381      */
382     hs.hideSequence(seqs[1]);
383     assertFalse(hs.isHidden(seqs[0]));
384     assertTrue(hs.isHidden(seqs[1]));
385     assertFalse(al.getSequences().contains(seqs[1]));
386     assertEquals(1, hs.getSize());
387     assertEquals(SEQ_COUNT - 1, al.getHeight());
388     assertSame(seqs[2], al.getSequenceAt(1));
389
390     /*
391      * hide what is now the second sequence in the alignment
392      */
393     hs.hideSequence(seqs[2]);
394     assertFalse(hs.isHidden(seqs[0]));
395     assertTrue(hs.isHidden(seqs[1]));
396     assertTrue(hs.isHidden(seqs[2]));
397     assertFalse(al.getSequences().contains(seqs[1]));
398     assertFalse(al.getSequences().contains(seqs[2]));
399     assertEquals(2, hs.getSize());
400     assertEquals(SEQ_COUNT - 2, al.getHeight());
401
402     /*
403      * perform 'reveal' on what is now the second sequence in the alignment
404      * this should unhide the two sequences that precede it
405      */
406     List<SequenceI> revealed = hs.showSequence(1, null);
407     assertEquals(2, revealed.size());
408     assertTrue(revealed.contains(seqs[1]));
409     assertTrue(revealed.contains(seqs[2]));
410     assertEquals(0, hs.getSize());
411     assertEquals(SEQ_COUNT, al.getHeight());
412   }
413
414   /**
415    * Test the method that adds a sequence to the hidden sequences and deletes it
416    * from the alignment, and its converse, where the first hidden sequences are
417    * at the bottom of the alignment (JAL-2437)
418    */
419   @Test(groups = "Functional")
420   public void testHideShowLastSequences()
421   {
422     AlignmentI al = new Alignment(seqs);
423     assertTrue(al.getSequences().contains(seqs[1]));
424     HiddenSequences hs = al.getHiddenSequences();
425     assertEquals(0, hs.getSize());
426     assertEquals(SEQ_COUNT, al.getHeight());
427
428     /*
429      * hide the last sequence in the alignment
430      */
431     hs.hideSequence(seqs[SEQ_COUNT - 1]);
432     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2]));
433     assertTrue(hs.isHidden(seqs[SEQ_COUNT - 1]));
434     assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 1]));
435     assertEquals(1, hs.getSize());
436     assertEquals(SEQ_COUNT - 1, al.getHeight());
437
438     /*
439      * hide the third last sequence in the alignment
440      */
441     hs.hideSequence(seqs[SEQ_COUNT - 3]);
442     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 2]));
443     assertTrue(hs.isHidden(seqs[SEQ_COUNT - 3]));
444     assertFalse(al.getSequences().contains(seqs[SEQ_COUNT - 3]));
445     assertEquals(2, hs.getSize());
446     assertEquals(SEQ_COUNT - 2, al.getHeight());
447
448     /*
449      * reveal all the sequences, which should be reinstated in the same order as they started in
450      */
451     hs.showAll(null);
452     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 3]));
453     assertFalse(hs.isHidden(seqs[SEQ_COUNT - 1]));
454     assertEquals(seqs[SEQ_COUNT - 3], al.getSequences().get(SEQ_COUNT - 3));
455     assertEquals(seqs[SEQ_COUNT - 2], al.getSequences().get(SEQ_COUNT - 2));
456     assertEquals(seqs[SEQ_COUNT - 1], al.getSequences().get(SEQ_COUNT - 1));
457     assertEquals(0, hs.getSize());
458     assertEquals(SEQ_COUNT, al.getHeight());
459   }
460
461   @Test(groups = "Functional")
462   public void testIsHidden()
463   {
464     AlignmentI al = new Alignment(seqs);
465     HiddenSequences hs = al.getHiddenSequences();
466     hs.hideSequence(seqs[7]);
467     hs.hideSequence(seqs[4]);
468     assertTrue(hs.isHidden(seqs[4]));
469     assertFalse(hs.isHidden(seqs[5]));
470     assertFalse(hs.isHidden(seqs[6]));
471     assertTrue(hs.isHidden(seqs[7]));
472     assertFalse(hs.isHidden(null));
473     assertFalse(hs.isHidden(new Sequence("", "")));
474   }
475
476   /**
477    * Test hiding and unhiding a group with a representative sequence. The
478    * representative should be left visible when the group is hidden, and
479    * included in the selected group when it is unhidden.
480    */
481   @Test(groups = "Functional")
482   public void testHideShowSequence_withHiddenRepSequence()
483   {
484     AlignmentI al = new Alignment(seqs);
485
486     /*
487      * represent seqs 2-4 with seq3
488      * this hides seq2 and seq4 but not seq3
489      */
490     AlignViewport av = new AlignViewport(al);
491     SequenceGroup sg = new SequenceGroup();
492     sg.addSequence(seqs[1], false);
493     sg.addSequence(seqs[2], false);
494     sg.addSequence(seqs[3], false);
495     av.setSelectionGroup(sg);
496
497     /*
498      * hiding group with reference sequence is done via AlignViewport
499      */
500     av.hideSequences(seqs[2], true);
501     HiddenSequences hs = al.getHiddenSequences();
502     assertEquals(2, hs.getSize());
503     assertTrue(hs.isHidden(seqs[1]));
504     assertFalse(hs.isHidden(seqs[2]));
505     assertTrue(hs.isHidden(seqs[3]));
506
507     /*
508      * should now be no sequences selected in the alignment
509      */
510     assertNull(av.getSelectionGroup());
511
512     /*
513      * visible alignment is now seq0/2/4/5/6/7/8/9
514      * 'reveal sequences' at the representative sequence (index = 1)
515      * this should unhide the one above i.e. seq1
516      * and return a selection list including seq2
517      * 
518      * note have to call via AlignViewport to get the expected
519      * resulting sequence selection
520      */
521     av.showSequence(1);
522
523     /*
524      * only seq3 is now hidden
525      */
526     assertEquals(1, hs.getSize());
527     assertTrue(hs.isHidden(seqs[3]));
528     assertEquals(SEQ_COUNT - 1, al.getHeight());
529     sg = av.getSelectionGroup();
530
531     /*
532      * unhidden and representative sequence selected
533      * (this behaviour may change! JAL-2133)
534      */
535     assertEquals(2, sg.getSize());
536     assertTrue(sg.getSequences().contains(seqs[1]));
537     assertTrue(sg.getSequences().contains(seqs[2]));
538     assertFalse(sg.getSequences().contains(seqs[3]));
539   }
540 }