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      * version "source:n" with n>0 is not superseded
 138      */
 139     ref1.setVersion("UNIPROT:1");
 140     assertFalse(ref1.updateFrom(ref2));
 141     assertEquals("UNIPROT:1", ref1.getVersion());
 142
 143     /*
 144      * version "10" is not superseded
 145      */
 146     ref1.setVersion("10");
 147     assertFalse(ref1.updateFrom(ref2));
 148     assertEquals("10", ref1.getVersion());
 149   }
 150
 151   @Test(groups = { "Functional" })
 152   public void testIsPrimaryCandidate()
 153   {
 154     DBRefEntry dbr = new DBRefEntry(DBRefSource.UNIPROT, "", "Q12345");
 155     assertTrue(dbr.isPrimaryCandidate());
 156
 157     /*
 158      *  1:1 mapping - ok
 159      */
 160     dbr.setMap(new Mapping(null, new int[] { 1, 3 }, new int[] { 1, 3 }, 1,
 161             1));
 162     assertTrue(dbr.isPrimaryCandidate());
 163
 164     /*
 165      *  1:1 mapping of identical split ranges - not ok
 166      */
 167     dbr.setMap(new Mapping(null, new int[] { 1, 3, 6, 9 }, new int[] { 1,
 168         3, 6, 9 }, 1, 1));
 169     assertFalse(dbr.isPrimaryCandidate());
 170
 171     /*
 172      *  1:1 mapping of different ranges - not ok
 173      */
 174     dbr.setMap(new Mapping(null, new int[] { 1, 4 }, new int[] { 2, 5 }, 1,
 175             1));
 176     assertFalse(dbr.isPrimaryCandidate());
 177
 178     /*
 179      *  1:1 mapping of 'isoform' ranges - not ok
 180      */
 181     dbr.setMap(new Mapping(null, new int[] { 1, 2, 6, 9 }, new int[] { 1,
 182         3, 7, 9 }, 1, 1));
 183     assertFalse(dbr.isPrimaryCandidate());
 184     dbr.setMap(null);
 185     assertTrue(dbr.isPrimaryCandidate());
 186
 187     /*
 188      * Version string is prefixed with another dbref source string (fail)
 189      */
 190     dbr.setVersion(DBRefSource.EMBL + ":0");
 191     assertFalse(dbr.isPrimaryCandidate());
 192
 193     /*
 194      * Version string is alphanumeric
 195      */
 196     dbr.setVersion("0.1.b");
 197     assertTrue(dbr.isPrimaryCandidate());
 198
 199     /*
 200      * null version string can't be primary ref
 201      */
 202     dbr.setVersion(null);
 203     assertFalse(dbr.isPrimaryCandidate());
 204     dbr.setVersion("");
 205     assertTrue(dbr.isPrimaryCandidate());
 206
 207     /*
 208      *  1:1 mapping and sequenceRef (fail)
 209      */
 210     dbr.setMap(new Mapping(new Sequence("foo", "ASDF"), new int[] { 1, 3 },
 211             new int[] { 1, 3 }, 1, 1));
 212     assertFalse(dbr.isPrimaryCandidate());
 213
 214     /*
 215      * 1:3 mapping (fail)
 216      */
 217     dbr.setMap(new Mapping(null, new int[] { 1, 3 }, new int[] { 1, 3 }, 1,
 218             3));
 219     assertFalse(dbr.isPrimaryCandidate());
 220
 221     /*
 222      * 2:2 mapping with shift (expected fail, but maybe use case for a pass)
 223      */
 224     dbr.setMap(new Mapping(null, new int[] { 1, 4 }, new int[] { 1, 4 }, 2,
 225             2));
 226     assertFalse(dbr.isPrimaryCandidate());
 227   }
 228 }