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 jalview.datamodel.SearchResults.Match;
  29
  30 import org.testng.annotations.Test;
  31
  32 public class SearchResultsTest
  33 {
  34
  35   @Test(groups = { "Functional" })
  36   public void testToString()
  37   {
  38     SequenceI seq = new Sequence("", "abcdefghijklm");
  39     SearchResults sr = new SearchResults();
  40     sr.addResult(seq, 1, 1);
  41     assertEquals("0a", sr.toString());
  42     sr.addResult(seq, 3, 5);
  43     assertEquals("0a2cde", sr.toString());
  44
  45     seq = new Sequence("", "pqrstuvwxy");
  46     sr.addResult(seq, 6, 7);
  47     assertEquals("0a2cde5uv", sr.toString());
  48   }
  49
  50   @Test(groups = { "Functional" })
  51   public void testGetCharacters()
  52   {
  53     SequenceI seq = new Sequence("", "abcdefghijklm");
  54     SearchResults sr = new SearchResults();
  55     sr.addResult(seq, 1, 1);
  56     assertEquals("a", sr.getCharacters());
  57     sr.addResult(seq, 3, 5);
  58     assertEquals("acde", sr.getCharacters());
  59
  60     seq = new Sequence("", "pqrstuvwxy");
  61     sr.addResult(seq, 6, 7);
  62     assertEquals("acdeuv", sr.getCharacters());
  63   }
  64
  65   @Test(groups = { "Functional" })
  66   public void testEquals()
  67   {
  68     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  69     SearchResults sr1 = new SearchResults();
  70     SearchResults sr2 = new SearchResults();
  71
  72     assertFalse(sr1.equals(null)); // null object
  73     assertFalse(sr1.equals(seq1)); // wrong type
  74     assertTrue(sr1.equals(sr1)); // self
  75     assertTrue(sr1.equals(sr2)); // empty
  76     assertTrue(sr2.equals(sr1)); // reflexive
  77
  78     /*
  79      * only one result is not empty
  80      */
  81     sr1.addResult(seq1, 1, 1);
  82     assertTrue(sr1.equals(sr1));
  83     assertFalse(sr1.equals(sr2));
  84     assertFalse(sr2.equals(sr1));
  85
  86     /*
  87      * both the same
  88      */
  89     sr2.addResult(seq1, 1, 1);
  90     assertTrue(sr1.equals(sr2));
  91     assertTrue(sr2.equals(sr1));
  92
  93     /*
  94      * both have three matches
  95      */
  96     sr1.addResult(seq1, 3, 4);
  97     sr1.addResult(seq1, 6, 8);
  98     sr2.addResult(seq1, 3, 4);
  99     sr2.addResult(seq1, 6, 8);
 100     assertTrue(sr1.equals(sr1));
 101     assertTrue(sr2.equals(sr2));
 102     assertTrue(sr1.equals(sr2));
 103     assertTrue(sr2.equals(sr1));
 104   }
 105
 106   /**
 107    * Matches that are similar but for distinct sequences are not equal
 108    */
 109   @Test(groups = { "Functional" })
 110   public void testEquals_distinctSequences()
 111   {
 112     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 113     SequenceI seq2 = new Sequence("", "abcdefghijklm");
 114     SearchResults sr1 = new SearchResults();
 115     SearchResults sr2 = new SearchResults();
 116
 117     sr1.addResult(seq1, 1, 1);
 118     sr2.addResult(seq2, 1, 1);
 119     assertFalse(sr1.equals(sr2));
 120     assertFalse(sr2.equals(sr1));
 121   }
 122
 123   /**
 124    * Matches that are the same except for ordering are not equal
 125    */
 126   @Test(groups = { "Functional" })
 127   public void testEquals_orderDiffers()
 128   {
 129     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 130     SearchResults sr1 = new SearchResults();
 131     SearchResults sr2 = new SearchResults();
 132
 133     sr1.addResult(seq1, 1, 1);
 134     sr1.addResult(seq1, 2, 2);
 135     sr2.addResult(seq1, 2, 2);
 136     sr2.addResult(seq1, 1, 1);
 137     assertFalse(sr1.equals(sr2));
 138     assertFalse(sr2.equals(sr1));
 139   }
 140
 141   /**
 142    * Verify that hashCode matches for equal objects
 143    */
 144   @Test(groups = { "Functional" })
 145   public void testHashcode()
 146   {
 147     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 148     SearchResults sr1 = new SearchResults();
 149     SearchResults sr2 = new SearchResults();
 150
 151     /*
 152      * both empty
 153      */
 154     assertEquals(sr1.hashCode(), sr2.hashCode());
 155
 156     /*
 157      * both one match
 158      */
 159     sr1.addResult(seq1, 1, 1);
 160     sr2.addResult(seq1, 1, 1);
 161     assertEquals(sr1.hashCode(), sr2.hashCode());
 162
 163     /*
 164      * both three matches
 165      */
 166     sr1.addResult(seq1, 3, 4);
 167     sr1.addResult(seq1, 6, 8);
 168     sr2.addResult(seq1, 3, 4);
 169     sr2.addResult(seq1, 6, 8);
 170     assertEquals(sr1.hashCode(), sr2.hashCode());
 171   }
 172
 173   /**
 174    * Verify that SearchResults$Match constructor normalises start/end to the
 175    * 'forwards' direction
 176    */
 177   @Test(groups = { "Functional" })
 178   public void testMatchConstructor()
 179   {
 180     SequenceI seq1 = new Sequence("", "abcdefghijklm");
 181     Match m = new SearchResults().new Match(seq1, 2, 5);
 182     assertSame(seq1, m.getSequence());
 183     assertEquals(2, m.getStart());
 184     assertEquals(5, m.getEnd());
 185
 186     // now a reverse mapping:
 187     m = new SearchResults().new Match(seq1, 5, 2);
 188     assertSame(seq1, m.getSequence());
 189     assertEquals(2, m.getStart());
 190     assertEquals(5, m.getEnd());
 191   }
 192 }