X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fio%2FJSONFileTest.java;h=0fe721a879332e31d7861055676ed3ddd0c4e1e7;hb=57738a1f3c19b1c3a00bd3ac5108f8cd0af32f99;hp=957343bf474f4a44e3381d36e406648b1d344f47;hpb=d1707d4c26db76cfeb640f0dbeb3e3427fd40eb7;p=jalview.git

diff --git a/test/jalview/io/JSONFileTest.java b/test/jalview/io/JSONFileTest.java
index 957343b..0fe721a 100644
--- a/test/jalview/io/JSONFileTest.java
+++ b/test/jalview/io/JSONFileTest.java
@@ -22,7 +22,8 @@ package jalview.io;
 
 import static org.testng.AssertJUnit.assertNotNull;
 
-import jalview.api.AlignExportSettingI;
+import jalview.api.AlignExportSettingsI;
+import jalview.datamodel.AlignExportSettingsAdapter;
 import jalview.datamodel.Alignment;
 import jalview.datamodel.AlignmentAnnotation;
 import jalview.datamodel.AlignmentI;
@@ -32,15 +33,19 @@ import jalview.datamodel.Sequence;
 import jalview.datamodel.SequenceFeature;
 import jalview.datamodel.SequenceGroup;
 import jalview.datamodel.SequenceI;
+import jalview.datamodel.features.SequenceFeatures;
 import jalview.gui.AlignFrame;
 import jalview.gui.JvOptionPane;
 import jalview.json.binding.biojson.v1.ColourSchemeMapper;
 import jalview.schemes.ColourSchemeI;
+import jalview.schemes.ResidueColourScheme;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Iterator;
 import java.util.List;
+import java.util.Map;
 
 import org.testng.Assert;
 import org.testng.AssertJUnit;
@@ -72,11 +77,11 @@ public class JSONFileTest
 
   private Alignment alignment;
 
-  private HashMap<String, SequenceI> expectedSeqs = new HashMap<String, SequenceI>();
+  private HashMap<String, SequenceI> expectedSeqs = new HashMap<>();
 
-  private HashMap<String, AlignmentAnnotation> expectedAnnots = new HashMap<String, AlignmentAnnotation>();
+  private HashMap<String, AlignmentAnnotation> expectedAnnots = new HashMap<>();
 
-  private HashMap<String, SequenceGroup> expectedGrps = new HashMap<String, SequenceGroup>();
+  private HashMap<String, SequenceGroup> expectedGrps = new HashMap<>();
 
   private HiddenColumns expectedColSel = new HiddenColumns();
 
@@ -90,9 +95,15 @@ public class JSONFileTest
 
   private JSONFile jf;
 
+  private AlignExportSettingsI exportSettings;
+
   @BeforeTest(alwaysRun = true)
   public void setup() throws Exception
   {
+    /*
+     * construct expected values
+     * nb this have to match the data in examples/example.json
+     */
     // create and add sequences
     Sequence[] seqs = new Sequence[5];
     seqs[0] = new Sequence("FER_CAPAN",
@@ -112,14 +123,18 @@ public class JSONFileTest
 
     // create and add sequence features
     SequenceFeature seqFeature2 = new SequenceFeature("feature_x",
-            "desciption", "status", 6, 15, "Jalview");
+            "theDesc", 6, 15, "Jalview");
     SequenceFeature seqFeature3 = new SequenceFeature("feature_x",
-            "desciption", "status", 9, 18, "Jalview");
+            "theDesc", 9, 18, "Jalview");
     SequenceFeature seqFeature4 = new SequenceFeature("feature_x",
-            "desciption", "status", 9, 18, "Jalview");
+            "theDesc", 9, 18, "Jalview");
+    // non-positional feature:
+    SequenceFeature seqFeature5 = new SequenceFeature("Domain",
+            "My description", 0, 0, "Pfam");
     seqs[2].addSequenceFeature(seqFeature2);
     seqs[3].addSequenceFeature(seqFeature3);
     seqs[4].addSequenceFeature(seqFeature4);
+    seqs[2].addSequenceFeature(seqFeature5);
 
     for (Sequence seq : seqs)
     {
@@ -127,16 +142,16 @@ public class JSONFileTest
       expectedSeqs.put(seq.getName(), seq);
     }
 
