JAL-2490 tidy code and tests for feature export in Jalview format

[jalview.git] / test / jalview / datamodel / features / SequenceFeaturesTest.java

diff --git a/test/jalview/datamodel/features/SequenceFeaturesTest.java b/test/jalview/datamodel/features/SequenceFeaturesTest.java
index bb11a87..eaa5276 100644 (file)
--- a/test/jalview/datamodel/features/SequenceFeaturesTest.java
+++ b/test/jalview/datamodel/features/SequenceFeaturesTest.java
@@ -2,10 +2,13 @@ package jalview.datamodel.features;
 
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertFalse;
+import static org.testng.Assert.assertSame;
 import static org.testng.Assert.assertTrue;
 
 import jalview.datamodel.SequenceFeature;
 
+import java.util.ArrayList;
+import java.util.Iterator;
 import java.util.List;
 import java.util.Set;
 
@@ -237,8 +240,6 @@ public class SequenceFeaturesTest
     SequenceFeature sf10 = addFeature(sf, "Cath", 40, 100);
     SequenceFeature sf11 = addFeature(sf, "Cath", 60, 100);
     SequenceFeature sf12 = addFeature(sf, "Cath", 70, 70);
-    // null type is weird but possible:
-    SequenceFeature sf13 = addFeature(sf, null, 5, 12);
   
     List<SequenceFeature> overlaps = sf.findFeatures(200, 200, "Pfam");
     assertTrue(overlaps.isEmpty());
@@ -281,8 +282,7 @@ public class SequenceFeaturesTest
     assertTrue(sf.findFeatures(0, 1000, "Metal").isEmpty());
 
     overlaps = sf.findFeatures(7, 7, (String) null);
-    assertEquals(overlaps.size(), 1);
-    assertTrue(overlaps.contains(sf13));
+    assertTrue(overlaps.isEmpty());
   }
 
   @Test(groups = "Functional")
@@ -508,13 +508,13 @@ public class SequenceFeaturesTest
     assertEquals(types.size(), 1);
     assertTrue(types.contains("Metal"));
 
-    // null type is possible...
+    // null type is rejected...
     SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20,
             Float.NaN, null);
-    store.add(sf2);
+    assertFalse(store.add(sf2));
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 2);
-    assertTrue(types.contains(null));
+    assertEquals(types.size(), 1);
+    assertFalse(types.contains(null));
     assertTrue(types.contains("Metal"));
 
     /*
@@ -524,7 +524,7 @@ public class SequenceFeaturesTest
             Float.NaN, null);
     store.add(sf3);
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 3);
+    assertEquals(types.size(), 2);
     assertTrue(types.contains("Pfam"));
 
     /*
@@ -534,7 +534,7 @@ public class SequenceFeaturesTest
             10, 20, Float.NaN, null);
     store.add(sf4);
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 4);
+    assertEquals(types.size(), 3);
     assertTrue(types.contains("Disulphide Bond"));
 
     /*
@@ -544,14 +544,14 @@ public class SequenceFeaturesTest
             Float.NaN, null);
     store.add(sf5);
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 4); // unchanged
+    assertEquals(types.size(), 3); // unchanged
 
     /*
      * delete first Pfam - still have one
      */
     assertTrue(store.delete(sf3));
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 4);
+    assertEquals(types.size(), 3);
     assertTrue(types.contains("Pfam"));
 
     /*
@@ -559,7 +559,7 @@ public class SequenceFeaturesTest
      */
     assertTrue(store.delete(sf5));
     types = store.getFeatureTypes();
-    assertEquals(types.size(), 3);
+    assertEquals(types.size(), 2);
     assertFalse(types.contains("Pfam"));
   }
 
@@ -580,12 +580,12 @@ public class SequenceFeaturesTest
     assertEquals(store.getFeatureCount(false), 0);
 
     /*
-     * another positional
+     * null feature type is rejected
      */
     SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20,
             Float.NaN, null);
-    store.add(sf2);
-    assertEquals(store.getFeatureCount(true), 2);
+    assertFalse(store.add(sf2));
+    assertEquals(store.getFeatureCount(true), 1);
     assertEquals(store.getFeatureCount(false), 0);
   
     /*
@@ -594,7 +594,7 @@ public class SequenceFeaturesTest
     SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0,
             Float.NaN, null);
     store.add(sf3);
-    assertEquals(store.getFeatureCount(true), 2);
+    assertEquals(store.getFeatureCount(true), 1);
     assertEquals(store.getFeatureCount(false), 1);
   
     /*
@@ -603,39 +603,39 @@ public class SequenceFeaturesTest
     SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc",
             10, 20, Float.NaN, null);
     store.add(sf4);
-    assertEquals(store.getFeatureCount(true), 3);
+    assertEquals(store.getFeatureCount(true), 2);
     assertEquals(store.getFeatureCount(false), 1);
   
     /*
-     * add another Pfam
+     * add another Pfam but this time as a positional feature
      */
     SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20,
             Float.NaN, null);
     store.add(sf5);
