X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=test%2Fjalview%2Fdatamodel%2Ffeatures%2FFeatureStoreTest.java;h=db0fabf6567bd4eb3626ed9f8bc27b66a0428e65;hb=0058ae87ea065cb53e5f4b8c19a188fad88ff6ad;hp=7fe94d021eb338cfd5188e74899ddcbf327c343b;hpb=5fa443fd521570a00ce85a627761582adad2bfd4;p=jalview.git

diff --git a/test/jalview/datamodel/features/FeatureStoreTest.java b/test/jalview/datamodel/features/FeatureStoreTest.java
index 7fe94d0..db0fabf 100644
--- a/test/jalview/datamodel/features/FeatureStoreTest.java
+++ b/test/jalview/datamodel/features/FeatureStoreTest.java
@@ -4,22 +4,30 @@ 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 static org.testng.Assert.fail;
 
 import jalview.datamodel.SequenceFeature;
 
 import java.util.ArrayList;
+import java.util.Collection;
 import java.util.List;
 import java.util.Set;
 
 import org.testng.annotations.Test;
 
+import junit.extensions.PA;
+
 public class FeatureStoreTest
 {
+  private FeatureStore newFeatureStore()
+  {
+    return new FeatureStore();
+  }
 
   @Test(groups = "Functional")
   public void testFindFeatures_nonNested()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN,
             null));
     // same range different description
@@ -27,35 +35,29 @@ public class FeatureStoreTest
     fs.addFeature(new SequenceFeature("", "", 15, 25, Float.NaN, null));
     fs.addFeature(new SequenceFeature("", "", 20, 35, Float.NaN, null));
 
-    List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
+    List<SequenceFeature> overlaps = fs.findFeatures(1, 9);
     assertTrue(overlaps.isEmpty());
 
-    overlaps = fs.findOverlappingFeatures(8, 10);
+    overlaps = fs.findFeatures(8, 10);
     assertEquals(overlaps.size(), 2);
     assertEquals(overlaps.get(0).getEnd(), 20);
     assertEquals(overlaps.get(1).getEnd(), 20);
 
-    overlaps = fs.findOverlappingFeatures(12, 16);
+    overlaps = fs.findFeatures(12, 16);
     assertEquals(overlaps.size(), 3);
     assertEquals(overlaps.get(0).getEnd(), 20);
     assertEquals(overlaps.get(1).getEnd(), 20);
     assertEquals(overlaps.get(2).getEnd(), 25);
 
-    overlaps = fs.findOverlappingFeatures(33, 33);
+    overlaps = fs.findFeatures(33, 33);
     assertEquals(overlaps.size(), 1);
     assertEquals(overlaps.get(0).getEnd(), 35);
   }
 
-  private FeatureStoreI newFeatureStore()
-  {
-    // return new FeatureStoreJS();
-    return new FeatureStoreImpl();
-  }
-
   @Test(groups = "Functional")
   public void testFindFeatures_nested()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     SequenceFeature sf1 = addFeature(fs, 10, 50);
     SequenceFeature sf2 = addFeature(fs, 10, 40);
     SequenceFeature sf3 = addFeature(fs, 20, 30);
@@ -65,25 +67,25 @@ public class FeatureStoreTest
     fs.addFeature(sf4);
     SequenceFeature sf5 = addFeature(fs, 35, 36);
 
-    List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
+    List<SequenceFeature> overlaps = fs.findFeatures(1, 9);
     assertTrue(overlaps.isEmpty());
 
-    overlaps = fs.findOverlappingFeatures(10, 15);
+    overlaps = fs.findFeatures(10, 15);
     assertEquals(overlaps.size(), 2);
     assertTrue(overlaps.contains(sf1));
     assertTrue(overlaps.contains(sf2));
 
-    overlaps = fs.findOverlappingFeatures(45, 60);
+    overlaps = fs.findFeatures(45, 60);
     assertEquals(overlaps.size(), 1);
     assertTrue(overlaps.contains(sf1));
 
-    overlaps = fs.findOverlappingFeatures(32, 38);
+    overlaps = fs.findFeatures(32, 38);
     assertEquals(overlaps.size(), 3);
     assertTrue(overlaps.contains(sf1));
     assertTrue(overlaps.contains(sf2));
     assertTrue(overlaps.contains(sf5));
 
