test/jalview/datamodel/SearchResultsTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.datamodel;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertSame;
  26 import static org.testng.AssertJUnit.assertTrue;
  27
  28 import java.util.BitSet;
  29
  30 import org.junit.Assert;
  31 import org.testng.annotations.BeforeClass;
  32 import org.testng.annotations.Test;
  33
  34 import jalview.gui.JvOptionPane;
  35
  36 public class SearchResultsTest
  37 {
  38
  39   @BeforeClass(alwaysRun = true)
  40   public void setUpJvOptionPane()
  41   {
  42     JvOptionPane.setInteractiveMode(false);
  43     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  44   }
  45
  46   @Test(groups = { "Functional" })
  47   public void testToString()
  48   {
  49     SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
  50     SearchResultsI sr = new SearchResults();
  51     sr.addResult(seq, 1, 1);
  52     assertEquals("[Seq1/1-1]", sr.toString());
  53     sr.addResult(seq, 3, 5);
  54     assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
  55
  56     seq = new Sequence("Seq2", "pqrstuvwxy");
  57     sr.addResult(seq, 6, 7);
  58     assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
  59   }
  60
  61   @Test(groups = { "Functional" })
  62   public void testEquals()
  63   {
  64     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  65     SearchResultsI sr1 = new SearchResults();
  66     SearchResultsI sr2 = new SearchResults();
  67
  68     assertFalse(sr1.equals(null)); // null object
  69     assertFalse(sr1.equals(seq1)); // wrong type
  70     assertTrue(sr1.equals(sr1)); // self
  71     assertTrue(sr1.equals(sr2)); // empty
  72     assertTrue(sr2.equals(sr1)); // reflexive
  73
  74     /*
  75      * if only one result is not empty
  76      */
  77     sr1.addResult(seq1, 1, 1);
  78     assertTrue(sr1.equals(sr1));
  79     assertFalse(sr1.equals(sr2));
  80     assertFalse(sr2.equals(sr1));
  81
  82     /*
  83      * both the same
  84      */
  85     sr2.addResult(seq1, 1, 1);
  86     assertTrue(sr1.equals(sr2));
  87     assertTrue(sr2.equals(sr1));
  88
  89     /*
  90      * both have three matches
  91      */
  92     sr1.addResult(seq1, 3, 4);
  93     sr1.addResult(seq1, 6, 8);
  94     sr2.addResult(seq1, 3, 4);
  95     sr2.addResult(seq1, 6, 8);
  96     assertTrue(sr1.equals(sr1));
  97     assertTrue(sr2.equals(sr2));
  98     assertTrue(sr1.equals(sr2));
  99     assertTrue(sr2.equals(sr1));
 100   }
 101
 102   /**
 103    * Matches that are similar but for distinct sequences are not equal
 104    */
 105   @Test(groups = { "Functional" })
 106   public void testEquals_distinctSequences()
 107   {
 108     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 109     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 110     SearchResultsI sr1 = new SearchResults();
 111     SearchResultsI sr2 = new SearchResults();
 112
 113     sr1.addResult(seq1, 1, 1);
 114     sr2.addResult(seq2, 1, 1);
 115     assertFalse(sr1.equals(sr2));
 116     assertFalse(sr2.equals(sr1));
 117   }
 118
 119   /**
 120    * Matches that are the same except for ordering are not equal
 121    */
 122   @Test(groups = { "Functional" })
 123   public void testEquals_orderDiffers()
 124   {
 125     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 126     SearchResultsI sr1 = new SearchResults();
 127     SearchResultsI sr2 = new SearchResults();
 128
 129     sr1.addResult(seq1, 1, 1);
 130     sr1.addResult(seq1, 2, 2);
 131     sr2.addResult(seq1, 2, 2);
 132     sr2.addResult(seq1, 1, 1);
 133     assertFalse(sr1.equals(sr2));
 134     assertFalse(sr2.equals(sr1));
 135   }
 136
 137   /**
 138    * Verify that hashCode matches for equal objects
 139    */
 140   @Test(groups = { "Functional" })
 141   public void testHashcode()
 142   {
 143     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 144     SearchResultsI sr1 = new SearchResults();
 145     SearchResultsI sr2 = new SearchResults();
 146
 147     /*
 148      * both empty
 149      */
 150     assertEquals(sr1.hashCode(), sr2.hashCode());
 151
 152     /*
 153      * both one match
 154      */
 155     sr1.addResult(seq1, 1, 1);
 156     sr2.addResult(seq1, 1, 1);
 157     assertEquals(sr1.hashCode(), sr2.hashCode());
 158
 159     /*
 160      * both three matches
 161      */
 162     sr1.addResult(seq1, 3, 4);
 163     sr1.addResult(seq1, 6, 8);
 164     sr2.addResult(seq1, 3, 4);
 165     sr2.addResult(seq1, 6, 8);
 166     assertEquals(sr1.hashCode(), sr2.hashCode());
 167   }
 168
 169   /**
 170    * Verify that SearchResults$Match constructor normalises start/end to the
 171    * 'forwards' direction
 172    */
 173   @Test(groups = { "Functional" })
 174   public void testMatchConstructor()
 175   {
 176     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 177     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 178     assertSame(seq1, m.getSequence());
 179     assertEquals(2, m.getStart());
 180     assertEquals(5, m.getEnd());
 181
 182     // now a reverse mapping:
 183     m = new SearchResults().new Match(seq1, 5, 2);
 184     assertSame(seq1, m.getSequence());
 185     assertEquals(2, m.getStart());
 186     assertEquals(5, m.getEnd());
 187   }
 188
 189   @Test(groups = { "Functional" })
 190   public void testMatchContains()
 191   {
 192     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 193     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 194     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 195
 196     assertTrue(m.contains(seq1, 2, 5));
 197     assertTrue(m.contains(seq1, 3, 5));
 198     assertTrue(m.contains(seq1, 2, 4));
 199     assertTrue(m.contains(seq1, 3, 3));
 200
 201     assertFalse(m.contains(seq1, 2, 6));
 202     assertFalse(m.contains(seq1, 1, 5));
 203     assertFalse(m.contains(seq1, 1, 8));
 204     assertFalse(m.contains(seq2, 3, 3));
 205     assertFalse(m.contains(null, 3, 3));
 206   }
 207
 208   /**
 209    * test markColumns for creating column selections
 210    */
 211   @Test(groups = { "Functional" })
 212   public void testMarkColumns()
 213   {
 214     int marked = 0;
 215     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 216     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 217     SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(),
 218             sallg = new SequenceGroup();
 219     s1g.addSequence(seq1, false);
 220     s2g.addSequence(seq2, false);
 221     sallg.addSequence(seq1, false);
 222     sallg.addSequence(seq2, false);
 223
 224     SearchResultsI sr = new SearchResults();
 225     BitSet bs = new BitSet();
 226
 227     SearchResultMatchI srm = null;
 228     srm = sr.addResult(seq1, 1, 1);
 229     Assert.assertNotNull("addResult didn't return Match", srm);
 230     srm = sr.addResult(seq2, 1, 2);
 231     assertEquals("Sequence reference not set", seq2, srm.getSequence());
 232     assertEquals("match start incorrect", 1, srm.getStart());
 233     assertEquals("match end incorrect", 2, srm.getEnd());
 234
 235     // set start/end range for groups to cover matches
 236
 237     s1g.setStartRes(0);
 238     s1g.setEndRes(5);
 239     s2g.setStartRes(0);
 240     s2g.setEndRes(5);
 241     sallg.setStartRes(0);
 242     sallg.setEndRes(5);
 243
 244     /*
 245      * just seq1
 246      */
 247     marked = sr.markColumns(s1g, bs);
 248     // check the bitset cardinality before checking the return value
 249     assertEquals("Didn't mark expected number", 1, bs.cardinality());
 250     assertEquals("Didn't return count of number of bits marked", 1, marked);
 251     assertTrue("Didn't mark expected position", bs.get(0));
 252     // now check return value for marking the same again
 253     assertEquals(
 254             "Didn't count number of bits marked for existing marked set", 0,
 255             sr.markColumns(s1g, bs));
 256     bs.clear();
 257
 258     /*
 259      * just seq2
 260      */
 261     marked = sr.markColumns(s2g, bs);
 262     assertEquals("Didn't mark expected number", 2, bs.cardinality());
 263     assertEquals("Didn't return count of number of bits marked", 2, marked);
 264     assertTrue("Didn't mark expected position (1)", bs.get(0));
 265     assertTrue("Didn't mark expected position (2)", bs.get(1));
 266
 267     /*
 268      * both seq1 and seq2
 269      * should be same as seq2
 270      */
 271     BitSet allbs = new BitSet();
 272     assertEquals(2, sr.markColumns(sallg, allbs));
 273     assertEquals(bs, allbs);
 274
 275     // now check range selection
 276
 277     /*
 278      * limit s2g to just the second column, sallg to the first column
 279      */
 280     s2g.setStartRes(1);
 281     s2g.setEndRes(1);
 282     sallg.setEndRes(0);
 283     BitSet tbs = new BitSet();
 284     assertEquals("Group start/end didn't select columns to mark", 1,
 285             sr.markColumns(s2g, tbs));
 286     assertEquals("Group start/end didn't select columns to mark", 1,
 287             sr.markColumns(sallg, tbs));
 288     assertEquals(
 289             "Didn't set expected number of columns in total for two successive marks",
 290             2, tbs.cardinality());
 291   }
 292
 293   /**
 294    * Test to verify adding doesn't create duplicate results
 295    */
 296   @Test(groups = { "Functional" })
 297   public void testAddResult()
 298   {
 299     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 300     SearchResultsI sr = new SearchResults();
 301     sr.addResult(seq1, 3, 5);
 302     assertEquals(1, sr.getCount());
 303     sr.addResult(seq1, 3, 5);
 304     assertEquals(1, sr.getCount());
 305     sr.addResult(seq1, 3, 6);
 306     assertEquals(2, sr.getCount());
 307   }
 308
 309   /**
 310    * Test for method that checks if search results matches a sequence region
 311    */
 312   @Test(groups = { "Functional" })
 313   public void testInvolvesSequence()
 314   {
 315     SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT");
 316     // first 'exon':
 317     SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA");
 318     cds1.setDatasetSequence(dataset);
 319     // overlapping second 'exon':
 320     SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA");
 321     cds2.setDatasetSequence(dataset);
 322     // unrelated sequence
 323     SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA");
 324
 325     SearchResults sr = new SearchResults();
 326     assertFalse(sr.involvesSequence(cds1));
 327
 328     /*
 329      * cds1 and cds2 share the same dataset sequence, but
 330      * only cds1 overlaps match 4:6 (fixes bug JAL-3613)
 331      */
 332     sr.addResult(dataset, 4, 6);
 333     assertTrue(sr.involvesSequence(cds1));
 334     assertFalse(sr.involvesSequence(cds2));
 335     assertFalse(sr.involvesSequence(cds3));
 336
 337     /*
 338      * search results overlap cds2 only
 339      */
 340     sr = new SearchResults();
 341     sr.addResult(dataset, 18, 18);
 342     assertFalse(sr.involvesSequence(cds1));
 343     assertTrue(sr.involvesSequence(cds2));
 344
 345     /*
 346      * add a search result overlapping cds1
 347      */
 348     sr.addResult(dataset, 1, 1);
 349     assertTrue(sr.involvesSequence(cds1));
 350     assertTrue(sr.involvesSequence(cds2));
 351
 352     /*
 353      * single search result overlapping both
 354      */
 355     sr = new SearchResults();
 356     sr.addResult(dataset, 10, 12);
 357     assertTrue(sr.involvesSequence(cds1));
 358     assertTrue(sr.involvesSequence(cds2));
 359
 360     /*
 361      * search results matching aligned sequence
 362      */
 363     sr = new SearchResults();
 364     sr.addResult(cds1, 10, 12);
 365     assertTrue(sr.involvesSequence(cds1));
 366     assertFalse(sr.involvesSequence(cds2));
 367     sr.addResult(cds2, 1, 3); // no start-end overlap
 368     assertFalse(sr.involvesSequence(cds2));
 369     sr.addResult(cds2, 7, 9); // start-end overlap
 370     assertTrue(sr.involvesSequence(cds2));
 371   }
 372 }