-    // create and add sequence groups
-    ArrayList<SequenceI> grpSeqs = new ArrayList<SequenceI>();
+    // create and add a sequence group
+    List<SequenceI> grpSeqs = new ArrayList<>();
     grpSeqs.add(seqs[1]);
     grpSeqs.add(seqs[2]);
     grpSeqs.add(seqs[3]);
     grpSeqs.add(seqs[4]);
     SequenceGroup seqGrp = new SequenceGroup(grpSeqs, "JGroup:1883305585",
             null, true, true, false, 21, 29);
-    ColourSchemeI scheme = ColourSchemeMapper.getJalviewColourScheme(
-            "zappo", seqGrp);
+    ColourSchemeI scheme = ColourSchemeMapper
+            .getJalviewColourScheme("zappo", seqGrp);
     seqGrp.cs.setColourScheme(scheme);
     seqGrp.setShowNonconserved(false);
     seqGrp.setDescription(null);
@@ -191,46 +206,9 @@ public class JSONFileTest
     TEST_SEQ_HEIGHT = expectedSeqs.size();
     TEST_GRP_HEIGHT = expectedGrps.size();
     TEST_ANOT_HEIGHT = expectedAnnots.size();
-    TEST_CS_HEIGHT = expectedColSel.getListOfCols().size();
-
-    AlignExportSettingI exportSettings = new AlignExportSettingI()
-    {
-      @Override
-      public boolean isExportHiddenSequences()
-      {
-        return true;
-      }
-
-      @Override
-      public boolean isExportHiddenColumns()
-      {
-        return true;
-      }
-
-      @Override
-      public boolean isExportGroups()
-      {
-        return true;
-      }
-
-      @Override
-      public boolean isExportFeatures()
-      {
-        return true;
-      }
-
-      @Override
-      public boolean isExportAnnotations()
-      {
-        return true;
-      }
+    TEST_CS_HEIGHT = expectedColSel.getNumberOfRegions();
 
-      @Override
-      public boolean isCancelled()
-      {
-        return false;
-      }
-    };
+    exportSettings = new AlignExportSettingsAdapter(true);
 
     AppletFormatAdapter formatAdapter = new AppletFormatAdapter();
     try
@@ -244,12 +222,13 @@ public class JSONFileTest
               AlignFrame.DEFAULT_HEIGHT);
       af.getViewport().setShowSequenceFeatures(jf.isShowSeqFeatures());
       String colourSchemeName = jf.getGlobalColourScheme();
-      ColourSchemeI cs = ColourSchemeMapper.getJalviewColourScheme(
-              colourSchemeName, alignment);
+      ColourSchemeI cs = ColourSchemeMapper
+              .getJalviewColourScheme(colourSchemeName, alignment);
       af.changeColour(cs);
       af.getViewport().setFeaturesDisplayed(jf.getDisplayedFeatures());
 
-      formatAdapter = new AppletFormatAdapter(af.alignPanel, exportSettings);
+      formatAdapter = new AppletFormatAdapter(af.alignPanel,
+              exportSettings);
       String jsonOutput = formatAdapter.formatSequences(FileFormat.Json,
               af.alignPanel.getAlignment(), false);
 
@@ -257,7 +236,7 @@ public class JSONFileTest
       testAlignment = formatAdapter.readFile(jsonOutput,
               DataSourceType.PASTE, FileFormat.Json);
       testJsonFile = (JSONFile) formatAdapter.getAlignFile();
-      // System.out.println(jsonOutput);
+      System.out.println(jsonOutput);
     } catch (IOException e)
     {
       e.printStackTrace();
@@ -311,11 +290,12 @@ public class JSONFileTest
   {
     HiddenColumns cs = testJsonFile.getHiddenColumns();
     Assert.assertNotNull(cs);
-    Assert.assertNotNull(cs.getListOfCols());
-    List<int[]> hiddenCols = cs.getListOfCols();
-    Assert.assertEquals(hiddenCols.size(), TEST_CS_HEIGHT);
-    Assert.assertEquals(hiddenCols.get(0), expectedColSel
-            .getListOfCols().get(0),
+
+    Iterator<int[]> it = cs.iterator();
+    Iterator<int[]> colselit = expectedColSel.iterator();
+    Assert.assertTrue(it.hasNext());
+    Assert.assertEquals(cs.getNumberOfRegions(), TEST_CS_HEIGHT);
+    Assert.assertEquals(it.next(), colselit.next(),
             "Mismatched hidden columns!");
   }
 
@@ -337,6 +317,58 @@ public class JSONFileTest
             "Zappo colour scheme expected!");
   }
 
