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.assertTrue;
  26
  27 import org.testng.annotations.Test;
  28
  29 public class SearchResultsTest
  30 {
  31
  32   @Test(groups = { "Functional" })
  33   public void testToString()
  34   {
  35     SequenceI seq = new Sequence("", "abcdefghijklm");
  36     SearchResults sr = new SearchResults();
  37     sr.addResult(seq, 1, 1);
  38     assertEquals("0a", sr.toString());
  39     sr.addResult(seq, 3, 5);
  40     assertEquals("0a2cde", sr.toString());
  41
  42     seq = new Sequence("", "pqrstuvwxy");
  43     sr.addResult(seq, 6, 7);
  44     assertEquals("0a2cde5uv", sr.toString());
  45   }
  46
  47   @Test(groups = { "Functional" })
  48   public void testGetCharacters()
  49   {
  50     SequenceI seq = new Sequence("", "abcdefghijklm");
  51     SearchResults sr = new SearchResults();
  52     sr.addResult(seq, 1, 1);
  53     assertEquals("a", sr.getCharacters());
  54     sr.addResult(seq, 3, 5);
  55     assertEquals("acde", sr.getCharacters());
  56
  57     seq = new Sequence("", "pqrstuvwxy");
  58     sr.addResult(seq, 6, 7);
  59     assertEquals("acdeuv", sr.getCharacters());
  60   }
  61
  62   @Test(groups = { "Functional" })
  63   public void testEquals()
  64   {
  65     SequenceI seq1 = new Sequence("", "abcdefghijklm");
  66     SearchResults sr1 = new SearchResults();
  67     SearchResults 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      * 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     SearchResults sr1 = new SearchResults();
 112     SearchResults 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     SearchResults sr1 = new SearchResults();
 128     SearchResults 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     SearchResults sr1 = new SearchResults();
 146     SearchResults 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 }