-    overlaps = fs.findOverlappingFeatures(15, 25);
+    overlaps = fs.findFeatures(15, 25);
     assertEquals(overlaps.size(), 4);
     assertTrue(overlaps.contains(sf1));
     assertTrue(overlaps.contains(sf2));
@@ -94,7 +96,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testFindFeatures_mixed()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     SequenceFeature sf1 = addFeature(fs, 10, 50);
     SequenceFeature sf2 = addFeature(fs, 1, 15);
     SequenceFeature sf3 = addFeature(fs, 20, 30);
@@ -102,30 +104,30 @@ public class FeatureStoreTest
     SequenceFeature sf5 = addFeature(fs, 60, 100);
     SequenceFeature sf6 = addFeature(fs, 70, 70);
 
-    List<SequenceFeature> overlaps = fs.findOverlappingFeatures(200, 200);
+    List<SequenceFeature> overlaps = fs.findFeatures(200, 200);
     assertTrue(overlaps.isEmpty());
 
-    overlaps = fs.findOverlappingFeatures(1, 9);
+    overlaps = fs.findFeatures(1, 9);
     assertEquals(overlaps.size(), 1);
     assertTrue(overlaps.contains(sf2));
 
-    overlaps = fs.findOverlappingFeatures(5, 18);
+    overlaps = fs.findFeatures(5, 18);
     assertEquals(overlaps.size(), 2);
     assertTrue(overlaps.contains(sf1));
     assertTrue(overlaps.contains(sf2));
 
-    overlaps = fs.findOverlappingFeatures(30, 40);
+    overlaps = fs.findFeatures(30, 40);
     assertEquals(overlaps.size(), 3);
     assertTrue(overlaps.contains(sf1));
     assertTrue(overlaps.contains(sf3));
     assertTrue(overlaps.contains(sf4));
 
-    overlaps = fs.findOverlappingFeatures(80, 90);
+    overlaps = fs.findFeatures(80, 90);
     assertEquals(overlaps.size(), 2);
     assertTrue(overlaps.contains(sf4));
     assertTrue(overlaps.contains(sf5));
 
-    overlaps = fs.findOverlappingFeatures(68, 70);
+    overlaps = fs.findFeatures(68, 70);
     assertEquals(overlaps.size(), 3);
     assertTrue(overlaps.contains(sf4));
     assertTrue(overlaps.contains(sf5));
@@ -140,7 +142,7 @@ public class FeatureStoreTest
    * @param to
    * @return
    */
-  SequenceFeature addFeature(FeatureStoreI fs, int from, int to)
+  SequenceFeature addFeature(FeatureStore fs, int from, int to)
   {
     SequenceFeature sf1 = new SequenceFeature("", "", from, to, Float.NaN,
             null);
@@ -151,7 +153,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testFindFeatures_contactFeatures()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
 
     SequenceFeature sf = new SequenceFeature("disulphide bond", "bond", 10,
             20, Float.NaN, null);
@@ -160,41 +162,135 @@ public class FeatureStoreTest
     /*
      * neither contact point in range
      */
-    List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
+    List<SequenceFeature> overlaps = fs.findFeatures(1, 9);
     assertTrue(overlaps.isEmpty());
 
     /*
      * neither contact point in range
      */
-    overlaps = fs.findOverlappingFeatures(11, 19);
+    overlaps = fs.findFeatures(11, 19);
     assertTrue(overlaps.isEmpty());
 
     /*
      * first contact point in range
      */
-    overlaps = fs.findOverlappingFeatures(5, 15);
+    overlaps = fs.findFeatures(5, 15);
     assertEquals(overlaps.size(), 1);
     assertTrue(overlaps.contains(sf));
 
     /*
      * second contact point in range
      */
-    overlaps = fs.findOverlappingFeatures(15, 25);
+    overlaps = fs.findFeatures(15, 25);
     assertEquals(overlaps.size(), 1);
     assertTrue(overlaps.contains(sf));
 
     /*
      * both contact points in range
      */
-    overlaps = fs.findOverlappingFeatures(5, 25);
+    overlaps = fs.findFeatures(5, 25);
     assertEquals(overlaps.size(), 1);
     assertTrue(overlaps.contains(sf));
   }
 
   @Test(groups = "Functional")
