Clover icon

Coverage Report

  1. Project Clover database Mon Nov 18 2024 09:56:54 GMT
  2. Package jalview.io

File JSONFileTest.java

 

Code metrics

26
231
19
1
635
499
57
0.25
12.16
19
3

Classes

Class Line # Actions
JSONFileTest 58 231 57
0.833333383.3%
 

Contributing tests

This file is covered by 10 tests. .

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.io;
22   
23    import static org.testng.AssertJUnit.assertNotNull;
24   
25    import jalview.api.AlignExportSettingsI;
26    import jalview.datamodel.AlignExportSettingsAdapter;
27    import jalview.datamodel.Alignment;
28    import jalview.datamodel.AlignmentAnnotation;
29    import jalview.datamodel.AlignmentI;
30    import jalview.datamodel.Annotation;
31    import jalview.datamodel.HiddenColumns;
32    import jalview.datamodel.Sequence;
33    import jalview.datamodel.SequenceFeature;
34    import jalview.datamodel.SequenceGroup;
35    import jalview.datamodel.SequenceI;
36    import jalview.datamodel.features.SequenceFeatures;
37    import jalview.gui.AlignFrame;
38    import jalview.gui.JvOptionPane;
39    import jalview.json.binding.biojson.v1.ColourSchemeMapper;
40    import jalview.schemes.ColourSchemeI;
41    import jalview.schemes.ResidueColourScheme;
42   
43    import java.io.IOException;
44    import java.util.ArrayList;
45    import java.util.HashMap;
46    import java.util.Iterator;
47    import java.util.List;
48    import java.util.Map;
49   
50    import org.testng.Assert;
51    import org.testng.AssertJUnit;
52    import org.testng.annotations.AfterTest;
53    import org.testng.annotations.BeforeClass;
54    import org.testng.annotations.BeforeMethod;
55    import org.testng.annotations.BeforeTest;
56    import org.testng.annotations.Test;
57   
 
58    public class JSONFileTest
59    {
60   
 
61  1 toggle @BeforeClass(alwaysRun = true)
62    public void setUpJvOptionPane()
63    {
64  1 JvOptionPane.setInteractiveMode(false);
65  1 JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION);
66    }
67   
68    private int TEST_SEQ_HEIGHT = 0;
69   
70    private int TEST_GRP_HEIGHT = 0;
71   
72    private int TEST_ANOT_HEIGHT = 0;
73   
74    private int TEST_CS_HEIGHT = 0;
75   
76    private String TEST_JSON_FILE = "examples/example.json";
77   
78    private Alignment alignment;
79   
80    private HashMap<String, SequenceI> expectedSeqs = new HashMap<>();
81   
82    private HashMap<String, AlignmentAnnotation> expectedAnnots = new HashMap<>();
83   
84    private HashMap<String, SequenceGroup> expectedGrps = new HashMap<>();
85   
86    private HiddenColumns expectedColSel = new HiddenColumns();
87   
88    private SequenceI[] expectedHiddenSeqs = new SequenceI[1];
89   
90    private AlignmentI testAlignment;
91   
92    private int passedCount;
93   
94    private JSONFile testJsonFile;
95   
96    private JSONFile jf;
97   
98    private AlignExportSettingsI exportSettings;
99   
 
