X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fio%2FStockholmFileTest.java;h=fc2ffdaffd2187e3e1af4ad057c5e584575a2841;hb=3c2de0e2204842f88e58c1e8f5ef6251c99a84d5;hp=cac1a88fd6da0138c7e30471cf5e7b2c201379e7;hpb=1c1cbbbba95796cbd8aeea8db28633eb84aa61a4;p=jalview.git

diff --git a/test/jalview/io/StockholmFileTest.java b/test/jalview/io/StockholmFileTest.java
index cac1a88..fc2ffda 100644
--- a/test/jalview/io/StockholmFileTest.java
+++ b/test/jalview/io/StockholmFileTest.java
@@ -4,6 +4,7 @@ import static org.junit.Assert.*;
 import jalview.datamodel.Alignment;
 import jalview.datamodel.AlignmentAnnotation;
 import jalview.datamodel.AlignmentI;
+import jalview.datamodel.Annotation;
 import jalview.datamodel.SequenceFeature;
 import jalview.datamodel.SequenceI;
 
@@ -16,192 +17,260 @@ import org.junit.Test;
 public class StockholmFileTest
 {
 
-  public static void main(String argv[])
+  static String PfamFile = "examples/PF00111_seed.stk",
+          RfamFile = "examples/RF00031_folded.stk";
+
+  @Test
+  public void pfamFileIO() throws Exception
   {
-    try {
-      new StockholmFileTest().pfamFileIO();
-    
-    } catch (Exception x)
+    testFileIOwithFormat(new File(PfamFile), "STH");
+  }
+  @Test
+  public void pfamFileDataExtraction() throws Exception
+  {  AppletFormatAdapter af = new AppletFormatAdapter();
+    AlignmentI al = af.readFile(PfamFile, af.FILE,
+            new IdentifyFile().Identify(PfamFile, af.FILE));
+    int numpdb = 0;
+    for (SequenceI sq : al.getSequences())
     {
-      x.printStackTrace();
+      if (sq.getPDBId() != null)
+      {
+        numpdb += sq.getPDBId().size();
+      }
     }
+    assertTrue(
+            "PF00111 seed alignment has at least 1 PDB file, but the reader found none.",
+            numpdb > 0);
   }
-  static String PfamFile = "examples/PF00111_seed.stk";
 
   @Test
-  public void pfamFileIO() throws Exception
+  public void rfamFileIO() throws Exception
   {
-      test(new File(PfamFile));
-      AppletFormatAdapter af = new AppletFormatAdapter();
-      AlignmentI al = af.readFile(PfamFile, af.FILE, new IdentifyFile().Identify(PfamFile, af.FILE));
-      int numpdb=0;
-      for (SequenceI sq:al.getSequences())
-      {
-        if (sq.getPDBId()!=null)
-        {
-          numpdb+=sq.getPDBId().size();
-        }
-      }
-      assertTrue("PF00111 seed alignment has at least 1 PDB file, but the reader found none.",numpdb>0);
+    testFileIOwithFormat(new File(RfamFile), "STH");
   }
 
-  private void test(File f)
+  /**
+   * test alignment data in given file can be imported, exported and reimported
+   * with no dataloss
+   * 
+   * @param f
+   *          - source datafile (IdentifyFile.identify() should work with it)
+   * @param ioformat
+   *          - label for IO class used to write and read back in the data from
+   *          f
+   */
+  public static void testFileIOwithFormat(File f, String ioformat)
   {
     System.out.println("Reading file: " + f);
     String ff = f.getPath();
     try
     {
-      Alignment al = new AppletFormatAdapter().readFile(ff, AppletFormatAdapter.FILE,
+      AppletFormatAdapter rf = new AppletFormatAdapter();
+
+      Alignment al = rf.readFile(ff, AppletFormatAdapter.FILE,
               new IdentifyFile().Identify(ff, AppletFormatAdapter.FILE));
-      
+
+      assertNotNull("Couldn't read supplied alignment data.", al);
+
+      // make sure dataset is initialised ? not sure about this
       for (int i = 0; i < al.getSequencesArray().length; ++i)
       {
         al.getSequenceAt(i).setDatasetSequence(al.getSequenceAt(i));
       }
-      AlignFile stFile = new StockholmFile(al);
-      stFile.setSeqs(al.getSequencesArray());
+      String outputfile = rf.formatSequences(ioformat, al, true);
+      System.out.println("Output file in '"+ioformat+"':\n"+outputfile+"\n<<EOF\n");
+      // test for consistency in io
+      Alignment al_input = new AppletFormatAdapter().readFile(outputfile,
+              AppletFormatAdapter.PASTE, ioformat);
+      assertNotNull("Couldn't parse reimported alignment data.", al_input);
 
-      String stockholmoutput = stFile.print();
-      Alignment al_input = new AppletFormatAdapter().readFile(stockholmoutput,
-              AppletFormatAdapter.PASTE, "STH");
-      if (al != null && al_input != null)
+      String identifyoutput = new IdentifyFile().Identify(outputfile,
+              AppletFormatAdapter.PASTE);
+      assertNotNull("Identify routine failed for outputformat " + ioformat,
+              identifyoutput);
+      assertTrue(
+              "Identify routine could not recognise output generated by '"
+                      + ioformat + "' writer",
+              ioformat.equals(identifyoutput));
+      testAlignmentEquivalence(al, al_input);
+    } catch (Exception e)
+    {
+      e.printStackTrace();
+      assertTrue("Couln't format the alignment for output file.", false);
+    }
+  }
+
+  /**
+   * assert alignment equivalence
+   * 
+   * @param al
+   *          'original'
+   * @param al_input
+   *          'secondary' or generated alignment from some datapreserving
+   *          transformation
+   */
+  private static void testAlignmentEquivalence(AlignmentI al,
+          AlignmentI al_input)
+  {
+    assertNotNull("Original alignment was null", al);
+    assertNotNull("Generated alignment was null", al_input);
+
+    assertTrue(
+            "Alignment dimension mismatch: originl contains "
+                    + al.getHeight() + " and generated has "
+                    + al_input.getHeight() + " sequences; original has "
+                    + al.getWidth() + " and generated has "
+                    + al_input.getWidth() + " columns.",
+            al.getHeight() == al_input.getHeight()
+                    && al.getWidth() == al_input.getWidth());
+
+    // check Alignment annotation
+    AlignmentAnnotation[] aa_new = al_input.getAlignmentAnnotation();
+    AlignmentAnnotation[] aa_original = al.getAlignmentAnnotation();
+
+    // note - at moment we do not distinguish between alignment without any
+    // annotation rows and alignment with no annotation row vector
+    // we might want to revise this in future
+    int aa_new_size = (aa_new == null ? 0 : aa_new.length), aa_original_size = (aa_original == null ? 0
+            : aa_original.length);
+
+    if (aa_new != null && aa_original != null)
+    {
+      for (int i = 0; i < aa_original.length; i++)
       {
-        System.out.println("Alignment contains: " + al.getHeight()
-                + " and " + al_input.getHeight() + " sequences; "
-                + al.getWidth() + " and " + al_input.getWidth()
-                + " columns.");
-        AlignmentAnnotation[] aa_new = al_input.getAlignmentAnnotation();
-        AlignmentAnnotation[] aa_original = al.getAlignmentAnnotation();
-
-        // check Alignment annotation
-        if (aa_new != null && aa_original != null)
-        {
-          System.out.println("Alignment contains: " + aa_new.length
-                  + "  and " + aa_original.length
-                  + " alignment annotation(s)");
-          for (int i = 0; i < aa_original.length; i++)
-          {
-            assertTrue("Different alignment annotation",equalss(aa_original[i], aa_new[i]));
-              
-          }
+        if (aa_new.length>i) {
+          assertTrue("Different alignment annotation at position "+i,
+                equalss(aa_original[i], aa_new[i]));
+        } else {
+          System.err.println("No matching annotation row for "+aa_original[i].toString());
         }
+      }
+    }
+    assertTrue(
+            "Generated and imported alignment have different annotation sets ("
+                    + aa_new_size + " != " + aa_original_size + ")",
+            aa_new_size == aa_original_size);
 
-        // check sequences, annotation and features
-        SequenceI[] seq_original = new SequenceI[al.getSequencesArray().length];
-        seq_original = al.getSequencesArray();
-        SequenceI[] seq_new = new SequenceI[al_input.getSequencesArray().length];
-        seq_new = al_input.getSequencesArray();
-        SequenceFeature[] sequenceFeatures_original, sequenceFeatures_new;
-        AlignmentAnnotation annot_original, annot_new;
-        //
-        for (int i = 0; i < al.getSequencesArray().length; i++)
+    // check sequences, annotation and features
+    SequenceI[] seq_original = new SequenceI[al.getSequencesArray().length];
+    seq_original = al.getSequencesArray();
+    SequenceI[] seq_new = new SequenceI[al_input.getSequencesArray().length];
+    seq_new = al_input.getSequencesArray();
+    SequenceFeature[] sequenceFeatures_original, sequenceFeatures_new;
+    AlignmentAnnotation annot_original, annot_new;
+    //
+    for (int i = 0; i < al.getSequencesArray().length; i++)
+    {
+      String name = seq_original[i].getName();
+      int start = seq_original[i].getStart();
+      int end = seq_original[i].getEnd();
+      System.out.println("Check sequence: " + name + "/" + start + "-"
+              + end);
+
+      // search equal sequence
+      for (int in = 0; in < al_input.getSequencesArray().length; in++)
+      {
+        if (name.equals(seq_new[in].getName())
+                && start == seq_new[in].getStart()
+                && end == seq_new[in].getEnd())
         {
-          String name = seq_original[i].getName();
-          int start = seq_original[i].getStart();
-          int end = seq_original[i].getEnd();
-          System.out.println("Check sequence: " + name + "/" + start + "-"
-                  + end);
-
-          // search equal sequence
-          for (int in = 0; in < al_input.getSequencesArray().length; in++)
+          String ss_original = seq_original[i].getSequenceAsString();
+          String ss_new = seq_new[in].getSequenceAsString();
+          assertTrue("The sequences " + name + "/" + start + "-" + end
+                  + " are not equal", ss_original.equals(ss_new));
+
+          assertTrue(
+                  "Sequence Features were not equivalent",
+                  (seq_original[i].getSequenceFeatures() == null && seq_new[in]
+                          .getSequenceFeatures() == null)
+                          || (seq_original[i].getSequenceFeatures() != null && seq_new[in]
+                                  .getSequenceFeatures() != null));
+          // compare sequence features
+          if (seq_original[i].getSequenceFeatures() != null
+                  && seq_new[in].getSequenceFeatures() != null)
           {
-            if (name.equals(seq_new[in].getName())
-                    && start == seq_new[in].getStart()
-                    && end == seq_new[in].getEnd())
+            System.out.println("There are feature!!!");
+            sequenceFeatures_original = new SequenceFeature[seq_original[i]
+                    .getSequenceFeatures().length];
+            sequenceFeatures_original = seq_original[i]
+                    .getSequenceFeatures();
+            sequenceFeatures_new = new SequenceFeature[seq_new[in]
+                    .getSequenceFeatures().length];
+            sequenceFeatures_new = seq_new[in].getSequenceFeatures();
+
+            assertTrue("different number of features", seq_original[i]
+                    .getSequenceFeatures().length == seq_new[in]
+                    .getSequenceFeatures().length);
+
+            for (int feat = 0; feat < seq_original[i].getSequenceFeatures().length; feat++)
             {
-              String ss_original = seq_original[i].getSequenceAsString();
-              String ss_new = seq_new[in].getSequenceAsString();
-              assertTrue("The sequences " + name + "/" + start
-                      + "-" + end + " are not equal", ss_original.equals(ss_new));
-              
-              assertTrue("Sequence Features were not equivalent", (seq_original[i].getSequenceFeatures()==null && seq_new[in].getSequenceFeatures()==null) || (seq_original[i].getSequenceFeatures()!=null && seq_new[in].getSequenceFeatures()!=null));
-              // compare sequence features
-              if (seq_original[i].getSequenceFeatures() != null
-                      && seq_new[in].getSequenceFeatures() != null)
-              {
-                System.out.println("There are feature!!!");
-                sequenceFeatures_original = new SequenceFeature[seq_original[i]
-                        .getSequenceFeatures().length];
-                sequenceFeatures_original = seq_original[i]
-                        .getSequenceFeatures();
-                sequenceFeatures_new = new SequenceFeature[seq_new[in]
-                        .getSequenceFeatures().length];
-                sequenceFeatures_new = seq_new[in].getSequenceFeatures();
-
-                assertTrue("different number of features", seq_original[i].getSequenceFeatures().length == seq_new[in]
-                        .getSequenceFeatures().length);
-                
-                for (int feat = 0; feat < seq_original[i]
-                        .getSequenceFeatures().length; feat++)
-                {
-                  assertTrue("Different features",sequenceFeatures_original[feat]
-                          .equals(sequenceFeatures_new[feat]));
-                }
-              }
+              assertTrue("Different features",
+                      sequenceFeatures_original[feat]
+                              .equals(sequenceFeatures_new[feat]));
+            }
+          }
 
-              // compare alignment annotation
-              if (al.getSequenceAt(i).getAnnotation() != null
-                      && al_input.getSequenceAt(in).getAnnotation() != null)
-              {
-                for (int j = 0; j < al.getSequenceAt(i).getAnnotation().length; j++)
-                {
-                  if (al.getSequenceAt(i).getAnnotation()[j] != null
-                          && al_input.getSequenceAt(in).getAnnotation()[j] != null)
-                  {
-                    annot_original = al.getSequenceAt(i).getAnnotation()[j];
-                    annot_new = al_input.getSequenceAt(in).getAnnotation()[j];
-                    assertTrue("Different annotation", equalss(annot_original, annot_new));
-                  }
-                }
-              }
-              else if (al.getSequenceAt(i).getAnnotation() == null
-                      && al_input.getSequenceAt(in).getAnnotation() == null)
-              {
-                System.out.println("No annotations");
-              }
-              else if (al.getSequenceAt(i).getAnnotation() != null
-                      && al_input.getSequenceAt(in).getAnnotation() == null)
+          // compare alignment annotation
+          if (al.getSequenceAt(i).getAnnotation() != null
+                  && al_input.getSequenceAt(in).getAnnotation() != null)
+          {
+            for (int j = 0; j < al.getSequenceAt(i).getAnnotation().length; j++)
+            {
+              if (al.getSequenceAt(i).getAnnotation()[j] != null
+                      && al_input.getSequenceAt(in).getAnnotation()[j] != null)
               {
-                assertTrue("Annotations differed between sequences ("+al.getSequenceAt(i).getName()+") and ("+al_input.getSequenceAt(i).getName()+")", false);
+                annot_original = al.getSequenceAt(i).getAnnotation()[j];
+                annot_new = al_input.getSequenceAt(in).getAnnotation()[j];
+                assertTrue("Different annotation",
+                        equalss(annot_original, annot_new));
               }
-              break;
             }
           }
+          else if (al.getSequenceAt(i).getAnnotation() == null
+                  && al_input.getSequenceAt(in).getAnnotation() == null)
+          {
+            System.out.println("No annotations");
+          }
+          else if (al.getSequenceAt(i).getAnnotation() != null
+                  && al_input.getSequenceAt(in).getAnnotation() == null)
+          {
+            assertTrue("Annotations differed between sequences ("
+                    + al.getSequenceAt(i).getName() + ") and ("
+                    + al_input.getSequenceAt(i).getName() + ")", false);
+          }
+          break;
         }
       }
-      else
-      {
-        assertTrue("Couldn't read alignment", false);
-      }
-    } catch (Exception e)
-    {
-      e.printStackTrace();
-      assertTrue("Couln't format the alignment for output file.", false);
     }
   }
 
   /*
    * compare annotations
    */
-  private boolean equalss(AlignmentAnnotation annot_or,
+  private static boolean equalss(AlignmentAnnotation annot_or,
           AlignmentAnnotation annot_new)
   {
     if (annot_or.annotations.length != annot_new.annotations.length)
     {
+      System.err.println("Different lengths for annotation row elements: "+annot_or.annotations.length +"!="+ annot_new.annotations.length);
       return false;
     }
+    // TODO: does not compare graphGroup or graph properties
+    // TODO: does not compare visibility
     for (int i = 0; i < annot_or.annotations.length; i++)
     {
-      if (annot_or.annotations[i] != null
-              && annot_new.annotations[i] != null)
+      Annotation an_or=annot_or.annotations[i],an_new=annot_new.annotations[i];
+      if (an_or != null
+              && an_new!= null)
       {
-        // Jim's comment - shouldn't the conditional here be using || not && for all these clauses ?
-        if (!annot_or.annotations[i].displayCharacter
-                .equals(annot_new.annotations[i].displayCharacter)
-                && annot_or.annotations[i].secondaryStructure != annot_new.annotations[i].secondaryStructure
-                && !annot_or.annotations[i].description
-                        .equals(annot_new.annotations[i].description))
+        if (!an_or.displayCharacter
+                .equals(an_new.displayCharacter)
+                || an_or.secondaryStructure != an_new.secondaryStructure
+                || (an_or.description != an_new.description && (an_or.description == null
+                        || an_new.description == null || !an_or.description
+                          .equals(an_new.description))))
         {
+          System.err.println("Annotation Element Mismatch\nElement "+i+" in original: "+annot_or.annotations[i].toString()+"\nElement "+i+" in new: "+annot_new.annotations[i].toString());
           return false;
         }
       }
@@ -212,6 +281,7 @@ public class StockholmFileTest
       }
       else
       {
+        System.err.println("Annotation Element Mismatch\nElement "+i+" in original: "+(annot_or.annotations[i]==null ? "is null" : annot_or.annotations[i].toString())+"\nElement "+i+" in new: "+(annot_new.annotations[i] == null ? "is null" : annot_new.annotations[i].toString()));
         return false;
       }
     }