2 * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
3 * Copyright (C) $$Year-Rel$$ The Jalview Authors
5 * This file is part of Jalview.
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.
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.
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.
21 package jalview.datamodel;
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;
32 import jalview.gui.AlignViewport;
33 import jalview.gui.JvOptionPane;
35 import java.util.List;
37 import org.testng.annotations.BeforeClass;
38 import org.testng.annotations.BeforeTest;
39 import org.testng.annotations.Test;
41 @Test(singleThreaded = true)
42 public class HiddenSequencesTest
45 @BeforeClass(alwaysRun = true)
46 public void setUpJvOptionPane()
48 JvOptionPane.setInteractiveMode(false);
49 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
52 static int SEQ_COUNT = 10;
57 * Set up an alignment of 10 sequences
59 @BeforeTest(alwaysRun = true)
62 seqs = new SequenceI[SEQ_COUNT];
63 for (int i = 0; i < SEQ_COUNT; i++)
65 // sequence lengths are 1, 2, ... 10
66 seqs[i] = new Sequence("Seq" + i, "abcdefghijk".substring(0, i + 1));
71 * Test the method that converts sequence alignment index to what it would be
72 * if all sequences were unhidden
74 @Test(groups = "Functional")
75 public void testAdjustForHiddenSeqs()
77 AlignmentI al = new Alignment(seqs);
78 HiddenSequences hs = al.getHiddenSequences();
79 for (int i = 0; i < SEQ_COUNT; i++)
81 assertEquals(i, hs.adjustForHiddenSeqs(i));
84 // hide seq1 and seq5 and seq6
85 hs.hideSequence(seqs[1]);
86 hs.hideSequence(seqs[5]);
87 hs.hideSequence(seqs[6]);
90 * alignment is now seq0/2/3/4/7/8/9
92 assertEquals(7, al.getHeight());
93 assertEquals(0, hs.adjustForHiddenSeqs(0));
94 assertEquals(2, hs.adjustForHiddenSeqs(1));
95 assertEquals(3, hs.adjustForHiddenSeqs(2));
96 assertEquals(4, hs.adjustForHiddenSeqs(3));
97 assertEquals(7, hs.adjustForHiddenSeqs(4));
98 assertEquals(8, hs.adjustForHiddenSeqs(5));
99 assertEquals(9, hs.adjustForHiddenSeqs(6));
103 * Test the method that increments the internal array size if a sequence is
104 * added to the alignment (ugh this should not be exposed to the light of day)
106 @Test(groups = "Functional")
107 public void testAdjustHeightSequenceAdded()
109 AlignmentI al = new Alignment(seqs);
110 assertEquals(SEQ_COUNT, al.getHeight());
112 HiddenSequences hs = al.getHiddenSequences();
113 // initially does nothing
114 hs.adjustHeightSequenceAdded();
115 assertNull(hs.hiddenSequences);
118 hs.hideSequence(seqs[3]);
119 assertEquals(1, hs.getSize());
120 assertEquals(SEQ_COUNT - 1, al.getHeight());
121 assertEquals(SEQ_COUNT, hs.hiddenSequences.length);
124 * add a sequence to the alignment
125 * - the safe way to call hs.adjustHeightSequenceAdded!
126 * (implementation depends on alignment height having
127 * been already updated for the added sequence)
129 al.addSequence(new Sequence("a", "b"));
130 assertEquals(1, hs.getSize());
131 assertEquals(SEQ_COUNT, al.getHeight());
132 assertEquals(SEQ_COUNT + 1, hs.hiddenSequences.length);
136 * Test the method that decrements the internal array size if a sequence is
137 * deleted from the alignment (ugh this should not be exposed to the light of
140 @Test(groups = "Functional")
141 public void testAdjustHeightSequenceDeleted()
143 AlignmentI al = new Alignment(seqs);
144 assertEquals(SEQ_COUNT, al.getHeight());
146 HiddenSequences hs = al.getHiddenSequences();
147 // initially does nothing
148 hs.adjustHeightSequenceAdded();
149 assertNull(hs.hiddenSequences);
151 // hide two sequences
152 hs.hideSequence(seqs[3]);
153 hs.hideSequence(seqs[5]);
154 assertEquals(2, hs.getSize());
155 assertTrue(hs.isHidden(seqs[3]));
156 assertTrue(hs.isHidden(seqs[5]));
157 assertEquals(SEQ_COUNT - 2, al.getHeight());
158 assertEquals(SEQ_COUNT, hs.hiddenSequences.length);
161 * delete a visible sequence from the alignment
162 * - the safe way to call hs.adjustHeightSequenceDeleted!
163 * (implementation depends on alignment height having
164 * been already updated for the removed sequence)
166 al.deleteSequence(seqs[2]);
167 assertEquals(2, hs.getSize());
168 // the visible alignment is unchanged:
169 assertEquals(SEQ_COUNT - 3, al.getHeight());
170 // sequences array size has decremented:
171 assertEquals(SEQ_COUNT - 1, hs.hiddenSequences.length);
175 * Test the method that converts a 'full alignment' sequence index into the
176 * equivalent in the alignment with sequences hidden
178 @Test(groups = "Functional")
179 public void testFindIndexWithoutHiddenSeqs()
181 AlignmentI al = new Alignment(seqs);
182 HiddenSequences hs = al.getHiddenSequences();
183 for (int i = 0; i < SEQ_COUNT; i++)
185 assertEquals(i, hs.findIndexWithoutHiddenSeqs(i));
188 // hide seq1 and seq5 and seq6
189 hs.hideSequence(seqs[1]);
190 hs.hideSequence(seqs[5]);
191 hs.hideSequence(seqs[6]);
194 * alignment is now seq0/2/3/4/7/8/9
196 assertEquals(7, al.getHeight());
197 assertEquals(0, hs.findIndexWithoutHiddenSeqs(0));
198 assertEquals(0, hs.findIndexWithoutHiddenSeqs(1));
199 assertEquals(1, hs.findIndexWithoutHiddenSeqs(2));
200 assertEquals(2, hs.findIndexWithoutHiddenSeqs(3));
201 assertEquals(3, hs.findIndexWithoutHiddenSeqs(4));
202 assertEquals(3, hs.findIndexWithoutHiddenSeqs(5));
203 assertEquals(3, hs.findIndexWithoutHiddenSeqs(6));
204 assertEquals(4, hs.findIndexWithoutHiddenSeqs(7));
205 assertEquals(5, hs.findIndexWithoutHiddenSeqs(8));
206 assertEquals(6, hs.findIndexWithoutHiddenSeqs(9));
210 * Test the method that reconstructs (sort of) the full alignment including
213 @Test(groups = "Functional")
214 public void testGetFullAlignment()
216 AlignmentI al = new Alignment(seqs);
217 assertArrayEquals(seqs, al.getSequencesArray());
218 al.setProperty("a", "b");
219 al.addAnnotation(new AlignmentAnnotation("ann", "label", 12f));
220 al.setSeqrep(seqs[4]);
221 SequenceGroup sg = new SequenceGroup();
222 sg.addSequence(seqs[8], false);
224 ((Alignment) al).hasRNAStructure = true;
226 HiddenSequences hs = al.getHiddenSequences();
227 AlignmentI al2 = hs.getFullAlignment();
228 // new alignment but with original sequences
229 assertNotSame(al, al2);
230 assertArrayEquals(al.getSequencesArray(), al2.getSequencesArray());
232 hs.hideSequence(seqs[4]);
233 hs.hideSequence(seqs[9]);
234 al2 = hs.getFullAlignment();
235 assertNotSame(al, al2);
236 assertArrayEquals(seqs, al2.getSequencesArray());
237 assertNotNull(al2.getProperties());
238 assertSame(al.getProperties(), al2.getProperties());
239 assertNotNull(al2.getAlignmentAnnotation());
240 assertSame(al.getAlignmentAnnotation(), al2.getAlignmentAnnotation());
241 assertSame(seqs[4], al2.getSeqrep());
242 assertNotNull(al2.getGroups());
243 assertSame(al.getGroups(), al2.getGroups());
244 assertTrue(al2.hasRNAStructure());
248 * Test the method that returns the hidden sequence at a given index in the
251 * @return either the sequence (if hidden) or null (if not hidden)
253 @Test(groups = "Functional")
254 public void testGetHiddenSequence()
256 AlignmentI al = new Alignment(seqs);
257 HiddenSequences hs = al.getHiddenSequences();
258 assertNull(hs.getHiddenSequence(0));
259 hs.hideSequence(seqs[3]);
260 assertSame(seqs[3], hs.getHiddenSequence(3));
261 assertNull(hs.getHiddenSequence(2));
262 assertNull(hs.getHiddenSequence(4));
265 @Test(groups = "Functional")
266 public void testGetSize()
270 @Test(groups = "Functional")
271 public void testGetWidth()
273 AlignmentI al = new Alignment(seqs);
274 HiddenSequences hs = al.getHiddenSequences();
275 assertEquals(0, hs.getWidth());
276 hs.hideSequence(seqs[6]);
277 hs.hideSequence(seqs[8]);
278 assertEquals(9, hs.getWidth());
282 * Test the method that adds a sequence to the hidden sequences and deletes it
283 * from the alignment, and its converse
285 @Test(groups = "Functional")
286 public void testHideShowSequence()
288 AlignmentI al = new Alignment(seqs);
289 assertTrue(al.getSequences().contains(seqs[1]));
290 HiddenSequences hs = al.getHiddenSequences();
291 assertEquals(0, hs.getSize());
292 assertEquals(10, al.getHeight());
295 * hide the second sequence in the alignment
297 hs.hideSequence(seqs[1]);
298 assertFalse(hs.isHidden(seqs[0]));
299 assertTrue(hs.isHidden(seqs[1]));
300 assertFalse(al.getSequences().contains(seqs[1]));
301 assertEquals(1, hs.getSize());
302 assertEquals(9, al.getHeight());
303 assertSame(seqs[2], al.getSequenceAt(1));
306 * hide what is now the second sequence in the alignment
308 hs.hideSequence(seqs[2]);
309 assertFalse(hs.isHidden(seqs[0]));
310 assertTrue(hs.isHidden(seqs[1]));
311 assertTrue(hs.isHidden(seqs[2]));
312 assertFalse(al.getSequences().contains(seqs[1]));
313 assertFalse(al.getSequences().contains(seqs[2]));
314 assertEquals(2, hs.getSize());
315 assertEquals(8, al.getHeight());
318 * perform 'reveal' on what is now the second sequence in the alignment
319 * this should unhide the two sequences that precede it
321 List<SequenceI> revealed = hs.showSequence(1, null);
322 assertEquals(2, revealed.size());
323 assertTrue(revealed.contains(seqs[1]));
324 assertTrue(revealed.contains(seqs[2]));
325 assertEquals(0, hs.getSize());
326 assertEquals(10, al.getHeight());
329 @Test(groups = "Functional")
330 public void testIsHidden()
332 AlignmentI al = new Alignment(seqs);
333 HiddenSequences hs = al.getHiddenSequences();
334 hs.hideSequence(seqs[7]);
335 hs.hideSequence(seqs[4]);
336 assertTrue(hs.isHidden(seqs[4]));
337 assertFalse(hs.isHidden(seqs[5]));
338 assertFalse(hs.isHidden(seqs[6]));
339 assertTrue(hs.isHidden(seqs[7]));
340 assertFalse(hs.isHidden(null));
341 assertFalse(hs.isHidden(new Sequence("", "")));
345 * Test hiding and unhiding a group with a representative sequence. The
346 * representative should be left visible when the group is hidden, and
347 * included in the selected group when it is unhidden.
349 @Test(groups = "Functional")
350 public void testHideShowSequence_withHiddenRepSequence()
352 AlignmentI al = new Alignment(seqs);
355 * represent seqs 2-4 with seq3
356 * this hides seq2 and seq4 but not seq3
358 AlignViewport av = new AlignViewport(al);
359 SequenceGroup sg = new SequenceGroup();
360 sg.addSequence(seqs[1], false);
361 sg.addSequence(seqs[2], false);
362 sg.addSequence(seqs[3], false);
363 av.setSelectionGroup(sg);
366 * hiding group with reference sequence is done via AlignViewport
368 av.hideSequences(seqs[2], true);
369 HiddenSequences hs = al.getHiddenSequences();
370 assertEquals(2, hs.getSize());
371 assertTrue(hs.isHidden(seqs[1]));
372 assertFalse(hs.isHidden(seqs[2]));
373 assertTrue(hs.isHidden(seqs[3]));
376 * should now be no sequences selected in the alignment
378 assertNull(av.getSelectionGroup());
381 * visible alignment is now seq0/2/4/5/6/7/8/9
382 * 'reveal sequences' at the representative sequence (index = 1)
383 * this should unhide the one above i.e. seq1
384 * and return a selection list including seq2
386 * note have to call via AlignViewport to get the expected
387 * resulting sequence selection
392 * only seq3 is now hidden
394 assertEquals(1, hs.getSize());
395 assertTrue(hs.isHidden(seqs[3]));
396 assertEquals(SEQ_COUNT - 1, al.getHeight());
397 sg = av.getSelectionGroup();
400 * unhidden and representative sequence selected
401 * (this behaviour may change! JAL-2133)
403 assertEquals(2, sg.getSize());
404 assertTrue(sg.getSequences().contains(seqs[1]));
405 assertTrue(sg.getSequences().contains(seqs[2]));
406 assertFalse(sg.getSequences().contains(seqs[3]));