100  4 toggle @BeforeTest(alwaysRun = true)
101    public void setup() throws Exception
102    {
103    /*
104    * construct expected values
105    * nb this have to match the data in examples/example.json
106    */
107    // create and add sequences
108  4 Sequence[] seqs = new Sequence[5];
109  4 seqs[0] = new Sequence("FER_CAPAN",
110    "SVSATMISTSFMPRKPAVTSL-KPIPNVGE--ALF", 3, 34);
111  4 seqs[1] = new Sequence("FER1_SOLLC",
112    "SISGTMISTSFLPRKPAVTSL-KAISNVGE--ALF", 3, 34);
113  4 seqs[2] = new Sequence("Q93XJ9_SOLTU",
114    "SISGTMISTSFLPRKPVVTSL-KAISNVGE--ALF", 3, 34);
115  4 seqs[3] = new Sequence("FER1_PEA",
116    "ALYGTAVSTSFLRTQPMPMSV-TTTKAFSN--GFL", 6, 37);
117  4 seqs[4] = new Sequence("Q7XA98_TRIPR",
118    "ALYGTAVSTSFMRRQPVPMSV-ATTTTTKAFPSGF", 6, 39);
119   
120  4 SequenceI hiddenSeq = new Sequence("FER_TOCH",
121    "FILGTMISKSFLFRKPAVTSL-KAISNVGE--ALF", 3, 34);
122  4 expectedHiddenSeqs[0] = hiddenSeq;
123   
124    // create and add sequence features
125  4 SequenceFeature seqFeature2 = new SequenceFeature("feature_x",
126    "theDesc", 6, 15, "Jalview");
127  4 SequenceFeature seqFeature3 = new SequenceFeature("feature_x",
128    "theDesc", 9, 18, "Jalview");
129  4 SequenceFeature seqFeature4 = new SequenceFeature("feature_x",
130    "theDesc", 9, 18, "Jalview");
131    // non-positional feature:
132  4 SequenceFeature seqFeature5 = new SequenceFeature("Domain",
133    "My description", 0, 0, "Pfam");
134  4 seqs[2].addSequenceFeature(seqFeature2);
135  4 seqs[3].addSequenceFeature(seqFeature3);
136  4 seqs[4].addSequenceFeature(seqFeature4);
137  4 seqs[2].addSequenceFeature(seqFeature5);
138   
139  4 for (Sequence seq : seqs)
140    {
141  20 seq.createDatasetSequence();
142  20 expectedSeqs.put(seq.getName(), seq);
143    }
144   
145    // create and add a sequence group
146  4 List<SequenceI> grpSeqs = new ArrayList<>();
147  4 grpSeqs.add(seqs[1]);
148  4 grpSeqs.add(seqs[2]);
149  4 grpSeqs.add(seqs[3]);
150  4 grpSeqs.add(seqs[4]);
151  4 SequenceGroup seqGrp = new SequenceGroup(grpSeqs, "JGroup:1883305585",
152    null, true, true, false, 21, 29);
153  4 ColourSchemeI scheme = ColourSchemeMapper
154    .getJalviewColourScheme("zappo", seqGrp);
155  4 seqGrp.cs.setColourScheme(scheme);
156  4 seqGrp.setShowNonconserved(false);
157  4 seqGrp.setDescription(null);
158   
159  4 expectedGrps.put(seqGrp.getName(), seqGrp);
160   
161    // create and add annotation
162  4 Annotation[] annot = new Annotation[35];
163  4 annot[0] = new Annotation("", "", '\u0000', 0);
164  4 annot[1] = new Annotation("", "", '\u0000', 0);
165  4 annot[2] = new Annotation("α", "", 'H', 0);
166  4 annot[3] = new Annotation("α", "", 'H', 0);
167  4 annot[4] = new Annotation("α", "", 'H', 0);
168  4 annot[5] = new Annotation("", "", '\u0000', 0);
169  4 annot[6] = new Annotation("", "", '\u0000', 0);
170  4 annot[7] = new Annotation("", "", '\u0000', 0);
171  4 annot[8] = new Annotation("β", "", 'E', 0);
172  4 annot[9] = new Annotation("β", "", 'E', 0);
173  4 annot[10] = new Annotation("β", "", 'E', 0);
174  4 annot[11] = new Annotation("β", "", 'E', 0);
175  4 annot[12] = new Annotation("β", "", 'E', 0);
176  4 annot[13] = new Annotation("β", "", 'E', 0);
177  4 annot[14] = new Annotation("β", "", 'E', 0);
178  4 annot[15] = new Annotation("β", "", 'E', 0);
179  4 annot[16] = new Annotation("", "", '\u0000', 0);
180  4 annot[17] = new Annotation("", "", '\u0000', 0);
181  4 annot[18] = new Annotation("", "", '\u0000', 0);
182  4 annot[19] = new Annotation("", "", '\u0000', 0);
183  4 annot[20] = new Annotation("", "", '\u0000', 0);
184  4 annot[21] = new Annotation("", "", '\u0000', 0);
185  4 annot[22] = new Annotation("", "", '\u0000', 0);
186  4 annot[23] = new Annotation("", "", '\u0000', 0);
187  4 annot[24] = new Annotation("", "", '\u0000', 0);
188  4 annot[25] = new Annotation("", "", '\u0000', 0);
189  4 annot[26] = new Annotation("α", "", 'H', 0);
190  4 annot[27] = new Annotation("α", "", 'H', 0);
191  4 annot[28] = new Annotation("α", "", 'H', 0);
192  4 annot[29] = new Annotation("α", "", 'H', 0);
193  4 annot[30] = new Annotation("α", "", 'H', 0);
194  4 annot[31] = new Annotation("", "", '\u0000', 0);
195  4 annot[32] = new Annotation("", "", '\u0000', 0);
196  4 annot[33] = new Annotation("", "", '\u0000', 0);
197  4 annot[34] = new Annotation("", "", '\u0000', 0);
198   
199  4 AlignmentAnnotation alignAnnot = new AlignmentAnnotation(
200    "Secondary Structure", "New description", annot);
201  4 expectedAnnots.put(alignAnnot.label, alignAnnot);
202   
203  4 expectedColSel.hideColumns(32, 33);
204  4 expectedColSel.hideColumns(34, 34);
205   
206  4 TEST_SEQ_HEIGHT = expectedSeqs.size();
207  4 TEST_GRP_HEIGHT = expectedGrps.size();
208  4 TEST_ANOT_HEIGHT = expectedAnnots.size();
209  4 TEST_CS_HEIGHT = expectedColSel.getNumberOfRegions();
210   
211  4 exportSettings = new AlignExportSettingsAdapter(true);
212   
213  4 AppletFormatAdapter formatAdapter = new AppletFormatAdapter();
214  4 try
215    {
216  4 alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE,
217    DataSourceType.FILE, FileFormat.Json);
218  4 jf = (JSONFile) formatAdapter.getAlignFile();
219   
220  4 AlignFrame af = new AlignFrame(alignment, jf.getHiddenSequences(),
221    jf.getHiddenColumns(), AlignFrame.DEFAULT_WIDTH,
222    AlignFrame.DEFAULT_HEIGHT);
223  4 af.getViewport().setShowSequenceFeatures(jf.isShowSeqFeatures());
224  4 String colourSchemeName = jf.getGlobalColourScheme();
225  4 ColourSchemeI cs = ColourSchemeMapper
226    .getJalviewColourScheme(colourSchemeName, alignment);
227  4 af.changeColour(cs);
228  4 af.getViewport().setFeaturesDisplayed(jf.getDisplayedFeatures());
229   
230  4 formatAdapter = new AppletFormatAdapter(af.alignPanel,
231    exportSettings);
232  4 String jsonOutput = formatAdapter.formatSequences(FileFormat.Json,
233    af.alignPanel.getAlignment(), false);
234   
235  4 formatAdapter = new AppletFormatAdapter();
236  4 testAlignment = formatAdapter.readFile(jsonOutput,
237    DataSourceType.PASTE, FileFormat.Json);
238  4 testJsonFile = (JSONFile) formatAdapter.getAlignFile();
239  4 System.out.println(jsonOutput);
240    } catch (IOException e)
241    {
242  0 e.printStackTrace();
243    }
244   
245    }
246   
 
