test/jalview/datamodel/DBRefEntryTest.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.gui.JvOptionPane;
  29 import jalview.util.MapList;
  30
  31 import org.testng.annotations.BeforeClass;
  32 import org.testng.annotations.Test;
  33
  34 public class DBRefEntryTest
  35 {
  36
  37   @BeforeClass(alwaysRun = true)
  38   public void setUpJvOptionPane()
  39   {
  40     JvOptionPane.setInteractiveMode(false);
  41     JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
  42   }
  43
  44   /**
  45    * Tests for the method that compares equality of reference (but not mapping)
  46    */
  47   @Test(groups = { "Functional" })
  48   public void testEqualRef()
  49   {
  50     DBRefEntry ref1 = new DBRefEntry("UNIPROT", "1", "V71633");
  51     assertTrue(ref1.equalRef(ref1));
  52     assertFalse(ref1.equalRef(null));
  53
  54     // comparison is not case sensitive
  55     DBRefEntry ref2 = new DBRefEntry("uniprot", "1", "v71633");
  56     assertTrue(ref1.equalRef(ref2));
  57     assertTrue(ref2.equalRef(ref1));
  58
  59     // source, version and accessionid must match
  60     assertFalse(ref1.equalRef(new DBRefEntry("UNIPRO", "1", "V71633")));
  61     assertFalse(ref1.equalRef(new DBRefEntry("UNIPROT", "2", "V71633")));
  62     assertFalse(ref1.equalRef(new DBRefEntry("UNIPROT", "1", "V71632")));
  63
  64     // presence of or differences in mappings are ignored
  65     ref1.setMap(new Mapping(new MapList(new int[] { 1, 3 }, new int[] { 1,
  66         1 }, 3, 1)));
  67     assertTrue(ref1.equalRef(ref2));
  68     assertTrue(ref2.equalRef(ref1));
  69     ref1.setMap(new Mapping(new MapList(new int[] { 1, 6 }, new int[] { 1,
  70         2 }, 3, 1)));
  71     assertTrue(ref1.equalRef(ref2));
  72     assertTrue(ref2.equalRef(ref1));
  73   }
  74
  75   /**
  76    * Tests for the method that may update a DBRefEntry from another with a
  77    * mapping or 'real' version
  78    */
  79   @Test(groups = { "Functional" })
  80   public void testUpdateFrom()
  81   {
  82     DBRefEntry ref1 = new DBRefEntry("UNIPROT", "1", "V71633");
  83
  84     assertFalse(ref1.updateFrom(null));
  85
  86     /*
  87      * equivalent other dbref
  88      */
  89     DBRefEntry ref2 = new DBRefEntry("uniprot", "1", "v71633");
  90     assertTrue(ref1.updateFrom(ref2));
  91     assertEquals("UNIPROT", ref1.getSource()); // unchanged
  92     assertEquals("V71633", ref1.getAccessionId()); // unchanged
  93
  94     /*
  95      * ref1 has no mapping, acquires mapping from ref2
  96      */
  97     Mapping map = new Mapping(new MapList(new int[] { 1, 3 }, new int[] {
  98         1, 1 }, 3, 1));
  99     ref2.setMap(map);
 100     assertTrue(ref1.updateFrom(ref2));
 101     assertSame(map, ref1.getMap()); // null mapping updated
 102
 103     /*
 104      * ref1 has a mapping, does not acquire mapping from ref2
 105      */
 106     ref2.setMap(new Mapping(map));
 107     assertTrue(ref1.updateFrom(ref2));
 108     assertSame(map, ref1.getMap()); // non-null mapping not updated
 109
 110     /*
 111      * ref2 has a different source, accession or version
 112      */
 113     ref2.setSource("pdb");
 114     assertFalse(ref1.updateFrom(ref2));
 115     ref2.setSource(ref1.getSource());
 116     ref2.setAccessionId("P12345");
 117     assertFalse(ref1.updateFrom(ref2));
 118     ref2.setAccessionId(ref1.getAccessionId());
 119     ref1.setVersion("2");
 120     assertFalse(ref1.updateFrom(ref2));
 121
 122     /*
 123      * a non-null version supersedes "0" or "source:0"
 124      */
 125     ref2.setVersion(null);
 126     assertFalse(ref1.updateFrom(ref2));
 127     assertEquals("2", ref1.getVersion());
 128     ref2.setVersion("3");
 129     ref1.setVersion("0");
 130     assertTrue(ref1.updateFrom(ref2));
 131     assertEquals("3", ref1.getVersion());
 132     ref1.setVersion("UNIPROT:0");
 133     assertTrue(ref1.updateFrom(ref2));
 134     assertEquals("3", ref1.getVersion());
 135
 136     /*
 137      * canonical == false superseded by canonical == true
 138      */
 139     ref1.setCanonical(false);
 140     ref2.setCanonical(true);
 141     assertTrue(ref1.updateFrom(ref2));
 142     assertTrue(ref1.isCanonical());
 143
 144     /*
 145      * canonical == true NOT superseded by canonical == false
 146      */
 147     ref1.setCanonical(true);
 148     ref2.setCanonical(false);
 149     assertFalse(ref1.updateFrom(ref2));
 150
 151     /*
 152      * version "source:n" with n>0 is not superseded
 153      */
 154     ref1.setVersion("UNIPROT:1");
 155     assertFalse(ref1.updateFrom(ref2));
 156     assertEquals("UNIPROT:1", ref1.getVersion());
 157
 158     /*
 159      * version "10" is not superseded
 160      */
 161     ref1.setVersion("10");
 162     assertFalse(ref1.updateFrom(ref2));
 163     assertEquals("10", ref1.getVersion());
 164   }
 165
 166   @Test(groups = { "Functional" })
 167   public void testIsPrimaryCandidate()
 168   {
 169     DBRefEntry dbr = new DBRefEntry(DBRefSource.UNIPROT, "", "Q12345");
 170     assertTrue(dbr.isPrimaryCandidate());
 171
 172     /*
 173      *  1:1 mapping - ok
 174      */
 175     dbr.setMap(new Mapping(null, new int[] { 1, 3 }, new int[] { 1, 3 }, 1,
 176             1));
 177     assertTrue(dbr.isPrimaryCandidate());
 178
 179     /*
 180      *  1:1 mapping of identical split ranges - not ok
 181      */
 182     dbr.setMap(new Mapping(null, new int[] { 1, 3, 6, 9 }, new int[] { 1,
 183         3, 6, 9 }, 1, 1));
 184     assertFalse(dbr.isPrimaryCandidate());
 185
 186     /*
 187      *  1:1 mapping of different ranges - not ok
 188      */
 189     dbr.setMap(new Mapping(null, new int[] { 1, 4 }, new int[] { 2, 5 }, 1,
 190             1));
 191     assertFalse(dbr.isPrimaryCandidate());
 192
 193     /*
 194      *  1:1 mapping of 'isoform' ranges - not ok
 195      */
 196     dbr.setMap(new Mapping(null, new int[] { 1, 2, 6, 9 }, new int[] { 1,
 197         3, 7, 9 }, 1, 1));
 198     assertFalse(dbr.isPrimaryCandidate());
 199     dbr.setMap(null);
 200     assertTrue(dbr.isPrimaryCandidate());
 201
 202     /*
 203      * Version string is prefixed with another dbref source string (fail)
 204      */
 205     dbr.setVersion(DBRefSource.EMBL + ":0");
 206     assertFalse(dbr.isPrimaryCandidate());
 207
 208     /*
 209      * Version string is alphanumeric
 210      */
 211     dbr.setVersion("0.1.b");
 212     assertTrue(dbr.isPrimaryCandidate());
 213
 214     /*
 215      * null version string can't be primary ref
 216      */
 217     dbr.setVersion(null);
 218     assertFalse(dbr.isPrimaryCandidate());
 219     dbr.setVersion("");
 220     assertTrue(dbr.isPrimaryCandidate());
 221
 222     /*
 223      *  1:1 mapping and sequenceRef (fail)
 224      */
 225     dbr.setMap(new Mapping(new Sequence("foo", "ASDF"), new int[] { 1, 3 },
 226             new int[] { 1, 3 }, 1, 1));
 227     assertFalse(dbr.isPrimaryCandidate());
 228
 229     /*
 230      * 1:3 mapping (fail)
 231      */
 232     dbr.setMap(new Mapping(null, new int[] { 1, 3 }, new int[] { 1, 3 }, 1,
 233             3));
 234     assertFalse(dbr.isPrimaryCandidate());
 235
 236     /*
 237      * 2:2 mapping with shift (expected fail, but maybe use case for a pass)
 238      */
 239     dbr.setMap(new Mapping(null, new int[] { 1, 4 }, new int[] { 1, 4 }, 2,
 240             2));
 241     assertFalse(dbr.isPrimaryCandidate());
 242   }
 243 }