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.Assert.assertNull;
24 import static org.testng.AssertJUnit.assertEquals;
25 import static org.testng.AssertJUnit.assertFalse;
26 import static org.testng.AssertJUnit.assertTrue;
28 import jalview.analysis.AlignmentGenerator;
29 import jalview.gui.JvOptionPane;
31 import java.util.Arrays;
32 import java.util.BitSet;
33 import java.util.List;
34 import java.util.Random;
36 import org.testng.annotations.BeforeClass;
37 import org.testng.annotations.Test;
39 public class HiddenColumnsTest
42 @BeforeClass(alwaysRun = true)
43 public void setUpJvOptionPane()
45 JvOptionPane.setInteractiveMode(false);
46 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
50 * Test the method which counts the number of hidden columns
52 @Test(groups = { "Functional" })
53 public void testGetSize()
55 HiddenColumns hidden = new HiddenColumns();
56 assertEquals(0, hidden.getSize());
58 hidden.hideColumns(3, 5);
59 assertEquals(3, hidden.getSize());
61 hidden.hideColumns(8, 8);
62 assertEquals(4, hidden.getSize());
64 hidden.hideColumns(9, 14);
65 assertEquals(10, hidden.getSize());
67 ColumnSelection cs = new ColumnSelection();
68 hidden.revealAllHiddenColumns(cs);
69 assertEquals(0, hidden.getSize());
73 * Test the method that finds the visible column position of an alignment
74 * column, allowing for hidden columns.
76 @Test(groups = { "Functional" })
77 public void testFindColumnPosition()
79 HiddenColumns cs = new HiddenColumns();
80 assertEquals(5, cs.findColumnPosition(5));
82 // hiding column 6 makes no difference
84 assertEquals(5, cs.findColumnPosition(5));
86 // hiding column 4 moves column 5 to column 4
88 assertEquals(4, cs.findColumnPosition(5));
90 // hiding column 4 moves column 4 to position 3
91 assertEquals(3, cs.findColumnPosition(4));
93 // hiding columns 1 and 2 moves column 5 to column 2
95 assertEquals(2, cs.findColumnPosition(5));
97 // check with > 1 hidden column regions
98 // where some columns are in the hidden regions
99 HiddenColumns cs2 = new HiddenColumns();
100 cs2.hideColumns(5, 10);
101 cs2.hideColumns(20, 27);
102 cs2.hideColumns(40, 44);
104 // hiding columns 5-10 and 20-27 moves column 8 to column 4
105 assertEquals(4, cs2.findColumnPosition(8));
107 // and moves column 24 to 13
108 assertEquals(13, cs2.findColumnPosition(24));
110 // and moves column 28 to 14
111 assertEquals(14, cs2.findColumnPosition(28));
113 // and moves column 40 to 25
114 assertEquals(25, cs2.findColumnPosition(40));
116 // check when hidden columns start at 0 that the visible column
118 HiddenColumns cs3 = new HiddenColumns();
119 cs3.hideColumns(0, 4);
120 assertEquals(0, cs3.findColumnPosition(2));
125 * Test the method that finds the visible column position a given distance
126 * before another column
128 @Test(groups = { "Functional" })
129 public void testFindColumnNToLeft()
131 HiddenColumns cs = new HiddenColumns();
133 // test that without hidden columns, findColumnNToLeft returns
134 // position n to left of provided position
135 int pos = cs.subtractVisibleColumns(3, 10);
136 assertEquals(7, pos);
138 // 0 returns same position
139 pos = cs.subtractVisibleColumns(0, 10);
140 assertEquals(10, pos);
142 // overflow to left returns negative number
143 pos = cs.subtractVisibleColumns(3, 0);
144 assertEquals(-3, pos);
146 // test that with hidden columns to left of result column
147 // behaviour is the same as above
148 cs.hideColumns(1, 3);
150 // position n to left of provided position
151 pos = cs.subtractVisibleColumns(3, 10);
152 assertEquals(7, pos);
154 // 0 returns same position
155 pos = cs.subtractVisibleColumns(0, 10);
156 assertEquals(10, pos);
158 // test with one set of hidden columns between start and required position
159 cs.hideColumns(12, 15);
160 pos = cs.subtractVisibleColumns(8, 17);
161 assertEquals(5, pos);
163 // test with two sets of hidden columns between start and required position
164 cs.hideColumns(20, 21);
165 pos = cs.subtractVisibleColumns(8, 23);
166 assertEquals(9, pos);
168 // repeat last 2 tests with no hidden columns to left of required position
169 ColumnSelection colsel = new ColumnSelection();
170 cs.revealAllHiddenColumns(colsel);
172 // test with one set of hidden columns between start and required position
173 cs.hideColumns(12, 15);
174 pos = cs.subtractVisibleColumns(8, 17);
175 assertEquals(5, pos);
177 // test with two sets of hidden columns between start and required position
178 cs.hideColumns(20, 21);
179 pos = cs.subtractVisibleColumns(8, 23);
180 assertEquals(9, pos);
184 @Test(groups = { "Functional" })
185 public void testGetVisibleContigs()
187 HiddenColumns cs = new HiddenColumns();
188 cs.hideColumns(3, 6);
189 cs.hideColumns(8, 9);
190 cs.hideColumns(12, 12);
192 // start position is inclusive, end position exclusive:
193 int[] visible = cs.getVisibleContigs(1, 13);
194 assertEquals("[1, 2, 7, 7, 10, 11]", Arrays.toString(visible));
196 visible = cs.getVisibleContigs(4, 14);
197 assertEquals("[7, 7, 10, 11, 13, 13]", Arrays.toString(visible));
199 visible = cs.getVisibleContigs(3, 10);
200 assertEquals("[7, 7]", Arrays.toString(visible));
202 visible = cs.getVisibleContigs(4, 6);
203 assertEquals("[]", Arrays.toString(visible));
206 @Test(groups = { "Functional" })
207 public void testEquals()
209 HiddenColumns cs = new HiddenColumns();
210 cs.hideColumns(5, 9);
212 // a different set of hidden columns
213 HiddenColumns cs2 = new HiddenColumns();
215 // with no hidden columns
216 assertFalse(cs.equals(cs2));
217 assertFalse(cs2.equals(cs));
219 // with hidden columns added in a different order
220 cs2.hideColumns(6, 9);
221 cs2.hideColumns(5, 8);
223 assertTrue(cs.equals(cs2));
224 assertTrue(cs.equals(cs));
225 assertTrue(cs2.equals(cs));
226 assertTrue(cs2.equals(cs2));
229 @Test(groups = "Functional")
230 public void testCopyConstructor()
232 HiddenColumns cs = new HiddenColumns();
233 cs.hideColumns(10, 11);
234 cs.hideColumns(5, 7);
235 assertEquals("[5, 7]",
236 Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
238 HiddenColumns cs2 = new HiddenColumns(cs);
239 assertTrue(cs2.hasHiddenColumns());
240 assertEquals(2, cs2.getHiddenColumnsCopy().size());
241 // hidden columns are held in column order
242 assertEquals("[5, 7]",
243 Arrays.toString(cs2.getHiddenColumnsCopy().get(0)));
244 assertEquals("[10, 11]",
245 Arrays.toString(cs2.getHiddenColumnsCopy().get(1)));
249 * Test the code used to locate the reference sequence ruler origin
251 @Test(groups = { "Functional" })
252 public void testLocateVisibleBoundsofSequence()
254 // create random alignment
255 AlignmentGenerator gen = new AlignmentGenerator(false);
256 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
258 HiddenColumns cs = al.getHiddenColumns();
259 ColumnSelection colsel = new ColumnSelection();
261 SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
262 assertEquals(2, seq.findIndex(seq.getStart()));
266 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
267 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
268 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
269 seq.findIndex(seq.getEnd()) - 1 }),
270 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
272 // hidden column on gap after end of sequence - should not affect bounds
273 colsel.hideSelectedColumns(13, al.getHiddenColumns());
275 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1,
276 seq.findIndex(seq.getEnd()) - 1, seq.getStart(),
277 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
278 seq.findIndex(seq.getEnd()) - 1 }),
279 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
281 cs.revealAllHiddenColumns(colsel);
282 // hidden column on gap before beginning of sequence - should vis bounds by
284 colsel.hideSelectedColumns(0, al.getHiddenColumns());
286 Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2,
287 seq.findIndex(seq.getEnd()) - 2, seq.getStart(),
288 seq.getEnd(), seq.findIndex(seq.getStart()) - 1,
289 seq.findIndex(seq.getEnd()) - 1 }),
290 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
292 cs.revealAllHiddenColumns(colsel);
293 // hide columns around most of sequence - leave one residue remaining
294 cs.hideColumns(1, 3);
295 cs.hideColumns(6, 11);
297 cs.getVisibleSequenceStrings(0, 5, new SequenceI[] { seq })[0]);
299 Arrays.toString(new int[] { 1, 1, 3, 3,
300 seq.findIndex(seq.getStart()) - 1,
301 seq.findIndex(seq.getEnd()) - 1 }),
302 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
303 cs.revealAllHiddenColumns(colsel);
305 // hide whole sequence - should just get location of hidden region
306 // containing sequence
307 cs.hideColumns(1, 11);
309 Arrays.toString(new int[] { 0, 1, 0, 0,
310 seq.findIndex(seq.getStart()) - 1,
311 seq.findIndex(seq.getEnd()) - 1 }),
312 Arrays.toString(cs.locateVisibleBoundsOfSequence(seq)));
316 @Test(groups = { "Functional" })
317 public void testLocateVisibleBoundsPathologicals()
319 // test some pathological cases we missed
320 AlignmentI al = new Alignment(new SequenceI[] { new Sequence(
321 "refseqGaptest", "KTDVTI----------NFI-----G----L") });
322 HiddenColumns cs = new HiddenColumns();
323 cs.hideInsertionsFor(al.getSequenceAt(0));
327 + al.getSequenceAt(0).getCharAt(
328 cs.adjustForHiddenColumns(9)));
332 @Test(groups = { "Functional" })
333 public void testHideColumns()
335 // create random alignment
336 AlignmentGenerator gen = new AlignmentGenerator(false);
337 AlignmentI al = gen.generate(50, 20, 123, 5, 5);
339 ColumnSelection colsel = new ColumnSelection();
340 HiddenColumns cs = al.getHiddenColumns();
341 colsel.hideSelectedColumns(5, al.getHiddenColumns());
342 List<int[]> hidden = cs.getHiddenColumnsCopy();
343 assertEquals(1, hidden.size());
344 assertEquals("[5, 5]", Arrays.toString(hidden.get(0)));
346 colsel.hideSelectedColumns(3, al.getHiddenColumns());
347 hidden = cs.getHiddenColumnsCopy();
348 assertEquals(2, hidden.size());
349 // two hidden ranges, in order:
350 assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size());
351 assertEquals("[3, 3]", Arrays.toString(hidden.get(0)));
352 assertEquals("[5, 5]", Arrays.toString(hidden.get(1)));
354 // hiding column 4 expands [3, 3] to [3, 4]
355 // and merges to [5, 5] to make [3, 5]
356 colsel.hideSelectedColumns(4, al.getHiddenColumns());
357 hidden = cs.getHiddenColumnsCopy();
358 assertEquals(1, hidden.size());
359 assertEquals("[3, 5]", Arrays.toString(hidden.get(0)));
361 // clear hidden columns (note they are added to selected)
362 cs.revealAllHiddenColumns(colsel);
363 // it is now actually null but getter returns an empty list
364 assertTrue(cs.getHiddenColumnsCopy().isEmpty());
366 cs.hideColumns(3, 6);
367 hidden = cs.getHiddenColumnsCopy();
368 int[] firstHiddenRange = hidden.get(0);
369 assertEquals("[3, 6]", Arrays.toString(firstHiddenRange));
371 // adding a subrange of already hidden should do nothing
372 cs.hideColumns(4, 5);
373 hidden = cs.getHiddenColumnsCopy();
374 assertEquals(1, hidden.size());
375 assertEquals("[3, 6]",
376 Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
377 cs.hideColumns(3, 5);
378 hidden = cs.getHiddenColumnsCopy();
379 assertEquals(1, hidden.size());
380 assertEquals("[3, 6]",
381 Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
382 cs.hideColumns(4, 6);
383 hidden = cs.getHiddenColumnsCopy();
384 assertEquals(1, hidden.size());
385 assertEquals("[3, 6]",
386 Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
387 cs.hideColumns(3, 6);
388 hidden = cs.getHiddenColumnsCopy();
389 assertEquals(1, hidden.size());
390 assertEquals("[3, 6]",
391 Arrays.toString(cs.getHiddenColumnsCopy().get(0)));
393 cs.revealAllHiddenColumns(colsel);
394 cs.hideColumns(2, 4);
395 hidden = cs.getHiddenColumnsCopy();
396 assertEquals(1, hidden.size());
397 assertEquals("[2, 4]", Arrays.toString(hidden.get(0)));
399 // extend contiguous with 2 positions overlap
400 cs.hideColumns(3, 5);
401 hidden = cs.getHiddenColumnsCopy();
402 assertEquals(1, hidden.size());
403 assertEquals("[2, 5]", Arrays.toString(hidden.get(0)));
405 // extend contiguous with 1 position overlap
406 cs.hideColumns(5, 6);
407 hidden = cs.getHiddenColumnsCopy();
408 assertEquals(1, hidden.size());
409 assertEquals("[2, 6]", Arrays.toString(hidden.get(0)));
411 // extend contiguous with overlap both ends:
412 cs.hideColumns(1, 7);
413 hidden = cs.getHiddenColumnsCopy();
414 assertEquals(1, hidden.size());
415 assertEquals("[1, 7]", Arrays.toString(hidden.get(0)));
419 * Test the method that reveals a range of hidden columns given the start
420 * column of the range
422 @Test(groups = { "Functional" })
423 public void testRevealHiddenColumns()
425 ColumnSelection colsel = new ColumnSelection();
426 HiddenColumns cs = new HiddenColumns();
427 cs.hideColumns(5, 8);
428 colsel.addElement(10);
429 cs.revealHiddenColumns(5, colsel);
430 // hidden columns list now null but getter returns empty list:
431 assertTrue(cs.getHiddenColumnsCopy().isEmpty());
432 // revealed columns are marked as selected (added to selection):
433 assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString());
435 // calling with a column other than the range start does nothing:
436 colsel = new ColumnSelection();
437 cs = new HiddenColumns();
438 cs.hideColumns(5, 8);
439 List<int[]> hidden = cs.getHiddenColumnsCopy();
440 cs.revealHiddenColumns(6, colsel);
441 assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size());
442 assertTrue(colsel.getSelected().isEmpty());
445 @Test(groups = { "Functional" })
446 public void testRevealAllHiddenColumns()
448 HiddenColumns cs = new HiddenColumns();
449 ColumnSelection colsel = new ColumnSelection();
450 cs.hideColumns(5, 8);
451 cs.hideColumns(2, 3);
452 colsel.addElement(11);
453 colsel.addElement(1);
454 cs.revealAllHiddenColumns(colsel);
457 * revealing hidden columns adds them (in order) to the (unordered)
460 assertTrue(cs.getHiddenColumnsCopy().isEmpty());
461 assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected()
465 @Test(groups = { "Functional" })
466 public void testIsVisible()
468 HiddenColumns cs = new HiddenColumns();
469 cs.hideColumns(2, 4);
470 cs.hideColumns(6, 7);
471 assertTrue(cs.isVisible(0));
472 assertTrue(cs.isVisible(-99));
473 assertTrue(cs.isVisible(1));
474 assertFalse(cs.isVisible(2));
475 assertFalse(cs.isVisible(3));
476 assertFalse(cs.isVisible(4));
477 assertTrue(cs.isVisible(5));
478 assertFalse(cs.isVisible(6));
479 assertFalse(cs.isVisible(7));
483 * Test for the case when a hidden range encloses more one already hidden
486 @Test(groups = { "Functional" })
487 public void testHideColumns_subsumingHidden()
490 * JAL-2370 bug scenario:
491 * two hidden ranges subsumed by a third
493 HiddenColumns cs = new HiddenColumns();
494 cs.hideColumns(49, 59);
495 cs.hideColumns(69, 79);
496 List<int[]> hidden = cs.getHiddenColumnsCopy();
497 assertEquals(2, hidden.size());
498 assertEquals("[49, 59]", Arrays.toString(hidden.get(0)));
499 assertEquals("[69, 79]", Arrays.toString(hidden.get(1)));
501 cs.hideColumns(48, 80);
502 hidden = cs.getHiddenColumnsCopy();
503 assertEquals(1, hidden.size());
504 assertEquals("[48, 80]", Arrays.toString(hidden.get(0)));
507 * another...joining hidden ranges
509 cs = new HiddenColumns();
510 cs.hideColumns(10, 20);
511 cs.hideColumns(30, 40);
512 cs.hideColumns(50, 60);
513 // hiding 21-49 should merge to one range
514 cs.hideColumns(21, 49);
515 hidden = cs.getHiddenColumnsCopy();
516 assertEquals(1, hidden.size());
517 assertEquals("[10, 60]", Arrays.toString(hidden.get(0)));
520 * another...left overlap, subsumption, right overlap,
521 * no overlap of existing hidden ranges
523 cs = new HiddenColumns();
524 cs.hideColumns(10, 20);
525 cs.hideColumns(10, 20);
526 cs.hideColumns(30, 35);
527 cs.hideColumns(40, 50);
528 cs.hideColumns(60, 70);
530 cs.hideColumns(15, 45);
531 hidden = cs.getHiddenColumnsCopy();
532 assertEquals(2, hidden.size());
533 assertEquals("[10, 50]", Arrays.toString(hidden.get(0)));
534 assertEquals("[60, 70]", Arrays.toString(hidden.get(1)));
537 @Test(groups = { "Functional" })
538 public void testHideBitset()
542 BitSet one = new BitSet();
546 cs = new HiddenColumns();
547 cs.hideMarkedBits(one);
548 assertEquals(1, cs.getHiddenColumnsCopy().size());
551 cs = new HiddenColumns();
552 cs.hideMarkedBits(one);
553 assertEquals(1, cs.getHiddenColumnsCopy().size());
556 cs = new HiddenColumns();
557 cs.hideMarkedBits(one);
558 assertEquals(1, cs.getHiddenColumnsCopy().size());
562 cs = new HiddenColumns();
563 cs.hideMarkedBits(one);
564 assertEquals(2, cs.getHiddenColumnsCopy().size());
566 assertEquals(0, cs.adjustForHiddenColumns(0));
567 assertEquals(2, cs.adjustForHiddenColumns(1));
568 assertEquals(4, cs.adjustForHiddenColumns(2));
572 cs = new HiddenColumns();
573 cs.hideMarkedBits(one);
575 assertEquals(1, cs.getHiddenColumnsCopy().size());
577 assertEquals(0, cs.adjustForHiddenColumns(0));
578 assertEquals(1, cs.adjustForHiddenColumns(1));
579 assertEquals(2, cs.adjustForHiddenColumns(2));
580 assertEquals(4, cs.adjustForHiddenColumns(3));
583 @Test(groups = { "Functional" })
584 public void testGetBitset()
586 BitSet toMark, fromMark;
587 long seed = -3241532;
588 Random number = new Random(seed);
589 for (int n = 0; n < 1000; n++)
591 // create a random bitfield
592 toMark = BitSet.valueOf(new long[] { number.nextLong(),
593 number.nextLong(), number.nextLong() });
594 toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
595 HiddenColumns hc = new HiddenColumns();
596 hc.hideMarkedBits(toMark);
598 // see if we can recover bitfield
599 hc.markHiddenRegions(fromMark = new BitSet());
600 assertEquals(toMark, fromMark);
604 @Test(groups = { "Functional" })
605 public void testFindHiddenRegionPositions()
607 HiddenColumns hc = new HiddenColumns();
609 List<Integer> positions = hc.findHiddenRegionPositions();
610 assertTrue(positions.isEmpty());
612 hc.hideColumns(3, 7);
613 hc.hideColumns(10, 10);
614 hc.hideColumns(14, 15);
616 positions = hc.findHiddenRegionPositions();
617 assertEquals(3, positions.size());
618 assertEquals(3, positions.get(0).intValue());
619 assertEquals(5, positions.get(1).intValue());
620 assertEquals(8, positions.get(2).intValue());
623 @Test(groups = { "Functional" })
624 public void testRegionsToString()
626 HiddenColumns hc = new HiddenColumns();
628 String result = hc.regionsToString(",", "--");
629 assertEquals("", result);
631 hc.hideColumns(3, 7);
632 hc.hideColumns(10, 10);
633 hc.hideColumns(14, 15);
635 result = hc.regionsToString(",", "--");
636 assertEquals("3--7,10--10,14--15", result);
639 @Test(groups = "Functional")
640 public void getVisibleStartAndEndIndexTest()
642 Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
643 AlignmentI align = new Alignment(new SequenceI[] { seq });
644 HiddenColumns hc = new HiddenColumns();
646 int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
647 assertEquals(0, startEnd[0]);
648 assertEquals(25, startEnd[1]);
650 hc.hideColumns(0, 0);
651 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
652 assertEquals(1, startEnd[0]);
653 assertEquals(25, startEnd[1]);
655 hc.hideColumns(6, 9);
656 hc.hideColumns(11, 12);
657 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
658 assertEquals(1, startEnd[0]);
659 assertEquals(25, startEnd[1]);
661 hc.hideColumns(24, 25);
662 startEnd = hc.getVisibleStartAndEndIndex(align.getWidth());
663 System.out.println(startEnd[0] + " : " + startEnd[1]);
664 assertEquals(1, startEnd[0]);
665 assertEquals(23, startEnd[1]);
668 @Test(groups = "Functional")
669 public void testGetRegionWithEdgeAtRes()
671 HiddenColumns hc = new HiddenColumns();
673 int[] result = hc.getRegionWithEdgeAtRes(5);
676 hc.hideColumns(3, 7);
677 hc.hideColumns(10, 10);
678 hc.hideColumns(14, 15);
680 result = hc.getRegionWithEdgeAtRes(3);
681 assertEquals(3, result[0]);
682 assertEquals(7, result[1]);
684 result = hc.getRegionWithEdgeAtRes(5);
685 assertEquals(10, result[0]);
686 assertEquals(10, result[1]);
688 result = hc.getRegionWithEdgeAtRes(6);
692 @Test(groups = "Functional")
693 public void testPropagateInsertions()
695 // create an alignment with no gaps - this will be the profile seq and other
697 AlignmentGenerator gen = new AlignmentGenerator(false);
698 AlignmentI al = gen.generate(20, 10, 1234, 0, 0);
700 // get the profileseq
701 SequenceI profileseq = al.getSequenceAt(0);
702 SequenceI gappedseq = new Sequence(profileseq);
703 gappedseq.insertCharAt(5, al.getGapCharacter());
704 gappedseq.insertCharAt(6, al.getGapCharacter());
705 gappedseq.insertCharAt(7, al.getGapCharacter());
706 gappedseq.insertCharAt(8, al.getGapCharacter());
708 // create an alignment view with the gapped sequence
709 SequenceI[] seqs = new SequenceI[1];
711 AlignmentI newal = new Alignment(seqs);
712 HiddenColumns hidden = new HiddenColumns();
713 hidden.hideColumns(15, 17);
715 AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
718 // confirm that original contigs are as expected
719 int[] oldcontigs = hidden.getVisibleContigs(0, 20);
720 int[] testcontigs = { 0, 14, 18, 19 };
721 assertTrue(Arrays.equals(oldcontigs, testcontigs));
723 // propagate insertions
724 HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
727 // confirm that the contigs have changed to account for the gaps
728 int[] newcontigs = result.getVisibleContigs(0, 20);
731 assertTrue(Arrays.equals(newcontigs, testcontigs));