import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Set;
import org.testng.annotations.Test;
+import junit.extensions.PA;
+
public class SequenceFeaturesTest
{
@Test(groups = "Functional")
+ public void testConstructor()
+ {
+ SequenceFeaturesI store = new SequenceFeatures();
+ assertFalse(store.hasFeatures());
+
+ store = new SequenceFeatures((List<SequenceFeature>) null);
+ assertFalse(store.hasFeatures());
+
+ List<SequenceFeature> features = new ArrayList<>();
+ store = new SequenceFeatures(features);
+ assertFalse(store.hasFeatures());
+
+ SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
+ Float.NaN, null);
+ features.add(sf1);
+ SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 15, 18,
+ Float.NaN, null);
+ features.add(sf2); // nested
+ SequenceFeature sf3 = new SequenceFeature("Pfam", "desc2", 0, 0,
+ Float.NaN, null); // non-positional
+ features.add(sf3);
+ store = new SequenceFeatures(features);
+ assertTrue(store.hasFeatures());
+ assertEquals(2, store.getFeatureCount(true)); // positional
+ assertEquals(1, store.getFeatureCount(false)); // non-positional
+ assertFalse(store.add(sf1)); // already contained
+ assertFalse(store.add(sf2)); // already contained
+ assertFalse(store.add(sf3)); // already contained
+ }
+
+ @Test(groups = "Functional")
public void testGetPositionalFeatures()
{
SequenceFeaturesI store = new SequenceFeatures();
groups = sf.getFeatureGroups(false); // for non-positional
assertEquals(groups.size(), 1);
assertTrue(groups.contains("AGroup"));
+ groups = sf.getFeatureGroups(false, "AType");
+ assertEquals(groups.size(), 1);
+ assertTrue(groups.contains("AGroup"));
+ groups = sf.getFeatureGroups(true, "AnotherType");
+ assertTrue(groups.isEmpty());
/*
* add, then delete, more non-positional features of different types
Float.NaN, null);
assertTrue(store.add(sf1));
assertEquals(store.getTotalFeatureLength(), 11);
+ assertEquals(store.getTotalFeatureLength("Metal"), 11);
+ assertEquals(store.getTotalFeatureLength("Plastic"), 0);
// re-add does nothing!
assertFalse(store.add(sf1));
* no type specified - get all types stored
* they are returned in keyset (alphabetical) order
*/
- Iterable<String> types = sf.varargToTypes();
- Iterator<String> iterator = types.iterator();
+ Map<String, FeatureStore> featureStores = (Map<String, FeatureStore>) PA
+ .getValue(sf, "featureStore");
+
+ Iterable<FeatureStore> types = sf.varargToTypes();
+ Iterator<FeatureStore> iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Cath");
+ assertSame(iterator.next(), featureStores.get("Cath"));
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
/*
types = sf.varargToTypes(new String[] {});
iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Cath");
+ assertSame(iterator.next(), featureStores.get("Cath"));
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
/*
types = sf.varargToTypes((String[]) null);
iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Cath");
+ assertSame(iterator.next(), featureStores.get("Cath"));
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
/*
types = sf.varargToTypes("Metal");
iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
/*
* two types specified - get sorted alphabetically
*/
- types = sf.varargToTypes("Metal", "Helix");
+ types = sf.varargToTypes("Metal", "Cath");
iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Helix");
+ assertSame(iterator.next(), featureStores.get("Cath"));
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
/*
- * null type included - should get removed
+ * null type included - should be ignored
*/
types = sf.varargToTypes("Metal", null, "Helix");
iterator = types.iterator();
assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Helix");
- assertTrue(iterator.hasNext());
- assertEquals(iterator.next(), "Metal");
+ assertSame(iterator.next(), featureStores.get("Metal"));
assertFalse(iterator.hasNext());
}
assertTrue(store.getFeaturesByOntology(new String[] {}).isEmpty());
assertTrue(store.getFeaturesByOntology((String[]) null).isEmpty());
- SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20,
+ SequenceFeature transcriptFeature = new SequenceFeature("transcript", "desc", 10, 20,
Float.NaN, null);
- store.add(sf1);
+ store.add(transcriptFeature);
- // mRNA isA transcript; added here 'as if' non-positional
- // just to show that non-positional features are included in results
- SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 0, 0,
+ /*
+ * mRNA is a sub-type of transcript; added here 'as if' non-positional
+ * just to show that non-positional features are included in results
+ */
+ SequenceFeature mrnaFeature = new SequenceFeature("mRNA", "desc", 0, 0,
Float.NaN, null);
- store.add(sf2);
+ store.add(mrnaFeature);
- SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 30, 40,
+ SequenceFeature pfamFeature = new SequenceFeature("Pfam", "desc", 30, 40,
Float.NaN, null);
- store.add(sf3);
+ store.add(pfamFeature);
+ /*
+ * "transcript" matches both itself and the sub-term "mRNA"
+ */
features = store.getFeaturesByOntology("transcript");
assertEquals(features.size(), 2);
- assertTrue(features.contains(sf1));
- assertTrue(features.contains(sf2));
+ assertTrue(features.contains(transcriptFeature));
+ assertTrue(features.contains(mrnaFeature));
+ /*
+ * "mRNA" matches itself but not parent term "transcript"
+ */
features = store.getFeaturesByOntology("mRNA");
assertEquals(features.size(), 1);
- assertTrue(features.contains(sf2));
+ assertTrue(features.contains(mrnaFeature));
+ /*
+ * "pfam" is not an SO term but is included as an exact match
+ */
features = store.getFeaturesByOntology("mRNA", "Pfam");
assertEquals(features.size(), 2);
- assertTrue(features.contains(sf2));
- assertTrue(features.contains(sf3));
+ assertTrue(features.contains(mrnaFeature));
+ assertTrue(features.contains(pfamFeature));
+
+ features = store.getFeaturesByOntology("sequence_variant");
+ assertTrue(features.isEmpty());
}
@Test(groups = "Functional")
public void testSortFeatures()
{
- List<SequenceFeature> sfs = new ArrayList<SequenceFeature>();
+ List<SequenceFeature> sfs = new ArrayList<>();
SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 30, 80,
Float.NaN, null);
sfs.add(sf1);
public void testShiftFeatures()
{
SequenceFeatures store = new SequenceFeatures();
- assertFalse(store.shiftFeatures(1));
+ assertFalse(store.shiftFeatures(0, 1));
SequenceFeature sf1 = new SequenceFeature("Cath", "", 2, 5, 0f, null);
store.add(sf1);
/*
* shift features right by 5
*/
- assertTrue(store.shiftFeatures(5));
+ assertTrue(store.shiftFeatures(0, 5));
// non-positional features untouched:
List<SequenceFeature> nonPos = store.getNonPositionalFeatures();
* feature at [7-10] should be removed
* feature at [13-19] should become [1-4]
*/
- assertTrue(store.shiftFeatures(-15));
+ assertTrue(store.shiftFeatures(0, -15));
pos = store.getPositionalFeatures();
assertEquals(pos.size(), 2);
SequenceFeatures.sortFeatures(pos, true);
assertEquals(pos.get(1).getBegin(), 13);
assertEquals(pos.get(1).getEnd(), 22);
assertEquals(pos.get(1).getType(), "Disulfide bond");
+
+ /*
+ * shift right by 4 from column 2
+ * feature at [1-4] should be unchanged
+ * feature at [13-22] should become [17-26]
+ */
+ assertTrue(store.shiftFeatures(2, 4));
+ pos = store.getPositionalFeatures();
+ assertEquals(pos.size(), 2);
+ SequenceFeatures.sortFeatures(pos, true);
+ assertEquals(pos.get(0).getBegin(), 1);
+ assertEquals(pos.get(0).getEnd(), 4);
+ assertEquals(pos.get(0).getType(), "Metal");
+ assertEquals(pos.get(1).getBegin(), 17);
+ assertEquals(pos.get(1).getEnd(), 26);
+ assertEquals(pos.get(1).getType(), "Disulfide bond");
+
+ /*
+ * shift right from column 18
+ * should be no updates
+ */
+ SequenceFeature f1 = pos.get(0);
+ SequenceFeature f2 = pos.get(1);
+ assertFalse(store.shiftFeatures(18, 6));
+ pos = store.getPositionalFeatures();
+ assertEquals(pos.size(), 2);
+ SequenceFeatures.sortFeatures(pos, true);
+ assertSame(pos.get(0), f1);
+ assertSame(pos.get(1), f2);
+ }
+
+ @Test(groups = "Functional")
+ public void testIsOntologyTerm()
+ {
+ SequenceFeatures store = new SequenceFeatures();
+ assertTrue(store.isOntologyTerm("gobbledygook"));
+ assertTrue(store.isOntologyTerm("transcript", "transcript"));
+ assertTrue(store.isOntologyTerm("mRNA", "transcript"));
+ assertFalse(store.isOntologyTerm("transcript", "mRNA"));
+ assertTrue(store.isOntologyTerm("junk", "transcript", "junk"));
+ assertTrue(store.isOntologyTerm("junk", new String[] {}));
+ assertTrue(store.isOntologyTerm("junk", (String[]) null));
+ }
+
+ @Test(groups = "Functional")
+ public void testDeleteAll()
+ {
+ SequenceFeaturesI store = new SequenceFeatures();
+ assertFalse(store.hasFeatures());
+ store.deleteAll();
+ assertFalse(store.hasFeatures());
+ store.add(new SequenceFeature("Cath", "Desc", 12, 20, 0f, "Group"));
+ store.add(new SequenceFeature("Pfam", "Desc", 6, 12, 2f, "Group2"));
+ assertTrue(store.hasFeatures());
+ store.deleteAll();
+ assertFalse(store.hasFeatures());
+ }
+
+ @Test(groups = "Functional")
+ public void testFindFeatures_withResultList()
+ {
+ SequenceFeaturesI sf = new SequenceFeatures();
+ SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50);
+ SequenceFeature sf2 = addFeature(sf, "Pfam", 150, 250);
+
+ /*
+ * findFeatures with result list to append to
+ */
+ List<SequenceFeature> overlaps = new ArrayList<>();
+ List<SequenceFeature> result = sf.findFeatures(200, "Pfam", overlaps);
+ assertSame(result, overlaps);
+ assertEquals(result.size(), 1);
+ assertTrue(result.contains(sf2));
+ assertFalse(result.contains(sf1));
+
+ /*
+ * with no result list - method creates one
+ */
+ result = sf.findFeatures(200, "Pfam", null);
+ assertEquals(result.size(), 1);
+ assertTrue(result.contains(sf2));
+ assertFalse(result.contains(sf1));
+
+ /*
+ * verify the created list is extendable (is not immutable)
+ * notice it may contain duplicates
+ */
+ result = sf.findFeatures(220, "Pfam", result);
+ assertEquals(result.size(), 2);
+ assertSame(result.get(0), sf2); // in input list
+ assertSame(result.get(1), sf2); // duplicate added
+
+ /*
+ * no feature of requested type - with result list
+ */
+ overlaps.clear();
+ result = sf.findFeatures(200, "Rfam", overlaps);
+ assertTrue(result.isEmpty());
+
+ /*
+ * no feature of requested type - with no result list
+ */
+ result = sf.findFeatures(200, "Rfam", null);
+ assertTrue(result.isEmpty());
+
+ /*
+ * verify the created list is extendable (is not immutable)
+ */
+ result = sf.findFeatures(210, "Pfam", result);
+ assertEquals(result.size(), 1);
+ assertTrue(result.contains(sf2));
+ assertFalse(result.contains(sf1));
}
}