247  10 toggle @BeforeMethod(alwaysRun = true)
248    public void methodSetup()
249    {
250  10 passedCount = 0;
251    }
252   
 
253  4 toggle @AfterTest(alwaysRun = true)
254    public void tearDown() throws Exception
255    {
256  4 testJsonFile = null;
257  4 alignment = null;
258  4 expectedSeqs = null;
259  4 expectedAnnots = null;
260  4 expectedGrps = null;
261  4 testAlignment = null;
262  4 jf = null;
263    }
264   
 
265  1 toggle @Test(groups = { "Functional" })
266    public void roundTripTest()
267    {
268  1 assertNotNull("JSON roundtrip test failed!", testJsonFile);
269    }
270   
 
271  1 toggle @Test(groups = { "Functional" })
272    public void testSeqParsed()
273    {
274  1 assertNotNull("Couldn't read supplied alignment data.", testAlignment);
275  1 Assert.assertNotNull(testAlignment.getSequences());
276  1 for (SequenceI seq : testAlignment.getSequences())
277    {
278  5 SequenceI expectedSeq = expectedSeqs.get(seq.getName());
279  5 AssertJUnit.assertTrue(
280    "Failed Sequence Test for >>> " + seq.getName(),
281    isSeqMatched(expectedSeq, seq));
282  5 passedCount++;
283    }
284  1 AssertJUnit.assertEquals("Some Sequences did not pass the test",
285    TEST_SEQ_HEIGHT, passedCount);
286    }
287   
 
