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 }