JAL-2068 minimised jalview.gui imports, test for removeAnnotation
[jalview.git] / test / jalview / io / JSONFileTest.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.io;
22
23 import static org.testng.AssertJUnit.assertNotNull;
24
25 import jalview.api.AlignExportSettingI;
26 import jalview.datamodel.Alignment;
27 import jalview.datamodel.AlignmentAnnotation;
28 import jalview.datamodel.AlignmentI;
29 import jalview.datamodel.Annotation;
30 import jalview.datamodel.ColumnSelection;
31 import jalview.datamodel.Sequence;
32 import jalview.datamodel.SequenceFeature;
33 import jalview.datamodel.SequenceGroup;
34 import jalview.datamodel.SequenceI;
35 import jalview.gui.AlignFrame;
36 import jalview.json.binding.biojson.v1.ColourSchemeMapper;
37 import jalview.schemes.ColourSchemeI;
38
39 import java.io.IOException;
40 import java.util.ArrayList;
41 import java.util.HashMap;
42 import java.util.List;
43
44 import org.testng.Assert;
45 import org.testng.AssertJUnit;
46 import org.testng.annotations.AfterTest;
47 import org.testng.annotations.BeforeMethod;
48 import org.testng.annotations.BeforeTest;
49 import org.testng.annotations.Test;
50
51 public class JSONFileTest
52 {
53
54   private int TEST_SEQ_HEIGHT = 0;
55
56   private int TEST_GRP_HEIGHT = 0;
57
58   private int TEST_ANOT_HEIGHT = 0;
59
60   private int TEST_CS_HEIGHT = 0;
61
62   private String TEST_JSON_FILE = "examples/example.json";
63
64   private Alignment alignment;
65
66   private HashMap<String, SequenceI> expectedSeqs = new HashMap<String, SequenceI>();
67
68   private HashMap<String, AlignmentAnnotation> expectedAnnots = new HashMap<String, AlignmentAnnotation>();
69
70   private HashMap<String, SequenceGroup> expectedGrps = new HashMap<String, SequenceGroup>();
71
72   private ColumnSelection expectedColSel = new ColumnSelection();
73
74   private SequenceI[] expectedHiddenSeqs = new SequenceI[1];
75
76   private AlignmentI testAlignment;
77
78   private int passedCount;
79
80   private JSONFile testJsonFile;
81
82   private JSONFile jf;
83
84   @BeforeTest(alwaysRun = true)
85   public void setup() throws Exception
86   {
87     // create and add sequences
88     Sequence[] seqs = new Sequence[5];
89     seqs[0] = new Sequence("FER_CAPAN",
90             "SVSATMISTSFMPRKPAVTSL-KPIPNVGE--ALF", 3, 34);
91     seqs[1] = new Sequence("FER1_SOLLC",
92             "SISGTMISTSFLPRKPAVTSL-KAISNVGE--ALF", 3, 34);
93     seqs[2] = new Sequence("Q93XJ9_SOLTU",
94             "SISGTMISTSFLPRKPVVTSL-KAISNVGE--ALF", 3, 34);
95     seqs[3] = new Sequence("FER1_PEA",
96             "ALYGTAVSTSFLRTQPMPMSV-TTTKAFSN--GFL", 6, 37);
97     seqs[4] = new Sequence("Q7XA98_TRIPR",
98             "ALYGTAVSTSFMRRQPVPMSV-ATTTTTKAFPSGF", 6, 39);
99
100     SequenceI hiddenSeq = new Sequence("FER_TOCH",
101             "FILGTMISKSFLFRKPAVTSL-KAISNVGE--ALF", 3, 34);
102     expectedHiddenSeqs[0] = hiddenSeq;
103
104     // create and add sequence features
105     SequenceFeature seqFeature2 = new SequenceFeature("feature_x",
106             "desciption", "status", 6, 15, "Jalview");
107     SequenceFeature seqFeature3 = new SequenceFeature("feature_x",
108             "desciption", "status", 9, 18, "Jalview");
109     SequenceFeature seqFeature4 = new SequenceFeature("feature_x",
110             "desciption", "status", 9, 18, "Jalview");
111     seqs[2].addSequenceFeature(seqFeature2);
112     seqs[3].addSequenceFeature(seqFeature3);
113     seqs[4].addSequenceFeature(seqFeature4);
114
115     for (Sequence seq : seqs)
116     {
117       seq.setDatasetSequence(seq);
118       expectedSeqs.put(seq.getName(), seq);
119     }
120
121     // create and add sequence groups
122     ArrayList<SequenceI> grpSeqs = new ArrayList<SequenceI>();
123     grpSeqs.add(seqs[1]);
124     grpSeqs.add(seqs[2]);
125     grpSeqs.add(seqs[3]);
126     grpSeqs.add(seqs[4]);
127     SequenceGroup seqGrp = new SequenceGroup(grpSeqs, "JGroup:1883305585",
128             null, true, true, false, 21, 29);
129     ColourSchemeI scheme = ColourSchemeMapper.getJalviewColourScheme(
130             "zappo", seqGrp);
131     seqGrp.cs = scheme;
132     seqGrp.setShowNonconserved(false);
133     seqGrp.setDescription(null);
134
135     expectedGrps.put(seqGrp.getName(), seqGrp);
136
137     // create and add annotation
138     Annotation[] annot = new Annotation[35];
139     annot[0] = new Annotation("", "", '\u0000', 0);
140     annot[1] = new Annotation("", "", '\u0000', 0);
141     annot[2] = new Annotation("α", "", 'H', 0);
142     annot[3] = new Annotation("α", "", 'H', 0);
143     annot[4] = new Annotation("α", "", 'H', 0);
144     annot[5] = new Annotation("", "", '\u0000', 0);
145     annot[6] = new Annotation("", "", '\u0000', 0);
146     annot[7] = new Annotation("", "", '\u0000', 0);
147     annot[8] = new Annotation("β", "", 'E', 0);
148     annot[9] = new Annotation("β", "", 'E', 0);
149     annot[10] = new Annotation("β", "", 'E', 0);
150     annot[11] = new Annotation("β", "", 'E', 0);
151     annot[12] = new Annotation("β", "", 'E', 0);
152     annot[13] = new Annotation("β", "", 'E', 0);
153     annot[14] = new Annotation("β", "", 'E', 0);
154     annot[15] = new Annotation("β", "", 'E', 0);
155     annot[16] = new Annotation("", "", '\u0000', 0);
156     annot[17] = new Annotation("", "", '\u0000', 0);
157     annot[18] = new Annotation("", "", '\u0000', 0);
158     annot[19] = new Annotation("", "", '\u0000', 0);
159     annot[20] = new Annotation("", "", '\u0000', 0);
160     annot[21] = new Annotation("", "", '\u0000', 0);
161     annot[22] = new Annotation("", "", '\u0000', 0);
162     annot[23] = new Annotation("", "", '\u0000', 0);
163     annot[24] = new Annotation("", "", '\u0000', 0);
164     annot[25] = new Annotation("", "", '\u0000', 0);
165     annot[26] = new Annotation("α", "", 'H', 0);
166     annot[27] = new Annotation("α", "", 'H', 0);
167     annot[28] = new Annotation("α", "", 'H', 0);
168     annot[29] = new Annotation("α", "", 'H', 0);
169     annot[30] = new Annotation("α", "", 'H', 0);
170     annot[31] = new Annotation("", "", '\u0000', 0);
171     annot[32] = new Annotation("", "", '\u0000', 0);
172     annot[33] = new Annotation("", "", '\u0000', 0);
173     annot[34] = new Annotation("", "", '\u0000', 0);
174
175     AlignmentAnnotation alignAnnot = new AlignmentAnnotation(
176             "Secondary Structure", "New description", annot);
177     expectedAnnots.put(alignAnnot.label, alignAnnot);
178
179     expectedColSel.hideColumns(32, 33);
180     expectedColSel.hideColumns(34, 34);
181
182     TEST_SEQ_HEIGHT = expectedSeqs.size();
183     TEST_GRP_HEIGHT = expectedGrps.size();
184     TEST_ANOT_HEIGHT = expectedAnnots.size();
185     TEST_CS_HEIGHT = expectedColSel.getHiddenColumns().size();
186
187     AlignExportSettingI exportSettings = new AlignExportSettingI()
188     {
189       @Override
190       public boolean isExportHiddenSequences()
191       {
192         return true;
193       }
194
195       @Override
196       public boolean isExportHiddenColumns()
197       {
198         return true;
199       }
200
201       @Override
202       public boolean isExportGroups()
203       {
204         return true;
205       }
206
207       @Override
208       public boolean isExportFeatures()
209       {
210         return true;
211       }
212
213       @Override
214       public boolean isExportAnnotations()
215       {
216         return true;
217       }
218
219       @Override
220       public boolean isCancelled()
221       {
222         return false;
223       }
224     };
225
226     AppletFormatAdapter formatAdapter = new AppletFormatAdapter();
227     try
228     {
229       alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE,
230               AppletFormatAdapter.FILE, JSONFile.FILE_DESC);
231       jf = (JSONFile) formatAdapter.getAlignFile();
232
233       AlignFrame af = new AlignFrame(alignment, jf.getHiddenSequences(),
234               jf.getColumnSelection(), AlignFrame.DEFAULT_WIDTH,
235               AlignFrame.DEFAULT_HEIGHT);
236       af.getViewport().setShowSequenceFeatures(jf.isShowSeqFeatures());
237       String colourSchemeName = jf.getGlobalColourScheme();
238       ColourSchemeI cs = ColourSchemeMapper.getJalviewColourScheme(
239               colourSchemeName, alignment);
240       af.changeColour(cs);
241       af.getViewport().setFeaturesDisplayed(jf.getDisplayedFeatures());
242
243       formatAdapter = new AppletFormatAdapter(af.alignPanel, exportSettings);
244       String jsonOutput = formatAdapter.formatSequences(JSONFile.FILE_DESC,
245               af.alignPanel.getAlignment(), false);
246
247       formatAdapter = new AppletFormatAdapter();
248       testAlignment = formatAdapter.readFile(jsonOutput,
249               AppletFormatAdapter.PASTE, JSONFile.FILE_DESC);
250       testJsonFile = (JSONFile) formatAdapter.getAlignFile();
251       // System.out.println(jsonOutput);
252     } catch (IOException e)
253     {
254       e.printStackTrace();
255     }
256
257   }
258
259   @BeforeMethod(alwaysRun = true)
260   public void methodSetup()
261   {
262     passedCount = 0;
263   }
264
265   @AfterTest
266   public void tearDown() throws Exception
267   {
268     testJsonFile = null;
269     alignment = null;
270     expectedSeqs = null;
271     expectedAnnots = null;
272     expectedGrps = null;
273     testAlignment = null;
274     jf = null;
275   }
276
277   @Test(groups = { "Functional" })
278   public void roundTripTest()
279   {
280     assertNotNull("JSON roundtrip test failed!", testJsonFile);
281   }
282
283   @Test(groups = { "Functional" })
284   public void testSeqParsed()
285   {
286     assertNotNull("Couldn't read supplied alignment data.", testAlignment);
287     Assert.assertNotNull(testAlignment.getSequences());
288     for (SequenceI seq : testAlignment.getSequences())
289     {
290       SequenceI expectedSeq = expectedSeqs.get(seq.getName());
291       AssertJUnit.assertTrue(
292               "Failed Sequence Test  for >>> " + seq.getName(),
293               isSeqMatched(expectedSeq, seq));
294       passedCount++;
295     }
296     AssertJUnit.assertEquals("Some Sequences did not pass the test",
297             TEST_SEQ_HEIGHT, passedCount);
298   }
299
300   @Test(groups = { "Functional" })
301   public void hiddenColsTest()
302   {
303     ColumnSelection cs = testJsonFile.getColumnSelection();
304     Assert.assertNotNull(cs);
305     Assert.assertNotNull(cs.getHiddenColumns());
306     List<int[]> hiddenCols = cs.getHiddenColumns();
307     Assert.assertEquals(hiddenCols.size(), TEST_CS_HEIGHT);
308     Assert.assertEquals(hiddenCols, expectedColSel.getHiddenColumns(),
309             "Mismatched hidden columns!");
310   }
311
312   @Test(groups = { "Functional" })
313   public void hiddenSeqsTest()
314   {
315     Assert.assertNotNull(testJsonFile.getHiddenSequences(),
316             "Hidden sequence Expected but found Null");
317     Assert.assertEquals(jf.getHiddenSequences().length, 1, "Hidden sequece");
318   }
319
320   @Test(groups = { "Functional" })
321   public void colorSchemeTest()
322   {
323     Assert.assertNotNull(testJsonFile.getGlobalColourScheme(),
324             "Colourscheme is null, parsing failed!");
325     Assert.assertEquals(testJsonFile.getGlobalColourScheme(), "Zappo",
326             "Zappo colour scheme expected!");
327   }
328
329   @Test(groups = { "Functional" })
330   public void isShowSeqFeaturesSet()
331   {
332     Assert.assertTrue(testJsonFile.isShowSeqFeatures(),
333             "Sequence feature isDisplayed setting expected to be true");
334   }
335
336   @Test(groups = { "Functional" })
337   public void testGrpParsed()
338   {
339     Assert.assertNotNull(testAlignment.getGroups());
340     for (SequenceGroup seqGrp : testAlignment.getGroups())
341     {
342       SequenceGroup expectedGrp = expectedGrps.get(seqGrp.getName());
343       AssertJUnit.assertTrue(
344               "Failed SequenceGroup Test for >>> " + seqGrp.getName(),
345               isGroupMatched(expectedGrp, seqGrp));
346       passedCount++;
347     }
348     AssertJUnit.assertEquals("Some SequenceGroups did not pass the test",
349             TEST_GRP_HEIGHT, passedCount);
350   }
351
352   @Test(groups = { "Functional" })
353   public void testAnnotationParsed()
354   {
355     Assert.assertNotNull(testAlignment.getAlignmentAnnotation());
356     for (AlignmentAnnotation annot : testAlignment.getAlignmentAnnotation())
357     {
358       AlignmentAnnotation expectedAnnot = expectedAnnots.get(annot.label);
359       AssertJUnit.assertTrue("Failed AlignmentAnnotation Test for >>> "
360               + annot.label, isAnnotationMatched(expectedAnnot, annot));
361       passedCount++;
362     }
363     AssertJUnit.assertEquals("Some Sequences did not pass the test",
364             TEST_ANOT_HEIGHT, passedCount);
365   }
366
367   public boolean isAnnotationMatched(AlignmentAnnotation eAnnot,
368           AlignmentAnnotation annot)
369   {
370     if (!eAnnot.label.equals(annot.label)
371             || !eAnnot.description.equals(annot.description)
372             || eAnnot.annotations.length != annot.annotations.length)
373     {
374       return false;
375     }
376
377     for (int x = 0; x < annot.annotations.length; x++)
378     {
379       Annotation y = annot.annotations[x];
380       Annotation z = annot.annotations[x];
381
382       if (!y.displayCharacter.equals(z.displayCharacter)
383               || y.value != z.value
384               || y.secondaryStructure != z.secondaryStructure)
385       {
386         return false;
387       }
388     }
389     return true;
390   }
391
392   public boolean isSeqMatched(SequenceI expectedSeq, SequenceI actualSeq)
393   {
394     System.out.println("Testing >>> " + actualSeq.getName());
395
396     if (expectedSeq.getName().equals(actualSeq.getName())
397             && expectedSeq.getSequenceAsString().equals(
398                     actualSeq.getSequenceAsString())
399             && expectedSeq.getStart() == actualSeq.getStart()
400             && expectedSeq.getEnd() == actualSeq.getEnd()
401             && featuresMatched(expectedSeq, actualSeq))
402     {
403       return true;
404     }
405     return false;
406   }
407
408   public boolean isGroupMatched(SequenceGroup expectedGrp,
409           SequenceGroup actualGrp)
410   {
411
412     System.out.println("Testing >>> " + actualGrp.getName());
413     System.out.println(expectedGrp.getName() + " | " + actualGrp.getName());
414     System.out.println(expectedGrp.getColourText() + " | "
415             + actualGrp.getColourText());
416     System.out.println(expectedGrp.getDisplayBoxes() + " | "
417             + actualGrp.getDisplayBoxes());
418     System.out.println(expectedGrp.getIgnoreGapsConsensus() + " | "
419             + actualGrp.getIgnoreGapsConsensus());
420     System.out.println(expectedGrp.getSequences().size() + " | "
421             + actualGrp.getSequences().size());
422     System.out.println(expectedGrp.getStartRes() + " | "
423             + actualGrp.getStartRes());
424     System.out.println(expectedGrp.getEndRes() + " | "
425             + actualGrp.getEndRes());
426     System.out.println(expectedGrp.cs + " | " + actualGrp.cs);
427
428     if (expectedGrp.getName().equals(actualGrp.getName())
429             && expectedGrp.getColourText() == actualGrp.getColourText()
430             && expectedGrp.getDisplayBoxes() == actualGrp.getDisplayBoxes()
431             && expectedGrp.getIgnoreGapsConsensus() == actualGrp
432                     .getIgnoreGapsConsensus()
433             && (expectedGrp.cs.getClass().equals(actualGrp.cs.getClass()))
434             && expectedGrp.getSequences().size() == actualGrp
435                     .getSequences().size()
436             && expectedGrp.getStartRes() == actualGrp.getStartRes()
437             && expectedGrp.getEndRes() == actualGrp.getEndRes())
438     {
439       return true;
440     }
441     return false;
442   }
443
444   private boolean featuresMatched(SequenceI seq1, SequenceI seq2)
445   {
446     boolean matched = false;
447     try
448     {
449       if (seq1 == null && seq2 == null)
450       {
451         return true;
452       }
453
454       SequenceFeature[] inFeature = seq1.getSequenceFeatures();
455       SequenceFeature[] outFeature = seq2.getSequenceFeatures();
456
457       if (inFeature == null && outFeature == null)
458       {
459         return true;
460       }
461       else if ((inFeature == null && outFeature != null)
462               || (inFeature != null && outFeature == null))
463       {
464         return false;
465       }
466
467       int testSize = inFeature.length;
468       int matchedCount = 0;
469       for (SequenceFeature in : inFeature)
470       {
471         for (SequenceFeature out : outFeature)
472         {
473           System.out.println(out.getType() + " | " + in.getType());
474           System.out.println(out.getBegin() + " | " + in.getBegin());
475           System.out.println(out.getEnd() + " | " + in.getEnd());
476
477           if (inFeature.length == outFeature.length
478                   && in.getBegin() == out.getBegin()
479                   && in.getEnd() == out.getEnd()
480                   && in.getScore() == out.getScore()
481                   && in.getFeatureGroup().equals(out.getFeatureGroup())
482                   && in.getType().equals(out.getType()))
483           {
484
485             ++matchedCount;
486           }
487         }
488       }
489       System.out.println("matched count >>>>>> " + matchedCount);
490       if (testSize == matchedCount)
491       {
492         matched = true;
493       }
494     } catch (Exception e)
495     {
496       e.printStackTrace();
497     }
498     // System.out.println(">>>>>>>>>>>>>> features matched : " + matched);
499     return matched;
500   }
501 }