288  1 toggle @Test(groups = { "Functional" })
289    public void hiddenColsTest()
290    {
291  1 HiddenColumns cs = testJsonFile.getHiddenColumns();
292  1 Assert.assertNotNull(cs);
293   
294  1 Iterator<int[]> it = cs.iterator();
295  1 Iterator<int[]> colselit = expectedColSel.iterator();
296  1 Assert.assertTrue(it.hasNext());
297  1 Assert.assertEquals(cs.getNumberOfRegions(), TEST_CS_HEIGHT);
298  1 Assert.assertEquals(it.next(), colselit.next(),
299    "Mismatched hidden columns!");
300    }
301   
 
302  1 toggle @Test(groups = { "Functional" })
303    public void hiddenSeqsTest()
304    {
305  1 Assert.assertNotNull(testJsonFile.getHiddenSequences(),
306    "Hidden sequence Expected but found Null");
307  1 Assert.assertEquals(jf.getHiddenSequences().length, 1,
308    "Hidden sequence");
309    }
310   
 
311  1 toggle @Test(groups = { "Functional" })
312    public void colorSchemeTest()
313    {
314  1 Assert.assertNotNull(testJsonFile.getGlobalColourScheme(),
315    "Colourscheme is null, parsing failed!");
316  1 Assert.assertEquals(testJsonFile.getGlobalColourScheme(), "Zappo",
317    "Zappo colour scheme expected!");
318    }
319   
320    /**
321    * Test for bug JAL-2489, NPE when exporting BioJSON with global colour
322    * scheme, and a group colour scheme, set as 'None'
323    */
 
324  1 toggle @Test(groups = { "Functional" })
325    public void testBioJSONRoundTripWithColourSchemeNone()
326    {
327  1 AppletFormatAdapter formatAdapter = new AppletFormatAdapter();
328   
329  1 Alignment _alignment;
330  1 try
331    {
332    // load example BioJSON file
333  1 _alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE,
334    DataSourceType.FILE, FileFormat.Json);
335  1 JSONFile bioJsonFile = (JSONFile) formatAdapter.getAlignFile();
336  1 AlignFrame alignFrame = new AlignFrame(_alignment,
337    bioJsonFile.getHiddenSequences(),
338    bioJsonFile.getHiddenColumns(), AlignFrame.DEFAULT_WIDTH,
339    AlignFrame.DEFAULT_HEIGHT);
340   
341    /*
342    * Create a group on the alignment;
343    * Change global and group colour scheme to 'None' and perform round trip
344    */
345  1 SequenceGroup sg = new SequenceGroup();
346  1 sg.addSequence(_alignment.getSequenceAt(0), false);
347  1 sg.setColourScheme(null);
348  1 ColourSchemeI cs = ColourSchemeMapper
349    .getJalviewColourScheme(ResidueColourScheme.NONE, _alignment);
350  1 alignFrame.changeColour(cs);
351  1 alignFrame.getViewport()
352    .setFeaturesDisplayed(bioJsonFile.getDisplayedFeatures());
353  1 formatAdapter = new AppletFormatAdapter(alignFrame.alignPanel,
354    exportSettings);
355    // export BioJSON string
356  1 String jsonOutput = formatAdapter.formatSequences(FileFormat.Json,
357    alignFrame.alignPanel.getAlignment(), false);
358    // read back Alignment from BioJSON string
359  1 formatAdapter = new AppletFormatAdapter();
360  1 formatAdapter.readFile(jsonOutput, DataSourceType.PASTE,
361    FileFormat.Json);
362    // assert 'None' colour scheme is retained after round trip
363  1 JSONFile _bioJsonFile = (JSONFile) formatAdapter.getAlignFile();
364  1 Assert.assertEquals(_bioJsonFile.getGlobalColourScheme(),
365    ResidueColourScheme.NONE);
366    } catch (IOException e)
367    {
368  0 e.printStackTrace();
369    }
370    }
371   
 
