Clover icon

Coverage Report

  1. Project Clover database Thu Dec 4 2025 16:11:35 GMT
  2. Package jalview.datamodel

File HiddenSequencesTest.java

 

Code metrics

8
234
15
1
541
325
19
0.08
15.6
15
1.27

Classes

Class Line # Actions
HiddenSequencesTest 43 234 19
1.0100%
 

Contributing tests

This file is covered by 13 tests. .

Source view

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