-    assertEquals(store.getFeatureCount(true), 4);
-    assertEquals(store.getFeatureCount(false), 1);
-    assertEquals(store.getFeatureCount(true, "Pfam"), 1);
-    assertEquals(store.getFeatureCount(false, "Pfam"), 1);
+    assertEquals(store.getFeatureCount(true), 3); // sf1, sf4, sf5
+    assertEquals(store.getFeatureCount(false), 1); // sf3
+    assertEquals(store.getFeatureCount(true, "Pfam"), 1); // positional
+    assertEquals(store.getFeatureCount(false, "Pfam"), 1); // non-positional
     // search for type==null
-    assertEquals(store.getFeatureCount(true, (String) null), 1);
+    assertEquals(store.getFeatureCount(true, (String) null), 0);
     // search with no type specified
-    assertEquals(store.getFeatureCount(true, (String[]) null), 4);
+    assertEquals(store.getFeatureCount(true, (String[]) null), 3);
     assertEquals(store.getFeatureCount(true, "Metal", "Cath"), 1);
     assertEquals(store.getFeatureCount(true, "Disulphide Bond"), 1);
-    assertEquals(store.getFeatureCount(true, "Metal", "Pfam", null), 3);
+    assertEquals(store.getFeatureCount(true, "Metal", "Pfam", null), 2);
 
     /*
      * delete first Pfam (non-positional)
      */
     assertTrue(store.delete(sf3));
-    assertEquals(store.getFeatureCount(true), 4);
+    assertEquals(store.getFeatureCount(true), 3);
     assertEquals(store.getFeatureCount(false), 0);
   
     /*
      * delete second Pfam (positional)
      */
     assertTrue(store.delete(sf5));
-    assertEquals(store.getFeatureCount(true), 3);
+    assertEquals(store.getFeatureCount(true), 2);
     assertEquals(store.getFeatureCount(false), 0);
   }
 
@@ -653,7 +653,7 @@ public class SequenceFeaturesTest
     assertEquals(features.size(), 1);
     assertTrue(features.contains(sf1));
   
-    SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20,
+    SequenceFeature sf2 = new SequenceFeature("Metallic", "desc", 10, 20,
             Float.NaN, null);
     store.add(sf2);
     features = store.getAllFeatures();
@@ -689,8 +689,14 @@ public class SequenceFeaturesTest
     features = store.getAllFeatures();
     assertEquals(features.size(), 5);
     assertTrue(features.contains(sf5));
+
+    /*
+     * select by type does not apply to non-positional features
+     */
     features = store.getAllFeatures("Cath");
-    assertTrue(features.isEmpty());
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf3));
+
     features = store.getAllFeatures("Pfam", "Cath", "Metal");
     assertEquals(features.size(), 3);
     assertTrue(features.contains(sf1));
@@ -830,4 +836,186 @@ public class SequenceFeaturesTest
     assertEquals(sf.getMinimumScore("Metal", true), Float.NaN);
     assertEquals(sf.getMaximumScore("Metal", true), Float.NaN);
   }
