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