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(
  66             new Mapping(new MapList(new int[]
  67             { 1, 3 }, new int[] { 1, 1 }, 3, 1)));
  68     assertTrue(ref1.equalRef(ref2));
  69     assertTrue(ref2.equalRef(ref1));
  70     ref1.setMap(
  71             new Mapping(new MapList(new int[]
  72             { 1, 6 }, new int[] { 1, 2 }, 3, 1)));
  73     assertTrue(ref1.equalRef(ref2));
  74     assertTrue(ref2.equalRef(ref1));
  75   }
  76
  77   /**
  78    * Tests for the method that may update a DBRefEntry from another with a
  79    * mapping or 'real' version
  80    */
  81   @Test(groups = { "Functional" })
  82   public void testUpdateFrom()
  83   {
  84     DBRefEntry ref1 = new DBRefEntry("UNIPROT", "1", "V71633");
  85
  86     assertFalse(ref1.updateFrom(null));
  87
  88     /*
  89      * equivalent other dbref
  90      */
  91     DBRefEntry ref2 = new DBRefEntry("uniprot", "1", "v71633");
  92     assertTrue(ref1.updateFrom(ref2));
  93     assertEquals("UNIPROT", ref1.getSource()); // unchanged
  94     assertEquals("V71633", ref1.getAccessionId()); // unchanged
  95
  96     /*
  97      * ref1 has no mapping, acquires mapping from ref2
  98      */
  99     Mapping map = new Mapping(
 100             new MapList(new int[]
 101             { 1, 3 }, new int[] { 1, 1 }, 3, 1));
 102     ref2.setMap(map);
 103     assertTrue(ref1.updateFrom(ref2));
 104     assertSame(map, ref1.getMap()); // null mapping updated
 105
 106     /*
 107      * ref1 has a mapping, does not acquire mapping from ref2
 108      */
 109     ref2.setMap(new Mapping(map));
 110     assertTrue(ref1.updateFrom(ref2));
 111     assertSame(map, ref1.getMap()); // non-null mapping not updated
 112
 113     /*
 114      * ref2 has a different source, accession or version
 115      */
 116     ref2.setSource("pdb");
 117     assertFalse(ref1.updateFrom(ref2));
 118     ref2.setSource(ref1.getSource());
 119     ref2.setAccessionId("P12345");
 120     assertFalse(ref1.updateFrom(ref2));
 121     ref2.setAccessionId(ref1.getAccessionId());
 122     ref1.setVersion("2");
 123     assertFalse(ref1.updateFrom(ref2));
 124
 125     /*
 126      * a non-null version supersedes "0" or "source:0"
 127      */
 128     ref2.setVersion(null);
 129     assertFalse(ref1.updateFrom(ref2));
 130     assertEquals("2", ref1.getVersion());
 131     ref2.setVersion("3");
 132     ref1.setVersion("0");
 133     assertTrue(ref1.updateFrom(ref2));
 134     assertEquals("3", ref1.getVersion());
 135     ref1.setVersion("UNIPROT:0");
 136     assertTrue(ref1.updateFrom(ref2));
 137     assertEquals("3", ref1.getVersion());
 138
 139     /*
 140      * canonical == false superseded by canonical == true
 141      */
 142     ref1.setCanonical(false);
 143     ref2.setCanonical(true);
 144     assertTrue(ref1.updateFrom(ref2));
 145     assertTrue(ref1.isCanonical());
 146
 147     /*
 148      * canonical == true NOT superseded by canonical == false
 149      */
 150     ref1.setCanonical(true);
 151     ref2.setCanonical(false);
 152     assertFalse(ref1.updateFrom(ref2));
 153
 154     /*
 155      * version "source:n" with n>0 is not superseded
 156      */
 157     ref1.setVersion("UNIPROT:1");
 158     assertFalse(ref1.updateFrom(ref2));
 159     assertEquals("UNIPROT:1", ref1.getVersion());
 160
 161     /*
 162      * version "10" is not superseded
 163      */
 164     ref1.setVersion("10");
 165     assertFalse(ref1.updateFrom(ref2));
 166     assertEquals("10", ref1.getVersion());
 167   }
 168
 169   @Test(groups = { "Functional" })
 170   public void testIsPrimaryCandidate()
 171   {
 172     DBRefEntry dbr = new DBRefEntry(DBRefSource.UNIPROT, "", "Q12345");
 173     assertTrue(dbr.isPrimaryCandidate());
 174
 175     /*
 176      *  1:1 mapping - ok
 177      */
 178     dbr.setMap(
 179             new Mapping(null, new int[]
 180             { 1, 3 }, new int[] { 1, 3 }, 1, 1));
 181     assertTrue(dbr.isPrimaryCandidate());
 182
 183     /*
 184      *  1:1 mapping of identical split ranges - not ok
 185      */
 186     dbr.setMap(
 187             new Mapping(null, new int[]
 188             { 1, 3, 6, 9 }, new int[] { 1, 3, 6, 9 }, 1, 1));
 189     assertFalse(dbr.isPrimaryCandidate());
 190
 191     /*
 192      *  1:1 mapping of different ranges - not ok
 193      */
 194     dbr.setMap(
 195             new Mapping(null, new int[]
 196             { 1, 4 }, new int[] { 2, 5 }, 1, 1));
 197     assertFalse(dbr.isPrimaryCandidate());
 198
 199     /*
 200      *  1:1 mapping of 'isoform' ranges - not ok
 201      */
 202     dbr.setMap(
 203             new Mapping(null, new int[]
 204             { 1, 2, 6, 9 }, new int[] { 1, 3, 7, 9 }, 1, 1));
 205     assertFalse(dbr.isPrimaryCandidate());
 206     dbr.setMap(null);
 207     assertTrue(dbr.isPrimaryCandidate());
 208
 209     /*
 210      * Version string is prefixed with another dbref source string (fail)
 211      */
 212     dbr.setVersion(DBRefSource.EMBL + ":0");
 213     assertFalse(dbr.isPrimaryCandidate());
 214
 215     /*
 216      * Version string is alphanumeric
 217      */
 218     dbr.setVersion("0.1.b");
 219     assertTrue(dbr.isPrimaryCandidate());
 220
 221     /*
 222      * null version string can't be primary ref
 223      */
 224     dbr.setVersion(null);
 225     assertFalse(dbr.isPrimaryCandidate());
 226     dbr.setVersion("");
 227     assertTrue(dbr.isPrimaryCandidate());
 228
 229     /*
 230      *  1:1 mapping and sequenceRef (fail)
 231      */
 232     dbr.setMap(
 233             new Mapping(new Sequence("foo", "ASDF"), new int[]
 234             { 1, 3 }, new int[] { 1, 3 }, 1, 1));
 235     assertFalse(dbr.isPrimaryCandidate());
 236
 237     /*
 238      * 1:3 mapping (fail)
 239      */
 240     dbr.setMap(
 241             new Mapping(null, new int[]
 242             { 1, 3 }, new int[] { 1, 3 }, 1, 3));
 243     assertFalse(dbr.isPrimaryCandidate());
 244
 245     /*
 246      * 2:2 mapping with shift (expected fail, but maybe use case for a pass)
 247      */
 248     dbr.setMap(
 249             new Mapping(null, new int[]
 250             { 1, 4 }, new int[] { 1, 4 }, 2, 2));
 251     assertFalse(dbr.isPrimaryCandidate());
 252   }
 253 }