Clover icon

Coverage Report

  1. Project Clover database Wed Nov 6 2024 14:47:21 GMT
  2. Package jalview.ws.sifts

File SiftsClientTest.java

 

Code metrics

4
240
27
1
534
438
31
0.13
8.89
27
1.15

Classes

Class Line # Actions
SiftsClientTest 54 240 31
0.428044342.8%
 

Contributing tests

This file is covered by 1 test. .

Source view

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.ws.sifts;
22   
23    import static org.testng.Assert.assertEquals;
24    import static org.testng.Assert.assertTrue;
25   
26    import jalview.api.DBRefEntryI;
27    import jalview.bin.Cache;
28    import jalview.datamodel.DBRefEntry;
29    import jalview.datamodel.DBRefSource;
30    import jalview.datamodel.Sequence;
31    import jalview.datamodel.SequenceI;
32    import jalview.gui.JvOptionPane;
33    import jalview.io.DataSourceType;
34    import jalview.structure.StructureMapping;
35    import jalview.xml.binding.sifts.Entry.Entity;
36   
37    import java.io.File;
38    import java.io.IOException;
39    import java.util.ArrayList;
40    import java.util.HashMap;
41    import java.util.Iterator;
42    import java.util.Map;
43   
44    import org.testng.Assert;
45    import org.testng.FileAssert;
46    import org.testng.annotations.AfterTest;
47    import org.testng.annotations.BeforeClass;
48    import org.testng.annotations.BeforeTest;
49    import org.testng.annotations.Test;
50   
51    import mc_view.Atom;
52    import mc_view.PDBfile;
53   
 
