X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2FColumnSelectionTest.java;h=d581345e5a99303e481d14a45fe32539c7427396;hb=01e95ae1be5ae83392de930dea48c531e2afa339;hp=e5f2daabe0347c900ed10d452f219a24aca528df;hpb=1b911af46e474fd504a4d505327e02b684d9a397;p=jalview.git diff --git a/test/jalview/datamodel/ColumnSelectionTest.java b/test/jalview/datamodel/ColumnSelectionTest.java index e5f2daa..d581345 100644 --- a/test/jalview/datamodel/ColumnSelectionTest.java +++ b/test/jalview/datamodel/ColumnSelectionTest.java @@ -27,11 +27,15 @@ import static org.testng.AssertJUnit.fail; import jalview.analysis.AlignmentGenerator; import jalview.gui.JvOptionPane; +import jalview.viewmodel.annotationfilter.AnnotationFilterParameter; +import jalview.viewmodel.annotationfilter.AnnotationFilterParameter.SearchableAnnotationField; +import jalview.viewmodel.annotationfilter.AnnotationFilterParameter.ThresholdType; import java.util.Arrays; import java.util.BitSet; import java.util.Collections; import java.util.ConcurrentModificationException; +import java.util.Iterator; import java.util.List; import org.testng.annotations.BeforeClass; @@ -59,6 +63,30 @@ public class ColumnSelectionTest assertEquals("[2, 5, 3]", sel.toString()); } + @Test(groups = { "Functional" }) + public void testSetElementsFrom() + { + ColumnSelection fromcs = new ColumnSelection(); + ColumnSelection tocs = new ColumnSelection(); + HiddenColumns hidden = new HiddenColumns(); + + fromcs.addElement(2); + fromcs.addElement(3); + fromcs.addElement(5); + + tocs.setElementsFrom(fromcs, hidden); + assertTrue(tocs.equals(fromcs)); + + hidden.hideColumns(4, 6); + tocs.setElementsFrom(fromcs, hidden); + + // expect cols 2 and 3 to be selected but not 5 + ColumnSelection expectcs = new ColumnSelection(); + expectcs.addElement(2); + expectcs.addElement(3); + assertTrue(tocs.equals(expectcs)); + } + /** * Test the remove method - in particular to verify that remove(int i) removes * the element whose value is i, _NOT_ the i'th element. @@ -75,8 +103,8 @@ public class ColumnSelectionTest cs.removeElement(1); List sel = cs.getSelected(); assertEquals(2, sel.size()); - assertEquals(new Integer(2), sel.get(0)); - assertEquals(new Integer(5), sel.get(1)); + assertEquals(Integer.valueOf(2), sel.get(0)); + assertEquals(Integer.valueOf(5), sel.get(1)); // removing an element in the list removes it cs.removeElement(2); @@ -84,7 +112,7 @@ public class ColumnSelectionTest assertEquals(1, sel.size()); sel = cs.getSelected(); assertEquals(1, sel.size()); - assertEquals(new Integer(5), sel.get(0)); + assertEquals(Integer.valueOf(5), sel.get(0)); } /** @@ -108,9 +136,9 @@ public class ColumnSelectionTest // hide column 5 (and adjacent): cs.hideSelectedColumns(5, al.getHiddenColumns()); // 4,5,6 now hidden: - List hidden = al.getHiddenColumns().getListOfCols(); - assertEquals(1, hidden.size()); - assertEquals("[4, 6]", Arrays.toString(hidden.get(0))); + Iterator regions = al.getHiddenColumns().iterator(); + assertEquals(1, al.getHiddenColumns().getNumberOfRegions()); + assertEquals("[4, 6]", Arrays.toString(regions.next())); // none now selected: assertTrue(cs.getSelected().isEmpty()); @@ -121,9 +149,9 @@ public class ColumnSelectionTest cs.addElement(5); cs.addElement(6); cs.hideSelectedColumns(4, al.getHiddenColumns()); - hidden = al.getHiddenColumns().getListOfCols(); - assertEquals(1, hidden.size()); - assertEquals("[4, 6]", Arrays.toString(hidden.get(0))); + regions = al.getHiddenColumns().iterator(); + assertEquals(1, al.getHiddenColumns().getNumberOfRegions()); + assertEquals("[4, 6]", Arrays.toString(regions.next())); assertTrue(cs.getSelected().isEmpty()); // repeat, hiding column (4, 5 and) 6 @@ -133,9 +161,9 @@ public class ColumnSelectionTest cs.addElement(5); cs.addElement(6); cs.hideSelectedColumns(6, al.getHiddenColumns()); - hidden = al.getHiddenColumns().getListOfCols(); - assertEquals(1, hidden.size()); - assertEquals("[4, 6]", Arrays.toString(hidden.get(0))); + regions = al.getHiddenColumns().iterator(); + assertEquals(1, al.getHiddenColumns().getNumberOfRegions()); + assertEquals("[4, 6]", Arrays.toString(regions.next())); assertTrue(cs.getSelected().isEmpty()); // repeat, with _only_ adjacent columns selected @@ -144,9 +172,9 @@ public class ColumnSelectionTest cs.addElement(4); cs.addElement(6); cs.hideSelectedColumns(5, al.getHiddenColumns()); - hidden = al.getHiddenColumns().getListOfCols(); - assertEquals(1, hidden.size()); - assertEquals("[4, 6]", Arrays.toString(hidden.get(0))); + regions = al.getHiddenColumns().iterator(); + assertEquals(1, al.getHiddenColumns().getNumberOfRegions()); + assertEquals("[4, 6]", Arrays.toString(regions.next())); assertTrue(cs.getSelected().isEmpty()); } @@ -172,12 +200,12 @@ public class ColumnSelectionTest cs.hideSelectedColumns(al); assertTrue(cs.getSelected().isEmpty()); - List hidden = cols.getListOfCols(); - assertEquals(4, hidden.size()); - assertEquals("[2, 4]", Arrays.toString(hidden.get(0))); - assertEquals("[7, 9]", Arrays.toString(hidden.get(1))); - assertEquals("[15, 18]", Arrays.toString(hidden.get(2))); - assertEquals("[20, 22]", Arrays.toString(hidden.get(3))); + Iterator regions = cols.iterator(); + assertEquals(4, cols.getNumberOfRegions()); + assertEquals("[2, 4]", Arrays.toString(regions.next())); + assertEquals("[7, 9]", Arrays.toString(regions.next())); + assertEquals("[15, 18]", Arrays.toString(regions.next())); + assertEquals("[20, 22]", Arrays.toString(regions.next())); } /** @@ -383,7 +411,8 @@ public class ColumnSelectionTest */ @Test( groups = "Functional", - expectedExceptions = { ConcurrentModificationException.class }) + expectedExceptions = + { ConcurrentModificationException.class }) public void testGetSelected_concurrentModification() { ColumnSelection cs = new ColumnSelection(); @@ -510,7 +539,6 @@ public class ColumnSelectionTest assertEquals("[3, 1]", cs2.getSelected().toString()); } - @Test(groups = { "Functional" }) public void testStretchGroup_expand() { @@ -573,4 +601,128 @@ public class ColumnSelectionTest assertEquals(sg.getStartRes(), 10); assertEquals(sg.getEndRes(), 19); } + + @Test(groups = { "Functional" }) + public void testFilterAnnotations() + { + ColumnSelection cs = new ColumnSelection(); + + /* + * filter with no conditions clears the selection + */ + Annotation[] anns = new Annotation[] { null }; + AnnotationFilterParameter filter = new AnnotationFilterParameter(); + cs.addElement(3); + int added = cs.filterAnnotations(anns, filter); + assertEquals(0, added); + assertTrue(cs.isEmpty()); + + /* + * select on description (regex) + */ + filter.setRegexString("w.rld"); + filter.addRegexSearchField(SearchableAnnotationField.DESCRIPTION); + Annotation helix = new Annotation("(", "hello", '<', 2f); + Annotation sheet = new Annotation("(", "world", '<', 2f); + added = cs.filterAnnotations(new Annotation[] { null, helix, sheet }, + filter); + assertEquals(1, added); + assertTrue(cs.contains(2)); + + /* + * select on label (invalid regex, exact match) + */ + filter = new AnnotationFilterParameter(); + filter.setRegexString("("); + filter.addRegexSearchField(SearchableAnnotationField.DISPLAY_STRING); + added = cs.filterAnnotations(new Annotation[] { null, helix, sheet }, + filter); + assertEquals(2, added); + assertTrue(cs.contains(1)); + assertTrue(cs.contains(2)); + + /* + * select Helix (secondary structure symbol H) + */ + filter = new AnnotationFilterParameter(); + filter.setFilterAlphaHelix(true); + helix = new Annotation("x", "desc", 'H', 0f); + sheet = new Annotation("x", "desc", 'E', 1f); + Annotation turn = new Annotation("x", "desc", 'S', 2f); + Annotation ann4 = new Annotation("x", "desc", 'Y', 3f); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(1, added); + assertTrue(cs.contains(1)); + + /* + * select Helix and Sheet (E) + */ + filter.setFilterBetaSheet(true); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(2, added); + assertTrue(cs.contains(1)); + assertTrue(cs.contains(2)); + + /* + * select Sheet and Turn (S) + */ + filter.setFilterAlphaHelix(false); + filter.setFilterTurn(true); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(2, added); + assertTrue(cs.contains(2)); + assertTrue(cs.contains(3)); + + /* + * select value < 2f (ann1, ann2) + */ + filter = new AnnotationFilterParameter(); + filter.setThresholdType(ThresholdType.BELOW_THRESHOLD); + filter.setThresholdValue(2f); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(2, added); + assertTrue(cs.contains(1)); + assertTrue(cs.contains(2)); + + /* + * select value > 2f (ann4 only) + */ + filter.setThresholdType(ThresholdType.ABOVE_THRESHOLD); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(1, added); + assertTrue(cs.contains(4)); + + /* + * select >2f or Helix + */ + filter.setFilterAlphaHelix(true); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(2, added); + assertTrue(cs.contains(1)); + assertTrue(cs.contains(4)); + + /* + * select < 1f or Helix; one annotation matches both + * return value should only count it once + */ + filter.setThresholdType(ThresholdType.BELOW_THRESHOLD); + filter.setThresholdValue(1f); + added = cs + .filterAnnotations(new Annotation[] + { null, helix, sheet, turn, ann4 }, filter); + assertEquals(1, added); + assertTrue(cs.contains(1)); + } }