+  public void testGetPositionalFeatures_withResultList()
+  {
+    FeatureStore store = newFeatureStore();
+    SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
+            Float.NaN, null);
+    store.addFeature(sf1);
+    // contact feature
+    SequenceFeature sf2 = new SequenceFeature("Disulphide bond", "desc", 18,
+            45, Float.NaN, null);
+    store.addFeature(sf2);
+
+    List<SequenceFeature> features = new ArrayList<>();
+    store.getPositionalFeatures(features);
+    assertEquals(features.size(), 2);
+    assertTrue(features.contains(sf1));
+    assertTrue(features.contains(sf2));
+
+    /*
+     * no check for duplicates
+     */
+    features.remove(sf1);
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf2));
+    store.getPositionalFeatures(features);
+    assertEquals(features.size(), 3);
+    assertTrue(features.contains(sf1));
+    assertTrue(features.contains(sf2)); // two copies now
+    features.remove(sf2);
+    assertTrue(features.contains(sf2)); // one copy left
+    assertEquals(features.size(), 2);
+
+    /*
+     * null argument throws exception
+     */
+    try
+    {
+      store.getPositionalFeatures(null);
+      fail("expected exception");
+    } catch (NullPointerException e)
+    {
+      // expected
+    }
+  }
+
+  @Test(groups = "Functional")
+  public void testGetNonPositionalFeatures()
+  {
+    FeatureStore store = newFeatureStore();
+    List<SequenceFeature> features = store.getNonPositionalFeatures();
+    assertTrue(features.isEmpty());
+
+    SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
+            Float.NaN, null);
+    store.addFeature(sf1);
+    assertTrue(features.isEmpty());
+
+    SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0,
+            Float.NaN, null);
+    store.addFeature(sf2);
+    features = store.getNonPositionalFeatures();
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf2));
+
+    /*
+     * with result list argument
+     */
+    features.clear();
+    store.getNonPositionalFeatures(features);
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf2));
+
+    /*
+     * no check for duplicates
+     */
+    store.getNonPositionalFeatures(features);
+    assertEquals(features.size(), 2);
+    assertTrue(features.contains(sf2)); // two copies
+    features.remove(sf2);
+    assertTrue(features.contains(sf2));
+
+    /*
+     * null argument throws exception
+     */
+    try
+    {
+      store.getNonPositionalFeatures(null);
+      fail("expected exception");
+    } catch (NullPointerException e)
+    {
+      // expected
+    }
+  }
+
+  @Test(groups = "Functional")
   public void testGetPositionalFeatures()
   {
-    FeatureStoreI store = newFeatureStore();
+    FeatureStore store = newFeatureStore();
     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
             Float.NaN, null);
     store.addFeature(sf1);
@@ -241,7 +337,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testDelete()
   {
-    FeatureStoreI store = newFeatureStore();
+    FeatureStore store = newFeatureStore();
     SequenceFeature sf1 = addFeature(store, 10, 20);
     assertTrue(store.getPositionalFeatures().contains(sf1));
 
@@ -313,7 +409,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testAddFeature()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
 
     SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
             Float.NaN, null);
@@ -364,7 +460,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testIsEmpty()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     assertTrue(fs.isEmpty());
     assertEquals(fs.getFeatureCount(true), 0);
 
@@ -417,7 +513,9 @@ public class FeatureStoreTest
     assertEquals(fs.getFeatureCount(true), 3);
     assertTrue(fs.delete(sf1));
     assertEquals(fs.getFeatureCount(true), 2);
-    assertEquals(fs.getFeatures().size(), 2);
+    Collection<SequenceFeature> intervalStore = (Collection<SequenceFeature>) PA
+            .getValue(fs, "features");
+    assertEquals(intervalStore.size(), 2);
     assertFalse(fs.isEmpty());
     assertTrue(fs.delete(sf2));
     assertEquals(fs.getFeatureCount(true), 1);
@@ -430,7 +528,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testGetFeatureGroups()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     assertTrue(fs.getFeatureGroups(true).isEmpty());
     assertTrue(fs.getFeatureGroups(false).isEmpty());
 
@@ -497,7 +595,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testGetTotalFeatureLength()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     assertEquals(fs.getTotalFeatureLength(), 0);
 
     addFeature(fs, 10, 20); // 11
