X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FColumnSelectionTest.java;h=2deb1a7685482302910f124825a59089becc6704;hb=c2d8f2308b066224de8e2a07e4d6b6f9720b8e88;hp=0e7678bf52b32873c315b4f20d6543286b26c6d8;hpb=e30ff358f69039c713e01d3558df3a1780bbf2d8;p=jalview.git diff --git a/test/jalview/datamodel/ColumnSelectionTest.java b/test/jalview/datamodel/ColumnSelectionTest.java index 0e7678b..2deb1a7 100644 --- a/test/jalview/datamodel/ColumnSelectionTest.java +++ b/test/jalview/datamodel/ColumnSelectionTest.java @@ -22,6 +22,7 @@ package jalview.datamodel; import static org.testng.AssertJUnit.assertEquals; import static org.testng.AssertJUnit.assertFalse; +import static org.testng.AssertJUnit.assertNotSame; import static org.testng.AssertJUnit.assertSame; import static org.testng.AssertJUnit.assertTrue; @@ -66,6 +67,9 @@ public class ColumnSelectionTest // removing an element in the list removes it cs.removeElement(2); + // ...but not from the copy list! + assertEquals(2, sel.size()); + sel = cs.getSelected(); assertEquals(1, sel.size()); assertEquals(new Integer(5), sel.get(0)); } @@ -100,19 +104,76 @@ public class ColumnSelectionTest public void testLocateVisibleBoundsofSequence() { ColumnSelection cs = new ColumnSelection(); - SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E"); + SequenceI seq = new Sequence("RefSeq", "-A-SD-ASD--E---"); assertEquals(2, seq.findIndex(seq.getStart())); - assertEquals(Arrays.toString(new int[] { seq.findIndex(seq.getStart()), - seq.findIndex(seq.getEnd()), seq.getStart(), seq.getEnd() }), + + // no hidden columns + assertEquals( + Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1, seq.getStart(), + seq.getEnd(), seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1 }), + Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + + // hidden column on gap after end of sequence - should not affect bounds + cs.hideColumns(13); + assertEquals( + Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1, seq.getStart(), + seq.getEnd(), seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1 }), + Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + + cs.revealAllHiddenColumns(); + // hidden column on gap before beginning of sequence - should vis bounds by + // one + cs.hideColumns(0); + assertEquals( + Arrays.toString(new int[] { seq.findIndex(seq.getStart()) - 2, + seq.findIndex(seq.getEnd()) - 2, seq.getStart(), + seq.getEnd(), seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1 }), Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + + cs.revealAllHiddenColumns(); + // 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(Arrays.toString(new int[] { 1, 1, 3, 3 }), + assertEquals( + Arrays.toString(new int[] { 1, 1, 3, 3, + seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1 }), Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + cs.revealAllHiddenColumns(); + + // hide whole sequence - should just get location of hidden region + // containing sequence + cs.hideColumns(1, 11); + assertEquals( + Arrays.toString(new int[] { 0, 1, 0, 0, + seq.findIndex(seq.getStart()) - 1, + seq.findIndex(seq.getEnd()) - 1 }), + Arrays.toString(cs.locateVisibleBoundsOfSequence(seq))); + } + @Test(groups={"Functional"}) + public void testLocateVisibleBoundsPathologicals() + { + // test some pathological cases we missed + AlignmentI al = new Alignment(new SequenceI[] { new Sequence("refseqGaptest","KTDVTI----------NFI-----G----L")}); + ColumnSelection cs = new ColumnSelection(); + cs.hideInsertionsFor(al.getSequenceAt(0)); + assertEquals( + "G", + "" + + al.getSequenceAt(0).getCharAt( + cs.adjustForHiddenColumns(9))); + + + } @Test(groups = { "Functional" }) public void testHideColumns() { @@ -268,10 +329,14 @@ public class ColumnSelectionTest * this fails, HideSelectedColumns may also fail */ @Test(groups = { "Functional" }) - public void testgetSelectedRanges() + public void testGetSelectedRanges() { + /* + * getSelectedRanges returns ordered columns regardless + * of the order in which they are added + */ ColumnSelection cs = new ColumnSelection(); - int[] sel = { 2, 3, 4, 7, 8, 9, 20, 21, 22 }; + int[] sel = { 4, 3, 7, 21, 9, 20, 8, 22, 2 }; for (int col : sel) { cs.addElement(col); @@ -421,4 +486,95 @@ public class ColumnSelectionTest cs.addElement(0); assertEquals(0, cs.getMin()); } + + @Test(groups = { "Functional" }) + public void testEquals() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(0); + cs.addElement(513); + cs.addElement(1); + cs.hideColumns(3); + cs.hideColumns(7); + cs.hideColumns(5,9); + + // same selections added in a different order + ColumnSelection cs2 = new ColumnSelection(); + cs2.addElement(1); + cs2.addElement(513); + cs2.addElement(0); + + // with no hidden columns + assertFalse(cs.equals(cs2)); + assertFalse(cs2.equals(cs)); + + // with hidden columns added in a different order + cs2.hideColumns(6, 9); + cs2.hideColumns(5, 8); + cs2.hideColumns(3); + + assertTrue(cs.equals(cs2)); + assertTrue(cs.equals(cs)); + assertTrue(cs2.equals(cs)); + assertTrue(cs2.equals(cs2)); + + cs2.addElement(12); + assertFalse(cs.equals(cs2)); + assertFalse(cs2.equals(cs)); + + cs2.removeElement(12); + assertTrue(cs.equals(cs2)); + + cs2.hideColumns(88); + assertFalse(cs.equals(cs2)); + /* + * unhiding a column adds it to selection! + */ + cs2.revealHiddenColumns(88); + assertFalse(cs.equals(cs2)); + cs.addElement(88); + assertTrue(cs.equals(cs2)); + } + + /** + * Test the method that returns selected columns, in the order in which they + * were added + */ + @Test(groups = { "Functional" }) + public void testGetSelection() + { + ColumnSelection cs = new ColumnSelection(); + int[] sel = { 4, 3, 7, 21 }; + for (int col : sel) + { + cs.addElement(col); + } + + List selected1 = cs.getSelected(); + assertEquals(4, selected1.size()); + + /* + * getSelected returns a copy, verify the list + * is externally immutable + */ + selected1.clear(); + List selected2 = cs.getSelected(); + assertNotSame(selected1, selected2); + assertEquals(4, selected2.size()); + int i = 0; + for (int col : sel) + { + assertEquals(col, selected2.get(i++).intValue()); + } + + cs.removeElement(7); + cs.addElement(1); + cs.removeElement(4); + + List selected3 = cs.getSelected(); + assertEquals(3, selected3.size()); + assertEquals(3, selected3.get(0).intValue()); + assertEquals(21, selected3.get(1).intValue()); + assertEquals(1, selected3.get(2).intValue()); + } }