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.Test;
  32
  33 public class SearchResultsTest
  34 {
  35
  36   @Test(groups = { "Functional" })
  37   public void testToString()
  38   {
  39     SequenceI seq = new Sequence("Seq1", "abcdefghijklm");
  40     SearchResultsI sr = new SearchResults();
  41     sr.addResult(seq, 1, 1);
  42     assertEquals("[Seq1/1-1]", sr.toString());
  43     sr.addResult(seq, 3, 5);
  44     assertEquals("[Seq1/1-1, Seq1/3-5]", sr.toString());
  45
  46     seq = new Sequence("Seq2", "pqrstuvwxy");
  47     sr.addResult(seq, 6, 7);
  48     assertEquals("[Seq1/1-1, Seq1/3-5, Seq2/6-7]", sr.toString());
  49   }
  50
  51   @Test(groups = { "Functional" })
  52   public void testEquals()
  53   {
  54     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  55     SearchResultsI sr1 = new SearchResults();
  56     SearchResultsI sr2 = new SearchResults();
  57
  58     assertFalse(sr1.equals(null)); // null object
  59     assertFalse(sr1.equals(seq1)); // wrong type
  60     assertTrue(sr1.equals(sr1)); // self
  61     assertTrue(sr1.equals(sr2)); // empty
  62     assertTrue(sr2.equals(sr1)); // reflexive
  63
  64     /*
  65      * if only one result is not empty
  66      */
  67     sr1.addResult(seq1, 1, 1);
  68     assertTrue(sr1.equals(sr1));
  69     assertFalse(sr1.equals(sr2));
  70     assertFalse(sr2.equals(sr1));
  71
  72     /*
  73      * both the same
  74      */
  75     sr2.addResult(seq1, 1, 1);
  76     assertTrue(sr1.equals(sr2));
  77     assertTrue(sr2.equals(sr1));
  78
  79     /*
  80      * both have three matches
  81      */
  82     sr1.addResult(seq1, 3, 4);
  83     sr1.addResult(seq1, 6, 8);
  84     sr2.addResult(seq1, 3, 4);
  85     sr2.addResult(seq1, 6, 8);
  86     assertTrue(sr1.equals(sr1));
  87     assertTrue(sr2.equals(sr2));
  88     assertTrue(sr1.equals(sr2));
  89     assertTrue(sr2.equals(sr1));
  90   }
  91
  92   /**
  93    * Matches that are similar but for distinct sequences are not equal
  94    */
  95   @Test(groups = { "Functional" })
  96   public void testEquals_distinctSequences()
  97   {
  98     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  99     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 100     SearchResultsI sr1 = new SearchResults();
 101     SearchResultsI sr2 = new SearchResults();
 102
 103     sr1.addResult(seq1, 1, 1);
 104     sr2.addResult(seq2, 1, 1);
 105     assertFalse(sr1.equals(sr2));
 106     assertFalse(sr2.equals(sr1));
 107   }
 108
 109   /**
 110    * Matches that are the same except for ordering are not equal
 111    */
 112   @Test(groups = { "Functional" })
 113   public void testEquals_orderDiffers()
 114   {
 115     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 116     SearchResultsI sr1 = new SearchResults();
 117     SearchResultsI sr2 = new SearchResults();
 118
 119     sr1.addResult(seq1, 1, 1);
 120     sr1.addResult(seq1, 2, 2);
 121     sr2.addResult(seq1, 2, 2);
 122     sr2.addResult(seq1, 1, 1);
 123     assertFalse(sr1.equals(sr2));
 124     assertFalse(sr2.equals(sr1));
 125   }
 126
 127   /**
 128    * Verify that hashCode matches for equal objects
 129    */
 130   @Test(groups = { "Functional" })
 131   public void testHashcode()
 132   {
 133     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 134     SearchResultsI sr1 = new SearchResults();
 135     SearchResultsI sr2 = new SearchResults();
 136
 137     /*
 138      * both empty
 139      */
 140     assertEquals(sr1.hashCode(), sr2.hashCode());
 141
 142     /*
 143      * both one match
 144      */
 145     sr1.addResult(seq1, 1, 1);
 146     sr2.addResult(seq1, 1, 1);
 147     assertEquals(sr1.hashCode(), sr2.hashCode());
 148
 149     /*
 150      * both three matches
 151      */
 152     sr1.addResult(seq1, 3, 4);
 153     sr1.addResult(seq1, 6, 8);
 154     sr2.addResult(seq1, 3, 4);
 155     sr2.addResult(seq1, 6, 8);
 156     assertEquals(sr1.hashCode(), sr2.hashCode());
 157   }
 158
 159   /**
 160    * Verify that SearchResults$Match constructor normalises start/end to the
 161    * 'forwards' direction
 162    */
 163   @Test(groups = { "Functional" })
 164   public void testMatchConstructor()
 165   {
 166     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 167     SearchResultMatchI m = new SearchResults().new Match(seq1, 2, 5);
 168     assertSame(seq1, m.getSequence());
 169     assertEquals(2, m.getStart());
 170     assertEquals(5, m.getEnd());
 171
 172     // now a reverse mapping:
 173     m = new SearchResults().new Match(seq1, 5, 2);
 174     assertSame(seq1, m.getSequence());
 175     assertEquals(2, m.getStart());
 176     assertEquals(5, m.getEnd());
 177   }
 178
 179   /**
 180    * test markColumns for creating column selections
 181    */
 182   @Test(groups = { "Functional" })
 183   public void testMarkColumns()
 184   {
 185     int marked = 0;
 186     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 187     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 188     SequenceGroup s1g=new SequenceGroup(), s2g=new SequenceGroup(), sallg=new SequenceGroup();
 189     s1g.addSequence(seq1, false);
 190     s2g.addSequence(seq2, false);
 191     sallg.addSequence(seq1, false);
 192     sallg.addSequence(seq2, false);
 193
 194     SearchResultsI sr = new SearchResults();
 195     BitSet bs = new BitSet();
 196
 197     SearchResultMatchI srm = null;
 198     srm = sr.addResult(seq1, 1, 1);
 199     Assert.assertNotNull("addResult didn't return Match", srm);
 200     srm = sr.addResult(seq2, 1, 2);
 201     assertEquals("Sequence reference not set", seq2, srm.getSequence());
 202     assertEquals("match start incorrect", 1, srm.getStart());
 203     assertEquals("match end incorrect", 2, srm.getEnd());
 204
 205     // set start/end range for groups to cover matches
 206
 207     s1g.setStartRes(0);
 208     s1g.setEndRes(5);
 209     s2g.setStartRes(0);
 210     s2g.setEndRes(5);
 211     sallg.setStartRes(0);
 212     sallg.setEndRes(5);
 213
 214     /*
 215      * just seq1
 216      */
 217     marked = sr.markColumns(s1g, bs);
 218     // check the bitset cardinality before checking the return value
 219     assertEquals("Didn't mark expected number", 1, bs.cardinality());
 220     assertEquals("Didn't return count of number of bits marked", 1, marked);
 221     assertTrue("Didn't mark expected position", bs.get(0));
 222     // now check return value for marking the same again
 223     assertEquals(
 224             "Didn't count number of bits marked for existing marked set",
 225             0,
 226             sr.markColumns(s1g, bs));
 227     bs.clear();
 228
 229     /*
 230      * just seq2
 231      */
 232     marked = sr.markColumns(s2g, bs);
 233     assertEquals("Didn't mark expected number", 2, bs.cardinality());
 234     assertEquals("Didn't return count of number of bits marked", 2, marked);
 235     assertTrue("Didn't mark expected position (1)", bs.get(0));
 236     assertTrue("Didn't mark expected position (2)", bs.get(1));
 237
 238     /*
 239      * both seq1 and seq2
 240      * should be same as seq2
 241      */
 242     BitSet allbs = new BitSet();
 243     assertEquals(2, sr.markColumns(sallg, allbs));
 244     assertEquals(bs, allbs);
 245
 246     // now check range selection
 247
 248     /*
 249      * limit s2g to just the second column, sallg to the first column
 250      */
 251     s2g.setStartRes(1);
 252     s2g.setEndRes(1);
 253     sallg.setEndRes(0);
 254     BitSet tbs = new BitSet();
 255     assertEquals("Group start/end didn't select columns to mark",1, sr.markColumns(s2g, tbs));
 256     assertEquals("Group start/end didn't select columns to mark", 1, sr.markColumns(sallg, tbs));
 257     assertEquals(
 258             "Didn't set expected number of columns in total for two successive marks",
 259             2, tbs.cardinality());
 260   }
 261 }