@@ -573,7 +671,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testGetMinimumScore_getMaximumScore()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     assertEquals(fs.getMinimumScore(true), Float.NaN); // positional
     assertEquals(fs.getMaximumScore(true), Float.NaN);
     assertEquals(fs.getMinimumScore(false), Float.NaN); // non-positional
@@ -645,14 +743,15 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testListContains()
   {
-    assertFalse(FeatureStore.listContains(null, null));
+    FeatureStore featureStore = newFeatureStore();
+    assertFalse(featureStore.listContains(null, null));
     List<SequenceFeature> features = new ArrayList<>();
-    assertFalse(FeatureStore.listContains(features, null));
+    assertFalse(featureStore.listContains(features, null));
 
     SequenceFeature sf1 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
             "group1");
-    assertFalse(FeatureStore.listContains(null, sf1));
-    assertFalse(FeatureStore.listContains(features, sf1));
+    assertFalse(featureStore.listContains(null, sf1));
+    assertFalse(featureStore.listContains(features, sf1));
 
     features.add(sf1);
     SequenceFeature sf2 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
@@ -661,14 +760,14 @@ public class FeatureStoreTest
             "group1");
 
     // sf2.equals(sf1) so contains should return true
-    assertTrue(FeatureStore.listContains(features, sf2));
-    assertFalse(FeatureStore.listContains(features, sf3));
+    assertTrue(featureStore.listContains(features, sf2));
+    assertFalse(featureStore.listContains(features, sf3));
   }
 
   @Test(groups = "Functional")
   public void testGetFeaturesForGroup()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
 
     /*
      * with no features
@@ -726,7 +825,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testShiftFeatures()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     assertFalse(fs.shiftFeatures(0, 1)); // nothing to do
 
     SequenceFeature sf1 = new SequenceFeature("Cath", "", 2, 5, 0f, null);
@@ -813,7 +912,7 @@ public class FeatureStoreTest
     /*
      * add a feature and a nested feature
      */
-    FeatureStoreI store = newFeatureStore();
+    FeatureStore store = newFeatureStore();
     SequenceFeature sf1 = addFeature(store, 10, 20);
     // sf2 is nested in sf1 so will be stored in nestedFeatures
     SequenceFeature sf2 = addFeature(store, 12, 14);
@@ -821,8 +920,10 @@ public class FeatureStoreTest
     assertEquals(features.size(), 2);
     assertTrue(features.contains(sf1));
     assertTrue(features.contains(sf2));
-    assertTrue(store.getFeatures().contains(sf1));
-    assertTrue(store.getFeatures().contains(sf2));
+    Collection<SequenceFeature> intervalStore = (Collection<SequenceFeature>) PA
+            .getValue(store, "features");
+    assertTrue(intervalStore.contains(sf1));
+    assertTrue(intervalStore.contains(sf2));
   
     /*
      * delete the first feature
@@ -844,7 +945,7 @@ public class FeatureStoreTest
   @Test(groups = "Functional")
   public void testContains()
   {
-    FeatureStoreI fs = newFeatureStore();
+    FeatureStore fs = newFeatureStore();
     SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
             Float.NaN, "group1");
     SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 20,
@@ -887,4 +988,28 @@ public class FeatureStoreTest
     assertFalse(fs.contains(sf1));
     assertTrue(fs.contains(sf7));
   }
+
+  @Test(groups = "Functional")
+  public void testFindFeatures_withResultList()
+  {
+    FeatureStore fs = newFeatureStore();
+    SequenceFeature sf1 = addFeature(fs, 10, 50);
+    SequenceFeature sf2 = addFeature(fs, 150, 250);
+  
+    List<SequenceFeature> overlaps = new ArrayList<>();
+    List<SequenceFeature> result = fs.findFeatures(200, 200,
+            overlaps);
+    assertSame(result, overlaps);
+    assertEquals(result.size(), 1);
+    assertTrue(result.contains(sf2));
+    assertFalse(result.contains(sf1));
+
+    /*
+     * if no list supplied, method creates one
+     */
+    result = fs.findFeatures(200, 200, null);
+    assertEquals(result.size(), 1);
+    assertTrue(result.contains(sf2));
+    assertFalse(result.contains(sf1));
+  }
 }