1 package jalview.datamodel.features;
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;
8 import jalview.datamodel.SequenceFeature;
10 import java.util.ArrayList;
11 import java.util.Iterator;
12 import java.util.List;
15 import org.testng.annotations.Test;
17 public class SequenceFeaturesTest
19 @Test(groups = "Functional")
20 public void testGetPositionalFeatures()
22 SequenceFeaturesI store = new SequenceFeatures();
23 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
26 // same range, different description
27 SequenceFeature sf2 = new SequenceFeature("Metal", "desc2", 10, 20,
30 // discontiguous range
31 SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 30, 40,
35 SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 15, 35,
39 SequenceFeature sf5 = new SequenceFeature("Metal", "desc", 5, 50,
42 // non-positional feature
43 SequenceFeature sf6 = new SequenceFeature("Metal", "desc", 0, 0,
47 SequenceFeature sf7 = new SequenceFeature("Disulphide bond", "desc",
48 18, 45, Float.NaN, null);
50 // different feature type
51 SequenceFeature sf8 = new SequenceFeature("Pfam", "desc", 30, 40,
54 SequenceFeature sf9 = new SequenceFeature("Pfam", "desc", 15, 35,
59 * get all positional features
61 List<SequenceFeature> features = store.getPositionalFeatures();
62 assertEquals(features.size(), 8);
63 assertTrue(features.contains(sf1));
64 assertTrue(features.contains(sf2));
65 assertTrue(features.contains(sf3));
66 assertTrue(features.contains(sf4));
67 assertTrue(features.contains(sf5));
68 assertFalse(features.contains(sf6)); // non-positional
69 assertTrue(features.contains(sf7));
70 assertTrue(features.contains(sf8));
71 assertTrue(features.contains(sf9));
74 * get features by type
76 assertTrue(store.getPositionalFeatures((String) null).isEmpty());
77 assertTrue(store.getPositionalFeatures("Cath").isEmpty());
78 assertTrue(store.getPositionalFeatures("METAL").isEmpty());
80 features = store.getPositionalFeatures("Metal");
81 assertEquals(features.size(), 5);
82 assertTrue(features.contains(sf1));
83 assertTrue(features.contains(sf2));
84 assertTrue(features.contains(sf3));
85 assertTrue(features.contains(sf4));
86 assertTrue(features.contains(sf5));
87 assertFalse(features.contains(sf6));
89 features = store.getPositionalFeatures("Disulphide bond");
90 assertEquals(features.size(), 1);
91 assertTrue(features.contains(sf7));
93 features = store.getPositionalFeatures("Pfam");
94 assertEquals(features.size(), 2);
95 assertTrue(features.contains(sf8));
96 assertTrue(features.contains(sf9));
99 @Test(groups = "Functional")
100 public void testGetContactFeatures()
102 SequenceFeaturesI store = new SequenceFeatures();
104 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
108 SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0,
112 SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc",
113 18, 45, Float.NaN, null);
115 // repeat for different feature type
116 SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20,
119 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0,
122 SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18,
123 45, Float.NaN, null);
127 * get all contact features
129 List<SequenceFeature> features = store.getContactFeatures();
130 assertEquals(features.size(), 2);
131 assertTrue(features.contains(sf3));
132 assertTrue(features.contains(sf6));
135 * get contact features by type
137 assertTrue(store.getContactFeatures((String) null).isEmpty());
138 assertTrue(store.getContactFeatures("Cath").isEmpty());
139 assertTrue(store.getContactFeatures("Pfam").isEmpty());
140 assertTrue(store.getContactFeatures("DISULPHIDE BOND").isEmpty());
142 features = store.getContactFeatures("Disulphide bond");
143 assertEquals(features.size(), 1);
144 assertTrue(features.contains(sf3));
146 features = store.getContactFeatures("Disulfide bond");
147 assertEquals(features.size(), 1);
148 assertTrue(features.contains(sf6));
151 @Test(groups = "Functional")
152 public void testGetNonPositionalFeatures()
154 SequenceFeaturesI store = new SequenceFeatures();
156 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
160 SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 0, 0,
164 SequenceFeature sf3 = new SequenceFeature("Disulphide bond", "desc",
165 18, 45, Float.NaN, null);
167 // repeat for different feature type
168 SequenceFeature sf4 = new SequenceFeature("Pfam", "desc", 10, 20,
171 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 0, 0,
174 SequenceFeature sf6 = new SequenceFeature("Disulfide bond", "desc", 18,
175 45, Float.NaN, null);
177 // one more non-positional, different description
178 SequenceFeature sf7 = new SequenceFeature("Pfam", "desc2", 0, 0,
183 * get all non-positional features
185 List<SequenceFeature> features = store.getNonPositionalFeatures();
186 assertEquals(features.size(), 3);
187 assertTrue(features.contains(sf2));
188 assertTrue(features.contains(sf5));
189 assertTrue(features.contains(sf7));
192 * get non-positional features by type
194 assertTrue(store.getNonPositionalFeatures((String) null).isEmpty());
195 assertTrue(store.getNonPositionalFeatures("Cath").isEmpty());
196 assertTrue(store.getNonPositionalFeatures("PFAM").isEmpty());
198 features = store.getNonPositionalFeatures("Metal");
199 assertEquals(features.size(), 1);
200 assertTrue(features.contains(sf2));
202 features = store.getNonPositionalFeatures("Pfam");
203 assertEquals(features.size(), 2);
204 assertTrue(features.contains(sf5));
205 assertTrue(features.contains(sf7));
209 * Helper method to add a feature of no particular type
217 SequenceFeature addFeature(SequenceFeaturesI sf, String type, int from,
220 SequenceFeature sf1 = new SequenceFeature(type, "", from, to,
227 @Test(groups = "Functional")
228 public void testFindFeatures()
230 SequenceFeaturesI sf = new SequenceFeatures();
231 SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
232 SequenceFeature sf2 = addFeature(sf, "Pfam", 1, 15);
233 SequenceFeature sf3 = addFeature(sf, "Pfam", 20, 30);
234 SequenceFeature sf4 = addFeature(sf, "Pfam", 40, 100);
235 SequenceFeature sf5 = addFeature(sf, "Pfam", 60, 100);
236 SequenceFeature sf6 = addFeature(sf, "Pfam", 70, 70);
237 SequenceFeature sf7 = addFeature(sf, "Cath", 10, 50);
238 SequenceFeature sf8 = addFeature(sf, "Cath", 1, 15);
239 SequenceFeature sf9 = addFeature(sf, "Cath", 20, 30);
240 SequenceFeature sf10 = addFeature(sf, "Cath", 40, 100);
241 SequenceFeature sf11 = addFeature(sf, "Cath", 60, 100);
242 SequenceFeature sf12 = addFeature(sf, "Cath", 70, 70);
244 List<SequenceFeature> overlaps = sf.findFeatures(200, 200, "Pfam");
245 assertTrue(overlaps.isEmpty());
247 overlaps = sf.findFeatures( 1, 9, "Pfam");
248 assertEquals(overlaps.size(), 1);
249 assertTrue(overlaps.contains(sf2));
251 overlaps = sf.findFeatures( 5, 18, "Pfam");
252 assertEquals(overlaps.size(), 2);
253 assertTrue(overlaps.contains(sf1));
254 assertTrue(overlaps.contains(sf2));
256 overlaps = sf.findFeatures(30, 40, "Pfam");
257 assertEquals(overlaps.size(), 3);
258 assertTrue(overlaps.contains(sf1));
259 assertTrue(overlaps.contains(sf3));
260 assertTrue(overlaps.contains(sf4));
262 overlaps = sf.findFeatures( 80, 90, "Pfam");
263 assertEquals(overlaps.size(), 2);
264 assertTrue(overlaps.contains(sf4));
265 assertTrue(overlaps.contains(sf5));
267 overlaps = sf.findFeatures( 68, 70, "Pfam");
268 assertEquals(overlaps.size(), 3);
269 assertTrue(overlaps.contains(sf4));
270 assertTrue(overlaps.contains(sf5));
271 assertTrue(overlaps.contains(sf6));
273 overlaps = sf.findFeatures(16, 69, "Cath");
274 assertEquals(overlaps.size(), 4);
275 assertTrue(overlaps.contains(sf7));
276 assertFalse(overlaps.contains(sf8));
277 assertTrue(overlaps.contains(sf9));
278 assertTrue(overlaps.contains(sf10));
279 assertTrue(overlaps.contains(sf11));
280 assertFalse(overlaps.contains(sf12));
282 assertTrue(sf.findFeatures(0, 1000, "Metal").isEmpty());
284 overlaps = sf.findFeatures(7, 7, (String) null);
285 assertTrue(overlaps.isEmpty());
288 @Test(groups = "Functional")
289 public void testDelete()
291 SequenceFeaturesI sf = new SequenceFeatures();
292 SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
293 assertTrue(sf.getPositionalFeatures().contains(sf1));
295 assertFalse(sf.delete(null));
296 SequenceFeature sf2 = new SequenceFeature("Cath", "", 10, 15, 0f, null);
297 assertFalse(sf.delete(sf2)); // not added, can't delete it
298 assertTrue(sf.delete(sf1));
299 assertTrue(sf.getPositionalFeatures().isEmpty());
302 @Test(groups = "Functional")
303 public void testHasFeatures()
305 SequenceFeaturesI sf = new SequenceFeatures();
306 assertFalse(sf.hasFeatures());
308 SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
309 assertTrue(sf.hasFeatures());
312 assertFalse(sf.hasFeatures());
316 * Tests for the method that gets feature groups for positional or
317 * non-positional features
319 @Test(groups = "Functional")
320 public void testGetFeatureGroups()
322 SequenceFeaturesI sf = new SequenceFeatures();
323 assertTrue(sf.getFeatureGroups(true).isEmpty());
324 assertTrue(sf.getFeatureGroups(false).isEmpty());
327 * add a non-positional feature (begin/end = 0/0)
329 SequenceFeature sfx = new SequenceFeature("AType", "Desc", 0, 0, 0f,
332 Set<String> groups = sf.getFeatureGroups(true); // for positional
333 assertTrue(groups.isEmpty());
334 groups = sf.getFeatureGroups(false); // for non-positional
335 assertEquals(groups.size(), 1);
336 assertTrue(groups.contains("AGroup"));
339 * add, then delete, more non-positional features of different types
341 SequenceFeature sfy = new SequenceFeature("AnotherType", "Desc", 0, 0,
345 SequenceFeature sfz = new SequenceFeature("AThirdType", "Desc", 0, 0,
349 groups = sf.getFeatureGroups(false);
350 assertEquals(groups.size(), 3);
351 assertTrue(groups.contains("AGroup"));
352 assertTrue(groups.contains("AnotherGroup"));
353 assertTrue(groups.contains(null)); // null is a possible group
356 groups = sf.getFeatureGroups(false);
357 assertEquals(groups.size(), 1);
358 assertTrue(groups.contains("AGroup"));
361 * add positional features
363 SequenceFeature sf1 = new SequenceFeature("Pfam", "Desc", 10, 50, 0f,
366 groups = sf.getFeatureGroups(true);
367 assertEquals(groups.size(), 1);
368 assertTrue(groups.contains("PfamGroup"));
369 groups = sf.getFeatureGroups(false); // non-positional unchanged
370 assertEquals(groups.size(), 1);
371 assertTrue(groups.contains("AGroup"));
373 SequenceFeature sf2 = new SequenceFeature("Cath", "Desc", 10, 50, 0f,
376 groups = sf.getFeatureGroups(true);
377 assertEquals(groups.size(), 2);
378 assertTrue(groups.contains("PfamGroup"));
379 assertTrue(groups.contains(null));
383 assertTrue(sf.getFeatureGroups(true).isEmpty());
385 SequenceFeature sf3 = new SequenceFeature("CDS", "", 10, 50, 0f,
388 SequenceFeature sf4 = new SequenceFeature("exon", "", 10, 50, 0f,
391 groups = sf.getFeatureGroups(true);
392 assertEquals(groups.size(), 1);
393 assertTrue(groups.contains("Ensembl"));
396 * delete last Ensembl group feature from CDS features
397 * but still have one in exon features
400 groups = sf.getFeatureGroups(true);
401 assertEquals(groups.size(), 1);
402 assertTrue(groups.contains("Ensembl"));
405 * delete the last non-positional feature
408 groups = sf.getFeatureGroups(false);
409 assertTrue(groups.isEmpty());
412 @Test(groups = "Functional")
413 public void testGetFeatureTypesForGroups()
415 SequenceFeaturesI sf = new SequenceFeatures();
416 assertTrue(sf.getFeatureTypesForGroups(true, (String) null).isEmpty());
419 * add feature with group = "Uniprot", type = "helix"
421 String groupUniprot = "Uniprot";
422 SequenceFeature sf1 = new SequenceFeature("helix", "Desc", 10, 50, 0f,
425 Set<String> groups = sf.getFeatureTypesForGroups(true, groupUniprot);
426 assertEquals(groups.size(), 1);
427 assertTrue(groups.contains("helix"));
428 assertTrue(sf.getFeatureTypesForGroups(true, (String) null).isEmpty());
431 * add feature with group = "Uniprot", type = "strand"
433 SequenceFeature sf2 = new SequenceFeature("strand", "Desc", 10, 50, 0f,
436 groups = sf.getFeatureTypesForGroups(true, groupUniprot);
437 assertEquals(groups.size(), 2);
438 assertTrue(groups.contains("helix"));
439 assertTrue(groups.contains("strand"));
442 * delete the "strand" Uniprot feature - still have "helix"
445 groups = sf.getFeatureTypesForGroups(true, groupUniprot);
446 assertEquals(groups.size(), 1);
447 assertTrue(groups.contains("helix"));
450 * delete the "helix" Uniprot feature - none left
453 assertTrue(sf.getFeatureTypesForGroups(true, groupUniprot).isEmpty());
456 * add some null group features
458 SequenceFeature sf3 = new SequenceFeature("strand", "Desc", 10, 50, 0f,
461 SequenceFeature sf4 = new SequenceFeature("turn", "Desc", 10, 50, 0f,
464 groups = sf.getFeatureTypesForGroups(true, (String) null);
465 assertEquals(groups.size(), 2);
466 assertTrue(groups.contains("strand"));
467 assertTrue(groups.contains("turn"));
470 * add strand/Cath and turn/Scop and query for one or both groups
471 * (find feature types for groups selected in Feature Settings)
473 SequenceFeature sf5 = new SequenceFeature("strand", "Desc", 10, 50, 0f,
476 SequenceFeature sf6 = new SequenceFeature("turn", "Desc", 10, 50, 0f,
479 groups = sf.getFeatureTypesForGroups(true, "Cath");
480 assertEquals(groups.size(), 1);
481 assertTrue(groups.contains("strand"));
482 groups = sf.getFeatureTypesForGroups(true, "Scop");
483 assertEquals(groups.size(), 1);
484 assertTrue(groups.contains("turn"));
485 groups = sf.getFeatureTypesForGroups(true, "Cath", "Scop");
486 assertEquals(groups.size(), 2);
487 assertTrue(groups.contains("turn"));
488 assertTrue(groups.contains("strand"));
489 // alternative vararg syntax
490 groups = sf.getFeatureTypesForGroups(true, new String[] { "Cath",
492 assertEquals(groups.size(), 2);
493 assertTrue(groups.contains("turn"));
494 assertTrue(groups.contains("strand"));
497 @Test(groups = "Functional")
498 public void testGetFeatureTypes()
500 SequenceFeaturesI store = new SequenceFeatures();
501 Set<String> types = store.getFeatureTypes();
502 assertTrue(types.isEmpty());
504 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
507 types = store.getFeatureTypes();
508 assertEquals(types.size(), 1);
509 assertTrue(types.contains("Metal"));
511 // null type is rejected...
512 SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20,
514 assertFalse(store.add(sf2));
515 types = store.getFeatureTypes();
516 assertEquals(types.size(), 1);
517 assertFalse(types.contains(null));
518 assertTrue(types.contains("Metal"));
521 * add non-positional feature
523 SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0,
526 types = store.getFeatureTypes();
527 assertEquals(types.size(), 2);
528 assertTrue(types.contains("Pfam"));
531 * add contact feature
533 SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc",
534 10, 20, Float.NaN, null);
536 types = store.getFeatureTypes();
537 assertEquals(types.size(), 3);
538 assertTrue(types.contains("Disulphide Bond"));
543 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20,
546 types = store.getFeatureTypes();
547 assertEquals(types.size(), 3); // unchanged
550 * delete first Pfam - still have one
552 assertTrue(store.delete(sf3));
553 types = store.getFeatureTypes();
554 assertEquals(types.size(), 3);
555 assertTrue(types.contains("Pfam"));
558 * delete second Pfam - no longer have one
560 assertTrue(store.delete(sf5));
561 types = store.getFeatureTypes();
562 assertEquals(types.size(), 2);
563 assertFalse(types.contains("Pfam"));
566 @Test(groups = "Functional")
567 public void testGetFeatureCount()
569 SequenceFeaturesI store = new SequenceFeatures();
570 assertEquals(store.getFeatureCount(true), 0);
571 assertEquals(store.getFeatureCount(false), 0);
576 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
579 assertEquals(store.getFeatureCount(true), 1);
580 assertEquals(store.getFeatureCount(false), 0);
583 * null feature type is rejected
585 SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20,
587 assertFalse(store.add(sf2));
588 assertEquals(store.getFeatureCount(true), 1);
589 assertEquals(store.getFeatureCount(false), 0);
592 * add non-positional feature
594 SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0,
597 assertEquals(store.getFeatureCount(true), 1);
598 assertEquals(store.getFeatureCount(false), 1);
601 * add contact feature (counts as 1)
603 SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc",
604 10, 20, Float.NaN, null);
606 assertEquals(store.getFeatureCount(true), 2);
607 assertEquals(store.getFeatureCount(false), 1);
610 * add another Pfam but this time as a positional feature
612 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20,
615 assertEquals(store.getFeatureCount(true), 3); // sf1, sf4, sf5
616 assertEquals(store.getFeatureCount(false), 1); // sf3
617 assertEquals(store.getFeatureCount(true, "Pfam"), 1); // positional
618 assertEquals(store.getFeatureCount(false, "Pfam"), 1); // non-positional
619 // search for type==null
620 assertEquals(store.getFeatureCount(true, (String) null), 0);
621 // search with no type specified
622 assertEquals(store.getFeatureCount(true, (String[]) null), 3);
623 assertEquals(store.getFeatureCount(true, "Metal", "Cath"), 1);
624 assertEquals(store.getFeatureCount(true, "Disulphide Bond"), 1);
625 assertEquals(store.getFeatureCount(true, "Metal", "Pfam", null), 2);
628 * delete first Pfam (non-positional)
630 assertTrue(store.delete(sf3));
631 assertEquals(store.getFeatureCount(true), 3);
632 assertEquals(store.getFeatureCount(false), 0);
635 * delete second Pfam (positional)
637 assertTrue(store.delete(sf5));
638 assertEquals(store.getFeatureCount(true), 2);
639 assertEquals(store.getFeatureCount(false), 0);
642 @Test(groups = "Functional")
643 public void testGetAllFeatures()
645 SequenceFeaturesI store = new SequenceFeatures();
646 List<SequenceFeature> features = store.getAllFeatures();
647 assertTrue(features.isEmpty());
649 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
652 features = store.getAllFeatures();
653 assertEquals(features.size(), 1);
654 assertTrue(features.contains(sf1));
656 SequenceFeature sf2 = new SequenceFeature("Metallic", "desc", 10, 20,
659 features = store.getAllFeatures();
660 assertEquals(features.size(), 2);
661 assertTrue(features.contains(sf2));
664 * add non-positional feature
666 SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0,
669 features = store.getAllFeatures();
670 assertEquals(features.size(), 3);
671 assertTrue(features.contains(sf3));
674 * add contact feature
676 SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc",
677 10, 20, Float.NaN, null);
679 features = store.getAllFeatures();
680 assertEquals(features.size(), 4);
681 assertTrue(features.contains(sf4));
686 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20,
689 features = store.getAllFeatures();
690 assertEquals(features.size(), 5);
691 assertTrue(features.contains(sf5));
694 * select by type does not apply to non-positional features
696 features = store.getAllFeatures("Cath");
697 assertEquals(features.size(), 1);
698 assertTrue(features.contains(sf3));
700 features = store.getAllFeatures("Pfam", "Cath", "Metal");
701 assertEquals(features.size(), 3);
702 assertTrue(features.contains(sf1));
703 assertTrue(features.contains(sf3));
704 assertTrue(features.contains(sf5));
709 assertTrue(store.delete(sf3));
710 features = store.getAllFeatures();
711 assertEquals(features.size(), 4);
712 assertFalse(features.contains(sf3));
717 assertTrue(store.delete(sf5));
718 features = store.getAllFeatures();
719 assertEquals(features.size(), 3);
720 assertFalse(features.contains(sf3));
723 @Test(groups = "Functional")
724 public void testGetTotalFeatureLength()
726 SequenceFeaturesI store = new SequenceFeatures();
727 assertEquals(store.getTotalFeatureLength(), 0);
729 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
731 assertTrue(store.add(sf1));
732 assertEquals(store.getTotalFeatureLength(), 11);
734 // re-add does nothing!
735 assertFalse(store.add(sf1));
736 assertEquals(store.getTotalFeatureLength(), 11);
739 * add non-positional feature
741 SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0,
744 assertEquals(store.getTotalFeatureLength(), 11);
747 * add contact feature - counts 1 to feature length
749 SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc",
750 10, 20, Float.NaN, null);
752 assertEquals(store.getTotalFeatureLength(), 12);
757 SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20,
760 assertEquals(store.getTotalFeatureLength(), 23);
765 assertTrue(store.delete(sf3)); // non-positional
766 assertEquals(store.getTotalFeatureLength(), 23); // no change
768 assertTrue(store.delete(sf5));
769 assertEquals(store.getTotalFeatureLength(), 12);
771 assertTrue(store.delete(sf4)); // contact
772 assertEquals(store.getTotalFeatureLength(), 11);
774 assertTrue(store.delete(sf1));
775 assertEquals(store.getTotalFeatureLength(), 0);
778 @Test(groups = "Functional")
779 public void testGetMinimumScore_getMaximumScore()
781 SequenceFeatures sf = new SequenceFeatures();
782 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 0, 0,
783 Float.NaN, "group"); // non-positional, no score
785 SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 10, 20,
786 Float.NaN, "group"); // positional, no score
788 SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 10, 20, 1f,
791 SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 12, 16, 4f,
794 SequenceFeature sf5 = new SequenceFeature("Cath", "desc", 0, 0, 11f,
797 SequenceFeature sf6 = new SequenceFeature("Cath", "desc", 0, 0, -7f,
801 assertEquals(sf.getMinimumScore("nosuchtype", true), Float.NaN);
802 assertEquals(sf.getMinimumScore("nosuchtype", false), Float.NaN);
803 assertEquals(sf.getMaximumScore("nosuchtype", true), Float.NaN);
804 assertEquals(sf.getMaximumScore("nosuchtype", false), Float.NaN);
806 // positional features min-max:
807 assertEquals(sf.getMinimumScore("Metal", true), 1f);
808 assertEquals(sf.getMaximumScore("Metal", true), 4f);
809 assertEquals(sf.getMinimumScore("Cath", true), Float.NaN);
810 assertEquals(sf.getMaximumScore("Cath", true), Float.NaN);
812 // non-positional features min-max:
813 assertEquals(sf.getMinimumScore("Cath", false), -7f);
814 assertEquals(sf.getMaximumScore("Cath", false), 11f);
815 assertEquals(sf.getMinimumScore("Metal", false), Float.NaN);
816 assertEquals(sf.getMaximumScore("Metal", false), Float.NaN);
818 // delete features; min-max should get recomputed
820 assertEquals(sf.getMinimumScore("Cath", false), 11f);
821 assertEquals(sf.getMaximumScore("Cath", false), 11f);
823 assertEquals(sf.getMinimumScore("Metal", true), 1f);
824 assertEquals(sf.getMaximumScore("Metal", true), 1f);
826 assertEquals(sf.getMinimumScore("Cath", false), Float.NaN);
827 assertEquals(sf.getMaximumScore("Cath", false), Float.NaN);
829 assertEquals(sf.getMinimumScore("Metal", true), Float.NaN);
830 assertEquals(sf.getMaximumScore("Metal", true), Float.NaN);
833 assertFalse(sf.hasFeatures());
834 assertEquals(sf.getMinimumScore("Cath", false), Float.NaN);
835 assertEquals(sf.getMaximumScore("Cath", false), Float.NaN);
836 assertEquals(sf.getMinimumScore("Metal", true), Float.NaN);
837 assertEquals(sf.getMaximumScore("Metal", true), Float.NaN);
840 @Test(groups = "Functional")
841 public void testVarargsToTypes()
843 SequenceFeatures sf = new SequenceFeatures();
844 sf.add(new SequenceFeature("Metal", "desc", 0, 0, Float.NaN, "group"));
845 sf.add(new SequenceFeature("Cath", "desc", 10, 20, Float.NaN, "group"));
848 * no type specified - get all types stored
849 * they are returned in keyset (alphabetical) order
851 Iterable<String> types = sf.varargToTypes();
852 Iterator<String> iterator = types.iterator();
853 assertTrue(iterator.hasNext());
854 assertEquals(iterator.next(), "Cath");
855 assertTrue(iterator.hasNext());
856 assertEquals(iterator.next(), "Metal");
857 assertFalse(iterator.hasNext());
860 * empty array is the same as no vararg parameter supplied
861 * so treated as all stored types
863 types = sf.varargToTypes(new String[] {});
864 iterator = types.iterator();
865 assertTrue(iterator.hasNext());
866 assertEquals(iterator.next(), "Cath");
867 assertTrue(iterator.hasNext());
868 assertEquals(iterator.next(), "Metal");
869 assertFalse(iterator.hasNext());
872 * null type specified; this is passed as vararg
875 types = sf.varargToTypes((String) null);
876 assertFalse(types.iterator().hasNext());
879 * null types array specified; this is passed as vararg null
881 types = sf.varargToTypes((String[]) null);
882 iterator = types.iterator();
883 assertTrue(iterator.hasNext());
884 assertEquals(iterator.next(), "Cath");
885 assertTrue(iterator.hasNext());
886 assertEquals(iterator.next(), "Metal");
887 assertFalse(iterator.hasNext());
892 types = sf.varargToTypes("Metal");
893 iterator = types.iterator();
894 assertTrue(iterator.hasNext());
895 assertEquals(iterator.next(), "Metal");
896 assertFalse(iterator.hasNext());
899 * two types specified - get sorted alphabetically
901 types = sf.varargToTypes("Metal", "Helix");
902 iterator = types.iterator();
903 assertTrue(iterator.hasNext());
904 assertEquals(iterator.next(), "Helix");
905 assertTrue(iterator.hasNext());
906 assertEquals(iterator.next(), "Metal");
907 assertFalse(iterator.hasNext());
910 * null type included - should get removed
912 types = sf.varargToTypes("Metal", null, "Helix");
913 iterator = types.iterator();
914 assertTrue(iterator.hasNext());
915 assertEquals(iterator.next(), "Helix");
916 assertTrue(iterator.hasNext());
917 assertEquals(iterator.next(), "Metal");
918 assertFalse(iterator.hasNext());
921 @Test(groups = "Functional")
922 public void testGetFeatureTypes_byOntology()
924 SequenceFeaturesI store = new SequenceFeatures();
926 SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20,
929 // mRNA isA mature_transcript isA transcript
930 SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 10, 20,
933 // just to prove non-positional feature types are included
934 SequenceFeature sf3 = new SequenceFeature("mRNA", "desc", 0, 0,
937 SequenceFeature sf4 = new SequenceFeature("CDS", "desc", 0, 0,
941 Set<String> types = store.getFeatureTypes("transcript");
942 assertEquals(types.size(), 2);
943 assertTrue(types.contains("transcript"));
944 assertTrue(types.contains("mRNA"));
946 // matches include arguments whether SO terms or not
947 types = store.getFeatureTypes("transcript", "CDS");
948 assertEquals(types.size(), 3);
949 assertTrue(types.contains("transcript"));
950 assertTrue(types.contains("mRNA"));
951 assertTrue(types.contains("CDS"));
953 types = store.getFeatureTypes("exon");
954 assertTrue(types.isEmpty());
957 @Test(groups = "Functional")
958 public void testGetFeaturesByOntology()
960 SequenceFeaturesI store = new SequenceFeatures();
961 List<SequenceFeature> features = store.getFeaturesByOntology();
962 assertTrue(features.isEmpty());
963 assertTrue(store.getFeaturesByOntology(new String[] {}).isEmpty());
964 assertTrue(store.getFeaturesByOntology((String[]) null).isEmpty());
966 SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20,
970 // mRNA isA transcript; added here 'as if' non-positional
971 // just to show that non-positional features are included in results
972 SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 0, 0,
976 SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 30, 40,
980 features = store.getFeaturesByOntology("transcript");
981 assertEquals(features.size(), 2);
982 assertTrue(features.contains(sf1));
983 assertTrue(features.contains(sf2));
985 features = store.getFeaturesByOntology("mRNA");
986 assertEquals(features.size(), 1);
987 assertTrue(features.contains(sf2));
989 features = store.getFeaturesByOntology("mRNA", "Pfam");
990 assertEquals(features.size(), 2);
991 assertTrue(features.contains(sf2));
992 assertTrue(features.contains(sf3));
995 @Test(groups = "Functional")
996 public void testSortFeatures()
998 List<SequenceFeature> sfs = new ArrayList<SequenceFeature>();
999 SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 30, 80,
1002 SequenceFeature sf2 = new SequenceFeature("Rfam", "desc", 40, 50,
1005 SequenceFeature sf3 = new SequenceFeature("Rfam", "desc", 50, 60,
1009 // sort by end position descending
1010 SequenceFeatures.sortFeatures(sfs, false);
1011 assertSame(sfs.get(0), sf1);
1012 assertSame(sfs.get(1), sf3);
1013 assertSame(sfs.get(2), sf2);
1015 // sort by start position ascending
1016 SequenceFeatures.sortFeatures(sfs, true);
1017 assertSame(sfs.get(0), sf1);
1018 assertSame(sfs.get(1), sf2);
1019 assertSame(sfs.get(2), sf3);