import static org.testng.AssertJUnit.assertTrue;
import jalview.analysis.AlignmentGenerator;
-import jalview.util.Comparison;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Iterator;
-import java.util.Random;
import org.testng.annotations.Test;
assertFalse(cs2.hasHiddenColumns());
}
- /**
- * Test the code used to locate the reference sequence ruler origin
- */
- @Test(groups = { "Functional" })
- public void testLocateVisibleStartofSequence()
- {
- // create random alignment
- AlignmentGenerator gen = new AlignmentGenerator(false);
- AlignmentI al = gen.generate(50, 20, 123, 5, 5);
-
- HiddenColumns cs = al.getHiddenColumns();
- ColumnSelection colsel = new ColumnSelection();
-
- SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
- assertEquals(2, seq.findIndex(seq.getStart()));
-
- // no hidden columns
- assertEquals(seq.findIndex(seq.getStart()) - 1, cs.locateVisibleStartOfSequence(seq));
-
- // hidden column on gap after end of sequence - should not affect bounds
- colsel.hideSelectedColumns(13, al.getHiddenColumns());
- assertEquals(seq.findIndex(seq.getStart()) - 1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- // hidden column on gap before beginning of sequence - should vis bounds by
- // one
- colsel.hideSelectedColumns(0, al.getHiddenColumns());
- assertEquals(seq.findIndex(seq.getStart()) - 2,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- // hide columns around most of sequence - leave one residue remaining
- cs.hideColumns(1, 3);
- cs.hideColumns(6, 11);
- assertEquals("-D",
- cs.getVisibleSequenceStrings(0, 5, new SequenceI[]
- { seq })[0]);
-
- assertEquals(1, cs.locateVisibleStartOfSequence(seq));
- cs.revealAllHiddenColumns(colsel);
-
- // hide whole sequence - should just get location of hidden region
- // containing sequence
- cs.hideColumns(1, 11);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 15);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- SequenceI seq2 = new Sequence("RefSeq2", "-------A-SD-ASD--E---");
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(7, 17);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(3, 17);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(3, 19);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq2));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 0);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 1);
- assertEquals(1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 2);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(1, 1);
- assertEquals(2,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(1, 2);
- assertEquals(1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(1, 3);
- assertEquals(1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 2);
- cs.hideColumns(5, 6);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 2);
- cs.hideColumns(5, 6);
- cs.hideColumns(9, 10);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 2);
- cs.hideColumns(7, 11);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(2, 4);
- cs.hideColumns(7, 11);
- assertEquals(1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(2, 4);
- cs.hideColumns(7, 12);
- assertEquals(1,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(1, 11);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 12);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 4);
- cs.hideColumns(6, 12);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 1);
- cs.hideColumns(3, 12);
- assertEquals(0,cs.locateVisibleStartOfSequence(seq));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(3, 14);
- cs.hideColumns(17, 19);
- assertEquals(3,cs.locateVisibleStartOfSequence(seq2));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(3, 7);
- cs.hideColumns(9, 14);
- cs.hideColumns(17, 19);
- assertEquals(9,cs.locateVisibleStartOfSequence(seq2));
-
- cs.revealAllHiddenColumns(colsel);
- cs.hideColumns(0, 1);
- cs.hideColumns(3, 4);
- cs.hideColumns(6, 8);
- cs.hideColumns(10, 12);
- assertEquals(6, cs.locateVisibleStartOfSequence(seq));
-
- }
-
- @Test(groups = { "Functional" })
- public void testLocateVisibleStartPathologicals()
- {
- // test some pathological cases we missed
- AlignmentI al = new Alignment(
- new SequenceI[]
- { new Sequence("refseqGaptest", "KTDVTI----------NFI-----G----L") });
- HiddenColumns cs = new HiddenColumns();
- cs.hideList(al.getSequenceAt(0).getInsertions());
- assertEquals("G", ""
- + al.getSequenceAt(0).getCharAt(cs.visibleToAbsoluteColumn(9)));
-
- // KM: no idea what this is meant to be testing... seems to be an unfinished
- // test
- }
@Test(groups = { "Functional" })
public void testHideColumns()
}
@Test(groups = { "Functional" })
- public void testHideBitset()
+ public void testHideColumns_BitSet()
{
HiddenColumns cs;
}
@Test(groups = { "Functional" })
- public void testMarkHiddenRegions()
+ public void hideColumns_BitSetAndRange()
{
- BitSet toMark, fromMark;
- long seed = -3241532;
- Random number = new Random(seed);
- for (int n = 0; n < 1000; n++)
- {
- // create a random bitfield
- toMark = BitSet
- .valueOf(new long[]
- { number.nextLong(), number.nextLong(), number.nextLong() });
- toMark.set(n * number.nextInt(10), n * (25 + number.nextInt(25)));
- HiddenColumns hc = new HiddenColumns();
-
- if (n == 0)
- {
- hc.markHiddenRegions(fromMark = new BitSet());
- assertTrue(fromMark.isEmpty());
- }
-
- hc.hideColumns(toMark);
-
- // see if we can recover bitfield
- hc.markHiddenRegions(fromMark = new BitSet());
- assertEquals(toMark, fromMark);
- }
+ HiddenColumns hc = new HiddenColumns();
+ hc.hideColumns(3, 5);
+ hc.hideColumns(15, 20);
+ hc.hideColumns(45, 60);
+
+ BitSet tohide = new BitSet();
+
+ // all unhidden if tohide is empty and range covers hidden
+ hc.hideColumns(tohide, 1, 70);
+ assertTrue(!hc.hasHiddenColumns());
+
+ hc.hideColumns(3, 5);
+ hc.hideColumns(15, 20);
+ hc.hideColumns(45, 60);
+
+ // but not if range does not cover hidden
+ hc.hideColumns(tohide, 23, 40);
+ assertTrue(hc.hasHiddenColumns());
+
+ // and partial unhide if range partially covers
+ hc.hideColumns(tohide, 1, 17);
+ Iterator<int[]> it = hc.iterator();
+ assertTrue(it.hasNext());
+ int[] region = it.next();
+
+ assertEquals(18, region[0]);
+ assertEquals(20, region[1]);
+
+ assertTrue(it.hasNext());
+ region = it.next();
+
+ assertEquals(45, region[0]);
+ assertEquals(60, region[1]);
+
+ assertFalse(it.hasNext());
}
@Test(groups = { "Functional" })
}
@Test(groups = "Functional")
- public void testPropagateInsertions()
- {
- // create an alignment with no gaps - this will be the profile seq and other
- // JPRED seqs
- AlignmentGenerator gen = new AlignmentGenerator(false);
- AlignmentI al = gen.generate(25, 10, 1234, 0, 0);
-
- // get the profileseq
- SequenceI profileseq = al.getSequenceAt(0);
- SequenceI gappedseq = new Sequence(profileseq);
- gappedseq.insertCharAt(5, al.getGapCharacter());
- gappedseq.insertCharAt(6, al.getGapCharacter());
- gappedseq.insertCharAt(7, al.getGapCharacter());
- gappedseq.insertCharAt(8, al.getGapCharacter());
-
- // force different kinds of padding
- al.getSequenceAt(3).deleteChars(2, 23);
- al.getSequenceAt(4).deleteChars(2, 27);
- al.getSequenceAt(5).deleteChars(10, 27);
-
- // create an alignment view with the gapped sequence
- SequenceI[] seqs = new SequenceI[1];
- seqs[0] = gappedseq;
- AlignmentI newal = new Alignment(seqs);
- HiddenColumns hidden = new HiddenColumns();
- hidden.hideColumns(15, 17);
-
- AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
- false);
-
- // confirm that original contigs are as expected
- Iterator<int[]> visible = hidden.getVisContigsIterator(0, 25, false);
- int[] region = visible.next();
- assertEquals("[0, 14]", Arrays.toString(region));
- region = visible.next();
- assertEquals("[18, 24]", Arrays.toString(region));
-
- // propagate insertions
- HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
- view);
-
- // confirm that the contigs have changed to account for the gaps
- visible = result.getVisContigsIterator(0, 25, false);
- region = visible.next();
- assertEquals("[0, 10]", Arrays.toString(region));
- region = visible.next();
- assertEquals("[14, 24]", Arrays.toString(region));
-
- // confirm the alignment has been changed so that the other sequences have
- // gaps inserted where the columns are hidden
- assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[10]));
- assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[11]));
- assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[12]));
- assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[13]));
- assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[14]));
-
- }
-
- @Test(groups = "Functional")
- public void testPropagateInsertionsOverlap()
- {
- // test propagateInsertions where gaps and hiddenColumns overlap
-
- // create an alignment with no gaps - this will be the profile seq and other
- // JPRED seqs
- AlignmentGenerator gen = new AlignmentGenerator(false);
- AlignmentI al = gen.generate(20, 10, 1234, 0, 0);
-
- // get the profileseq
- SequenceI profileseq = al.getSequenceAt(0);
- SequenceI gappedseq = new Sequence(profileseq);
- gappedseq.insertCharAt(5, al.getGapCharacter());
- gappedseq.insertCharAt(6, al.getGapCharacter());
- gappedseq.insertCharAt(7, al.getGapCharacter());
- gappedseq.insertCharAt(8, al.getGapCharacter());
-
- // create an alignment view with the gapped sequence
- SequenceI[] seqs = new SequenceI[1];
- seqs[0] = gappedseq;
- AlignmentI newal = new Alignment(seqs);
-
- // hide columns so that some overlap with the gaps
- HiddenColumns hidden = new HiddenColumns();
- hidden.hideColumns(7, 10);
-
- AlignmentView view = new AlignmentView(newal, hidden, null, true, false,
- false);
-
- // confirm that original contigs are as expected
- Iterator<int[]> visible = hidden.getVisContigsIterator(0, 20, false);
- int[] region = visible.next();
- assertEquals("[0, 6]", Arrays.toString(region));
- region = visible.next();
- assertEquals("[11, 19]", Arrays.toString(region));
- assertFalse(visible.hasNext());
-
- // propagate insertions
- HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al,
- view);
-
- // confirm that the contigs have changed to account for the gaps
- visible = result.getVisContigsIterator(0, 20, false);
- region = visible.next();
- assertEquals("[0, 4]", Arrays.toString(region));
- region = visible.next();
- assertEquals("[7, 19]", Arrays.toString(region));
- assertFalse(visible.hasNext());
-
- // confirm the alignment has been changed so that the other sequences have
- // gaps inserted where the columns are hidden
- assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[4]));
- assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[5]));
- assertTrue(Comparison.isGap(al.getSequenceAt(1).getSequence()[6]));
- assertFalse(Comparison.isGap(al.getSequenceAt(1).getSequence()[7]));
- }
-
- @Test(groups = "Functional")
public void testHasHiddenColumns()
{
HiddenColumns h = new HiddenColumns();
HiddenColumns h = new HiddenColumns();
// returns same value if no hidden cols
- assertEquals(3, h.getHiddenBoundaryLeft(3));
+ assertEquals(3, h.getNextHiddenBoundary(true, 3));
h.hideColumns(5, 10);
- assertEquals(10, h.getHiddenBoundaryLeft(15));
- assertEquals(3, h.getHiddenBoundaryLeft(3));
- assertEquals(7, h.getHiddenBoundaryLeft(7));
+ assertEquals(10, h.getNextHiddenBoundary(true, 15));
+ assertEquals(3, h.getNextHiddenBoundary(true, 3));
+ assertEquals(7, h.getNextHiddenBoundary(true, 7));
h.hideColumns(15, 20);
- assertEquals(10, h.getHiddenBoundaryLeft(15));
- assertEquals(20, h.getHiddenBoundaryLeft(21));
+ assertEquals(10, h.getNextHiddenBoundary(true, 15));
+ assertEquals(20, h.getNextHiddenBoundary(true, 21));
}
@Test(groups = "Functional")
- public void testGetHiddenBoundaryRight()
+ public void testGetNextHiddenBoundary()
{
HiddenColumns h = new HiddenColumns();
// returns same value if no hidden cols
- assertEquals(3, h.getHiddenBoundaryRight(3));
+ assertEquals(3, h.getNextHiddenBoundary(false, 3));
h.hideColumns(5, 10);
- assertEquals(5, h.getHiddenBoundaryRight(3));
- assertEquals(15, h.getHiddenBoundaryRight(15));
- assertEquals(7, h.getHiddenBoundaryRight(7));
+ assertEquals(5, h.getNextHiddenBoundary(false, 3));
+ assertEquals(15, h.getNextHiddenBoundary(false, 15));
+ assertEquals(7, h.getNextHiddenBoundary(false, 7));
h.hideColumns(15, 20);
- assertEquals(15, h.getHiddenBoundaryRight(7));
- assertEquals(15, h.getHiddenBoundaryRight(14));
+ assertEquals(15, h.getNextHiddenBoundary(false, 7));
+ assertEquals(15, h.getNextHiddenBoundary(false, 14));
// returns same value if there is no next hidden column
- assertEquals(22, h.getHiddenBoundaryRight(22));
+ assertEquals(22, h.getNextHiddenBoundary(false, 22));
}
@Test(groups = "Functional")
assertFalse(result.hasNext());
}
- @Test(groups = "Functional")
+ /* @Test(groups = "Functional")
public void testGetVisibleSequenceStrings()
{
HiddenColumns h = new HiddenColumns();
assertEquals(2, result.length);
assertEquals("WKQES", result[0]);
assertEquals("RNDTG", result[1]);
-
+
h.hideColumns(6, 8);
result = h.getVisibleSequenceStrings(5, 10, seqs);
assertEquals(2, result.length);
assertEquals("WS", result[0]);
assertEquals("RG", result[1]);
-
+
SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---");
ColumnSelection sel = new ColumnSelection();
h.revealAllHiddenColumns(sel);
assertEquals("-D",
h.getVisibleSequenceStrings(0, 5, new SequenceI[]
{ seq })[0]);
- }
+ }*/
@Test(groups = "Functional")
public void testHideInsertionsFor()
}
@Test(groups = "Functional")
- public void testHideMarkedBits()
+ public void testHideColumns_BitSet_range()
{
HiddenColumns h = new HiddenColumns();
HiddenColumns h2 = new HiddenColumns();
h.hideColumns(tohide);
assertTrue(h.equals(h2));
- // NB in hideMarkedBits, the last bit is not set to hidden
+ // when setting bitset, first param is invlusive, second exclusive
tohide.set(3, 6);
tohide.set(9);
- tohide.set(19, 21);
- h.hideColumns(tohide);
+ tohide.set(15, 21);
+ h.hideColumns(tohide, 5, 23);
- h2.hideColumns(3, 5);
+ h2.hideColumns(5, 5);
h2.hideColumns(9, 9);
- h2.hideColumns(19, 20);
+ h2.hideColumns(15, 20);
+ assertTrue(h.equals(h2));
+
+ tohide.clear();
+ tohide.set(41);
+ h.hideColumns(tohide, 23, 30);
+ assertTrue(h.equals(h2));
+
+ tohide.set(41);
+ h.hideColumns(tohide, 30, 45);
+ h2.hideColumns(41, 41);
assertTrue(h.equals(h2));
+
+ tohide.clear();
+ tohide.set(25, 28);
+ h.hideColumns(tohide, 17, 50);
+ h2 = new HiddenColumns();
+ h2.hideColumns(17, 20);
+ h2.hideColumns(25, 27);
+ h2.hideColumns(41, 41);
}
@Test(groups = "Functional")
- public void testSubtractVisibleColumns()
+ public void testOffsetByVisibleColumns()
{
HiddenColumns h = new HiddenColumns();
- int result = h.subtractVisibleColumns(1, 10);
+ int result = h.offsetByVisibleColumns(-1, 10);
assertEquals(9, result);
h.hideColumns(7, 9);
- result = h.subtractVisibleColumns(4, 10);
+ result = h.offsetByVisibleColumns(-4, 10);
assertEquals(3, result);
h.hideColumns(14, 15);
- result = h.subtractVisibleColumns(4, 10);
+ result = h.offsetByVisibleColumns(-4, 10);
assertEquals(3, result);
- result = h.subtractVisibleColumns(10, 17);
+ result = h.offsetByVisibleColumns(-10, 17);
assertEquals(2, result);
- result = h.subtractVisibleColumns(1, 7);
+ result = h.offsetByVisibleColumns(-1, 7);
assertEquals(5, result);
- result = h.subtractVisibleColumns(1, 8);
+ result = h.offsetByVisibleColumns(-1, 8);
assertEquals(5, result);
- result = h.subtractVisibleColumns(3, 15);
+ result = h.offsetByVisibleColumns(-3, 15);
assertEquals(10, result);
ColumnSelection sel = new ColumnSelection();
h.revealAllHiddenColumns(sel);
h.hideColumns(0, 30);
- result = h.subtractVisibleColumns(31, 0);
+ result = h.offsetByVisibleColumns(-31, 0);
assertEquals(-31, result);
HiddenColumns cs = new HiddenColumns();
- // test that without hidden columns, findColumnNToLeft returns
+ // test that without hidden columns, offsetByVisibleColumns returns
// position n to left of provided position
- long pos = cs.subtractVisibleColumns(3, 10);
+ long pos = cs.offsetByVisibleColumns(-3, 10);
assertEquals(7, pos);
// 0 returns same position
- pos = cs.subtractVisibleColumns(0, 10);
+ pos = cs.offsetByVisibleColumns(0, 10);
assertEquals(10, pos);
// overflow to left returns negative number
- pos = cs.subtractVisibleColumns(3, 0);
+ pos = cs.offsetByVisibleColumns(-3, 0);
assertEquals(-3, pos);
// test that with hidden columns to left of result column
cs.hideColumns(1, 3);
// position n to left of provided position
- pos = cs.subtractVisibleColumns(3, 10);
+ pos = cs.offsetByVisibleColumns(-3, 10);
assertEquals(7, pos);
// 0 returns same position
- pos = cs.subtractVisibleColumns(0, 10);
+ pos = cs.offsetByVisibleColumns(0, 10);
assertEquals(10, pos);
// test with one set of hidden columns between start and required position
cs.hideColumns(12, 15);
- pos = cs.subtractVisibleColumns(8, 17);
+ pos = cs.offsetByVisibleColumns(-8, 17);
assertEquals(5, pos);
// test with two sets of hidden columns between start and required position
cs.hideColumns(20, 21);
- pos = cs.subtractVisibleColumns(8, 23);
+ pos = cs.offsetByVisibleColumns(-8, 23);
assertEquals(9, pos);
// repeat last 2 tests with no hidden columns to left of required position
// test with one set of hidden columns between start and required position
cs.hideColumns(12, 15);
- pos = cs.subtractVisibleColumns(8, 17);
+ pos = cs.offsetByVisibleColumns(-8, 17);
assertEquals(5, pos);
// test with two sets of hidden columns between start and required position
cs.hideColumns(20, 21);
- pos = cs.subtractVisibleColumns(8, 23);
+ pos = cs.offsetByVisibleColumns(-8, 23);
assertEquals(9, pos);
- }
+ // test with right (positive) offsets
+
+ // test that without hidden columns, offsetByVisibleColumns returns
+ // position n to right of provided position
+ pos = cs.offsetByVisibleColumns(3, 7);
+ assertEquals(10, pos);
+ // test that with hidden columns to left of result column
+ // behaviour is the same as above
+ cs.hideColumns(1, 3);
+
+ // test with one set of hidden columns between start and required position
+ cs.hideColumns(12, 15);
+ pos = cs.offsetByVisibleColumns(8, 5);
+ assertEquals(17, pos);
+
+ // test with two sets of hidden columns between start and required position
+ cs.hideColumns(20, 21);
+ pos = cs.offsetByVisibleColumns(8, 9);
+ assertEquals(23, pos);
+
+ // repeat last 2 tests with no hidden columns to left of required position
+ colsel = new ColumnSelection();
+ cs.revealAllHiddenColumns(colsel);
+
+ // test with one set of hidden columns between start and required position
+ cs.hideColumns(12, 15);
+ pos = cs.offsetByVisibleColumns(8, 5);
+ assertEquals(17, pos);
+
+ // test with two sets of hidden columns between start and required position
+ cs.hideColumns(20, 21);
+ pos = cs.offsetByVisibleColumns(8, 9);
+ assertEquals(23, pos);
+ }
@Test(groups = "Functional")
public void testBoundedIterator()