372  1 toggle @Test(groups = { "Functional" })
373    public void isShowSeqFeaturesSet()
374    {
375  1 Assert.assertTrue(testJsonFile.isShowSeqFeatures(),
376    "Sequence feature isDisplayed setting expected to be true");
377    }
378   
 
379  1 toggle @Test(groups = { "Functional" })
380    public void testGrpParsed()
381    {
382  1 Assert.assertNotNull(testAlignment.getGroups());
383  1 for (SequenceGroup seqGrp : testAlignment.getGroups())
384    {
385  1 SequenceGroup expectedGrp = expectedGrps.get(seqGrp.getName());
386  1 AssertJUnit.assertTrue(
387    "Failed SequenceGroup Test for >>> " + seqGrp.getName(),
388    isGroupMatched(expectedGrp, seqGrp));
389  1 passedCount++;
390    }
391  1 AssertJUnit.assertEquals("Some SequenceGroups did not pass the test",
392    TEST_GRP_HEIGHT, passedCount);
393    }
394   
 
395  1 toggle @Test(groups = { "Functional" })
396    public void testAnnotationParsed()
397    {
398  1 Assert.assertNotNull(testAlignment.getAlignmentAnnotation());
399  1 for (AlignmentAnnotation annot : testAlignment.getAlignmentAnnotation())
400    {
401  1 AlignmentAnnotation expectedAnnot = expectedAnnots.get(annot.label);
402  1 AssertJUnit.assertTrue(
403    "Failed AlignmentAnnotation Test for >>> " + annot.label,
404    isAnnotationMatched(expectedAnnot, annot));
405  1 passedCount++;
406    }
407  1 AssertJUnit.assertEquals("Some Sequences did not pass the test",
408    TEST_ANOT_HEIGHT, passedCount);
409    }
410   
 
411  1 toggle public boolean isAnnotationMatched(AlignmentAnnotation eAnnot,
412    AlignmentAnnotation annot)
413    {
414  1 if (!eAnnot.label.equals(annot.label)
415    || !eAnnot.description.equals(annot.description)
416    || eAnnot.annotations.length != annot.annotations.length)
417    {
418  0 return false;
419    }
420   
421  36 for (int x = 0; x < annot.annotations.length; x++)
422    {
423  35 Annotation y = annot.annotations[x];
424  35 Annotation z = annot.annotations[x];
425   
426  35 if (!y.displayCharacter.equals(z.displayCharacter)
427    || y.value != z.value
428    || y.secondaryStructure != z.secondaryStructure)
429    {
430  0 return false;
431    }
432    }
433  1 return true;
434    }
435   
 
