test/jalview/io/FeaturesFileTest.java

   1 /*
   2  * Jalview - A Sequence Alignment Editor and Viewer ($$Version-Rel$$)
   3  * Copyright (C) $$Year-Rel$$ The Jalview Authors
   4  *
   5  * This file is part of Jalview.
   6  *
   7  * Jalview is free software: you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation, either version 3
  10  * of the License, or (at your option) any later version.
  11  *
  12  * Jalview is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty
  14  * of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE.  See the GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with Jalview.  If not, see <http://www.gnu.org/licenses/>.
  19  * The Jalview Authors are detailed in the 'AUTHORS' file.
  20  */
  21 package jalview.io;
  22
  23 import static org.testng.AssertJUnit.assertEquals;
  24 import static org.testng.AssertJUnit.assertFalse;
  25 import static org.testng.AssertJUnit.assertNotNull;
  26 import static org.testng.AssertJUnit.assertNull;
  27 import static org.testng.AssertJUnit.assertTrue;
  28
  29 import jalview.api.FeatureColourI;
  30 import jalview.api.FeatureRenderer;
  31 import jalview.datamodel.Alignment;
  32 import jalview.datamodel.AlignmentI;
  33 import jalview.datamodel.SequenceDummy;
  34 import jalview.datamodel.SequenceFeature;
  35 import jalview.datamodel.SequenceI;
  36 import jalview.gui.AlignFrame;
  37
  38 import java.awt.Color;
  39 import java.io.File;
  40 import java.io.IOException;
  41 import java.util.Map;
  42
  43 import org.testng.annotations.Test;
  44
  45 public class FeaturesFileTest
  46 {
  47
  48   private static String simpleGffFile = "examples/testdata/simpleGff3.gff";
  49
  50   @Test(groups = { "Functional" })
  51   public void testParse() throws Exception
  52   {
  53     File f = new File("examples/uniref50.fa");
  54     AlignmentI al = readAlignmentFile(f);
  55     AlignFrame af = new AlignFrame(al, 500, 500);
  56     Map<String, FeatureColourI> colours = af.getFeatureRenderer()
  57             .getFeatureColours();
  58     FeaturesFile featuresFile = new FeaturesFile(
  59             "examples/exampleFeatures.txt", FormatAdapter.FILE);
  60     assertTrue("Test " + "Features file test"
  61             + "\nFailed to parse features file.",
  62             featuresFile.parse(al.getDataset(), colours, true));
  63
  64     /*
  65      * Refetch the colour map from the FeatureRenderer (to confirm it has been
  66      * updated - JAL-1904), and verify (some) feature group colours
  67      */
  68     colours = af.getFeatureRenderer().getFeatureColours();
  69     assertEquals("26 feature group colours not found", 26, colours.size());
  70     assertEquals(colours.get("Cath").getColour(), new Color(0x93b1d1));
  71     assertEquals(colours.get("ASX-MOTIF").getColour(), new Color(0x6addbb));
  72
  73     /*
  74      * verify (some) features on sequences
  75      */
  76     SequenceFeature[] sfs = al.getSequenceAt(0).getDatasetSequence()
  77             .getSequenceFeatures(); // FER_CAPAA
  78     assertEquals(8, sfs.length);
  79     SequenceFeature sf = sfs[0];
  80     assertEquals("Pfam family%LINK%", sf.description);
  81     assertEquals(0, sf.begin);
  82     assertEquals(0, sf.end);
  83     assertEquals("uniprot", sf.featureGroup);
  84     assertEquals("Pfam", sf.type);
  85     assertEquals(1, sf.links.size());
  86     assertEquals("Pfam family|http://pfam.xfam.org/family/PF00111",
  87             sf.links.get(0));
  88
  89     sf = sfs[1];
  90     assertEquals("Iron-sulfur (2Fe-2S)", sf.description);
  91     assertEquals(39, sf.begin);
  92     assertEquals(39, sf.end);
  93     assertEquals("uniprot", sf.featureGroup);
  94     assertEquals("METAL", sf.type);
  95     sf = sfs[2];
  96     assertEquals("Iron-sulfur (2Fe-2S)", sf.description);
  97     assertEquals(44, sf.begin);
  98     assertEquals(44, sf.end);
  99     assertEquals("uniprot", sf.featureGroup);
 100     assertEquals("METAL", sf.type);
 101     sf = sfs[3];
 102     assertEquals("Iron-sulfur (2Fe-2S)", sf.description);
 103     assertEquals(47, sf.begin);
 104     assertEquals(47, sf.end);
 105     assertEquals("uniprot", sf.featureGroup);
 106     assertEquals("METAL", sf.type);
 107     sf = sfs[4];
 108     assertEquals("Iron-sulfur (2Fe-2S)", sf.description);
 109     assertEquals(77, sf.begin);
 110     assertEquals(77, sf.end);
 111     assertEquals("uniprot", sf.featureGroup);
 112     assertEquals("METAL", sf.type);
 113     sf = sfs[5];
 114     assertEquals("Fer2 Status: True Positive Pfam 8_8%LINK%",
 115             sf.description);
 116     assertEquals("Pfam 8_8|http://pfam.xfam.org/family/PF00111",
 117             sf.links.get(0));
 118     assertEquals(8, sf.begin);
 119     assertEquals(83, sf.end);
 120     assertEquals("uniprot", sf.featureGroup);
 121     assertEquals("Pfam", sf.type);
 122     sf = sfs[6];
 123     assertEquals("Ferredoxin_fold Status: True Positive ", sf.description);
 124     assertEquals(3, sf.begin);
 125     assertEquals(93, sf.end);
 126     assertEquals("uniprot", sf.featureGroup);
 127     assertEquals("Cath", sf.type);
 128     sf = sfs[7];
 129     assertEquals(
 130             "High confidence server. Only hits with scores over 0.8 are reported. PHOSPHORYLATION (T) 89_8%LINK%",
 131             sf.description);
 132     assertEquals(
 133             "PHOSPHORYLATION (T) 89_8|http://www.cbs.dtu.dk/cgi-bin/proview/webface-link?seqid=P83527&amp;service=NetPhos-2.0",
 134             sf.links.get(0));
 135     assertEquals(89, sf.begin);
 136     assertEquals(89, sf.end);
 137     assertEquals("netphos", sf.featureGroup);
 138     assertEquals("PHOSPHORYLATION (T)", sf.type);
 139   }
 140
 141   /**
 142    * Test parsing a features file with a mix of Jalview and GFF formatted
 143    * content
 144    *
 145    * @throws Exception
 146    */
 147   @Test(groups = { "Functional" })
 148   public void testParse_mixedJalviewGff() throws Exception
 149   {
 150     File f = new File("examples/uniref50.fa");
 151     AlignmentI al = readAlignmentFile(f);
 152     AlignFrame af = new AlignFrame(al, 500, 500);
 153     Map<String, FeatureColourI> colours = af.getFeatureRenderer()
 154             .getFeatureColours();
 155     // GFF2 uses space as name/value separator in column 9
 156     String gffData = "METAL\tcc9900\n" + "GFF\n"
 157             + "FER_CAPAA\tuniprot\tMETAL\t44\t45\t4.0\t.\t.\tNote Iron-sulfur; Note 2Fe-2S\n"
 158             + "FER1_SOLLC\tuniprot\tPfam\t55\t130\t2.0\t.\t.";
 159     FeaturesFile featuresFile = new FeaturesFile(gffData,
 160             FormatAdapter.PASTE);
 161     assertTrue("Failed to parse features file",
 162             featuresFile.parse(al.getDataset(), colours, true));
 163
 164     // verify colours read or synthesized
 165     colours = af.getFeatureRenderer().getFeatureColours();
 166     assertEquals("1 feature group colours not found", 1, colours.size());
 167     assertEquals(colours.get("METAL").getColour(), new Color(0xcc9900));
 168
 169     // verify feature on FER_CAPAA
 170     SequenceFeature[] sfs = al.getSequenceAt(0).getDatasetSequence()
 171             .getSequenceFeatures();
 172     assertEquals(1, sfs.length);
 173     SequenceFeature sf = sfs[0];
 174     assertEquals("Iron-sulfur,2Fe-2S", sf.description);
 175     assertEquals(44, sf.begin);
 176     assertEquals(45, sf.end);
 177     assertEquals("uniprot", sf.featureGroup);
 178     assertEquals("METAL", sf.type);
 179     assertEquals(4f, sf.getScore(), 0.001f);
 180
 181     // verify feature on FER1_SOLLC
 182     sfs = al.getSequenceAt(2).getDatasetSequence().getSequenceFeatures();
 183     assertEquals(1, sfs.length);
 184     sf = sfs[0];
 185     assertEquals("uniprot", sf.description);
 186     assertEquals(55, sf.begin);
 187     assertEquals(130, sf.end);
 188     assertEquals("uniprot", sf.featureGroup);
 189     assertEquals("Pfam", sf.type);
 190     assertEquals(2f, sf.getScore(), 0.001f);
 191   }
 192
 193   public static AlignmentI readAlignmentFile(File f) throws IOException
 194   {
 195     System.out.println("Reading file: " + f);
 196     String ff = f.getPath();
 197     FormatAdapter rf = new FormatAdapter();
 198
 199     AlignmentI al = rf.readFile(ff, FormatAdapter.FILE,
 200             new IdentifyFile().identify(ff, FormatAdapter.FILE));
 201
 202     al.setDataset(null); // creates dataset sequences
 203     assertNotNull("Couldn't read supplied alignment data.", al);
 204     return al;
 205   }
 206
 207   /**
 208    * Test parsing a features file with GFF formatted content only
 209    *
 210    * @throws Exception
 211    */
 212   @Test(groups = { "Functional" })
 213   public void testParse_pureGff3() throws Exception
 214   {
 215     File f = new File("examples/uniref50.fa");
 216     AlignmentI al = readAlignmentFile(f);
 217     AlignFrame af = new AlignFrame(al, 500, 500);
 218     Map<String, FeatureColourI> colours = af.getFeatureRenderer()
 219             .getFeatureColours();
 220     // GFF3 uses '=' separator for name/value pairs in colum 9
 221     String gffData = "##gff-version 3\n"
 222             + "FER_CAPAA\tuniprot\tMETAL\t39\t39\t0.0\t.\t.\t"
 223             + "Note=Iron-sulfur (2Fe-2S);Note=another note;evidence=ECO:0000255|PROSITE-ProRule:PRU00465\n"
 224             + "FER1_SOLLC\tuniprot\tPfam\t55\t130\t3.0\t.\t.\tID=$23";
 225     FeaturesFile featuresFile = new FeaturesFile(gffData,
 226             FormatAdapter.PASTE);
 227     assertTrue("Failed to parse features file",
 228             featuresFile.parse(al.getDataset(), colours, true));
 229
 230     // verify feature on FER_CAPAA
 231     SequenceFeature[] sfs = al.getSequenceAt(0).getDatasetSequence()
 232             .getSequenceFeatures();
 233     assertEquals(1, sfs.length);
 234     SequenceFeature sf = sfs[0];
 235     // description parsed from Note attribute
 236     assertEquals("Iron-sulfur (2Fe-2S),another note", sf.description);
 237     assertEquals(39, sf.begin);
 238     assertEquals(39, sf.end);
 239     assertEquals("uniprot", sf.featureGroup);
 240     assertEquals("METAL", sf.type);
 241     assertEquals(
 242             "Note=Iron-sulfur (2Fe-2S);Note=another note;evidence=ECO:0000255|PROSITE-ProRule:PRU00465",
 243             sf.getValue("ATTRIBUTES"));
 244
 245     // verify feature on FER1_SOLLC1
 246     sfs = al.getSequenceAt(2).getDatasetSequence().getSequenceFeatures();
 247     assertEquals(1, sfs.length);
 248     sf = sfs[0];
 249     // ID used for description if available
 250     assertEquals("$23", sf.description);
 251     assertEquals(55, sf.begin);
 252     assertEquals(130, sf.end);
 253     assertEquals("uniprot", sf.featureGroup);
 254     assertEquals("Pfam", sf.type);
 255     assertEquals(3f, sf.getScore(), 0.001f);
 256   }
 257
 258   /**
 259    * Test parsing a features file with Jalview format features (but no colour
 260    * descriptors or startgroup to give the hint not to parse as GFF)
 261    *
 262    * @throws Exception
 263    */
 264   @Test(groups = { "Functional" })
 265   public void testParse_jalviewFeaturesOnly() throws Exception
 266   {
 267     File f = new File("examples/uniref50.fa");
 268     AlignmentI al = readAlignmentFile(f);
 269     AlignFrame af = new AlignFrame(al, 500, 500);
 270     Map<String, FeatureColourI> colours = af.getFeatureRenderer()
 271             .getFeatureColours();
 272
 273     /*
 274      * one feature on FER_CAPAA and one on sequence 3 (index 2) FER1_SOLLC
 275      */
 276     String featureData = "Iron-sulfur (2Fe-2S)\tFER_CAPAA\t-1\t39\t39\tMETAL\n"
 277             + "Iron-phosphorus (2Fe-P)\tID_NOT_SPECIFIED\t2\t86\t87\tMETALLIC\n";
 278     FeaturesFile featuresFile = new FeaturesFile(featureData,
 279             FormatAdapter.PASTE);
 280     assertTrue("Failed to parse features file",
 281             featuresFile.parse(al.getDataset(), colours, true));
 282
 283     // verify FER_CAPAA feature
 284     SequenceFeature[] sfs = al.getSequenceAt(0).getDatasetSequence()
 285             .getSequenceFeatures();
 286     assertEquals(1, sfs.length);
 287     SequenceFeature sf = sfs[0];
 288     assertEquals("Iron-sulfur (2Fe-2S)", sf.description);
 289     assertEquals(39, sf.begin);
 290     assertEquals(39, sf.end);
 291     assertEquals("METAL", sf.type);
 292
 293     // verify FER1_SOLLC feature
 294     sfs = al.getSequenceAt(2).getDatasetSequence().getSequenceFeatures();
 295     assertEquals(1, sfs.length);
 296     sf = sfs[0];
 297     assertEquals("Iron-phosphorus (2Fe-P)", sf.description);
 298     assertEquals(86, sf.begin);
 299     assertEquals(87, sf.end);
 300     assertEquals("METALLIC", sf.type);
 301   }
 302
 303   private void checkDatasetfromSimpleGff3(AlignmentI dataset)
 304   {
 305     assertEquals("no sequences extracted from GFF3 file", 2,
 306             dataset.getHeight());
 307
 308     SequenceI seq1 = dataset.findName("seq1");
 309     SequenceI seq2 = dataset.findName("seq2");
 310     assertNotNull(seq1);
 311     assertNotNull(seq2);
 312     assertFalse(
 313             "Failed to replace dummy seq1 with real sequence",
 314             seq1 instanceof SequenceDummy
 315                     && ((SequenceDummy) seq1).isDummy());
 316     assertFalse(
 317             "Failed to replace dummy seq2 with real sequence",
 318             seq2 instanceof SequenceDummy
 319                     && ((SequenceDummy) seq2).isDummy());
 320     String placeholderseq = new SequenceDummy("foo").getSequenceAsString();
 321     assertFalse("dummy replacement buggy for seq1",
 322             placeholderseq.equals(seq1.getSequenceAsString()));
 323     assertFalse("dummy replacement buggy for seq2",
 324             placeholderseq.equals(seq2.getSequenceAsString()));
 325     assertNotNull("No features added to seq1", seq1.getSequenceFeatures());
 326     assertEquals("Wrong number of features", 3,
 327             seq1.getSequenceFeatures().length);
 328     assertNull(seq2.getSequenceFeatures());
 329     assertEquals(
 330             "Wrong number of features",
 331             0,
 332             seq2.getSequenceFeatures() == null ? 0 : seq2
 333                     .getSequenceFeatures().length);
 334     assertTrue(
 335             "Expected at least one CDNA/Protein mapping for seq1",
 336             dataset.getCodonFrame(seq1) != null
 337                     && dataset.getCodonFrame(seq1).size() > 0);
 338
 339   }
 340
 341   @Test(groups = { "Functional" })
 342   public void readGff3File() throws IOException
 343   {
 344     FeaturesFile gffreader = new FeaturesFile(true, simpleGffFile,
 345             FormatAdapter.FILE);
 346     Alignment dataset = new Alignment(gffreader.getSeqsAsArray());
 347     gffreader.addProperties(dataset);
 348     checkDatasetfromSimpleGff3(dataset);
 349   }
 350
 351   @Test(groups = { "Functional" })
 352   public void simpleGff3FileClass() throws IOException
 353   {
 354     AlignmentI dataset = new Alignment(new SequenceI[] {});
 355     FeaturesFile ffile = new FeaturesFile(simpleGffFile,
 356             FormatAdapter.FILE);
 357
 358     boolean parseResult = ffile.parse(dataset, null, false, false);
 359     assertTrue("return result should be true", parseResult);
 360     checkDatasetfromSimpleGff3(dataset);
 361   }
 362
 363   @Test(groups = { "Functional" })
 364   public void simpleGff3FileLoader() throws IOException
 365   {
 366     AlignFrame af = new FileLoader(false).LoadFileWaitTillLoaded(
 367             simpleGffFile, FormatAdapter.FILE);
 368     assertTrue(
 369             "Didn't read the alignment into an alignframe from Gff3 File",
 370             af != null);
 371     checkDatasetfromSimpleGff3(af.getViewport().getAlignment());
 372   }
 373
 374   @Test(groups = { "Functional" })
 375   public void simpleGff3RelaxedIdMatching() throws IOException
 376   {
 377     AlignmentI dataset = new Alignment(new SequenceI[] {});
 378     FeaturesFile ffile = new FeaturesFile(simpleGffFile,
 379             FormatAdapter.FILE);
 380
 381     boolean parseResult = ffile.parse(dataset, null, false, true);
 382     assertTrue("return result (relaxedID matching) should be true",
 383             parseResult);
 384     checkDatasetfromSimpleGff3(dataset);
 385   }
 386
 387   @Test(groups = { "Functional" })
 388   public void testPrintJalviewFormat() throws Exception
 389   {
 390     File f = new File("examples/uniref50.fa");
 391     AlignmentI al = readAlignmentFile(f);
 392     AlignFrame af = new AlignFrame(al, 500, 500);
 393     Map<String, FeatureColourI> colours = af.getFeatureRenderer()
 394             .getFeatureColours();
 395     String features = "METAL\tcc9900\n"
 396             + "GAMMA-TURN\tred|0,255,255|20.0|95.0|below|66.0\n"
 397             + "Pfam\tred\n"
 398             + "STARTGROUP\tuniprot\n"
 399             + "Iron\tFER_CAPAA\t-1\t39\t39\tMETAL\n"
 400             + "Turn\tFER_CAPAA\t-1\t36\t38\tGAMMA-TURN\n"
 401             + "<html>Pfam domain<a href=\"http://pfam.xfam.org/family/PF00111\">Pfam_3_4</a></html>\tFER_CAPAA\t-1\t20\t20\tPfam\n"
 402             + "ENDGROUP\tuniprot\n";
 403     FeaturesFile featuresFile = new FeaturesFile(features,
 404             FormatAdapter.PASTE);
 405     featuresFile.parse(al.getDataset(), colours, false);
 406
 407     /*
 408      * first with no features displayed
 409      */
 410     FeatureRenderer fr = af.alignPanel.getFeatureRenderer();
 411     Map<String, FeatureColourI> visible = fr
 412             .getDisplayedFeatureCols();
 413     String exported = featuresFile.printJalviewFormat(
 414             al.getSequencesArray(), visible);
 415     String expected = "No Features Visible";
 416     assertEquals(expected, exported);
 417
 418     /*
 419      * set METAL (in uniprot group) and GAMMA-TURN visible, but not Pfam
 420      */
 421     fr.setVisible("METAL");
 422     fr.setVisible("GAMMA-TURN");
 423     visible = fr.getDisplayedFeatureCols();
 424     exported = featuresFile.printJalviewFormat(al.getSequencesArray(),
 425             visible);
 426     expected = "METAL\tcc9900\n"
 427             + "GAMMA-TURN\tff0000|00ffff|20.0|95.0|below|66.0\n"
 428             + "\nSTARTGROUP\tuniprot\n"
 429             + "Iron\tFER_CAPAA\t-1\t39\t39\tMETAL\t0.0\n"
 430             + "Turn\tFER_CAPAA\t-1\t36\t38\tGAMMA-TURN\t0.0\n"
 431             + "ENDGROUP\tuniprot\n";
 432     assertEquals(expected, exported);
 433
 434     /*
 435      * now set Pfam visible
 436      */
 437     fr.setVisible("Pfam");
 438     visible = fr.getDisplayedFeatureCols();
 439     exported = featuresFile.printJalviewFormat(al.getSequencesArray(),
 440             visible);
 441     /*
 442      * note the order of feature types is uncontrolled - derives from
 443      * FeaturesDisplayed.featuresDisplayed which is a HashSet
 444      */
 445     expected = "METAL\tcc9900\n"
 446             + "Pfam\tff0000\n"
 447             + "GAMMA-TURN\tff0000|00ffff|20.0|95.0|below|66.0\n"
 448             + "\nSTARTGROUP\tuniprot\n"
 449             + "Iron\tFER_CAPAA\t-1\t39\t39\tMETAL\t0.0\n"
 450             + "Turn\tFER_CAPAA\t-1\t36\t38\tGAMMA-TURN\t0.0\n"
 451             + "<html>Pfam domain<a href=\"http://pfam.xfam.org/family/PF00111\">Pfam_3_4</a></html>\tFER_CAPAA\t-1\t20\t20\tPfam\t0.0\n"
 452             + "ENDGROUP\tuniprot\n";
 453     assertEquals(expected, exported);
 454   }
 455 }