test/jalview/datamodel/features/SequenceFeaturesTest.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 SequenceFeaturesTest
  14 {
  15   @Test(groups = "Functional")
  16   public void testGetFeatures()
  17   {
  18     SequenceFeatures store = new SequenceFeatures();
  19     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
  20             Float.NaN, null);
  21     store.add(sf1);
  22     // same range, different description
  23     SequenceFeature sf2 = new SequenceFeature("Metal", "desc2", 10, 20,
  24             Float.NaN, null);
  25     store.add(sf2);
  26     // discontiguous range
  27     SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 30, 40,
  28             Float.NaN, null);
  29     store.add(sf3);
  30     // overlapping range
  31     SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 15, 35,
  32             Float.NaN, null);
  33     store.add(sf4);
  34     // enclosing range
  35     SequenceFeature sf5 = new SequenceFeature("Metal", "desc", 5, 50,
  36             Float.NaN, null);
  37     store.add(sf5);
  38     // non-positional feature
  39     SequenceFeature sf6 = new SequenceFeature("Metal", "desc", 0, 0,
  40             Float.NaN, null);
  41     store.add(sf6);
  42     // contact feature
  43     SequenceFeature sf7 = new SequenceFeature("Disulphide bond", "desc",
  44             18, 45, Float.NaN, null);
  45     store.add(sf7);
  46     // different feature type
  47     SequenceFeature sf8 = new SequenceFeature("Pfam", "desc", 30, 40,
  48             Float.NaN, null);
  49     store.add(sf8);
  50     SequenceFeature sf9 = new SequenceFeature("Pfam", "desc", 15, 35,
  51             Float.NaN, null);
  52     store.add(sf9);
  53
  54     /*
  55      * get all features
  56      */
  57     List<SequenceFeature> features = store.getFeatures();
  58     assertEquals(features.size(), 9);
  59     assertTrue(features.contains(sf1));
  60     assertTrue(features.contains(sf2));
  61     assertTrue(features.contains(sf3));
  62     assertTrue(features.contains(sf4));
  63     assertTrue(features.contains(sf5));
  64     assertTrue(features.contains(sf6));
  65     assertTrue(features.contains(sf7));
  66     assertTrue(features.contains(sf8));
  67     assertTrue(features.contains(sf9));
  68
  69     /*
  70      * get features by type
  71      */
  72     assertTrue(store.getFeatures(null).isEmpty());
  73     assertTrue(store.getFeatures("Cath").isEmpty());
  74     assertTrue(store.getFeatures("METAL").isEmpty());
  75
  76     features = store.getFeatures("Metal");
  77     assertEquals(features.size(), 6);
  78     assertTrue(features.contains(sf1));
  79     assertTrue(features.contains(sf2));
  80     assertTrue(features.contains(sf3));
  81     assertTrue(features.contains(sf4));
  82     assertTrue(features.contains(sf5));
  83     assertTrue(features.contains(sf6));
  84
  85     features = store.getFeatures("Disulphide bond");
  86     assertEquals(features.size(), 1);
  87     assertTrue(features.contains(sf7));
  88
  89     features = store.getFeatures("Pfam");
  90     assertEquals(features.size(), 2);
  91     assertTrue(features.contains(sf8));
  92     assertTrue(features.contains(sf9));
  93   }
  94
  95   @Test(groups = "Functional")
  96   public void testGetContactFeatures()
  97   {
  98     SequenceFeatures store = new SequenceFeatures();
  99     // non-contact
 100     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
 101             Float.NaN, null);
 102     store.add(sf1);
 103     // non-positional
 104     SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0,
 105             Float.NaN, null);
 106     store.add(sf2);
 107     // contact feature
 108     SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc",
 109             18, 45, Float.NaN, null);
 110     store.add(sf3);
 111     // repeat for different feature type
 112     SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20,
 113             Float.NaN, null);
 114     store.add(sf4);
 115     SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0,
 116             Float.NaN, null);
 117     store.add(sf5);
 118     SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18,
 119             45, Float.NaN, null);
 120     store.add(sf6);
 121
 122     /*
 123      * get all contact features
 124      */
 125     List<SequenceFeature> features = store.getContactFeatures();
 126     assertEquals(features.size(), 2);
 127     assertTrue(features.contains(sf3));
 128     assertTrue(features.contains(sf6));
 129
 130     /*
 131      * get contact features by type
 132      */
 133     assertTrue(store.getContactFeatures(null).isEmpty());
 134     assertTrue(store.getContactFeatures("Cath").isEmpty());
 135     assertTrue(store.getContactFeatures("Pfam").isEmpty());
 136     assertTrue(store.getContactFeatures("DISULPHIDE BOND").isEmpty());
 137
 138     features = store.getContactFeatures("Disulphide bond");
 139     assertEquals(features.size(), 1);
 140     assertTrue(features.contains(sf3));
 141
 142     features = store.getContactFeatures("Disulfide bond");
 143     assertEquals(features.size(), 1);
 144     assertTrue(features.contains(sf6));
 145   }
 146
 147   @Test(groups = "Functional")
 148   public void testGetNonPositionalFeatures()
 149   {
 150     SequenceFeatures store = new SequenceFeatures();
 151     // positional
 152     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
 153             Float.NaN, null);
 154     store.add(sf1);
 155     // non-positional
 156     SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0,
 157             Float.NaN, null);
 158     store.add(sf2);
 159     // contact feature
 160     SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc",
 161             18, 45, Float.NaN, null);
 162     store.add(sf3);
 163     // repeat for different feature type
 164     SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20,
 165             Float.NaN, null);
 166     store.add(sf4);
 167     SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0,
 168             Float.NaN, null);
 169     store.add(sf5);
 170     SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18,
 171             45, Float.NaN, null);
 172     store.add(sf6);
 173     // one more non-positional, different description
 174     SequenceFeature sf7 = new SequenceFeature("Pfam", "desc2", 0, 0,
 175             Float.NaN, null);
 176     store.add(sf7);
 177
 178     /*
 179      * get all non-positional features
 180      */
 181     List<SequenceFeature> features = store.getNonPositionalFeatures();
 182     assertEquals(features.size(), 3);
 183     assertTrue(features.contains(sf2));
 184     assertTrue(features.contains(sf5));
 185     assertTrue(features.contains(sf7));
 186
 187     /*
 188      * get non-positional features by type
 189      */
 190     assertTrue(store.getNonPositionalFeatures(null).isEmpty());
 191     assertTrue(store.getNonPositionalFeatures("Cath").isEmpty());
 192     assertTrue(store.getNonPositionalFeatures("PFAM").isEmpty());
 193
 194     features = store.getNonPositionalFeatures("Metal");
 195     assertEquals(features.size(), 1);
 196     assertTrue(features.contains(sf2));
 197
 198     features = store.getNonPositionalFeatures("Pfam");
 199     assertEquals(features.size(), 2);
 200     assertTrue(features.contains(sf5));
 201     assertTrue(features.contains(sf7));
 202   }
 203
 204   /**
 205    * Helper method to add a feature of no particular type
 206    *
 207    * @param sf
 208    * @param type
 209    * @param from
 210    * @param to
 211    * @return
 212    */
 213   SequenceFeature addFeature(SequenceFeatures sf, String type, int from,
 214           int to)
 215   {
 216     SequenceFeature sf1 = new SequenceFeature(type, "", from, to,
 217             Float.NaN,
 218             null);
 219     sf.add(sf1);
 220     return sf1;
 221   }
 222
 223   @Test(groups = "Functional")
 224   public void testFindFeatures()
 225   {
 226     SequenceFeatures sf = new SequenceFeatures();
 227     SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
 228     SequenceFeature sf2 = addFeature(sf, "Pfam", 1, 15);
 229     SequenceFeature sf3 = addFeature(sf, "Pfam", 20, 30);
 230     SequenceFeature sf4 = addFeature(sf, "Pfam", 40, 100);
 231     SequenceFeature sf5 = addFeature(sf, "Pfam", 60, 100);
 232     SequenceFeature sf6 = addFeature(sf, "Pfam", 70, 70);
 233     SequenceFeature sf7 = addFeature(sf, "Cath", 10, 50);
 234     SequenceFeature sf8 = addFeature(sf, "Cath", 1, 15);
 235     SequenceFeature sf9 = addFeature(sf, "Cath", 20, 30);
 236     SequenceFeature sf10 = addFeature(sf, "Cath", 40, 100);
 237     SequenceFeature sf11 = addFeature(sf, "Cath", 60, 100);
 238     SequenceFeature sf12 = addFeature(sf, "Cath", 70, 70);
 239     // null type is weird but possible:
 240     SequenceFeature sf13 = addFeature(sf, null, 5, 12);
 241
 242     List<SequenceFeature> overlaps = sf.findFeatures("Pfam", 200, 200);
 243     assertTrue(overlaps.isEmpty());
 244
 245     overlaps = sf.findFeatures("Pfam", 1, 9);
 246     assertEquals(overlaps.size(), 1);
 247     assertTrue(overlaps.contains(sf2));
 248
 249     overlaps = sf.findFeatures("Pfam", 5, 18);
 250     assertEquals(overlaps.size(), 2);
 251     assertTrue(overlaps.contains(sf1));
 252     assertTrue(overlaps.contains(sf2));
 253
 254     overlaps = sf.findFeatures("Pfam", 30, 40);
 255     assertEquals(overlaps.size(), 3);
 256     assertTrue(overlaps.contains(sf1));
 257     assertTrue(overlaps.contains(sf3));
 258     assertTrue(overlaps.contains(sf4));
 259
 260     overlaps = sf.findFeatures("Pfam", 80, 90);
 261     assertEquals(overlaps.size(), 2);
 262     assertTrue(overlaps.contains(sf4));
 263     assertTrue(overlaps.contains(sf5));
 264
 265     overlaps = sf.findFeatures("Pfam", 68, 70);
 266     assertEquals(overlaps.size(), 3);
 267     assertTrue(overlaps.contains(sf4));
 268     assertTrue(overlaps.contains(sf5));
 269     assertTrue(overlaps.contains(sf6));
 270
 271     overlaps = sf.findFeatures("Cath", 16, 69);
 272     assertEquals(overlaps.size(), 4);
 273     assertTrue(overlaps.contains(sf7));
 274     assertFalse(overlaps.contains(sf8));
 275     assertTrue(overlaps.contains(sf9));
 276     assertTrue(overlaps.contains(sf10));
 277     assertTrue(overlaps.contains(sf11));
 278     assertFalse(overlaps.contains(sf12));
 279
 280     assertTrue(sf.findFeatures("Metal", 0, 1000).isEmpty());
 281
 282     overlaps = sf.findFeatures(null, 7, 7);
 283     assertEquals(overlaps.size(), 1);
 284     assertTrue(overlaps.contains(sf13));
 285   }
 286
 287   @Test(groups = "Functional")
 288   public void testDelete()
 289   {
 290     SequenceFeatures sf = new SequenceFeatures();
 291     SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
 292     assertTrue(sf.getFeatures().contains(sf1));
 293
 294     assertFalse(sf.delete(null));
 295     SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 15, 0f, null);
 296     assertFalse(sf.delete(sf2)); // not added, can't delete it
 297     assertTrue(sf.delete(sf1));
 298     assertTrue(sf.getFeatures().isEmpty());
 299   }
 300 }