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