1 |
|
|
2 |
|
|
3 |
|
|
4 |
|
|
5 |
|
|
6 |
|
|
7 |
|
|
8 |
|
|
9 |
|
|
10 |
|
|
11 |
|
|
12 |
|
|
13 |
|
|
14 |
|
|
15 |
|
|
16 |
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
package jalview.datamodel; |
22 |
|
|
23 |
|
import static org.testng.Assert.assertNull; |
24 |
|
import static org.testng.AssertJUnit.assertEquals; |
25 |
|
import static org.testng.AssertJUnit.assertFalse; |
26 |
|
import static org.testng.AssertJUnit.assertTrue; |
27 |
|
|
28 |
|
import jalview.analysis.AlignmentGenerator; |
29 |
|
|
30 |
|
import java.util.Arrays; |
31 |
|
import java.util.BitSet; |
32 |
|
import java.util.Iterator; |
33 |
|
|
34 |
|
import org.testng.annotations.Test; |
35 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (787) |
Complexity: 29 |
Complexity Density: 0.04 |
|
36 |
|
public class HiddenColumnsTest |
37 |
|
{ |
38 |
|
|
39 |
|
|
40 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
41 |
1 |
@Test(groups = { "Functional" })... |
42 |
|
public void testGetSize() |
43 |
|
{ |
44 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
45 |
1 |
assertEquals(0, hidden.getSize()); |
46 |
|
|
47 |
1 |
hidden.hideColumns(3, 5); |
48 |
1 |
assertEquals(3, hidden.getSize()); |
49 |
|
|
50 |
1 |
hidden.hideColumns(8, 8); |
51 |
1 |
assertEquals(4, hidden.getSize()); |
52 |
|
|
53 |
1 |
hidden.hideColumns(9, 14); |
54 |
1 |
assertEquals(10, hidden.getSize()); |
55 |
|
|
56 |
1 |
ColumnSelection cs = new ColumnSelection(); |
57 |
1 |
hidden.revealAllHiddenColumns(cs); |
58 |
1 |
assertEquals(0, hidden.getSize()); |
59 |
|
} |
60 |
|
|
61 |
|
|
62 |
|
|
63 |
|
|
64 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (21) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
65 |
1 |
@Test(groups = { "Functional" })... |
66 |
|
public void testFindColumnPosition() |
67 |
|
{ |
68 |
1 |
HiddenColumns cs = new HiddenColumns(); |
69 |
1 |
assertEquals(5, cs.absoluteToVisibleColumn(5)); |
70 |
|
|
71 |
|
|
72 |
1 |
cs.hideColumns(6, 6); |
73 |
1 |
assertEquals(5, cs.absoluteToVisibleColumn(5)); |
74 |
|
|
75 |
|
|
76 |
1 |
cs.hideColumns(4, 4); |
77 |
1 |
assertEquals(4, cs.absoluteToVisibleColumn(5)); |
78 |
|
|
79 |
|
|
80 |
1 |
assertEquals(3, cs.absoluteToVisibleColumn(4)); |
81 |
|
|
82 |
|
|
83 |
1 |
cs.hideColumns(1, 2); |
84 |
1 |
assertEquals(2, cs.absoluteToVisibleColumn(5)); |
85 |
|
|
86 |
|
|
87 |
|
|
88 |
1 |
HiddenColumns cs2 = new HiddenColumns(); |
89 |
1 |
cs2.hideColumns(5, 10); |
90 |
1 |
cs2.hideColumns(20, 27); |
91 |
1 |
cs2.hideColumns(40, 44); |
92 |
|
|
93 |
|
|
94 |
1 |
assertEquals(4, cs2.absoluteToVisibleColumn(8)); |
95 |
|
|
96 |
|
|
97 |
1 |
assertEquals(13, cs2.absoluteToVisibleColumn(24)); |
98 |
|
|
99 |
|
|
100 |
1 |
assertEquals(14, cs2.absoluteToVisibleColumn(28)); |
101 |
|
|
102 |
|
|
103 |
1 |
assertEquals(25, cs2.absoluteToVisibleColumn(40)); |
104 |
|
|
105 |
|
|
106 |
|
|
107 |
1 |
HiddenColumns cs3 = new HiddenColumns(); |
108 |
1 |
cs3.hideColumns(0, 4); |
109 |
1 |
assertEquals(0, cs3.absoluteToVisibleColumn(2)); |
110 |
|
|
111 |
|
|
112 |
1 |
assertEquals(46, cs2.absoluteToVisibleColumn(65)); |
113 |
|
} |
114 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (38) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
115 |
1 |
@Test(groups = { "Functional" })... |
116 |
|
public void testVisibleContigsIterator() |
117 |
|
{ |
118 |
1 |
HiddenColumns cs = new HiddenColumns(); |
119 |
|
|
120 |
1 |
Iterator<int[]> visible = cs.getVisContigsIterator(3, 10, false); |
121 |
1 |
int[] region = visible.next(); |
122 |
1 |
assertEquals("[3, 9]", Arrays.toString(region)); |
123 |
1 |
assertFalse(visible.hasNext()); |
124 |
|
|
125 |
1 |
cs.hideColumns(3, 6); |
126 |
1 |
cs.hideColumns(8, 9); |
127 |
1 |
cs.hideColumns(12, 12); |
128 |
|
|
129 |
|
|
130 |
|
|
131 |
|
|
132 |
1 |
visible = cs.getVisContigsIterator(1, 13, false); |
133 |
1 |
region = visible.next(); |
134 |
1 |
assertEquals("[1, 2]", Arrays.toString(region)); |
135 |
1 |
region = visible.next(); |
136 |
1 |
assertEquals("[7, 7]", Arrays.toString(region)); |
137 |
1 |
region = visible.next(); |
138 |
1 |
assertEquals("[10, 11]", Arrays.toString(region)); |
139 |
1 |
assertFalse(visible.hasNext()); |
140 |
|
|
141 |
|
|
142 |
1 |
visible = cs.getVisContigsIterator(4, 14, false); |
143 |
1 |
region = visible.next(); |
144 |
1 |
assertEquals("[7, 7]", Arrays.toString(region)); |
145 |
1 |
region = visible.next(); |
146 |
1 |
assertEquals("[10, 11]", Arrays.toString(region)); |
147 |
1 |
region = visible.next(); |
148 |
1 |
assertEquals("[13, 13]", Arrays.toString(region)); |
149 |
1 |
assertFalse(visible.hasNext()); |
150 |
|
|
151 |
|
|
152 |
1 |
visible = cs.getVisContigsIterator(3, 10, false); |
153 |
1 |
region = visible.next(); |
154 |
1 |
assertEquals("[7, 7]", Arrays.toString(region)); |
155 |
1 |
assertFalse(visible.hasNext()); |
156 |
|
|
157 |
|
|
158 |
1 |
visible = cs.getVisContigsIterator(0, 13, false); |
159 |
1 |
region = visible.next(); |
160 |
1 |
assertEquals("[0, 2]", Arrays.toString(region)); |
161 |
1 |
region = visible.next(); |
162 |
1 |
assertEquals("[7, 7]", Arrays.toString(region)); |
163 |
1 |
region = visible.next(); |
164 |
1 |
assertEquals("[10, 11]", Arrays.toString(region)); |
165 |
1 |
assertFalse(visible.hasNext()); |
166 |
|
|
167 |
|
|
168 |
1 |
visible = cs.getVisContigsIterator(4, 6, false); |
169 |
1 |
assertFalse(visible.hasNext()); |
170 |
|
} |
171 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (20) |
Complexity: 1 |
Complexity Density: 0.05 |
1PASS
|
|
172 |
1 |
@Test(groups = { "Functional" })... |
173 |
|
public void testEquals() |
174 |
|
{ |
175 |
1 |
HiddenColumns cs = new HiddenColumns(); |
176 |
1 |
cs.hideColumns(5, 9); |
177 |
|
|
178 |
|
|
179 |
1 |
HiddenColumns cs2 = new HiddenColumns(); |
180 |
|
|
181 |
|
|
182 |
1 |
assertFalse(cs.equals(cs2)); |
183 |
1 |
assertFalse(cs2.equals(cs)); |
184 |
|
|
185 |
|
|
186 |
1 |
assertFalse(cs.equals(new HiddenColumnsCursor())); |
187 |
|
|
188 |
|
|
189 |
1 |
HiddenColumns cs3 = new HiddenColumns(); |
190 |
1 |
cs3.hideColumns(2, 3); |
191 |
1 |
assertFalse(cs.equals(cs3)); |
192 |
|
|
193 |
|
|
194 |
1 |
cs2.hideColumns(6, 9); |
195 |
1 |
assertFalse(cs.equals(cs2)); |
196 |
1 |
assertFalse(cs2.equals(cs)); |
197 |
|
|
198 |
1 |
cs2.hideColumns(5, 8); |
199 |
|
|
200 |
1 |
assertTrue(cs.equals(cs2)); |
201 |
1 |
assertTrue(cs.equals(cs)); |
202 |
1 |
assertTrue(cs2.equals(cs)); |
203 |
1 |
assertTrue(cs2.equals(cs2)); |
204 |
|
|
205 |
|
|
206 |
1 |
cs.hideColumns(10, 12); |
207 |
1 |
cs2.hideColumns(10, 15); |
208 |
1 |
assertFalse(cs.equals(cs2)); |
209 |
|
|
210 |
|
} |
211 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
212 |
1 |
@Test(groups = "Functional")... |
213 |
|
public void testCopyConstructor() |
214 |
|
{ |
215 |
1 |
HiddenColumns cs = new HiddenColumns(); |
216 |
1 |
cs.hideColumns(10, 11); |
217 |
1 |
cs.hideColumns(5, 7); |
218 |
1 |
Iterator<int[]> regions = cs.iterator(); |
219 |
1 |
assertEquals("[5, 7]", |
220 |
|
Arrays.toString(regions.next())); |
221 |
|
|
222 |
1 |
HiddenColumns cs2 = new HiddenColumns(cs); |
223 |
1 |
regions = cs2.iterator(); |
224 |
1 |
assertTrue(cs2.hasHiddenColumns()); |
225 |
1 |
assertEquals(2, cs2.getNumberOfRegions()); |
226 |
|
|
227 |
1 |
assertEquals("[5, 7]", |
228 |
|
Arrays.toString(regions.next())); |
229 |
1 |
assertEquals("[10, 11]", |
230 |
|
Arrays.toString(regions.next())); |
231 |
|
} |
232 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (15) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
233 |
1 |
@Test(groups = "Functional")... |
234 |
|
public void testCopyConstructor2() |
235 |
|
{ |
236 |
1 |
HiddenColumns cs = new HiddenColumns(); |
237 |
1 |
cs.hideColumns(10, 11); |
238 |
1 |
cs.hideColumns(5, 7); |
239 |
|
|
240 |
1 |
HiddenColumns cs2 = new HiddenColumns(cs, 3, 9, 1); |
241 |
1 |
assertTrue(cs2.hasHiddenColumns()); |
242 |
1 |
Iterator<int[]> regions = cs2.iterator(); |
243 |
|
|
244 |
|
|
245 |
1 |
assertEquals("[4, 6]", |
246 |
|
Arrays.toString(regions.next())); |
247 |
1 |
assertEquals(3, cs2.getSize()); |
248 |
|
|
249 |
1 |
cs2 = new HiddenColumns(cs, 8, 15, 4); |
250 |
1 |
regions = cs2.iterator(); |
251 |
1 |
assertTrue(cs2.hasHiddenColumns()); |
252 |
|
|
253 |
|
|
254 |
1 |
assertEquals("[6, 7]", |
255 |
|
Arrays.toString(regions.next())); |
256 |
1 |
assertEquals(2, cs2.getSize()); |
257 |
|
|
258 |
1 |
cs2 = new HiddenColumns(cs, 6, 10, 4); |
259 |
1 |
assertFalse(cs2.hasHiddenColumns()); |
260 |
|
} |
261 |
|
|
262 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (79) |
Complexity: 1 |
Complexity Density: 0.01 |
1PASS
|
|
263 |
1 |
@Test(groups = { "Functional" })... |
264 |
|
public void testHideColumns() |
265 |
|
{ |
266 |
|
|
267 |
1 |
AlignmentGenerator gen = new AlignmentGenerator(false); |
268 |
1 |
AlignmentI al = gen.generate(50, 20, 123, 5, 5); |
269 |
|
|
270 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
271 |
1 |
HiddenColumns cs = al.getHiddenColumns(); |
272 |
1 |
colsel.hideSelectedColumns(5, al.getHiddenColumns()); |
273 |
1 |
Iterator<int[]> regions = cs.iterator(); |
274 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
275 |
1 |
assertEquals("[5, 5]", Arrays.toString(regions.next())); |
276 |
1 |
assertEquals(cs.getSize(), 1); |
277 |
|
|
278 |
1 |
colsel.hideSelectedColumns(3, al.getHiddenColumns()); |
279 |
1 |
regions = cs.iterator(); |
280 |
1 |
assertEquals(2, cs.getNumberOfRegions()); |
281 |
|
|
282 |
1 |
assertEquals("[3, 3]", Arrays.toString(regions.next())); |
283 |
1 |
assertEquals("[5, 5]", Arrays.toString(regions.next())); |
284 |
1 |
assertEquals(cs.getSize(), 2); |
285 |
|
|
286 |
|
|
287 |
|
|
288 |
1 |
colsel.hideSelectedColumns(4, al.getHiddenColumns()); |
289 |
1 |
regions = cs.iterator(); |
290 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
291 |
1 |
assertEquals("[3, 5]", Arrays.toString(regions.next())); |
292 |
1 |
assertEquals(cs.getSize(), 3); |
293 |
|
|
294 |
|
|
295 |
1 |
cs.revealAllHiddenColumns(colsel); |
296 |
|
|
297 |
1 |
assertEquals(0, cs.getNumberOfRegions()); |
298 |
1 |
assertEquals(cs.getSize(), 0); |
299 |
|
|
300 |
1 |
cs.hideColumns(3, 6); |
301 |
1 |
regions = cs.iterator(); |
302 |
1 |
int[] firstHiddenRange = regions.next(); |
303 |
1 |
assertEquals("[3, 6]", Arrays.toString(firstHiddenRange)); |
304 |
1 |
assertEquals(cs.getSize(), 4); |
305 |
|
|
306 |
|
|
307 |
1 |
cs.hideColumns(4, 5); |
308 |
1 |
regions = cs.iterator(); |
309 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
310 |
1 |
assertEquals("[3, 6]", |
311 |
|
Arrays.toString(regions.next())); |
312 |
1 |
assertEquals(cs.getSize(), 4); |
313 |
1 |
cs.hideColumns(3, 5); |
314 |
1 |
regions = cs.iterator(); |
315 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
316 |
1 |
assertEquals("[3, 6]", |
317 |
|
Arrays.toString(regions.next())); |
318 |
1 |
assertEquals(cs.getSize(), 4); |
319 |
1 |
cs.hideColumns(4, 6); |
320 |
1 |
regions = cs.iterator(); |
321 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
322 |
1 |
assertEquals("[3, 6]", |
323 |
|
Arrays.toString(regions.next())); |
324 |
1 |
assertEquals(cs.getSize(), 4); |
325 |
1 |
cs.hideColumns(3, 6); |
326 |
1 |
regions = cs.iterator(); |
327 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
328 |
1 |
assertEquals("[3, 6]", |
329 |
|
Arrays.toString(regions.next())); |
330 |
1 |
assertEquals(cs.getSize(), 4); |
331 |
|
|
332 |
1 |
cs.revealAllHiddenColumns(colsel); |
333 |
1 |
cs.hideColumns(2, 4); |
334 |
1 |
regions = cs.iterator(); |
335 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
336 |
1 |
assertEquals("[2, 4]", Arrays.toString(regions.next())); |
337 |
1 |
assertEquals(cs.getSize(), 3); |
338 |
|
|
339 |
|
|
340 |
1 |
cs.hideColumns(3, 5); |
341 |
1 |
regions = cs.iterator(); |
342 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
343 |
1 |
assertEquals("[2, 5]", Arrays.toString(regions.next())); |
344 |
1 |
assertEquals(cs.getSize(), 4); |
345 |
|
|
346 |
|
|
347 |
1 |
cs.hideColumns(5, 6); |
348 |
1 |
regions = cs.iterator(); |
349 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
350 |
1 |
assertEquals("[2, 6]", Arrays.toString(regions.next())); |
351 |
1 |
assertEquals(cs.getSize(), 5); |
352 |
|
|
353 |
|
|
354 |
1 |
cs.hideColumns(1, 7); |
355 |
1 |
regions = cs.iterator(); |
356 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
357 |
1 |
assertEquals("[1, 7]", Arrays.toString(regions.next())); |
358 |
1 |
assertEquals(cs.getSize(), 7); |
359 |
|
|
360 |
1 |
cs.revealAllHiddenColumns(colsel); |
361 |
1 |
cs.hideColumns(15, 18); |
362 |
1 |
cs.hideColumns(2, 4); |
363 |
1 |
cs.hideColumns(7, 9); |
364 |
1 |
regions = cs.iterator(); |
365 |
1 |
assertEquals(3, cs.getNumberOfRegions()); |
366 |
1 |
assertEquals("[2, 4]", Arrays.toString(regions.next())); |
367 |
1 |
assertEquals("[7, 9]", Arrays.toString(regions.next())); |
368 |
1 |
assertEquals("[15, 18]", Arrays.toString(regions.next())); |
369 |
1 |
assertEquals(cs.getSize(), 10); |
370 |
|
} |
371 |
|
|
372 |
|
|
373 |
|
|
374 |
|
|
375 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (25) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
376 |
1 |
@Test(groups = { "Functional" })... |
377 |
|
public void testRevealHiddenColumns() |
378 |
|
{ |
379 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
380 |
1 |
HiddenColumns cs = new HiddenColumns(); |
381 |
|
|
382 |
|
|
383 |
1 |
cs.revealHiddenColumns(5, colsel); |
384 |
1 |
assertTrue(colsel.getSelected().isEmpty()); |
385 |
|
|
386 |
1 |
cs.hideColumns(5, 8); |
387 |
1 |
colsel.addElement(10); |
388 |
1 |
cs.revealHiddenColumns(5, colsel); |
389 |
|
|
390 |
|
|
391 |
1 |
assertEquals(0, cs.getSize()); |
392 |
|
|
393 |
|
|
394 |
1 |
assertEquals("[10, 5, 6, 7, 8]", colsel.getSelected().toString()); |
395 |
|
|
396 |
|
|
397 |
1 |
colsel = new ColumnSelection(); |
398 |
1 |
cs = new HiddenColumns(); |
399 |
1 |
cs.hideColumns(5, 8); |
400 |
|
|
401 |
1 |
int prevSize = cs.getSize(); |
402 |
1 |
cs.revealHiddenColumns(6, colsel); |
403 |
1 |
assertEquals(prevSize, cs.getSize()); |
404 |
1 |
assertTrue(colsel.getSelected().isEmpty()); |
405 |
|
|
406 |
|
|
407 |
1 |
cs.hideColumns(20, 23); |
408 |
|
|
409 |
1 |
assertEquals(2, cs.getNumberOfRegions()); |
410 |
|
|
411 |
1 |
cs.revealHiddenColumns(20, colsel); |
412 |
|
|
413 |
|
|
414 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
415 |
|
|
416 |
|
|
417 |
1 |
assertEquals("[20, 21, 22, 23]", colsel.getSelected().toString()); |
418 |
|
|
419 |
|
|
420 |
1 |
colsel.clear(); |
421 |
1 |
cs.revealHiddenColumns(20, colsel); |
422 |
|
|
423 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
424 |
1 |
assertTrue(colsel.getSelected().isEmpty()); |
425 |
|
} |
426 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (11) |
Complexity: 1 |
Complexity Density: 0.09 |
1PASS
|
|
427 |
1 |
@Test(groups = { "Functional" })... |
428 |
|
public void testRevealAllHiddenColumns() |
429 |
|
{ |
430 |
1 |
HiddenColumns hidden = new HiddenColumns(); |
431 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
432 |
|
|
433 |
|
|
434 |
1 |
hidden.revealAllHiddenColumns(colsel); |
435 |
1 |
assertTrue(colsel.getSelected().isEmpty()); |
436 |
|
|
437 |
1 |
hidden.hideColumns(5, 8); |
438 |
1 |
hidden.hideColumns(2, 3); |
439 |
1 |
colsel.addElement(11); |
440 |
1 |
colsel.addElement(1); |
441 |
1 |
hidden.revealAllHiddenColumns(colsel); |
442 |
|
|
443 |
|
|
444 |
|
|
445 |
|
|
446 |
|
|
447 |
|
|
448 |
|
|
449 |
1 |
assertEquals(0, hidden.getSize()); |
450 |
|
|
451 |
1 |
assertEquals("[11, 1, 2, 3, 5, 6, 7, 8]", |
452 |
|
colsel.getSelected().toString()); |
453 |
|
} |
454 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
455 |
1 |
@Test(groups = { "Functional" })... |
456 |
|
public void testIsVisible() |
457 |
|
{ |
458 |
1 |
HiddenColumns cs = new HiddenColumns(); |
459 |
1 |
assertTrue(cs.isVisible(5)); |
460 |
|
|
461 |
1 |
cs.hideColumns(2, 4); |
462 |
1 |
cs.hideColumns(6, 7); |
463 |
1 |
assertTrue(cs.isVisible(0)); |
464 |
1 |
assertTrue(cs.isVisible(-99)); |
465 |
1 |
assertTrue(cs.isVisible(1)); |
466 |
1 |
assertFalse(cs.isVisible(2)); |
467 |
1 |
assertFalse(cs.isVisible(3)); |
468 |
1 |
assertFalse(cs.isVisible(4)); |
469 |
1 |
assertTrue(cs.isVisible(5)); |
470 |
1 |
assertFalse(cs.isVisible(6)); |
471 |
1 |
assertFalse(cs.isVisible(7)); |
472 |
1 |
assertTrue(cs.isVisible(8)); |
473 |
|
} |
474 |
|
|
475 |
|
|
476 |
|
|
477 |
|
|
478 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (34) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
479 |
1 |
@Test(groups = { "Functional" })... |
480 |
|
public void testHideColumns_subsumingHidden() |
481 |
|
{ |
482 |
|
|
483 |
|
|
484 |
|
|
485 |
|
|
486 |
1 |
HiddenColumns cs = new HiddenColumns(); |
487 |
1 |
cs.hideColumns(49, 59); |
488 |
1 |
cs.hideColumns(69, 79); |
489 |
1 |
Iterator<int[]> regions = cs.iterator(); |
490 |
1 |
assertEquals(2, cs.getNumberOfRegions()); |
491 |
1 |
assertEquals("[49, 59]", Arrays.toString(regions.next())); |
492 |
1 |
assertEquals("[69, 79]", Arrays.toString(regions.next())); |
493 |
1 |
assertEquals(22, cs.getSize()); |
494 |
|
|
495 |
1 |
cs.hideColumns(48, 80); |
496 |
1 |
regions = cs.iterator(); |
497 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
498 |
1 |
assertEquals("[48, 80]", Arrays.toString(regions.next())); |
499 |
1 |
assertEquals(33, cs.getSize()); |
500 |
|
|
501 |
|
|
502 |
|
|
503 |
|
|
504 |
1 |
cs = new HiddenColumns(); |
505 |
1 |
cs.hideColumns(10, 20); |
506 |
1 |
cs.hideColumns(30, 40); |
507 |
1 |
cs.hideColumns(50, 60); |
508 |
|
|
509 |
1 |
cs.hideColumns(21, 49); |
510 |
1 |
regions = cs.iterator(); |
511 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
512 |
1 |
assertEquals("[10, 60]", Arrays.toString(regions.next())); |
513 |
1 |
assertEquals(51, cs.getSize()); |
514 |
|
|
515 |
|
|
516 |
|
|
517 |
|
|
518 |
|
|
519 |
1 |
cs = new HiddenColumns(); |
520 |
1 |
cs.hideColumns(10, 20); |
521 |
1 |
cs.hideColumns(10, 20); |
522 |
1 |
cs.hideColumns(30, 35); |
523 |
1 |
cs.hideColumns(40, 50); |
524 |
1 |
cs.hideColumns(60, 70); |
525 |
|
|
526 |
1 |
cs.hideColumns(15, 45); |
527 |
1 |
regions = cs.iterator(); |
528 |
1 |
assertEquals(2, cs.getNumberOfRegions()); |
529 |
1 |
assertEquals("[10, 50]", Arrays.toString(regions.next())); |
530 |
1 |
assertEquals("[60, 70]", Arrays.toString(regions.next())); |
531 |
1 |
assertEquals(52, cs.getSize()); |
532 |
|
} |
533 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (34) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
534 |
1 |
@Test(groups = { "Functional" })... |
535 |
|
public void testHideColumns_BitSet() |
536 |
|
{ |
537 |
1 |
HiddenColumns cs; |
538 |
|
|
539 |
1 |
BitSet one = new BitSet(); |
540 |
|
|
541 |
|
|
542 |
1 |
one.set(1); |
543 |
1 |
cs = new HiddenColumns(); |
544 |
1 |
cs.hideColumns(one); |
545 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
546 |
1 |
assertEquals(1, cs.getSize()); |
547 |
|
|
548 |
1 |
one.set(2); |
549 |
1 |
cs = new HiddenColumns(); |
550 |
1 |
cs.hideColumns(one); |
551 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
552 |
1 |
assertEquals(2, cs.getSize()); |
553 |
|
|
554 |
1 |
one.set(3); |
555 |
1 |
cs = new HiddenColumns(); |
556 |
1 |
cs.hideColumns(one); |
557 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
558 |
1 |
assertEquals(3, cs.getSize()); |
559 |
|
|
560 |
|
|
561 |
1 |
one.clear(2); |
562 |
1 |
cs = new HiddenColumns(); |
563 |
1 |
cs.hideColumns(one); |
564 |
1 |
assertEquals(2, cs.getNumberOfRegions()); |
565 |
1 |
assertEquals(2, cs.getSize()); |
566 |
|
|
567 |
1 |
assertEquals(0, cs.visibleToAbsoluteColumn(0)); |
568 |
1 |
assertEquals(2, cs.visibleToAbsoluteColumn(1)); |
569 |
1 |
assertEquals(4, cs.visibleToAbsoluteColumn(2)); |
570 |
|
|
571 |
|
|
572 |
1 |
one.clear(1); |
573 |
1 |
cs = new HiddenColumns(); |
574 |
1 |
cs.hideColumns(one); |
575 |
1 |
assertEquals(1, cs.getSize()); |
576 |
|
|
577 |
1 |
assertEquals(1, cs.getNumberOfRegions()); |
578 |
|
|
579 |
1 |
assertEquals(0, cs.visibleToAbsoluteColumn(0)); |
580 |
1 |
assertEquals(1, cs.visibleToAbsoluteColumn(1)); |
581 |
1 |
assertEquals(2, cs.visibleToAbsoluteColumn(2)); |
582 |
1 |
assertEquals(4, cs.visibleToAbsoluteColumn(3)); |
583 |
|
} |
584 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
585 |
1 |
@Test(groups = { "Functional" })... |
586 |
|
public void testRegionsToString() |
587 |
|
{ |
588 |
1 |
HiddenColumns hc = new HiddenColumns(); |
589 |
|
|
590 |
1 |
String result = hc.regionsToString(",", "--"); |
591 |
1 |
assertEquals("", result); |
592 |
|
|
593 |
1 |
hc.hideColumns(3, 7); |
594 |
1 |
hc.hideColumns(10, 10); |
595 |
1 |
hc.hideColumns(14, 15); |
596 |
|
|
597 |
1 |
result = hc.regionsToString(",", "--"); |
598 |
1 |
assertEquals("3--7,10--10,14--15", result); |
599 |
|
} |
600 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (25) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
601 |
1 |
@Test(groups = "Functional")... |
602 |
|
public void testGetVisibleStartAndEndIndex() |
603 |
|
{ |
604 |
1 |
Sequence seq = new Sequence("testSeq", "ABCDEFGHIJKLMNOPQRSTUVWXYZ"); |
605 |
1 |
AlignmentI align = new Alignment(new SequenceI[] { seq }); |
606 |
1 |
HiddenColumns hc = new HiddenColumns(); |
607 |
|
|
608 |
1 |
int[] startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); |
609 |
1 |
assertEquals(0, startEnd[0]); |
610 |
1 |
assertEquals(25, startEnd[1]); |
611 |
|
|
612 |
1 |
hc.hideColumns(0, 0); |
613 |
1 |
startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); |
614 |
1 |
assertEquals(1, startEnd[0]); |
615 |
1 |
assertEquals(25, startEnd[1]); |
616 |
|
|
617 |
1 |
hc.hideColumns(6, 9); |
618 |
1 |
hc.hideColumns(11, 12); |
619 |
1 |
startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); |
620 |
1 |
assertEquals(1, startEnd[0]); |
621 |
1 |
assertEquals(25, startEnd[1]); |
622 |
|
|
623 |
1 |
hc.hideColumns(24, 25); |
624 |
1 |
startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); |
625 |
1 |
System.out.println(startEnd[0] + " : " + startEnd[1]); |
626 |
1 |
assertEquals(1, startEnd[0]); |
627 |
1 |
assertEquals(23, startEnd[1]); |
628 |
|
|
629 |
|
|
630 |
1 |
hc = new HiddenColumns(); |
631 |
1 |
hc.hideColumns(3, 4); |
632 |
1 |
startEnd = hc.getVisibleStartAndEndIndex(align.getWidth()); |
633 |
1 |
assertEquals(0, startEnd[0]); |
634 |
1 |
assertEquals(25, startEnd[1]); |
635 |
|
} |
636 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (27) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
637 |
1 |
@Test(groups = "Functional")... |
638 |
|
public void testGetRegionWithEdgeAtRes() |
639 |
|
{ |
640 |
1 |
HiddenColumns hc = new HiddenColumns(); |
641 |
|
|
642 |
1 |
int[] result = hc.getRegionWithEdgeAtRes(5); |
643 |
1 |
assertNull(result); |
644 |
|
|
645 |
1 |
hc.hideColumns(3, 7); |
646 |
1 |
hc.hideColumns(10, 10); |
647 |
1 |
hc.hideColumns(14, 15); |
648 |
|
|
649 |
1 |
result = hc.getRegionWithEdgeAtRes(2); |
650 |
1 |
assertEquals(3, result[0]); |
651 |
1 |
assertEquals(7, result[1]); |
652 |
|
|
653 |
1 |
result = hc.getRegionWithEdgeAtRes(4); |
654 |
1 |
assertEquals(10, result[0]); |
655 |
1 |
assertEquals(10, result[1]); |
656 |
|
|
657 |
1 |
result = hc.getRegionWithEdgeAtRes(5); |
658 |
1 |
assertEquals(10, result[0]); |
659 |
1 |
assertEquals(10, result[1]); |
660 |
|
|
661 |
1 |
result = hc.getRegionWithEdgeAtRes(6); |
662 |
1 |
assertNull(result); |
663 |
|
|
664 |
1 |
result = hc.getRegionWithEdgeAtRes(0); |
665 |
1 |
assertNull(result); |
666 |
|
|
667 |
1 |
result = hc.getRegionWithEdgeAtRes(7); |
668 |
1 |
assertEquals(14, result[0]); |
669 |
1 |
assertEquals(15, result[1]); |
670 |
|
|
671 |
1 |
result = hc.getRegionWithEdgeAtRes(8); |
672 |
1 |
assertEquals(14, result[0]); |
673 |
1 |
assertEquals(15, result[1]); |
674 |
|
|
675 |
1 |
result = hc.getRegionWithEdgeAtRes(16); |
676 |
1 |
assertNull(result); |
677 |
|
} |
678 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
679 |
1 |
@Test(groups = "Functional")... |
680 |
|
public void testHasHiddenColumns() |
681 |
|
{ |
682 |
1 |
HiddenColumns h = new HiddenColumns(); |
683 |
|
|
684 |
|
|
685 |
1 |
assertFalse(h.hasHiddenColumns()); |
686 |
|
|
687 |
|
|
688 |
1 |
h.hideColumns(5, 10); |
689 |
1 |
assertTrue(h.hasHiddenColumns()); |
690 |
|
|
691 |
|
|
692 |
1 |
ColumnSelection sel = new ColumnSelection(); |
693 |
1 |
h.revealAllHiddenColumns(sel); |
694 |
1 |
assertFalse(h.hasHiddenColumns()); |
695 |
|
} |
696 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (8) |
Complexity: 1 |
Complexity Density: 0.12 |
1PASS
|
|
697 |
1 |
@Test(groups = "Functional")... |
698 |
|
public void testHasManyHiddenColumns() |
699 |
|
{ |
700 |
1 |
HiddenColumns h = new HiddenColumns(); |
701 |
|
|
702 |
|
|
703 |
1 |
assertFalse(h.hasMultiHiddenColumnRegions()); |
704 |
|
|
705 |
|
|
706 |
1 |
h.hideColumns(5, 10); |
707 |
1 |
assertFalse(h.hasMultiHiddenColumnRegions()); |
708 |
|
|
709 |
|
|
710 |
1 |
h.hideColumns(15, 17); |
711 |
1 |
assertTrue(h.hasMultiHiddenColumnRegions()); |
712 |
|
|
713 |
|
|
714 |
1 |
h.hideColumns(11, 14); |
715 |
1 |
assertFalse(h.hasMultiHiddenColumnRegions()); |
716 |
|
} |
717 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (14) |
Complexity: 1 |
Complexity Density: 0.07 |
1PASS
|
|
718 |
1 |
@Test(groups = "Functional")... |
719 |
|
public void testAdjustForHiddenColumns() |
720 |
|
{ |
721 |
1 |
HiddenColumns h = new HiddenColumns(); |
722 |
|
|
723 |
1 |
assertEquals(10, h.visibleToAbsoluteColumn(10)); |
724 |
|
|
725 |
1 |
h.hideColumns(20, 30); |
726 |
1 |
assertEquals(10, h.visibleToAbsoluteColumn(10)); |
727 |
1 |
assertEquals(20 + 11, h.visibleToAbsoluteColumn(20)); |
728 |
1 |
assertEquals(35 + 11, h.visibleToAbsoluteColumn(35)); |
729 |
|
|
730 |
1 |
h.hideColumns(5, 7); |
731 |
1 |
assertEquals(10 + 3, h.visibleToAbsoluteColumn(10)); |
732 |
1 |
assertEquals(20 + 14, h.visibleToAbsoluteColumn(20)); |
733 |
1 |
assertEquals(35 + 14, h.visibleToAbsoluteColumn(35)); |
734 |
|
|
735 |
1 |
ColumnSelection sel = new ColumnSelection(); |
736 |
1 |
h.revealAllHiddenColumns(sel); |
737 |
1 |
h.hideColumns(0, 1); |
738 |
1 |
assertEquals(4, h.visibleToAbsoluteColumn(2)); |
739 |
|
} |
740 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (9) |
Complexity: 1 |
Complexity Density: 0.11 |
1PASS
|
|
741 |
1 |
@Test(groups = "Functional")... |
742 |
|
public void testGetNextHiddenBoundary_Left() |
743 |
|
{ |
744 |
1 |
HiddenColumns h = new HiddenColumns(); |
745 |
|
|
746 |
|
|
747 |
1 |
assertEquals(3, h.getNextHiddenBoundary(true, 3)); |
748 |
|
|
749 |
1 |
h.hideColumns(5, 10); |
750 |
1 |
assertEquals(10, h.getNextHiddenBoundary(true, 15)); |
751 |
1 |
assertEquals(3, h.getNextHiddenBoundary(true, 3)); |
752 |
1 |
assertEquals(7, h.getNextHiddenBoundary(true, 7)); |
753 |
|
|
754 |
1 |
h.hideColumns(15, 20); |
755 |
1 |
assertEquals(10, h.getNextHiddenBoundary(true, 15)); |
756 |
1 |
assertEquals(20, h.getNextHiddenBoundary(true, 21)); |
757 |
|
} |
758 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (10) |
Complexity: 1 |
Complexity Density: 0.1 |
1PASS
|
|
759 |
1 |
@Test(groups = "Functional")... |
760 |
|
public void testGetNextHiddenBoundary_Right() |
761 |
|
{ |
762 |
1 |
HiddenColumns h = new HiddenColumns(); |
763 |
|
|
764 |
|
|
765 |
1 |
assertEquals(3, h.getNextHiddenBoundary(false, 3)); |
766 |
|
|
767 |
1 |
h.hideColumns(5, 10); |
768 |
1 |
assertEquals(5, h.getNextHiddenBoundary(false, 3)); |
769 |
1 |
assertEquals(15, h.getNextHiddenBoundary(false, 15)); |
770 |
1 |
assertEquals(7, h.getNextHiddenBoundary(false, 7)); |
771 |
|
|
772 |
1 |
h.hideColumns(15, 20); |
773 |
1 |
assertEquals(15, h.getNextHiddenBoundary(false, 7)); |
774 |
1 |
assertEquals(15, h.getNextHiddenBoundary(false, 14)); |
775 |
|
|
776 |
|
|
777 |
1 |
assertEquals(22, h.getNextHiddenBoundary(false, 22)); |
778 |
|
} |
779 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (26) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
780 |
1 |
@Test(groups = "Functional")... |
781 |
|
public void testIterator() |
782 |
|
{ |
783 |
1 |
HiddenColumns h = new HiddenColumns(); |
784 |
1 |
Iterator<int[]> result = h.iterator(); |
785 |
1 |
assertFalse(result.hasNext()); |
786 |
|
|
787 |
1 |
h.hideColumns(5, 10); |
788 |
1 |
result = h.iterator(); |
789 |
1 |
int[] next = result.next(); |
790 |
1 |
assertEquals(5, next[0]); |
791 |
1 |
assertEquals(10, next[1]); |
792 |
1 |
assertFalse(result.hasNext()); |
793 |
|
|
794 |
1 |
h.hideColumns(22, 23); |
795 |
1 |
result = h.iterator(); |
796 |
1 |
next = result.next(); |
797 |
1 |
assertEquals(5, next[0]); |
798 |
1 |
assertEquals(10, next[1]); |
799 |
1 |
next = result.next(); |
800 |
1 |
assertEquals(22, next[0]); |
801 |
1 |
assertEquals(23, next[1]); |
802 |
1 |
assertFalse(result.hasNext()); |
803 |
|
|
804 |
|
|
805 |
1 |
ColumnSelection sel = new ColumnSelection(); |
806 |
1 |
h.revealAllHiddenColumns(sel); |
807 |
1 |
h.hideColumns(0, 1); |
808 |
1 |
result = h.iterator(); |
809 |
1 |
next = result.next(); |
810 |
1 |
assertEquals(0, next[0]); |
811 |
1 |
assertEquals(1, next[1]); |
812 |
1 |
assertFalse(result.hasNext()); |
813 |
|
} |
814 |
|
|
815 |
|
|
816 |
|
|
817 |
|
|
818 |
|
|
819 |
|
|
820 |
|
|
821 |
|
|
822 |
|
|
823 |
|
|
824 |
|
|
825 |
|
|
826 |
|
|
827 |
|
|
828 |
|
|
829 |
|
|
830 |
|
|
831 |
|
|
832 |
|
|
833 |
|
|
834 |
|
|
835 |
|
|
836 |
|
|
837 |
|
|
838 |
|
|
839 |
|
|
840 |
|
|
841 |
|
|
842 |
|
|
843 |
|
|
844 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (13) |
Complexity: 1 |
Complexity Density: 0.08 |
1PASS
|
|
845 |
1 |
@Test(groups = "Functional")... |
846 |
|
public void testHideInsertionsFor() |
847 |
|
{ |
848 |
1 |
HiddenColumns h = new HiddenColumns(); |
849 |
1 |
HiddenColumns h2 = new HiddenColumns(); |
850 |
1 |
SequenceI seq1 = new Sequence("TEST1", "GAL---MFW-KQESPVICY--HRNDT"); |
851 |
1 |
SequenceI seq2 = new Sequence("TEST1", "GALMFWKQESPVICYHRNDT"); |
852 |
|
|
853 |
1 |
h.hideList(seq2.getInsertions()); |
854 |
1 |
assertTrue(h.equals(h2)); |
855 |
1 |
assertEquals(0, h.getSize()); |
856 |
|
|
857 |
1 |
h.hideList(seq1.getInsertions()); |
858 |
1 |
h2.hideColumns(3, 5); |
859 |
1 |
h2.hideColumns(9, 9); |
860 |
1 |
h2.hideColumns(19, 20); |
861 |
1 |
assertTrue(h.equals(h2)); |
862 |
1 |
assertEquals(6, h.getSize()); |
863 |
|
} |
864 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (61) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
865 |
1 |
@Test(groups = "Functional")... |
866 |
|
public void testHideColumns_BitSet_range() |
867 |
|
{ |
868 |
1 |
HiddenColumns h = new HiddenColumns(); |
869 |
1 |
HiddenColumns h2 = new HiddenColumns(); |
870 |
|
|
871 |
1 |
BitSet tohide = new BitSet(25); |
872 |
1 |
h.hideColumns(tohide); |
873 |
1 |
assertTrue(h.equals(h2)); |
874 |
|
|
875 |
|
|
876 |
1 |
tohide.set(3, 6); |
877 |
1 |
tohide.set(9); |
878 |
1 |
tohide.set(15, 21); |
879 |
1 |
h.clearAndHideColumns(tohide, 5, 23); |
880 |
|
|
881 |
1 |
h2.hideColumns(5, 5); |
882 |
1 |
h2.hideColumns(9, 9); |
883 |
1 |
h2.hideColumns(15, 20); |
884 |
1 |
assertTrue(h.equals(h2)); |
885 |
1 |
assertEquals(h.getSize(), h2.getSize()); |
886 |
|
|
887 |
1 |
tohide.clear(); |
888 |
1 |
tohide.set(41); |
889 |
1 |
h.clearAndHideColumns(tohide, 23, 30); |
890 |
1 |
assertTrue(h.equals(h2)); |
891 |
1 |
assertEquals(h.getSize(), h2.getSize()); |
892 |
|
|
893 |
1 |
tohide.set(41); |
894 |
1 |
h.clearAndHideColumns(tohide, 30, 45); |
895 |
1 |
h2.hideColumns(41, 41); |
896 |
1 |
assertTrue(h.equals(h2)); |
897 |
1 |
assertEquals(h.getSize(), h2.getSize()); |
898 |
|
|
899 |
1 |
tohide.clear(); |
900 |
1 |
tohide.set(25, 28); |
901 |
1 |
h.clearAndHideColumns(tohide, 17, 50); |
902 |
1 |
h2 = new HiddenColumns(); |
903 |
1 |
h2.hideColumns(5, 5); |
904 |
1 |
h2.hideColumns(9, 9); |
905 |
1 |
h2.hideColumns(15, 16); |
906 |
1 |
h2.hideColumns(25, 27); |
907 |
1 |
assertTrue(h.equals(h2)); |
908 |
1 |
assertEquals(h.getSize(), h2.getSize()); |
909 |
|
|
910 |
1 |
HiddenColumns hc = new HiddenColumns(); |
911 |
1 |
hc.hideColumns(3, 5); |
912 |
1 |
hc.hideColumns(15, 20); |
913 |
1 |
hc.hideColumns(45, 60); |
914 |
|
|
915 |
1 |
tohide = new BitSet(); |
916 |
|
|
917 |
|
|
918 |
1 |
hc.clearAndHideColumns(tohide, 1, 70); |
919 |
1 |
assertTrue(!hc.hasHiddenColumns()); |
920 |
1 |
assertEquals(0, hc.getSize()); |
921 |
|
|
922 |
1 |
hc.hideColumns(3, 5); |
923 |
1 |
hc.hideColumns(15, 20); |
924 |
1 |
hc.hideColumns(45, 60); |
925 |
1 |
assertEquals(25, hc.getSize()); |
926 |
|
|
927 |
|
|
928 |
1 |
hc.clearAndHideColumns(tohide, 23, 40); |
929 |
1 |
assertTrue(hc.hasHiddenColumns()); |
930 |
1 |
assertEquals(25, hc.getSize()); |
931 |
|
|
932 |
|
|
933 |
1 |
hc.clearAndHideColumns(tohide, 1, 17); |
934 |
1 |
Iterator<int[]> it = hc.iterator(); |
935 |
1 |
assertTrue(it.hasNext()); |
936 |
1 |
int[] region = it.next(); |
937 |
|
|
938 |
1 |
assertEquals(18, region[0]); |
939 |
1 |
assertEquals(20, region[1]); |
940 |
|
|
941 |
1 |
assertTrue(it.hasNext()); |
942 |
1 |
region = it.next(); |
943 |
|
|
944 |
1 |
assertEquals(45, region[0]); |
945 |
1 |
assertEquals(60, region[1]); |
946 |
|
|
947 |
1 |
assertFalse(it.hasNext()); |
948 |
1 |
assertEquals(19, hc.getSize()); |
949 |
|
} |
950 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (65) |
Complexity: 1 |
Complexity Density: 0.02 |
1PASS
|
|
951 |
1 |
@Test(groups = "Functional")... |
952 |
|
public void testOffsetByVisibleColumns() |
953 |
|
{ |
954 |
1 |
HiddenColumns h = new HiddenColumns(); |
955 |
1 |
int result = h.offsetByVisibleColumns(-1, 10); |
956 |
1 |
assertEquals(9, result); |
957 |
|
|
958 |
1 |
h.hideColumns(7, 9); |
959 |
1 |
result = h.offsetByVisibleColumns(-4, 10); |
960 |
1 |
assertEquals(3, result); |
961 |
|
|
962 |
1 |
h.hideColumns(14, 15); |
963 |
1 |
result = h.offsetByVisibleColumns(-4, 10); |
964 |
1 |
assertEquals(3, result); |
965 |
|
|
966 |
1 |
result = h.offsetByVisibleColumns(-10, 17); |
967 |
1 |
assertEquals(2, result); |
968 |
|
|
969 |
1 |
result = h.offsetByVisibleColumns(-1, 7); |
970 |
1 |
assertEquals(5, result); |
971 |
|
|
972 |
1 |
result = h.offsetByVisibleColumns(-1, 8); |
973 |
1 |
assertEquals(5, result); |
974 |
|
|
975 |
1 |
result = h.offsetByVisibleColumns(-3, 15); |
976 |
1 |
assertEquals(10, result); |
977 |
|
|
978 |
1 |
ColumnSelection sel = new ColumnSelection(); |
979 |
1 |
h.revealAllHiddenColumns(sel); |
980 |
1 |
h.hideColumns(0, 30); |
981 |
1 |
result = h.offsetByVisibleColumns(-31, 0); |
982 |
1 |
assertEquals(-31, result); |
983 |
|
|
984 |
1 |
HiddenColumns cs = new HiddenColumns(); |
985 |
|
|
986 |
|
|
987 |
|
|
988 |
1 |
long pos = cs.offsetByVisibleColumns(-3, 10); |
989 |
1 |
assertEquals(7, pos); |
990 |
|
|
991 |
|
|
992 |
1 |
pos = cs.offsetByVisibleColumns(0, 10); |
993 |
1 |
assertEquals(10, pos); |
994 |
|
|
995 |
|
|
996 |
1 |
pos = cs.offsetByVisibleColumns(-3, 0); |
997 |
1 |
assertEquals(-3, pos); |
998 |
|
|
999 |
|
|
1000 |
|
|
1001 |
1 |
cs.hideColumns(1, 3); |
1002 |
|
|
1003 |
|
|
1004 |
1 |
pos = cs.offsetByVisibleColumns(-3, 10); |
1005 |
1 |
assertEquals(7, pos); |
1006 |
|
|
1007 |
|
|
1008 |
1 |
pos = cs.offsetByVisibleColumns(0, 10); |
1009 |
1 |
assertEquals(10, pos); |
1010 |
|
|
1011 |
|
|
1012 |
1 |
cs.hideColumns(12, 15); |
1013 |
1 |
pos = cs.offsetByVisibleColumns(-8, 17); |
1014 |
1 |
assertEquals(5, pos); |
1015 |
|
|
1016 |
|
|
1017 |
1 |
cs.hideColumns(20, 21); |
1018 |
1 |
pos = cs.offsetByVisibleColumns(-8, 23); |
1019 |
1 |
assertEquals(9, pos); |
1020 |
|
|
1021 |
|
|
1022 |
1 |
ColumnSelection colsel = new ColumnSelection(); |
1023 |
1 |
cs.revealAllHiddenColumns(colsel); |
1024 |
|
|
1025 |
|
|
1026 |
1 |
cs.hideColumns(12, 15); |
1027 |
1 |
pos = cs.offsetByVisibleColumns(-8, 17); |
1028 |
1 |
assertEquals(5, pos); |
1029 |
|
|
1030 |
|
|
1031 |
1 |
cs.hideColumns(20, 21); |
1032 |
1 |
pos = cs.offsetByVisibleColumns(-8, 23); |
1033 |
1 |
assertEquals(9, pos); |
1034 |
|
|
1035 |
|
|
1036 |
|
|
1037 |
|
|
1038 |
|
|
1039 |
1 |
pos = cs.offsetByVisibleColumns(3, 7); |
1040 |
1 |
assertEquals(10, pos); |
1041 |
|
|
1042 |
|
|
1043 |
|
|
1044 |
1 |
cs.hideColumns(1, 3); |
1045 |
|
|
1046 |
|
|
1047 |
1 |
cs.hideColumns(12, 15); |
1048 |
1 |
pos = cs.offsetByVisibleColumns(8, 5); |
1049 |
1 |
assertEquals(17, pos); |
1050 |
|
|
1051 |
|
|
1052 |
1 |
cs.hideColumns(20, 21); |
1053 |
1 |
pos = cs.offsetByVisibleColumns(8, 9); |
1054 |
1 |
assertEquals(23, pos); |
1055 |
|
|
1056 |
|
|
1057 |
1 |
colsel = new ColumnSelection(); |
1058 |
1 |
cs.revealAllHiddenColumns(colsel); |
1059 |
|
|
1060 |
|
|
1061 |
1 |
cs.hideColumns(12, 15); |
1062 |
1 |
pos = cs.offsetByVisibleColumns(8, 5); |
1063 |
1 |
assertEquals(17, pos); |
1064 |
|
|
1065 |
|
|
1066 |
1 |
cs.hideColumns(20, 21); |
1067 |
1 |
pos = cs.offsetByVisibleColumns(8, 9); |
1068 |
1 |
assertEquals(23, pos); |
1069 |
|
} |
1070 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (38) |
Complexity: 1 |
Complexity Density: 0.03 |
1PASS
|
|
1071 |
1 |
@Test(groups = "Functional")... |
1072 |
|
public void testBoundedIterator() |
1073 |
|
{ |
1074 |
1 |
HiddenColumns h = new HiddenColumns(); |
1075 |
1 |
Iterator<int[]> it = h.getBoundedIterator(0, 10); |
1076 |
|
|
1077 |
|
|
1078 |
1 |
assertFalse(it.hasNext()); |
1079 |
|
|
1080 |
|
|
1081 |
|
|
1082 |
1 |
h.hideColumns(3, 10); |
1083 |
1 |
h.hideColumns(14, 16); |
1084 |
1 |
it = h.getBoundedIterator(0, 20); |
1085 |
1 |
assertTrue(it.hasNext()); |
1086 |
1 |
int[] next = it.next(); |
1087 |
1 |
assertEquals(3, next[0]); |
1088 |
1 |
assertEquals(10, next[1]); |
1089 |
1 |
next = it.next(); |
1090 |
1 |
assertEquals(14, next[0]); |
1091 |
1 |
assertEquals(16, next[1]); |
1092 |
1 |
assertFalse(it.hasNext()); |
1093 |
|
|
1094 |
|
|
1095 |
|
|
1096 |
1 |
it = h.getBoundedIterator(5, 7); |
1097 |
1 |
assertTrue(it.hasNext()); |
1098 |
1 |
next = it.next(); |
1099 |
1 |
assertEquals(3, next[0]); |
1100 |
1 |
assertEquals(10, next[1]); |
1101 |
1 |
assertFalse(it.hasNext()); |
1102 |
|
|
1103 |
|
|
1104 |
|
|
1105 |
1 |
it = h.getBoundedIterator(3, 15); |
1106 |
1 |
assertTrue(it.hasNext()); |
1107 |
1 |
next = it.next(); |
1108 |
1 |
assertEquals(3, next[0]); |
1109 |
1 |
assertEquals(10, next[1]); |
1110 |
1 |
next = it.next(); |
1111 |
1 |
assertEquals(14, next[0]); |
1112 |
1 |
assertEquals(16, next[1]); |
1113 |
1 |
assertFalse(it.hasNext()); |
1114 |
|
|
1115 |
|
|
1116 |
|
|
1117 |
1 |
it = h.getBoundedIterator(4, 20); |
1118 |
1 |
assertTrue(it.hasNext()); |
1119 |
1 |
next = it.next(); |
1120 |
1 |
assertEquals(3, next[0]); |
1121 |
1 |
assertEquals(10, next[1]); |
1122 |
1 |
next = it.next(); |
1123 |
1 |
assertEquals(14, next[0]); |
1124 |
1 |
assertEquals(16, next[1]); |
1125 |
1 |
assertFalse(it.hasNext()); |
1126 |
|
} |
1127 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (26) |
Complexity: 1 |
Complexity Density: 0.04 |
1PASS
|
|
1128 |
1 |
@Test(groups = "Functional")... |
1129 |
|
public void testBoundedStartIterator() |
1130 |
|
{ |
1131 |
1 |
HiddenColumns h = new HiddenColumns(); |
1132 |
1 |
Iterator<Integer> it = h.getStartRegionIterator(0, 10); |
1133 |
|
|
1134 |
|
|
1135 |
1 |
assertFalse(it.hasNext()); |
1136 |
|
|
1137 |
|
|
1138 |
|
|
1139 |
1 |
h.hideColumns(3, 10); |
1140 |
1 |
h.hideColumns(14, 16); |
1141 |
1 |
it = h.getStartRegionIterator(0, 20); |
1142 |
1 |
assertTrue(it.hasNext()); |
1143 |
1 |
int next = it.next(); |
1144 |
1 |
assertEquals(3, next); |
1145 |
1 |
next = it.next(); |
1146 |
1 |
assertEquals(6, next); |
1147 |
1 |
assertFalse(it.hasNext()); |
1148 |
|
|
1149 |
|
|
1150 |
|
|
1151 |
1 |
it = h.getStartRegionIterator(4, 5); |
1152 |
1 |
assertFalse(it.hasNext()); |
1153 |
|
|
1154 |
|
|
1155 |
|
|
1156 |
1 |
it = h.getStartRegionIterator(3, 7); |
1157 |
1 |
assertTrue(it.hasNext()); |
1158 |
1 |
next = it.next(); |
1159 |
1 |
assertEquals(3, next); |
1160 |
1 |
next = it.next(); |
1161 |
1 |
assertEquals(6, next); |
1162 |
1 |
assertFalse(it.hasNext()); |
1163 |
|
|
1164 |
|
|
1165 |
|
|
1166 |
1 |
it = h.getStartRegionIterator(4, 20); |
1167 |
1 |
assertTrue(it.hasNext()); |
1168 |
1 |
next = it.next(); |
1169 |
1 |
assertEquals(6, next); |
1170 |
1 |
assertFalse(it.hasNext()); |
1171 |
|
} |
1172 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (98) |
Complexity: 1 |
Complexity Density: 0.01 |
1PASS
|
|
1173 |
1 |
@Test(groups = "Functional")... |
1174 |
|
public void testVisibleBlocksVisBoundsIterator() |
1175 |
|
{ |
1176 |
1 |
HiddenColumns h = new HiddenColumns(); |
1177 |
1 |
Iterator<int[]> regions = h.getVisContigsIterator(0, 31, true); |
1178 |
|
|
1179 |
|
|
1180 |
1 |
assertTrue(regions.hasNext()); |
1181 |
1 |
int[] region = regions.next(); |
1182 |
1 |
assertEquals(0, region[0]); |
1183 |
1 |
assertEquals(30, region[1]); |
1184 |
1 |
assertFalse(regions.hasNext()); |
1185 |
|
|
1186 |
|
|
1187 |
|
|
1188 |
|
|
1189 |
1 |
h.hideColumns(10, 15); |
1190 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1191 |
|
|
1192 |
1 |
assertTrue(regions.hasNext()); |
1193 |
1 |
region = regions.next(); |
1194 |
1 |
assertEquals(0, region[0]); |
1195 |
1 |
assertEquals(9, region[1]); |
1196 |
1 |
region = regions.next(); |
1197 |
1 |
assertEquals(16, region[0]); |
1198 |
1 |
assertEquals(36, region[1]); |
1199 |
1 |
assertFalse(regions.hasNext()); |
1200 |
|
|
1201 |
|
|
1202 |
1 |
h = new HiddenColumns(); |
1203 |
1 |
h.hideColumns(0, 5); |
1204 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1205 |
|
|
1206 |
1 |
assertTrue(regions.hasNext()); |
1207 |
1 |
region = regions.next(); |
1208 |
1 |
assertEquals(6, region[0]); |
1209 |
1 |
assertEquals(36, region[1]); |
1210 |
1 |
assertFalse(regions.hasNext()); |
1211 |
|
|
1212 |
|
|
1213 |
1 |
h = new HiddenColumns(); |
1214 |
1 |
h.hideColumns(27, 30); |
1215 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1216 |
|
|
1217 |
1 |
assertTrue(regions.hasNext()); |
1218 |
1 |
region = regions.next(); |
1219 |
1 |
assertEquals(0, region[0]); |
1220 |
1 |
assertEquals(26, region[1]); |
1221 |
1 |
region = regions.next(); |
1222 |
1 |
assertEquals(31, region[0]); |
1223 |
1 |
assertEquals(34, region[1]); |
1224 |
1 |
assertFalse(regions.hasNext()); |
1225 |
|
|
1226 |
|
|
1227 |
1 |
h = new HiddenColumns(); |
1228 |
1 |
h.hideColumns(0, 5); |
1229 |
1 |
h.hideColumns(23, 25); |
1230 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1231 |
|
|
1232 |
1 |
assertTrue(regions.hasNext()); |
1233 |
1 |
region = regions.next(); |
1234 |
1 |
assertEquals(6, region[0]); |
1235 |
1 |
assertEquals(22, region[1]); |
1236 |
1 |
region = regions.next(); |
1237 |
1 |
assertEquals(26, region[0]); |
1238 |
1 |
assertEquals(39, region[1]); |
1239 |
1 |
assertFalse(regions.hasNext()); |
1240 |
|
|
1241 |
|
|
1242 |
1 |
h = new HiddenColumns(); |
1243 |
1 |
h.hideColumns(27, 30); |
1244 |
1 |
h.hideColumns(11, 14); |
1245 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1246 |
|
|
1247 |
1 |
assertTrue(regions.hasNext()); |
1248 |
1 |
region = regions.next(); |
1249 |
1 |
assertEquals(0, region[0]); |
1250 |
1 |
assertEquals(10, region[1]); |
1251 |
1 |
region = regions.next(); |
1252 |
1 |
assertEquals(15, region[0]); |
1253 |
1 |
assertEquals(26, region[1]); |
1254 |
1 |
region = regions.next(); |
1255 |
1 |
assertEquals(31, region[0]); |
1256 |
1 |
assertEquals(38, region[1]); |
1257 |
1 |
assertFalse(regions.hasNext()); |
1258 |
|
|
1259 |
|
|
1260 |
1 |
h = new HiddenColumns(); |
1261 |
1 |
h.hideColumns(27, 35); |
1262 |
1 |
h.hideColumns(0, 4); |
1263 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1264 |
|
|
1265 |
1 |
assertTrue(regions.hasNext()); |
1266 |
1 |
region = regions.next(); |
1267 |
1 |
assertEquals(5, region[0]); |
1268 |
1 |
assertEquals(26, region[1]); |
1269 |
1 |
region = regions.next(); |
1270 |
1 |
assertEquals(36, region[0]); |
1271 |
1 |
assertEquals(44, region[1]); |
1272 |
1 |
assertFalse(regions.hasNext()); |
1273 |
|
|
1274 |
|
|
1275 |
1 |
h = new HiddenColumns(); |
1276 |
1 |
h.hideColumns(1, 1); |
1277 |
1 |
h.hideColumns(3, 5); |
1278 |
1 |
h.hideColumns(9, 11); |
1279 |
1 |
h.hideColumns(22, 26); |
1280 |
|
|
1281 |
1 |
regions = h.getVisContigsIterator(0, 31, true); |
1282 |
|
|
1283 |
1 |
assertTrue(regions.hasNext()); |
1284 |
1 |
region = regions.next(); |
1285 |
1 |
assertEquals(0, region[0]); |
1286 |
1 |
assertEquals(0, region[1]); |
1287 |
1 |
region = regions.next(); |
1288 |
1 |
assertEquals(2, region[0]); |
1289 |
1 |
assertEquals(2, region[1]); |
1290 |
1 |
region = regions.next(); |
1291 |
1 |
assertEquals(6, region[0]); |
1292 |
1 |
assertEquals(8, region[1]); |
1293 |
1 |
region = regions.next(); |
1294 |
1 |
assertEquals(12, region[0]); |
1295 |
1 |
assertEquals(21, region[1]); |
1296 |
1 |
region = regions.next(); |
1297 |
1 |
assertEquals(27, region[0]); |
1298 |
1 |
assertEquals(42, region[1]); |
1299 |
1 |
assertFalse(regions.hasNext()); |
1300 |
|
} |
1301 |
|
|
1302 |
|
|
1303 |
|
|
1304 |
|
|
1305 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (3) |
Complexity: 1 |
Complexity Density: 0.33 |
1PASS
|
|
1306 |
1 |
@Test(groups = "Functional")... |
1307 |
|
public void testGetVisibleColsIterator() |
1308 |
|
{ |
1309 |
1 |
HiddenColumns h = new HiddenColumns(); |
1310 |
1 |
Iterator<Integer> it = h.getVisibleColsIterator(0, 10); |
1311 |
|
|
1312 |
1 |
assertTrue(it instanceof RangeElementsIterator); |
1313 |
|
} |
1314 |
|
|
|
|
| 100% |
Uncovered Elements: 0 (7) |
Complexity: 1 |
Complexity Density: 0.14 |
1PASS
|
|
1315 |
1 |
@Test(groups = "Functional")... |
1316 |
|
public void testHashCode() |
1317 |
|
{ |
1318 |
1 |
HiddenColumns h = new HiddenColumns(); |
1319 |
1 |
h.hideColumns(0, 25); |
1320 |
|
|
1321 |
1 |
int result = h.hashCode(); |
1322 |
1 |
assertTrue(result > 0); |
1323 |
|
|
1324 |
1 |
h.hideColumns(30, 50); |
1325 |
1 |
assertTrue(h.hashCode() > 0); |
1326 |
1 |
assertTrue(result != h.hashCode()); |
1327 |
|
} |
1328 |
|
} |