From b13f4cb3250a7cb9b6cc74e51db50c01477b647f Mon Sep 17 00:00:00 2001 From: Natasha Date: Mon, 17 Dec 2012 15:48:23 +0000 Subject: [PATCH] test for output a file in Stockholm format --- src/jalview/io/AppletFormatAdapter.java | 165 ++++++++++++++++++++++++++++++- 1 file changed, 164 insertions(+), 1 deletion(-) diff --git a/src/jalview/io/AppletFormatAdapter.java b/src/jalview/io/AppletFormatAdapter.java index a848555..b57b088 100755 --- 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. -- 1.7.10.2