436  5 toggle boolean isSeqMatched(SequenceI expectedSeq, SequenceI actualSeq)
437    {
438  5 System.out.println("Testing >>> " + actualSeq.getName());
439   
440  5 if (expectedSeq.getName().equals(actualSeq.getName())
441    && expectedSeq.getSequenceAsString()
442    .equals(actualSeq.getSequenceAsString())
443    && expectedSeq.getStart() == actualSeq.getStart()
444    && expectedSeq.getEnd() == actualSeq.getEnd()
445    && featuresMatched(expectedSeq, actualSeq))
446    {
447  5 return true;
448    }
449  0 return false;
450    }
451   
 
452  2 toggle public boolean isGroupMatched(SequenceGroup expectedGrp,
453    SequenceGroup actualGrp)
454    {
455   
456  2 System.out.println("Testing >>> " + actualGrp.getName());
457  2 System.out.println(expectedGrp.getName() + " | " + actualGrp.getName());
458  2 System.out.println(expectedGrp.getColourText() + " | "
459    + actualGrp.getColourText());
460  2 System.out.println(expectedGrp.getDisplayBoxes() + " | "
461    + actualGrp.getDisplayBoxes());
462  2 System.out.println(expectedGrp.getIgnoreGapsConsensus() + " | "
463    + actualGrp.getIgnoreGapsConsensus());
464  2 System.out.println(expectedGrp.getSequences().size() + " | "
465    + actualGrp.getSequences().size());
466  2 System.out.println(
467    expectedGrp.getStartRes() + " | " + actualGrp.getStartRes());
468  2 System.out.println(
469    expectedGrp.getEndRes() + " | " + actualGrp.getEndRes());
470  2 System.out.println(expectedGrp.cs.getColourScheme() + " | "
471    + actualGrp.cs.getColourScheme());
472   
473  2 boolean colourSchemeMatches = (expectedGrp.cs.getColourScheme() == null
474    && actualGrp.cs.getColourScheme() == null)
475    || expectedGrp.cs.getColourScheme().getClass()
476    .equals(actualGrp.cs.getColourScheme().getClass());
477  2 if (expectedGrp.getName().equals(actualGrp.getName())
478    && expectedGrp.getColourText() == actualGrp.getColourText()
479    && expectedGrp.getDisplayBoxes() == actualGrp.getDisplayBoxes()
480    && expectedGrp.getIgnoreGapsConsensus() == actualGrp
481    .getIgnoreGapsConsensus()
482    && colourSchemeMatches
483    && expectedGrp.getSequences().size() == actualGrp.getSequences()
484    .size()
485    && expectedGrp.getStartRes() == actualGrp.getStartRes()
486    && expectedGrp.getEndRes() == actualGrp.getEndRes())
487    {
488  2 return true;
489    }
490  0 return false;
491    }
492   
 
493  5 toggle private boolean featuresMatched(SequenceI seq1, SequenceI seq2)
494    {
495  5 try
496    {
497  5 if (seq1 == null && seq2 == null)
498    {
499  0 return true;
500    }
501   
502  5 List<SequenceFeature> inFeature = seq1.getFeatures().getAllFeatures();
503  5 List<SequenceFeature> outFeature = seq2.getFeatures()
504    .getAllFeatures();
505   
506  5 if (inFeature.size() != outFeature.size())
507    {
508  0 System.err.println("Feature count in: " + inFeature.size()
509    + ", out: " + outFeature.size());
510  0 return false;
511    }
512   
513  5 SequenceFeatures.sortFeatures(inFeature, true);
514  5 SequenceFeatures.sortFeatures(outFeature, true);
515  5 int i = 0;
516  5 for (SequenceFeature in : inFeature)
517    {
518  4 SequenceFeature out = outFeature.get(i);
519    /*
520    System.out.println(out.getType() + " | " + in.getType());
521    System.out.println(out.getBegin() + " | " + in.getBegin());
522    System.out.println(out.getEnd() + " | " + in.getEnd());
523    */
524  4 if (!in.equals(out))
525    {
526  0 System.err.println(
527    "Mismatch of " + in.toString() + " " + out.toString());
528  0 return false;
529    }
530    /*
531    if (in.getBegin() == out.getBegin() && in.getEnd() == out.getEnd()
532    && in.getScore() == out.getScore()
533    && in.getFeatureGroup().equals(out.getFeatureGroup())
534    && in.getType().equals(out.getType())
535    && mapsMatch(in.otherDetails, out.otherDetails))
536    {
537    }
538    else
539    {
540    System.err.println("Feature[" + i + "] mismatch, in: "
541    + in.toString() + ", out: "
542    + outFeature.get(i).toString());
543    return false;
544    }
545    */
546  4 i++;
547    }
548    } catch (Exception e)
549    {
550  0 e.printStackTrace();
551    }
552    // System.out.println(">>>>>>>>>>>>>> features matched : " + matched);
553  5 return true;
554    }
555   
 
