X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FHiddenColumnsTest.java;h=7c88d7109a988583d6e9b713ba8ddba4a6a59a91;hb=783c351b9a8aed11ea41c9db193e8ae3be20b017;hp=a6712631f84c464341f05821b135c09c3326504a;hpb=ce3d87d456ac70e1677909dc527eb548275e6daa;p=jalview.git diff --git a/test/jalview/datamodel/HiddenColumnsTest.java b/test/jalview/datamodel/HiddenColumnsTest.java index a671263..7c88d71 100644 --- a/test/jalview/datamodel/HiddenColumnsTest.java +++ b/test/jalview/datamodel/HiddenColumnsTest.java @@ -20,9 +20,9 @@ */ package jalview.datamodel; +import static org.testng.Assert.assertNull; import static org.testng.AssertJUnit.assertEquals; import static org.testng.AssertJUnit.assertFalse; -import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; import jalview.analysis.AlignmentGenerator; @@ -31,6 +31,7 @@ import jalview.gui.JvOptionPane; import java.util.Arrays; import java.util.BitSet; import java.util.List; +import java.util.Random; import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; @@ -231,14 +232,17 @@ public class HiddenColumnsTest HiddenColumns cs = new HiddenColumns(); cs.hideColumns(10, 11); cs.hideColumns(5, 7); - assertEquals("[5, 7]", Arrays.toString(cs.getHiddenRegions().get(0))); + assertEquals("[5, 7]", + Arrays.toString(cs.getHiddenColumnsCopy().get(0))); HiddenColumns cs2 = new HiddenColumns(cs); assertTrue(cs2.hasHiddenColumns()); - assertEquals(2, cs2.getHiddenRegions().size()); + assertEquals(2, cs2.getHiddenColumnsCopy().size()); // hidden columns are held in column order - assertEquals("[5, 7]", Arrays.toString(cs2.getHiddenRegions().get(0))); - assertEquals("[10, 11]", Arrays.toString(cs2.getHiddenRegions().get(1))); + assertEquals("[5, 7]", + Arrays.toString(cs2.getHiddenColumnsCopy().get(0))); + assertEquals("[10, 11]", + Arrays.toString(cs2.getHiddenColumnsCopy().get(1))); } /** @@ -335,66 +339,78 @@ public class HiddenColumnsTest ColumnSelection colsel = new ColumnSelection(); HiddenColumns cs = al.getHiddenColumns(); colsel.hideSelectedColumns(5, al.getHiddenColumns()); - List hidden = cs.getHiddenRegions(); + List hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[5, 5]", Arrays.toString(hidden.get(0))); colsel.hideSelectedColumns(3, al.getHiddenColumns()); + hidden = cs.getHiddenColumnsCopy(); assertEquals(2, hidden.size()); // two hidden ranges, in order: - assertSame(hidden, cs.getHiddenRegions()); + assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size()); assertEquals("[3, 3]", Arrays.toString(hidden.get(0))); assertEquals("[5, 5]", Arrays.toString(hidden.get(1))); // hiding column 4 expands [3, 3] to [3, 4] // and merges to [5, 5] to make [3, 5] colsel.hideSelectedColumns(4, al.getHiddenColumns()); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[3, 5]", Arrays.toString(hidden.get(0))); // clear hidden columns (note they are added to selected) cs.revealAllHiddenColumns(colsel); // it is now actually null but getter returns an empty list - assertTrue(cs.getHiddenRegions().isEmpty()); + assertTrue(cs.getHiddenColumnsCopy().isEmpty()); cs.hideColumns(3, 6); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); int[] firstHiddenRange = hidden.get(0); assertEquals("[3, 6]", Arrays.toString(firstHiddenRange)); // adding a subrange of already hidden should do nothing cs.hideColumns(4, 5); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); - assertSame(firstHiddenRange, cs.getHiddenRegions().get(0)); + assertEquals("[3, 6]", + Arrays.toString(cs.getHiddenColumnsCopy().get(0))); cs.hideColumns(3, 5); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); - assertSame(firstHiddenRange, cs.getHiddenRegions().get(0)); + assertEquals("[3, 6]", + Arrays.toString(cs.getHiddenColumnsCopy().get(0))); cs.hideColumns(4, 6); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); - assertSame(firstHiddenRange, cs.getHiddenRegions().get(0)); + assertEquals("[3, 6]", + Arrays.toString(cs.getHiddenColumnsCopy().get(0))); cs.hideColumns(3, 6); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); - assertSame(firstHiddenRange, cs.getHiddenRegions().get(0)); + assertEquals("[3, 6]", + Arrays.toString(cs.getHiddenColumnsCopy().get(0))); cs.revealAllHiddenColumns(colsel); cs.hideColumns(2, 4); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[2, 4]", Arrays.toString(hidden.get(0))); // extend contiguous with 2 positions overlap cs.hideColumns(3, 5); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[2, 5]", Arrays.toString(hidden.get(0))); // extend contiguous with 1 position overlap cs.hideColumns(5, 6); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[2, 6]", Arrays.toString(hidden.get(0))); // extend contiguous with overlap both ends: cs.hideColumns(1, 7); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[1, 7]", Arrays.toString(hidden.get(0))); } @@ -412,7 +428,7 @@ public class HiddenColumnsTest colsel.addElement(10); cs.revealHiddenColumns(5, colsel); // hidden columns list now null but getter returns empty list: - assertTrue(cs.getHiddenRegions().isEmpty()); + assertTrue(cs.getHiddenColumnsCopy().isEmpty()); // revealed columns are marked as selected (added to selection): assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString()); @@ -420,9 +436,9 @@ public class HiddenColumnsTest colsel = new ColumnSelection(); cs = new HiddenColumns(); cs.hideColumns(5, 8); - List hidden = cs.getHiddenRegions(); + List hidden = cs.getHiddenColumnsCopy(); cs.revealHiddenColumns(6, colsel); - assertSame(hidden, cs.getHiddenRegions()); + assertEquals(hidden.size(), cs.getHiddenColumnsCopy().size()); assertTrue(colsel.getSelected().isEmpty()); } @@ -441,7 +457,7 @@ public class HiddenColumnsTest * revealing hidden columns adds them (in order) to the (unordered) * selection list */ - assertTrue(cs.getHiddenRegions().isEmpty()); + assertTrue(cs.getHiddenColumnsCopy().isEmpty()); assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", colsel.getSelected() .toString()); } @@ -477,13 +493,13 @@ public class HiddenColumnsTest HiddenColumns cs = new HiddenColumns(); cs.hideColumns(49, 59); cs.hideColumns(69, 79); - List hidden = cs.getHiddenRegions(); + List hidden = cs.getHiddenColumnsCopy(); assertEquals(2, hidden.size()); assertEquals("[49, 59]", Arrays.toString(hidden.get(0))); assertEquals("[69, 79]", Arrays.toString(hidden.get(1))); cs.hideColumns(48, 80); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[48, 80]", Arrays.toString(hidden.get(0))); @@ -496,7 +512,7 @@ public class HiddenColumnsTest cs.hideColumns(50, 60); // hiding 21-49 should merge to one range cs.hideColumns(21, 49); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); assertEquals(1, hidden.size()); assertEquals("[10, 60]", Arrays.toString(hidden.get(0))); @@ -512,7 +528,7 @@ public class HiddenColumnsTest cs.hideColumns(60, 70); cs.hideColumns(15, 45); - hidden = cs.getHiddenRegions(); + hidden = cs.getHiddenColumnsCopy(); assertEquals(2, hidden.size()); assertEquals("[10, 50]", Arrays.toString(hidden.get(0))); assertEquals("[60, 70]", Arrays.toString(hidden.get(1))); @@ -529,23 +545,23 @@ public class HiddenColumnsTest one.set(1); cs = new HiddenColumns(); cs.hideMarkedBits(one); - assertEquals(1, cs.getHiddenRegions().size()); + assertEquals(1, cs.getHiddenColumnsCopy().size()); one.set(2); cs = new HiddenColumns(); cs.hideMarkedBits(one); - assertEquals(1, cs.getHiddenRegions().size()); + assertEquals(1, cs.getHiddenColumnsCopy().size()); one.set(3); cs = new HiddenColumns(); cs.hideMarkedBits(one); - assertEquals(1, cs.getHiddenRegions().size()); + assertEquals(1, cs.getHiddenColumnsCopy().size()); // split one.clear(2); cs = new HiddenColumns(); cs.hideMarkedBits(one); - assertEquals(2, cs.getHiddenRegions().size()); + assertEquals(2, cs.getHiddenColumnsCopy().size()); assertEquals(0, cs.adjustForHiddenColumns(0)); assertEquals(2, cs.adjustForHiddenColumns(1)); @@ -556,11 +572,163 @@ public class HiddenColumnsTest cs = new HiddenColumns(); cs.hideMarkedBits(one); - assertEquals(1, cs.getHiddenRegions().size()); + assertEquals(1, cs.getHiddenColumnsCopy().size()); assertEquals(0, cs.adjustForHiddenColumns(0)); assertEquals(1, cs.adjustForHiddenColumns(1)); assertEquals(2, cs.adjustForHiddenColumns(2)); assertEquals(4, cs.adjustForHiddenColumns(3)); } + + @Test(groups = { "Functional" }) + public void testGetBitset() + { + 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(); + hc.hideMarkedBits(toMark); + + // see if we can recover bitfield + hc.markHiddenRegions(fromMark = new BitSet()); + assertEquals(toMark, fromMark); + } + } + + @Test(groups = { "Functional" }) + public void testFindHiddenRegionPositions() + { + HiddenColumns hc = new HiddenColumns(); + + List positions = hc.findHiddenRegionPositions(); + assertTrue(positions.isEmpty()); + + hc.hideColumns(3, 7); + hc.hideColumns(10, 10); + hc.hideColumns(14, 15); + + positions = hc.findHiddenRegionPositions(); + assertEquals(3, positions.size()); + assertEquals(3, positions.get(0).intValue()); + assertEquals(5, positions.get(1).intValue()); + assertEquals(8, positions.get(2).intValue()); + } + + @Test(groups = { "Functional" }) + public void testRegionsToString() + { + HiddenColumns hc = new HiddenColumns(); + + String result = hc.regionsToString(",", "--"); + assertEquals("", result); + + hc.hideColumns(3, 7); + hc.hideColumns(10, 10); + hc.hideColumns(14, 15); + + result = hc.regionsToString(",", "--"); + assertEquals("3--7,10--10,14--15", result); + } + + @Test(groups = "Functional") + public void getVisibleStartAndEndIndexTest() + { + Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); + AlignmentI align = new Alignment(new SequenceI[] { seq }); + HiddenColumns hc = new HiddenColumns(); + + int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); + assertEquals(0, startEnd[0]); + assertEquals(25, startEnd[1]); + + hc.hideColumns(0, 0); + startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); + assertEquals(1, startEnd[0]); + assertEquals(25, startEnd[1]); + + hc.hideColumns(6, 9); + hc.hideColumns(11, 12); + startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); + assertEquals(1, startEnd[0]); + assertEquals(25, startEnd[1]); + + hc.hideColumns(24, 25); + startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); + System.out.println(startEnd[0] + " : " + startEnd[1]); + assertEquals(1, startEnd[0]); + assertEquals(23, startEnd[1]); + } + + @Test(groups = "Functional") + public void testGetRegionWithEdgeAtRes() + { + HiddenColumns hc = new HiddenColumns(); + + int[] result = hc.getRegionWithEdgeAtRes(5); + assertNull(result); + + hc.hideColumns(3, 7); + hc.hideColumns(10, 10); + hc.hideColumns(14, 15); + + result = hc.getRegionWithEdgeAtRes(3); + assertEquals(3, result[0]); + assertEquals(7, result[1]); + + result = hc.getRegionWithEdgeAtRes(5); + assertEquals(10, result[0]); + assertEquals(10, result[1]); + + result = hc.getRegionWithEdgeAtRes(6); + assertNull(result); + } + + @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(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); + 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 + int[] oldcontigs = hidden.getVisibleContigs(0, 20); + int[] testcontigs = { 0, 14, 18, 19 }; + assertTrue(Arrays.equals(oldcontigs, testcontigs)); + + // propagate insertions + HiddenColumns result = HiddenColumns.propagateInsertions(profileseq, al, + view); + + // confirm that the contigs have changed to account for the gaps + int[] newcontigs = result.getVisibleContigs(0, 20); + testcontigs[1] = 10; + testcontigs[2] = 14; + assertTrue(Arrays.equals(newcontigs, testcontigs)); + + } }