X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FColumnSelectionTest.java;h=e34b23f478da0de9a22c2c7f962320251b7a2e36;hb=d387f0ee40a8e248ce08c97aca2e427aa75a40d8;hp=e1d04eb09315f2d8f21e8ffd61a7ee786934d15f;hpb=c2484e319127d8c57182a156138ef50de3740c64;p=jalview.git diff --git a/test/jalview/datamodel/ColumnSelectionTest.java b/test/jalview/datamodel/ColumnSelectionTest.java index e1d04eb..e34b23f 100644 --- a/test/jalview/datamodel/ColumnSelectionTest.java +++ b/test/jalview/datamodel/ColumnSelectionTest.java @@ -24,15 +24,29 @@ 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 static org.testng.AssertJUnit.fail; + +import jalview.gui.JvOptionPane; import java.util.Arrays; +import java.util.BitSet; +import java.util.Collections; +import java.util.ConcurrentModificationException; import java.util.List; +import org.testng.annotations.BeforeClass; import org.testng.annotations.Test; public class ColumnSelectionTest { + @BeforeClass(alwaysRun = true) + public void setUpJvOptionPane() + { + JvOptionPane.setInteractiveMode(false); + JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); + } + @Test(groups = { "Functional" }) public void testAddElement() { @@ -66,6 +80,9 @@ public class ColumnSelectionTest // removing an element in the list removes it cs.removeElement(2); + // ...and also from the read-only view + assertEquals(1, sel.size()); + sel = cs.getSelected(); assertEquals(1, sel.size()); assertEquals(new Integer(5), sel.get(0)); } @@ -88,9 +105,38 @@ public class ColumnSelectionTest cs.hideColumns(4, 4); assertEquals(4, cs.findColumnPosition(5)); + // hiding column 4 moves column 4 to position 3 + assertEquals(3, cs.findColumnPosition(4)); + // hiding columns 1 and 2 moves column 5 to column 2 cs.hideColumns(1, 2); assertEquals(2, cs.findColumnPosition(5)); + + // check with > 1 hidden column regions + // where some columns are in the hidden regions + ColumnSelection cs2 = new ColumnSelection(); + cs2.hideColumns(5, 10); + cs2.hideColumns(20, 27); + cs2.hideColumns(40, 44); + + // hiding columns 5-10 and 20-27 moves column 8 to column 4 + assertEquals(4, cs2.findColumnPosition(8)); + + // and moves column 24 to 13 + assertEquals(13, cs2.findColumnPosition(24)); + + // and moves column 28 to 14 + assertEquals(14, cs2.findColumnPosition(28)); + + // and moves column 40 to 25 + assertEquals(25, cs2.findColumnPosition(40)); + + // check when hidden columns start at 0 that the visible column + // to the right is returned for hidden cols in the region + ColumnSelection cs3 = new ColumnSelection(); + cs3.hideColumns(0, 4); + assertEquals(5, cs3.findColumnPosition(2)); + } /** @@ -155,11 +201,12 @@ public class ColumnSelectionTest } - @Test(groups={"Functional"}) + @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")}); + AlignmentI al = new Alignment(new SequenceI[] { new Sequence( + "refseqGaptest", "KTDVTI----------NFI-----G----L") }); ColumnSelection cs = new ColumnSelection(); cs.hideInsertionsFor(al.getSequenceAt(0)); assertEquals( @@ -168,8 +215,8 @@ public class ColumnSelectionTest + al.getSequenceAt(0).getCharAt( cs.adjustForHiddenColumns(9))); - } + @Test(groups = { "Functional" }) public void testHideColumns() { @@ -187,12 +234,11 @@ public class ColumnSelectionTest assertEquals("[5, 5]", Arrays.toString(hidden.get(1))); // hiding column 4 expands [3, 3] to [3, 4] - // not fancy enough to coalesce this into [3, 5] though + // and merges to [5, 5] to make [3, 5] cs.hideColumns(4); hidden = cs.getHiddenColumns(); - assertEquals(2, hidden.size()); - assertEquals("[3, 4]", Arrays.toString(hidden.get(0))); - assertEquals("[5, 5]", Arrays.toString(hidden.get(1))); + assertEquals(1, hidden.size()); + assertEquals("[3, 5]", Arrays.toString(hidden.get(0))); // clear hidden columns (note they are added to selected) cs.revealAllHiddenColumns(); @@ -325,10 +371,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); @@ -488,17 +538,23 @@ public class ColumnSelectionTest cs.addElement(1); cs.hideColumns(3); cs.hideColumns(7); - cs.hideColumns(5,9); + 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)); @@ -521,4 +577,334 @@ public class ColumnSelectionTest 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 testGetSelected() + { + ColumnSelection cs = new ColumnSelection(); + int[] sel = { 4, 3, 7, 21 }; + for (int col : sel) + { + cs.addElement(col); + } + + List selected = cs.getSelected(); + assertEquals(4, selected.size()); + assertEquals("[4, 3, 7, 21]", selected.toString()); + + /* + * getSelected returns a read-only view of the list + * verify the view follows any changes in it + */ + cs.removeElement(7); + cs.addElement(1); + cs.removeElement(4); + assertEquals("[3, 21, 1]", selected.toString()); + } + + /** + * Test to verify that the list returned by getSelection cannot be modified + */ + @Test(groups = { "Functional" }) + public void testGetSelected_isReadOnly() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(3); + + List selected = cs.getSelected(); + try + { + selected.clear(); + fail("expected exception"); + } catch (UnsupportedOperationException e) + { + // expected + } + try + { + selected.add(1); + fail("expected exception"); + } catch (UnsupportedOperationException e) + { + // expected + } + try + { + selected.remove(3); + fail("expected exception"); + } catch (UnsupportedOperationException e) + { + // expected + } + try + { + Collections.sort(selected); + fail("expected exception"); + } catch (UnsupportedOperationException e) + { + // expected + } + } + + /** + * Test that demonstrates a ConcurrentModificationException is thrown if you + * change the selection while iterating over it + */ + @Test( + groups = "Functional", + expectedExceptions = { ConcurrentModificationException.class }) + public void testGetSelected_concurrentModification() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(0); + cs.addElement(1); + cs.addElement(2); + + /* + * simulate changing the list under us (e.g. in a separate + * thread) while iterating over it -> ConcurrentModificationException + */ + List selected = cs.getSelected(); + for (Integer col : selected) + { + if (col.intValue() == 0) + { + cs.removeElement(1); + } + } + } + + @Test(groups = "Functional") + public void testMarkColumns() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(5); // this will be cleared + BitSet toMark = new BitSet(); + toMark.set(1); + toMark.set(3); + toMark.set(6); + toMark.set(9); + + assertTrue(cs.markColumns(toMark, 3, 8, false, false, false)); + List selected = cs.getSelected(); + assertEquals(2, selected.size()); + assertTrue(selected.contains(3)); + assertTrue(selected.contains(6)); + } + + @Test(groups = "Functional") + public void testMarkColumns_extend() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(1); + cs.addElement(5); + BitSet toMark = new BitSet(); + toMark.set(1); + toMark.set(3); + toMark.set(6); + toMark.set(9); + + /* + * extending selection of {3, 6} should leave {1, 3, 5, 6} selected + */ + assertTrue(cs.markColumns(toMark, 3, 8, false, true, false)); + List selected = cs.getSelected(); + assertEquals(4, selected.size()); + assertTrue(selected.contains(1)); + assertTrue(selected.contains(3)); + assertTrue(selected.contains(5)); + assertTrue(selected.contains(6)); + } + + @Test(groups = "Functional") + public void testMarkColumns_invert() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(5); // this will be cleared + BitSet toMark = new BitSet(); + toMark.set(1); + toMark.set(3); + toMark.set(6); + toMark.set(9); + + /* + * inverted selection of {3, 6} should select {4, 5, 7, 8} + */ + assertTrue(cs.markColumns(toMark, 3, 8, true, false, false)); + List selected = cs.getSelected(); + assertEquals(4, selected.size()); + assertTrue(selected.contains(4)); + assertTrue(selected.contains(5)); + assertTrue(selected.contains(7)); + assertTrue(selected.contains(8)); + } + + @Test(groups = "Functional") + public void testMarkColumns_toggle() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(1); // outside change range + cs.addElement(3); + cs.addElement(4); + cs.addElement(10); // outside change range + BitSet toMark = new BitSet(); + toMark.set(1); + toMark.set(3); + toMark.set(6); + toMark.set(9); + + /* + * toggling state of {3, 6} should leave {1, 4, 6, 10} selected + */ + assertTrue(cs.markColumns(toMark, 3, 8, false, false, true)); + List selected = cs.getSelected(); + assertEquals(4, selected.size()); + assertTrue(selected.contains(1)); + assertTrue(selected.contains(4)); + assertTrue(selected.contains(6)); + assertTrue(selected.contains(10)); + } + + @Test(groups = "Functional") + public void testCopyConstructor() + { + ColumnSelection cs = new ColumnSelection(); + cs.addElement(3); + cs.addElement(1); + cs.hideColumns(10, 11); + cs.hideColumns(5, 7); + assertEquals("[5, 7]", Arrays.toString(cs.getHiddenColumns().get(0))); + + ColumnSelection cs2 = new ColumnSelection(cs); + assertTrue(cs2.hasSelectedColumns()); + assertTrue(cs2.hasHiddenColumns()); + // order of column selection is preserved + assertEquals("[3, 1]", cs2.getSelected().toString()); + assertEquals(2, cs2.getHiddenColumns().size()); + // hidden columns are held in column order + assertEquals("[5, 7]", Arrays.toString(cs2.getHiddenColumns().get(0))); + assertEquals("[10, 11]", Arrays.toString(cs2.getHiddenColumns().get(1))); + } + + /** + * Test for the case when a hidden range encloses more one already hidden + * range + */ + @Test(groups = { "Functional" }) + public void testHideColumns_subsumingHidden() + { + /* + * JAL-2370 bug scenario: + * two hidden ranges subsumed by a third + */ + ColumnSelection cs = new ColumnSelection(); + cs.hideColumns(49, 59); + cs.hideColumns(69, 79); + List hidden = cs.getHiddenColumns(); + 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.getHiddenColumns(); + assertEquals(1, hidden.size()); + assertEquals("[48, 80]", Arrays.toString(hidden.get(0))); + + /* + * another...joining hidden ranges + */ + cs = new ColumnSelection(); + cs.hideColumns(10, 20); + cs.hideColumns(30, 40); + cs.hideColumns(50, 60); + // hiding 21-49 should merge to one range + cs.hideColumns(21, 49); + hidden = cs.getHiddenColumns(); + assertEquals(1, hidden.size()); + assertEquals("[10, 60]", Arrays.toString(hidden.get(0))); + + /* + * another...lef overlap, subsumption, right overlap, + * no overlap of existing hidden ranges + */ + cs = new ColumnSelection(); + cs.hideColumns(10, 20); + cs.hideColumns(10, 20); + cs.hideColumns(30, 35); + cs.hideColumns(40, 50); + cs.hideColumns(60, 70); + + cs.hideColumns(15, 45); + hidden = cs.getHiddenColumns(); + assertEquals(2, hidden.size()); + assertEquals("[10, 50]", Arrays.toString(hidden.get(0))); + assertEquals("[60, 70]", Arrays.toString(hidden.get(1))); + } + + @Test(groups = { "Functional" }) + public void testStretchGroup_expand() + { + /* + * test that emulates clicking column 4 (selected) + * and dragging right to column 5 (all base 0) + */ + ColumnSelection cs = new ColumnSelection(); + cs.addElement(4); + SequenceGroup sg = new SequenceGroup(); + sg.setStartRes(4); + sg.setEndRes(4); + cs.stretchGroup(5, sg, 4, 4); + assertEquals(cs.getSelected().size(), 2); + assertTrue(cs.contains(4)); + assertTrue(cs.contains(5)); + assertEquals(sg.getStartRes(), 4); + assertEquals(sg.getEndRes(), 5); + + /* + * emulate drag right with columns 10-20 already selected + */ + cs.clear(); + for (int i = 10; i <= 20; i++) + { + cs.addElement(i); + } + assertEquals(cs.getSelected().size(), 11); + sg = new SequenceGroup(); + sg.setStartRes(10); + sg.setEndRes(20); + cs.stretchGroup(21, sg, 10, 20); + assertEquals(cs.getSelected().size(), 12); + assertTrue(cs.contains(10)); + assertTrue(cs.contains(21)); + assertEquals(sg.getStartRes(), 10); + assertEquals(sg.getEndRes(), 21); + } + + @Test(groups = { "Functional" }) + public void testStretchGroup_shrink() + { + /* + * emulate drag left to 19 with columns 10-20 already selected + */ + ColumnSelection cs = new ColumnSelection(); + for (int i = 10; i <= 20; i++) + { + cs.addElement(i); + } + assertEquals(cs.getSelected().size(), 11); + SequenceGroup sg = new SequenceGroup(); + sg.setStartRes(10); + sg.setEndRes(20); + cs.stretchGroup(19, sg, 10, 20); + assertEquals(cs.getSelected().size(), 10); + assertTrue(cs.contains(10)); + assertTrue(cs.contains(19)); + assertFalse(cs.contains(20)); + assertEquals(sg.getStartRes(), 10); + assertEquals(sg.getEndRes(), 19); + } }