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.assertSame;
   6 import static org.testng.Assert.assertTrue;
   7
   8 import jalview.datamodel.SequenceFeature;
   9
  10 import java.util.ArrayList;
  11 import java.util.List;
  12 import java.util.Set;
  13
  14 import org.testng.annotations.Test;
  15
  16 public class FeatureStoreTest
  17 {
  18
  19   @Test(groups = "Functional")
  20   public void testFindFeatures_nonNested()
  21   {
  22     FeatureStoreI fs = newFeatureStore();
  23     fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN,
  24             null));
  25     // same range different description
  26     fs.addFeature(new SequenceFeature("", "desc", 10, 20, Float.NaN, null));
  27     fs.addFeature(new SequenceFeature("", "", 15, 25, Float.NaN, null));
  28     fs.addFeature(new SequenceFeature("", "", 20, 35, Float.NaN, null));
  29
  30     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
  31     assertTrue(overlaps.isEmpty());
  32
  33     overlaps = fs.findOverlappingFeatures(8, 10);
  34     assertEquals(overlaps.size(), 2);
  35     assertEquals(overlaps.get(0).getEnd(), 20);
  36     assertEquals(overlaps.get(1).getEnd(), 20);
  37
  38     overlaps = fs.findOverlappingFeatures(12, 16);
  39     assertEquals(overlaps.size(), 3);
  40     assertEquals(overlaps.get(0).getEnd(), 20);
  41     assertEquals(overlaps.get(1).getEnd(), 20);
  42     assertEquals(overlaps.get(2).getEnd(), 25);
  43
  44     overlaps = fs.findOverlappingFeatures(33, 33);
  45     assertEquals(overlaps.size(), 1);
  46     assertEquals(overlaps.get(0).getEnd(), 35);
  47   }
  48
  49   private FeatureStoreI newFeatureStore()
  50   {
  51     // return new FeatureStoreJS();
  52     return new FeatureStoreImpl();
  53   }
  54
  55   @Test(groups = "Functional")
  56   public void testFindFeatures_nested()
  57   {
  58     FeatureStoreI fs = newFeatureStore();
  59     SequenceFeature sf1 = addFeature(fs, 10, 50);
  60     SequenceFeature sf2 = addFeature(fs, 10, 40);
  61     SequenceFeature sf3 = addFeature(fs, 20, 30);
  62     // fudge feature at same location but different group (so is added)
  63     SequenceFeature sf4 = new SequenceFeature("", "", 20, 30, Float.NaN,
  64             "different group");
  65     fs.addFeature(sf4);
  66     SequenceFeature sf5 = addFeature(fs, 35, 36);
  67
  68     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
  69     assertTrue(overlaps.isEmpty());
  70
  71     overlaps = fs.findOverlappingFeatures(10, 15);
  72     assertEquals(overlaps.size(), 2);
  73     assertTrue(overlaps.contains(sf1));
  74     assertTrue(overlaps.contains(sf2));
  75
  76     overlaps = fs.findOverlappingFeatures(45, 60);
  77     assertEquals(overlaps.size(), 1);
  78     assertTrue(overlaps.contains(sf1));
  79
  80     overlaps = fs.findOverlappingFeatures(32, 38);
  81     assertEquals(overlaps.size(), 3);
  82     assertTrue(overlaps.contains(sf1));
  83     assertTrue(overlaps.contains(sf2));
  84     assertTrue(overlaps.contains(sf5));
  85
  86     overlaps = fs.findOverlappingFeatures(15, 25);
  87     assertEquals(overlaps.size(), 4);
  88     assertTrue(overlaps.contains(sf1));
  89     assertTrue(overlaps.contains(sf2));
  90     assertTrue(overlaps.contains(sf3));
  91     assertTrue(overlaps.contains(sf4));
  92   }
  93
  94   @Test(groups = "Functional")
  95   public void testFindFeatures_mixed()
  96   {
  97     FeatureStoreI fs = newFeatureStore();
  98     SequenceFeature sf1 = addFeature(fs, 10, 50);
  99     SequenceFeature sf2 = addFeature(fs, 1, 15);
 100     SequenceFeature sf3 = addFeature(fs, 20, 30);
 101     SequenceFeature sf4 = addFeature(fs, 40, 100);
 102     SequenceFeature sf5 = addFeature(fs, 60, 100);
 103     SequenceFeature sf6 = addFeature(fs, 70, 70);
 104
 105     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(200, 200);
 106     assertTrue(overlaps.isEmpty());
 107
 108     overlaps = fs.findOverlappingFeatures(1, 9);
 109     assertEquals(overlaps.size(), 1);
 110     assertTrue(overlaps.contains(sf2));
 111
 112     overlaps = fs.findOverlappingFeatures(5, 18);
 113     assertEquals(overlaps.size(), 2);
 114     assertTrue(overlaps.contains(sf1));
 115     assertTrue(overlaps.contains(sf2));
 116
 117     overlaps = fs.findOverlappingFeatures(30, 40);
 118     assertEquals(overlaps.size(), 3);
 119     assertTrue(overlaps.contains(sf1));
 120     assertTrue(overlaps.contains(sf3));
 121     assertTrue(overlaps.contains(sf4));
 122
 123     overlaps = fs.findOverlappingFeatures(80, 90);
 124     assertEquals(overlaps.size(), 2);
 125     assertTrue(overlaps.contains(sf4));
 126     assertTrue(overlaps.contains(sf5));
 127
 128     overlaps = fs.findOverlappingFeatures(68, 70);
 129     assertEquals(overlaps.size(), 3);
 130     assertTrue(overlaps.contains(sf4));
 131     assertTrue(overlaps.contains(sf5));
 132     assertTrue(overlaps.contains(sf6));
 133   }
 134
 135   /**
 136    * Helper method to add a feature of no particular type
 137    *
 138    * @param fs
 139    * @param from
 140    * @param to
 141    * @return
 142    */
 143   SequenceFeature addFeature(FeatureStoreI fs, int from, int to)
 144   {
 145     SequenceFeature sf1 = new SequenceFeature("", "", from, to, Float.NaN,
 146             null);
 147     fs.addFeature(sf1);
 148     return sf1;
 149   }
 150
 151   @Test(groups = "Functional")
 152   public void testFindFeatures_contactFeatures()
 153   {
 154     FeatureStoreI fs = newFeatureStore();
 155
 156     SequenceFeature sf = new SequenceFeature("disulphide bond", "bond", 10,
 157             20, Float.NaN, null);
 158     fs.addFeature(sf);
 159
 160     /*
 161      * neither contact point in range
 162      */
 163     List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
 164     assertTrue(overlaps.isEmpty());
 165
 166     /*
 167      * neither contact point in range
 168      */
 169     overlaps = fs.findOverlappingFeatures(11, 19);
 170     assertTrue(overlaps.isEmpty());
 171
 172     /*
 173      * first contact point in range
 174      */
 175     overlaps = fs.findOverlappingFeatures(5, 15);
 176     assertEquals(overlaps.size(), 1);
 177     assertTrue(overlaps.contains(sf));
 178
 179     /*
 180      * second contact point in range
 181      */
 182     overlaps = fs.findOverlappingFeatures(15, 25);
 183     assertEquals(overlaps.size(), 1);
 184     assertTrue(overlaps.contains(sf));
 185
 186     /*
 187      * both contact points in range
 188      */
 189     overlaps = fs.findOverlappingFeatures(5, 25);
 190     assertEquals(overlaps.size(), 1);
 191     assertTrue(overlaps.contains(sf));
 192   }
 193
 194   @Test(groups = "Functional")
 195   public void testGetPositionalFeatures()
 196   {
 197     FeatureStoreI store = newFeatureStore();
 198     SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
 199             Float.NaN, null);
 200     store.addFeature(sf1);
 201     // same range, different description
 202     SequenceFeature sf2 = new SequenceFeature("Metal", "desc2", 10, 20,
 203             Float.NaN, null);
 204     store.addFeature(sf2);
 205     // discontiguous range
 206     SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 30, 40,
 207             Float.NaN, null);
 208     store.addFeature(sf3);
 209     // overlapping range
 210     SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 15, 35,
 211             Float.NaN, null);
 212     store.addFeature(sf4);
 213     // enclosing range
 214     SequenceFeature sf5 = new SequenceFeature("Metal", "desc", 5, 50,
 215             Float.NaN, null);
 216     store.addFeature(sf5);
 217     // non-positional feature
 218     SequenceFeature sf6 = new SequenceFeature("Metal", "desc", 0, 0,
 219             Float.NaN, null);
 220     store.addFeature(sf6);
 221     // contact feature
 222     SequenceFeature sf7 = new SequenceFeature("Disulphide bond", "desc",
 223             18, 45, Float.NaN, null);
 224     store.addFeature(sf7);
 225
 226     List<SequenceFeature> features = store.getPositionalFeatures();
 227     assertEquals(features.size(), 6);
 228     assertTrue(features.contains(sf1));
 229     assertTrue(features.contains(sf2));
 230     assertTrue(features.contains(sf3));
 231     assertTrue(features.contains(sf4));
 232     assertTrue(features.contains(sf5));
 233     assertFalse(features.contains(sf6));
 234     assertTrue(features.contains(sf7));
 235
 236     features = store.getNonPositionalFeatures();
 237     assertEquals(features.size(), 1);
 238     assertTrue(features.contains(sf6));
 239   }
 240
 241   @Test(groups = "Functional")
 242   public void testDelete()
 243   {
 244     FeatureStoreI store = newFeatureStore();
 245     SequenceFeature sf1 = addFeature(store, 10, 20);
 246     assertTrue(store.getPositionalFeatures().contains(sf1));
 247
 248     /*
 249      * simple deletion
 250      */
 251     assertTrue(store.delete(sf1));
 252     assertTrue(store.getPositionalFeatures().isEmpty());
 253
 254     /*
 255      * non-positional feature deletion
 256      */
 257     SequenceFeature sf2 = addFeature(store, 0, 0);
 258     assertFalse(store.getPositionalFeatures().contains(sf2));
 259     assertTrue(store.getNonPositionalFeatures().contains(sf2));
 260     assertTrue(store.delete(sf2));
 261     assertTrue(store.getNonPositionalFeatures().isEmpty());
 262
 263     /*
 264      * contact feature deletion
 265      */
 266     SequenceFeature sf3 = new SequenceFeature("", "Disulphide Bond", 11,
 267             23, Float.NaN, null);
 268     store.addFeature(sf3);
 269     assertEquals(store.getPositionalFeatures().size(), 1);
 270     assertTrue(store.getPositionalFeatures().contains(sf3));
 271     assertTrue(store.delete(sf3));
 272     assertTrue(store.getPositionalFeatures().isEmpty());
 273
 274     /*
 275      * nested feature deletion
 276      */
 277     SequenceFeature sf4 = addFeature(store, 20, 30);
 278     SequenceFeature sf5 = addFeature(store, 22, 26); // to NCList
 279     SequenceFeature sf6 = addFeature(store, 23, 24); // child of sf5
 280     SequenceFeature sf7 = addFeature(store, 25, 25); // sibling of sf6
 281     SequenceFeature sf8 = addFeature(store, 24, 24); // child of sf6
 282     SequenceFeature sf9 = addFeature(store, 23, 23); // child of sf6
 283     assertEquals(store.getPositionalFeatures().size(), 6);
 284
 285     // delete a node with children - they take its place
 286     assertTrue(store.delete(sf6)); // sf8, sf9 should become children of sf5
 287     assertEquals(store.getPositionalFeatures().size(), 5);
 288     assertFalse(store.getPositionalFeatures().contains(sf6));
 289
 290     // delete a node with no children
 291     assertTrue(store.delete(sf7));
 292     assertEquals(store.getPositionalFeatures().size(), 4);
 293     assertFalse(store.getPositionalFeatures().contains(sf7));
 294
 295     // delete root of NCList
 296     assertTrue(store.delete(sf5));
 297     assertEquals(store.getPositionalFeatures().size(), 3);
 298     assertFalse(store.getPositionalFeatures().contains(sf5));
 299
 300     // continue the killing fields
 301     assertTrue(store.delete(sf4));
 302     assertEquals(store.getPositionalFeatures().size(), 2);
 303     assertFalse(store.getPositionalFeatures().contains(sf4));
 304
 305     assertTrue(store.delete(sf9));
 306     assertEquals(store.getPositionalFeatures().size(), 1);
 307     assertFalse(store.getPositionalFeatures().contains(sf9));
 308
 309     assertTrue(store.delete(sf8));
 310     assertTrue(store.getPositionalFeatures().isEmpty());
 311   }
 312
 313   @Test(groups = "Functional")
 314   public void testAddFeature()
 315   {
 316     FeatureStoreI fs = newFeatureStore();
 317
 318     SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
 319             Float.NaN, null);
 320     SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 20,
 321             Float.NaN, null);
 322
 323     assertTrue(fs.addFeature(sf1));
 324     assertEquals(fs.getFeatureCount(true), 1); // positional
 325     assertEquals(fs.getFeatureCount(false), 0); // non-positional
 326
 327     /*
 328      * re-adding the same or an identical feature should fail
 329      */
 330     assertFalse(fs.addFeature(sf1));
 331     assertEquals(fs.getFeatureCount(true), 1);
 332     assertFalse(fs.addFeature(sf2));
 333     assertEquals(fs.getFeatureCount(true), 1);
 334
 335     /*
 336      * add non-positional
 337      */
 338     SequenceFeature sf3 = new SequenceFeature("Cath", "", 0, 0, Float.NaN,
 339             null);
 340     assertTrue(fs.addFeature(sf3));
 341     assertEquals(fs.getFeatureCount(true), 1); // positional
 342     assertEquals(fs.getFeatureCount(false), 1); // non-positional
 343     SequenceFeature sf4 = new SequenceFeature("Cath", "", 0, 0, Float.NaN,
 344             null);
 345     assertFalse(fs.addFeature(sf4)); // already stored
 346     assertEquals(fs.getFeatureCount(true), 1); // positional
 347     assertEquals(fs.getFeatureCount(false), 1); // non-positional
 348
 349     /*
 350      * add contact
 351      */
 352     SequenceFeature sf5 = new SequenceFeature("Disulfide bond", "", 10, 20,
 353             Float.NaN, null);
 354     assertTrue(fs.addFeature(sf5));
 355     assertEquals(fs.getFeatureCount(true), 2); // positional - add 1 for contact
 356     assertEquals(fs.getFeatureCount(false), 1); // non-positional
 357     SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "", 10, 20,
 358             Float.NaN, null);
 359     assertFalse(fs.addFeature(sf6)); // already stored
 360     assertEquals(fs.getFeatureCount(true), 2); // no change
 361     assertEquals(fs.getFeatureCount(false), 1); // no change
 362   }
 363
 364   @Test(groups = "Functional")
 365   public void testIsEmpty()
 366   {
 367     FeatureStoreI fs = newFeatureStore();
 368     assertTrue(fs.isEmpty());
 369     assertEquals(fs.getFeatureCount(true), 0);
 370
 371     /*
 372      * non-nested feature
 373      */
 374     SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
 375             Float.NaN, null);
 376     fs.addFeature(sf1);
 377     assertFalse(fs.isEmpty());
 378     assertEquals(fs.getFeatureCount(true), 1);
 379     fs.delete(sf1);
 380     assertTrue(fs.isEmpty());
 381     assertEquals(fs.getFeatureCount(true), 0);
 382
 383     /*
 384      * non-positional feature
 385      */
 386     sf1 = new SequenceFeature("Cath", "", 0, 0, Float.NaN, null);
 387     fs.addFeature(sf1);
 388     assertFalse(fs.isEmpty());
 389     assertEquals(fs.getFeatureCount(false), 1); // non-positional
 390     assertEquals(fs.getFeatureCount(true), 0); // positional
 391     fs.delete(sf1);
 392     assertTrue(fs.isEmpty());
 393     assertEquals(fs.getFeatureCount(false), 0);
 394
 395     /*
 396      * contact feature
 397      */
 398     sf1 = new SequenceFeature("Disulfide bond", "", 19, 49, Float.NaN, null);
 399     fs.addFeature(sf1);
 400     assertFalse(fs.isEmpty());
 401     assertEquals(fs.getFeatureCount(true), 1);
 402     fs.delete(sf1);
 403     assertTrue(fs.isEmpty());
 404     assertEquals(fs.getFeatureCount(true), 0);
 405
 406     /*
 407      * sf2, sf3 added as nested features
 408      */
 409     sf1 = new SequenceFeature("Cath", "", 19, 49, Float.NaN, null);
 410     SequenceFeature sf2 = new SequenceFeature("Cath", "", 20, 40,
 411             Float.NaN, null);
 412     SequenceFeature sf3 = new SequenceFeature("Cath", "", 25, 35,
 413             Float.NaN, null);
 414     fs.addFeature(sf1);
 415     fs.addFeature(sf2);
 416     fs.addFeature(sf3);
 417     assertEquals(fs.getFeatureCount(true), 3);
 418     assertTrue(fs.delete(sf1));
 419     assertEquals(fs.getFeatureCount(true), 2);
 420     assertEquals(fs.getFeatures().size(), 2);
 421     assertFalse(fs.isEmpty());
 422     assertTrue(fs.delete(sf2));
 423     assertEquals(fs.getFeatureCount(true), 1);
 424     assertFalse(fs.isEmpty());
 425     assertTrue(fs.delete(sf3));
 426     assertEquals(fs.getFeatureCount(true), 0);
 427     assertTrue(fs.isEmpty()); // all gone
 428   }
 429
 430   @Test(groups = "Functional")
 431   public void testGetFeatureGroups()
 432   {
 433     FeatureStoreI fs = newFeatureStore();
 434     assertTrue(fs.getFeatureGroups(true).isEmpty());
 435     assertTrue(fs.getFeatureGroups(false).isEmpty());
 436
 437     SequenceFeature sf1 = new SequenceFeature("Cath", "desc", 10, 20, 1f, "group1");
 438     fs.addFeature(sf1);
 439     Set<String> groups = fs.getFeatureGroups(true);
 440     assertEquals(groups.size(), 1);
 441     assertTrue(groups.contains("group1"));
 442
 443     /*
 444      * add another feature of the same group, delete one, delete both
 445      */
 446     SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 20, 30, 1f, "group1");
 447     fs.addFeature(sf2);
 448     groups = fs.getFeatureGroups(true);
 449     assertEquals(groups.size(), 1);
 450     assertTrue(groups.contains("group1"));
 451     fs.delete(sf2);
 452     groups = fs.getFeatureGroups(true);
 453     assertEquals(groups.size(), 1);
 454     assertTrue(groups.contains("group1"));
 455     fs.delete(sf1);
 456     groups = fs.getFeatureGroups(true);
 457     assertTrue(fs.getFeatureGroups(true).isEmpty());
 458
 459     SequenceFeature sf3 = new SequenceFeature("Cath", "desc", 20, 30, 1f, "group2");
 460     fs.addFeature(sf3);
 461     SequenceFeature sf4 = new SequenceFeature("Cath", "desc", 20, 30, 1f, "Group2");
 462     fs.addFeature(sf4);
 463     SequenceFeature sf5 = new SequenceFeature("Cath", "desc", 20, 30, 1f, null);
 464     fs.addFeature(sf5);
 465     groups = fs.getFeatureGroups(true);
 466     assertEquals(groups.size(), 3);
 467     assertTrue(groups.contains("group2"));
 468     assertTrue(groups.contains("Group2")); // case sensitive
 469     assertTrue(groups.contains(null)); // null allowed
 470     assertTrue(fs.getFeatureGroups(false).isEmpty()); // non-positional
 471
 472     fs.delete(sf3);
 473     groups = fs.getFeatureGroups(true);
 474     assertEquals(groups.size(), 2);
 475     assertFalse(groups.contains("group2"));
 476     fs.delete(sf4);
 477     groups = fs.getFeatureGroups(true);
 478     assertEquals(groups.size(), 1);
 479     assertFalse(groups.contains("Group2"));
 480     fs.delete(sf5);
 481     groups = fs.getFeatureGroups(true);
 482     assertTrue(groups.isEmpty());
 483
 484     /*
 485      * add non-positional feature
 486      */
 487     SequenceFeature sf6 = new SequenceFeature("Cath", "desc", 0, 0, 1f,
 488             "CathGroup");
 489     fs.addFeature(sf6);
 490     groups = fs.getFeatureGroups(false);
 491     assertEquals(groups.size(), 1);
 492     assertTrue(groups.contains("CathGroup"));
 493     assertTrue(fs.delete(sf6));
 494     assertTrue(fs.getFeatureGroups(false).isEmpty());
 495   }
 496
 497   @Test(groups = "Functional")
 498   public void testGetTotalFeatureLength()
 499   {
 500     FeatureStoreI fs = newFeatureStore();
 501     assertEquals(fs.getTotalFeatureLength(), 0);
 502
 503     addFeature(fs, 10, 20); // 11
 504     assertEquals(fs.getTotalFeatureLength(), 11);
 505     addFeature(fs, 17, 37); // 21
 506     SequenceFeature sf1 = addFeature(fs, 14, 74); // 61
 507     assertEquals(fs.getTotalFeatureLength(), 93);
 508
 509     // non-positional features don't count
 510     SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 0, 0, 1f,
 511             "group1");
 512     fs.addFeature(sf2);
 513     assertEquals(fs.getTotalFeatureLength(), 93);
 514
 515     // contact features count 1
 516     SequenceFeature sf3 = new SequenceFeature("disulphide bond", "desc",
 517             15, 35, 1f, "group1");
 518     fs.addFeature(sf3);
 519     assertEquals(fs.getTotalFeatureLength(), 94);
 520
 521     assertTrue(fs.delete(sf1));
 522     assertEquals(fs.getTotalFeatureLength(), 33);
 523     assertFalse(fs.delete(sf1));
 524     assertEquals(fs.getTotalFeatureLength(), 33);
 525     assertTrue(fs.delete(sf2));
 526     assertEquals(fs.getTotalFeatureLength(), 33);
 527     assertTrue(fs.delete(sf3));
 528     assertEquals(fs.getTotalFeatureLength(), 32);
 529   }
 530
 531   @Test(groups = "Functional")
 532   public void testGetFeatureLength()
 533   {
 534     /*
 535      * positional feature
 536      */
 537     SequenceFeature sf1 = new SequenceFeature("Cath", "desc", 10, 20, 1f, "group1");
 538     assertEquals(FeatureStore.getFeatureLength(sf1), 11);
 539
 540     /*
 541      * non-positional feature
 542      */
 543     SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 0, 0, 1f,
 544             "CathGroup");
 545     assertEquals(FeatureStore.getFeatureLength(sf2), 0);
 546
 547     /*
 548      * contact feature counts 1
 549      */
 550     SequenceFeature sf3 = new SequenceFeature("Disulphide Bond", "desc",
 551             14, 28, 1f, "AGroup");
 552     assertEquals(FeatureStore.getFeatureLength(sf3), 1);
 553   }
 554
 555   @Test(groups = "Functional")
 556   public void testMin()
 557   {
 558     assertEquals(FeatureStore.min(Float.NaN, Float.NaN), Float.NaN);
 559     assertEquals(FeatureStore.min(Float.NaN, 2f), 2f);
 560     assertEquals(FeatureStore.min(-2f, Float.NaN), -2f);
 561     assertEquals(FeatureStore.min(2f, -3f), -3f);
 562   }
 563
 564   @Test(groups = "Functional")
 565   public void testMax()
 566   {
 567     assertEquals(FeatureStore.max(Float.NaN, Float.NaN), Float.NaN);
 568     assertEquals(FeatureStore.max(Float.NaN, 2f), 2f);
 569     assertEquals(FeatureStore.max(-2f, Float.NaN), -2f);
 570     assertEquals(FeatureStore.max(2f, -3f), 2f);
 571   }
 572
 573   @Test(groups = "Functional")
 574   public void testGetMinimumScore_getMaximumScore()
 575   {
 576     FeatureStoreI fs = newFeatureStore();
 577     assertEquals(fs.getMinimumScore(true), Float.NaN); // positional
 578     assertEquals(fs.getMaximumScore(true), Float.NaN);
 579     assertEquals(fs.getMinimumScore(false), Float.NaN); // non-positional
 580     assertEquals(fs.getMaximumScore(false), Float.NaN);
 581
 582     // add features with no score
 583     SequenceFeature sf1 = new SequenceFeature("type", "desc", 0, 0,
 584             Float.NaN, "group");
 585     fs.addFeature(sf1);
 586     SequenceFeature sf2 = new SequenceFeature("type", "desc", 10, 20,
 587             Float.NaN, "group");
 588     fs.addFeature(sf2);
 589     assertEquals(fs.getMinimumScore(true), Float.NaN);
 590     assertEquals(fs.getMaximumScore(true), Float.NaN);
 591     assertEquals(fs.getMinimumScore(false), Float.NaN);
 592     assertEquals(fs.getMaximumScore(false), Float.NaN);
 593
 594     // add positional features with score
 595     SequenceFeature sf3 = new SequenceFeature("type", "desc", 10, 20, 1f,
 596             "group");
 597     fs.addFeature(sf3);
 598     SequenceFeature sf4 = new SequenceFeature("type", "desc", 12, 16, 4f,
 599             "group");
 600     fs.addFeature(sf4);
 601     assertEquals(fs.getMinimumScore(true), 1f);
 602     assertEquals(fs.getMaximumScore(true), 4f);
 603     assertEquals(fs.getMinimumScore(false), Float.NaN);
 604     assertEquals(fs.getMaximumScore(false), Float.NaN);
 605
 606     // add non-positional features with score
 607     SequenceFeature sf5 = new SequenceFeature("type", "desc", 0, 0, 11f,
 608             "group");
 609     fs.addFeature(sf5);
 610     SequenceFeature sf6 = new SequenceFeature("type", "desc", 0, 0, -7f,
 611             "group");
 612     fs.addFeature(sf6);
 613     assertEquals(fs.getMinimumScore(true), 1f);
 614     assertEquals(fs.getMaximumScore(true), 4f);
 615     assertEquals(fs.getMinimumScore(false), -7f);
 616     assertEquals(fs.getMaximumScore(false), 11f);
 617
 618     // delete one positional and one non-positional
 619     // min-max should be recomputed
 620     assertTrue(fs.delete(sf6));
 621     assertTrue(fs.delete(sf3));
 622     assertEquals(fs.getMinimumScore(true), 4f);
 623     assertEquals(fs.getMaximumScore(true), 4f);
 624     assertEquals(fs.getMinimumScore(false), 11f);
 625     assertEquals(fs.getMaximumScore(false), 11f);
 626
 627     // delete remaining features with score
 628     assertTrue(fs.delete(sf4));
 629     assertTrue(fs.delete(sf5));
 630     assertEquals(fs.getMinimumScore(true), Float.NaN);
 631     assertEquals(fs.getMaximumScore(true), Float.NaN);
 632     assertEquals(fs.getMinimumScore(false), Float.NaN);
 633     assertEquals(fs.getMaximumScore(false), Float.NaN);
 634
 635     // delete all features
 636     assertTrue(fs.delete(sf1));
 637     assertTrue(fs.delete(sf2));
 638     assertTrue(fs.isEmpty());
 639     assertEquals(fs.getMinimumScore(true), Float.NaN);
 640     assertEquals(fs.getMaximumScore(true), Float.NaN);
 641     assertEquals(fs.getMinimumScore(false), Float.NaN);
 642     assertEquals(fs.getMaximumScore(false), Float.NaN);
 643   }
 644
 645   @Test(groups = "Functional")
 646   public void testListContains()
 647   {
 648     assertFalse(FeatureStore.listContains(null, null));
 649     List<SequenceFeature> features = new ArrayList<>();
 650     assertFalse(FeatureStore.listContains(features, null));
 651
 652     SequenceFeature sf1 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
 653             "group1");
 654     assertFalse(FeatureStore.listContains(null, sf1));
 655     assertFalse(FeatureStore.listContains(features, sf1));
 656
 657     features.add(sf1);
 658     SequenceFeature sf2 = new SequenceFeature("type1", "desc1", 20, 30, 3f,
 659             "group1");
 660     SequenceFeature sf3 = new SequenceFeature("type1", "desc1", 20, 40, 3f,
 661             "group1");
 662
 663     // sf2.equals(sf1) so contains should return true
 664     assertTrue(FeatureStore.listContains(features, sf2));
 665     assertFalse(FeatureStore.listContains(features, sf3));
 666   }
 667
 668   @Test(groups = "Functional")
 669   public void testGetFeaturesForGroup()
 670   {
 671     FeatureStoreI fs = newFeatureStore();
 672
 673     /*
 674      * with no features
 675      */
 676     assertTrue(fs.getFeaturesForGroup(true, null).isEmpty());
 677     assertTrue(fs.getFeaturesForGroup(false, null).isEmpty());
 678     assertTrue(fs.getFeaturesForGroup(true, "uniprot").isEmpty());
 679     assertTrue(fs.getFeaturesForGroup(false, "uniprot").isEmpty());
 680
 681     /*
 682      * sf1: positional feature in the null group
 683      */
 684     SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 4, 10, 0f,
 685             null);
 686     fs.addFeature(sf1);
 687     assertTrue(fs.getFeaturesForGroup(true, "uniprot").isEmpty());
 688     assertTrue(fs.getFeaturesForGroup(false, "uniprot").isEmpty());
 689     assertTrue(fs.getFeaturesForGroup(false, null).isEmpty());
 690     List<SequenceFeature> features = fs.getFeaturesForGroup(true, null);
 691     assertEquals(features.size(), 1);
 692     assertTrue(features.contains(sf1));
 693
 694     /*
 695      * sf2: non-positional feature in the null group
 696      * sf3: positional feature in a non-null group
 697      * sf4: non-positional feature in a non-null group
 698      */
 699     SequenceFeature sf2 = new SequenceFeature("Pfam", "desc", 0, 0, 0f,
 700             null);
 701     SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 4, 10, 0f,
 702             "Uniprot");
 703     SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 0, 0, 0f,
 704             "Rfam");
 705     fs.addFeature(sf2);
 706     fs.addFeature(sf3);
 707     fs.addFeature(sf4);
 708
 709     features = fs.getFeaturesForGroup(true, null);
 710     assertEquals(features.size(), 1);
 711     assertTrue(features.contains(sf1));
 712
 713     features = fs.getFeaturesForGroup(false, null);
 714     assertEquals(features.size(), 1);
 715     assertTrue(features.contains(sf2));
 716
 717     features = fs.getFeaturesForGroup(true, "Uniprot");
 718     assertEquals(features.size(), 1);
 719     assertTrue(features.contains(sf3));
 720
 721     features = fs.getFeaturesForGroup(false, "Rfam");
 722     assertEquals(features.size(), 1);
 723     assertTrue(features.contains(sf4));
 724   }
 725
 726   @Test(groups = "Functional")
 727   public void testShiftFeatures()
 728   {
 729     FeatureStoreI fs = newFeatureStore();
 730     assertFalse(fs.shiftFeatures(0, 1)); // nothing to do
 731
 732     SequenceFeature sf1 = new SequenceFeature("Cath", "", 2, 5, 0f, null);
 733     fs.addFeature(sf1);
 734     // nested feature:
 735     SequenceFeature sf2 = new SequenceFeature("Cath", "", 8, 14, 0f, null);
 736     fs.addFeature(sf2);
 737     // contact feature:
 738     SequenceFeature sf3 = new SequenceFeature("Disulfide bond", "", 23, 32,
 739             0f, null);
 740     fs.addFeature(sf3);
 741     // non-positional feature:
 742     SequenceFeature sf4 = new SequenceFeature("Cath", "", 0, 0, 0f, null);
 743     fs.addFeature(sf4);
 744
 745     /*
 746      * shift all features right by 5
 747      */
 748     assertTrue(fs.shiftFeatures(0, 5));
 749
 750     // non-positional features untouched:
 751     List<SequenceFeature> nonPos = fs.getNonPositionalFeatures();
 752     assertEquals(nonPos.size(), 1);
 753     assertTrue(nonPos.contains(sf4));
 754
 755     // positional features are replaced
 756     List<SequenceFeature> pos = fs.getPositionalFeatures();
 757     assertEquals(pos.size(), 3);
 758     assertFalse(pos.contains(sf1));
 759     assertFalse(pos.contains(sf2));
 760     assertFalse(pos.contains(sf3));
 761     SequenceFeatures.sortFeatures(pos, true); // ascending start pos
 762     assertEquals(pos.get(0).getBegin(), 7);
 763     assertEquals(pos.get(0).getEnd(), 10);
 764     assertEquals(pos.get(1).getBegin(), 13);
 765     assertEquals(pos.get(1).getEnd(), 19);
 766     assertEquals(pos.get(2).getBegin(), 28);
 767     assertEquals(pos.get(2).getEnd(), 37);
 768
 769     /*
 770      * now shift left by 15
 771      * feature at [7-10] should be removed
 772      * feature at [13-19] should become [1-4]
 773      */
 774     assertTrue(fs.shiftFeatures(0, -15));
 775     pos = fs.getPositionalFeatures();
 776     assertEquals(pos.size(), 2);
 777     SequenceFeatures.sortFeatures(pos, true);
 778     assertEquals(pos.get(0).getBegin(), 1);
 779     assertEquals(pos.get(0).getEnd(), 4);
 780     assertEquals(pos.get(1).getBegin(), 13);
 781     assertEquals(pos.get(1).getEnd(), 22);
 782
 783     /*
 784      * shift right by 4 from position 2 onwards
 785      * feature at [1-4] unchanged, feature at [13-22] shifts
 786      */
 787     assertTrue(fs.shiftFeatures(2, 4));
 788     pos = fs.getPositionalFeatures();
 789     assertEquals(pos.size(), 2);
 790     SequenceFeatures.sortFeatures(pos, true);
 791     assertEquals(pos.get(0).getBegin(), 1);
 792     assertEquals(pos.get(0).getEnd(), 4);
 793     assertEquals(pos.get(1).getBegin(), 17);
 794     assertEquals(pos.get(1).getEnd(), 26);
 795
 796     /*
 797      * shift right by 4 from position 18 onwards
 798      * should be no change
 799      */
 800     SequenceFeature f1 = pos.get(0);
 801     SequenceFeature f2 = pos.get(1);
 802     assertFalse(fs.shiftFeatures(18, 4)); // no update
 803     pos = fs.getPositionalFeatures();
 804     assertEquals(pos.size(), 2);
 805     SequenceFeatures.sortFeatures(pos, true);
 806     assertSame(pos.get(0), f1);
 807     assertSame(pos.get(1), f2);
 808   }
 809
 810   @Test(groups = "Functional")
 811   public void testDelete_readd()
 812   {
 813     /*
 814      * add a feature and a nested feature
 815      */
 816     FeatureStoreI store = newFeatureStore();
 817     SequenceFeature sf1 = addFeature(store, 10, 20);
 818     // sf2 is nested in sf1 so will be stored in nestedFeatures
 819     SequenceFeature sf2 = addFeature(store, 12, 14);
 820     List<SequenceFeature> features = store.getPositionalFeatures();
 821     assertEquals(features.size(), 2);
 822     assertTrue(features.contains(sf1));
 823     assertTrue(features.contains(sf2));
 824     assertTrue(store.getFeatures().contains(sf1));
 825     assertTrue(store.getFeatures().contains(sf2));
 826
 827     /*
 828      * delete the first feature
 829      */
 830     assertTrue(store.delete(sf1));
 831     features = store.getPositionalFeatures();
 832     assertFalse(features.contains(sf1));
 833     assertTrue(features.contains(sf2));
 834
 835     /*
 836      * re-add the 'nested' feature; is it now duplicated?
 837      */
 838     store.addFeature(sf2);
 839     features = store.getPositionalFeatures();
 840     assertEquals(features.size(), 1);
 841     assertTrue(features.contains(sf2));
 842   }
 843
 844   @Test(groups = "Functional")
 845   public void testContains()
 846   {
 847     FeatureStoreI fs = newFeatureStore();
 848     SequenceFeature sf1 = new SequenceFeature("Cath", "", 10, 20,
 849             Float.NaN, "group1");
 850     SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 20,
 851             Float.NaN, "group2");
 852     SequenceFeature sf3 = new SequenceFeature("Cath", "", 0, 0, Float.NaN,
 853             "group1");
 854     SequenceFeature sf4 = new SequenceFeature("Cath", "", 0, 0, 0f,
 855             "group1");
 856     SequenceFeature sf5 = new SequenceFeature("Disulphide Bond", "", 5, 15,
 857             Float.NaN, "group1");
 858     SequenceFeature sf6 = new SequenceFeature("Disulphide Bond", "", 5, 15,
 859             Float.NaN, "group2");
 860
 861     fs.addFeature(sf1);
 862     fs.addFeature(sf3);
 863     fs.addFeature(sf5);
 864     assertTrue(fs.contains(sf1)); // positional feature
 865     assertTrue(fs.contains(new SequenceFeature(sf1))); // identical feature
 866     assertFalse(fs.contains(sf2)); // different group
 867     assertTrue(fs.contains(sf3)); // non-positional
 868     assertTrue(fs.contains(new SequenceFeature(sf3)));
 869     assertFalse(fs.contains(sf4)); // different score
 870     assertTrue(fs.contains(sf5)); // contact feature
 871     assertTrue(fs.contains(new SequenceFeature(sf5)));
 872     assertFalse(fs.contains(sf6)); // different group
 873
 874     /*
 875      * add a nested feature
 876      */
 877     SequenceFeature sf7 = new SequenceFeature("Cath", "", 12, 16,
 878             Float.NaN, "group1");
 879     fs.addFeature(sf7);
 880     assertTrue(fs.contains(sf7));
 881     assertTrue(fs.contains(new SequenceFeature(sf7)));
 882
 883     /*
 884      * delete the outer (enclosing, non-nested) feature
 885      */
 886     fs.delete(sf1);
 887     assertFalse(fs.contains(sf1));
 888     assertTrue(fs.contains(sf7));
 889   }
 890 }