test for output a file in Stockholm format

diff --git a/src/jalview/io/AppletFormatAdapter.java b/src/jalview/io/AppletFormatAdapter.java
index a848555..b57b088 100755 (executable)
--- a/src/jalview/io/AppletFormatAdapter.java
+++ b/src/jalview/io/AppletFormatAdapter.java
@@ -502,6 +502,14 @@ public class AppletFormatAdapter
         {
           System.out.println("Reading file: " + f);
           AppletFormatAdapter afa = new AppletFormatAdapter();
+          String fName = f.getName();
+          String extension = fName.substring(fName.lastIndexOf(".") + 1, fName.length());
+          if (extension.equals("stk") || extension.equals("sto"))
+          {  
+                 afa.test(f);
+          }
+          else
+          {
           Runtime r = Runtime.getRuntime();
           System.gc();
           long memf = -r.totalMemory() + r.freeMemory();
@@ -534,12 +542,13 @@ public class AppletFormatAdapter
           System.out
                   .println("Difference between free memory now and before is "
                           + (memf / (1024.0 * 1024.0) * 1.0) + " MB");
-
+          }
         } catch (Exception e)
         {
           System.err.println("Exception when dealing with " + i
                   + "'th argument: " + args[i] + "\n" + e);
         }
+     
       }
       else
       {
@@ -550,6 +559,160 @@ public class AppletFormatAdapter
     }
   }
 
+  private void test(File f) {
+               System.out.println("Reading file: " + f);
+           String ff = f.getPath();
+               try 
+               {
+                 Alignment al = readFile(ff, FILE, new IdentifyFile().Identify(ff, FILE));
+             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 stockholmoutput = stFile.print();
+             Alignment al_input = readFile(stockholmoutput, AppletFormatAdapter.PASTE, "STH");
+             if (al != null && al_input!= null) 
+             {
+               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++)
+                 {
+                   if (!equalss(aa_original[i], aa_new[i]))
+                       System.out.println("Different alignment annotation");
+                 }
+               }
+               
+               // 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 ss_original = seq_original[i].getSequenceAsString();
+                     String ss_new = seq_new[in].getSequenceAsString();
+                     if (!ss_original.equals(ss_new))
+                     {
+                       System.out.println("The sequences " + name + "/" + start + "-" + end + " are not equal");
+                     } 
+            
+                         // 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();
+                           
+                           if (seq_original[i].getSequenceFeatures().length == seq_new[in].getSequenceFeatures().length) 
+                           {
+                              for (int feat = 0; feat < seq_original[i].getSequenceFeatures().length; feat++) {
+                            if (!sequenceFeatures_original[feat].equals(sequenceFeatures_new[feat])) {
+                              System.out.println("Different features");
+                              break;
+                            }
+                          }
+                       } else
+                       {
+                               System.out.println("different number of features");
+                       }
+                     } else if (seq_original[i].getSequenceFeatures() == null && seq_new[in].getSequenceFeatures() == null)
+                     {
+                         System.out.println("No sequence features");
+                     } else if (seq_original[i].getSequenceFeatures() != null && seq_new[in].getSequenceFeatures() == null) 
+                     {
+                       System.out.println("Coudn't compare sequence features new one");
+                     }
+                           // 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];
+                           if (!equalss(annot_original, annot_new))
+                             System.out.println("Different annotation");  
+                         } 
+                       }
+                     } 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)
+                     {
+                         System.out.println("Coudn't compare annotations new one"); 
+                     }
+                     break;
+                   }
+                 }     
+               }
+             } else 
+             {
+               System.out.println("Couldn't read alignment");
+             }
+           } catch (Exception e)
+           {
+             System.err.println("Couln't format the alignment for output file.");
+             e.printStackTrace(System.err);
+           }
+         }
+
+         /*
+          * compare annotations
+          */
+          private boolean equalss(AlignmentAnnotation annot_or, AlignmentAnnotation annot_new)
+          {
+                  if (annot_or.annotations.length != annot_new.annotations.length) 
+                  {
+                    return false; 
+                  }
+                  for (int i = 0; i < annot_or.annotations.length; i++)
+                  {
+                    if (annot_or.annotations[i] != null && annot_new.annotations[i] != null)
+                    {
+                  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)) 
+                  {
+                    return false;
+                  }      
+                    } else if (annot_or.annotations[i] == null && annot_new.annotations[i] == null) 
+                    {
+                      continue; 
+                    } else 
+                    {
+                      return false;  
+                    }
+                  }
+                  return true;
+          }
   /**
    * try to discover how to access the given file as a valid datasource that
    * will be identified as the given type.