54    public class SiftsClientTest
55    {
56   
 
57  1 toggle @BeforeClass(alwaysRun = true)
58    public void setUpJvOptionPane()
59    {
60  1 JvOptionPane.setInteractiveMode(false);
61  1 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
62    }
63   
64    public static final String DEFAULT_SIFTS_DOWNLOAD_DIR = System
65    .getProperty("user.home") + File.separatorChar
66    + ".sifts_downloads" + File.separatorChar;
67   
68    private String testPDBId = "1a70";
69   
70    private SiftsClient siftsClient = null;
71   
72    SequenceI testSeq = new Sequence("P00221",
73    "MAAT..TTTMMG..MATTFVPKPQAPPMMAALPSNTGR..SLFGLKT.GSR..GGRMTMA"
74    + "AYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDD"
75    + "QSFLDDDQIDEGWVLTCAAYPVSDVTIETHKEEELTA.",
76    1, 147);
77   
78    int u = SiftsClient.UNASSIGNED;
79   
80    HashMap<Integer, int[]> expectedMapping = new HashMap<Integer, int[]>();
81   
 
82  4 toggle @BeforeTest(alwaysRun = true)
83    public void populateExpectedMapping() throws SiftsException
84    {
85  4 expectedMapping.put(51, new int[] { 1, 2, 1 });
86  4 expectedMapping.put(52, new int[] { 2, 7, 2 });
87  4 expectedMapping.put(53, new int[] { 3, 12, 3 });
88  4 expectedMapping.put(54, new int[] { 4, 24, 4 });
89  4 expectedMapping.put(55, new int[] { 5, 33, 5 });
90  4 expectedMapping.put(56, new int[] { 6, 40, 6 });
91  4 expectedMapping.put(57, new int[] { 7, 47, 7 });
92  4 expectedMapping.put(58, new int[] { 8, 55, 8 });
93  4 expectedMapping.put(59, new int[] { 9, 62, 9 });
94  4 expectedMapping.put(60, new int[] { 10, 69, 10 });
95  4 expectedMapping.put(61, new int[] { 11, 76, 11 });
96  4 expectedMapping.put(62, new int[] { 12, 83, 12 });
97  4 expectedMapping.put(63, new int[] { 13, 87, 13 });
98  4 expectedMapping.put(64, new int[] { 14, 95, 14 });
99  4 expectedMapping.put(65, new int[] { 15, 102, 15 });
100  4 expectedMapping.put(66, new int[] { 16, 111, 16 });
101  4 expectedMapping.put(67, new int[] { 17, 122, 17 });
102  4 expectedMapping.put(68, new int[] { 18, 131, 18 });
103  4 expectedMapping.put(69, new int[] { 19, 137, 19 });
104  4 expectedMapping.put(70, new int[] { 20, 144, 20 });
105  4 expectedMapping.put(71, new int[] { 21, 152, 21 });
106  4 expectedMapping.put(72, new int[] { 22, 160, 22 });
107  4 expectedMapping.put(73, new int[] { 23, 167, 23 });
108  4 expectedMapping.put(74, new int[] { 24, 179, 24 });
109  4 expectedMapping.put(75, new int[] { 25, 187, 25 });
110  4 expectedMapping.put(76, new int[] { 26, 195, 26 });
111  4 expectedMapping.put(77, new int[] { 27, 203, 27 });
112  4 expectedMapping.put(78, new int[] { 28, 208, 28 });
113  4 expectedMapping.put(79, new int[] { 29, 213, 29 });
114  4 expectedMapping.put(80, new int[] { 30, 222, 30 });
115  4 expectedMapping.put(81, new int[] { 31, 231, 31 });
116  4 expectedMapping.put(82, new int[] { 32, 240, 32 });
117  4 expectedMapping.put(83, new int[] { 33, 244, 33 });
118  4 expectedMapping.put(84, new int[] { 34, 252, 34 });
119  4 expectedMapping.put(85, new int[] { 35, 260, 35 });
120  4 expectedMapping.put(86, new int[] { 36, 268, 36 });
121  4 expectedMapping.put(87, new int[] { 37, 275, 37 });
122  4 expectedMapping.put(88, new int[] { 38, 287, 38 });
123  4 expectedMapping.put(89, new int[] { 39, 293, 39 });
124  4 expectedMapping.put(90, new int[] { 40, 299, 40 });
125  4 expectedMapping.put(91, new int[] { 41, 310, 41 });
126  4 expectedMapping.put(92, new int[] { 42, 315, 42 });
127  4 expectedMapping.put(93, new int[] { 43, 319, 43 });
128  4 expectedMapping.put(94, new int[] { 44, 325, 44 });
129  4 expectedMapping.put(95, new int[] { 45, 331, 45 });
130  4 expectedMapping.put(96, new int[] { 46, 337, 46 });
131  4 expectedMapping.put(97, new int[] { 47, 343, 47 });
132  4 expectedMapping.put(98, new int[] { 48, 349, 48 });
133  4 expectedMapping.put(99, new int[] { 49, 354, 49 });
134  4 expectedMapping.put(100, new int[] { 50, 358, 50 });
135  4 expectedMapping.put(101, new int[] { 51, 367, 51 });
136  4 expectedMapping.put(102, new int[] { 52, 375, 52 });
137  4 expectedMapping.put(103, new int[] { 53, 384, 53 });
138  4 expectedMapping.put(104, new int[] { 54, 391, 54 });
139  4 expectedMapping.put(105, new int[] { 55, 395, 55 });
140  4 expectedMapping.put(106, new int[] { 56, 401, 56 });
141  4 expectedMapping.put(107, new int[] { 57, 409, 57 });
142  4 expectedMapping.put(108, new int[] { 58, 417, 58 });
143  4 expectedMapping.put(109, new int[] { 59, 426, 59 });
144  4 expectedMapping.put(110, new int[] { 60, 434, 60 });
145  4 expectedMapping.put(111, new int[] { 61, 442, 61 });
146  4 expectedMapping.put(112, new int[] { 62, 451, 62 });
147  4 expectedMapping.put(113, new int[] { 63, 457, 63 });
148  4 expectedMapping.put(114, new int[] { 64, 468, 64 });
149  4 expectedMapping.put(115, new int[] { 65, 476, 65 });
150  4 expectedMapping.put(116, new int[] { 66, 484, 66 });
151  4 expectedMapping.put(117, new int[] { 67, 492, 67 });
152  4 expectedMapping.put(118, new int[] { 68, 500, 68 });
153  4 expectedMapping.put(119, new int[] { 69, 509, 69 });
154  4 expectedMapping.put(120, new int[] { 70, 517, 70 });
155  4 expectedMapping.put(121, new int[] { 71, 525, 71 });
156  4 expectedMapping.put(122, new int[] { 72, 534, 72 });
157  4 expectedMapping.put(123, new int[] { 73, 538, 73 });
158  4 expectedMapping.put(124, new int[] { 74, 552, 74 });
159  4 expectedMapping.put(125, new int[] { 75, 559, 75 });
160  4 expectedMapping.put(126, new int[] { 76, 567, 76 });
161  4 expectedMapping.put(127, new int[] { 77, 574, 77 });
162  4 expectedMapping.put(128, new int[] { 78, 580, 78 });
163  4 expectedMapping.put(129, new int[] { 79, 585, 79 });
164  4 expectedMapping.put(130, new int[] { 80, 590, 80 });
165  4 expectedMapping.put(131, new int[] { 81, 602, 81 });
166  4 expectedMapping.put(132, new int[] { 82, 609, 82 });
167  4 expectedMapping.put(133, new int[] { 83, 616, 83 });
168  4 expectedMapping.put(134, new int[] { 84, 622, 84 });
169  4 expectedMapping.put(135, new int[] { 85, 630, 85 });
170  4 expectedMapping.put(136, new int[] { 86, 637, 86 });
171  4 expectedMapping.put(137, new int[] { 87, 644, 87 });
172  4 expectedMapping.put(138, new int[] { 88, 652, 88 });
173  4 expectedMapping.put(139, new int[] { 89, 661, 89 });
174  4 expectedMapping.put(140, new int[] { 90, 668, 90 });
175  4 expectedMapping.put(141, new int[] { 91, 678, 91 });
176  4 expectedMapping.put(142, new int[] { 92, 687, 92 });
177  4 expectedMapping.put(143, new int[] { 93, 696, 93 });
178  4 expectedMapping.put(144, new int[] { 94, 705, 94 });
179  4 expectedMapping.put(145, new int[] { 95, 714, 95 });
180  4 expectedMapping.put(146, new int[] { 96, 722, 96 });
181  4 expectedMapping.put(147, new int[] { 97, 729, 97 });
182    }
183   
 
184  4 toggle @BeforeTest(alwaysRun = true)
185    public void setUpSiftsClient() throws SiftsException, IOException
186    {
187    // read test props before manipulating config
188  4 Cache.loadProperties("test/jalview/io/testProps.jvprops");
189    // SIFTs entries are updated weekly - so use saved SIFTs file to enforce
190    // test reproducibility
191  4 new SiftsSettings();
192  4 SiftsSettings.setSiftDownloadDirectory(jalview.bin.Cache
193    .getDefault("sifts_download_dir", DEFAULT_SIFTS_DOWNLOAD_DIR));
194  4 SiftsSettings.setMapWithSifts(true);
195  4 SiftsSettings.setCacheThresholdInDays("2");
196  4 SiftsSettings.setFailSafePIDThreshold("70");
197  4 PDBfile pdbFile;
198   
199  4 pdbFile = new PDBfile(false, false, false,
200    "test/jalview/io/" + testPDBId + ".pdb", DataSourceType.FILE);
201    // TODO: this uses a network connection - we should mock the sifts
202    // testPDBId.xml.gz
203  4 siftsClient = new SiftsClient(pdbFile);
204    }
205   
 
206  4 toggle @AfterTest(alwaysRun = true)
207    public void cleanUpSiftsClient()
208    {
209  4 siftsClient = null;
210    }
211   
 
212  1 toggle @Test(groups = { "Functional" })
213    public void testSIFTsDownloadURL()
214    {
215  1 String expectedUrl = "https://ftp.ebi.ac.uk/pub/databases/msd/sifts/split_xml/xy/1xyz.sifts.xml.gz";
216  1 Assert.assertEquals(SiftsClient.getDownloadUrlFor("1xyz.sifts.xml.gz"),
217    expectedUrl);
218    }
219   
 
220  0 toggle @Test(groups = { "Network" })
221    public void getSIFTsFileTest() throws SiftsException, IOException
222    {
223  0 File siftsFile;
224  0 siftsFile = SiftsClient.downloadSiftsFile(testPDBId);
225  0 FileAssert.assertFile(siftsFile);
226  0 long t1 = siftsFile.lastModified();
227   
228    // re-read file should be returned from cache
229  0 siftsFile = SiftsClient.getSiftsFile(testPDBId);
230  0 FileAssert.assertFile(siftsFile);
231  0 long t2 = siftsFile.lastModified();
232  0 assertEquals(t1, t2);
233   
234    /*
235    * force fetch by having 0 expiry of cache
236    * also wait one second, because file timestamp does not
237    * give millisecond resolution :-(
238    */
239  0 synchronized (this)
240    {
241  0 try
242    {
243  0 wait(1000);
244    } catch (InterruptedException e)
245    {
246    }
247    }
248  0 SiftsSettings.setCacheThresholdInDays("0");
249  0 siftsFile = SiftsClient.getSiftsFile(testPDBId);
250  0 FileAssert.assertFile(siftsFile);
251  0 long t3 = siftsFile.lastModified();
252  0 assertTrue(t3 > t2, "file timestamp unchanged at " + t3);
253   
254  0 SiftsSettings.setCacheThresholdInDays("2");
255    }
256   
 
257  0 toggle @Test(groups = { "Network" })
258    public void downloadSiftsFileTest() throws SiftsException, IOException
259    {
260    // Assert that file isn't yet downloaded - if already downloaded, assert it
261    // is deleted
262  0 Assert.assertTrue(SiftsClient.deleteSiftsFileByPDBId(testPDBId));
263  0 File siftsFile;
264  0 siftsFile = SiftsClient.downloadSiftsFile(testPDBId);
265  0 FileAssert.assertFile(siftsFile);
266  0 SiftsClient.downloadSiftsFile(testPDBId);
267    }
268   
 
269  0 toggle @Test(groups = { "Network" })
270    public void getAllMappingAccessionTest()
271    {
272  0 Assert.assertNotNull(siftsClient);
273  0 Assert.assertNotNull(siftsClient.getAllMappingAccession());
274  0 Assert.assertTrue(siftsClient.getAllMappingAccession().size() > 1);
275    }
276   
 
277  0 toggle @Test(groups = { "Network" })
278    public void getGreedyMappingTest()
279    {
280  0 Assert.assertNotNull(siftsClient);
281  0 Assert.assertNotNull(testSeq);
282  0 Assert.assertNotNull(expectedMapping);
283   
284    // TODO delete when auto-fetching of DBRefEntry is implemented
285  0 DBRefEntry dbRef = new DBRefEntry("uniprot", "", "P00221");
286  0 testSeq.addDBRef(dbRef);
287    // testSeq.setSourceDBRef(dbRef);
288   
289  0 try
290    {
291  0 HashMap<Integer, int[]> actualMapping = siftsClient
292    .getGreedyMapping("A", testSeq, null);
293  0 Assert.assertEquals(testSeq.getStart(), 1);
294  0 Assert.assertEquals(testSeq.getEnd(), 147);
295    // Can't do Assert.assertEquals(actualMapping, expectedMapping);
296    // because this fails in our version of TestNG
297  0 Assert.assertEquals(actualMapping.size(), expectedMapping.size());
298  0 Iterator<Map.Entry<Integer, int[]>> it = expectedMapping.entrySet()
299    .iterator();
300  0 while (it.hasNext())
301    {
302  0 Map.Entry<Integer, int[]> pair = it.next();
303  0 Assert.assertTrue(actualMapping.containsKey(pair.getKey()));
304  0 Assert.assertEquals(actualMapping.get(pair.getKey()),
305    pair.getValue());
306    }
307   
308    } catch (Exception e)
309    {
310  0 e.printStackTrace();
311  0 Assert.fail("Exception thrown while generating mapping...");
312    }
313    }
314   
 
315  0 toggle @Test(groups = { "Network" })
316    private void getAtomIndexTest()
317    {
318  0 ArrayList<Atom> atoms = new ArrayList<Atom>();
319  0 Atom atom = new Atom(u, u, u);
320  0 atom.resNumber = 43;
321  0 atom.atomIndex = 7;
322  0 atoms.add(atom);
323  0 int actualAtomIndex = siftsClient.getAtomIndex(1, atoms);
324  0 Assert.assertEquals(actualAtomIndex, siftsClient.UNASSIGNED);
325  0 actualAtomIndex = siftsClient.getAtomIndex(43, atoms);
326  0 Assert.assertEquals(actualAtomIndex, 7);
327    }
328   
 
329  0 toggle @Test(
330    groups =
331    { "Network" },
332    expectedExceptions = IllegalArgumentException.class)
333    private void getAtomIndexNullTest()
334    {
335  0 siftsClient.getAtomIndex(1, null);
336    }
337   
 
338  0 toggle @Test(groups = { "Network" })
339    private void padWithGapsTest()
340    {
341   
342    }
343   
 
344  0 toggle @Test(groups = { "Network" }, expectedExceptions = SiftsException.class)
345    private void populateAtomPositionsNullTest1()
346    throws IllegalArgumentException, SiftsException
347    {
348  0 siftsClient.populateAtomPositions(null, null);
349    }
350   
 
351  0 toggle @Test(groups = { "Network" }, expectedExceptions = SiftsException.class)
352    private void populateAtomPositionsNullTest2()
353    throws IllegalArgumentException, SiftsException
354    {
355  0 siftsClient.populateAtomPositions("A", null);
356    }
357   
 
358  0 toggle @Test(groups = { "Network" })
359    public void getValidSourceDBRefTest() throws SiftsException
360    {
361  0 DBRefEntryI actualValidSrcDBRef = siftsClient
362    .getValidSourceDBRef(testSeq);
363  0 DBRefEntryI expectedDBRef = new DBRefEntry();
364  0 expectedDBRef.setSource(DBRefSource.UNIPROT);
365  0 expectedDBRef.setAccessionId("P00221");
366  0 expectedDBRef.setVersion("");
367  0 Assert.assertEquals(actualValidSrcDBRef, expectedDBRef);
368    }
369   
 
370  0 toggle @Test(groups = { "Network" }, expectedExceptions = SiftsException.class)
371    public void getValidSourceDBRefExceptionTest() throws SiftsException
372    {
373  0 SequenceI invalidTestSeq = new Sequence("testSeq", "ABCDEFGH");
374  0 siftsClient.getValidSourceDBRef(invalidTestSeq);
375    }
376   
 
377  0 toggle @Test(groups = { "Network" }, expectedExceptions = SiftsException.class)
378    public void getValidSourceDBRefExceptionXTest() throws SiftsException
379    {
380  0 SequenceI invalidTestSeq = new Sequence("testSeq", "ABCDEFGH");
381  0 DBRefEntry invalidDBRef = new DBRefEntry();
382  0 invalidDBRef.setAccessionId("BLAR"); // note no version is set, so also
383    // invalid
384  0 invalidTestSeq.addDBRef(invalidDBRef);
385  0 siftsClient.getValidSourceDBRef(invalidTestSeq);
386    }
387   
 
388  0 toggle @Test(groups = { "Network" })
389    public void isValidDBRefEntryTest()
390    {
391  0 DBRefEntryI validDBRef = new DBRefEntry();
392  0 validDBRef.setSource(DBRefSource.UNIPROT);
393  0 validDBRef.setAccessionId("P00221");
394  0 validDBRef.setVersion("");
395  0 Assert.assertTrue(siftsClient.isValidDBRefEntry(validDBRef));
396    }
397   
 
398  0 toggle @Test(groups = { "Network" })
399    public void getSiftsStructureMappingTest() throws SiftsException
400    {
401  0 Assert.assertTrue(SiftsSettings.isMapWithSifts());
402  0 StructureMapping strucMapping = siftsClient
403    .getSiftsStructureMapping(testSeq, testPDBId, "A");
404  0 String expectedMappingOutput = "\nSequence ⟷ Structure mapping details\n"
405    + "Method: SIFTS\n\n" + "P00221 : 51 - 147 Maps to \n"
406    + "1A70|A : 1 - 97\n\n"
407    + "P00221 AAYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDDQSFLD\n"
408    + " |||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||\n"
409    + "1A70|A AAYKVTLVTPTGNVEFQCPDDVYILDAAEEEGIDLPYSCRAGSCSSCAGKLKTGSLNQDDQSFLD\n\n"
410   
411    + "P00221 DDQIDEGWVLTCAAYPVSDVTIETHKEEELTA\n"
412    + " |||||||||||||||||||||||||| |||||\n"
413    + "1A70|A DDQIDEGWVLTCAAYPVSDVTIETHKKEELTA\n\n" +
414   
415    "Length of alignment = 97\n" + "Percentage ID = 98.97\n";
416   
417  0 Assert.assertEquals(strucMapping.getMappingDetailsOutput(),
418    expectedMappingOutput);
419   
420    // Can't do Assert.assertEquals(strucMapping.getMapping(), expectedMapping);
421    // because this fails in our version of TestNG
422  0 Assert.assertEquals(strucMapping.getMapping().size(),
423    expectedMapping.size());
424  0 Iterator<Map.Entry<Integer, int[]>> it = expectedMapping.entrySet()
425    .iterator();
426  0 while (it.hasNext())
427    {
428  0 Map.Entry<Integer, int[]> pair = it.next();
429  0 Assert.assertTrue(
430    strucMapping.getMapping().containsKey(pair.getKey()));
431  0 Assert.assertEquals(strucMapping.getMapping().get(pair.getKey()),
432    pair.getValue());
433    }
434    }
435   
 
436  0 toggle @Test(groups = { "Network" })
437    public void getEntityCountTest()
438    {
439  0 int actualEntityCount = siftsClient.getEntityCount();
440  0 System.out.println("actual entity count : " + actualEntityCount);
441  0 Assert.assertEquals(actualEntityCount, 1);
442    }
443   
 
444  0 toggle @Test(groups = { "Network" })
445    public void getDbAccessionIdTest()
446    {
447  0 String actualDbAccId = siftsClient.getDbAccessionId();
448  0 System.out.println("Actual Db Accession Id: " + actualDbAccId);
449  0 Assert.assertEquals(actualDbAccId, "1a70");
450    }
451   
 
452  0 toggle @Test(groups = { "Network" })
453    public void getDbCoordSysTest()
454    {
455  0 String actualDbCoordSys = siftsClient.getDbCoordSys();
456  0 System.out.println("Actual DbCoordSys: " + actualDbCoordSys);
457  0 Assert.assertEquals(actualDbCoordSys, "PDBe");
458    }
459   
 
460  0 toggle @Test(groups = { "Network" })
461    public void getDbSourceTest()
462    {
463  0 String actualDbSource = siftsClient.getDbSource();
464  0 System.out.println("Actual DbSource: " + actualDbSource);
465  0 Assert.assertEquals(actualDbSource, "PDBe");
466    }
467   
 
468  0 toggle @Test(groups = { "Network" })
469    public void getDbVersionTest()
470    {
471  0 String actualDbVersion = siftsClient.getDbVersion();
472  0 System.out.println("Actual DbVersion: " + actualDbVersion);
473  0 Assert.assertEquals(actualDbVersion, "2.0");
474    }
475   
 
476  0 toggle @Test(groups = { "Network" })
477    public void getEntityByMostOptimalMatchedIdTest1()
478    throws IOException, SiftsException
479    {
480  0 SiftsClient siftsClientX = null;
481  0 PDBfile pdbFile;
482  0 pdbFile = new PDBfile(false, false, false,
483    "test/jalview/io/2nq2" + ".pdb", DataSourceType.FILE);
484  0 siftsClientX = new SiftsClient(pdbFile);
485  0 Entity entityA = siftsClientX.getEntityByMostOptimalMatchedId("A");
486  0 Assert.assertEquals(entityA.getEntityId(), "A");
487  0 Entity entityB = siftsClientX.getEntityByMostOptimalMatchedId("B");
488  0 Assert.assertEquals(entityB.getEntityId(), "C");
489  0 Entity entityC = siftsClientX.getEntityByMostOptimalMatchedId("C");
490  0 Assert.assertEquals(entityC.getEntityId(), "B");
491  0 Entity entityD = siftsClientX.getEntityByMostOptimalMatchedId("D");
492  0 Assert.assertEquals(entityD.getEntityId(), "D");
493   
494    }
495   
 
496  0 toggle @Test(groups = { "Network" })
497    public void getEntityByMostOptimalMatchedIdTest2()
498    throws IOException, SiftsException
499    {
500    // This test is for a SIFTS file in which entity A should map to chain P for
501    // the given PDB Id. All the other chains shouldn't be mapped as there are
502    // no SIFTS entity records for them.
503  0 SiftsClient siftsClientX = null;
504  0 PDBfile pdbFile;
505  0 pdbFile = new PDBfile(false, false, false, "test/jalview/io/3ucu.cif",
506    DataSourceType.FILE);
507  0 siftsClientX = new SiftsClient(pdbFile);
508  0 Entity entityA = siftsClientX.getEntityByMostOptimalMatchedId("P");
509  0 Entity entityP = siftsClientX.getEntityByMostOptimalMatchedId("A");
510  0 Entity entityR = siftsClientX.getEntityByMostOptimalMatchedId("R");
511  0 Assert.assertEquals(entityA.getEntityId(), "A");
512  0 Assert.assertNotEquals(entityR, "A");
513  0 Assert.assertNotEquals(entityP, "A");
514  0 Assert.assertNotEquals(entityR, "R");
515  0 Assert.assertNotEquals(entityP, "P");
516  0 Assert.assertNull(entityR);
517  0 Assert.assertNull(entityP);
518   
519    }
520   
 
521  0 toggle @Test(groups = { "Network" })
522    public void getLeadingIntegerFromString()
523    {
524  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("1234abcd", -1),
525    1234);
526  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("1234", -1),
527    1234);
528  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("abcd", -1), -1);
529  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("abcd1234", -1),
530    -1);
531  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("None", -1), -1);
532  0 Assert.assertEquals(SiftsClient.getLeadingIntegerValue("Null", -1), -1);
533    }
534    }
  • Report generated by OpenClover v 4.4.1 on Wed Nov 6 2024 14:54:51 GMT using coverage data from Wed Nov 6 2024 14:54:40 GMT.
  • OpenClover is free and open-source software.