X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fio%2FStockholmFileTest.java;h=035f4843d099b6c3c73a5c4f224ddbe386f0cb97;hb=37de9310bec3501cbc6381e0c3dcb282fcaad812;hp=a0c9336bad4fab4d651b5bef781f77314d5bb48c;hpb=323663120848253cb367f13d7e470790ec451219;p=jalview.git diff --git a/test/jalview/io/StockholmFileTest.java b/test/jalview/io/StockholmFileTest.java index a0c9336..035f484 100644 --- a/test/jalview/io/StockholmFileTest.java +++ b/test/jalview/io/StockholmFileTest.java @@ -1,8 +1,30 @@ +/* + * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$) + * Copyright (C) $$Year-Rel$$ 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.assertNotNull; -import static org.junit.Assert.assertTrue; -import jalview.datamodel.Alignment; +import static org.testng.AssertJUnit.assertEquals; +import static org.testng.AssertJUnit.assertNotNull; +import static org.testng.AssertJUnit.assertTrue; +import static org.testng.AssertJUnit.fail; + import jalview.datamodel.AlignmentAnnotation; import jalview.datamodel.AlignmentI; import jalview.datamodel.Annotation; @@ -14,7 +36,7 @@ import java.util.BitSet; import java.util.HashMap; import java.util.Map; -import org.junit.Test; +import org.testng.annotations.Test; public class StockholmFileTest { @@ -22,22 +44,24 @@ public class StockholmFileTest static String PfamFile = "examples/PF00111_seed.stk", RfamFile = "examples/RF00031_folded.stk"; - @Test + @Test(groups = { "Functional" }) public void pfamFileIO() throws Exception { - testFileIOwithFormat(new File(PfamFile), "STH"); + testFileIOwithFormat(new File(PfamFile), "STH", -1, 0); } - @Test + + @Test(groups = { "Functional" }) public void pfamFileDataExtraction() throws Exception - { AppletFormatAdapter af = new AppletFormatAdapter(); + { + AppletFormatAdapter af = new AppletFormatAdapter(); AlignmentI al = af.readFile(PfamFile, af.FILE, - new IdentifyFile().Identify(PfamFile, af.FILE)); + new IdentifyFile().identify(PfamFile, af.FILE)); int numpdb = 0; for (SequenceI sq : al.getSequences()) { - if (sq.getPDBId() != null) + if (sq.getAllPDBEntries() != null) { - numpdb += sq.getPDBId().size(); + numpdb += sq.getAllPDBEntries().size(); } } assertTrue( @@ -45,10 +69,10 @@ public class StockholmFileTest numpdb > 0); } - @Test + @Test(groups = { "Functional" }) public void rfamFileIO() throws Exception { - testFileIOwithFormat(new File(RfamFile), "STH"); + testFileIOwithFormat(new File(RfamFile), "STH", 2, 1); } /** @@ -61,7 +85,9 @@ 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(); @@ -69,24 +95,25 @@ public class StockholmFileTest { AppletFormatAdapter rf = new AppletFormatAdapter(); - Alignment al = rf.readFile(ff, AppletFormatAdapter.FILE, - new IdentifyFile().Identify(ff, AppletFormatAdapter.FILE)); + AlignmentI 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)); + al.getSequenceAt(i).createDatasetSequence(); } 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(); @@ -110,19 +159,18 @@ public class StockholmFileTest * @param al_input * 'secondary' or generated alignment from some datapreserving * transformation + * @param ignoreFeatures + * when true, differences in sequence feature annotation are ignored */ public static void testAlignmentEquivalence(AlignmentI al, - AlignmentI al_input) + AlignmentI al_input, boolean ignoreFeatures) { 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.", + assertTrue("Alignment dimension mismatch: original: " + al.getHeight() + + "x" + al.getWidth() + ", generated: " + al_input.getHeight() + + "x" + al_input.getWidth(), al.getHeight() == al_input.getHeight() && al.getWidth() == al_input.getWidth()); @@ -133,40 +181,54 @@ public class StockholmFileTest // 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); - Map orig_groups=new HashMap(),new_groups=new HashMap(); + int aa_new_size = (aa_new == null ? 0 : aa_new.length); + int aa_original_size = (aa_original == null ? 0 : aa_original.length); + Map orig_groups = new HashMap(); + Map 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 at position "+i, - 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])); // 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); + assertEquals("Graph type not identical.", aa_original[i].graph, + aa_new[i].graph); + assertEquals("Visibility not identical.", aa_original[i].visible, + aa_new[i].visible); + assertEquals("Threshold line not identical.", + aa_original[i].threshold, 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()); + Integer o_ggrp = new Integer(aa_original[i].graphGroup + 2); + Integer n_ggrp = new Integer(aa_new[i].graphGroup + 2); + BitSet orig_g = orig_groups.get(o_ggrp); + BitSet 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()); + 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()); + assertEquals("Graph Group pattern differs at annotation " + i, + orig_g, new_g); + orig_g.set(i); + new_g.set(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); + assertEquals( + "Generated and imported alignment have different annotation sets", + aa_original_size, aa_new_size); // check sequences, annotation and features SequenceI[] seq_original = new SequenceI[al.getSequencesArray().length]; @@ -193,13 +255,15 @@ public class StockholmFileTest { 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)); + assertEquals("The sequences " + name + "/" + start + "-" + end + + " are not equal", ss_original, ss_new); assertTrue( - "Sequence Features were not equivalent", - (seq_original[i].getSequenceFeatures() == null && seq_new[in] - .getSequenceFeatures() == null) + "Sequence Features were not equivalent" + + (ignoreFeatures ? " ignoring." : ""), + ignoreFeatures + || (seq_original[i].getSequenceFeatures() == null && seq_new[in] + .getSequenceFeatures() == null) || (seq_original[i].getSequenceFeatures() != null && seq_new[in] .getSequenceFeatures() != null)); // compare sequence features @@ -215,15 +279,15 @@ public class StockholmFileTest .getSequenceFeatures().length]; sequenceFeatures_new = seq_new[in].getSequenceFeatures(); - assertTrue("different number of features", seq_original[i] - .getSequenceFeatures().length == seq_new[in] - .getSequenceFeatures().length); + assertEquals("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])); + assertEquals("Different features", + sequenceFeatures_original[feat], + sequenceFeatures_new[feat]); } } // compare alignment annotation @@ -250,9 +314,9 @@ public class StockholmFileTest else if (al.getSequenceAt(i).getAnnotation() != null && al_input.getSequenceAt(in).getAnnotation() == null) { - assertTrue("Annotations differed between sequences (" + fail("Annotations differed between sequences (" + al.getSequenceAt(i).getName() + ") and (" - + al_input.getSequenceAt(i).getName() + ")", false); + + al_input.getSequenceAt(i).getName() + ")"); } break; } @@ -268,23 +332,30 @@ 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++) { - Annotation an_or=annot_or.annotations[i],an_new=annot_new.annotations[i]; - if (an_or != null - && an_new!= null) + Annotation an_or = annot_or.annotations[i], an_new = annot_new.annotations[i]; + if (an_or != null && an_new != null) { - 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)))) + 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 + .trim().length() == 0) + || (an_new.description == null && an_or.description + .trim().length() == 0) || an_or.description + .trim().equals(an_new.description.trim())))) { - 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; } } @@ -295,7 +366,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; } }