1 /* 2 * Jalview - A Sequence Alignment Editor and Viewer (2.11.1.4) 3 * Copyright (C) 2021 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) setUpJvOptionPane()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" }) testEqualRef()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" }) testUpdateFrom()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" }) testIsPrimaryCandidate()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 } 229