X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fio%2FStockholmFileTest.java;h=00cbbb9bbf6a58e8d1a49aa9d591653ce3ad4ff8;hb=ab43013b7e357b84b4abade0dba949668dfb2a0e;hp=d826e13c2deadd4667276c0714086e8941b00e1b;hpb=6b6d90d341b2458d50cccbe61b6900d9a128c220;p=jalview.git diff --git a/test/jalview/io/StockholmFileTest.java b/test/jalview/io/StockholmFileTest.java index d826e13..00cbbb9 100644 --- a/test/jalview/io/StockholmFileTest.java +++ b/test/jalview/io/StockholmFileTest.java @@ -1,55 +1,77 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer (Version 2.8.2b1) + * Copyright (C) 2014 The Jalview Authors + * + * This file is part of Jalview. + * + * Jalview is free software: you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation, either version 3 + * of the License, or (at your option) any later version. + * + * Jalview is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty + * of MERCHANTABILITY or FITNESS FOR A PARTICULAR + * PURPOSE. See the GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Jalview. If not, see . + * The Jalview Authors are detailed in the 'AUTHORS' file. + */ package jalview.io; -import static org.junit.Assert.*; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; import jalview.datamodel.Alignment; import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; +import jalview.datamodel.Annotation; import jalview.datamodel.SequenceFeature; import jalview.datamodel.SequenceI; import java.io.File; -import java.io.IOException; -import java.io.InputStream; +import java.util.BitSet; +import java.util.HashMap; +import java.util.Map; import org.junit.Test; public class StockholmFileTest { - public static void main(String argv[]) - { - try { - new StockholmFileTest().pfamFileIO(); - - } catch (Exception x) - { - x.printStackTrace(); - } - } - static String PfamFile = "examples/PF00111_seed.stk", RfamFile = "examples/RF00031_folded.stk"; @Test public void pfamFileIO() 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()) + testFileIOwithFormat(new File(PfamFile), "STH", -1, 0); + } + + @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()) + { + if (sq.getPDBId() != null) { - if (sq.getPDBId()!=null) - { - numpdb+=sq.getPDBId().size(); - } + numpdb += sq.getPDBId().size(); } - assertTrue("PF00111 seed alignment has at least 1 PDB file, but the reader found none.",numpdb>0); + } + assertTrue( + "PF00111 seed alignment has at least 1 PDB file, but the reader found none.", + numpdb > 0); } + @Test public void rfamFileIO() throws Exception { - testFileIOwithFormat(new File(RfamFile), "STH"); + testFileIOwithFormat(new File(RfamFile), "STH", 2, 1); } /** @@ -62,7 +84,8 @@ public class StockholmFileTest * - label for IO class used to write and read back in the data from * f */ - public static void testFileIOwithFormat(File f, String ioformat) + public static void testFileIOwithFormat(File f, String ioformat, + int naliannot, int nminseqann) { System.out.println("Reading file: " + f); String ff = f.getPath(); @@ -81,7 +104,8 @@ public class StockholmFileTest al.getSequenceAt(i).setDatasetSequence(al.getSequenceAt(i)); } String outputfile = rf.formatSequences(ioformat, al, true); - System.out.println("Output file in '"+ioformat+"':\n"+outputfile+"\n< -1) + { + assertEquals("Number of alignment annotations", naliannot, + numaliannot); + } + + assertTrue( + "Number of sequence associated annotations wasn't at least " + + nminseqann, numsqswithali >= nminseqann); + } catch (Exception e) { e.printStackTrace(); @@ -112,7 +158,7 @@ public class StockholmFileTest * 'secondary' or generated alignment from some datapreserving * transformation */ - private static void testAlignmentEquivalence(AlignmentI al, + public static void testAlignmentEquivalence(AlignmentI al, AlignmentI al_input) { assertNotNull("Original alignment was null", al); @@ -136,16 +182,48 @@ public class StockholmFileTest // 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); + Map orig_groups = new HashMap(), new_groups = new HashMap(); if (aa_new != null && aa_original != null) { for (int i = 0; i < aa_original.length; i++) { - if (aa_new.length>i) { - assertTrue("Different alignment annotation ordering", - equalss(aa_original[i], aa_new[i])); - } else { - System.err.println("No matching annotation row for "+aa_original[i].toString()); + if (aa_new.length > i) + { + assertTrue("Different alignment annotation at position " + i, + equalss(aa_original[i], aa_new[i])); + // compare graphGroup or graph properties - needed to verify JAL-1299 + assertTrue("Graph type not identical.", + aa_original[i].graph == aa_new[i].graph); + assertTrue("Visibility not identical.", + aa_original[i].visible == aa_new[i].visible); + assertTrue( + "Threshold line not identical.", + aa_original[i].threshold == null ? aa_new[i].threshold == null + : aa_original[i].threshold + .equals(aa_new[i].threshold)); + // graphGroup may differ, but pattern should be the same + Integer o_ggrp = new Integer(aa_original[i].graphGroup + 2), n_ggrp = new Integer( + aa_new[i].graphGroup + 2); + BitSet orig_g = orig_groups.get(o_ggrp), new_g = new_groups + .get(n_ggrp); + if (orig_g == null) + { + orig_groups.put(o_ggrp, orig_g = new BitSet()); + } + if (new_g == null) + { + new_groups.put(n_ggrp, new_g = new BitSet()); + } + assertTrue("Graph Group pattern differs at annotation " + i, + orig_g.equals(new_g)); + orig_g.set(i); + new_g.set(i); + } + else + { + System.err.println("No matching annotation row for " + + aa_original[i].toString()); } } } @@ -212,7 +290,6 @@ public class StockholmFileTest .equals(sequenceFeatures_new[feat])); } } - // compare alignment annotation if (al.getSequenceAt(i).getAnnotation() != null && al_input.getSequenceAt(in).getAnnotation() != null) @@ -224,7 +301,7 @@ public class StockholmFileTest { annot_original = al.getSequenceAt(i).getAnnotation()[j]; annot_new = al_input.getSequenceAt(in).getAnnotation()[j]; - assertTrue("Different annotation", + assertTrue("Different annotation elements", equalss(annot_original, annot_new)); } } @@ -255,23 +332,28 @@ public class StockholmFileTest { 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); + System.err.println("Different lengths for annotation row elements: " + + 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) + 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.trim().equals( + an_new.displayCharacter.trim()) + || !("" + an_or.secondaryStructure).trim().equals( + ("" + an_new.secondaryStructure).trim()) + || (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()); + 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; } } @@ -282,7 +364,16 @@ 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())); + 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; } }