JAL-2480 simpler and safer test to avoid adding duplicates

[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 f5be818..db21c2f 100644 (file)
--- a/test/jalview/datamodel/features/FeatureStoreTest.java
+++ b/test/jalview/datamodel/features/FeatureStoreTest.java
@@ -394,12 +394,12 @@ public class FeatureStoreTest
     /*
      * add contact
      */
-    SequenceFeature sf5 = new SequenceFeature("Disulfide bond", "", 0, 0,
+    SequenceFeature sf5 = new SequenceFeature("Disulfide bond", "", 10, 20,
             Float.NaN, null);
     assertTrue(fs.addFeature(sf5));
     assertEquals(fs.getFeatureCount(true), 2); // positional - add 1 for contact
     assertEquals(fs.getFeatureCount(false), 1); // non-positional
-    SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "", 0, 0,
+    SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "", 10, 20,
             Float.NaN, null);
     assertFalse(fs.addFeature(sf6)); // already stored
     assertEquals(fs.getFeatureCount(true), 2); // no change
@@ -690,16 +690,16 @@ public class FeatureStoreTest
   }
 
   @Test(groups = "Functional")
-  public void testContains()
+  public void testListContains()
   {
-    assertFalse(FeatureStore.contains(null, null));
+    assertFalse(FeatureStore.listContains(null, null));
     List<SequenceFeature> features = new ArrayList<SequenceFeature>();
-    assertFalse(FeatureStore.contains(features, null));
+    assertFalse(FeatureStore.listContains(features, null));
 
     SequenceFeature sf1 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
             "group1");
-    assertFalse(FeatureStore.contains(null, sf1));
-    assertFalse(FeatureStore.contains(features, sf1));
+    assertFalse(FeatureStore.listContains(null, sf1));
+    assertFalse(FeatureStore.listContains(features, sf1));
 
     features.add(sf1);
     SequenceFeature sf2 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
@@ -708,8 +708,8 @@ public class FeatureStoreTest
             "group1");
 
     // sf2.equals(sf1) so contains should return true
-    assertTrue(FeatureStore.contains(features, sf2));
-    assertFalse(FeatureStore.contains(features, sf3));
+    assertTrue(FeatureStore.listContains(features, sf2));
+    assertFalse(FeatureStore.listContains(features, sf3));
   }
 
   @Test(groups = "Functional")
@@ -827,4 +827,85 @@ public class FeatureStoreTest
     assertEquals(pos.get(1).getBegin(), 13);
     assertEquals(pos.get(1).getEnd(), 22);
   }
+
+  @Test(groups = "Functional")
+  public void testDelete_readd()
+  {
+    /*
+     * add a feature and a nested feature
+     */
+    FeatureStore store = new FeatureStore();
+    SequenceFeature sf1 = addFeature(store, 10, 20);
+    // sf2 is nested in sf1 so will be stored in nestedFeatures
+    SequenceFeature sf2 = addFeature(store, 12, 14);
+    List<SequenceFeature> features = store.getPositionalFeatures();
+    assertEquals(features.size(), 2);
+    assertTrue(features.contains(sf1));
+    assertTrue(features.contains(sf2));
+    assertTrue(store.nonNestedFeatures.contains(sf1));
+    assertTrue(store.nestedFeatures.contains(sf2));
+  
+    /*
+     * delete the first feature
+     */
+    assertTrue(store.delete(sf1));
+    features = store.getPositionalFeatures();
+    assertFalse(features.contains(sf1));
+    assertTrue(features.contains(sf2));
+
+    /*
+     * re-add the 'nested' feature; is it now duplicated?
+     */
+    store.addFeature(sf2);
+    features = store.getPositionalFeatures();
+    assertEquals(features.size(), 1);
+    assertTrue(features.contains(sf2));
+  }
+
+  @Test(groups = "Functional")
+  public void testContains()
+  {
+    FeatureStore fs = new FeatureStore();
+    SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
+            Float.NaN, "group1");
+    SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 20,
+            Float.NaN, "group2");
+    SequenceFeature sf3 = new SequenceFeature("Cath", "", 0, 0, Float.NaN,
+            "group1");
+    SequenceFeature sf4 = new SequenceFeature("Cath", "", 0, 0, 0f,
+            "group1");
+    SequenceFeature sf5 = new SequenceFeature("Disulphide Bond", "", 5, 15,
+            Float.NaN, "group1");
+    SequenceFeature sf6 = new SequenceFeature("Disulphide Bond", "", 5, 15,
+            Float.NaN, "group2");
+
+    fs.addFeature(sf1);
+    fs.addFeature(sf3);
+    fs.addFeature(sf5);
+    assertTrue(fs.contains(sf1)); // positional feature
+    assertTrue(fs.contains(new SequenceFeature(sf1))); // identical feature
+    assertFalse(fs.contains(sf2)); // different group
+    assertTrue(fs.contains(sf3)); // non-positional
+    assertTrue(fs.contains(new SequenceFeature(sf3)));
+    assertFalse(fs.contains(sf4)); // different score
+    assertTrue(fs.contains(sf5)); // contact feature
+    assertTrue(fs.contains(new SequenceFeature(sf5)));
+    assertFalse(fs.contains(sf6)); // different group
+
+    /*
+     * add a nested feature
+     */
+    SequenceFeature sf7 = new SequenceFeature("Cath", "", 12, 16,
+            Float.NaN, "group1");
+    fs.addFeature(sf7);
+    assertTrue(fs.contains(sf7));
+    assertTrue(fs.contains(new SequenceFeature(sf7)));
+
+    /*
+     * delete the outer (enclosing, non-nested) feature
+     */
+    fs.delete(sf1);
+    assertFalse(fs.contains(sf1));
+    assertTrue(fs.contains(sf7));
+  }
 }