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.assertTrue;
7 import jalview.datamodel.SequenceFeature;
11 import org.testng.annotations.Test;
13 public class FeatureStoreTest
16 @Test(groups = "Functional")
17 public void testFindFeatures_nonNested()
19 FeatureStore fs = new FeatureStore();
20 fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN,
22 fs.addFeature(new SequenceFeature("", "", 10, 20, Float.NaN, null));
23 fs.addFeature(new SequenceFeature("", "", 15, 25, Float.NaN, null));
24 fs.addFeature(new SequenceFeature("", "", 20, 35, Float.NaN, null));
26 List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
27 assertTrue(overlaps.isEmpty());
29 overlaps = fs.findOverlappingFeatures(8, 10);
30 assertEquals(overlaps.size(), 2);
31 assertEquals(overlaps.get(0).getEnd(), 20);
32 assertEquals(overlaps.get(1).getEnd(), 20);
34 overlaps = fs.findOverlappingFeatures(12, 16);
35 assertEquals(overlaps.size(), 3);
36 assertEquals(overlaps.get(0).getEnd(), 20);
37 assertEquals(overlaps.get(1).getEnd(), 20);
38 assertEquals(overlaps.get(2).getEnd(), 25);
40 overlaps = fs.findOverlappingFeatures(33, 33);
41 assertEquals(overlaps.size(), 1);
42 assertEquals(overlaps.get(0).getEnd(), 35);
45 @Test(groups = "Functional")
46 public void testFindFeatures_nested()
48 FeatureStore fs = new FeatureStore();
49 SequenceFeature sf1 = addFeature(fs, 10, 50);
50 SequenceFeature sf2 = addFeature(fs, 10, 40);
51 SequenceFeature sf3 = addFeature(fs, 20, 30);
52 SequenceFeature sf4 = addFeature(fs, 20, 30);
53 SequenceFeature sf5 = addFeature(fs, 35, 36);
55 List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
56 assertTrue(overlaps.isEmpty());
58 overlaps = fs.findOverlappingFeatures(10, 15);
59 assertEquals(overlaps.size(), 2);
60 assertTrue(overlaps.contains(sf1));
61 assertTrue(overlaps.contains(sf2));
63 overlaps = fs.findOverlappingFeatures(45, 60);
64 assertEquals(overlaps.size(), 1);
65 assertTrue(overlaps.contains(sf1));
67 overlaps = fs.findOverlappingFeatures(32, 38);
68 assertEquals(overlaps.size(), 3);
69 assertTrue(overlaps.contains(sf1));
70 assertTrue(overlaps.contains(sf2));
71 assertTrue(overlaps.contains(sf5));
73 overlaps = fs.findOverlappingFeatures(15, 25);
74 assertEquals(overlaps.size(), 4);
75 assertTrue(overlaps.contains(sf1));
76 assertTrue(overlaps.contains(sf2));
77 assertTrue(overlaps.contains(sf3));
78 assertTrue(overlaps.contains(sf4));
81 @Test(groups = "Functional")
82 public void testFindFeatures_mixed()
84 FeatureStore fs = new FeatureStore();
85 SequenceFeature sf1 = addFeature(fs, 10, 50);
86 SequenceFeature sf2 = addFeature(fs, 1, 15);
87 SequenceFeature sf3 = addFeature(fs, 20, 30);
88 SequenceFeature sf4 = addFeature(fs, 40, 100);
89 SequenceFeature sf5 = addFeature(fs, 60, 100);
90 SequenceFeature sf6 = addFeature(fs, 70, 70);
92 List<SequenceFeature> overlaps = fs.findOverlappingFeatures(200, 200);
93 assertTrue(overlaps.isEmpty());
95 overlaps = fs.findOverlappingFeatures(1, 9);
96 assertEquals(overlaps.size(), 1);
97 assertTrue(overlaps.contains(sf2));
99 overlaps = fs.findOverlappingFeatures(5, 18);
100 assertEquals(overlaps.size(), 2);
101 assertTrue(overlaps.contains(sf1));
102 assertTrue(overlaps.contains(sf2));
104 overlaps = fs.findOverlappingFeatures(30, 40);
105 assertEquals(overlaps.size(), 3);
106 assertTrue(overlaps.contains(sf1));
107 assertTrue(overlaps.contains(sf3));
108 assertTrue(overlaps.contains(sf4));
110 overlaps = fs.findOverlappingFeatures(80, 90);
111 assertEquals(overlaps.size(), 2);
112 assertTrue(overlaps.contains(sf4));
113 assertTrue(overlaps.contains(sf5));
115 overlaps = fs.findOverlappingFeatures(68, 70);
116 assertEquals(overlaps.size(), 3);
117 assertTrue(overlaps.contains(sf4));
118 assertTrue(overlaps.contains(sf5));
119 assertTrue(overlaps.contains(sf6));
123 * Helper method to add a feature of no particular type
130 SequenceFeature addFeature(FeatureStore fs, int from, int to)
132 SequenceFeature sf1 = new SequenceFeature("", "", from, to, Float.NaN,
138 @Test(groups = "Functional")
139 public void testFindFeatures_contactFeatures()
141 FeatureStore fs = new FeatureStore();
143 SequenceFeature sf = new SequenceFeature("disulphide bond", "bond", 10,
144 20, Float.NaN, null);
148 * neither contact point in range
150 List<SequenceFeature> overlaps = fs.findOverlappingFeatures(1, 9);
151 assertTrue(overlaps.isEmpty());
154 * neither contact point in range
156 overlaps = fs.findOverlappingFeatures(11, 19);
157 assertTrue(overlaps.isEmpty());
160 * first contact point in range
162 overlaps = fs.findOverlappingFeatures(5, 15);
163 assertEquals(overlaps.size(), 1);
164 assertTrue(overlaps.contains(sf));
167 * second contact point in range
169 overlaps = fs.findOverlappingFeatures(15, 25);
170 assertEquals(overlaps.size(), 1);
171 assertTrue(overlaps.contains(sf));
174 * both contact points in range
176 overlaps = fs.findOverlappingFeatures(5, 25);
177 assertEquals(overlaps.size(), 1);
178 assertTrue(overlaps.contains(sf));
182 * Tests for the method that returns false for an attempt to add a feature
183 * that would enclose, or be enclosed by, another feature
185 @Test(groups = "Functional")
186 public void testAddNonNestedFeature()
188 FeatureStore fs = new FeatureStore();
190 String type = "Domain";
191 SequenceFeature sf1 = new SequenceFeature(type, type, 10, 20,
193 assertTrue(fs.addNonNestedFeature(sf1));
195 // co-located feature is ok
196 SequenceFeature sf2 = new SequenceFeature(type, type, 10, 20,
198 assertTrue(fs.addNonNestedFeature(sf2));
200 // overlap left is ok
201 SequenceFeature sf3 = new SequenceFeature(type, type, 5, 15, Float.NaN,
203 assertTrue(fs.addNonNestedFeature(sf3));
205 // overlap right is ok
206 SequenceFeature sf4 = new SequenceFeature(type, type, 15, 25,
208 assertTrue(fs.addNonNestedFeature(sf4));
210 // add enclosing feature is not ok
211 SequenceFeature sf5 = new SequenceFeature(type, type, 10, 21,
213 assertFalse(fs.addNonNestedFeature(sf5));
214 SequenceFeature sf6 = new SequenceFeature(type, type, 4, 15, Float.NaN,
216 assertFalse(fs.addNonNestedFeature(sf6));
217 SequenceFeature sf7 = new SequenceFeature(type, type, 1, 50, Float.NaN,
219 assertFalse(fs.addNonNestedFeature(sf7));
221 // add enclosed feature is not ok
222 SequenceFeature sf8 = new SequenceFeature(type, type, 10, 19,
224 assertFalse(fs.addNonNestedFeature(sf8));
225 SequenceFeature sf9 = new SequenceFeature(type, type, 16, 25,
227 assertFalse(fs.addNonNestedFeature(sf9));
228 SequenceFeature sf10 = new SequenceFeature(type, type, 7, 7, Float.NaN,
230 assertFalse(fs.addNonNestedFeature(sf10));
233 @Test(groups = "Functional")
234 public void testGetFeatures()
236 FeatureStore store = new FeatureStore();
237 SequenceFeature sf1 = new SequenceFeature("Metal", "desc", 10, 20,
239 store.addFeature(sf1);
241 SequenceFeature sf2 = new SequenceFeature("Metal", "desc", 10, 20,
243 store.addFeature(sf2);
244 // discontiguous range
245 SequenceFeature sf3 = new SequenceFeature("Metal", "desc", 30, 40,
247 store.addFeature(sf3);
249 SequenceFeature sf4 = new SequenceFeature("Metal", "desc", 15, 35,
251 store.addFeature(sf4);
253 SequenceFeature sf5 = new SequenceFeature("Metal", "desc", 5, 50,
255 store.addFeature(sf5);
256 // non-positional feature
257 SequenceFeature sf6 = new SequenceFeature("Metal", "desc", 0, 0,
259 store.addFeature(sf6);
261 SequenceFeature sf7 = new SequenceFeature("Disulphide bond", "desc",
262 18, 45, Float.NaN, null);
263 store.addFeature(sf7);
265 List<SequenceFeature> features = store.getFeatures();
266 assertEquals(features.size(), 7);
267 assertTrue(features.contains(sf1));
268 assertTrue(features.contains(sf2));
269 assertTrue(features.contains(sf3));
270 assertTrue(features.contains(sf4));
271 assertTrue(features.contains(sf5));
272 assertTrue(features.contains(sf6));
273 assertTrue(features.contains(sf7));