+ assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
+ }
+
+ @Test(groups = { "Functional" })
+ public void testEquals()
+ {
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
+
+ assertFalse(sr1.equals(null)); // null object
+ assertFalse(sr1.equals(seq1)); // wrong type
+ assertTrue(sr1.equals(sr1)); // self
+ assertTrue(sr1.equals(sr2)); // empty
+ assertTrue(sr2.equals(sr1)); // reflexive
+
+ /*
+ * if only one result is not empty
+ */
+ sr1.addResult(seq1, 1, 1);
+ assertTrue(sr1.equals(sr1));
+ assertFalse(sr1.equals(sr2));
+ assertFalse(sr2.equals(sr1));
+
+ /*
+ * both the same
+ */
+ sr2.addResult(seq1, 1, 1);
+ assertTrue(sr1.equals(sr2));
+ assertTrue(sr2.equals(sr1));
+
+ /*
+ * both have three matches
+ */
+ sr1.addResult(seq1, 3, 4);
+ sr1.addResult(seq1, 6, 8);
+ sr2.addResult(seq1, 3, 4);
+ sr2.addResult(seq1, 6, 8);
+ assertTrue(sr1.equals(sr1));
+ assertTrue(sr2.equals(sr2));
+ assertTrue(sr1.equals(sr2));
+ assertTrue(sr2.equals(sr1));
+ }
+
+ /**
+ * Matches that are similar but for distinct sequences are not equal
+ */
+ @Test(groups = { "Functional" })
+ public void testEquals_distinctSequences()
+ {
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SequenceI seq2 = new Sequence("", "abcdefghijklm");
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
+
+ sr1.addResult(seq1, 1, 1);
+ sr2.addResult(seq2, 1, 1);
+ assertFalse(sr1.equals(sr2));
+ assertFalse(sr2.equals(sr1));
+ }
+
+ /**
+ * Matches that are the same except for ordering are not equal
+ */
+ @Test(groups = { "Functional" })
+ public void testEquals_orderDiffers()
+ {
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
+
+ sr1.addResult(seq1, 1, 1);
+ sr1.addResult(seq1, 2, 2);
+ sr2.addResult(seq1, 2, 2);
+ sr2.addResult(seq1, 1, 1);
+ assertFalse(sr1.equals(sr2));
+ assertFalse(sr2.equals(sr1));
+ }
+
+ /**
+ * Verify that hashCode matches for equal objects
+ */
+ @Test(groups = { "Functional" })
+ public void testHashcode()
+ {
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SearchResultsI sr1 = new SearchResults();
+ SearchResultsI sr2 = new SearchResults();
+
+ /*
+ * both empty
+ */
+ assertEquals(sr1.hashCode(), sr2.hashCode());
+
+ /*
+ * both one match
+ */
+ sr1.addResult(seq1, 1, 1);
+ sr2.addResult(seq1, 1, 1);
+ assertEquals(sr1.hashCode(), sr2.hashCode());
+
+ /*
+ * both three matches
+ */
+ sr1.addResult(seq1, 3, 4);
+ sr1.addResult(seq1, 6, 8);
+ sr2.addResult(seq1, 3, 4);
+ sr2.addResult(seq1, 6, 8);
+ assertEquals(sr1.hashCode(), sr2.hashCode());
+ }
+
+ /**
+ * Verify that SearchResults$Match constructor normalises start/end to the
+ * 'forwards' direction
+ */
+ @Test(groups = { "Functional" })
+ public void testMatchConstructor()
+ {
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
+ assertSame(seq1, m.getSequence());
+ assertEquals(2, m.getStart());
+ assertEquals(5, m.getEnd());
+
+ // now a reverse mapping:
+ m = new SearchResults().new Match(seq1, 5, 2);
+ assertSame(seq1, m.getSequence());
+ assertEquals(2, m.getStart());
+ assertEquals(5, m.getEnd());
+ }
+
+ /**
+ * test markColumns for creating column selections
+ */
+ @Test(groups = { "Functional" })
+ public void testMarkColumns()
+ {
+ int marked = 0;
+ SequenceI seq1 = new Sequence("", "abcdefghijklm");
+ SequenceI seq2 = new Sequence("", "abcdefghijklm");
+ SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
+ s1g.addSequence(seq1, false);
+ s2g.addSequence(seq2, false);
+ sallg.addSequence(seq1, false);
+ sallg.addSequence(seq2, false);
+
+ SearchResultsI sr = new SearchResults();
+ BitSet bs = new BitSet();
+
+ SearchResultMatchI srm = null;
+ srm = sr.addResult(seq1, 1, 1);
+ Assert.assertNotNull("addResult didn't return Match", srm);
+ srm = sr.addResult(seq2, 1, 2);
+ assertEquals("Sequence reference not set", seq2, srm.getSequence());
+ assertEquals("match start incorrect", 1, srm.getStart());
+ assertEquals("match end incorrect", 2, srm.getEnd());
+
+ // set start/end range for groups to cover matches
+
+ s1g.setStartRes(0);
+ s1g.setEndRes(5);
+ s2g.setStartRes(0);
+ s2g.setEndRes(5);
+ sallg.setStartRes(0);
+ sallg.setEndRes(5);
+
+ /*
+ * just seq1
+ */
+ marked = sr.markColumns(s1g, bs);
+ // check the bitset cardinality before checking the return value
+ assertEquals("Didn't mark expected number", 1, bs.cardinality());
+ assertEquals("Didn't return count of number of bits marked", 1, marked);
+ assertTrue("Didn't mark expected position", bs.get(0));
+ // now check return value for marking the same again
+ assertEquals(
+ "Didn't count number of bits marked for existing marked set",
+ 0,
+ sr.markColumns(s1g, bs));
+ bs.clear();
+
+ /*
+ * just seq2
+ */
+ marked = sr.markColumns(s2g, bs);
+ assertEquals("Didn't mark expected number", 2, bs.cardinality());
+ assertEquals("Didn't return count of number of bits marked", 2, marked);
+ assertTrue("Didn't mark expected position (1)", bs.get(0));
+ assertTrue("Didn't mark expected position (2)", bs.get(1));
+
+ /*
+ * both seq1 and seq2
+ * should be same as seq2
+ */
+ BitSet allbs = new BitSet();
+ assertEquals(2, sr.markColumns(sallg, allbs));
+ assertEquals(bs, allbs);
+
+ // now check range selection
+
+ /*
+ * limit s2g to just the second column, sallg to the first column
+ */
+ s2g.setStartRes(1);
+ s2g.setEndRes(1);
+ sallg.setEndRes(0);
+ BitSet tbs = new BitSet();
+ assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
+ assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
+ assertEquals(
+ "Didn't set expected number of columns in total for two successive marks",
+ 2, tbs.cardinality());