1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.util; |
22 |
|
|
23 |
|
import static org.testng.AssertJUnit.assertEquals; |
24 |
|
import static org.testng.AssertJUnit.assertFalse; |
25 |
|
import static org.testng.AssertJUnit.assertSame; |
26 |
|
import static org.testng.AssertJUnit.assertTrue; |
27 |
|
|
28 |
|
import jalview.api.AlignViewportI; |
29 |
|
import jalview.commands.EditCommand; |
30 |
|
import jalview.commands.EditCommand.Action; |
31 |
|
import jalview.commands.EditCommand.Edit; |
32 |
|
import jalview.datamodel.AlignedCodonFrame; |
33 |
|
import jalview.datamodel.Alignment; |
34 |
|
import jalview.datamodel.AlignmentI; |
35 |
|
import jalview.datamodel.ColumnSelection; |
36 |
|
import jalview.datamodel.HiddenColumns; |
37 |
|
import jalview.datamodel.SearchResultMatchI; |
38 |
|
import jalview.datamodel.SearchResultsI; |
39 |
|
import jalview.datamodel.Sequence; |
40 |
|
import jalview.datamodel.SequenceGroup; |
41 |
|
import jalview.datamodel.SequenceI; |
42 |
|
import jalview.gui.AlignViewport; |
43 |
|
import jalview.gui.JvOptionPane; |
44 |
|
import jalview.io.DataSourceType; |
45 |
|
import jalview.io.FileFormat; |
46 |
|
import jalview.io.FileFormatI; |
47 |
|
import jalview.io.FormatAdapter; |
48 |
|
|
49 |
|
import java.awt.Color; |
50 |
|
import java.io.IOException; |
51 |
|
import java.util.ArrayList; |
52 |
|
import java.util.Arrays; |
53 |
|
import java.util.Iterator; |
54 |
|
import java.util.List; |
55 |
|
|
56 |
|
import org.testng.annotations.BeforeClass; |
57 |
|
import org.testng.annotations.Test; |
58 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (646) |
Complexity: 36 |
Complexity Density: 0.06 |
|
59 |
|
public class MappingUtilsTest |
60 |
|
{ |
61 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (2) |
Complexity: 1 |
Complexity Density: 0.5 |
|
62 |
1 |
@BeforeClass(alwaysRun = true)... |
63 |
|
public void setUpJvOptionPane() |
64 |
|
{ |
65 |
1 |
JvOptionPane.setInteractiveMode(false); |
66 |
1 |
JvOptionPane.setMockResponse(JvOptionPane.CANCEL_OPTION); |
67 |
|
} |
68 |
|
|
69 |
|
private AlignViewportI dnaView; |
70 |
|
|
71 |
|
private AlignViewportI proteinView; |
72 |
|
|
73 |
|
|
74 |
|
|
75 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (32) |
Complexity: 3 |
Complexity Density: 0.11 |
1PASS
|
|
76 |
1 |
@Test(groups = { "Functional" })... |
77 |
|
public void testBuildSearchResults() |
78 |
|
{ |
79 |
1 |
final Sequence seq1 = new Sequence("Seq1/5-10", "C-G-TA-GC"); |
80 |
1 |
seq1.createDatasetSequence(); |
81 |
|
|
82 |
1 |
final Sequence aseq1 = new Sequence("Seq1/12-13", "-P-R"); |
83 |
1 |
aseq1.createDatasetSequence(); |
84 |
|
|
85 |
|
|
86 |
|
|
87 |
|
|
88 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
89 |
1 |
MapList map = new MapList(new int[] { 5, 10 }, new int[] { 12, 13 }, 3, |
90 |
|
1); |
91 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
92 |
1 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
93 |
|
{ acf }); |
94 |
|
|
95 |
|
|
96 |
|
|
97 |
|
|
98 |
1 |
SearchResultsI sr = MappingUtils.buildSearchResults(aseq1, 12, acfList); |
99 |
1 |
assertEquals(1, sr.getResults().size()); |
100 |
1 |
SearchResultMatchI m = sr.getResults().get(0); |
101 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
102 |
1 |
assertEquals(5, m.getStart()); |
103 |
1 |
assertEquals(7, m.getEnd()); |
104 |
1 |
sr = MappingUtils.buildSearchResults(aseq1, 13, acfList); |
105 |
1 |
assertEquals(1, sr.getResults().size()); |
106 |
1 |
m = sr.getResults().get(0); |
107 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
108 |
1 |
assertEquals(8, m.getStart()); |
109 |
1 |
assertEquals(10, m.getEnd()); |
110 |
|
|
111 |
|
|
112 |
|
|
113 |
|
|
114 |
7 |
for (int i = 5; i < 11; i++) |
115 |
|
{ |
116 |
6 |
sr = MappingUtils.buildSearchResults(seq1, i, acfList); |
117 |
6 |
assertEquals(1, sr.getResults().size()); |
118 |
6 |
m = sr.getResults().get(0); |
119 |
6 |
assertEquals(aseq1.getDatasetSequence(), m.getSequence()); |
120 |
6 |
int residue = i > 7 ? 13 : 12; |
121 |
6 |
assertEquals(residue, m.getStart()); |
122 |
6 |
assertEquals(residue, m.getEnd()); |
123 |
|
} |
124 |
|
} |
125 |
|
|
126 |
|
|
127 |
|
|
128 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (51) |
Complexity: 9 |
Complexity Density: 0.21 |
1PASS
|
|
129 |
1 |
@Test(groups = { "Functional" })... |
130 |
|
public void testBuildSearchResults_withIntron() |
131 |
|
{ |
132 |
1 |
final Sequence seq1 = new Sequence("Seq1/5-17", "c-G-tAGa-GcAgCtt"); |
133 |
1 |
seq1.createDatasetSequence(); |
134 |
|
|
135 |
1 |
final Sequence aseq1 = new Sequence("Seq1/8-9", "-E-D"); |
136 |
1 |
aseq1.createDatasetSequence(); |
137 |
|
|
138 |
|
|
139 |
|
|
140 |
|
|
141 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
142 |
1 |
MapList map = new MapList(new int[] { 6, 6, 8, 9, 11, 11, 13, 13, 15, |
143 |
|
15 }, new int[] { 8, 9 }, 3, 1); |
144 |
1 |
acf.addMap(seq1.getDatasetSequence(), aseq1.getDatasetSequence(), map); |
145 |
1 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
146 |
|
{ acf }); |
147 |
|
|
148 |
|
|
149 |
|
|
150 |
|
|
151 |
1 |
SearchResultsI sr = MappingUtils.buildSearchResults(aseq1, 8, acfList); |
152 |
1 |
assertEquals(2, sr.getResults().size()); |
153 |
1 |
SearchResultMatchI m = sr.getResults().get(0); |
154 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
155 |
1 |
assertEquals(6, m.getStart()); |
156 |
1 |
assertEquals(6, m.getEnd()); |
157 |
1 |
m = sr.getResults().get(1); |
158 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
159 |
1 |
assertEquals(8, m.getStart()); |
160 |
1 |
assertEquals(9, m.getEnd()); |
161 |
|
|
162 |
|
|
163 |
|
|
164 |
|
|
165 |
1 |
sr = MappingUtils.buildSearchResults(aseq1, 9, acfList); |
166 |
1 |
assertEquals(3, sr.getResults().size()); |
167 |
1 |
m = sr.getResults().get(0); |
168 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
169 |
1 |
assertEquals(11, m.getStart()); |
170 |
1 |
assertEquals(11, m.getEnd()); |
171 |
1 |
m = sr.getResults().get(1); |
172 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
173 |
1 |
assertEquals(13, m.getStart()); |
174 |
1 |
assertEquals(13, m.getEnd()); |
175 |
1 |
m = sr.getResults().get(2); |
176 |
1 |
assertEquals(seq1.getDatasetSequence(), m.getSequence()); |
177 |
1 |
assertEquals(15, m.getStart()); |
178 |
1 |
assertEquals(15, m.getEnd()); |
179 |
|
|
180 |
|
|
181 |
|
|
182 |
|
|
183 |
14 |
for (int i = 5; i < 18; i++) |
184 |
|
{ |
185 |
13 |
sr = MappingUtils.buildSearchResults(seq1, i, acfList); |
186 |
10 |
int residue = (i == 6 || i == 8 || i == 9) ? 8 : (i == 11 || i == 13 |
187 |
|
|| i == 15 ? 9 : 0); |
188 |
13 |
if (residue == 0) |
189 |
|
{ |
190 |
7 |
assertEquals(0, sr.getResults().size()); |
191 |
7 |
continue; |
192 |
|
} |
193 |
6 |
assertEquals(1, sr.getResults().size()); |
194 |
6 |
m = sr.getResults().get(0); |
195 |
6 |
assertEquals(aseq1.getDatasetSequence(), m.getSequence()); |
196 |
6 |
assertEquals(residue, m.getStart()); |
197 |
6 |
assertEquals(residue, m.getEnd()); |
198 |
|
} |
199 |
|
} |
200 |
|
|
201 |
|
|
202 |
|
|
203 |
|
|
204 |
|
@throws |
205 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (43) |
Complexity: 2 |
Complexity Density: 0.05 |
1PASS
|
|
206 |
1 |
@Test(groups = { "Functional" })... |
207 |
|
public void testMapSequenceGroup_sequences() throws IOException |
208 |
|
{ |
209 |
|
|
210 |
|
|
211 |
|
|
212 |
|
|
213 |
1 |
AlignmentI cdna = loadAlignment(">Seq1\nACG\n>Seq2\nTGA\n>Seq3\nTAC\n", |
214 |
|
FileFormat.Fasta); |
215 |
1 |
cdna.setDataset(null); |
216 |
1 |
AlignmentI protein = loadAlignment(">Seq1\nK\n>Seq2\nL\n>Seq3\nQ\n", |
217 |
|
FileFormat.Fasta); |
218 |
1 |
protein.setDataset(null); |
219 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
220 |
1 |
MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 1 }, 3, 1); |
221 |
4 |
for (int seq = 0; seq < 3; seq++) |
222 |
|
{ |
223 |
3 |
acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein |
224 |
|
.getSequenceAt(seq).getDatasetSequence(), map); |
225 |
|
} |
226 |
1 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
227 |
|
{ acf }); |
228 |
|
|
229 |
1 |
AlignViewportI dnaView = new AlignViewport(cdna); |
230 |
1 |
AlignViewportI proteinView = new AlignViewport(protein); |
231 |
1 |
protein.setCodonFrames(acfList); |
232 |
|
|
233 |
|
|
234 |
|
|
235 |
|
|
236 |
1 |
SequenceGroup sg = new SequenceGroup(); |
237 |
1 |
sg.setColourText(true); |
238 |
1 |
sg.setIdColour(Color.GREEN); |
239 |
1 |
sg.setOutlineColour(Color.LIGHT_GRAY); |
240 |
1 |
sg.addSequence(protein.getSequenceAt(0), false); |
241 |
1 |
sg.addSequence(protein.getSequenceAt(2), false); |
242 |
|
|
243 |
|
|
244 |
|
|
245 |
|
|
246 |
1 |
SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg, |
247 |
|
proteinView, dnaView); |
248 |
1 |
assertTrue(mappedGroup.getColourText()); |
249 |
1 |
assertSame(sg.getIdColour(), mappedGroup.getIdColour()); |
250 |
1 |
assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour()); |
251 |
1 |
assertEquals(2, mappedGroup.getSequences().size()); |
252 |
1 |
assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0)); |
253 |
1 |
assertSame(cdna.getSequenceAt(2), mappedGroup.getSequences().get(1)); |
254 |
1 |
assertEquals(0, mappedGroup.getStartRes()); |
255 |
1 |
assertEquals(2, mappedGroup.getEndRes()); |
256 |
|
|
257 |
|
|
258 |
|
|
259 |
|
|
260 |
1 |
sg.clear(); |
261 |
1 |
sg.addSequence(cdna.getSequenceAt(1), false); |
262 |
1 |
sg.addSequence(cdna.getSequenceAt(0), false); |
263 |
1 |
sg.setStartRes(0); |
264 |
1 |
sg.setEndRes(2); |
265 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView); |
266 |
1 |
assertTrue(mappedGroup.getColourText()); |
267 |
1 |
assertSame(sg.getIdColour(), mappedGroup.getIdColour()); |
268 |
1 |
assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour()); |
269 |
1 |
assertEquals(2, mappedGroup.getSequences().size()); |
270 |
1 |
assertSame(protein.getSequenceAt(1), mappedGroup.getSequences().get(0)); |
271 |
1 |
assertSame(protein.getSequenceAt(0), mappedGroup.getSequences().get(1)); |
272 |
1 |
assertEquals(0, mappedGroup.getStartRes()); |
273 |
1 |
assertEquals(0, mappedGroup.getEndRes()); |
274 |
|
} |
275 |
|
|
276 |
|
|
277 |
|
|
278 |
|
|
279 |
|
@param |
280 |
|
@param |
281 |
|
|
282 |
|
@return |
283 |
|
@throws |
284 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
|
285 |
14 |
protected AlignmentI loadAlignment(final String data, FileFormatI format)... |
286 |
|
throws IOException |
287 |
|
{ |
288 |
14 |
AlignmentI a = new FormatAdapter().readFile(data, |
289 |
|
DataSourceType.PASTE, format); |
290 |
14 |
a.setDataset(null); |
291 |
14 |
return a; |
292 |
|
} |
293 |
|
|
294 |
|
|
295 |
|
|
296 |
|
|
297 |
|
@throws |
298 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (29) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
299 |
1 |
@Test(groups = { "Functional" })... |
300 |
|
public void testMapColumnSelection_proteinToDna() throws IOException |
301 |
|
{ |
302 |
1 |
setupMappedAlignments(); |
303 |
|
|
304 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
305 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
306 |
|
|
307 |
|
|
308 |
|
|
309 |
|
|
310 |
|
|
311 |
1 |
colsel.addElement(0); |
312 |
1 |
ColumnSelection cs = new ColumnSelection(); |
313 |
1 |
HiddenColumns hs = new HiddenColumns(); |
314 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, proteinView, dnaView, |
315 |
|
cs, hs); |
316 |
1 |
assertEquals("[0, 1, 2, 3, 4]", cs.getSelected().toString()); |
317 |
|
|
318 |
|
|
319 |
|
|
320 |
|
|
321 |
1 |
cs.clear(); |
322 |
1 |
colsel.clear(); |
323 |
1 |
colsel.addElement(1); |
324 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, proteinView, dnaView, |
325 |
|
cs, hs); |
326 |
1 |
assertEquals("[0, 1, 2, 3]", cs.getSelected().toString()); |
327 |
|
|
328 |
|
|
329 |
|
|
330 |
|
|
331 |
1 |
cs.clear(); |
332 |
1 |
colsel.clear(); |
333 |
1 |
colsel.addElement(2); |
334 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, proteinView, |
335 |
|
dnaView, cs, hs); |
336 |
1 |
assertEquals("[]", cs.getSelected().toString()); |
337 |
|
|
338 |
|
|
339 |
|
|
340 |
|
|
341 |
|
|
342 |
1 |
cs.clear(); |
343 |
1 |
colsel.clear(); |
344 |
1 |
colsel.addElement(3); |
345 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, proteinView, |
346 |
|
dnaView, cs, hs); |
347 |
1 |
assertEquals("[5, 6, 7, 8, 9, 10]", cs.getSelected().toString()); |
348 |
|
|
349 |
|
|
350 |
|
|
351 |
|
|
352 |
|
|
353 |
1 |
cs.clear(); |
354 |
1 |
colsel.clear(); |
355 |
1 |
colsel.addElement(1); |
356 |
1 |
colsel.addElement(3); |
357 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, proteinView, |
358 |
|
dnaView, cs, hs); |
359 |
1 |
assertEquals("[0, 1, 2, 3, 5, 6, 7, 8, 9, 10]", cs.getSelected() |
360 |
|
.toString()); |
361 |
|
} |
362 |
|
|
363 |
|
|
364 |
|
|
365 |
|
|
366 |
|
|
367 |
|
@throws |
368 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
|
369 |
4 |
protected void setupMappedAlignments() throws IOException... |
370 |
|
{ |
371 |
|
|
372 |
|
|
373 |
|
|
374 |
|
|
375 |
|
|
376 |
|
|
377 |
4 |
AlignmentI cdna = loadAlignment(">Seq1/10-18\nAC-GctGtC-T\n" |
378 |
|
+ ">Seq2/20-27\nTc-GA-G-T-Tc\n" + ">Seq3/30-38\nTtTT-AaCGg-\n", |
379 |
|
FileFormat.Fasta); |
380 |
4 |
cdna.setDataset(null); |
381 |
4 |
AlignmentI protein = loadAlignment( |
382 |
|
">Seq1/40-41\n-K-P\n>Seq2/50-51\nL--Q\n>Seq3/60-61\nG--S\n", |
383 |
|
FileFormat.Fasta); |
384 |
4 |
protein.setDataset(null); |
385 |
|
|
386 |
|
|
387 |
4 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
388 |
4 |
MapList map = new MapList(new int[] { 10, 12, 15, 15, 17, 18 }, |
389 |
|
new int[] { 40, 41 }, 3, 1); |
390 |
4 |
acf.addMap(cdna.getSequenceAt(0).getDatasetSequence(), protein |
391 |
|
.getSequenceAt(0).getDatasetSequence(), map); |
392 |
|
|
393 |
|
|
394 |
4 |
map = new MapList(new int[] { 20, 20, 22, 23, 24, 26 }, new int[] { 50, |
395 |
|
51 }, 3, 1); |
396 |
4 |
acf.addMap(cdna.getSequenceAt(1).getDatasetSequence(), protein |
397 |
|
.getSequenceAt(1).getDatasetSequence(), map); |
398 |
|
|
399 |
|
|
400 |
4 |
map = new MapList(new int[] { 30, 30, 32, 34, 36, 37 }, new int[] { 60, |
401 |
|
61 }, 3, 1); |
402 |
4 |
acf.addMap(cdna.getSequenceAt(2).getDatasetSequence(), protein |
403 |
|
.getSequenceAt(2).getDatasetSequence(), map); |
404 |
4 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
405 |
|
{ acf }); |
406 |
|
|
407 |
4 |
dnaView = new AlignViewport(cdna); |
408 |
4 |
proteinView = new AlignViewport(protein); |
409 |
4 |
protein.setCodonFrames(acfList); |
410 |
|
} |
411 |
|
|
412 |
|
|
413 |
|
|
414 |
|
|
415 |
|
@throws |
416 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
417 |
1 |
@Test(groups = { "Functional" })... |
418 |
|
public void testMapColumnSelection_dnaToProtein() throws IOException |
419 |
|
{ |
420 |
1 |
setupMappedAlignments(); |
421 |
|
|
422 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
423 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
424 |
|
|
425 |
|
|
426 |
|
|
427 |
|
|
428 |
|
|
429 |
1 |
ColumnSelection cs = new ColumnSelection(); |
430 |
1 |
HiddenColumns hs = new HiddenColumns(); |
431 |
1 |
colsel.addElement(0); |
432 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, dnaView, proteinView, |
433 |
|
cs, hs); |
434 |
1 |
assertEquals("[0, 1]", cs.getSelected().toString()); |
435 |
|
|
436 |
|
|
437 |
|
|
438 |
|
|
439 |
|
|
440 |
1 |
colsel.addElement(3); |
441 |
1 |
colsel.addElement(4); |
442 |
1 |
colsel.addElement(5); |
443 |
1 |
cs.clear(); |
444 |
1 |
MappingUtils.mapColumnSelection(colsel, hidden, dnaView, proteinView, |
445 |
|
cs, hs); |
446 |
1 |
assertEquals("[0, 1, 3]", cs.getSelected().toString()); |
447 |
|
} |
448 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 1 |
Complexity Density: 0.2 |
1PASS
|
|
449 |
1 |
@Test(groups = { "Functional" })... |
450 |
|
public void testMapColumnSelection_null() throws IOException |
451 |
|
{ |
452 |
1 |
setupMappedAlignments(); |
453 |
1 |
ColumnSelection cs = new ColumnSelection(); |
454 |
1 |
HiddenColumns hs = new HiddenColumns(); |
455 |
1 |
MappingUtils.mapColumnSelection(null, null, dnaView, proteinView, cs, |
456 |
|
hs); |
457 |
1 |
assertTrue("mapped selection not empty", cs.getSelected().isEmpty()); |
458 |
|
} |
459 |
|
|
460 |
|
|
461 |
|
|
462 |
|
|
463 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (5) |
Complexity: 1 |
Complexity Density: 0.2 |
1PASS
|
|
464 |
1 |
@Test(groups = { "Functional" })... |
465 |
|
public void testFlattenRanges() |
466 |
|
{ |
467 |
1 |
assertEquals("[1, 2, 3, 4]", |
468 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4 }))); |
469 |
1 |
assertEquals( |
470 |
|
"[1, 2, 3, 4]", |
471 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 2, 3, |
472 |
|
4 }))); |
473 |
1 |
assertEquals( |
474 |
|
"[1, 2, 3, 4]", |
475 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 1, 2, |
476 |
|
2, 3, 3, 4, 4 }))); |
477 |
1 |
assertEquals( |
478 |
|
"[1, 2, 3, 4, 7, 8, 9, 12]", |
479 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4, 7, |
480 |
|
9, 12, 12 }))); |
481 |
|
|
482 |
1 |
assertEquals( |
483 |
|
"[1, 2, 3, 4, 7, 8, 9, 12]", |
484 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 1, 4, 7, |
485 |
|
9, 12, 12, 15 }))); |
486 |
|
} |
487 |
|
|
488 |
|
|
489 |
|
|
490 |
|
|
491 |
|
@throws |
492 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (49) |
Complexity: 2 |
Complexity Density: 0.04 |
1PASS
|
|
493 |
1 |
@Test(groups = { "Functional" })... |
494 |
|
public void testMapSequenceGroup_columns() throws IOException |
495 |
|
{ |
496 |
|
|
497 |
|
|
498 |
|
|
499 |
|
|
500 |
1 |
AlignmentI cdna = loadAlignment( |
501 |
|
">Seq1\nACGGCA\n>Seq2\nTGACAG\n>Seq3\nTACGTA\n", |
502 |
|
FileFormat.Fasta); |
503 |
1 |
cdna.setDataset(null); |
504 |
1 |
AlignmentI protein = loadAlignment(">Seq1\nKA\n>Seq2\nLQ\n>Seq3\nQV\n", |
505 |
|
FileFormat.Fasta); |
506 |
1 |
protein.setDataset(null); |
507 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
508 |
1 |
MapList map = new MapList(new int[] { 1, 6 }, new int[] { 1, 2 }, 3, 1); |
509 |
4 |
for (int seq = 0; seq < 3; seq++) |
510 |
|
{ |
511 |
3 |
acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein |
512 |
|
.getSequenceAt(seq).getDatasetSequence(), map); |
513 |
|
} |
514 |
1 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
515 |
|
{ acf }); |
516 |
|
|
517 |
1 |
AlignViewportI dnaView = new AlignViewport(cdna); |
518 |
1 |
AlignViewportI proteinView = new AlignViewport(protein); |
519 |
1 |
protein.setCodonFrames(acfList); |
520 |
|
|
521 |
|
|
522 |
|
|
523 |
|
|
524 |
1 |
SequenceGroup sg = new SequenceGroup(); |
525 |
1 |
sg.setColourText(true); |
526 |
1 |
sg.setIdColour(Color.GREEN); |
527 |
1 |
sg.setOutlineColour(Color.LIGHT_GRAY); |
528 |
1 |
sg.addSequence(protein.getSequenceAt(0), false); |
529 |
1 |
sg.addSequence(protein.getSequenceAt(1), false); |
530 |
1 |
sg.addSequence(protein.getSequenceAt(2), false); |
531 |
1 |
sg.setStartRes(1); |
532 |
1 |
sg.setEndRes(1); |
533 |
|
|
534 |
|
|
535 |
|
|
536 |
|
|
537 |
1 |
SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg, |
538 |
|
proteinView, dnaView); |
539 |
1 |
assertTrue(mappedGroup.getColourText()); |
540 |
1 |
assertSame(sg.getIdColour(), mappedGroup.getIdColour()); |
541 |
1 |
assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour()); |
542 |
1 |
assertEquals(3, mappedGroup.getSequences().size()); |
543 |
1 |
assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0)); |
544 |
1 |
assertSame(cdna.getSequenceAt(1), mappedGroup.getSequences().get(1)); |
545 |
1 |
assertSame(cdna.getSequenceAt(2), mappedGroup.getSequences().get(2)); |
546 |
1 |
assertEquals(3, mappedGroup.getStartRes()); |
547 |
1 |
assertEquals(5, mappedGroup.getEndRes()); |
548 |
|
|
549 |
|
|
550 |
|
|
551 |
|
|
552 |
1 |
sg.clear(); |
553 |
1 |
sg.addSequence(cdna.getSequenceAt(0), false); |
554 |
1 |
sg.addSequence(cdna.getSequenceAt(1), false); |
555 |
1 |
sg.addSequence(cdna.getSequenceAt(2), false); |
556 |
|
|
557 |
1 |
sg.setStartRes(2); |
558 |
1 |
sg.setEndRes(3); |
559 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView); |
560 |
1 |
assertTrue(mappedGroup.getColourText()); |
561 |
1 |
assertSame(sg.getIdColour(), mappedGroup.getIdColour()); |
562 |
1 |
assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour()); |
563 |
1 |
assertEquals(3, mappedGroup.getSequences().size()); |
564 |
1 |
assertSame(protein.getSequenceAt(0), mappedGroup.getSequences().get(0)); |
565 |
1 |
assertSame(protein.getSequenceAt(1), mappedGroup.getSequences().get(1)); |
566 |
1 |
assertSame(protein.getSequenceAt(2), mappedGroup.getSequences().get(2)); |
567 |
1 |
assertEquals(0, mappedGroup.getStartRes()); |
568 |
1 |
assertEquals(1, mappedGroup.getEndRes()); |
569 |
|
} |
570 |
|
|
571 |
|
|
572 |
|
|
573 |
|
|
574 |
|
@throws |
575 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (50) |
Complexity: 2 |
Complexity Density: 0.04 |
1PASS
|
|
576 |
1 |
@Test(groups = { "Functional" })... |
577 |
|
public void testMapSequenceGroup_region() throws IOException |
578 |
|
{ |
579 |
|
|
580 |
|
|
581 |
|
|
582 |
|
|
583 |
1 |
AlignmentI cdna = loadAlignment( |
584 |
|
">Seq1\nA-CG-GC--AT-CA\n>Seq2\n-TG-AC-AG-T-AT\n>Seq3\n-T--ACG-TAAT-G\n", |
585 |
|
FileFormat.Fasta); |
586 |
1 |
cdna.setDataset(null); |
587 |
1 |
AlignmentI protein = loadAlignment( |
588 |
|
">Seq1\n-KA-S\n>Seq2\n--L-QY\n>Seq3\nQ-V-M\n", FileFormat.Fasta); |
589 |
1 |
protein.setDataset(null); |
590 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
591 |
1 |
MapList map = new MapList(new int[] { 1, 9 }, new int[] { 1, 3 }, 3, 1); |
592 |
4 |
for (int seq = 0; seq < 3; seq++) |
593 |
|
{ |
594 |
3 |
acf.addMap(cdna.getSequenceAt(seq).getDatasetSequence(), protein |
595 |
|
.getSequenceAt(seq).getDatasetSequence(), map); |
596 |
|
} |
597 |
1 |
List<AlignedCodonFrame> acfList = Arrays.asList(new AlignedCodonFrame[] |
598 |
|
{ acf }); |
599 |
|
|
600 |
1 |
AlignViewportI dnaView = new AlignViewport(cdna); |
601 |
1 |
AlignViewportI proteinView = new AlignViewport(protein); |
602 |
1 |
protein.setCodonFrames(acfList); |
603 |
|
|
604 |
|
|
605 |
|
|
606 |
|
|
607 |
|
|
608 |
|
|
609 |
|
|
610 |
1 |
SequenceGroup sg = new SequenceGroup(); |
611 |
1 |
sg.setColourText(true); |
612 |
1 |
sg.setIdColour(Color.GREEN); |
613 |
1 |
sg.setOutlineColour(Color.LIGHT_GRAY); |
614 |
1 |
sg.addSequence(protein.getSequenceAt(0), false); |
615 |
1 |
sg.addSequence(protein.getSequenceAt(1), false); |
616 |
1 |
sg.setStartRes(1); |
617 |
1 |
sg.setEndRes(1); |
618 |
|
|
619 |
|
|
620 |
|
|
621 |
|
|
622 |
1 |
SequenceGroup mappedGroup = MappingUtils.mapSequenceGroup(sg, |
623 |
|
proteinView, dnaView); |
624 |
1 |
assertTrue(mappedGroup.getColourText()); |
625 |
1 |
assertSame(sg.getIdColour(), mappedGroup.getIdColour()); |
626 |
1 |
assertSame(sg.getOutlineColour(), mappedGroup.getOutlineColour()); |
627 |
1 |
assertEquals(1, mappedGroup.getSequences().size()); |
628 |
1 |
assertSame(cdna.getSequenceAt(0), mappedGroup.getSequences().get(0)); |
629 |
|
|
630 |
|
|
631 |
1 |
assertEquals(0, mappedGroup.getStartRes()); |
632 |
1 |
assertEquals(3, mappedGroup.getEndRes()); |
633 |
|
|
634 |
|
|
635 |
|
|
636 |
|
|
637 |
|
|
638 |
1 |
sg.setStartRes(2); |
639 |
1 |
sg.setEndRes(4); |
640 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, proteinView, dnaView); |
641 |
1 |
assertEquals(1, mappedGroup.getStartRes()); |
642 |
1 |
assertEquals(13, mappedGroup.getEndRes()); |
643 |
|
|
644 |
|
|
645 |
|
|
646 |
|
|
647 |
1 |
sg.clear(); |
648 |
1 |
sg.addSequence(cdna.getSequenceAt(0), false); |
649 |
|
|
650 |
|
|
651 |
1 |
sg.setStartRes(4); |
652 |
1 |
sg.setEndRes(5); |
653 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView); |
654 |
1 |
assertEquals(2, mappedGroup.getStartRes()); |
655 |
1 |
assertEquals(2, mappedGroup.getEndRes()); |
656 |
|
|
657 |
|
|
658 |
1 |
sg.addSequence(cdna.getSequenceAt(1), false); |
659 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView); |
660 |
1 |
assertEquals(2, mappedGroup.getStartRes()); |
661 |
1 |
assertEquals(4, mappedGroup.getEndRes()); |
662 |
|
|
663 |
|
|
664 |
1 |
sg.addSequence(cdna.getSequenceAt(2), false); |
665 |
1 |
mappedGroup = MappingUtils.mapSequenceGroup(sg, dnaView, proteinView); |
666 |
1 |
assertEquals(0, mappedGroup.getStartRes()); |
667 |
1 |
assertEquals(4, mappedGroup.getEndRes()); |
668 |
|
} |
669 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (39) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
670 |
1 |
@Test(groups = { "Functional" })... |
671 |
|
public void testFindMappingsForSequence() |
672 |
|
{ |
673 |
1 |
SequenceI seq1 = new Sequence("Seq1", "ABC"); |
674 |
1 |
SequenceI seq2 = new Sequence("Seq2", "ABC"); |
675 |
1 |
SequenceI seq3 = new Sequence("Seq3", "ABC"); |
676 |
1 |
SequenceI seq4 = new Sequence("Seq4", "ABC"); |
677 |
1 |
seq1.createDatasetSequence(); |
678 |
1 |
seq2.createDatasetSequence(); |
679 |
1 |
seq3.createDatasetSequence(); |
680 |
1 |
seq4.createDatasetSequence(); |
681 |
|
|
682 |
|
|
683 |
|
|
684 |
|
|
685 |
1 |
AlignedCodonFrame acf1 = new AlignedCodonFrame(); |
686 |
1 |
MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 3 }, 1, 1); |
687 |
1 |
acf1.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map); |
688 |
1 |
AlignedCodonFrame acf2 = new AlignedCodonFrame(); |
689 |
1 |
acf2.addMap(seq2.getDatasetSequence(), seq1.getDatasetSequence(), map); |
690 |
1 |
AlignedCodonFrame acf3 = new AlignedCodonFrame(); |
691 |
1 |
acf3.addMap(seq3.getDatasetSequence(), seq1.getDatasetSequence(), map); |
692 |
|
|
693 |
1 |
List<AlignedCodonFrame> mappings = new ArrayList<>(); |
694 |
1 |
mappings.add(acf1); |
695 |
1 |
mappings.add(acf2); |
696 |
1 |
mappings.add(acf3); |
697 |
|
|
698 |
|
|
699 |
|
|
700 |
|
|
701 |
1 |
List<AlignedCodonFrame> result = MappingUtils.findMappingsForSequence( |
702 |
|
seq1, mappings); |
703 |
1 |
assertEquals(3, result.size()); |
704 |
1 |
assertTrue(result.contains(acf1)); |
705 |
1 |
assertTrue(result.contains(acf2)); |
706 |
1 |
assertTrue(result.contains(acf3)); |
707 |
|
|
708 |
|
|
709 |
|
|
710 |
|
|
711 |
1 |
result = MappingUtils.findMappingsForSequence(seq2, mappings); |
712 |
1 |
assertEquals(2, result.size()); |
713 |
1 |
assertTrue(result.contains(acf1)); |
714 |
1 |
assertTrue(result.contains(acf2)); |
715 |
|
|
716 |
|
|
717 |
|
|
718 |
|
|
719 |
1 |
result = MappingUtils.findMappingsForSequence(seq3, mappings); |
720 |
1 |
assertEquals(1, result.size()); |
721 |
1 |
assertTrue(result.contains(acf3)); |
722 |
|
|
723 |
|
|
724 |
|
|
725 |
|
|
726 |
1 |
result = MappingUtils.findMappingsForSequence(seq4, mappings); |
727 |
1 |
assertEquals(0, result.size()); |
728 |
|
|
729 |
1 |
result = MappingUtils.findMappingsForSequence(null, mappings); |
730 |
1 |
assertEquals(0, result.size()); |
731 |
|
|
732 |
1 |
result = MappingUtils.findMappingsForSequence(seq1, null); |
733 |
1 |
assertEquals(0, result.size()); |
734 |
|
|
735 |
1 |
result = MappingUtils.findMappingsForSequence(null, null); |
736 |
1 |
assertEquals(0, result.size()); |
737 |
|
} |
738 |
|
|
739 |
|
|
740 |
|
|
741 |
|
|
742 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (37) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
743 |
1 |
@Test(groups = { "Functional" })... |
744 |
|
public void testFindMappingsForSequenceAndOthers() |
745 |
|
{ |
746 |
1 |
SequenceI seq1 = new Sequence("Seq1", "ABC"); |
747 |
1 |
SequenceI seq2 = new Sequence("Seq2", "ABC"); |
748 |
1 |
SequenceI seq3 = new Sequence("Seq3", "ABC"); |
749 |
1 |
SequenceI seq4 = new Sequence("Seq4", "ABC"); |
750 |
1 |
seq1.createDatasetSequence(); |
751 |
1 |
seq2.createDatasetSequence(); |
752 |
1 |
seq3.createDatasetSequence(); |
753 |
1 |
seq4.createDatasetSequence(); |
754 |
|
|
755 |
|
|
756 |
|
|
757 |
|
|
758 |
1 |
AlignedCodonFrame acf1 = new AlignedCodonFrame(); |
759 |
1 |
MapList map = new MapList(new int[] { 1, 3 }, new int[] { 1, 3 }, 1, 1); |
760 |
1 |
acf1.addMap(seq1.getDatasetSequence(), seq2.getDatasetSequence(), map); |
761 |
1 |
AlignedCodonFrame acf2 = new AlignedCodonFrame(); |
762 |
1 |
acf2.addMap(seq2.getDatasetSequence(), seq1.getDatasetSequence(), map); |
763 |
1 |
AlignedCodonFrame acf3 = new AlignedCodonFrame(); |
764 |
1 |
acf3.addMap(seq3.getDatasetSequence(), seq1.getDatasetSequence(), map); |
765 |
1 |
AlignedCodonFrame acf4 = new AlignedCodonFrame(); |
766 |
1 |
acf4.addMap(seq3.getDatasetSequence(), seq4.getDatasetSequence(), map); |
767 |
|
|
768 |
1 |
List<AlignedCodonFrame> mappings = new ArrayList<>(); |
769 |
1 |
mappings.add(acf1); |
770 |
1 |
mappings.add(acf2); |
771 |
1 |
mappings.add(acf3); |
772 |
1 |
mappings.add(acf4); |
773 |
|
|
774 |
|
|
775 |
|
|
776 |
|
|
777 |
1 |
List<AlignedCodonFrame> result = MappingUtils |
778 |
|
.findMappingsForSequenceAndOthers(null, mappings, |
779 |
|
Arrays.asList(new SequenceI[] { seq1, seq2 })); |
780 |
1 |
assertTrue(result.isEmpty()); |
781 |
|
|
782 |
1 |
result = MappingUtils.findMappingsForSequenceAndOthers(seq1, null, |
783 |
|
Arrays.asList(new SequenceI[] { seq1, seq2 })); |
784 |
1 |
assertTrue(result.isEmpty()); |
785 |
|
|
786 |
|
|
787 |
|
|
788 |
|
|
789 |
|
|
790 |
1 |
result = MappingUtils.findMappingsForSequenceAndOthers( |
791 |
|
seq1, |
792 |
|
mappings, |
793 |
|
Arrays.asList(new SequenceI[] { seq1, seq2, |
794 |
|
seq1.getDatasetSequence() })); |
795 |
1 |
assertEquals(2, result.size()); |
796 |
1 |
assertTrue(result.contains(acf1)); |
797 |
1 |
assertTrue(result.contains(acf2)); |
798 |
1 |
assertFalse("Did not expect to find mapping acf3 - subselect failed", |
799 |
|
result.contains(acf3)); |
800 |
1 |
assertFalse( |
801 |
|
"Did not expect to find mapping acf4 - doesn't involve sequence", |
802 |
|
result.contains(acf4)); |
803 |
|
|
804 |
|
|
805 |
|
|
806 |
|
|
807 |
1 |
result = MappingUtils.findMappingsForSequenceAndOthers(seq1, mappings, |
808 |
|
null); |
809 |
1 |
assertEquals(3, result.size()); |
810 |
1 |
assertTrue(result.contains(acf1)); |
811 |
1 |
assertTrue(result.contains(acf2)); |
812 |
1 |
assertTrue(result.contains(acf3)); |
813 |
|
} |
814 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (22) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
815 |
1 |
@Test(groups = { "Functional" })... |
816 |
|
public void testMapEditCommand() |
817 |
|
{ |
818 |
1 |
SequenceI dna = new Sequence("Seq1", "---ACG---GCATCA", 8, 16); |
819 |
1 |
SequenceI protein = new Sequence("Seq2", "-T-AS", 5, 7); |
820 |
1 |
dna.createDatasetSequence(); |
821 |
1 |
protein.createDatasetSequence(); |
822 |
1 |
AlignedCodonFrame acf = new AlignedCodonFrame(); |
823 |
1 |
MapList map = new MapList(new int[] { 8, 16 }, new int[] { 5, 7 }, 3, 1); |
824 |
1 |
acf.addMap(dna.getDatasetSequence(), protein.getDatasetSequence(), map); |
825 |
1 |
List<AlignedCodonFrame> mappings = new ArrayList<>(); |
826 |
1 |
mappings.add(acf); |
827 |
|
|
828 |
1 |
AlignmentI prot = new Alignment(new SequenceI[] { protein }); |
829 |
1 |
prot.setCodonFrames(mappings); |
830 |
1 |
AlignmentI nuc = new Alignment(new SequenceI[] { dna }); |
831 |
|
|
832 |
|
|
833 |
|
|
834 |
|
|
835 |
|
|
836 |
1 |
EditCommand ec = new EditCommand(); |
837 |
1 |
final Edit edit = ec.new Edit(Action.INSERT_GAP, |
838 |
|
new SequenceI[] { protein }, 4, 2, '-'); |
839 |
1 |
ec.appendEdit(edit, prot, true, null); |
840 |
|
|
841 |
|
|
842 |
|
|
843 |
|
|
844 |
|
|
845 |
1 |
EditCommand mappedEdit = MappingUtils.mapEditCommand(ec, false, nuc, |
846 |
|
'-', mappings); |
847 |
1 |
assertEquals(1, mappedEdit.getEdits().size()); |
848 |
1 |
Edit e = mappedEdit.getEdits().get(0); |
849 |
1 |
assertEquals(1, e.getSequences().length); |
850 |
1 |
assertEquals(dna, e.getSequences()[0]); |
851 |
1 |
assertEquals(12, e.getPosition()); |
852 |
1 |
assertEquals(6, e.getNumber()); |
853 |
|
} |
854 |
|
|
855 |
|
|
856 |
|
|
857 |
|
|
858 |
|
|
859 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
860 |
1 |
@Test(groups = { "Functional" })... |
861 |
|
public void testFlattenRanges_reverseStrand() |
862 |
|
{ |
863 |
1 |
assertEquals("[4, 3, 2, 1]", |
864 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 1 }))); |
865 |
1 |
assertEquals( |
866 |
|
"[4, 3, 2, 1]", |
867 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 3, 2, |
868 |
|
1 }))); |
869 |
1 |
assertEquals( |
870 |
|
"[4, 3, 2, 1]", |
871 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 4, 3, |
872 |
|
3, 2, 2, 1, 1 }))); |
873 |
1 |
assertEquals( |
874 |
|
"[12, 9, 8, 7, 4, 3, 2, 1]", |
875 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 12, 12, |
876 |
|
9, 7, 4, 1 }))); |
877 |
|
|
878 |
1 |
assertEquals( |
879 |
|
"[4, 5, 6, 3, 2, 1]", |
880 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 4, 6, 3, |
881 |
|
1 }))); |
882 |
|
|
883 |
1 |
assertEquals( |
884 |
|
"[3, 2, 1, 4, 5, 6]", |
885 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 3, 1, 4, |
886 |
|
6 }))); |
887 |
|
|
888 |
1 |
assertEquals( |
889 |
|
"[12, 9, 8, 7, 4, 3, 2]", |
890 |
|
Arrays.toString(MappingUtils.flattenRanges(new int[] { 12, 12, |
891 |
|
9, 7, 4, 2, 1 }))); |
892 |
|
} |
893 |
|
|
894 |
|
|
895 |
|
|
896 |
|
|
897 |
|
@throws |
898 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (50) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
899 |
1 |
@Test(groups = { "Functional" })... |
900 |
|
public void testMapColumnSelection_hiddenColumns() throws IOException |
901 |
|
{ |
902 |
1 |
setupMappedAlignments(); |
903 |
|
|
904 |
1 |
ColumnSelection proteinSelection = new ColumnSelection(); |
905 |
1 |
HiddenColumns hiddenCols = new HiddenColumns(); |
906 |
|
|
907 |
|
|
908 |
|
|
909 |
|
|
910 |
|
|
911 |
1 |
proteinSelection.hideSelectedColumns(0, hiddenCols); |
912 |
1 |
ColumnSelection dnaSelection = new ColumnSelection(); |
913 |
1 |
HiddenColumns dnaHidden = new HiddenColumns(); |
914 |
1 |
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols, |
915 |
|
proteinView, dnaView, dnaSelection, dnaHidden); |
916 |
1 |
assertEquals("[]", dnaSelection.getSelected().toString()); |
917 |
1 |
Iterator<int[]> regions = dnaHidden.iterator(); |
918 |
1 |
assertEquals(1, dnaHidden.getNumberOfRegions()); |
919 |
1 |
assertEquals("[0, 4]", Arrays.toString(regions.next())); |
920 |
|
|
921 |
|
|
922 |
|
|
923 |
|
|
924 |
1 |
dnaSelection = new ColumnSelection(); |
925 |
1 |
dnaHidden = new HiddenColumns(); |
926 |
1 |
hiddenCols.revealAllHiddenColumns(proteinSelection); |
927 |
|
|
928 |
1 |
assertEquals("[0]", proteinSelection.getSelected().toString()); |
929 |
|
|
930 |
1 |
proteinSelection.clear(); |
931 |
1 |
proteinSelection.hideSelectedColumns(1, hiddenCols); |
932 |
1 |
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols, |
933 |
|
proteinView, dnaView, dnaSelection, dnaHidden); |
934 |
1 |
regions = dnaHidden.iterator(); |
935 |
1 |
assertEquals(1, dnaHidden.getNumberOfRegions()); |
936 |
1 |
assertEquals("[0, 3]", Arrays.toString(regions.next())); |
937 |
|
|
938 |
|
|
939 |
|
|
940 |
|
|
941 |
1 |
dnaSelection = new ColumnSelection(); |
942 |
1 |
dnaHidden = new HiddenColumns(); |
943 |
1 |
hiddenCols.revealAllHiddenColumns(proteinSelection); |
944 |
1 |
proteinSelection.clear(); |
945 |
1 |
proteinSelection.hideSelectedColumns(2, hiddenCols); |
946 |
1 |
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols, |
947 |
|
proteinView, dnaView, dnaSelection, dnaHidden); |
948 |
1 |
assertEquals(0, dnaHidden.getNumberOfRegions()); |
949 |
|
|
950 |
|
|
951 |
|
|
952 |
|
|
953 |
|
|
954 |
1 |
dnaSelection = new ColumnSelection(); |
955 |
1 |
dnaHidden = new HiddenColumns(); |
956 |
1 |
hiddenCols.revealAllHiddenColumns(proteinSelection); |
957 |
1 |
proteinSelection.clear(); |
958 |
1 |
proteinSelection.hideSelectedColumns(3, hiddenCols); |
959 |
1 |
proteinSelection.addElement(1); |
960 |
1 |
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols, |
961 |
|
proteinView, dnaView, dnaSelection, dnaHidden); |
962 |
1 |
assertEquals("[0, 1, 2, 3]", dnaSelection.getSelected().toString()); |
963 |
1 |
regions = dnaHidden.iterator(); |
964 |
1 |
assertEquals(1, dnaHidden.getNumberOfRegions()); |
965 |
1 |
assertEquals("[5, 10]", Arrays.toString(regions.next())); |
966 |
|
|
967 |
|
|
968 |
|
|
969 |
|
|
970 |
1 |
dnaSelection = new ColumnSelection(); |
971 |
1 |
dnaHidden = new HiddenColumns(); |
972 |
1 |
hiddenCols.revealAllHiddenColumns(proteinSelection); |
973 |
1 |
proteinSelection.clear(); |
974 |
1 |
proteinSelection.hideSelectedColumns(1, hiddenCols); |
975 |
1 |
proteinSelection.hideSelectedColumns(3, hiddenCols); |
976 |
1 |
MappingUtils.mapColumnSelection(proteinSelection, hiddenCols, |
977 |
|
proteinView, dnaView, dnaSelection, dnaHidden); |
978 |
1 |
regions = dnaHidden.iterator(); |
979 |
1 |
assertEquals(2, dnaHidden.getNumberOfRegions()); |
980 |
1 |
assertEquals("[0, 3]", Arrays.toString(regions.next())); |
981 |
1 |
assertEquals("[5, 10]", Arrays.toString(regions.next())); |
982 |
|
} |
983 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
984 |
1 |
@Test(groups = { "Functional" })... |
985 |
|
public void testGetLength() |
986 |
|
{ |
987 |
1 |
assertEquals(0, MappingUtils.getLength(null)); |
988 |
|
|
989 |
|
|
990 |
|
|
991 |
|
|
992 |
1 |
List<int[]> ranges = new ArrayList<>(); |
993 |
1 |
assertEquals(0, MappingUtils.getLength(ranges)); |
994 |
1 |
ranges.add(new int[] { 1, 1 }); |
995 |
1 |
assertEquals(1, MappingUtils.getLength(ranges)); |
996 |
1 |
ranges.add(new int[] { 2, 10 }); |
997 |
1 |
assertEquals(10, MappingUtils.getLength(ranges)); |
998 |
1 |
ranges.add(new int[] { 20, 10 }); |
999 |
1 |
assertEquals(21, MappingUtils.getLength(ranges)); |
1000 |
|
|
1001 |
|
|
1002 |
|
|
1003 |
|
|
1004 |
1 |
ranges.clear(); |
1005 |
1 |
ranges.add(new int[] { 1, 5, 8, 4 }); |
1006 |
1 |
ranges.add(new int[] { 8, 2 }); |
1007 |
1 |
ranges.add(new int[] { 12, 12 }); |
1008 |
1 |
assertEquals(18, MappingUtils.getLength(ranges)); |
1009 |
|
} |
1010 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (28) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
1011 |
1 |
@Test(groups = { "Functional" })... |
1012 |
|
public void testContains() |
1013 |
|
{ |
1014 |
1 |
assertFalse(MappingUtils.contains(null, 1)); |
1015 |
1 |
List<int[]> ranges = new ArrayList<>(); |
1016 |
1 |
assertFalse(MappingUtils.contains(ranges, 1)); |
1017 |
|
|
1018 |
1 |
ranges.add(new int[] { 1, 4 }); |
1019 |
1 |
ranges.add(new int[] { 6, 6 }); |
1020 |
1 |
ranges.add(new int[] { 8, 10 }); |
1021 |
1 |
ranges.add(new int[] { 30, 20 }); |
1022 |
1 |
ranges.add(new int[] { -16, -44 }); |
1023 |
|
|
1024 |
1 |
assertFalse(MappingUtils.contains(ranges, 0)); |
1025 |
1 |
assertTrue(MappingUtils.contains(ranges, 1)); |
1026 |
1 |
assertTrue(MappingUtils.contains(ranges, 2)); |
1027 |
1 |
assertTrue(MappingUtils.contains(ranges, 3)); |
1028 |
1 |
assertTrue(MappingUtils.contains(ranges, 4)); |
1029 |
1 |
assertFalse(MappingUtils.contains(ranges, 5)); |
1030 |
|
|
1031 |
1 |
assertTrue(MappingUtils.contains(ranges, 6)); |
1032 |
1 |
assertFalse(MappingUtils.contains(ranges, 7)); |
1033 |
|
|
1034 |
1 |
assertTrue(MappingUtils.contains(ranges, 8)); |
1035 |
1 |
assertTrue(MappingUtils.contains(ranges, 9)); |
1036 |
1 |
assertTrue(MappingUtils.contains(ranges, 10)); |
1037 |
|
|
1038 |
1 |
assertFalse(MappingUtils.contains(ranges, 31)); |
1039 |
1 |
assertTrue(MappingUtils.contains(ranges, 30)); |
1040 |
1 |
assertTrue(MappingUtils.contains(ranges, 29)); |
1041 |
1 |
assertTrue(MappingUtils.contains(ranges, 20)); |
1042 |
1 |
assertFalse(MappingUtils.contains(ranges, 19)); |
1043 |
|
|
1044 |
1 |
assertFalse(MappingUtils.contains(ranges, -15)); |
1045 |
1 |
assertTrue(MappingUtils.contains(ranges, -16)); |
1046 |
1 |
assertTrue(MappingUtils.contains(ranges, -44)); |
1047 |
1 |
assertFalse(MappingUtils.contains(ranges, -45)); |
1048 |
|
} |
1049 |
|
|
1050 |
|
|
1051 |
|
|
1052 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (34) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1053 |
1 |
@Test(groups = "Functional")... |
1054 |
|
public void testRemoveStartPositions() |
1055 |
|
{ |
1056 |
1 |
int[] ranges = new int[] { 1, 10 }; |
1057 |
1 |
int[] adjusted = MappingUtils.removeStartPositions(0, ranges); |
1058 |
1 |
assertEquals("[1, 10]", Arrays.toString(adjusted)); |
1059 |
|
|
1060 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1061 |
1 |
assertEquals("[2, 10]", Arrays.toString(adjusted)); |
1062 |
1 |
assertEquals("[1, 10]", Arrays.toString(ranges)); |
1063 |
|
|
1064 |
1 |
ranges = adjusted; |
1065 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1066 |
1 |
assertEquals("[3, 10]", Arrays.toString(adjusted)); |
1067 |
1 |
assertEquals("[2, 10]", Arrays.toString(ranges)); |
1068 |
|
|
1069 |
1 |
ranges = new int[] { 2, 3, 10, 12 }; |
1070 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1071 |
1 |
assertEquals("[3, 3, 10, 12]", Arrays.toString(adjusted)); |
1072 |
1 |
assertEquals("[2, 3, 10, 12]", Arrays.toString(ranges)); |
1073 |
|
|
1074 |
1 |
ranges = new int[] { 2, 2, 8, 12 }; |
1075 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1076 |
1 |
assertEquals("[8, 12]", Arrays.toString(adjusted)); |
1077 |
1 |
assertEquals("[2, 2, 8, 12]", Arrays.toString(ranges)); |
1078 |
|
|
1079 |
1 |
ranges = new int[] { 2, 2, 8, 12 }; |
1080 |
1 |
adjusted = MappingUtils.removeStartPositions(2, ranges); |
1081 |
1 |
assertEquals("[9, 12]", Arrays.toString(adjusted)); |
1082 |
1 |
assertEquals("[2, 2, 8, 12]", Arrays.toString(ranges)); |
1083 |
|
|
1084 |
1 |
ranges = new int[] { 2, 2, 4, 4, 9, 12 }; |
1085 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1086 |
1 |
assertEquals("[4, 4, 9, 12]", Arrays.toString(adjusted)); |
1087 |
1 |
assertEquals("[2, 2, 4, 4, 9, 12]", Arrays.toString(ranges)); |
1088 |
|
|
1089 |
1 |
ranges = new int[] { 2, 2, 4, 4, 9, 12 }; |
1090 |
1 |
adjusted = MappingUtils.removeStartPositions(2, ranges); |
1091 |
1 |
assertEquals("[9, 12]", Arrays.toString(adjusted)); |
1092 |
1 |
assertEquals("[2, 2, 4, 4, 9, 12]", Arrays.toString(ranges)); |
1093 |
|
|
1094 |
1 |
ranges = new int[] { 2, 3, 9, 12 }; |
1095 |
1 |
adjusted = MappingUtils.removeStartPositions(3, ranges); |
1096 |
1 |
assertEquals("[10, 12]", Arrays.toString(adjusted)); |
1097 |
1 |
assertEquals("[2, 3, 9, 12]", Arrays.toString(ranges)); |
1098 |
|
} |
1099 |
|
|
1100 |
|
|
1101 |
|
|
1102 |
|
|
1103 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (36) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1104 |
1 |
@Test(groups = "Functional")... |
1105 |
|
public void testRemoveStartPositions_reverseStrand() |
1106 |
|
{ |
1107 |
1 |
int[] ranges = new int[] { 10, 1 }; |
1108 |
1 |
int[] adjusted = MappingUtils.removeStartPositions(0, ranges); |
1109 |
1 |
assertEquals("[10, 1]", Arrays.toString(adjusted)); |
1110 |
1 |
assertEquals("[10, 1]", Arrays.toString(ranges)); |
1111 |
|
|
1112 |
1 |
ranges = adjusted; |
1113 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1114 |
1 |
assertEquals("[9, 1]", Arrays.toString(adjusted)); |
1115 |
1 |
assertEquals("[10, 1]", Arrays.toString(ranges)); |
1116 |
|
|
1117 |
1 |
ranges = adjusted; |
1118 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1119 |
1 |
assertEquals("[8, 1]", Arrays.toString(adjusted)); |
1120 |
1 |
assertEquals("[9, 1]", Arrays.toString(ranges)); |
1121 |
|
|
1122 |
1 |
ranges = new int[] { 12, 11, 9, 6 }; |
1123 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1124 |
1 |
assertEquals("[11, 11, 9, 6]", Arrays.toString(adjusted)); |
1125 |
1 |
assertEquals("[12, 11, 9, 6]", Arrays.toString(ranges)); |
1126 |
|
|
1127 |
1 |
ranges = new int[] { 12, 12, 8, 4 }; |
1128 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1129 |
1 |
assertEquals("[8, 4]", Arrays.toString(adjusted)); |
1130 |
1 |
assertEquals("[12, 12, 8, 4]", Arrays.toString(ranges)); |
1131 |
|
|
1132 |
1 |
ranges = new int[] { 12, 12, 8, 4 }; |
1133 |
1 |
adjusted = MappingUtils.removeStartPositions(2, ranges); |
1134 |
1 |
assertEquals("[7, 4]", Arrays.toString(adjusted)); |
1135 |
1 |
assertEquals("[12, 12, 8, 4]", Arrays.toString(ranges)); |
1136 |
|
|
1137 |
1 |
ranges = new int[] { 12, 12, 10, 10, 8, 4 }; |
1138 |
1 |
adjusted = MappingUtils.removeStartPositions(1, ranges); |
1139 |
1 |
assertEquals("[10, 10, 8, 4]", Arrays.toString(adjusted)); |
1140 |
1 |
assertEquals("[12, 12, 10, 10, 8, 4]", Arrays.toString(ranges)); |
1141 |
|
|
1142 |
1 |
ranges = new int[] { 12, 12, 10, 10, 8, 4 }; |
1143 |
1 |
adjusted = MappingUtils.removeStartPositions(2, ranges); |
1144 |
1 |
assertEquals("[8, 4]", Arrays.toString(adjusted)); |
1145 |
1 |
assertEquals("[12, 12, 10, 10, 8, 4]", Arrays.toString(ranges)); |
1146 |
|
|
1147 |
1 |
ranges = new int[] { 12, 11, 8, 4 }; |
1148 |
1 |
adjusted = MappingUtils.removeStartPositions(3, ranges); |
1149 |
1 |
assertEquals("[7, 4]", Arrays.toString(adjusted)); |
1150 |
1 |
assertEquals("[12, 11, 8, 4]", Arrays.toString(ranges)); |
1151 |
|
} |
1152 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (33) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1153 |
1 |
@Test(groups = { "Functional" })... |
1154 |
|
public void testRangeContains() |
1155 |
|
{ |
1156 |
|
|
1157 |
|
|
1158 |
|
|
1159 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1160 |
|
1, 10 })); |
1161 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1162 |
|
2, 10 })); |
1163 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1164 |
|
1, 9 })); |
1165 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1166 |
|
4, 5 })); |
1167 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1168 |
|
0, 9 })); |
1169 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1170 |
|
-10, -9 })); |
1171 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1172 |
|
1, 11 })); |
1173 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1174 |
|
11, 12 })); |
1175 |
|
|
1176 |
|
|
1177 |
|
|
1178 |
|
|
1179 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1180 |
|
10, 1 })); |
1181 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1182 |
|
9, 1 })); |
1183 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1184 |
|
10, 2 })); |
1185 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1186 |
|
5, 5 })); |
1187 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1188 |
|
11, 1 })); |
1189 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, new int[] { |
1190 |
|
10, 0 })); |
1191 |
|
|
1192 |
|
|
1193 |
|
|
1194 |
|
|
1195 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1196 |
|
1, 10 })); |
1197 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1198 |
|
1, 9 })); |
1199 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1200 |
|
2, 10 })); |
1201 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1202 |
|
6, 6 })); |
1203 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1204 |
|
6, 11 })); |
1205 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1206 |
|
11, 20 })); |
1207 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1208 |
|
-3, -2 })); |
1209 |
|
|
1210 |
|
|
1211 |
|
|
1212 |
|
|
1213 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1214 |
|
10, 1 })); |
1215 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1216 |
|
9, 1 })); |
1217 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1218 |
|
10, 2 })); |
1219 |
1 |
assertTrue(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1220 |
|
3, 3 })); |
1221 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1222 |
|
11, 1 })); |
1223 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1224 |
|
10, 0 })); |
1225 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1226 |
|
12, 11 })); |
1227 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 10, 1 }, new int[] { |
1228 |
|
-5, -8 })); |
1229 |
|
|
1230 |
|
|
1231 |
|
|
1232 |
|
|
1233 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10, 12 }, |
1234 |
|
new int[] { |
1235 |
|
1, 10 })); |
1236 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, |
1237 |
|
new int[] { 1 })); |
1238 |
1 |
assertFalse(MappingUtils.rangeContains(new int[] { 1, 10 }, null)); |
1239 |
1 |
assertFalse(MappingUtils.rangeContains(null, new int[] { 1, 10 })); |
1240 |
|
} |
1241 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (25) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
1242 |
1 |
@Test(groups = "Functional")... |
1243 |
|
public void testRemoveEndPositions() |
1244 |
|
{ |
1245 |
1 |
List<int[]> ranges = new ArrayList<>(); |
1246 |
|
|
1247 |
|
|
1248 |
|
|
1249 |
|
|
1250 |
1 |
ranges.add(new int[] { 1, 10 }); |
1251 |
1 |
ranges.add(new int[] { 20, 30 }); |
1252 |
1 |
MappingUtils.removeEndPositions(5, ranges); |
1253 |
1 |
assertEquals(2, ranges.size()); |
1254 |
1 |
assertEquals(25, ranges.get(1)[1]); |
1255 |
|
|
1256 |
|
|
1257 |
|
|
1258 |
|
|
1259 |
1 |
ranges.clear(); |
1260 |
1 |
ranges.add(new int[] { 1, 10 }); |
1261 |
1 |
ranges.add(new int[] { 20, 22 }); |
1262 |
1 |
MappingUtils.removeEndPositions(3, ranges); |
1263 |
1 |
assertEquals(1, ranges.size()); |
1264 |
1 |
assertEquals(10, ranges.get(0)[1]); |
1265 |
|
|
1266 |
|
|
1267 |
|
|
1268 |
|
|
1269 |
1 |
ranges.clear(); |
1270 |
1 |
ranges.add(new int[] { 1, 10 }); |
1271 |
1 |
ranges.add(new int[] { 20, 21 }); |
1272 |
1 |
MappingUtils.removeEndPositions(3, ranges); |
1273 |
1 |
assertEquals(1, ranges.size()); |
1274 |
1 |
assertEquals(9, ranges.get(0)[1]); |
1275 |
|
|
1276 |
|
|
1277 |
|
|
1278 |
|
|
1279 |
1 |
ranges.clear(); |
1280 |
1 |
ranges.add(new int[] { 1, 10 }); |
1281 |
1 |
ranges.add(new int[] { 20, 20 }); |
1282 |
1 |
ranges.add(new int[] { 30, 30 }); |
1283 |
1 |
MappingUtils.removeEndPositions(3, ranges); |
1284 |
1 |
assertEquals(1, ranges.size()); |
1285 |
1 |
assertEquals(9, ranges.get(0)[1]); |
1286 |
|
} |
1287 |
|
} |