+  /**
+   * Test for bug JAL-2489, NPE when exporting BioJSON with global colour
+   * scheme, and a group colour scheme, set as 'None'
+   */
+  @Test(groups = { "Functional" })
+  public void testBioJSONRoundTripWithColourSchemeNone()
+  {
+    AppletFormatAdapter formatAdapter = new AppletFormatAdapter();
+
+    Alignment _alignment;
+    try
+    {
+      // load example BioJSON file
+      _alignment = (Alignment) formatAdapter.readFile(TEST_JSON_FILE,
+              DataSourceType.FILE, FileFormat.Json);
+      JSONFile bioJsonFile = (JSONFile) formatAdapter.getAlignFile();
+      AlignFrame alignFrame = new AlignFrame(_alignment,
+              bioJsonFile.getHiddenSequences(),
+              bioJsonFile.getHiddenColumns(), AlignFrame.DEFAULT_WIDTH,
+              AlignFrame.DEFAULT_HEIGHT);
+
+      /*
+       * Create a group on the alignment;
+       * Change global and group colour scheme to 'None' and perform round trip
+       */
+      SequenceGroup sg = new SequenceGroup();
+      sg.addSequence(_alignment.getSequenceAt(0), false);
+      sg.setColourScheme(null);
+      ColourSchemeI cs = ColourSchemeMapper
+              .getJalviewColourScheme(ResidueColourScheme.NONE, _alignment);
+      alignFrame.changeColour(cs);
+      alignFrame.getViewport()
+              .setFeaturesDisplayed(bioJsonFile.getDisplayedFeatures());
+      formatAdapter = new AppletFormatAdapter(alignFrame.alignPanel,
+              exportSettings);
+      // export BioJSON string
+      String jsonOutput = formatAdapter.formatSequences(FileFormat.Json,
+              alignFrame.alignPanel.getAlignment(), false);
+      // read back Alignment from BioJSON string
+      formatAdapter = new AppletFormatAdapter();
+      formatAdapter.readFile(jsonOutput, DataSourceType.PASTE,
+              FileFormat.Json);
+      // assert 'None' colour scheme is retained after round trip
+      JSONFile _bioJsonFile = (JSONFile) formatAdapter.getAlignFile();
+      Assert.assertEquals(_bioJsonFile.getGlobalColourScheme(),
+              ResidueColourScheme.NONE);
+    } catch (IOException e)
+    {
+      e.printStackTrace();
+    }
+  }
+
   @Test(groups = { "Functional" })
   public void isShowSeqFeaturesSet()
   {
@@ -367,8 +399,9 @@ public class JSONFileTest
     for (AlignmentAnnotation annot : testAlignment.getAlignmentAnnotation())
     {
       AlignmentAnnotation expectedAnnot = expectedAnnots.get(annot.label);
-      AssertJUnit.assertTrue("Failed AlignmentAnnotation Test for >>> "
-              + annot.label, isAnnotationMatched(expectedAnnot, annot));
+      AssertJUnit.assertTrue(
+              "Failed AlignmentAnnotation Test for >>> " + annot.label,
+              isAnnotationMatched(expectedAnnot, annot));
       passedCount++;
     }
     AssertJUnit.assertEquals("Some Sequences did not pass the test",
@@ -400,13 +433,13 @@ public class JSONFileTest
     return true;
   }
 
-  public boolean isSeqMatched(SequenceI expectedSeq, SequenceI actualSeq)
+  boolean isSeqMatched(SequenceI expectedSeq, SequenceI actualSeq)
   {
     System.out.println("Testing >>> " + actualSeq.getName());
 
     if (expectedSeq.getName().equals(actualSeq.getName())
-            && expectedSeq.getSequenceAsString().equals(
-                    actualSeq.getSequenceAsString())
+            && expectedSeq.getSequenceAsString()
+                    .equals(actualSeq.getSequenceAsString())
             && expectedSeq.getStart() == actualSeq.getStart()
             && expectedSeq.getEnd() == actualSeq.getEnd()
             && featuresMatched(expectedSeq, actualSeq))
@@ -430,20 +463,25 @@ public class JSONFileTest
             + actualGrp.getIgnoreGapsConsensus());
     System.out.println(expectedGrp.getSequences().size() + " | "
             + actualGrp.getSequences().size());
-    System.out.println(expectedGrp.getStartRes() + " | "
-            + actualGrp.getStartRes());
-    System.out.println(expectedGrp.getEndRes() + " | "
-            + actualGrp.getEndRes());
-    System.out.println(expectedGrp.cs + " | " + actualGrp.cs);
-
+    System.out.println(
+            expectedGrp.getStartRes() + " | " + actualGrp.getStartRes());
+    System.out.println(
+            expectedGrp.getEndRes() + " | " + actualGrp.getEndRes());
+    System.out.println(expectedGrp.cs.getColourScheme() + " | "
+            + actualGrp.cs.getColourScheme());
+
+    boolean colourSchemeMatches = (expectedGrp.cs.getColourScheme() == null
+            && actualGrp.cs.getColourScheme() == null)
+            || expectedGrp.cs.getColourScheme().getClass()
+                    .equals(actualGrp.cs.getColourScheme().getClass());
     if (expectedGrp.getName().equals(actualGrp.getName())
             && expectedGrp.getColourText() == actualGrp.getColourText()
             && expectedGrp.getDisplayBoxes() == actualGrp.getDisplayBoxes()
             && expectedGrp.getIgnoreGapsConsensus() == actualGrp
                     .getIgnoreGapsConsensus()
-            && (expectedGrp.cs.getClass().equals(actualGrp.cs.getClass()))
-            && expectedGrp.getSequences().size() == actualGrp
-                    .getSequences().size()
+            && colourSchemeMatches
+            && expectedGrp.getSequences().size() == actualGrp.getSequences()
+                    .size()
             && expectedGrp.getStartRes() == actualGrp.getStartRes()
             && expectedGrp.getEndRes() == actualGrp.getEndRes())
     {
@@ -454,7 +492,6 @@ public class JSONFileTest
 
   private boolean featuresMatched(SequenceI seq1, SequenceI seq2)
   {
-    boolean matched = false;
     try
     {
       if (seq1 == null && seq2 == null)
@@ -462,51 +499,137 @@ public class JSONFileTest
         return true;
       }
 
-      SequenceFeature[] inFeature = seq1.getSequenceFeatures();
-      SequenceFeature[] outFeature = seq2.getSequenceFeatures();
+      List<SequenceFeature> inFeature = seq1.getFeatures().getAllFeatures();
+      List<SequenceFeature> outFeature = seq2.getFeatures()
+              .getAllFeatures();
 
-      if (inFeature == null && outFeature == null)
-      {
-        return true;
-      }
-      else if ((inFeature == null && outFeature != null)
-              || (inFeature != null && outFeature == null))
+      if (inFeature.size() != outFeature.size())
       {
+        System.err.println("Feature count in: " + inFeature.size()
+                + ", out: " + outFeature.size());
         return false;
       }
 
-      int testSize = inFeature.length;
-      int matchedCount = 0;
+      SequenceFeatures.sortFeatures(inFeature, true);
+      SequenceFeatures.sortFeatures(outFeature, true);
+      int i = 0;
       for (SequenceFeature in : inFeature)
       {
-        for (SequenceFeature out : outFeature)
+        SequenceFeature out = outFeature.get(i);
+        /*
+        System.out.println(out.getType() + " | " + in.getType());
+        System.out.println(out.getBegin() + " | " + in.getBegin());
+        System.out.println(out.getEnd() + " | " + in.getEnd());
+        */
+        if (!in.equals(out))
         {
-          System.out.println(out.getType() + " | " + in.getType());
-          System.out.println(out.getBegin() + " | " + in.getBegin());
-          System.out.println(out.getEnd() + " | " + in.getEnd());
-
-          if (inFeature.length == outFeature.length
-                  && in.getBegin() == out.getBegin()
-                  && in.getEnd() == out.getEnd()
-                  && in.getScore() == out.getScore()
-                  && in.getFeatureGroup().equals(out.getFeatureGroup())
-                  && in.getType().equals(out.getType()))
-          {
-
-            ++matchedCount;
-          }
+          System.err.println(
+                  "Mismatch of " + in.toString() + " " + out.toString());
+          return false;
         }
-      }
-      System.out.println("matched count >>>>>> " + matchedCount);
-      if (testSize == matchedCount)
-      {
-        matched = true;
+        /*
+                if (in.getBegin() == out.getBegin() && in.getEnd() == out.getEnd()
+                        && in.getScore() == out.getScore()
+                        && in.getFeatureGroup().equals(out.getFeatureGroup())
+                        && in.getType().equals(out.getType())
+                        && mapsMatch(in.otherDetails, out.otherDetails))
+                {
+                }
+                else
+                {
+                  System.err.println("Feature[" + i + "] mismatch, in: "
+                          + in.toString() + ", out: "
+                          + outFeature.get(i).toString());
+                  return false;
+                }
+                */
+        i++;
       }
     } catch (Exception e)
     {
       e.printStackTrace();
     }
     // System.out.println(">>>>>>>>>>>>>> features matched : " + matched);
-    return matched;
+    return true;
+  }
+
+  boolean mapsMatch(Map<String, Object> m1, Map<String, Object> m2)
+  {
+    if (m1 == null || m2 == null)
+    {
+      if (m1 != null || m2 != null)
+      {
+        System.err.println(
+                "only one SequenceFeature.otherDetails is not null");
+        return false;
+      }
+      else
+      {
+        return true;
+      }
+    }
+    if (m1.size() != m2.size())
+    {
+      System.err.println("otherDetails map different sizes");
+      return false;
+    }
+    for (String key : m1.keySet())
+    {
+      if (!m2.containsKey(key))
+      {
+        System.err.println(key + " in only one otherDetails");
+        return false;
+      }
+      if (m1.get(key) == null && m2.get(key) != null
+              || m1.get(key) != null && m2.get(key) == null
+              || !m1.get(key).equals(m2.get(key)))
+      {
+        System.err.println(key + " values in otherDetails don't match");
+        return false;
+      }
+    }
+    return true;
+  }
+
+  /**
+   * Test group roundtrip with null (None) group colour scheme
+   * 
+   * @throws IOException
+   */
+  @Test(groups = { "Functional" })
+  public void testGrpParsed_colourNone() throws IOException
+  {
+    AlignmentI copy = new Alignment(testAlignment);
+    SequenceGroup sg = testAlignment.getGroups().get(0);
+    SequenceGroup copySg = new SequenceGroup(new ArrayList<SequenceI>(),
+            sg.getName(), null, sg.getDisplayBoxes(), sg.getDisplayText(),
+            sg.getColourText(), sg.getStartRes(), sg.getEndRes());
+    for (SequenceI seq : sg.getSequences())
+    {
+      int seqIndex = testAlignment.findIndex(seq);
+      copySg.addSequence(copy.getSequenceAt(seqIndex), false);
+    }
+    copy.addGroup(copySg);
+
+    AlignFrame af = new AlignFrame(copy, copy.getWidth(), copy.getHeight());
+    AppletFormatAdapter formatAdapter = new AppletFormatAdapter(
+            af.alignPanel);
+    String jsonOutput = formatAdapter.formatSequences(FileFormat.Json, copy,
+            false);
+    formatAdapter = new AppletFormatAdapter();
+    AlignmentI newAlignment = formatAdapter.readFile(jsonOutput,
+            DataSourceType.PASTE, FileFormat.Json);
+
+    Assert.assertNotNull(newAlignment.getGroups());
+    for (SequenceGroup seqGrp : newAlignment.getGroups())
+    {
+      SequenceGroup expectedGrp = copySg;
+      AssertJUnit.assertTrue(
+              "Failed SequenceGroup Test for >>> " + seqGrp.getName(),
+              isGroupMatched(expectedGrp, seqGrp));
+      passedCount++;
+    }
+    AssertJUnit.assertEquals("Some SequenceGroups did not pass the test",
+            TEST_GRP_HEIGHT, passedCount);
   }
 }