1 /*
2 * Copyright (c) 2011, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 package javafx.scene.control;
27
28 import com.sun.javafx.scene.control.behavior.ListCellBehavior;
29 import com.sun.javafx.scene.control.behavior.TableCellBehavior;
30 import javafx.beans.InvalidationListener;
31 import javafx.beans.Observable;
32 import javafx.beans.property.ReadOnlyStringWrapper;
33 import javafx.collections.FXCollections;
34 import javafx.collections.ListChangeListener;
35 import javafx.collections.ObservableList;
36 import javafx.event.EventHandler;
37 import javafx.scene.input.KeyCode;
38 import java.util.List;
39 import com.sun.javafx.PlatformUtil;
40 import com.sun.javafx.util.Utils;
41 import com.sun.javafx.scene.control.behavior.ListViewAnchorRetriever;
42 import com.sun.javafx.scene.control.infrastructure.KeyEventFirer;
43 import com.sun.javafx.scene.control.infrastructure.KeyModifier;
44 import com.sun.javafx.scene.control.infrastructure.StageLoader;
45 import com.sun.javafx.scene.control.infrastructure.VirtualFlowTestUtils;
46 import com.sun.javafx.tk.Toolkit;
47 import javafx.scene.layout.HBox;
48 import org.junit.After;
49 import org.junit.Before;
50 import org.junit.Ignore;
51 import org.junit.Test;
52 import static org.junit.Assert.assertEquals;
53 import static org.junit.Assert.assertFalse;
54 import static org.junit.Assert.assertNotSame;
55 import static org.junit.Assert.assertNull;
56 import static org.junit.Assert.assertTrue;
57 import static org.junit.Assert.fail;
58
59 public class ListViewKeyInputTest {
60 private ListView<String> listView;
61 private MultipleSelectionModel<String> sm;
62 private FocusModel<String> fm;
63
64 private KeyEventFirer keyboard;
65
66 private StageLoader stageLoader;
67
68 @Before public void setup() {
69 listView = new ListView<>();
70 sm = listView.getSelectionModel();
71 fm = listView.getFocusModel();
72
73 sm.setSelectionMode(SelectionMode.MULTIPLE);
74
75 keyboard = new KeyEventFirer(listView);
76 stageLoader = new StageLoader(listView);
77
78 listView.getItems().setAll("1", "2", "3", "4", "5", "6", "7", "8", "9", "10");
79 }
80
81 @After public void tearDown() {
82 listView.getSkin().dispose();
83 stageLoader.dispose();
84 }
85
86
87 /***************************************************************************
88 * Util methods
89 **************************************************************************/
90
91 private String debug() {
92 StringBuilder sb = new StringBuilder("Selected Indices: [");
93
94 List<Integer> indices = sm.getSelectedIndices();
95 for (Integer index : indices) {
96 sb.append(index);
97 sb.append(", ");
98 }
99
100 sb.append("] \nFocus: " + fm.getFocusedIndex());
101 sb.append(" \nAnchor: " + getAnchor());
102 return sb.toString();
103 }
104
105 // Returns true if ALL indices are selected
106 private boolean isSelected(int... indices) {
107 for (int index : indices) {
108 if (! sm.isSelected(index)) {
109 System.out.println("Index " + index + " is not selected, but it is expected to be");
110 return false;
111 }
112 }
113 return true;
114 }
115
116 // Returns true if ALL indices are NOT selected
117 private boolean isNotSelected(int... indices) {
118 for (int index : indices) {
119 if (sm.isSelected(index)) {
120 System.out.println("Index " + index + " is selected, but it is not expected to be");
121 return false;
122 }
123 }
124 return true;
125 }
126
127 private int getAnchor() {
128 return ListViewAnchorRetriever.getAnchor(listView);
129 }
130
131 private boolean isAnchor(int index) {
132 return getAnchor() == index;
133 }
134
135
136 /***************************************************************************
137 * General tests
138 **************************************************************************/
139
140 @Test public void testInitialState() {
141 assertTrue(sm.getSelectedIndices().isEmpty());
142 assertTrue(sm.getSelectedItems().isEmpty());
143 }
144
145 /***************************************************************************
146 * Tests for row-based single selection
147 **************************************************************************/
148
149 @Test public void testDownArrowChangesSelection() {
150 sm.clearAndSelect(0);
151 keyboard.doDownArrowPress();
152 assertFalse(sm.isSelected(0));
153 assertTrue(sm.isSelected(1));
154 }
155
156 @Test public void testDownArrowDoesNotChangeSelectionWhenAtLastIndex() {
157 int endIndex = listView.getItems().size() - 1;
158 sm.clearAndSelect(endIndex);
159 assertTrue(sm.isSelected(endIndex));
160 keyboard.doDownArrowPress();
161 assertTrue(sm.isSelected(endIndex));
162 }
163
164 @Test public void testUpArrowDoesNotChangeSelectionWhenAt0Index() {
165 sm.clearAndSelect(0);
166 keyboard.doUpArrowPress();
167 assertTrue(sm.isSelected(0));
168 assertEquals(1, sm.getSelectedIndices().size());
169 assertEquals(1, sm.getSelectedItems().size());
170 }
171
172 @Test public void testUpArrowChangesSelection() {
173 sm.clearAndSelect(1);
174 keyboard.doUpArrowPress();
175 assertFalse(sm.isSelected(1));
176 assertTrue(sm.isSelected(0));
177 }
178
179 @Test public void testLeftArrowDoesNotChangeState() {
180 keyboard.doLeftArrowPress();
181 testInitialState();
182 }
183
184 @Test public void testRightArrowDoesNotChangeState() {
185 keyboard.doRightArrowPress();
186 testInitialState();
187 }
188
189 // test 19
190 @Test public void testCtrlDownMovesFocusButLeavesSelectionAlone() {
191 sm.clearAndSelect(0);
192 assertTrue(fm.isFocused(0));
193 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
194 assertTrue(fm.isFocused(1));
195 assertTrue(sm.isSelected(0));
196 assertFalse(sm.isSelected(1));
197 }
198
199 // test 20
200 @Test public void testCtrlUpDoesNotMoveFocus() {
201 sm.clearAndSelect(0);
202 assertTrue(fm.isFocused(0));
203 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
204 assertTrue(fm.isFocused(0));
205 assertTrue(sm.isSelected(0));
206 }
207
208 // test 21
209 @Test public void testCtrlLeftDoesNotMoveFocus() {
210 sm.clearAndSelect(0);
211 assertTrue(fm.isFocused(0));
212 keyboard.doLeftArrowPress(KeyModifier.getShortcutKey());
213 assertTrue(fm.isFocused(0));
214 assertTrue(sm.isSelected(0));
215 }
216
217 // test 22
218 @Test public void testCtrlRightDoesNotMoveFocus() {
219 sm.clearAndSelect(0);
220 assertTrue(fm.isFocused(0));
221 keyboard.doRightArrowPress(KeyModifier.getShortcutKey());
222 assertTrue(fm.isFocused(0));
223 assertTrue(sm.isSelected(0));
224 }
225
226 // test 23
227 @Test public void testCtrlUpMovesFocus() {
228 sm.clearAndSelect(1);
229 assertTrue(fm.isFocused(1));
230 assertTrue(sm.isSelected(1));
231 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
232 assertTrue(fm.isFocused(0));
233
234 }
235
236 // test 24
237 @Test public void testCtrlDownDoesNotMoveFocusWhenAtLastIndex() {
238 int endIndex = listView.getItems().size() - 1;
239 sm.clearAndSelect(endIndex);
240 assertTrue(fm.isFocused(endIndex));
241 assertTrue(sm.isSelected(endIndex));
242 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
243 assertTrue(fm.isFocused(endIndex));
244 assertTrue(sm.isSelected(endIndex));
245 }
246
247 // test 25
248 @Test public void testCtrlDownArrowWithSpaceChangesAnchor() {
249 sm.clearAndSelect(0);
250 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
251 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
252 keyboard.doKeyPress(KeyCode.SPACE,
253 KeyModifier.getShortcutKey(),
254 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 2
255
256 assertTrue(isSelected(0, 2));
257 assertTrue(isNotSelected(1));
258 assertTrue(isAnchor(2));
259 }
260
261 // test 26
262 @Test public void testCtrlUpArrowWithSpaceChangesAnchor() {
263 sm.clearAndSelect(2);
264 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
265 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
266 keyboard.doKeyPress(KeyCode.SPACE,
267 KeyModifier.getShortcutKey(),
268 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 0
269
270 assertTrue(isSelected(0, 2));
271 assertTrue(isNotSelected(1));
272 assertTrue(isAnchor(0));
273 }
274
275 // test 44
276 @Test public void testHomeKey() {
277 sm.clearAndSelect(3);
278 keyboard.doKeyPress(KeyCode.HOME);
279 assertTrue(debug(), isSelected(0));
280 assertTrue(isNotSelected(1,2,3));
281 }
282
283 // test 45
284 @Test public void testEndKey() {
285 sm.clearAndSelect(3);
286 keyboard.doKeyPress(KeyCode.END);
287 assertTrue(isSelected(listView.getItems().size() - 1));
288 assertTrue(isNotSelected(1,2,3));
289 }
290
291 // test 53
292 @Test public void testCtrlHome() {
293 sm.clearAndSelect(5);
294 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.getShortcutKey());
295 assertTrue(isSelected(5));
296 assertTrue(fm.isFocused(0));
297 }
298
299 // test 54
300 @Test public void testCtrlEnd() {
301 sm.clearAndSelect(5);
302 keyboard.doKeyPress(KeyCode.END, KeyModifier.getShortcutKey());
303 assertTrue(isSelected(5));
304 assertTrue(fm.isFocused(listView.getItems().size() - 1));
305 }
306
307 // test 68
308 @Test public void testCtrlSpaceToClearSelection() {
309 sm.clearAndSelect(5);
310 assertTrue(isSelected(5));
311 assertTrue(fm.isFocused(5));
312
313 keyboard.doKeyPress(KeyCode.SPACE,
314 KeyModifier.getShortcutKey(),
315 (Utils.isMac() ? KeyModifier.CTRL : null));
316
317 assertTrue(isNotSelected(5));
318 assertTrue(debug(), fm.isFocused(5));
319 assertTrue(isAnchor(5));
320 }
321
322
323
324 /***************************************************************************
325 * Tests for row-based multiple selection
326 **************************************************************************/
327
328 @Test public void testShiftDownArrowIncreasesSelection() {
329 sm.clearAndSelect(0);
330 keyboard.doDownArrowPress(KeyModifier.SHIFT);
331 assertTrue(sm.isSelected(0));
332 assertTrue(sm.isSelected(1));
333 }
334
335 @Test public void testShiftDownArrowDoesNotChangeSelectionWhenAtLastIndex() {
336 int endIndex = listView.getItems().size() - 1;
337 sm.clearAndSelect(endIndex);
338 assertTrue(sm.isSelected(endIndex));
339 keyboard.doDownArrowPress(KeyModifier.SHIFT);
340 assertTrue(sm.isSelected(endIndex));
341 }
342
343 @Test public void testShiftUpArrowIncreasesSelection() {
344 sm.clearAndSelect(1);
345 keyboard.doUpArrowPress(KeyModifier.SHIFT);
346 assertTrue(sm.isSelected(0));
347 assertTrue(sm.isSelected(1));
348 }
349
350 @Test public void testShiftUpArrowWhenAt0Index() {
351 sm.clearAndSelect(0);
352 keyboard.doUpArrowPress(KeyModifier.SHIFT);
353 assertTrue(sm.isSelected(0));
354 }
355
356 @Test public void testShiftLeftArrowWhenAt0Index() {
357 sm.clearAndSelect(0);
358 keyboard.doLeftArrowPress(KeyModifier.SHIFT);
359 assertTrue(sm.isSelected(0));
360 assertFalse(sm.isSelected(1));
361 }
362
363 @Test public void testShiftRightArrowWhenAt0Index() {
364 sm.clearAndSelect(0);
365 keyboard.doRightArrowPress(KeyModifier.SHIFT);
366 assertTrue(sm.isSelected(0));
367 assertFalse(sm.isSelected(1));
368 }
369
370 @Test public void testShiftDownTwiceThenShiftUp() {
371 sm.clearAndSelect(0);
372 keyboard.doDownArrowPress(KeyModifier.SHIFT);
373 keyboard.doDownArrowPress(KeyModifier.SHIFT);
374 keyboard.doUpArrowPress(KeyModifier.SHIFT);
375 assertTrue(debug(), sm.isSelected(0));
376 assertTrue(sm.isSelected(1));
377 assertFalse(sm.isSelected(2));
378 }
379
380 @Test public void testShiftUpTwiceThenShiftDownFrom0Index() {
381 sm.clearAndSelect(0);
382 keyboard.doUpArrowPress(KeyModifier.SHIFT);
383 keyboard.doUpArrowPress(KeyModifier.SHIFT);
384 keyboard.doDownArrowPress(KeyModifier.SHIFT);
385 assertTrue(sm.isSelected(0));
386 assertTrue(sm.isSelected(1));
387 assertFalse(sm.isSelected(2));
388 }
389
390 @Test public void testShiftLeftTwiceThenShiftRight() {
391 sm.clearAndSelect(0);
392 keyboard.doLeftArrowPress(KeyModifier.SHIFT);
393 keyboard.doLeftArrowPress(KeyModifier.SHIFT);
394 keyboard.doRightArrowPress(KeyModifier.SHIFT);
395 assertTrue(sm.isSelected(0));
396 assertFalse(sm.isSelected(1));
397 assertFalse(sm.isSelected(2));
398 }
399
400 @Test public void testShiftRightTwiceThenShiftLeft() {
401 sm.clearAndSelect(0);
402 keyboard.doRightArrowPress(KeyModifier.SHIFT);
403 keyboard.doRightArrowPress(KeyModifier.SHIFT);
404 keyboard.doLeftArrowPress(KeyModifier.SHIFT);
405 assertTrue(sm.isSelected(0));
406 assertFalse(sm.isSelected(1));
407 assertFalse(sm.isSelected(2));
408 }
409
410 @Test public void testShiftUpTwiceThenShiftDown() {
411 sm.clearAndSelect(2);
412 keyboard.doUpArrowPress(KeyModifier.SHIFT);
413 keyboard.doUpArrowPress(KeyModifier.SHIFT);
414 keyboard.doDownArrowPress(KeyModifier.SHIFT);
415 assertFalse(sm.isSelected(0));
416 assertTrue(sm.isSelected(1));
417 assertTrue(sm.isSelected(2));
418 assertFalse(sm.isSelected(3));
419 }
420
421 // test 18 from Jindra's testcases.rtf file
422 @Test public void testShiftDownTwiceThenShiftUpWhenAtLastIndex() {
423 int endIndex = listView.getItems().size() - 1;
424 sm.clearAndSelect(endIndex);
425 keyboard.doDownArrowPress(KeyModifier.SHIFT);
426 keyboard.doDownArrowPress(KeyModifier.SHIFT);
427 keyboard.doUpArrowPress(KeyModifier.SHIFT);
428 assertTrue(sm.isSelected(endIndex));
429 assertTrue(sm.isSelected(endIndex - 1));
430 assertFalse(sm.isSelected(endIndex - 2));
431 }
432
433 // test 27
434 @Test public void testCtrlDownArrowWithSpaceChangesAnchor_extended() {
435 sm.clearAndSelect(0);
436 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
437 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
438 keyboard.doKeyPress(KeyCode.SPACE,
439 KeyModifier.getShortcutKey(),
440 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 2
441
442 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
443 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
444 keyboard.doKeyPress(KeyCode.SPACE,
445 KeyModifier.getShortcutKey(),
446 (Utils.isMac() ? KeyModifier.CTRL : null)); // deselect 0
447 assertTrue(isSelected(2));
448 assertTrue(isNotSelected(0, 1));
449 assertTrue(isAnchor(0));
450 }
451
452 // test 28
453 @Test public void testCtrlUpArrowWithSpaceChangesAnchor_extended() {
454 sm.clearAndSelect(2);
455 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
456 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
457 keyboard.doKeyPress(KeyCode.SPACE,
458 KeyModifier.getShortcutKey(),
459 Utils.isMac() ? KeyModifier.CTRL : null); // select 0
460
461 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
462 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
463 keyboard.doKeyPress(KeyCode.SPACE,
464 KeyModifier.getShortcutKey(),
465 Utils.isMac() ? KeyModifier.CTRL : null); // deselect 2
466 assertTrue(isSelected(0));
467 assertTrue(isNotSelected(1, 2));
468 assertTrue(isAnchor(2));
469 }
470
471 // test 29
472 @Test public void testCtrlDownArrowWithSpaceChangesAnchor_extended2() {
473 sm.clearAndSelect(0);
474 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
475 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
476 keyboard.doKeyPress(KeyCode.SPACE,
477 KeyModifier.getShortcutKey(),
478 Utils.isMac() ? KeyModifier.CTRL : null); // select 2
479
480 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
481 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
482 keyboard.doKeyPress(KeyCode.SPACE,
483 KeyModifier.getShortcutKey(),
484 Utils.isMac() ? KeyModifier.CTRL : null); // select 4
485 assertTrue(isSelected(0, 2, 4));
486 assertTrue(isNotSelected(1, 3, 5));
487 assertTrue(isAnchor(4));
488 }
489
490 // test 30
491 @Test public void testCtrlUpArrowWithSpaceChangesAnchor_extended2() {
492 sm.clearAndSelect(4);
493 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
494 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
495 keyboard.doKeyPress(KeyCode.SPACE,
496 KeyModifier.getShortcutKey(),
497 Utils.isMac() ? KeyModifier.CTRL : null); // select 2
498
499 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
500 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
501 keyboard.doKeyPress(KeyCode.SPACE,
502 KeyModifier.getShortcutKey(),
503 Utils.isMac() ? KeyModifier.CTRL : null); // select 0
504 assertTrue(isSelected(0, 2, 4));
505 assertTrue(isNotSelected(1, 3));
506 assertTrue(isAnchor(0));
507 }
508
509 // test 31
510 @Test public void testCtrlDownArrowThenShiftSpaceToSelectRange() {
511 sm.clearAndSelect(0);
512 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
513 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
514 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.SHIFT); // select 0,1,2
515 assertTrue(isSelected(0, 1, 2));
516 assertTrue(isNotSelected(3));
517 assertTrue(isAnchor(0));
518 }
519
520 // test 32
521 @Test public void testCtrlUpArrowThenShiftSpaceToSelectRange() {
522 sm.clearAndSelect(2);
523 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
524 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
525 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.SHIFT); // select 0,1,2
526 assertTrue(isSelected(0, 1, 2));
527 assertTrue(isNotSelected(3));
528 assertTrue(debug(), isAnchor(2));
529 }
530
531 // test 33
532 @Test public void testCtrlDownArrowThenSpaceToChangeSelection() {
533 sm.clearAndSelect(0);
534 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
535 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
536 keyboard.doKeyPress(KeyCode.SPACE,
537 KeyModifier.getShortcutKey(),
538 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 2, keeping 0 selected
539 assertTrue(isSelected(0, 2));
540 assertTrue(isNotSelected(1, 3));
541 assertTrue(isAnchor(2));
542
543 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
544 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
545 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.SHIFT); // select 2,3,4
546 assertTrue(isSelected(2, 3, 4));
547 assertTrue(isNotSelected(0, 1));
548 assertTrue(isAnchor(2));
549 }
550
551 // test 34
552 @Test public void testCtrlUpArrowThenSpaceToChangeSelection() {
553 sm.clearAndSelect(4);
554 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
555 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
556 keyboard.doKeyPress(KeyCode.SPACE,
557 KeyModifier.getShortcutKey(),
558 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 2, keeping 4 selected
559 assertTrue(isSelected(2, 4));
560 assertTrue(isNotSelected(0, 1, 3));
561 assertTrue(isAnchor(2));
562
563 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
564 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
565 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.SHIFT); // select 0,1,2
566 assertTrue(isSelected(0, 1, 2));
567 assertTrue(isNotSelected(3, 4));
568 assertTrue(debug(), isAnchor(2));
569 }
570
571 // test 35
572 @Test public void testCtrlDownTwiceThenShiftDown() {
573 sm.clearAndSelect(0);
574 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
575 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
576 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT); // select 0,1,2,3
577 assertTrue(isSelected(0, 1, 2, 3));
578 }
579
580 // test 36
581 @Test public void testCtrlUpThriceThenShiftDown() {
582 sm.clearAndSelect(3);
583 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
584 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
585 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
586 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select 1,2,3
587 assertTrue(debug(), isSelected(1, 2, 3));
588 assertTrue(isNotSelected(0));
589 }
590
591 // test 37
592 @Test public void testCtrlDownThriceThenShiftUp() {
593 sm.clearAndSelect(0);
594 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
595 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
596 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
597 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // select 0,1,2
598 assertTrue(isSelected(0, 1, 2));
599 assertTrue(isNotSelected(3, 4));
600 }
601
602 // test 38
603 @Test public void testCtrlUpTwiceThenShiftUp() {
604 sm.clearAndSelect(3);
605 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
606 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
607 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // select 0,1,2,3
608 assertTrue(isSelected(0, 1, 2, 3));
609 assertTrue(isNotSelected(4));
610 }
611
612 // test 39
613 @Test public void testCtrlDownTwiceThenSpace_extended() {
614 sm.clearAndSelect(0);
615 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
616 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
617 keyboard.doKeyPress(KeyCode.SPACE,
618 KeyModifier.getShortcutKey(),
619 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 0,2
620 assertTrue(isSelected(0, 2));
621 assertTrue(isNotSelected(1, 3));
622 assertTrue(isAnchor(2));
623
624 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
625 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
626 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select 2,3,4,5
627 assertTrue(isSelected(2, 3, 4, 5));
628 assertTrue(isNotSelected(0, 1));
629 assertTrue(isAnchor(2));
630 }
631
632 // test 40
633 @Test public void testCtrlUpTwiceThenSpace_extended() {
634 sm.clearAndSelect(5);
635 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
636 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
637 keyboard.doKeyPress(KeyCode.SPACE,
638 KeyModifier.getShortcutKey(),
639 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 3,5
640 assertTrue(isSelected(3,5));
641 assertTrue(isNotSelected(0,1,2,4));
642 assertTrue(isAnchor(3));
643
644 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
645 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
646 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 0
647 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select 1,2,3
648 assertTrue(isSelected(1,2,3));
649 assertTrue(isNotSelected(0,4,5));
650 assertTrue(isAnchor(3));
651 }
652
653 // test 41
654 @Test public void testCtrlDownTwiceThenSpace_extended2() {
655 sm.clearAndSelect(0);
656 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
657 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
658 keyboard.doKeyPress(KeyCode.SPACE,
659 KeyModifier.getShortcutKey(),
660 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 0,2
661 assertTrue(isSelected(0,2));
662 assertTrue(isNotSelected(1,3,4));
663 assertTrue(isAnchor(2));
664
665 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
666 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
667 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 5
668 keyboard.doUpArrowPress(KeyModifier.SHIFT); // select 2,3,4
669 assertTrue(isSelected(2,3,4));
670 assertTrue(isNotSelected(0,1,5));
671 assertTrue(isAnchor(2));
672 }
673
674 // test 50
675 @Test public void testCtrlDownThenShiftHome() {
676 sm.clearAndSelect(0);
677 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
678 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
679 keyboard.doKeyPress(KeyCode.SPACE,
680 KeyModifier.getShortcutKey(),
681 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 0,2
682 assertTrue(isSelected(0,2));
683 assertTrue(isNotSelected(1,3,4));
684 assertTrue(isAnchor(2));
685
686 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
687 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
688 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
689 assertTrue(isSelected(0,1,2));
690 assertTrue(isNotSelected(3,4));
691 assertTrue(debug(),isAnchor(2));
692 }
693
694 // test 51
695 @Test public void testCtrlUpThenShiftEnd() {
696 sm.clearAndSelect(5);
697 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
698 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
699 keyboard.doKeyPress(KeyCode.SPACE,
700 KeyModifier.getShortcutKey(),
701 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 3,5
702 assertTrue(isSelected(3,5));
703 assertTrue(isNotSelected(1,2,4));
704 assertTrue(isAnchor(3));
705
706 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
707 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
708 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
709 assertTrue(isSelected(3,4,5,6,7,8,9));
710 assertTrue(isNotSelected(0,1,2));
711 assertTrue(debug(),isAnchor(3));
712 }
713
714 // test 42
715 @Test public void testCtrlUpTwiceThenSpace_extended2() {
716 sm.clearAndSelect(5);
717 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 4
718 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 3
719 keyboard.doKeyPress(KeyCode.SPACE,
720 KeyModifier.getShortcutKey(),
721 (Utils.isMac() ? KeyModifier.CTRL : null)); // select 3,5
722 assertTrue(isSelected(3,5));
723 assertTrue(isNotSelected(0,1,2,4));
724 assertTrue(isAnchor(3));
725
726 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 2
727 keyboard.doUpArrowPress(KeyModifier.getShortcutKey()); // move focus to 1
728 keyboard.doUpArrowPress(KeyModifier.SHIFT); // select 0,1,2,3
729 assertTrue(isSelected(0,1,2,3));
730 assertTrue(isNotSelected(4,5));
731 assertTrue(isAnchor(3));
732 }
733
734 // test 46
735 @Test public void testHomeKey_withSelectedItems() {
736 sm.clearSelection();
737 sm.selectRange(4, 11);
738 keyboard.doKeyPress(KeyCode.HOME);
739 assertTrue(isSelected(0));
740 assertTrue(isNotSelected(1,2,3,4,5,6,7,8,9,10,11));
741 }
742
743 // test 47
744 @Test public void testEndKey_withSelectedItems() {
745 sm.clearSelection();
746 sm.selectRange(4, 11);
747 keyboard.doKeyPress(KeyCode.END);
748 assertTrue(isSelected(listView.getItems().size() - 1));
749 assertTrue(isNotSelected(1,2,3,4,5,6,7,8));
750 }
751
752 // test 48
753 @Test public void testShiftHome() {
754 sm.clearAndSelect(3);
755 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
756 assertTrue(isSelected(0,1,2,3));
757 assertTrue(isNotSelected(4,5));
758 assertTrue(debug(), isAnchor(3));
759 }
760
761 // test 49
762 @Test public void testShiftEnd() {
763 sm.clearAndSelect(3);
764 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
765 assertTrue(isSelected(3,4,5,6,7,8,9));
766 assertTrue(isNotSelected(0,1,2));
767 assertTrue(isAnchor(3));
768 }
769
770 // test 52
771 @Test public void testShiftHomeThenShiftEnd() {
772 sm.clearAndSelect(5);
773 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
774 assertTrue(isSelected(0,1,2,3,4,5));
775 assertTrue(isAnchor(5));
776
777 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
778 assertTrue(isSelected(5,6,7,8,9));
779 assertTrue(isAnchor(5));
780 }
781
782 // test 65
783 @Test public void testShiftPageUp() {
784 sm.clearAndSelect(0);
785 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
786 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
787 keyboard.doKeyPress(KeyCode.SPACE,
788 KeyModifier.getShortcutKey(),
789 (Utils.isMac() ? KeyModifier.CTRL : null));
790 assertTrue(isSelected(0,2));
791 assertTrue(isAnchor(2));
792
793 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
794 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
795 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
796 assertTrue(isSelected(0,1,2));
797 assertTrue(isAnchor(2));
798 }
799
800 // test 67
801 @Test public void testCtrlAToSelectAll() {
802 sm.clearAndSelect(5);
803 keyboard.doKeyPress(KeyCode.A, KeyModifier.getShortcutKey());
804 assertTrue(isSelected(0,1,2,3,4,5,6,7,8,9));
805 }
806
807
808
809 /***************************************************************************
810 * Tests for discontinuous multiple selection (RT-18953)
811 **************************************************************************/
812
813 // Test 1
814 @Test public void test_rt18593_1() {
815 sm.clearAndSelect(0);
816 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
817 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
818 keyboard.doKeyPress(KeyCode.SPACE,
819 KeyModifier.getShortcutKey(),
820 (Utils.isMac() ? KeyModifier.CTRL : null));
821 assertTrue(isSelected(0,2));
822 assertTrue(isAnchor(2));
823
824 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
825 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
826 assertTrue(debug(),isSelected(0,2,3,4));
827 assertTrue(isAnchor(2));
828 }
829
830 // Test 2
831 @Test public void test_rt18593_2() {
832 sm.clearAndSelect(5);
833 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
834 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
835 keyboard.doKeyPress(KeyCode.SPACE,
836 KeyModifier.getShortcutKey(),
837 (Utils.isMac() ? KeyModifier.CTRL : null));
838 assertTrue(isSelected(3,5));
839 assertTrue(isAnchor(3));
840
841 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
842 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
843 assertTrue(isSelected(1,2,3,5));
844 assertTrue(isAnchor(3));
845 }
846
847 // Test 3
848 @Test public void test_rt18593_3() {
849 sm.clearAndSelect(0);
850 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
851 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
852 keyboard.doKeyPress(KeyCode.SPACE,
853 KeyModifier.getShortcutKey(),
854 (Utils.isMac() ? KeyModifier.CTRL : null));
855 assertTrue(isSelected(0,2));
856 assertTrue(isAnchor(2));
857
858 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
859 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
860 assertTrue(isSelected(0,2,3,4));
861 assertTrue(isAnchor(2));
862
863 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
864 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
865 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
866 assertTrue(isSelected(0,1,2,3,4));
867 assertTrue(isAnchor(2));
868 }
869
870 // Test 4
871 @Test public void test_rt18593_4() {
872 sm.clearAndSelect(5);
873 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
874 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
875 keyboard.doKeyPress(KeyCode.SPACE,
876 KeyModifier.getShortcutKey(),
877 (Utils.isMac() ? KeyModifier.CTRL : null));
878 assertTrue(isSelected(3,5));
879 assertTrue(isAnchor(3));
880
881 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
882 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
883 assertTrue(isSelected(1,2,3,5));
884 assertTrue(isAnchor(3));
885
886 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
887 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
888 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
889 assertTrue(isSelected(1,2,3,4,5));
890 assertTrue(isAnchor(3));
891 }
892
893 // TODO skipped some tests here (5-8)
894
895 // Test 9
896 @Test public void test_rt18593_9() {
897 sm.clearAndSelect(0);
898 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
899 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
900 keyboard.doKeyPress(KeyCode.SPACE,
901 KeyModifier.getShortcutKey(),
902 (Utils.isMac() ? KeyModifier.CTRL : null));
903 assertTrue(isSelected(0,2));
904 assertTrue(isAnchor(2));
905
906 keyboard.doKeyPress(KeyCode.END, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
907 assertTrue(isSelected(0,2,3,4,5,6,7,8,9));
908 assertTrue(isAnchor(2));
909 }
910
911 // Test 10
912 @Test public void test_rt18593_10() {
913 sm.clearAndSelect(9);
914 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
915 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
916 keyboard.doKeyPress(KeyCode.SPACE,
917 KeyModifier.getShortcutKey(),
918 (Utils.isMac() ? KeyModifier.CTRL : null));
919 assertTrue(isSelected(7,9));
920 assertTrue(isAnchor(7));
921
922 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
923 assertTrue(isSelected(0,1,2,3,4,5,6,7,9));
924 assertTrue(isAnchor(7));
925 }
926
927 // Test 11
928 @Test public void test_rt18593_11() {
929 sm.clearAndSelect(5);
930 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
931 assertTrue(isSelected(0,1,2,3,4,5));
932 assertTrue(isAnchor(5));
933
934 keyboard.doKeyPress(KeyCode.END, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
935 assertTrue(isSelected(0,1,2,3,4,5,6,7,8,9));
936 assertTrue(isAnchor(5));
937 }
938
939 // Test 12
940 @Test public void test_rt18593_12() {
941 sm.clearAndSelect(0);
942 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
943 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
944 keyboard.doKeyPress(KeyCode.SPACE,
945 KeyModifier.getShortcutKey(),
946 (Utils.isMac() ? KeyModifier.CTRL : null));
947 assertTrue(isSelected(0,2));
948 assertTrue(isAnchor(2));
949
950 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
951 keyboard.doDownArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
952 assertTrue(isSelected(0,2,3,4));
953 assertTrue(isAnchor(2));
954
955 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
956 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
957 keyboard.doUpArrowPress(KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
958 assertTrue(isSelected(0,1,2,3,4));
959 assertTrue(isAnchor(2));
960
961 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
962 keyboard.doKeyPress(KeyCode.SPACE,
963 KeyModifier.getShortcutKey(),
964 (Utils.isMac() ? KeyModifier.CTRL : null));
965 assertTrue(isSelected(1,2,3,4));
966 assertTrue(fm.isFocused(0));
967 assertTrue(isAnchor(0));
968 }
969
970
971 /***************************************************************************
972 * Tests for editing
973 **************************************************************************/
974
975 // test 43 (part 1)
976 @Test public void testF2EntersEditModeAndEscapeCancelsEdit_part1() {
977 listView.setEditable(true);
978
979 sm.clearAndSelect(0);
980 assertEquals(-1, listView.getEditingIndex());
981 keyboard.doKeyPress(KeyCode.F2);
982 assertEquals(0, listView.getEditingIndex());
983
984 keyboard.doKeyPress(KeyCode.ESCAPE);
985 assertEquals(-1, listView.getEditingIndex());
986 }
987
988 // // test 43 (part 2)
989 // @Test public void testF2EntersEditModeAndEscapeCancelsEdit_part2() {
990 // listView.setEditable(true);
991 //
992 // sm.clearAndSelect(0);
993 // keyboard.doKeyPress(KeyCode.F2);
994 //
995 //
996 // }
997
998 /***************************************************************************
999 * Tests for specific bug reports
1000 **************************************************************************/
1001
1002 @Test public void test_rt18642() {
1003 sm.clearAndSelect(1); // select 1
1004 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // shift focus to 2
1005 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // shift focus to 3
1006 keyboard.doKeyPress(KeyCode.SPACE,
1007 KeyModifier.getShortcutKey(),
1008 (Utils.isMac() ? KeyModifier.CTRL : null)); // set anchor, and also select, 3
1009 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // shift focus to 4
1010 keyboard.doDownArrowPress(KeyModifier.getShortcutKey()); // shift focus to 5
1011 keyboard.doKeyPress(KeyCode.SPACE,
1012 KeyModifier.getShortcutKey(),
1013 (Utils.isMac() ? KeyModifier.CTRL : null)); // set anchor, and also select, 5
1014
1015 assertTrue(isSelected(1, 3, 5));
1016 assertTrue(isNotSelected(0, 2, 4));
1017
1018 // anchor is at 5, so shift+UP should select rows 4 and 5 only
1019 keyboard.doUpArrowPress(KeyModifier.SHIFT);
1020 assertTrue(isSelected(4, 5));
1021 assertTrue(isNotSelected(0, 1, 2, 3));
1022 }
1023
1024 @Test public void test_rt14451_1() {
1025 sm.clearAndSelect(5);
1026
1027 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
1028 assertTrue(isSelected(0,1,2,3,4,5));
1029 assertTrue(isNotSelected(6,7,8,9));
1030
1031 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
1032 assertTrue(isNotSelected(0,1,2,3,4));
1033 assertTrue(isSelected(5,6,7,8,9));
1034
1035 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
1036 assertTrue(isSelected(0,1,2,3,4,5));
1037 assertTrue(debug(), isNotSelected(6,7,8,9));
1038 }
1039
1040 @Test public void test_rt14451_2() {
1041 sm.clearAndSelect(5);
1042
1043 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
1044 assertTrue(isNotSelected(0,1,2,3,4));
1045 assertTrue(isSelected(5,6,7,8,9));
1046
1047 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
1048 assertTrue(isSelected(0,1,2,3,4,5));
1049 assertTrue(debug(), isNotSelected(6,7,8,9));
1050
1051 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
1052 assertTrue(isNotSelected(0,1,2,3,4));
1053 assertTrue(isSelected(5,6,7,8,9));
1054 }
1055
1056 @Test public void test_rt26835_1() {
1057 sm.clearAndSelect(5);
1058 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.getShortcutKey());
1059 assertTrue(fm.isFocused(0));
1060 }
1061
1062 @Test public void test_rt26835_2() {
1063 sm.clearAndSelect(5);
1064 keyboard.doKeyPress(KeyCode.END, KeyModifier.getShortcutKey());
1065 assertTrue(debug(), fm.isFocused(listView.getItems().size() - 1));
1066 }
1067
1068 @Test public void test_rt27175() {
1069 sm.clearAndSelect(5);
1070 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT, KeyModifier.getShortcutKey());
1071 assertTrue(debug(), fm.isFocused(0));
1072 assertTrue(isSelected(0,1,2,3,4,5));
1073 }
1074
1075 @Test public void test_rt28065() {
1076 sm.setSelectionMode(SelectionMode.MULTIPLE);
1077 listView.getItems().setAll("Apple", "Orange", "Banana");
1078
1079 listView.getSelectionModel().select(0);
1080 assertEquals(0, listView.getSelectionModel().getSelectedIndex());
1081 assertEquals("Apple", listView.getSelectionModel().getSelectedItem());
1082 assertEquals(0, listView.getFocusModel().getFocusedIndex());
1083 assertEquals("Apple", listView.getFocusModel().getFocusedItem());
1084
1085 keyboard.doKeyPress(KeyCode.A, KeyModifier.getShortcutKey());
1086 assertEquals(0, listView.getSelectionModel().getSelectedIndex());
1087 assertEquals("Apple", listView.getSelectionModel().getSelectedItem());
1088 assertEquals(0, listView.getFocusModel().getFocusedIndex());
1089 assertEquals("Apple", listView.getFocusModel().getFocusedItem());
1090 }
1091
1092 @Test public void test_rt29930() {
1093 sm.setSelectionMode(SelectionMode.MULTIPLE);
1094
1095 sm.clearAndSelect(0);
1096
1097 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select rows [0,1]
1098 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select rows [0,1,2]
1099 assertTrue(isSelected(0,1,2));
1100 assertEquals(2, fm.getFocusedIndex());
1101 assertEquals(0, getAnchor());
1102
1103 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), PlatformUtil.isMac() ? KeyModifier.CTRL : null); // set new anchor point
1104 assertTrue(isSelected(0,1));
1105 assertEquals(2, fm.getFocusedIndex());
1106 assertEquals(2, getAnchor());
1107
1108 keyboard.doDownArrowPress(KeyModifier.SHIFT); // select rows [2,3]
1109 assertTrue(isSelected(2,3));
1110 assertTrue(isNotSelected(0,1));
1111 assertEquals(3, fm.getFocusedIndex());
1112 assertEquals(2, getAnchor());
1113 }
1114
1115 private int rt29849_start_count = 0;
1116 private int rt29849_cancel_count = 0;
1117 @Test public void test_rt29849() {
1118 listView.setEditable(true);
1119
1120 listView.setOnEditStart(t -> {
1121 rt29849_start_count++;
1122 });
1123 listView.setOnEditCancel(t -> {
1124 rt29849_cancel_count++;
1125 });
1126
1127 // initially the counts should be zero
1128 assertEquals(0, rt29849_start_count);
1129 assertEquals(0, rt29849_cancel_count);
1130
1131 IndexedCell cell = VirtualFlowTestUtils.getCell(listView, 0);
1132 assertTrue(cell.isEditable());
1133 assertFalse(cell.isEditing());
1134 assertEquals(0, cell.getIndex());
1135
1136 // do an edit, start count should be one, cancel still zero
1137 listView.edit(0);
1138 assertTrue(cell.isEditing());
1139 assertEquals(1, rt29849_start_count);
1140 assertEquals(0, rt29849_cancel_count);
1141
1142 // cancel edit, now both counts should be 1
1143 keyboard.doKeyPress(KeyCode.ESCAPE);
1144 assertFalse(cell.isEditing());
1145 assertEquals(1, rt29849_start_count);
1146 assertEquals(1, rt29849_cancel_count);
1147 }
1148
1149 private int rt31577_count = 0;
1150 @Test public void test_rt31577() {
1151 final MultipleSelectionModel sm = listView.getSelectionModel();
1152 sm.setSelectionMode(SelectionMode.SINGLE);
1153 sm.clearSelection();
1154
1155 // the actual bug is that the selectedItem property does not fire an
1156 // event when the selected items list changes (due to deselection).
1157 // It actually does always contain the right value - it just doesn't
1158 // let anyone know it!
1159 sm.selectedItemProperty().addListener(observable -> {
1160 rt31577_count++;
1161 });
1162
1163 assertTrue(sm.getSelectedItems().isEmpty());
1164 assertFalse(sm.isSelected(1));
1165 assertEquals(0, rt31577_count);
1166
1167 // select the first row
1168 keyboard.doKeyPress(KeyCode.KP_DOWN);
1169 assertEquals(1, sm.getSelectedItems().size());
1170 assertTrue(sm.isSelected(0));
1171 assertTrue(sm.getSelectedItems().contains("1"));
1172 assertEquals("1", sm.getSelectedItem());
1173 assertEquals(1, rt31577_count);
1174
1175 // deselect the row
1176 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.CTRL,
1177 Utils.isMac() ? KeyModifier.getShortcutKey() : null);
1178 assertTrue(sm.getSelectedItems().isEmpty());
1179 assertFalse(sm.isSelected(1));
1180 assertNull(sm.getSelectedItem());
1181 assertEquals(2, rt31577_count);
1182 }
1183
1184 @Test public void test_rt32383_pageDown() {
1185 // this test requires a lot of data
1186 listView.getItems().clear();
1187 for (int i = 0; i < 100; i++) {
1188 listView.getItems().add("Row " + i);
1189 }
1190
1191 final MultipleSelectionModel sm = listView.getSelectionModel();
1192 sm.setSelectionMode(SelectionMode.SINGLE);
1193 sm.clearAndSelect(0);
1194
1195 final String initialFocusOwner = fm.getFocusedItem();
1196
1197 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.getShortcutKey());
1198 Toolkit.getToolkit().firePulse();
1199 final String newFocusOwner = fm.getFocusedItem();
1200 assertNotSame(initialFocusOwner, newFocusOwner);
1201
1202 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.getShortcutKey());
1203 Toolkit.getToolkit().firePulse();
1204 final String nextFocusOwner = fm.getFocusedItem();
1205 assertNotSame(initialFocusOwner, nextFocusOwner);
1206 assertNotSame(newFocusOwner, nextFocusOwner);
1207 }
1208
1209 @Test public void test_rt32383_pageUp() {
1210 // this test requires a lot of data
1211 listView.getItems().clear();
1212 for (int i = 0; i < 100; i++) {
1213 listView.getItems().add("Row " + i);
1214 }
1215
1216 final int lastIndex = 99;
1217
1218 final MultipleSelectionModel sm = listView.getSelectionModel();
1219 sm.setSelectionMode(SelectionMode.SINGLE);
1220 sm.clearAndSelect(lastIndex);
1221
1222 // need to make sure we scroll down to the bottom!
1223 listView.scrollTo(lastIndex);
1224 Toolkit.getToolkit().firePulse();
1225
1226 assertEquals(lastIndex, sm.getSelectedIndex());
1227 assertEquals(lastIndex, fm.getFocusedIndex());
1228
1229 final String initialFocusOwner = fm.getFocusedItem();
1230
1231 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.getShortcutKey());
1232 Toolkit.getToolkit().firePulse();
1233 final String newFocusOwner = fm.getFocusedItem();
1234 assertNotSame(initialFocusOwner, newFocusOwner);
1235
1236 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.getShortcutKey());
1237 Toolkit.getToolkit().firePulse();
1238 final String nextFocusOwner = fm.getFocusedItem();
1239 assertNotSame(initialFocusOwner, nextFocusOwner);
1240 assertNotSame(newFocusOwner, nextFocusOwner);
1241 }
1242
1243 @Test public void test_rt19053_pageUp() {
1244 final int items = 8;
1245 listView.getItems().clear();
1246 for (int i = 0; i < items; i++) {
1247 listView.getItems().add("Row " + i);
1248 }
1249
1250 final int middleIndex = items / 2;
1251
1252 final MultipleSelectionModel sm = listView.getSelectionModel();
1253 sm.setSelectionMode(SelectionMode.SINGLE);
1254 sm.clearAndSelect(middleIndex);
1255
1256 assertEquals(middleIndex, sm.getSelectedIndex());
1257
1258 final Object initialSelectionOwner = sm.getSelectedItem();
1259
1260 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1261 Toolkit.getToolkit().firePulse();
1262 final Object newSelectionOwner = sm.getSelectedItem();
1263 assertNotSame(initialSelectionOwner, newSelectionOwner);
1264
1265 // selection should go all the way to the top, but this bug
1266 // shows that instead it seems to stop midway - where the anchor is
1267 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1268 Toolkit.getToolkit().firePulse();
1269 assertEquals(0, fm.getFocusedIndex());
1270 assertEquals(0, sm.getSelectedIndex());
1271 final Object nextSelectionOwner = sm.getSelectedItem();
1272 assertNotSame(initialSelectionOwner, nextSelectionOwner);
1273 assertNotSame(newSelectionOwner, nextSelectionOwner);
1274 }
1275
1276 @Test public void test_rt19053_pageDown() {
1277 final int items = 8;
1278 listView.getItems().clear();
1279 for (int i = 0; i < items; i++) {
1280 listView.getItems().add("Row " + i);
1281 }
1282
1283 final int middleIndex = items / 2;
1284
1285 final MultipleSelectionModel sm = listView.getSelectionModel();
1286 sm.setSelectionMode(SelectionMode.SINGLE);
1287 sm.clearAndSelect(middleIndex);
1288
1289 assertEquals(middleIndex, sm.getSelectedIndex());
1290
1291 final Object initialSelectionOwner = sm.getSelectedItem();
1292
1293 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1294 Toolkit.getToolkit().firePulse();
1295 final Object newSelectionOwner = sm.getSelectedItem();
1296 assertNotSame(initialSelectionOwner, newSelectionOwner);
1297
1298 // selection should go all the way to the bottom, but this bug
1299 // shows that instead it seems to stop midway - where the anchor is
1300 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1301 Toolkit.getToolkit().firePulse();
1302 assertEquals(items - 1, fm.getFocusedIndex());
1303 assertEquals(items - 1, sm.getSelectedIndex());
1304 final Object nextSelectionOwner = sm.getSelectedItem();
1305 assertNotSame(initialSelectionOwner, nextSelectionOwner);
1306 assertNotSame(newSelectionOwner, nextSelectionOwner);
1307 }
1308
1309 @Ignore("Fix not yet implemented")
1310 @Test public void test_rt20641_pageUp() {
1311 final int items = 20;
1312 listView.getItems().clear();
1313 for (int i = 0; i < items; i++) {
1314 listView.getItems().add("Row " + i);
1315 }
1316
1317 final MultipleSelectionModel sm = listView.getSelectionModel();
1318 sm.setSelectionMode(SelectionMode.MULTIPLE);
1319 sm.clearAndSelect(0);
1320 assertEquals(0, sm.getSelectedIndex());
1321
1322 final int selectedIndex0 = sm.getSelectedIndex();
1323
1324 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1325 Toolkit.getToolkit().firePulse();
1326 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1327 Toolkit.getToolkit().firePulse();
1328 final int selectedIndex1 = sm.getSelectedIndex();
1329 assertNotSame(selectedIndex0, selectedIndex1);
1330 assertTrue(selectedIndex0 < selectedIndex1);
1331
1332 // selection should go up one page, but bug shows it goes right back
1333 // to start
1334 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1335 Toolkit.getToolkit().firePulse();
1336 final int selectedIndex2 = sm.getSelectedIndex();
1337 assertNotSame(selectedIndex0, selectedIndex1);
1338 assertNotSame(selectedIndex0, selectedIndex2);
1339 assertTrue(selectedIndex2 < selectedIndex1);
1340 assertTrue(selectedIndex0 < selectedIndex2);
1341 }
1342
1343 @Ignore("Fix not yet implemented")
1344 @Test public void test_rt20641_pageDown() {
1345 final int items = 100;
1346 listView.getItems().clear();
1347 for (int i = 0; i < items; i++) {
1348 listView.getItems().add("Row " + i);
1349 }
1350
1351 final MultipleSelectionModel sm = listView.getSelectionModel();
1352 sm.setSelectionMode(SelectionMode.MULTIPLE);
1353 sm.clearAndSelect(items - 1);
1354 fm.setFocusedIndex(items - 1);
1355 assertEquals(items - 1, sm.getSelectedIndex());
1356 assertEquals(items - 1, fm.getFocusedIndex());
1357
1358 final int selectedIndex0 = sm.getSelectedIndex();
1359
1360 // need to make sure we scroll down to the bottom!
1361 listView.scrollTo(items - 1);
1362 Toolkit.getToolkit().firePulse();
1363
1364 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1365 Toolkit.getToolkit().firePulse();
1366 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1367 Toolkit.getToolkit().firePulse();
1368 final int selectedIndex1 = sm.getSelectedIndex();
1369 assertNotSame(selectedIndex0, selectedIndex1);
1370 assertTrue(selectedIndex0 > selectedIndex1);
1371
1372 // selection should go up down page, but bug shows it goes right back
1373 // to end (where selection started)
1374 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1375 Toolkit.getToolkit().firePulse();
1376 final int selectedIndex2 = sm.getSelectedIndex();
1377 assertNotSame(selectedIndex0, selectedIndex1);
1378 assertNotSame(selectedIndex0, selectedIndex2);
1379 assertTrue(selectedIndex2 > selectedIndex1);
1380 assertTrue(selectedIndex0 > selectedIndex2);
1381 }
1382
1383 @Test public void test_rt21375_scenario_1a_down() {
1384 final int items = 8;
1385 listView.getItems().clear();
1386 for (int i = 1; i <= items; i++) {
1387 listView.getItems().add("Row " + i);
1388 }
1389
1390 final MultipleSelectionModel sm = listView.getSelectionModel();
1391 sm.setSelectionMode(SelectionMode.MULTIPLE);
1392 sm.clearAndSelect(0);
1393
1394 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1395 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1396 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT);
1397 Toolkit.getToolkit().firePulse();
1398 assertTrue(isSelected(0,1,2,3));
1399 assertEquals(4, sm.getSelectedItems().size());
1400 }
1401
1402 @Test public void test_rt21375_scenario_1b_down() {
1403 final int items = 8;
1404 listView.getItems().clear();
1405 for (int i = 1; i <= items; i++) {
1406 listView.getItems().add("Row " + i);
1407 }
1408
1409 final MultipleSelectionModel sm = listView.getSelectionModel();
1410 sm.setSelectionMode(SelectionMode.MULTIPLE);
1411 sm.clearAndSelect(0);
1412
1413 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1414 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1415 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1416 Toolkit.getToolkit().firePulse();
1417 assertTrue(isSelected(0,1,2,3));
1418 assertEquals(4, sm.getSelectedItems().size());
1419 }
1420
1421 @Test public void test_rt21375_scenario_2_down() {
1422 final int items = 8;
1423 listView.getItems().clear();
1424 for (int i = 1; i <= items; i++) {
1425 listView.getItems().add("Row " + i);
1426 }
1427
1428 final MultipleSelectionModel sm = listView.getSelectionModel();
1429 sm.setSelectionMode(SelectionMode.MULTIPLE);
1430 sm.clearAndSelect(0);
1431
1432 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1433 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1434 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), PlatformUtil.isMac() ? KeyModifier.CTRL : null);
1435 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1436 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT);
1437 Toolkit.getToolkit().firePulse();
1438 assertTrue(isSelected(2,3,4));
1439 assertEquals(3, sm.getSelectedItems().size());
1440 }
1441
1442 @Test public void test_rt21375_scenario_3_down() {
1443 final int items = 8;
1444 listView.getItems().clear();
1445 for (int i = 1; i <= items; i++) {
1446 listView.getItems().add("Row " + i);
1447 }
1448
1449 final MultipleSelectionModel sm = listView.getSelectionModel();
1450 sm.setSelectionMode(SelectionMode.MULTIPLE);
1451 sm.clearAndSelect(0);
1452
1453 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1454 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1455 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), PlatformUtil.isMac() ? KeyModifier.CTRL : null);
1456 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1457 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1458 Toolkit.getToolkit().firePulse();
1459 assertTrue(isSelected(0,2,3,4));
1460 assertEquals(4, sm.getSelectedItems().size());
1461 }
1462
1463 @Test public void test_rt21375_scenario_1a_up() {
1464 final int items = 8;
1465 listView.getItems().clear();
1466 for (int i = 1; i <= items; i++) {
1467 listView.getItems().add("Row " + i);
1468 }
1469
1470 final MultipleSelectionModel sm = listView.getSelectionModel();
1471 sm.setSelectionMode(SelectionMode.MULTIPLE);
1472 sm.clearAndSelect(7);
1473
1474 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1475 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1476 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
1477 Toolkit.getToolkit().firePulse();
1478 assertTrue(isSelected(7,6,5,4));
1479 assertEquals(4, sm.getSelectedItems().size());
1480 }
1481
1482 @Test public void test_rt21375_scenario_1b_up() {
1483 final int items = 8;
1484 listView.getItems().clear();
1485 for (int i = 1; i <= items; i++) {
1486 listView.getItems().add("Row " + i);
1487 }
1488
1489 final MultipleSelectionModel sm = listView.getSelectionModel();
1490 sm.setSelectionMode(SelectionMode.MULTIPLE);
1491 sm.clearAndSelect(7);
1492
1493 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1494 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1495 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1496 Toolkit.getToolkit().firePulse();
1497 assertTrue(isSelected(7,6,5,4));
1498 assertEquals(4, sm.getSelectedItems().size());
1499 }
1500
1501 @Test public void test_rt21375_scenario_2_up() {
1502 final int items = 8;
1503 listView.getItems().clear();
1504 for (int i = 1; i <= items; i++) {
1505 listView.getItems().add("Row " + i);
1506 }
1507
1508 final MultipleSelectionModel sm = listView.getSelectionModel();
1509 sm.setSelectionMode(SelectionMode.MULTIPLE);
1510 sm.clearAndSelect(7);
1511
1512 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1513 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1514 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), PlatformUtil.isMac() ? KeyModifier.CTRL : null);
1515 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1516 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
1517 Toolkit.getToolkit().firePulse();
1518 assertTrue(isSelected(5,4,3));
1519 assertEquals(3, sm.getSelectedItems().size());
1520 }
1521
1522 @Test public void test_rt21375_scenario_3_up() {
1523 final int items = 8;
1524 listView.getItems().clear();
1525 for (int i = 1; i <= items; i++) {
1526 listView.getItems().add("Row " + i);
1527 }
1528
1529 final MultipleSelectionModel sm = listView.getSelectionModel();
1530 sm.setSelectionMode(SelectionMode.MULTIPLE);
1531 sm.clearAndSelect(7);
1532
1533 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1534 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1535 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), PlatformUtil.isMac() ? KeyModifier.CTRL : null);
1536 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1537 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1538 Toolkit.getToolkit().firePulse();
1539 assertTrue(isSelected(7,5,4,3));
1540 assertEquals(4, sm.getSelectedItems().size());
1541 }
1542
1543 @Test public void test_rt33301_multipleSelection_down() {
1544 final int items = 5;
1545 listView.getItems().clear();
1546 for (int i = 0; i < items; i++) {
1547 listView.getItems().add("Row " + i);
1548 }
1549
1550 final FocusModel fm = listView.getFocusModel();
1551 final MultipleSelectionModel sm = listView.getSelectionModel();
1552 sm.setSelectionMode(SelectionMode.MULTIPLE);
1553 sm.clearAndSelect(2);
1554
1555 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 3
1556 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 4
1557 Toolkit.getToolkit().firePulse();
1558 assertTrue(isNotSelected(0,1));
1559 assertTrue(isSelected(2,3,4));
1560 assertEquals(3, sm.getSelectedItems().size());
1561 assertTrue(fm.isFocused(4));
1562
1563 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1564 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1565 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1566 Toolkit.getToolkit().firePulse();
1567 assertTrue(isNotSelected(0,1));
1568 assertTrue(isSelected(2,3,4));
1569 assertEquals(3, sm.getSelectedItems().size());
1570 assertTrue("Focus index incorrectly at: " + fm.getFocusedIndex(), fm.isFocused(4));
1571 }
1572
1573 @Test public void test_rt33301_multipleSelection_up() {
1574 final int items = 5;
1575 listView.getItems().clear();
1576 for (int i = 0; i < items; i++) {
1577 listView.getItems().add("Row " + i);
1578 }
1579
1580 final FocusModel fm = listView.getFocusModel();
1581 final MultipleSelectionModel sm = listView.getSelectionModel();
1582 sm.setSelectionMode(SelectionMode.MULTIPLE);
1583 sm.clearAndSelect(2);
1584
1585 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 1
1586 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 0
1587 Toolkit.getToolkit().firePulse();
1588 assertTrue(isNotSelected(3,4));
1589 assertTrue(isSelected(0,1,2));
1590 assertEquals(3, sm.getSelectedItems().size());
1591 assertTrue(fm.isFocused(0));
1592
1593 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1594 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1595 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1596 Toolkit.getToolkit().firePulse();
1597 assertTrue(isNotSelected(3,4));
1598 assertTrue(isSelected(0,1,2));
1599 assertEquals(3, sm.getSelectedItems().size());
1600 assertTrue(fm.isFocused(0));
1601 }
1602
1603 @Test public void test_rt33301_singleSelection_down() {
1604 final int items = 5;
1605 listView.getItems().clear();
1606 for (int i = 0; i < items; i++) {
1607 listView.getItems().add("Row " + i);
1608 }
1609
1610 final FocusModel fm = listView.getFocusModel();
1611 final MultipleSelectionModel sm = listView.getSelectionModel();
1612 sm.setSelectionMode(SelectionMode.SINGLE);
1613 sm.clearAndSelect(2);
1614
1615 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 3
1616 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 4
1617 Toolkit.getToolkit().firePulse();
1618 assertTrue(isNotSelected(0,1,2,3));
1619 assertTrue(isSelected(4));
1620 assertEquals(1, sm.getSelectedItems().size());
1621 assertTrue(fm.isFocused(4));
1622
1623 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1624 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1625 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 4
1626 Toolkit.getToolkit().firePulse();
1627 assertTrue(isNotSelected(0,1,2,3));
1628 assertTrue(isSelected(4));
1629 assertEquals(1, sm.getSelectedItems().size());
1630 assertTrue(fm.isFocused(4));
1631 }
1632
1633 @Test public void test_rt33301_singleSelection_up() {
1634 final int items = 5;
1635 listView.getItems().clear();
1636 for (int i = 0; i < items; i++) {
1637 listView.getItems().add("Row " + i);
1638 }
1639
1640 final FocusModel fm = listView.getFocusModel();
1641 final MultipleSelectionModel sm = listView.getSelectionModel();
1642 sm.setSelectionMode(SelectionMode.SINGLE);
1643 sm.clearAndSelect(2);
1644
1645 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 1
1646 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // row 0
1647 Toolkit.getToolkit().firePulse();
1648 assertTrue(isNotSelected(1,2,3,4));
1649 assertTrue(isSelected(0));
1650 assertEquals(1, sm.getSelectedItems().size());
1651 assertTrue(fm.isFocused(0));
1652
1653 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1654 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1655 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT); // should stay at row 0
1656 Toolkit.getToolkit().firePulse();
1657 assertTrue(isNotSelected(1,2,3,4));
1658 assertTrue(isSelected(0));
1659 assertEquals(1, sm.getSelectedItems().size());
1660 assertTrue(fm.isFocused(0));
1661 }
1662
1663 @Test public void test_rt20915() {
1664 final FocusModel fm = listView.getFocusModel();
1665 final MultipleSelectionModel sm = listView.getSelectionModel();
1666
1667 sm.clearAndSelect(0);
1668 assertEquals(0, getAnchor());
1669
1670 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1671 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1672 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1673 Toolkit.getToolkit().firePulse();
1674 assertTrue(isNotSelected(1,2,3));
1675 assertTrue(isSelected(0));
1676 assertEquals(1, sm.getSelectedItems().size());
1677 assertTrue(fm.isFocused(3));
1678
1679 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1680 Toolkit.getToolkit().firePulse();
1681 assertTrue(isSelected(0,1,2,3));
1682 assertEquals(4, sm.getSelectedItems().size());
1683 assertTrue(fm.isFocused(3));
1684 }
1685
1686 @Test public void test_rt34200() {
1687 final int items = 100;
1688 listView.getItems().clear();
1689 for (int i = 0; i < items; i++) {
1690 listView.getItems().add("Row " + i);
1691 }
1692
1693 sm.clearAndSelect(99);
1694 listView.scrollTo(99);
1695 assertEquals(99, getAnchor());
1696 assertEquals(99, fm.getFocusedIndex());
1697
1698 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1699 Toolkit.getToolkit().firePulse();
1700 assertEquals(99, getAnchor());
1701 assertTrue(fm.getFocusedIndex() < 99);
1702 }
1703
1704 @Test public void test_rt34369() {
1705 final int items = 100;
1706 listView.getItems().clear();
1707 for (int i = 0; i < items; i++) {
1708 listView.getItems().add("Row " + i);
1709 }
1710
1711 sm.clearAndSelect(99);
1712 listView.scrollTo(99);
1713 assertEquals(99, getAnchor());
1714 assertEquals(99, fm.getFocusedIndex());
1715
1716 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1717 Toolkit.getToolkit().firePulse();
1718 assertEquals(99, getAnchor());
1719 assertTrue(fm.getFocusedIndex() < 99);
1720 }
1721
1722 @Test public void test_rt33894() {
1723 final int items = 5;
1724 listView.getItems().clear();
1725 for (int i = 0; i < items; i++) {
1726 listView.getItems().add("Row " + i);
1727 }
1728
1729 sm.clearAndSelect(1);
1730 assertEquals(1, getAnchor());
1731 assertEquals(1, fm.getFocusedIndex());
1732 assertEquals(1, sm.getSelectedIndex());
1733
1734 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1735 Toolkit.getToolkit().firePulse();
1736 assertEquals(1, getAnchor());
1737 assertEquals(2, fm.getFocusedIndex());
1738 assertEquals(1, sm.getSelectedIndex());
1739
1740 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1741 Toolkit.getToolkit().firePulse();
1742 assertEquals(2, getAnchor());
1743 assertEquals(2, fm.getFocusedIndex());
1744 assertEquals(2, sm.getSelectedIndex());
1745 assertTrue(isSelected(1, 2));
1746
1747 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1748 keyboard.doKeyPress(KeyCode.UP, KeyModifier.getShortcutKey());
1749 Toolkit.getToolkit().firePulse();
1750 assertEquals(2, getAnchor());
1751 assertEquals(0, fm.getFocusedIndex());
1752 assertEquals(2, sm.getSelectedIndex());
1753 assertTrue(isSelected(1, 2));
1754
1755 keyboard.doKeyPress(KeyCode.SPACE, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
1756 Toolkit.getToolkit().firePulse();
1757 assertEquals(0, getAnchor());
1758 assertEquals(0, fm.getFocusedIndex());
1759 assertEquals(0, sm.getSelectedIndex());
1760 assertTrue(isSelected(0, 1, 2));
1761 }
1762
1763 @Test public void test_rt34425() {
1764 final int items = 5;
1765 listView.getItems().clear();
1766 for (int i = 0; i < items; i++) {
1767 listView.getItems().add("Row " + i);
1768 }
1769
1770 sm.clearAndSelect(1);
1771 assertEquals(1, getAnchor());
1772 assertEquals(1, fm.getFocusedIndex());
1773 assertEquals(1, sm.getSelectedIndex());
1774
1775 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.getShortcutKey());
1776 Toolkit.getToolkit().firePulse();
1777 assertEquals(1, getAnchor());
1778 assertEquals(2, fm.getFocusedIndex());
1779 assertEquals(1, sm.getSelectedIndex());
1780
1781 keyboard.doKeyPress(KeyCode.SPACE);
1782 Toolkit.getToolkit().firePulse();
1783 assertEquals(2, getAnchor());
1784 assertEquals(2, fm.getFocusedIndex());
1785 assertEquals(2, sm.getSelectedIndex());
1786 assertTrue(isSelected(1, 2));
1787 }
1788
1789 @Test public void test_rt34407_down_down_up() {
1790 final int items = 100;
1791 listView.getItems().clear();
1792 for (int i = 0; i < items; i++) {
1793 listView.getItems().add("Row " + i);
1794 }
1795 listView.setPrefHeight(130); // roughly room for four rows
1796
1797 // this stageLoader is needed....although right now I'm not sure why
1798 StageLoader sl = new StageLoader(listView);
1799 final FocusModel fm = listView.getFocusModel();
1800 final MultipleSelectionModel sm = listView.getSelectionModel();
1801 sm.setSelectionMode(SelectionMode.MULTIPLE);
1802
1803 sm.clearAndSelect(0);
1804 fm.focus(0);
1805 assertEquals(0, getAnchor());
1806 assertTrue(fm.isFocused(0));
1807 assertTrue(sm.isSelected(0));
1808 assertFalse(sm.isSelected(1));
1809
1810 // we expect the final Page-up to return us back to this selected index and with the same number of selected indices
1811 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1812 final int leadSelectedIndex = sm.getSelectedIndex();
1813 final int selectedIndicesCount = sm.getSelectedIndices().size();
1814 assertEquals(6, leadSelectedIndex);
1815 assertEquals(6, fm.getFocusedIndex());
1816 assertEquals(7, selectedIndicesCount);
1817
1818 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1819 assertEquals(leadSelectedIndex * 2, sm.getSelectedIndex());
1820 assertEquals(leadSelectedIndex * 2, fm.getFocusedIndex());
1821 assertEquals(selectedIndicesCount * 2 - 1, sm.getSelectedIndices().size());
1822
1823 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1824 assertEquals(leadSelectedIndex, sm.getSelectedIndex());
1825 assertEquals(leadSelectedIndex, fm.getFocusedIndex());
1826 assertEquals(selectedIndicesCount, sm.getSelectedIndices().size());
1827
1828 sl.dispose();
1829 }
1830
1831 @Test public void test_rt34407_up_up_down() {
1832 final int items = 100;
1833 listView.getItems().clear();
1834 for (int i = 0; i < items; i++) {
1835 listView.getItems().add("Row " + i);
1836 }
1837 listView.setPrefHeight(130); // roughly room for four rows
1838
1839 sm.setSelectionMode(SelectionMode.MULTIPLE);
1840
1841 sm.clearAndSelect(99);
1842 fm.focus(99);
1843 listView.scrollTo(99);
1844 Toolkit.getToolkit().firePulse();
1845
1846 assertEquals(99, getAnchor());
1847 assertTrue(fm.isFocused(99));
1848 assertTrue(sm.isSelected(99));
1849 assertFalse(sm.isSelected(98));
1850
1851 // we expect the final Page-down to return us back to this selected index and with the same number of selected indices
1852 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1853 final int leadSelectedIndex = sm.getSelectedIndex();
1854 final int selectedIndicesCount = sm.getSelectedIndices().size();
1855 final int diff = 99 - leadSelectedIndex;
1856 assertEquals(99 - diff, leadSelectedIndex);
1857 assertEquals(99 - diff, fm.getFocusedIndex());
1858 assertEquals(7, selectedIndicesCount);
1859
1860 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
1861 assertEquals(99 - diff * 2, sm.getSelectedIndex());
1862 assertEquals(selectedIndicesCount * 2 - 1, sm.getSelectedIndices().size());
1863
1864 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
1865 assertEquals(leadSelectedIndex, sm.getSelectedIndex());
1866 assertEquals(selectedIndicesCount, sm.getSelectedIndices().size());
1867 }
1868
1869 @Test public void test_rt34768() {
1870 listView.getSelectionModel().setSelectionMode(SelectionMode.MULTIPLE);
1871 listView.getItems().clear();
1872
1873 // no need for an assert here - we're testing for an AIOOBE
1874 keyboard.doKeyPress(KeyCode.A, KeyModifier.getShortcutKey());
1875 }
1876
1877 @Test public void test_rt35853_multipleSelection_shiftDown() {
1878 final int items = 10;
1879 listView.getItems().clear();
1880 for (int i = 0; i < items; i++) {
1881 listView.getItems().add("Row " + i);
1882 }
1883
1884 sm.setSelectionMode(SelectionMode.MULTIPLE);
1885
1886 sm.clearAndSelect(5);
1887 assertEquals(5, getAnchor());
1888 assertTrue(fm.isFocused(5));
1889 assertTrue(sm.isSelected(5));
1890
1891 sm.selectedIndexProperty().addListener(observable -> {
1892 // we expect only one selected index change event, from 5 to 4
1893 assertEquals(4, sm.getSelectedIndex());
1894 });
1895
1896 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
1897 assertEquals(5, getAnchor());
1898 assertTrue(fm.isFocused(4));
1899 assertTrue(sm.isSelected(4));
1900 assertTrue(sm.isSelected(5));
1901 }
1902
1903 @Test public void test_rt35853_multipleSelection_noShiftDown() {
1904 final int items = 10;
1905 listView.getItems().clear();
1906 for (int i = 0; i < items; i++) {
1907 listView.getItems().add("Row " + i);
1908 }
1909
1910 sm.setSelectionMode(SelectionMode.MULTIPLE);
1911
1912 sm.clearAndSelect(5);
1913 assertEquals(5, getAnchor());
1914 assertTrue(fm.isFocused(5));
1915 assertTrue(sm.isSelected(5));
1916
1917 sm.selectedIndexProperty().addListener(observable -> {
1918 // we expect only one selected index change event, from 5 to 4
1919 assertEquals(4, sm.getSelectedIndex());
1920 });
1921
1922 keyboard.doKeyPress(KeyCode.UP);
1923 assertEquals(4, getAnchor());
1924 assertTrue(fm.isFocused(4));
1925 assertTrue(sm.isSelected(4));
1926 assertFalse(sm.isSelected(5));
1927 }
1928
1929 @Test public void test_rt35853_singleSelection_shiftDown() {
1930 final int items = 10;
1931 listView.getItems().clear();
1932 for (int i = 0; i < items; i++) {
1933 listView.getItems().add("Row " + i);
1934 }
1935
1936 sm.setSelectionMode(SelectionMode.SINGLE);
1937
1938 sm.clearAndSelect(5);
1939 assertEquals(5, getAnchor());
1940 assertTrue(fm.isFocused(5));
1941 assertTrue(sm.isSelected(5));
1942
1943 sm.selectedIndexProperty().addListener(observable -> {
1944 // we expect only one selected index change event, from 5 to 4
1945 assertEquals(4, sm.getSelectedIndex());
1946 });
1947
1948 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
1949 assertEquals(4, getAnchor());
1950 assertTrue(fm.isFocused(4));
1951 assertTrue(sm.isSelected(4));
1952 assertFalse(sm.isSelected(5));
1953 }
1954
1955 @Test public void test_rt35853_singleSelection_noShiftDown() {
1956 final int items = 10;
1957 listView.getItems().clear();
1958 for (int i = 0; i < items; i++) {
1959 listView.getItems().add("Row " + i);
1960 }
1961
1962 sm.setSelectionMode(SelectionMode.SINGLE);
1963
1964 sm.clearAndSelect(5);
1965 assertEquals(5, getAnchor());
1966 assertTrue(fm.isFocused(5));
1967 assertTrue(sm.isSelected(5));
1968
1969 sm.selectedIndexProperty().addListener(observable -> {
1970 // we expect only one selected index change event, from 5 to 4
1971 assertEquals(4, sm.getSelectedIndex());
1972 });
1973
1974 keyboard.doKeyPress(KeyCode.UP);
1975 assertEquals(4, getAnchor());
1976 assertTrue(fm.isFocused(4));
1977 assertTrue(sm.isSelected(4));
1978 assertFalse(sm.isSelected(5));
1979 }
1980
1981 @Test public void test_rt36800() {
1982 // get the current exception handler before replacing with our own,
1983 // as ListListenerHelp intercepts the exception otherwise
1984 final Thread.UncaughtExceptionHandler exceptionHandler = Thread.currentThread().getUncaughtExceptionHandler();
1985 Thread.currentThread().setUncaughtExceptionHandler((t, e) -> fail("We don't expect any exceptions in this test!"));
1986
1987 final int items = 10;
1988 listView.getItems().clear();
1989 for (int i = 0; i < items; i++) {
1990 listView.getItems().add("Row " + i);
1991 }
1992
1993 sm.setSelectionMode(SelectionMode.SINGLE);
1994
1995 sm.clearAndSelect(5);
1996 assertEquals(5, getAnchor());
1997 assertTrue(fm.isFocused(5));
1998 assertTrue(sm.isSelected(5));
1999
2000 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // 4
2001 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // 3
2002 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // 2
2003 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // 1
2004 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // 0
2005 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT); // bug time?
2006
2007 assertEquals(0, getAnchor());
2008 assertTrue(fm.isFocused(0));
2009 assertTrue(sm.isSelected(0));
2010 assertFalse(sm.isSelected(1));
2011 assertFalse(sm.isSelected(2));
2012 assertFalse(sm.isSelected(3));
2013 assertFalse(sm.isSelected(4));
2014 assertFalse(sm.isSelected(5));
2015
2016 // reset the exception handler
2017 Thread.currentThread().setUncaughtExceptionHandler(exceptionHandler);
2018 }
2019
2020 @Test public void test_rt_36942() {
2021 // get the current exception handler before replacing with our own,
2022 // as ListListenerHelp intercepts the exception otherwise
2023 final Thread.UncaughtExceptionHandler exceptionHandler = Thread.currentThread().getUncaughtExceptionHandler();
2024 Thread.currentThread().setUncaughtExceptionHandler((t, e) -> fail("We don't expect any exceptions in this test!"));
2025
2026 final int items = 3;
2027 listView.getItems().clear();
2028 for (int i = 0; i < items; i++) {
2029 listView.getItems().add("Row " + i);
2030 }
2031
2032 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2033 sm.setSelectionMode(SelectionMode.MULTIPLE);
2034 ObservableList<String> selectedItems = sm.getSelectedItems();
2035
2036 ListView<String> selectedItemsListView = new ListView<>(selectedItems);
2037
2038 HBox root = new HBox(5, listView, selectedItemsListView);
2039
2040 StageLoader sl = new StageLoader(root);
2041
2042 sm.select(0);
2043 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT); // 0,1
2044 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT); // 0,1,2
2045 keyboard.doKeyPress(KeyCode.DOWN, KeyModifier.SHIFT); // 0,1,2,Exception?
2046
2047 sl.dispose();
2048
2049 // reset the exception handler
2050 Thread.currentThread().setUncaughtExceptionHandler(exceptionHandler);
2051 }
2052
2053 @Test public void test_rt_37130_pageUpAtTop() {
2054 final int items = 100;
2055 listView.getItems().clear();
2056 for (int i = 0; i < items; i++) {
2057 listView.getItems().add("Row " + i);
2058 }
2059
2060 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2061 sm.setSelectionMode(SelectionMode.MULTIPLE);
2062
2063 StageLoader sl = new StageLoader(listView);
2064
2065 sm.select(5);
2066 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
2067 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
2068
2069 sl.dispose();
2070 }
2071
2072 @Test public void test_rt_37130_pageUpAtBottom() {
2073 final int items = 100;
2074 listView.getItems().clear();
2075 for (int i = 0; i < items; i++) {
2076 listView.getItems().add("Row " + i);
2077 }
2078
2079 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2080 sm.setSelectionMode(SelectionMode.MULTIPLE);
2081
2082 StageLoader sl = new StageLoader(listView);
2083
2084 sm.select(95);
2085 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
2086 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.SHIFT);
2087
2088 sl.dispose();
2089 }
2090
2091 @Test public void test_rt_37130_pageDownAtTop() {
2092 final int items = 100;
2093 listView.getItems().clear();
2094 for (int i = 0; i < items; i++) {
2095 listView.getItems().add("Row " + i);
2096 }
2097
2098 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2099 sm.setSelectionMode(SelectionMode.MULTIPLE);
2100
2101 StageLoader sl = new StageLoader(listView);
2102
2103 sm.select(5);
2104 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
2105 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
2106
2107 sl.dispose();
2108 }
2109
2110 @Test public void test_rt_37130_pageDownAtBottom() {
2111 final int items = 100;
2112 listView.getItems().clear();
2113 for (int i = 0; i < items; i++) {
2114 listView.getItems().add("Row " + i);
2115 }
2116
2117 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2118 sm.setSelectionMode(SelectionMode.MULTIPLE);
2119
2120 StageLoader sl = new StageLoader(listView);
2121
2122 sm.select(95);
2123 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
2124 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.SHIFT);
2125
2126 sl.dispose();
2127 }
2128
2129 private int rt_39088_indices_event_count = 0;
2130 private int rt_39088_items_event_count = 0;
2131 @Test public void test_rt_39088() {
2132 listView.getItems().clear();
2133 for (int i = 0; i < 4; i++) {
2134 listView.getItems().add("Row " + i);
2135 }
2136
2137 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2138 sm.setSelectionMode(SelectionMode.MULTIPLE);
2139
2140 ObservableList<Integer> indices = sm.getSelectedIndices();
2141 ObservableList<String> items = sm.getSelectedItems();
2142
2143 indices.addListener((ListChangeListener<Integer>) change -> rt_39088_indices_event_count++);
2144 items.addListener((ListChangeListener<String>) change -> rt_39088_items_event_count++);
2145
2146 StageLoader sl = new StageLoader(listView);
2147
2148 assertEquals(0, rt_39088_indices_event_count);
2149 assertEquals(0, rt_39088_items_event_count);
2150 assertEquals(0, indices.size());
2151 assertEquals(0, items.size());
2152
2153 sm.select(3);
2154 assertEquals(1, rt_39088_indices_event_count);
2155 assertEquals(1, rt_39088_items_event_count);
2156 assertEquals(1, indices.size());
2157 assertEquals(1, items.size());
2158
2159 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
2160 assertEquals(2, rt_39088_indices_event_count);
2161 assertEquals(2, rt_39088_items_event_count);
2162 assertEquals(2, indices.size());
2163 assertEquals(2, items.size());
2164
2165 // this is where the test fails...
2166 keyboard.doKeyPress(KeyCode.UP, KeyModifier.SHIFT);
2167 assertEquals(3, rt_39088_indices_event_count);
2168 assertEquals(3, rt_39088_items_event_count);
2169 assertEquals(3, indices.size());
2170 assertEquals(3, items.size());
2171
2172 sl.dispose();
2173 }
2174
2175 @Test public void test_rt_27709_singleSelection_rowSelection() {
2176 test_rt_27709(SelectionMode.SINGLE, false);
2177 }
2178
2179 @Test public void test_rt_27709_multipleSelection_rowSelection() {
2180 test_rt_27709(SelectionMode.MULTIPLE, false);
2181 }
2182
2183 @Test public void test_rt_27709_singleSelection_rowSelection_resetSelection() {
2184 test_rt_27709(SelectionMode.SINGLE, true);
2185 }
2186
2187 @Test public void test_rt_27709_multipleSelection_rowSelection_resetSelection() {
2188 test_rt_27709(SelectionMode.MULTIPLE, true);
2189 }
2190
2191 private void test_rt_27709(SelectionMode mode, boolean resetSelection) {
2192 ObservableList<String> itemsList = FXCollections.observableArrayList();
2193 for (int i = 0; i < 10; i++) {
2194 itemsList.add("Row " + i);
2195 }
2196
2197 listView.setItems(itemsList);
2198
2199 MultipleSelectionModel<String> sm = listView.getSelectionModel();
2200 sm.setSelectionMode(mode);
2201
2202 ObservableList<Integer> indices = sm.getSelectedIndices();
2203
2204 int expectedSize = mode == SelectionMode.SINGLE ? 1 : 10;
2205 int lookupIndex = mode == SelectionMode.SINGLE ? 0 : 9;
2206
2207 sm.select(0);
2208 assertEquals(1, indices.size());
2209
2210 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
2211 assertEquals(expectedSize, indices.size());
2212 assertEquals(9, (int) indices.get(lookupIndex));
2213
2214 if (resetSelection) {
2215 sm.clearAndSelect(9);
2216 int anchor = ListCellBehavior.getAnchor(listView, null);
2217 assertEquals(9, anchor);
2218 } else {
2219 expectedSize = 1;
2220 }
2221
2222 keyboard.doKeyPress(KeyCode.HOME, KeyModifier.SHIFT);
2223 assertEquals(expectedSize, indices.size());
2224 assertTrue(debug(),sm.isSelected(0));
2225
2226 if (resetSelection) {
2227 sm.clearAndSelect(0);
2228
2229 int anchor = ListCellBehavior.getAnchor(listView, null);
2230 assertEquals(0, anchor);
2231 } else {
2232 expectedSize = mode == SelectionMode.SINGLE ? 1 : 10;
2233 }
2234
2235 keyboard.doKeyPress(KeyCode.END, KeyModifier.SHIFT);
2236 assertEquals(expectedSize, indices.size());
2237 assertTrue(sm.isSelected(9));
2238 }
2239
2240 @Test public void test_rt_24865_moveDownwards() {
2241 listView.getItems().clear();
2242 for (int i = 0; i < 100; i++) {
2243 listView.getItems().add("Row " + i);
2244 }
2245
2246 Toolkit.getToolkit().firePulse();
2247
2248 ObservableList<Integer> indices = sm.getSelectedIndices();
2249
2250 sm.select(0);
2251 assertTrue(isSelected(0));
2252 assertTrue(fm.isFocused(0));
2253 assertEquals(1, indices.size());
2254 assertEquals(0, (int) ListCellBehavior.getAnchor(listView, -1));
2255
2256 keyboard.doDownArrowPress(KeyModifier.SHIFT);
2257 keyboard.doDownArrowPress(KeyModifier.SHIFT);
2258 keyboard.doDownArrowPress(KeyModifier.SHIFT);
2259 assertTrue(isSelected(0, 1, 2, 3));
2260 assertTrue(fm.isFocused(3));
2261 assertEquals(4, indices.size());
2262 assertEquals(0, (int) ListCellBehavior.getAnchor(listView, -1));
2263
2264 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
2265 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
2266 keyboard.doDownArrowPress(KeyModifier.getShortcutKey());
2267 assertTrue(isSelected(0, 1, 2, 3));
2268 assertTrue(isNotSelected(4, 5, 6, 7, 8, 9));
2269 assertTrue(fm.isFocused(6));
2270 assertEquals(4, indices.size());
2271 assertEquals(0, (int) ListCellBehavior.getAnchor(listView, -1));
2272
2273 // main point of test: selection between the last index (3) and the focus
2274 // index (6) should now be true
2275 keyboard.doKeyPress(KeyCode.PAGE_DOWN, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
2276 final int selectedRowCount = indices.size();
2277 for (int i = 0; i < selectedRowCount; i++) {
2278 assertTrue(isSelected(i));
2279 }
2280 assertTrue(fm.isFocused(selectedRowCount - 1));
2281 assertEquals(0, (int) ListCellBehavior.getAnchor(listView, -1));
2282
2283 keyboard.doDownArrowPress(KeyModifier.SHIFT);
2284 int newSelectedRowCount = selectedRowCount + 1;
2285 for (int i = 0; i < newSelectedRowCount; i++) {
2286 assertTrue(isSelected(i));
2287 }
2288 assertTrue(fm.isFocused(newSelectedRowCount - 1));
2289 assertEquals(0, (int) ListCellBehavior.getAnchor(listView, -1));
2290 }
2291
2292 @Test public void test_rt_24865_moveUpwards() {
2293 listView.getItems().clear();
2294 for (int i = 0; i < 100; i++) {
2295 listView.getItems().add("Row " + i);
2296 }
2297
2298 Toolkit.getToolkit().firePulse();
2299
2300 ObservableList<Integer> indices = sm.getSelectedIndices();
2301
2302 sm.select(50);
2303 listView.scrollTo(50);
2304
2305 Toolkit.getToolkit().firePulse();
2306
2307 assertTrue(isSelected(50));
2308 assertTrue(fm.isFocused(50));
2309 assertEquals(1, indices.size());
2310 assertEquals(50, (int) ListCellBehavior.getAnchor(listView, -1));
2311
2312 keyboard.doUpArrowPress(KeyModifier.SHIFT);
2313 keyboard.doUpArrowPress(KeyModifier.SHIFT);
2314 keyboard.doUpArrowPress(KeyModifier.SHIFT);
2315 assertTrue(isSelected(50, 49, 48, 47));
2316 assertTrue(fm.isFocused(47));
2317 assertEquals(4, indices.size());
2318 assertEquals(50, (int) ListCellBehavior.getAnchor(listView, -1));
2319
2320 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
2321 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
2322 keyboard.doUpArrowPress(KeyModifier.getShortcutKey());
2323 assertTrue(isSelected(50, 49, 48, 47));
2324 assertTrue(isNotSelected(46, 45, 44, 43, 42, 41));
2325 assertTrue(fm.isFocused(44));
2326 assertEquals(4, indices.size());
2327 assertEquals(50, (int) ListCellBehavior.getAnchor(listView, -1));
2328
2329 // main point of test: selection between the last index (47) and the focus
2330 // index (44) should now be true
2331 keyboard.doKeyPress(KeyCode.PAGE_UP, KeyModifier.getShortcutKey(), KeyModifier.SHIFT);
2332 final int selectedRowCount = indices.size();
2333 for (int i = 0; i < selectedRowCount; i++) {
2334 assertTrue(isSelected(50 - i));
2335 }
2336 assertTrue(fm.isFocused(50 - selectedRowCount + 1));
2337 assertEquals(50, (int) ListCellBehavior.getAnchor(listView, -1));
2338
2339 keyboard.doUpArrowPress(KeyModifier.SHIFT);
2340 int newSelectedRowCount = selectedRowCount + 1;
2341 for (int i = 0; i < newSelectedRowCount; i++) {
2342 assertTrue(isSelected(50 - i));
2343 }
2344 assertTrue(fm.isFocused(50 - newSelectedRowCount + 1));
2345 assertEquals(50, (int) ListCellBehavior.getAnchor(listView, -1));
2346 }
2347 }