556  0 toggle boolean mapsMatch(Map<String, Object> m1, Map<String, Object> m2)
557    {
558  0 if (m1 == null || m2 == null)
559    {
560  0 if (m1 != null || m2 != null)
561    {
562  0 System.err.println(
563    "only one SequenceFeature.otherDetails is not null");
564  0 return false;
565    }
566    else
567    {
568  0 return true;
569    }
570    }
571  0 if (m1.size() != m2.size())
572    {
573  0 System.err.println("otherDetails map different sizes");
574  0 return false;
575    }
576  0 for (String key : m1.keySet())
577    {
578  0 if (!m2.containsKey(key))
579    {
580  0 System.err.println(key + " in only one otherDetails");
581  0 return false;
582    }
583  0 if (m1.get(key) == null && m2.get(key) != null
584    || m1.get(key) != null && m2.get(key) == null
585    || !m1.get(key).equals(m2.get(key)))
586    {
587  0 System.err.println(key + " values in otherDetails don't match");
588  0 return false;
589    }
590    }
591  0 return true;
592    }
593   
594    /**
595    * Test group roundtrip with null (None) group colour scheme
596    *
597    * @throws IOException
598    */
 
599  1 toggle @Test(groups = { "Functional" })
600    public void testGrpParsed_colourNone() throws IOException
601    {
602  1 AlignmentI copy = new Alignment(testAlignment);
603  1 SequenceGroup sg = testAlignment.getGroups().get(0);
604  1 SequenceGroup copySg = new SequenceGroup(new ArrayList<SequenceI>(),
605    sg.getName(), null, sg.getDisplayBoxes(), sg.getDisplayText(),
606    sg.getColourText(), sg.getStartRes(), sg.getEndRes());
607  1 for (SequenceI seq : sg.getSequences())
608    {
609  4 int seqIndex = testAlignment.findIndex(seq);
610  4 copySg.addSequence(copy.getSequenceAt(seqIndex), false);
611    }
612  1 copy.addGroup(copySg);
613   
614  1 AlignFrame af = new AlignFrame(copy, copy.getWidth(), copy.getHeight());
615  1 AppletFormatAdapter formatAdapter = new AppletFormatAdapter(
616    af.alignPanel);
617  1 String jsonOutput = formatAdapter.formatSequences(FileFormat.Json, copy,
618    false);
619  1 formatAdapter = new AppletFormatAdapter();
620  1 AlignmentI newAlignment = formatAdapter.readFile(jsonOutput,
621    DataSourceType.PASTE, FileFormat.Json);
622   
623  1 Assert.assertNotNull(newAlignment.getGroups());
624  1 for (SequenceGroup seqGrp : newAlignment.getGroups())
625    {
626  1 SequenceGroup expectedGrp = copySg;
627  1 AssertJUnit.assertTrue(
628    "Failed SequenceGroup Test for >>> " + seqGrp.getName(),
629    isGroupMatched(expectedGrp, seqGrp));
630  1 passedCount++;
631    }
632  1 AssertJUnit.assertEquals("Some SequenceGroups did not pass the test",
633    TEST_GRP_HEIGHT, passedCount);
634    }
635    }
  • Report generated by OpenClover v 4.4.1 on Mon Nov 18 2024 10:04:05 GMT using coverage data from Mon Nov 18 2024 10:03:47 GMT.
  • OpenClover is free and open-source software.