import static org.testng.Assert.assertSame;
import static org.testng.Assert.assertTrue;
+import jalview.bin.Cache;
import jalview.datamodel.Alignment;
import jalview.datamodel.AlignmentI;
import jalview.datamodel.SearchResultMatchI;
import jalview.datamodel.SearchResultsI;
import jalview.datamodel.Sequence;
+import jalview.datamodel.SequenceGroup;
import jalview.gui.AlignFrame;
import jalview.gui.JvOptionPane;
+import jalview.io.DataSourceType;
import jalview.io.FileLoader;
-import jalview.io.FormatAdapter;
import java.util.List;
@BeforeClass(groups = "Functional")
public void setUp()
{
- String seqData = "seq1 ABCD--EF-GHI\n" + "seq2 A--BCDefHI\n"
+ Cache.loadProperties("test/jalview/io/testProps.jvprops");
+ Cache.applicationProperties.setProperty("PAD_GAPS",
+ Boolean.FALSE.toString());
+
+ String seqData = "seq1seq1/8-16 ABCD--EF-GHI\n" + "seq2 A--BCDefHI\n"
+ "seq3 --bcdEFH\n" + "seq4 aa---aMMMMMaaa\n";
af = new FileLoader().LoadFileWaitTillLoaded(seqData,
- FormatAdapter.PASTE);
+ DataSourceType.PASTE);
al = af.getViewport().getAlignment();
}
/**
- * Test for find all matches of a regular expression
+ * Test for find matches of a regular expression
*/
@Test(groups = "Functional")
- public void testFindAll_regex()
+ public void testFind_regex()
{
+ /*
+ * find next match only
+ */
Finder f = new Finder(al, null);
- f.setFindAll(true);
f.find("E.H"); // 'E, any character, H'
+ // should match seq2 efH only
+ SearchResultsI sr = f.getSearchResults();
+ assertEquals(sr.getSize(), 1);
+ List<SearchResultMatchI> matches = sr.getResults();
+ assertSame(al.getSequenceAt(1), matches.get(0).getSequence());
+ assertEquals(matches.get(0).getStart(), 5);
+ assertEquals(matches.get(0).getEnd(), 7);
+ f = new Finder(al, null);
+ f.setFindAll(true);
+ f.find("E.H"); // 'E, any character, H'
// should match seq2 efH and seq3 EFH
- SearchResultsI sr = f.getSearchResults();
+ sr = f.getSearchResults();
assertEquals(sr.getSize(), 2);
- List<SearchResultMatchI> matches = sr.getResults();
+ matches = sr.getResults();
assertSame(al.getSequenceAt(1), matches.get(0).getSequence());
assertSame(al.getSequenceAt(2), matches.get(1).getSequence());
assertEquals(matches.get(0).getStart(), 5);
public void testFind_residueNumber()
{
Finder f = new Finder(al, null);
- f.setFindAll(true);
- f.find("9");
- // seq1 and seq4 have 9 residues; no match in other sequences
+ /*
+ * find first match should return seq1 residue 9
+ */
+ f.find("9");
SearchResultsI sr = f.getSearchResults();
- assertEquals(sr.getSize(), 2);
+ assertEquals(sr.getSize(), 1);
List<SearchResultMatchI> matches = sr.getResults();
assertSame(al.getSequenceAt(0), matches.get(0).getSequence());
+ assertEquals(matches.get(0).getStart(), 9);
+ assertEquals(matches.get(0).getEnd(), 9);
+
+ /*
+ * find all matches should return seq1 and seq4 (others are too short)
+ */
+ f = new Finder(al, null);
+ f.setFindAll(true);
+ f.find("9");
+ sr = f.getSearchResults();
+ assertEquals(sr.getSize(), 2);
+ matches = sr.getResults();
+ assertSame(al.getSequenceAt(0), matches.get(0).getSequence());
assertSame(al.getSequenceAt(3), matches.get(1).getSequence());
assertEquals(matches.get(0).getStart(), 9);
assertEquals(matches.get(0).getEnd(), 9);
assertEquals(matches.get(1).getStart(), 9);
assertEquals(matches.get(1).getEnd(), 9);
+
+ /*
+ * parsing of search string as integer is strict
+ */
+ f = new Finder(al, null);
+ f.find(" 9");
+ assertTrue(f.getSearchResults().isEmpty());
}
/**
* Test for matching within sequence descriptions
*/
@Test(groups = "Functional")
- public void testFindAll_inDescription()
+ public void testFind_inDescription()
{
AlignmentI al2 = new Alignment(al);
al2.getSequenceAt(0).setDescription("BRAF");
al2.getSequenceAt(1).setDescription("braf");
+
+ /*
+ * find first match only
+ */
Finder f = new Finder(al2, null);
- f.setFindAll(true);
f.setIncludeDescription(true);
+ f.find("rAF");
+ assertEquals(f.getIdMatch().size(), 1);
+ assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
+ assertTrue(f.getSearchResults().isEmpty());
+ /*
+ * find all matches
+ */
+ f = new Finder(al2, null);
+ f.setFindAll(true);
+ f.setIncludeDescription(true);
f.find("rAF");
assertEquals(f.getIdMatch().size(), 2);
assertSame(f.getIdMatch().get(0), al2.getSequenceAt(0));
f.setFindAll(true);
/*
- * case insensitive
+ * case insensitive; seq1 occurs twice in sequence id but
+ * only one match should be returned
*/
f.find("SEQ1");
assertEquals(f.getIdMatch().size(), 1);
}
/**
- * Test finding all matches of a sequence pattern in an alignment
+ * Test finding next match of a sequence pattern in an alignment
+ */
+ @Test(groups = "Functional")
+ public void testFind()
+ {
+ Finder f = new Finder(al, null);
+ f.find("EfH");
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(5, match.getStart());
+ assertEquals(7, match.getEnd());
+ }
+
+ /**
+ * Test for JAL-2302 to verify that sub-matches are not included in a find all
+ * result
*/
@Test(groups = "Functional")
- public void testFindAll_simpleMatch()
+ public void testFind_maximalResultOnly()
{
Finder f = new Finder(al, null);
f.setFindAll(true);
+ f.find("M+");
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(3), match.getSequence());
+ assertEquals(4, match.getStart()); // dataset sequence positions
+ assertEquals(8, match.getEnd()); // base 1
+ }
- /*
- * case insensitive first
- */
+ /**
+ * Test finding all matches of a sequence pattern in an alignment
+ */
+ @Test(groups = "Functional")
+ public void testFind_findAll()
+ {
+ Finder f = new Finder(al, null);
+ f.setFindAll(true);
f.find("EfH");
SearchResultsI searchResults = f.getSearchResults();
assertEquals(searchResults.getSize(), 2);
assertSame(al.getSequenceAt(2), match.getSequence());
assertEquals(4, match.getStart());
assertEquals(6, match.getEnd());
+ }
- /*
- * case sensitive
- */
- f = new Finder(al, null);
- f.setFindAll(true);
+ /**
+ * Test finding all matches, case-sensitive
+ */
+ @Test(groups = "Functional")
+ public void testFind_findAllCaseSensitive()
+ {
+ Finder f = new Finder(al, null);
f.setCaseSensitive(true);
+ f.setFindAll(true);
f.find("BC");
- searchResults = f.getSearchResults();
+ SearchResultsI searchResults = f.getSearchResults();
assertEquals(searchResults.getSize(), 2);
- match = searchResults.getResults().get(0);
+ SearchResultMatchI match = searchResults.getResults().get(0);
assertSame(al.getSequenceAt(0), match.getSequence());
- assertEquals(2, match.getStart());
- assertEquals(3, match.getEnd());
+ assertEquals(match.getStart(), 9);
+ assertEquals(match.getEnd(), 10);
match = searchResults.getResults().get(1);
assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(match.getStart(), 2);
+ assertEquals(match.getEnd(), 3);
+ }
+
+ /**
+ * Test finding next match of a sequence pattern in a selection group
+ */
+ @Test(groups = "Functional")
+ public void testFind_inSelection()
+ {
+ /*
+ * select sequences 2 and 3, columns 4-6 which contains
+ * BCD
+ * cdE
+ */
+ SequenceGroup sg = new SequenceGroup();
+ sg.setStartRes(3);
+ sg.setEndRes(5);
+ sg.addSequence(al.getSequenceAt(1), false);
+ sg.addSequence(al.getSequenceAt(2), false);
+
+ Finder f = new Finder(al, sg);
+ f.find("b");
+ assertTrue(f.getIdMatch().isEmpty());
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(1), match.getSequence());
assertEquals(2, match.getStart());
+ assertEquals(2, match.getEnd());
+
+ /*
+ * a second Find should not return the 'b' in seq3 as outside the selection
+ */
+ f.find("b");
+ assertTrue(f.getSearchResults().isEmpty());
+ assertTrue(f.getIdMatch().isEmpty());
+
+ f = new Finder(al, sg);
+ f.find("d");
+ assertTrue(f.getIdMatch().isEmpty());
+ searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(4, match.getStart());
+ assertEquals(4, match.getEnd());
+ f.find("d");
+ assertTrue(f.getIdMatch().isEmpty());
+ searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 1);
+ match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(2), match.getSequence());
+ assertEquals(3, match.getStart());
assertEquals(3, match.getEnd());
}
/**
- * Test for JAL-2302 to verify that sub-matches are not included in a find all
- * result
+ * Test finding all matches of a search pattern in a selection group
*/
@Test(groups = "Functional")
- public void testFind_maximalResultOnly()
+ public void testFind_findAllInSelection()
{
- Finder f = new Finder(al, null);
+ /*
+ * select sequences 2 and 3, columns 4-6 which contains
+ * BCD
+ * cdE
+ */
+ SequenceGroup sg = new SequenceGroup();
+ sg.setStartRes(3);
+ sg.setEndRes(5);
+ sg.addSequence(al.getSequenceAt(1), false);
+ sg.addSequence(al.getSequenceAt(2), false);
+
+ /*
+ * search for 'e' should match two sequence ids and one residue
+ */
+ Finder f = new Finder(al, sg);
f.setFindAll(true);
- f.find("M+");
+ f.find("e");
+ assertEquals(f.getIdMatch().size(), 2);
+ assertSame(f.getIdMatch().get(0), al.getSequenceAt(1));
+ assertSame(f.getIdMatch().get(1), al.getSequenceAt(2));
SearchResultsI searchResults = f.getSearchResults();
assertEquals(searchResults.getSize(), 1);
SearchResultMatchI match = searchResults.getResults().get(0);
- assertSame(al.getSequenceAt(3), match.getSequence());
- assertEquals(4, match.getStart()); // dataset sequence positions
- assertEquals(8, match.getEnd()); // base 1
+ assertSame(al.getSequenceAt(2), match.getSequence());
+ assertEquals(4, match.getStart());
+ assertEquals(4, match.getEnd());
+
+ /*
+ * search for 'Q' should match two sequence ids only
+ */
+ f = new Finder(al, sg);
+ f.setFindAll(true);
+ f.find("Q");
+ assertEquals(f.getIdMatch().size(), 2);
+ assertSame(f.getIdMatch().get(0), al.getSequenceAt(1));
+ assertSame(f.getIdMatch().get(1), al.getSequenceAt(2));
+ assertTrue(f.getSearchResults().isEmpty());
+ }
+
+ /**
+ * Test finding in selection with a sequence too short to reach it
+ */
+ @Test(groups = "Functional")
+ public void testFind_findAllInSelectionWithShortSequence()
+ {
+ /*
+ * select all sequences, columns 10-12
+ * BCD
+ * cdE
+ */
+ SequenceGroup sg = new SequenceGroup();
+ sg.setStartRes(9);
+ sg.setEndRes(11);
+ sg.addSequence(al.getSequenceAt(0), false);
+ sg.addSequence(al.getSequenceAt(1), false);
+ sg.addSequence(al.getSequenceAt(2), false);
+ sg.addSequence(al.getSequenceAt(3), false);
+
+ /*
+ * search for 'I' should match two sequence positions
+ */
+ Finder f = new Finder(al, sg);
+ f.setFindAll(true);
+ f.find("I");
+ assertTrue(f.getIdMatch().isEmpty());
+ SearchResultsI searchResults = f.getSearchResults();
+ assertEquals(searchResults.getSize(), 2);
+ SearchResultMatchI match = searchResults.getResults().get(0);
+ assertSame(al.getSequenceAt(0), match.getSequence());
+ assertEquals(16, match.getStart());
+ assertEquals(16, match.getEnd());
+ match = searchResults.getResults().get(1);
+ assertSame(al.getSequenceAt(1), match.getSequence());
+ assertEquals(8, match.getStart());
+ assertEquals(8, match.getEnd());
}
}
git://source.jalview.org / jalview.git / blobdiff