+
+  @Test(groups = "Functional")
+  public void testVarargsToTypes()
+  {
+    SequenceFeatures sf = new SequenceFeatures();
+    sf.add(new SequenceFeature("Metal", "desc", 0, 0, Float.NaN, "group"));
+    sf.add(new SequenceFeature("Cath", "desc", 10, 20, Float.NaN, "group"));
+
+    /*
+     * no type specified - get all types stored
+     * they are returned in keyset (alphabetical) order
+     */
+    Iterable<String> types = sf.varargToTypes();
+    Iterator<String> iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Cath");
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+
+    /*
+     * empty array is the same as no vararg parameter supplied
+     * so treated as all stored types
+     */
+    types = sf.varargToTypes(new String[] {});
+    iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Cath");
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+
+    /*
+     * null type specified; this is passed as vararg
+     * String[1] {null}
+     */
+    types = sf.varargToTypes((String) null);
+    assertFalse(types.iterator().hasNext());
+
+    /*
+     * null types array specified; this is passed as vararg null
+     */
+    types = sf.varargToTypes((String[]) null);
+    iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Cath");
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+
+    /*
+     * one type specified
+     */
+    types = sf.varargToTypes("Metal");
+    iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+
+    /*
+     * two types specified - get sorted alphabetically
+     */
+    types = sf.varargToTypes("Metal", "Helix");
+    iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Helix");
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+
+    /*
+     * null type included - should get removed
+     */
+    types = sf.varargToTypes("Metal", null, "Helix");
+    iterator = types.iterator();
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Helix");
+    assertTrue(iterator.hasNext());
+    assertEquals(iterator.next(), "Metal");
+    assertFalse(iterator.hasNext());
+  }
+
+  @Test(groups = "Functional")
+  public void testGetFeatureTypes_byOntology()
+  {
+    SequenceFeaturesI store = new SequenceFeatures();
+  
+    SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20,
+            Float.NaN, null);
+    store.add(sf1);
+    // mRNA isA mature_transcript isA transcript
+    SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 10, 20,
+            Float.NaN, null);
+    store.add(sf2);
+    // just to prove non-positional feature types are included
+    SequenceFeature sf3 = new SequenceFeature("mRNA", "desc", 0, 0,
+            Float.NaN, null);
+    store.add(sf3);
+    SequenceFeature sf4 = new SequenceFeature("CDS", "desc", 0, 0,
+            Float.NaN, null);
+    store.add(sf4);
+
+    Set<String> types = store.getFeatureTypes("transcript");
+    assertEquals(types.size(), 2);
+    assertTrue(types.contains("transcript"));
+    assertTrue(types.contains("mRNA"));
+
+    // matches include arguments whether SO terms or not
+    types = store.getFeatureTypes("transcript", "CDS");
+    assertEquals(types.size(), 3);
+    assertTrue(types.contains("transcript"));
+    assertTrue(types.contains("mRNA"));
+    assertTrue(types.contains("CDS"));
+
+    types = store.getFeatureTypes("exon");
+    assertTrue(types.isEmpty());
+  }
+
+  @Test(groups = "Functional")
+  public void testGetFeaturesByOntology()
+  {
+    SequenceFeaturesI store = new SequenceFeatures();
+    List<SequenceFeature> features = store.getFeaturesByOntology();
+    assertTrue(features.isEmpty());
+    assertTrue(store.getFeaturesByOntology(new String[] {}).isEmpty());
+    assertTrue(store.getFeaturesByOntology((String[]) null).isEmpty());
+  
+    SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20,
+            Float.NaN, null);
+    store.add(sf1);
+
+    // mRNA isA transcript; added here 'as if' non-positional
+    // just to show that non-positional features are included in results
+    SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 0, 0,
+            Float.NaN, null);
+    store.add(sf2);
+
+    SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 30, 40,
+            Float.NaN, null);
+    store.add(sf3);
+
+    features = store.getFeaturesByOntology("transcript");
+    assertEquals(features.size(), 2);
+    assertTrue(features.contains(sf1));
+    assertTrue(features.contains(sf2));
+
+    features = store.getFeaturesByOntology("mRNA");
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf2));
+
+    features = store.getFeaturesByOntology("mRNA", "Pfam");
+    assertEquals(features.size(), 2);
+    assertTrue(features.contains(sf2));
+    assertTrue(features.contains(sf3));
+  }
+
+  @Test(groups = "Functional")
+  public void testSortFeatures()
+  {
+    List<SequenceFeature> sfs = new ArrayList<SequenceFeature>();
+    SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 30, 80,
+            Float.NaN, null);
+    sfs.add(sf1);
+    SequenceFeature sf2 = new SequenceFeature("Rfam", "desc", 40, 50,
+            Float.NaN, null);
+    sfs.add(sf2);
+    SequenceFeature sf3 = new SequenceFeature("Rfam", "desc", 50, 60,
+            Float.NaN, null);
+    sfs.add(sf3);
+
+    // sort by end position descending
+    SequenceFeatures.sortFeatures(sfs, false);
+    assertSame(sfs.get(0), sf1);
+    assertSame(sfs.get(1), sf3);
+    assertSame(sfs.get(2), sf2);
+
+    // sort by start position ascending
+    SequenceFeatures.sortFeatures(sfs, true);
+    assertSame(sfs.get(0), sf1);
+    assertSame(sfs.get(1), sf2);
+    assertSame(sfs.get(2), sf3);
+  }
 }