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 import java.util.List;
  30
  31 import org.junit.Assert;
  32 import org.testng.annotations.BeforeClass;
  33 import org.testng.annotations.Test;
  34
  35 import jalview.gui.JvOptionPane;
  36
  37 public class SearchResultsTest
  38 {
  39
  40   @BeforeClass(alwaysRun = true)
  41   public void setUpJvOptionPane()
  42   {
  43     JvOptionPane.setInteractiveMode(false);
  44     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  45   }
  46
  47   @Test(groups = { "Functional" })
  48   public void testToString()
  49   {
  50     SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
  51     SearchResultsI sr = new SearchResults();
  52     sr.addResult(seq, 1, 1);
  53     assertEquals("[Seq1/1-1]", sr.toString());
  54     sr.addResult(seq, 3, 5);
  55     assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
  56
  57     seq = new Sequence("Seq2", "pqrstuvwxy");
  58     sr.addResult(seq, 6, 7);
  59     assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
  60   }
  61
  62   @Test(groups = { "Functional" })
  63   public void testEquals()
  64   {
  65     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  66     SearchResultsI sr1 = new SearchResults();
  67     SearchResultsI sr2 = new SearchResults();
  68
  69     assertFalse(sr1.equals(null)); // null object
  70     assertFalse(sr1.equals(seq1)); // wrong type
  71     assertTrue(sr1.equals(sr1)); // self
  72     assertTrue(sr1.equals(sr2)); // empty
  73     assertTrue(sr2.equals(sr1)); // reflexive
  74
  75     /*
  76      * if only one result is not empty
  77      */
  78     sr1.addResult(seq1, 1, 1);
  79     assertTrue(sr1.equals(sr1));
  80     assertFalse(sr1.equals(sr2));
  81     assertFalse(sr2.equals(sr1));
  82
  83     /*
  84      * both the same
  85      */
  86     sr2.addResult(seq1, 1, 1);
  87     assertTrue(sr1.equals(sr2));
  88     assertTrue(sr2.equals(sr1));
  89
  90     /*
  91      * both have three matches
  92      */
  93     sr1.addResult(seq1, 3, 4);
  94     sr1.addResult(seq1, 6, 8);
  95     sr2.addResult(seq1, 3, 4);
  96     sr2.addResult(seq1, 6, 8);
  97     assertTrue(sr1.equals(sr1));
  98     assertTrue(sr2.equals(sr2));
  99     assertTrue(sr1.equals(sr2));
 100     assertTrue(sr2.equals(sr1));
 101   }
 102
 103   /**
 104    * Matches that are similar but for distinct sequences are not equal
 105    */
 106   @Test(groups = { "Functional" })
 107   public void testEquals_distinctSequences()
 108   {
 109     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 110     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 111     SearchResultsI sr1 = new SearchResults();
 112     SearchResultsI sr2 = new SearchResults();
 113
 114     sr1.addResult(seq1, 1, 1);
 115     sr2.addResult(seq2, 1, 1);
 116     assertFalse(sr1.equals(sr2));
 117     assertFalse(sr2.equals(sr1));
 118   }
 119
 120   /**
 121    * Matches that are the same except for ordering are not equal
 122    */
 123   @Test(groups = { "Functional" })
 124   public void testEquals_orderDiffers()
 125   {
 126     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 127     SearchResultsI sr1 = new SearchResults();
 128     SearchResultsI sr2 = new SearchResults();
 129
 130     sr1.addResult(seq1, 1, 1);
 131     sr1.addResult(seq1, 2, 2);
 132     sr2.addResult(seq1, 2, 2);
 133     sr2.addResult(seq1, 1, 1);
 134     assertFalse(sr1.equals(sr2));
 135     assertFalse(sr2.equals(sr1));
 136   }
 137
 138   /**
 139    * Verify that hashCode matches for equal objects
 140    */
 141   @Test(groups = { "Functional" })
 142   public void testHashcode()
 143   {
 144     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 145     SearchResultsI sr1 = new SearchResults();
 146     SearchResultsI sr2 = new SearchResults();
 147
 148     /*
 149      * both empty
 150      */
 151     assertEquals(sr1.hashCode(), sr2.hashCode());
 152
 153     /*
 154      * both one match
 155      */
 156     sr1.addResult(seq1, 1, 1);
 157     sr2.addResult(seq1, 1, 1);
 158     assertEquals(sr1.hashCode(), sr2.hashCode());
 159
 160     /*
 161      * both three matches
 162      */
 163     sr1.addResult(seq1, 3, 4);
 164     sr1.addResult(seq1, 6, 8);
 165     sr2.addResult(seq1, 3, 4);
 166     sr2.addResult(seq1, 6, 8);
 167     assertEquals(sr1.hashCode(), sr2.hashCode());
 168   }
 169
 170   /**
 171    * Verify that SearchResults$Match constructor normalises start/end to the
 172    * 'forwards' direction
 173    */
 174   @Test(groups = { "Functional" })
 175   public void testMatchConstructor()
 176   {
 177     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 178     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 179     assertSame(seq1, m.getSequence());
 180     assertEquals(2, m.getStart());
 181     assertEquals(5, m.getEnd());
 182
 183     // now a reverse mapping:
 184     m = new SearchResults().new Match(seq1, 5, 2);
 185     assertSame(seq1, m.getSequence());
 186     assertEquals(2, m.getStart());
 187     assertEquals(5, m.getEnd());
 188   }
 189
 190   @Test(groups = { "Functional" })
 191   public void testMatchContains()
 192   {
 193     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 194     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 195     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 196
 197     assertTrue(m.contains(seq1, 2, 5));
 198     assertTrue(m.contains(seq1, 3, 5));
 199     assertTrue(m.contains(seq1, 2, 4));
 200     assertTrue(m.contains(seq1, 3, 3));
 201
 202     assertFalse(m.contains(seq1, 2, 6));
 203     assertFalse(m.contains(seq1, 1, 5));
 204     assertFalse(m.contains(seq1, 1, 8));
 205     assertFalse(m.contains(seq2, 3, 3));
 206     assertFalse(m.contains(null, 3, 3));
 207   }
 208
 209   @Test(groups = { "Functional" })
 210   public void testMatchAdjacent()
 211   {
 212     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 213     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 214     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 215
 216     assertTrue(m.adjacent(seq1, 2, 5));
 217     assertTrue(m.adjacent(seq1, 3, 5));
 218     assertTrue(m.adjacent(seq1, 2, 4));
 219     assertTrue(m.adjacent(seq1, 3, 3));
 220
 221     assertTrue(m.adjacent(seq1, 2, 6));
 222     assertTrue(m.adjacent(seq1, 1, 5));
 223     assertTrue(m.adjacent(seq1, 1, 8));
 224     assertFalse(m.adjacent(seq1, 0, 0));
 225     assertFalse(m.adjacent(seq1, 7, 8));
 226     assertTrue(m.adjacent(seq1, 6, 8));
 227     assertTrue(m.adjacent(seq1, 5, 8));
 228     assertTrue(m.adjacent(seq1, 0, 1));
 229
 230     assertFalse(m.adjacent(seq2, 3, 3));
 231     assertFalse(m.adjacent(null, 3, 3));
 232   }
 233
 234   /**
 235    * test markColumns for creating column selections
 236    */
 237   @Test(groups = { "Functional" })
 238   public void testMarkColumns()
 239   {
 240     int marked = 0;
 241     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 242     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 243     SequenceGroup s1g = new SequenceGroup(), s2g = new SequenceGroup(),
 244             sallg = new SequenceGroup();
 245     s1g.addSequence(seq1, false);
 246     s2g.addSequence(seq2, false);
 247     sallg.addSequence(seq1, false);
 248     sallg.addSequence(seq2, false);
 249
 250     SearchResultsI sr = new SearchResults();
 251     BitSet bs = new BitSet();
 252
 253     SearchResultMatchI srm = null;
 254     srm = sr.addResult(seq1, 1, 1);
 255     Assert.assertNotNull("addResult didn't return Match", srm);
 256     srm = sr.addResult(seq2, 1, 2);
 257     assertEquals("Sequence reference not set", seq2, srm.getSequence());
 258     assertEquals("match start incorrect", 1, srm.getStart());
 259     assertEquals("match end incorrect", 2, srm.getEnd());
 260
 261     // set start/end range for groups to cover matches
 262
 263     s1g.setStartRes(0);
 264     s1g.setEndRes(5);
 265     s2g.setStartRes(0);
 266     s2g.setEndRes(5);
 267     sallg.setStartRes(0);
 268     sallg.setEndRes(5);
 269
 270     /*
 271      * just seq1
 272      */
 273     marked = sr.markColumns(s1g, bs);
 274     // check the bitset cardinality before checking the return value
 275     assertEquals("Didn't mark expected number", 1, bs.cardinality());
 276     assertEquals("Didn't return count of number of bits marked", 1, marked);
 277     assertTrue("Didn't mark expected position", bs.get(0));
 278     // now check return value for marking the same again
 279     assertEquals(
 280             "Didn't count number of bits marked for existing marked set", 0,
 281             sr.markColumns(s1g, bs));
 282     bs.clear();
 283
 284     /*
 285      * just seq2
 286      */
 287     marked = sr.markColumns(s2g, bs);
 288     assertEquals("Didn't mark expected number", 2, bs.cardinality());
 289     assertEquals("Didn't return count of number of bits marked", 2, marked);
 290     assertTrue("Didn't mark expected position (1)", bs.get(0));
 291     assertTrue("Didn't mark expected position (2)", bs.get(1));
 292
 293     /*
 294      * both seq1 and seq2
 295      * should be same as seq2
 296      */
 297     BitSet allbs = new BitSet();
 298     assertEquals(2, sr.markColumns(sallg, allbs));
 299     assertEquals(bs, allbs);
 300
 301     // now check range selection
 302
 303     /*
 304      * limit s2g to just the second column, sallg to the first column
 305      */
 306     s2g.setStartRes(1);
 307     s2g.setEndRes(1);
 308     sallg.setEndRes(0);
 309     BitSet tbs = new BitSet();
 310     assertEquals("Group start/end didn't select columns to mark", 1,
 311             sr.markColumns(s2g, tbs));
 312     assertEquals("Group start/end didn't select columns to mark", 1,
 313             sr.markColumns(sallg, tbs));
 314     assertEquals(
 315             "Didn't set expected number of columns in total for two successive marks",
 316             2, tbs.cardinality());
 317   }
 318
 319   /**
 320    * Test to verify adding doesn't create duplicate results
 321    */
 322   @Test(groups = { "Functional" })
 323   public void testAddResult()
 324   {
 325     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 326     SearchResultsI sr = new SearchResults();
 327     sr.addResult(seq1, 3, 5);
 328     assertEquals(1, sr.getCount());
 329     sr.addResult(seq1, 3, 5);
 330     assertEquals(1, sr.getCount());
 331     sr.addResult(seq1, 3, 6);
 332     assertEquals(2, sr.getCount());
 333   }
 334
 335   /**
 336    * Test to verify appending creates a minimal set of results
 337    */
 338   @Test(groups = { "Functional" })
 339   public void testAppendResult()
 340   {
 341     SequenceI seq1 = new Sequence("", "abcdefghijklm"),
 342             seq2 = new Sequence("", "defdefdefdef");
 343     SearchResultsI sr = new SearchResults();
 344     sr.appendResult(seq1, 3, 5);
 345     assertEquals(1, sr.getCount());
 346     sr.appendResult(seq1, 3, 6);
 347     assertEquals(1, sr.getCount());
 348     sr.appendResult(seq1, 8, 8);
 349     assertEquals(2, sr.getCount());
 350     sr.appendResult(seq1, 7, 7);
 351     assertEquals(1, sr.getCount());
 352     sr.appendResult(seq2, 7, 7);
 353     assertEquals(2, sr.getCount());
 354     sr.appendResult(seq2, 2, 7);
 355     assertTrue(sr.appendResult(seq2, 7, 49));
 356     assertTrue(sr.appendResult(seq2, 0, 30));
 357     assertEquals(2, sr.getCount());
 358     int c = 0;
 359     for (SearchResultMatchI sre : sr.getResults())
 360     {
 361       c++;
 362     }
 363     assertEquals(c, 2);
 364
 365   }
 366
 367   /**
 368    * Test for method that checks if search results matches a sequence region
 369    */
 370   @Test(groups = { "Functional" })
 371   public void testInvolvesSequence()
 372   {
 373     SequenceI dataset = new Sequence("genome", "ATGGCCCTTTAAGCAACATTT");
 374     // first 'exon':
 375     SequenceI cds1 = new Sequence("cds1/1-12", "ATGGCCCTTTAA");
 376     cds1.setDatasetSequence(dataset);
 377     // overlapping second 'exon':
 378     SequenceI cds2 = new Sequence("cds2/7-18", "CTTTAAGCAACA");
 379     cds2.setDatasetSequence(dataset);
 380     // unrelated sequence
 381     SequenceI cds3 = new Sequence("cds3", "ATGGCCCTTTAAGCAACA");
 382
 383     SearchResults sr = new SearchResults();
 384     assertFalse(sr.involvesSequence(cds1));
 385
 386     /*
 387      * cds1 and cds2 share the same dataset sequence, but
 388      * only cds1 overlaps match 4:6 (fixes bug JAL-3613)
 389      */
 390     sr.addResult(dataset, 4, 6);
 391     assertTrue(sr.involvesSequence(cds1));
 392     assertFalse(sr.involvesSequence(cds2));
 393     assertFalse(sr.involvesSequence(cds3));
 394
 395     /*
 396      * search results overlap cds2 only
 397      */
 398     sr = new SearchResults();
 399     sr.addResult(dataset, 18, 18);
 400     assertFalse(sr.involvesSequence(cds1));
 401     assertTrue(sr.involvesSequence(cds2));
 402
 403     /*
 404      * add a search result overlapping cds1
 405      */
 406     sr.addResult(dataset, 1, 1);
 407     assertTrue(sr.involvesSequence(cds1));
 408     assertTrue(sr.involvesSequence(cds2));
 409
 410     /*
 411      * single search result overlapping both
 412      */
 413     sr = new SearchResults();
 414     sr.addResult(dataset, 10, 12);
 415     assertTrue(sr.involvesSequence(cds1));
 416     assertTrue(sr.involvesSequence(cds2));
 417
 418     /*
 419      * search results matching aligned sequence
 420      */
 421     sr = new SearchResults();
 422     sr.addResult(cds1, 10, 12);
 423     assertTrue(sr.involvesSequence(cds1));
 424     assertFalse(sr.involvesSequence(cds2));
 425     sr.addResult(cds2, 1, 3); // no start-end overlap
 426     assertFalse(sr.involvesSequence(cds2));
 427     sr.addResult(cds2, 7, 9); // start-end overlap
 428     assertTrue(sr.involvesSequence(cds2));
 429   }
 430
 431   /**
 432    * Test extraction of Sequence objects for matched ranges on a sequence
 433    */
 434   @Test(groups = { "Functional" })
 435   public void testGetSequences()
 436   {
 437     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 438     SequenceI seq2 = new Sequence("", "nopqrstuvwxyz");
 439     seq2.setStart(23);
 440     seq2.setEnd(35);
 441     List<SequenceI> seqres = null;
 442
 443     SearchResultsI sr = new SearchResults();
 444     seqres = sr.getMatchingSubSequences();
 445     assertEquals(0, seqres.size());
 446
 447     sr.addResult(seq1, 3, 5);
 448     seqres = sr.getMatchingSubSequences();
 449
 450     assertEquals(1, seqres.size());
 451     assertEquals("cde", seqres.get(0).getSequenceAsString());
 452     assertEquals(3, seqres.get(0).getStart());
 453     assertEquals(seq1, seqres.get(0).getDatasetSequence());
 454
 455     sr.addResult(seq1, 3, 6);
 456     seqres = sr.getMatchingSubSequences();
 457
 458     assertEquals(2, seqres.size());
 459     assertEquals("cdef", seqres.get(1).getSequenceAsString());
 460     assertEquals(3, seqres.get(1).getStart());
 461
 462     // this is a quirk - match on 26-29 yields subsequence 27-30
 463     sr.addResult(seq2, 26, 29);
 464     seqres = sr.getMatchingSubSequences();
 465     assertEquals(3, seqres.size());
 466     assertEquals("qrst", seqres.get(2).getSequenceAsString());
 467     assertEquals(26, seqres.get(2).getStart());
 468   }
 469
 470 }