X-Git-Url: http://source.jalview.org/gitweb/?a=blobdiff_plain;f=test%2Fjalview%2Fdatamodel%2Ffeatures%2FSequenceFeaturesTest.java;h=d3927fe153beb27b811adca08fa00c8b41df5c99;hb=f782e40f6f1b3f2bb22927891493c5faf318625b;hp=84a07b4ff33e210e7d78beed7805017bd3a99fe9;hpb=5c10f71b18bb8a9e3320440cc1eaa95350d56120;p=jalview.git diff --git a/test/jalview/datamodel/features/SequenceFeaturesTest.java b/test/jalview/datamodel/features/SequenceFeaturesTest.java index 84a07b4..d3927fe 100644 --- a/test/jalview/datamodel/features/SequenceFeaturesTest.java +++ b/test/jalview/datamodel/features/SequenceFeaturesTest.java @@ -2,10 +2,13 @@ package jalview.datamodel.features; import static org.testng.Assert.assertEquals; import static org.testng.Assert.assertFalse; +import static org.testng.Assert.assertSame; import static org.testng.Assert.assertTrue; import jalview.datamodel.SequenceFeature; +import java.util.ArrayList; +import java.util.Iterator; import java.util.List; import java.util.Set; @@ -16,7 +19,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testGetPositionalFeatures() { - SequenceFeatures store = new SequenceFeatures(); + SequenceFeaturesI store = new SequenceFeatures(); SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, Float.NaN, null); store.add(sf1); @@ -96,7 +99,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testGetContactFeatures() { - SequenceFeatures store = new SequenceFeatures(); + SequenceFeaturesI store = new SequenceFeatures(); // non-contact SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, Float.NaN, null); @@ -148,7 +151,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testGetNonPositionalFeatures() { - SequenceFeatures store = new SequenceFeatures(); + SequenceFeaturesI store = new SequenceFeatures(); // positional SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, Float.NaN, null); @@ -211,7 +214,7 @@ public class SequenceFeaturesTest * @param to * @return */ - SequenceFeature addFeature(SequenceFeatures sf, String type, int from, + SequenceFeature addFeature(SequenceFeaturesI sf, String type, int from, int to) { SequenceFeature sf1 = new SequenceFeature(type, "", from, to, @@ -224,7 +227,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testFindFeatures() { - SequenceFeatures sf = new SequenceFeatures(); + SequenceFeaturesI sf = new SequenceFeatures(); SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); SequenceFeature sf2 = addFeature(sf, "Pfam", 1, 15); SequenceFeature sf3 = addFeature(sf, "Pfam", 20, 30); @@ -237,8 +240,6 @@ public class SequenceFeaturesTest SequenceFeature sf10 = addFeature(sf, "Cath", 40, 100); SequenceFeature sf11 = addFeature(sf, "Cath", 60, 100); SequenceFeature sf12 = addFeature(sf, "Cath", 70, 70); - // null type is weird but possible: - SequenceFeature sf13 = addFeature(sf, null, 5, 12); List overlaps = sf.findFeatures(200, 200, "Pfam"); assertTrue(overlaps.isEmpty()); @@ -281,14 +282,13 @@ public class SequenceFeaturesTest assertTrue(sf.findFeatures(0, 1000, "Metal").isEmpty()); overlaps = sf.findFeatures(7, 7, (String) null); - assertEquals(overlaps.size(), 1); - assertTrue(overlaps.contains(sf13)); + assertTrue(overlaps.isEmpty()); } @Test(groups = "Functional") public void testDelete() { - SequenceFeatures sf = new SequenceFeatures(); + SequenceFeaturesI sf = new SequenceFeatures(); SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); assertTrue(sf.getPositionalFeatures().contains(sf1)); @@ -302,7 +302,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testHasFeatures() { - SequenceFeatures sf = new SequenceFeatures(); + SequenceFeaturesI sf = new SequenceFeatures(); assertFalse(sf.hasFeatures()); SequenceFeature sf1 = addFeature(sf, "Pfam", 10, 50); @@ -319,7 +319,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testGetFeatureGroups() { - SequenceFeatures sf = new SequenceFeatures(); + SequenceFeaturesI sf = new SequenceFeatures(); assertTrue(sf.getFeatureGroups(true).isEmpty()); assertTrue(sf.getFeatureGroups(false).isEmpty()); @@ -412,7 +412,7 @@ public class SequenceFeaturesTest @Test(groups = "Functional") public void testGetFeatureTypesForGroups() { - SequenceFeatures sf = new SequenceFeatures(); + SequenceFeaturesI sf = new SequenceFeatures(); assertTrue(sf.getFeatureTypesForGroups(true, (String) null).isEmpty()); /* @@ -493,4 +493,529 @@ public class SequenceFeaturesTest assertTrue(groups.contains("turn")); assertTrue(groups.contains("strand")); } + + @Test(groups = "Functional") + public void testGetFeatureTypes() + { + SequenceFeaturesI store = new SequenceFeatures(); + Set types = store.getFeatureTypes(); + assertTrue(types.isEmpty()); + + SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, + Float.NaN, null); + store.add(sf1); + types = store.getFeatureTypes(); + assertEquals(types.size(), 1); + assertTrue(types.contains("Metal")); + + // null type is rejected... + SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20, + Float.NaN, null); + assertFalse(store.add(sf2)); + types = store.getFeatureTypes(); + assertEquals(types.size(), 1); + assertFalse(types.contains(null)); + assertTrue(types.contains("Metal")); + + /* + * add non-positional feature + */ + SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, + Float.NaN, null); + store.add(sf3); + types = store.getFeatureTypes(); + assertEquals(types.size(), 2); + assertTrue(types.contains("Pfam")); + + /* + * add contact feature + */ + SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", + 10, 20, Float.NaN, null); + store.add(sf4); + types = store.getFeatureTypes(); + assertEquals(types.size(), 3); + assertTrue(types.contains("Disulphide Bond")); + + /* + * add another Pfam + */ + SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, + Float.NaN, null); + store.add(sf5); + types = store.getFeatureTypes(); + assertEquals(types.size(), 3); // unchanged + + /* + * delete first Pfam - still have one + */ + assertTrue(store.delete(sf3)); + types = store.getFeatureTypes(); + assertEquals(types.size(), 3); + assertTrue(types.contains("Pfam")); + + /* + * delete second Pfam - no longer have one + */ + assertTrue(store.delete(sf5)); + types = store.getFeatureTypes(); + assertEquals(types.size(), 2); + assertFalse(types.contains("Pfam")); + } + + @Test(groups = "Functional") + public void testGetFeatureCount() + { + SequenceFeaturesI store = new SequenceFeatures(); + assertEquals(store.getFeatureCount(true), 0); + assertEquals(store.getFeatureCount(false), 0); + + /* + * add positional + */ + SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, + Float.NaN, null); + store.add(sf1); + assertEquals(store.getFeatureCount(true), 1); + assertEquals(store.getFeatureCount(false), 0); + + /* + * null feature type is rejected + */ + SequenceFeature sf2 = new SequenceFeature(null, "desc", 10, 20, + Float.NaN, null); + assertFalse(store.add(sf2)); + assertEquals(store.getFeatureCount(true), 1); + assertEquals(store.getFeatureCount(false), 0); + + /* + * add non-positional feature + */ + SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, + Float.NaN, null); + store.add(sf3); + assertEquals(store.getFeatureCount(true), 1); + assertEquals(store.getFeatureCount(false), 1); + + /* + * add contact feature (counts as 1) + */ + SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", + 10, 20, Float.NaN, null); + store.add(sf4); + assertEquals(store.getFeatureCount(true), 2); + assertEquals(store.getFeatureCount(false), 1); + + /* + * add another Pfam but this time as a positional feature + */ + SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, + Float.NaN, null); + store.add(sf5); + assertEquals(store.getFeatureCount(true), 3); // sf1, sf4, sf5 + assertEquals(store.getFeatureCount(false), 1); // sf3 + assertEquals(store.getFeatureCount(true, "Pfam"), 1); // positional + assertEquals(store.getFeatureCount(false, "Pfam"), 1); // non-positional + // search for type==null + assertEquals(store.getFeatureCount(true, (String) null), 0); + // search with no type specified + assertEquals(store.getFeatureCount(true, (String[]) null), 3); + assertEquals(store.getFeatureCount(true, "Metal", "Cath"), 1); + assertEquals(store.getFeatureCount(true, "Disulphide Bond"), 1); + assertEquals(store.getFeatureCount(true, "Metal", "Pfam", null), 2); + + /* + * delete first Pfam (non-positional) + */ + assertTrue(store.delete(sf3)); + assertEquals(store.getFeatureCount(true), 3); + assertEquals(store.getFeatureCount(false), 0); + + /* + * delete second Pfam (positional) + */ + assertTrue(store.delete(sf5)); + assertEquals(store.getFeatureCount(true), 2); + assertEquals(store.getFeatureCount(false), 0); + } + + @Test(groups = "Functional") + public void testGetAllFeatures() + { + SequenceFeaturesI store = new SequenceFeatures(); + List features = store.getAllFeatures(); + assertTrue(features.isEmpty()); + + SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, + Float.NaN, null); + store.add(sf1); + features = store.getAllFeatures(); + assertEquals(features.size(), 1); + assertTrue(features.contains(sf1)); + + SequenceFeature sf2 = new SequenceFeature("Metallic", "desc", 10, 20, + Float.NaN, null); + store.add(sf2); + features = store.getAllFeatures(); + assertEquals(features.size(), 2); + assertTrue(features.contains(sf2)); + + /* + * add non-positional feature + */ + SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, + Float.NaN, null); + store.add(sf3); + features = store.getAllFeatures(); + assertEquals(features.size(), 3); + assertTrue(features.contains(sf3)); + + /* + * add contact feature + */ + SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", + 10, 20, Float.NaN, null); + store.add(sf4); + features = store.getAllFeatures(); + assertEquals(features.size(), 4); + assertTrue(features.contains(sf4)); + + /* + * add another Pfam + */ + SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, + Float.NaN, null); + store.add(sf5); + features = store.getAllFeatures(); + assertEquals(features.size(), 5); + assertTrue(features.contains(sf5)); + + /* + * select by type does not apply to non-positional features + */ + features = store.getAllFeatures("Cath"); + assertEquals(features.size(), 1); + assertTrue(features.contains(sf3)); + + features = store.getAllFeatures("Pfam", "Cath", "Metal"); + assertEquals(features.size(), 3); + assertTrue(features.contains(sf1)); + assertTrue(features.contains(sf3)); + assertTrue(features.contains(sf5)); + + /* + * delete first Pfam + */ + assertTrue(store.delete(sf3)); + features = store.getAllFeatures(); + assertEquals(features.size(), 4); + assertFalse(features.contains(sf3)); + + /* + * delete second Pfam + */ + assertTrue(store.delete(sf5)); + features = store.getAllFeatures(); + assertEquals(features.size(), 3); + assertFalse(features.contains(sf3)); + } + + @Test(groups = "Functional") + public void testGetTotalFeatureLength() + { + SequenceFeaturesI store = new SequenceFeatures(); + assertEquals(store.getTotalFeatureLength(), 0); + + SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20, + Float.NaN, null); + assertTrue(store.add(sf1)); + assertEquals(store.getTotalFeatureLength(), 11); + + // re-add does nothing! + assertFalse(store.add(sf1)); + assertEquals(store.getTotalFeatureLength(), 11); + + /* + * add non-positional feature + */ + SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 0, 0, + Float.NaN, null); + store.add(sf3); + assertEquals(store.getTotalFeatureLength(), 11); + + /* + * add contact feature - counts 1 to feature length + */ + SequenceFeature sf4 = new SequenceFeature("Disulphide Bond", "desc", + 10, 20, Float.NaN, null); + store.add(sf4); + assertEquals(store.getTotalFeatureLength(), 12); + + /* + * add another Pfam + */ + SequenceFeature sf5 = new SequenceFeature("Pfam", "desc", 10, 20, + Float.NaN, null); + store.add(sf5); + assertEquals(store.getTotalFeatureLength(), 23); + + /* + * delete features + */ + assertTrue(store.delete(sf3)); // non-positional + assertEquals(store.getTotalFeatureLength(), 23); // no change + + assertTrue(store.delete(sf5)); + assertEquals(store.getTotalFeatureLength(), 12); + + assertTrue(store.delete(sf4)); // contact + assertEquals(store.getTotalFeatureLength(), 11); + + assertTrue(store.delete(sf1)); + assertEquals(store.getTotalFeatureLength(), 0); + } + + @Test(groups = "Functional") + public void testGetMinimumScore_getMaximumScore() + { + SequenceFeatures sf = new SequenceFeatures(); + SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 0, 0, + Float.NaN, "group"); // non-positional, no score + sf.add(sf1); + SequenceFeature sf2 = new SequenceFeature("Cath", "desc", 10, 20, + Float.NaN, "group"); // positional, no score + sf.add(sf2); + SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 10, 20, 1f, + "group"); + sf.add(sf3); + SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 12, 16, 4f, + "group"); + sf.add(sf4); + SequenceFeature sf5 = new SequenceFeature("Cath", "desc", 0, 0, 11f, + "group"); + sf.add(sf5); + SequenceFeature sf6 = new SequenceFeature("Cath", "desc", 0, 0, -7f, + "group"); + sf.add(sf6); + + assertEquals(sf.getMinimumScore("nosuchtype", true), Float.NaN); + assertEquals(sf.getMinimumScore("nosuchtype", false), Float.NaN); + assertEquals(sf.getMaximumScore("nosuchtype", true), Float.NaN); + assertEquals(sf.getMaximumScore("nosuchtype", false), Float.NaN); + + // positional features min-max: + assertEquals(sf.getMinimumScore("Metal", true), 1f); + assertEquals(sf.getMaximumScore("Metal", true), 4f); + assertEquals(sf.getMinimumScore("Cath", true), Float.NaN); + assertEquals(sf.getMaximumScore("Cath", true), Float.NaN); + + // non-positional features min-max: + assertEquals(sf.getMinimumScore("Cath", false), -7f); + assertEquals(sf.getMaximumScore("Cath", false), 11f); + assertEquals(sf.getMinimumScore("Metal", false), Float.NaN); + assertEquals(sf.getMaximumScore("Metal", false), Float.NaN); + + // delete features; min-max should get recomputed + sf.delete(sf6); + assertEquals(sf.getMinimumScore("Cath", false), 11f); + assertEquals(sf.getMaximumScore("Cath", false), 11f); + sf.delete(sf4); + assertEquals(sf.getMinimumScore("Metal", true), 1f); + assertEquals(sf.getMaximumScore("Metal", true), 1f); + sf.delete(sf5); + assertEquals(sf.getMinimumScore("Cath", false), Float.NaN); + assertEquals(sf.getMaximumScore("Cath", false), Float.NaN); + sf.delete(sf3); + assertEquals(sf.getMinimumScore("Metal", true), Float.NaN); + assertEquals(sf.getMaximumScore("Metal", true), Float.NaN); + sf.delete(sf1); + sf.delete(sf2); + assertFalse(sf.hasFeatures()); + assertEquals(sf.getMinimumScore("Cath", false), Float.NaN); + assertEquals(sf.getMaximumScore("Cath", false), Float.NaN); + assertEquals(sf.getMinimumScore("Metal", true), Float.NaN); + assertEquals(sf.getMaximumScore("Metal", true), Float.NaN); + } + + @Test(groups = "Functional") + public void testVarargsToTypes() + { + SequenceFeatures sf = new SequenceFeatures(); + sf.add(new SequenceFeature("Metal", "desc", 0, 0, Float.NaN, "group")); + sf.add(new SequenceFeature("Cath", "desc", 10, 20, Float.NaN, "group")); + + /* + * no type specified - get all types stored + * they are returned in keyset (alphabetical) order + */ + Iterable types = sf.varargToTypes(); + Iterator iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Cath"); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertFalse(iterator.hasNext()); + + /* + * empty array is the same as no vararg parameter supplied + * so treated as all stored types + */ + types = sf.varargToTypes(new String[] {}); + iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Cath"); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertFalse(iterator.hasNext()); + + /* + * null type specified; this is passed as vararg + * String[1] {null} + */ + types = sf.varargToTypes((String) null); + assertFalse(types.iterator().hasNext()); + + /* + * null types array specified; this is passed as vararg null + */ + types = sf.varargToTypes((String[]) null); + iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Cath"); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertFalse(iterator.hasNext()); + + /* + * one type specified + */ + types = sf.varargToTypes("Metal"); + iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertFalse(iterator.hasNext()); + + /* + * two types specified + */ + types = sf.varargToTypes("Metal", "Helix"); + iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Helix"); + assertFalse(iterator.hasNext()); + + /* + * null type included - should get removed + */ + types = sf.varargToTypes("Metal", null, "Helix"); + iterator = types.iterator(); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Metal"); + assertTrue(iterator.hasNext()); + assertEquals(iterator.next(), "Helix"); + assertFalse(iterator.hasNext()); + } + + @Test(groups = "Functional") + public void testGetFeatureTypes_byOntology() + { + SequenceFeaturesI store = new SequenceFeatures(); + + SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20, + Float.NaN, null); + store.add(sf1); + // mRNA isA mature_transcript isA transcript + SequenceFeature sf2 = new SequenceFeature("mRNA", "desc", 10, 20, + Float.NaN, null); + store.add(sf2); + // just to prove non-positional feature types are included + SequenceFeature sf3 = new SequenceFeature("mRNA", "desc", 0, 0, + Float.NaN, null); + store.add(sf3); + SequenceFeature sf4 = new SequenceFeature("CDS", "desc", 0, 0, + Float.NaN, null); + store.add(sf4); + + Set types = store.getFeatureTypes("transcript"); + assertEquals(types.size(), 2); + assertTrue(types.contains("transcript")); + assertTrue(types.contains("mRNA")); + + // matches include arguments whether SO terms or not + types = store.getFeatureTypes("transcript", "CDS"); + assertEquals(types.size(), 3); + assertTrue(types.contains("transcript")); + assertTrue(types.contains("mRNA")); + assertTrue(types.contains("CDS")); + + types = store.getFeatureTypes("exon"); + assertTrue(types.isEmpty()); + } + + @Test(groups = "Functional") + public void testGetFeaturesByOntology() + { + SequenceFeaturesI store = new SequenceFeatures(); + List features = store.getFeaturesByOntology(); + assertTrue(features.isEmpty()); + assertTrue(store.getFeaturesByOntology(new String[] {}).isEmpty()); + assertTrue(store.getFeaturesByOntology((String[]) null).isEmpty()); + + SequenceFeature sf1 = new SequenceFeature("transcript", "desc", 10, 20, + Float.NaN, null); + store.add(sf1); + + // 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, + Float.NaN, null); + store.add(sf2); + + SequenceFeature sf3 = new SequenceFeature("Pfam", "desc", 30, 40, + Float.NaN, null); + store.add(sf3); + + features = store.getFeaturesByOntology("transcript"); + assertEquals(features.size(), 2); + assertTrue(features.contains(sf1)); + assertTrue(features.contains(sf2)); + + features = store.getFeaturesByOntology("mRNA"); + assertEquals(features.size(), 1); + assertTrue(features.contains(sf2)); + + features = store.getFeaturesByOntology("mRNA", "Pfam"); + assertEquals(features.size(), 2); + assertTrue(features.contains(sf2)); + assertTrue(features.contains(sf3)); + } + + @Test(groups = "Functional") + public void testSortFeatures() + { + List sfs = new ArrayList(); + SequenceFeature sf1 = new SequenceFeature("Pfam", "desc", 30, 80, + Float.NaN, null); + sfs.add(sf1); + SequenceFeature sf2 = new SequenceFeature("Rfam", "desc", 40, 50, + Float.NaN, null); + sfs.add(sf2); + SequenceFeature sf3 = new SequenceFeature("Rfam", "desc", 50, 60, + Float.NaN, null); + sfs.add(sf3); + + // sort by end position descending + SequenceFeatures.sortFeatures(sfs, false); + assertSame(sfs.get(0), sf1); + assertSame(sfs.get(1), sf3); + assertSame(sfs.get(2), sf2); + + // sort by start position ascending + SequenceFeatures.sortFeatures(sfs, true); + assertSame(sfs.get(0), sf1); + assertSame(sfs.get(1), sf2); + assertSame(sfs.get(2), sf3); + } }