test/jalview/datamodel/features/FeatureStoreTest.java

   1 package jalview.datamodel.features;
   2
   3 import static org.testng.Assert.assertEquals;
   4 import static org.testng.Assert.assertFalse;
   5 import static org.testng.Assert.assertTrue;
   6
   7 import jalview.datamodel.SequenceFeature;
   8
   9 import java.util.List;
  10
  11 import org.testng.annotations.Test;
  12
  13 public class FeatureStoreTest
  14 {
  15
  16   @Test(groups = "Functional")
  17   public void testFindFeatures_nonNested()
  18   {
  19     FeatureStore fs = new FeatureStore();
  20     fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN,
  21             null));
  22     fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN, null));
  23     fs.addFeature(new SequenceFeature("", "", 15, 25, Float.NaN, null));
  24     fs.addFeature(new SequenceFeature("", "", 20, 35, Float.NaN, null));
  25
  26     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
  27     assertTrue(overlaps.isEmpty());
  28
  29     overlaps = fs.findOverlappingFeatures(8, 10);
  30     assertEquals(overlaps.size(), 2);
  31     assertEquals(overlaps.get(0).getEnd(), 20);
  32     assertEquals(overlaps.get(1).getEnd(), 20);
  33
  34     overlaps = fs.findOverlappingFeatures(12, 16);
  35     assertEquals(overlaps.size(), 3);
  36     assertEquals(overlaps.get(0).getEnd(), 20);
  37     assertEquals(overlaps.get(1).getEnd(), 20);
  38     assertEquals(overlaps.get(2).getEnd(), 25);
  39
  40     overlaps = fs.findOverlappingFeatures(33, 33);
  41     assertEquals(overlaps.size(), 1);
  42     assertEquals(overlaps.get(0).getEnd(), 35);
  43   }
  44
  45   @Test(groups = "Functional")
  46   public void testFindFeatures_nested()
  47   {
  48     FeatureStore fs = new FeatureStore();
  49     SequenceFeature sf1 = addFeature(fs, 10, 50);
  50     SequenceFeature sf2 = addFeature(fs, 10, 40);
  51     SequenceFeature sf3 = addFeature(fs, 20, 30);
  52     SequenceFeature sf4 = addFeature(fs, 20, 30);
  53     SequenceFeature sf5 = addFeature(fs, 35, 36);
  54
  55     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
  56     assertTrue(overlaps.isEmpty());
  57
  58     overlaps = fs.findOverlappingFeatures(10, 15);
  59     assertEquals(overlaps.size(), 2);
  60     assertTrue(overlaps.contains(sf1));
  61     assertTrue(overlaps.contains(sf2));
  62
  63     overlaps = fs.findOverlappingFeatures(45, 60);
  64     assertEquals(overlaps.size(), 1);
  65     assertTrue(overlaps.contains(sf1));
  66
  67     overlaps = fs.findOverlappingFeatures(32, 38);
  68     assertEquals(overlaps.size(), 3);
  69     assertTrue(overlaps.contains(sf1));
  70     assertTrue(overlaps.contains(sf2));
  71     assertTrue(overlaps.contains(sf5));
  72
  73     overlaps = fs.findOverlappingFeatures(15, 25);
  74     assertEquals(overlaps.size(), 4);
  75     assertTrue(overlaps.contains(sf1));
  76     assertTrue(overlaps.contains(sf2));
  77     assertTrue(overlaps.contains(sf3));
  78     assertTrue(overlaps.contains(sf4));
  79   }
  80
  81   @Test(groups = "Functional")
  82   public void testFindFeatures_mixed()
  83   {
  84     FeatureStore fs = new FeatureStore();
  85     SequenceFeature sf1 = addFeature(fs, 10, 50);
  86     SequenceFeature sf2 = addFeature(fs, 1, 15);
  87     SequenceFeature sf3 = addFeature(fs, 20, 30);
  88     SequenceFeature sf4 = addFeature(fs, 40, 100);
  89     SequenceFeature sf5 = addFeature(fs, 60, 100);
  90     SequenceFeature sf6 = addFeature(fs, 70, 70);
  91
  92     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(200, 200);
  93     assertTrue(overlaps.isEmpty());
  94
  95     overlaps = fs.findOverlappingFeatures(1, 9);
  96     assertEquals(overlaps.size(), 1);
  97     assertTrue(overlaps.contains(sf2));
  98
  99     overlaps = fs.findOverlappingFeatures(5, 18);
 100     assertEquals(overlaps.size(), 2);
 101     assertTrue(overlaps.contains(sf1));
 102     assertTrue(overlaps.contains(sf2));
 103
 104     overlaps = fs.findOverlappingFeatures(30, 40);
 105     assertEquals(overlaps.size(), 3);
 106     assertTrue(overlaps.contains(sf1));
 107     assertTrue(overlaps.contains(sf3));
 108     assertTrue(overlaps.contains(sf4));
 109
 110     overlaps = fs.findOverlappingFeatures(80, 90);
 111     assertEquals(overlaps.size(), 2);
 112     assertTrue(overlaps.contains(sf4));
 113     assertTrue(overlaps.contains(sf5));
 114
 115     overlaps = fs.findOverlappingFeatures(68, 70);
 116     assertEquals(overlaps.size(), 3);
 117     assertTrue(overlaps.contains(sf4));
 118     assertTrue(overlaps.contains(sf5));
 119     assertTrue(overlaps.contains(sf6));
 120   }
 121
 122   /**
 123    * Helper method to add a feature of no particular type
 124    *
 125    * @param fs
 126    * @param from
 127    * @param to
 128    * @return
 129    */
 130   SequenceFeature addFeature(FeatureStore fs, int from, int to)
 131   {
 132     SequenceFeature sf1 = new SequenceFeature("", "", from, to, Float.NaN,
 133             null);
 134     fs.addFeature(sf1);
 135     return sf1;
 136   }
 137
 138   @Test(groups = "Functional")
 139   public void testFindFeatures_contactFeatures()
 140   {
 141     FeatureStore fs = new FeatureStore();
 142
 143     SequenceFeature sf = new SequenceFeature("disulphide bond", "bond", 10,
 144             20, Float.NaN, null);
 145     fs.addFeature(sf);
 146
 147     /*
 148      * neither contact point in range
 149      */
 150     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
 151     assertTrue(overlaps.isEmpty());
 152
 153     /*
 154      * neither contact point in range
 155      */
 156     overlaps = fs.findOverlappingFeatures(11, 19);
 157     assertTrue(overlaps.isEmpty());
 158
 159     /*
 160      * first contact point in range
 161      */
 162     overlaps = fs.findOverlappingFeatures(5, 15);
 163     assertEquals(overlaps.size(), 1);
 164     assertTrue(overlaps.contains(sf));
 165
 166     /*
 167      * second contact point in range
 168      */
 169     overlaps = fs.findOverlappingFeatures(15, 25);
 170     assertEquals(overlaps.size(), 1);
 171     assertTrue(overlaps.contains(sf));
 172
 173     /*
 174      * both contact points in range
 175      */
 176     overlaps = fs.findOverlappingFeatures(5, 25);
 177     assertEquals(overlaps.size(), 1);
 178     assertTrue(overlaps.contains(sf));
 179   }
 180
 181   /**
 182    * Tests for the method that returns false for an attempt to add a feature
 183    * that would enclose, or be enclosed by, another feature
 184    */
 185   @Test(groups = "Functional")
 186   public void testAddNonNestedFeature()
 187   {
 188     FeatureStore fs = new FeatureStore();
 189
 190     String type = "Domain";
 191     SequenceFeature sf1 = new SequenceFeature(type, type, 10, 20,
 192             Float.NaN, null);
 193     assertTrue(fs.addNonNestedFeature(sf1));
 194
 195     // co-located feature is ok
 196     SequenceFeature sf2 = new SequenceFeature(type, type, 10, 20,
 197             Float.NaN, null);
 198     assertTrue(fs.addNonNestedFeature(sf2));
 199
 200     // overlap left is ok
 201     SequenceFeature sf3 = new SequenceFeature(type, type, 5, 15, Float.NaN,
 202             null);
 203     assertTrue(fs.addNonNestedFeature(sf3));
 204
 205     // overlap right is ok
 206     SequenceFeature sf4 = new SequenceFeature(type, type, 15, 25,
 207             Float.NaN, null);
 208     assertTrue(fs.addNonNestedFeature(sf4));
 209
 210     // add enclosing feature is not ok
 211     SequenceFeature sf5 = new SequenceFeature(type, type, 10, 21,
 212             Float.NaN, null);
 213     assertFalse(fs.addNonNestedFeature(sf5));
 214     SequenceFeature sf6 = new SequenceFeature(type, type, 4, 15, Float.NaN,
 215             null);
 216     assertFalse(fs.addNonNestedFeature(sf6));
 217     SequenceFeature sf7 = new SequenceFeature(type, type, 1, 50, Float.NaN,
 218             null);
 219     assertFalse(fs.addNonNestedFeature(sf7));
 220
 221     // add enclosed feature is not ok
 222     SequenceFeature sf8 = new SequenceFeature(type, type, 10, 19,
 223             Float.NaN, null);
 224     assertFalse(fs.addNonNestedFeature(sf8));
 225     SequenceFeature sf9 = new SequenceFeature(type, type, 16, 25,
 226             Float.NaN, null);
 227     assertFalse(fs.addNonNestedFeature(sf9));
 228     SequenceFeature sf10 = new SequenceFeature(type, type, 7, 7, Float.NaN,
 229             null);
 230     assertFalse(fs.addNonNestedFeature(sf10));
 231   }
 232 }