JAL-2446 added contains, delete, checks for inclusion on add + tests

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

diff --git a/test/jalview/datamodel/features/FeatureStoreTest.java b/test/jalview/datamodel/features/FeatureStoreTest.java
index 7147c51..88a7616 100644 (file)
--- a/test/jalview/datamodel/features/FeatureStoreTest.java
+++ b/test/jalview/datamodel/features/FeatureStoreTest.java
@@ -19,7 +19,8 @@ public class FeatureStoreTest
     FeatureStore fs = new FeatureStore();
     fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN,
             null));
-    fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN, null));
+    // same range different description
+    fs.addFeature(new SequenceFeature("", "desc", 10, 20, Float.NaN, null));
     fs.addFeature(new SequenceFeature("", "", 15, 25, Float.NaN, null));
     fs.addFeature(new SequenceFeature("", "", 20, 35, Float.NaN, null));
 
@@ -49,7 +50,10 @@ public class FeatureStoreTest
     SequenceFeature sf1 = addFeature(fs, 10, 50);
     SequenceFeature sf2 = addFeature(fs, 10, 40);
     SequenceFeature sf3 = addFeature(fs, 20, 30);
-    SequenceFeature sf4 = addFeature(fs, 20, 30);
+    // fudge feature at same location but different group (so is added)
+    SequenceFeature sf4 = new SequenceFeature("", "", 20, 30, Float.NaN,
+            "different group");
+    fs.addFeature(sf4);
     SequenceFeature sf5 = addFeature(fs, 35, 36);
 
     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
@@ -237,8 +241,8 @@ public class FeatureStoreTest
     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
             Float.NaN, null);
     store.addFeature(sf1);
-    // same range
-    SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 10, 20,
+    // same range, different description
+    SequenceFeature sf2 = new SequenceFeature("Metal", "desc2", 10, 20,
             Float.NaN, null);
     store.addFeature(sf2);
     // discontiguous range
@@ -272,4 +276,94 @@ public class FeatureStoreTest
     assertTrue(features.contains(sf6));
     assertTrue(features.contains(sf7));
   }
+
+  @Test(groups = "Functional")
+  public void testDelete()
+  {
+    FeatureStore store = new FeatureStore();
+    SequenceFeature sf1 = addFeature(store, 10, 20);
+    assertTrue(store.getFeatures().contains(sf1));
+
+    /*
+     * simple deletion
+     */
+    assertTrue(store.delete(sf1));
+    assertTrue(store.getFeatures().isEmpty());
+
+    /*
+     * non-positional feature deletion
+     */
+    SequenceFeature sf2 = addFeature(store, 0, 0);
+    assertTrue(store.getFeatures().contains(sf2));
+    assertTrue(store.delete(sf2));
+    assertTrue(store.getFeatures().isEmpty());
+
+    /*
+     * contact feature deletion
+     */
+    SequenceFeature sf3 = new SequenceFeature("", "Disulphide Bond", 11,
+            23, Float.NaN, null);
+    store.addFeature(sf3);
+    assertEquals(store.getFeatures().size(), 1);
+    assertTrue(store.getFeatures().contains(sf3));
+    assertTrue(store.delete(sf3));
+    assertTrue(store.getFeatures().isEmpty());
+
+    /*
+     * nested feature deletion
+     */
+    SequenceFeature sf4 = addFeature(store, 20, 30);
+    SequenceFeature sf5 = addFeature(store, 22, 26); // to NCList
+    SequenceFeature sf6 = addFeature(store, 23, 24); // child of sf5
+    SequenceFeature sf7 = addFeature(store, 25, 25); // sibling of sf6
+    SequenceFeature sf8 = addFeature(store, 24, 24); // child of sf6
+    SequenceFeature sf9 = addFeature(store, 23, 23); // child of sf6
+    assertEquals(store.getFeatures().size(), 6);
+
+    // delete a node with children - they take its place
+    assertTrue(store.delete(sf6)); // sf8, sf9 should become children of sf5
+    assertEquals(store.getFeatures().size(), 5);
+    assertFalse(store.getFeatures().contains(sf6));
+
+    // delete a node with no children
+    assertTrue(store.delete(sf7));
+    assertEquals(store.getFeatures().size(), 4);
+    assertFalse(store.getFeatures().contains(sf7));
+
+    // delete root of NCList
+    assertTrue(store.delete(sf5));
+    assertEquals(store.getFeatures().size(), 3);
+    assertFalse(store.getFeatures().contains(sf5));
+
+    // continue the killing fields
+    assertTrue(store.delete(sf4));
+    assertEquals(store.getFeatures().size(), 2);
+    assertFalse(store.getFeatures().contains(sf4));
+
+    assertTrue(store.delete(sf9));
+    assertEquals(store.getFeatures().size(), 1);
+    assertFalse(store.getFeatures().contains(sf9));
+
+    assertTrue(store.delete(sf8));
+    assertTrue(store.getFeatures().isEmpty());
+  }
+
+  @Test(groups = "Functional")
+  public void testAddFeature()
+  {
+    FeatureStore fs = new FeatureStore();
+
+    SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
+            Float.NaN, null);
+    SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 20,
+            Float.NaN, null);
+
+    assertTrue(fs.addFeature(sf1));
+
+    /*
+     * re-adding the same or an identical feature should fail
+     */
+    assertFalse(fs.addFeature(sf1));
+    assertFalse(fs.addFeature(sf2));
+  }
 }