1 /*
2 * Copyright (c) 2014, 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 package javafx.scene.control.test.combobox;
26
27 import client.test.ScreenshotCheck;
28 import client.test.Smoke;
29 import java.text.Format;
30 import java.text.MessageFormat;
31 import java.util.ArrayList;
32 import java.util.EnumSet;
33 import java.util.HashMap;
34 import java.util.List;
35 import java.util.Map;
36 import javafx.beans.value.ObservableValue;
37 import javafx.collections.FXCollections;
38 import javafx.collections.ObservableList;
39 import javafx.commons.SortValidator;
40 import javafx.event.Event;
41 import javafx.event.EventHandler;
42 import javafx.geometry.Orientation;
43 import javafx.scene.Node;
44 import javafx.scene.control.ComboBox;
45 import javafx.scene.control.Label;
46 import javafx.scene.control.ListCell;
47 import javafx.scene.control.ListView;
48 import javafx.scene.control.ScrollBar;
49 import javafx.scene.control.TextField;
50 import static javafx.scene.control.test.combobox.ComboBoxApp.*;
51 import static javafx.scene.control.test.combobox.TestBase.ITER;
52 import javafx.scene.control.test.combobox.TestBase.Properties;
53 import static javafx.scene.control.test.combobox.TestBase.testedControl;
54 import javafx.scene.control.test.util.PropertyTest;
55 import javafx.scene.control.test.utils.CustomMultipleSelectionModel;
56 import javafx.scene.control.test.utils.CustomStringConverter;
57 import static javafx.scene.control.test.utils.CustomStringConverter.FROM_STRING_PREFIX;
58 import static javafx.scene.control.test.utils.CustomStringConverter.TO_STRING_PREFIX;
59 import javafx.scene.control.test.utils.ptables.AbstractPropertyController.SettingType;
60 import javafx.scene.shape.Polygon;
61 import javafx.scene.shape.Rectangle;
62 import javafx.util.Callback;
63 import javafx.util.StringConverter;
64 import javafx.util.converter.FormatStringConverter;
65 import org.jemmy.Point;
66 import org.jemmy.action.GetAction;
67 import org.jemmy.control.Wrap;
68 import org.jemmy.fx.ByStyleClass;
69 import org.jemmy.fx.ByText;
70 import org.jemmy.fx.NodeWrap;
71 import org.jemmy.fx.Root;
72 import org.jemmy.fx.control.ChoiceBoxWrap;
73 import org.jemmy.fx.control.ListItemWrap.ListItemByObjectLookup;
74 import org.jemmy.input.AbstractScroll;
75 import org.jemmy.interfaces.Keyboard.KeyboardButton;
76 import org.jemmy.interfaces.Keyboard.KeyboardButtons;
77 import org.jemmy.interfaces.Keyboard.KeyboardModifiers;
78 import org.jemmy.interfaces.Parent;
79 import org.jemmy.interfaces.Selectable;
80 import org.jemmy.interfaces.Text;
81 import org.jemmy.lookup.Lookup;
82 import org.jemmy.lookup.LookupCriteria;
83 import org.jemmy.resources.StringComparePolicy;
84 import org.jemmy.timing.State;
85 import static org.junit.Assert.*;
86 import org.junit.Test;
87 import org.junit.runner.RunWith;
88 import test.javaclient.shared.FilteredTestRunner;
89
90 /**
91 * @author Alexander Kirov
92 *
93 */
94 @RunWith(FilteredTestRunner.class)
95 public class ComboBoxTest extends TestBase {
96
97 @ScreenshotCheck
98 @Test(timeout = 300000)
99 public void editablePropertyTest() throws Throwable {
100 assertEquals((new ComboBox()).editableProperty().getValue(), false);
101
102 testedControl.getEnvironment().setTimeout(Wrap.WAIT_STATE_TIMEOUT, 2000);
103
104 for (SettingType btype : EnumSet.of(SettingType.BIDIRECTIONAL, SettingType.SETTER, SettingType.UNIDIRECTIONAL)) {
105 for (int i = 0; i < 4; i++) {
106 setPropertyByToggleClick(btype, Properties.editable);
107 checkEditable(i % 2 == 0 ? true : false);
108 checkScreenshot("ComboBox_editable_[" + (i % 2 == 0 ? true : false) + "]", testedControl);
109 }
110 }
111
112 throwScreenshotError();
113 }
114
115 @Smoke
116 @Test(timeout = 300000)
117 public void showingPropertyTest() throws InterruptedException {
118 assertEquals((new ComboBox()).showingProperty().getValue(), false);
119
120 clickDropDownButton();
121 checkPopupShowing(true);
122 clickDropDownButton();
123 checkPopupShowing(false);
124 testedControl.mouse().click();
125 checkPopupShowing(true);
126 checkButtonForPopupShowing(KeyboardButtons.F4);
127 checkButtonForPopupShowing(KeyboardButtons.DOWN, KeyboardModifiers.ALT_DOWN_MASK);
128 checkButtonForPopupShowing(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
129
130 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
131 //We switched property and need to wait, until it will be applied, to click on buttons.
132 Thread.sleep(1000);
133
134 testedControl.mouse().click();
135 checkPopupShowing(false);
136 clickDropDownButton();
137 checkPopupShowing(true);
138 clickDropDownButton();
139 checkPopupShowing(false);
140 }
141
142 private void checkButtonForPopupShowing(KeyboardButtons button, KeyboardModifiers... mdfs) throws InterruptedException {
143 testedControl.keyboard().pushKey(button, mdfs);
144 checkPopupShowing(false);
145 testedControl.keyboard().pushKey(button, mdfs);
146 checkPopupShowing(true);
147 }
148
149 @Smoke
150 @Test(timeout = 300000)
151 public void armedTest() {
152 assertEquals((new ComboBox()).armedProperty().getValue(), false);
153
154 testedControl.mouse().move();
155 testedControl.mouse().press();
156
157 checkTextFieldText(Properties.armed, "true");
158
159 testedControl.mouse().release();
160
161 checkTextFieldText(Properties.armed, "false");
162 checkTextFieldText(Properties.showing, "true");
163
164 testedControl.mouse().press();
165
166 checkTextFieldText(Properties.armed, "true");
167 checkTextFieldText(Properties.showing, "false");
168
169 testedControl.mouse().release();
170
171 checkTextFieldText(Properties.armed, "false");
172 checkTextFieldText(Properties.showing, "false");
173
174 testedControl.mouse().press();
175 org.jemmy.Rectangle bounds = testedControl.getScreenBounds();
176 testedControl.mouse().move(new Point(bounds.getWidth() + 5, testedControl.getScreenBounds().getHeight() + 5));
177
178 checkTextFieldText(Properties.armed, "false");
179 }
180
181 @Smoke
182 @Test(timeout = 300000)//RT-18945
183 public void valuePropertyTest() throws InterruptedException {
184 assertEquals((new ComboBox()).getValue(), null);
185
186 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
187
188 setPropertyByTextField(SettingType.BIDIRECTIONAL, Properties.value, NEW_VALUE_1);
189 checkTextFieldText(Properties.value, NEW_VALUE_1);
190 assertEquals(getTextFieldText(), NEW_VALUE_1);
191
192 setPropertyByTextField(SettingType.UNIDIRECTIONAL, Properties.value, NEW_VALUE_2);
193 checkTextFieldText(Properties.value, NEW_VALUE_2);
194 assertEquals(getTextFieldText(), NEW_VALUE_2);
195
196 setPropertyByTextField(SettingType.SETTER, Properties.value, NEW_VALUE_1);
197 checkTextFieldText(Properties.value, NEW_VALUE_1);
198 assertEquals(getTextFieldText(), NEW_VALUE_1);
199
200 switchOffBinding(SettingType.UNIDIRECTIONAL, Properties.value);
201
202 for (int i = 0; i < ITER; i++) {
203 addElement(String.valueOf(i), i);
204 }
205
206 for (int i = 0; i < ITER; i++) {
207 testedControl.as(Selectable.class).selector().select(String.valueOf(i));
208 assertEquals(getValue(), String.valueOf(i));
209 }
210
211 testedControl.as(Selectable.class).selector().select(String.valueOf(ITER - 1));
212
213 //Do some actions to change state of control and verify value
214 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
215 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
216 setPropertyByTextField(SettingType.BIDIRECTIONAL, Properties.promptText, "some text");
217 clickDropDownButton();
218 applyCustomSelectionModel();
219 applyCustomStringConverter();
220
221 assertEquals(getValue().toString(), "null");
222 assertEquals(getTextFieldText(), "");
223 }
224
225 @ScreenshotCheck
226 @Test(timeout = 300000)//RT-19225
227 public void promptPropertyTest() throws Throwable {
228 assertEquals((new ComboBox()).promptTextProperty().getValue(), null);
229
230 //move focus from control. otherwise, we will not see prompt.
231 requestFocusOnControl(testedControl);
232 testedControl.keyboard().pushKey(KeyboardButtons.TAB);
233
234 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
235
236 for (SettingType btype : EnumSet.of(SettingType.BIDIRECTIONAL, SettingType.SETTER, SettingType.UNIDIRECTIONAL)) {
237 setPropertyByTextField(btype, Properties.promptText, btype.name());
238 checkTextFieldText(Properties.promptText, btype.name());
239 assertEquals(btype.name(), getTextFieldPrompt());
240 checkScreenshot("ComboBox_PromptText_[" + btype.name() + "]", testedControl);
241 }
242 throwScreenshotError();
243 }
244
245 @ScreenshotCheck
246 @Test(timeout = 300000)
247 public void visibleRowCountPropertyTest() throws InterruptedException, Throwable {
248 assertEquals((long) (new ComboBox()).visibleRowCountProperty().getValue(), 10);
249
250 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 6);
251 checkTextFieldValue(Properties.visibleRowCount, 6);
252
253 addElements(1, 2, 3, 4, 5, 6, 7);
254
255 clickDropDownButton();
256 checkScrollBarVisibility(true);
257
258 Wrap<? extends ListView> list = getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap();
259 Wrap<? extends ListCell> cell = list.as(Parent.class, Node.class).lookup(ListCell.class, new ListItemByObjectLookup<String>("1")).wrap();
260 assertEquals(cell.getScreenBounds().getHeight() * 6, list.getScreenBounds().getHeight(), 4);
261
262 removeFromPos(2);
263
264 clickDropDownButton();
265 checkScrollBarVisibility(false);
266
267 setPropertyBySlider(SettingType.SETTER, Properties.visibleRowCount, 5);
268 checkTextFieldValue(Properties.visibleRowCount, 5);
269
270 clickDropDownButton();
271 checkScrollBarVisibility(true);
272 removeFromPos(5);
273
274 setPropertyBySlider(SettingType.UNIDIRECTIONAL, Properties.visibleRowCount, 4);
275 checkTextFieldValue(Properties.visibleRowCount, 4);
276
277 testedControl.as(Selectable.class).selector().select("2");
278
279 clickDropDownButton();
280 checkScrollBarVisibility(true);
281
282 checkScreenshot("ComboBox_visibleRowCount_4_visible_and_5_elements_and_3_removed", getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap());
283 throwScreenshotError();
284 }
285
286 @ScreenshotCheck
287 @Test(timeout = 300000)
288 public void emptyDropDownScreenshotTest() throws InterruptedException, Throwable {
289 clickDropDownButton();
290 checkPopupShowing(true);
291 checkScreenshot("ComboBox_emptyDropDown", getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap());
292 throwScreenshotError();
293 }
294
295 @Smoke
296 @Test(timeout = 300000)
297 public void converterPropertyTest() throws InterruptedException {
298 assertNotSame((new ComboBox()).getConverter(), null);
299
300 assertTrue(new GetAction<Object>() {
301 @Override
302 public void run(Object... os) throws Exception {
303 setResult(((ComboBox) os[0]).getConverter());
304 }
305 }.dispatch(Root.ROOT.getEnvironment(),
306 testedControl.getControl()) instanceof StringConverter);
307
308 String element = "Random element 1";
309 addElement(element, 0);
310
311 testedControl.as(Selectable.class).selector().select(element);
312 checkSimpleListenerValue(Properties.selectedItem, element);
313
314 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
315
316 assertTrue(new GetAction<Object>() {
317 @Override
318 public void run(Object... os) throws Exception {
319 setResult(((ComboBox) os[0]).getConverter());
320 }
321 }.dispatch(Root.ROOT.getEnvironment(),
322 testedControl.getControl()) instanceof StringConverter);
323
324 String element2 = "Random element 2";
325 addElement(element2, 1);
326 testedControl.as(Selectable.class).selector().select(element2);
327 checkSimpleListenerValue(Properties.selectedItem, element2);
328 assertEquals(getTextFieldText(), element2);
329
330 applyCustomStringConverter();
331
332 assertTrue(new GetAction<Object>() {
333 @Override
334 public void run(Object... os) throws Exception {
335 setResult(((ComboBox) os[0]).converterProperty().getValue());
336 }
337 }.dispatch(Root.ROOT.getEnvironment(),
338 testedControl.getControl()) instanceof CustomStringConverter);
339
340 String element3 = "Random element 3";
341 addElement(element3, 2);
342 testedControl.as(Selectable.class).selector().select(element3);
343 checkSimpleListenerValue(Properties.selectedItem, element3);
344 assertEquals(getTextFieldText(), TO_STRING_PREFIX + "3");
345
346 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
347 testedControl.as(Selectable.class).selector().select(element2);
348 checkSimpleListenerValue(Properties.selectedItem, element2);
349 }
350
351 @Smoke
352 @Test(timeout = 300000)
353 public void itemsPropertyTest() throws InterruptedException {
354 assertNotSame((new ComboBox()).getItems(), null);
355 assertTrue((new ComboBox()).getItems() instanceof ObservableList);
356
357 checkListsEquality();
358 for (int i = 0; i < 5; i++) {
359 for (int j = 0; j < 5; j++) {
360 addElement(String.valueOf(j), j);
361 checkListsEquality();
362 }
363
364 for (int j = 0; j < 5; j++) {
365 removeFromPos(0);
366 checkListsEquality();
367 }
368 }
369
370 }
371
372 private void checkListsEquality() throws InterruptedException {
373 //Equality: both are lists, size are equal, elements each by each are equal
374 if (!testedControl.getProperty(Boolean.class, ChoiceBoxWrap.IS_SHOWING_PROP_NAME)) {
375 clickDropDownButton();
376 }
377 assertEquals(((ListView) getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap().getControl()).getItems(), ((ComboBox) testedControl.getControl()).getItems());
378 }
379
380 //Test//Jonathan said, that there is no support for multiple
381 // selection model now. So I'll wait until he will write it and check my
382 // customMultipleSelection model class. So to write test now is impossible.
383 public void customMultipleSelectionModelTest() throws InterruptedException {
384 assertNotSame((new ComboBox()).getItems(), null);
385
386 clickDropDownButton();
387
388 applyCustomSelectionModel();
389 clickDropDownButton();
390
391 assertTrue(new GetAction<Object>() {
392 @Override
393 public void run(Object... os) throws Exception {
394 setResult(((ComboBox) os[0]).getSelectionModel());
395 }
396 }.dispatch(Root.ROOT.getEnvironment(),
397 testedControl.getControl()) instanceof CustomMultipleSelectionModel);
398
399 addElements(1, 2, 3);
400
401 for (int i = 1; i <= 3; i++) {
402 testedControl.as(Selectable.class).selector().select(String.valueOf(i));
403 }
404 }
405
406 @Smoke
407 @Test(timeout = 300000)
408 public void onActionPropertyTest() {
409 assertTrue((new ComboBox()).getOnAction() == null);
410 assertTrue(testedControl.getControl().getOnAction() instanceof EventHandler);
411 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 0);
412
413 addElements(1, 2, 3);
414 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 0);
415 testedControl.mouse().click();
416 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 0);
417 testedControl.as(Selectable.class).selector().select("2");
418 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 1);
419 testedControl.keyboard().pushKey(KeyboardButtons.UP);
420 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 2);
421 testedControl.keyboard().pushKey(KeyboardButtons.DOWN);
422 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 3);
423 testedControl.keyboard().pushKey(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
424 testedControl.keyboard().pushKey(KeyboardButtons.DOWN, KeyboardModifiers.ALT_DOWN_MASK);
425 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 3);
426 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
427
428 testedControl.mouse().click();
429 testedControl.mouse().click();
430
431 testedControl.keyboard().pushKey(KeyboardButtons.A);
432 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 3);
433 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
434 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 4);
435 setPropertyByTextField(SettingType.BIDIRECTIONAL, Properties.value, NEW_VALUE_1);
436 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 6);
437 setPropertyByTextField(SettingType.UNIDIRECTIONAL, Properties.value, NEW_VALUE_2);
438 checkCounterValue(ON_ACTION_EVENT_COUNTER_ID, 8);
439 }
440
441 @Smoke
442 @Test(timeout = 300000)//RT-19227
443 public void selectionTest() throws InterruptedException, Exception {
444 final int number = 10;
445 for (int i = 0; i < number; i++) {
446 addElement(String.valueOf(i), i);
447 }
448 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 4);
449
450 for (int i = 0; i < number * 2; i++) {
451 testedControl.as(Selectable.class).selector().select(String.valueOf(i % number));
452 try {
453 checkSelectionState(i % number, i % number);
454 } catch (Exception e) {
455 System.out.println("Exception was thrown on step " + i);
456 throw e;
457 }
458 }
459 }
460
461 @Smoke
462 @Test(timeout = 300000)
463 public void selection2Test() throws InterruptedException, Exception {
464 clickDropDownButton();
465 ListView lw = ((ListView) getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap().getControl());
466 final int number = 10;
467 for (int i = 0; i < number; i++) {
468 addElement(String.valueOf(i), i);
469 }
470 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 4);
471
472 for (int i = 0; i < number * 3; i++) {
473 testedControl.as(Selectable.class).selector().select(String.valueOf(i % number));
474 clickDropDownButton();
475 clickDropDownButton();
476 try {
477 assertEquals(i % number, lw.getSelectionModel().getSelectedIndex());
478 assertEquals(String.valueOf(i % number), lw.getSelectionModel().getSelectedItem());
479 } catch (Exception e) {
480 System.out.println("Exception was thrown on step " + i);
481 throw e;
482 }
483 }
484 }
485
486 @Smoke
487 @Test(timeout = 300000)
488 public void keyboardF4Tests() throws Exception {
489 popupShowingOnKeyPressCommonTest(KeyboardButtons.F4);
490 }
491
492 @Smoke
493 @Test(timeout = 300000)//RT-18176
494 public void keyboardAltUpTest() throws Exception {
495 popupShowingOnKeyPressCommonTest(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
496 }
497
498 @Smoke
499 @Test(timeout = 300000)//RT-18176
500 public void keyboardAltDownTest() throws Exception {
501 popupShowingOnKeyPressCommonTest(KeyboardButtons.DOWN, KeyboardModifiers.ALT_DOWN_MASK);
502 }
503
504 private void popupShowingOnKeyPressCommonTest(KeyboardButtons button, KeyboardModifiers... mdfs) throws Exception {
505 requestFocusOnControl(testedControl);
506 for (int j = 0; j <= 1; j++) { //to switch editable property
507 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
508 for (int i = 0; i < ITER; i++) {
509 testedControl.keyboard().pushKey(button, mdfs);
510 if (j == 0) {//editable state.
511 assertEquals(getTextFieldText(), "");
512 }
513 checkTextFieldText(Properties.value, "null");
514
515 try {
516 checkPopupShowing(i % 2 == 0 ? true : false);
517 } catch (Exception e) {
518 System.out.println("Exception was thrown on step " + i);
519 throw e;
520 }
521 }
522 }
523 }
524
525 @Smoke
526 @Test(timeout = 300000)
527 public void keyboardUpDownTest() throws InterruptedException {
528 final int number = 10;
529 for (int i = 0; i < number; i++) {
530 addElement(String.valueOf(i), i);
531 }
532
533 int currentItem = -1;
534
535 testedControl.mouse().click();
536 testedControl.mouse().click();
537 testedControl.keyboard().pushKey(KeyboardButtons.DOWN);
538
539 for (int k = 0; k < 3; k++) {
540 for (KeyboardButton key : EnumSet.of(KeyboardButtons.DOWN, KeyboardButtons.UP)) {
541 for (int i = 0; i < ITER; i++) {
542 if (key == KeyboardButtons.UP) {
543 currentItem -= 1;
544 } else {
545 currentItem += 1;
546 }
547 currentItem = (int) Math.round(adjustValue(0, number - 1, currentItem));
548
549 testedControl.keyboard().pushKey(key);
550
551 checkSelectionState(currentItem, currentItem);
552 }
553 }
554 }
555 }
556
557 @Smoke
558 @Test(timeout = 300000)
559 public void keyboardPopupCloseTest() throws InterruptedException {
560 //According to spec: [Active list is open] close the active list.
561 for (int i = 0; i < 2; i++) {
562 for (KeyboardButton button : EnumSet.of(KeyboardButtons.ENTER, KeyboardButtons.ESCAPE, KeyboardButtons.SPACE)) {
563 clickDropDownButton();
564 checkPopupShowing(true);
565
566 requestFocusOnControl(testedControl);
567 testedControl.keyboard().pushKey(button);
568 checkPopupShowing(false);
569 }
570 }
571
572 //ANTITEST:
573 requestFocusOnControl(testedControl);
574 for (int i = 0; i < 2; i++) {
575 for (KeyboardButton button : EnumSet.of(KeyboardButtons.ENTER, KeyboardButtons.ESCAPE, KeyboardButtons.SPACE)) {
576 checkPopupShowing(false);
577 testedControl.keyboard().pushKey(button);
578 checkPopupShowing(false);
579 }
580 }
581 }
582
583 @Smoke
584 @Test(timeout = 300000)
585 public void onEscapeNotSelectingTest() throws InterruptedException {
586 selectOnKeyboardCommonTest(KeyboardButtons.ESCAPE);
587 }
588
589 @Smoke
590 @Test(timeout = 300000)
591 public void onEnterSelectTest() throws InterruptedException {
592 selectOnKeyboardCommonTest(KeyboardButtons.ENTER);
593 }
594
595 @Smoke
596 @Test(timeout = 300000)
597 public void onSpaceSelectTest() throws InterruptedException {
598 selectOnKeyboardCommonTest(KeyboardButtons.SPACE);
599 }
600
601 private void selectOnKeyboardCommonTest(KeyboardButtons button) throws InterruptedException {
602 int number = 10;
603 for (int i = 0; i < number; i++) {
604 addElement(String.valueOf(i), i);
605 }
606
607 for (int i = 1; i < number; i++) {
608 testedControl.keyboard().pushKey(KeyboardButtons.F4);
609 testedControl.keyboard().pushKey(KeyboardButtons.DOWN);
610 testedControl.keyboard().pushKey(button);
611 checkPopupShowing(false);
612 checkTextFieldText(Properties.value, String.valueOf((i - 1) % number));
613 }
614 }
615
616 //RT-18064 that would be a feature, so that is not a test//Ok.
617 public void keyboardAnyKeyTest() {
618 addElements("aaa", "bbb", "ccc");
619
620 requestFocusOnControl(testedControl);
621 testedControl.keyboard().pushKey(KeyboardButtons.B);
622 checkSimpleListenerValue(Properties.selectedItem, "bbb");
623 }
624
625 @Smoke
626 @Test(timeout = 300000)
627 public void mouseTest() throws InterruptedException {
628
629 //common click
630 testedControl.mouse().click();
631 checkTextFieldText(Properties.showing, "true");
632 testedControl.mouse().click();
633 checkTextFieldText(Properties.showing, "false");
634
635 //drop down button test
636 clickDropDownButton();
637 checkTextFieldText(Properties.showing, "true");
638 clickDropDownButton();
639 checkTextFieldText(Properties.showing, "false");
640
641 //select test
642 addElement("0", 0);
643 testedControl.as(Selectable.class).selector().select("0");
644 assertEquals("0", getCurrentValue());
645
646 //scrollbar interaction test
647 addElements(1, 2, 3, 4, 5, 6);
648 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 5);
649 clickDropDownButton();
650 Wrap<? extends ScrollBar> sb = findScrollBar(
651 ((Parent<Node>) ((Wrap<? extends ListView>) ((Parent<Node>) getPopupWrap().as(Parent.class, Node.class))
652 .lookup(ListView.class).wrap()).as(Parent.class, Node.class)), Orientation.VERTICAL, true);
653 sb.as(AbstractScroll.class).caret().to(1);
654 checkTextFieldText(Properties.showing, "true");
655 testedControl.as(Selectable.class).selector().select("6");
656 checkTextFieldText(Properties.showing, "false");
657
658 //selection in editable state
659 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
660 requestFocusOnControl(testedControl);
661 testedControl.as(Text.class).type("a");
662 assertEquals(getTextFieldText(), "a");
663
664 //drop down in editable state
665 clickDropDownButton();
666 testedControl.as(Selectable.class).selector().select("3");
667 checkTextFieldText(Properties.value, "3");
668 }
669
670 @ScreenshotCheck
671 @Smoke
672 @Test(timeout = 300000)//RT-19227
673 public void commonNonEditableTest() throws InterruptedException, Throwable {
674 addElements(1, 2, 3, 4, 5, 6);
675 checkScreenshot("ComboBox_initial", testedControl);
676
677 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 3);
678
679 testedControl.mouse().click();
680 testedControl.mouse().click();
681
682 testedControl.keyboard().pushKey(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
683 checkScrollBarVisibility(true);
684 checkTextFieldText(Properties.showing, "true");
685
686 testedControl.as(Selectable.class).selector().select("6");
687 checkSelectionState(5, 6);
688 checkTextFieldText(Properties.value, "6");
689
690 clickDropDownButton();
691 checkScreenshot("ComboBox_combobox_noneditable[6_is_selected]", testedControl);
692 Wrap wrap = getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap();
693
694 checkScreenshot("ComboBox_popup_noneditable[6_is_selected]", wrap);
695 throwScreenshotError();
696 }
697
698 @ScreenshotCheck
699 @Smoke
700 @Test(timeout = 300000)
701 public void commonEditableTest() throws InterruptedException, Throwable {
702 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
703 addElements(1, 2, 3, 4, 5, 6);
704 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 4);
705
706 testedControl.as(Selectable.class).selector().select("6");
707 checkSelectionState(5, 6);
708 assertEquals(getTextFieldText(), "6");
709 checkTextFieldText(Properties.value, "6");
710 checkSimpleListenerValue(Properties.selectedIndex, 5);
711
712 testedControl.mouse().click();
713 testedControl.as(Text.class).type("abc");
714 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
715
716 checkSimpleListenerValue(Properties.selectedItem, "6abc");
717 checkTextFieldText(Properties.value, "6abc");
718
719 clickDropDownButton();
720
721 checkScreenshot("ComboBox_combobox_editable", testedControl);
722 checkScreenshot("ComboBox_popup_editable", getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap());
723 throwScreenshotError();
724 }
725
726 @ScreenshotCheck
727 @Test(timeout = 300000)
728 public void initialAndFinalSizeTest() throws Throwable {
729 String commonScreenShotName = "ComboBox_initial";
730 //checkScreenshot(commonScreenShotName, testedControl);//Removed, as size of empty is different.
731
732 int size = 10;
733 for (int i = 0; i < size; i++) {
734 addElement(String.valueOf(i), i);
735 checkScreenshot(commonScreenShotName, testedControl);
736 }
737 setPropertyBySlider(SettingType.BIDIRECTIONAL, Properties.visibleRowCount, 5);
738
739 for (int i = 0; i < size; i++) {
740 removeFromPos(0);
741 checkScreenshot(commonScreenShotName, testedControl);
742 }
743
744 checkScreenshot(commonScreenShotName, testedControl);
745 throwScreenshotError();
746 }
747
748 @Smoke
749 @Test(timeout = 300000)
750 public void consistentAndEmptySelectionTest() {
751 //seems, the only way to do empty selection is using keyboard.UP.
752 int number = 5;
753 for (int i = 0; i < number; i++) {
754 addElement(String.valueOf(i), i);
755 }
756
757 requestFocusOnControl(testedControl);
758 testedControl.keyboard().pushKey(KeyboardButtons.DOWN);
759 for (int j = 1; j < number; j++) {
760 for (int k = 0; k < j; k++) {
761 testedControl.keyboard().pushKey(KeyboardButtons.DOWN);
762 checkTextFieldText(Properties.value, String.valueOf(k + 1));
763 }
764
765 for (int k = 0; k < number; k++) {
766 testedControl.keyboard().pushKey(KeyboardButtons.UP);
767 if (k + 1 < j) {
768 checkTextFieldText(Properties.value, String.valueOf(j - k - 1));
769 } else {
770 checkTextFieldText(Properties.value, String.valueOf(0));
771 }
772 }
773
774 checkTextFieldText(Properties.value, "0");
775 }
776 }
777
778 @Smoke
779 @Test(timeout = 300000)
780 public void addElementsInDropDownTest() {
781 addElements(0, 1, 2, 3, 4, 5, 6);
782
783 testedControl.as(Selectable.class).selector().select("3");
784 checkSelectionState(3, 3);
785 addElement("2,5", 2);
786 checkSelectionState(4, 3);
787 addElement("3,5", 4);
788 checkSelectionState(5, 3);
789 addElement("4,5", 6);
790 checkSelectionState(5, 3);
791 }
792
793 @Smoke
794 @Test(timeout = 300000)//RT-18944, RT-19227
795 public void removeElementsFromDropDownTest() {
796 addElements(0, 1, 2, 3, 4, 5, 6);
797
798 testedControl.as(Selectable.class).selector().select("3");
799 checkSelectionState(3, 3);
800 removeFromPos(5);
801 checkSelectionState(3, 3);
802 removeFromPos(4);
803 checkSelectionState(3, 3);
804 removeFromPos(2);
805 checkSelectionState(2, 3);
806 removeFromPos(2);
807 checkSimpleListenerValue(Properties.selectedIndex, -1);
808 checkTextFieldText(Properties.value, "null");
809 }
810
811 @Smoke
812 @Test(timeout = 300000)//RT-18972
813 public void editingChangeModeText() {
814 currentSettingOption = SettingOption.MANUAL;//That is needed because otherwise test fails
815 addElements(1, 2, 3);
816 //initial state is uneditable
817 testedControl.as(Selectable.class).selector().select("3");
818 checkValue("3");
819
820 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
821 //editable
822 checkValue("null");
823 assertEquals(getTextFieldText(), "");
824 testedControl.as(Text.class).type(NEW_VALUE_1);
825 checkValue("null");
826 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
827 checkValue(NEW_VALUE_1);
828 testedControl.as(Selectable.class).selector().select("1");
829 assertEquals(getTextFieldText(), "1");
830 checkValue("1");
831 testedControl.as(Text.class).type(NEW_VALUE_2);
832 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
833 checkValue(NEW_VALUE_2 + "1");
834
835 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
836 //non-editable
837 checkValue("null");
838 testedControl.as(Selectable.class).selector().select("2");
839 checkValue("2");
840
841 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
842 //editable
843 checkValue("null");
844 testedControl.as(Selectable.class).selector().select("1");
845 checkValue("1");
846 }
847
848 @ScreenshotCheck
849 @Test(timeout = 300000)
850 public void customCellAPIApplying() throws Throwable {
851 assertTrue((new ComboBox()).getCellFactory() == null);
852 assertTrue(testedControl.getControl().getCellFactory() == null);
853 applyCustomCellAPI();
854 assertTrue(testedControl.getControl().getCellFactory() instanceof Callback);
855 addElements(1, 2, 3);
856
857 testedControl.as(Selectable.class).selector().select("3");
858 checkValue("3");
859
860 testedControl.mouse().click();
861
862 checkScreenshot("ComboBox_Custom_CellAPI_[3]", testedControl);
863 Wrap wrap = getPopupWrap().as(Parent.class, Node.class).lookup(ListView.class).wrap();
864
865 checkScreenshot("ComboBox_Custom_CellAPI_[Custom3]", wrap);
866 throwScreenshotError();
867 }
868 //add cell factory testing
869 static private final String NEW_VALUE_1 = "new value 1";
870 static private final String NEW_VALUE_2 = "new value 2";
871
872 @Smoke
873 @Test(timeout = 300000)
874 public void testOnShowingEvent() throws Throwable {
875 testEvents(new CheckFunctor.IdCounter("SET_ON_SHOWING_COUNTER"),
876 new CheckFunctor.NullCounter());
877 }
878
879 @Smoke
880 @Test(timeout = 300000)
881 public void testOnShownEvent() throws Throwable {
882 testEvents(new CheckFunctor.IdCounter("SET_ON_SHOWN_COUNTER"),
883 new CheckFunctor.NullCounter());
884 }
885
886 @Smoke
887 @Test(timeout = 300000)
888 public void testOnHiding() throws Throwable {
889 testEvents(new CheckFunctor.NullCounter(),
890 new CheckFunctor.IdCounter("SET_ON_HIDING_COUNTER"));
891 }
892
893 @Smoke
894 @Test(timeout = 300000)
895 public void testOnHidden() throws Throwable {
896 testEvents(new CheckFunctor.NullCounter(),
897 new CheckFunctor.IdCounter("SET_ON_HIDEN_COUNTER"));
898 }
899
900 @Smoke
901 @Test(timeout = 300000)
902 public void testEventsSequence() throws Throwable {
903
904 /**
905 * Save default event handlers
906 */
907 final EventHandler<Event> onShowing = new GetAction<EventHandler<Event>>() {
908 @Override
909 public void run(Object... os) throws Exception {
910 setResult(testedControl.getControl().getOnShowing());
911 }
912 }.dispatch(Root.ROOT.getEnvironment());
913
914 final EventHandler<Event> onShown = new GetAction<EventHandler<Event>>() {
915 @Override
916 public void run(Object... os) throws Exception {
917 setResult(testedControl.getControl().getOnShown());
918 }
919 }.dispatch(Root.ROOT.getEnvironment());
920
921 final EventHandler<Event> onHiding = new GetAction<EventHandler<Event>>() {
922 @Override
923 public void run(Object... os) throws Exception {
924 setResult(testedControl.getControl().getOnHiding());
925 }
926 }.dispatch(Root.ROOT.getEnvironment());
927
928 final EventHandler<Event> onHidden = new GetAction<EventHandler<Event>>() {
929 @Override
930 public void run(Object... os) throws Exception {
931 setResult(testedControl.getControl().getOnHidden());
932 }
933 }.dispatch(Root.ROOT.getEnvironment());
934
935 final Map<EventHandler<Event>, Long> timestampsOfEvents =
936 new HashMap<EventHandler<Event>, Long>();
937
938 /**
939 * Assing new event handlers to get timestamps
940 */
941 new GetAction<Object>() {
942 @Override
943 public void run(Object... os) throws Exception {
944 testedControl.getControl().setOnShowing(new EventHandler() {
945 public void handle(Event t) {
946 timestampsOfEvents.put(onShowing, System.nanoTime());
947 }
948 });
949
950 testedControl.getControl().setOnShown(new EventHandler() {
951 public void handle(Event t) {
952 timestampsOfEvents.put(onShown, System.nanoTime());
953 }
954 });
955
956 testedControl.getControl().setOnHiding(new EventHandler() {
957 public void handle(Event t) {
958 timestampsOfEvents.put(onHiding, System.nanoTime());
959 }
960 });
961
962 testedControl.getControl().setOnHidden(new EventHandler() {
963 public void handle(Event t) {
964 timestampsOfEvents.put(onHidden, System.nanoTime());
965 }
966 });
967 }
968 }.dispatch(Root.ROOT.getEnvironment());
969
970 testEvents(new CheckFunctor.NullCounter(),
971 new CheckFunctor() {
972 @Override
973 public void call(int conterVal) throws Throwable {
974 /**
975 * Compare timestamps of events
976 */
977 Long onShowingTime = timestampsOfEvents.get(onShowing);
978 Long onShownTime = timestampsOfEvents.get(onShown);
979 Long onHidingTime = timestampsOfEvents.get(onHiding);
980 Long onHiddenTime = timestampsOfEvents.get(onHidden);
981
982 assertEquals(true, onShowingTime < onShownTime);
983 assertEquals(true, onShownTime < onHidingTime);
984 assertEquals(true, onHidingTime < onHiddenTime);
985 }
986 });
987 /**
988 * Restore default event handlers
989 */
990 new GetAction<Object>() {
991 @Override
992 public void run(Object... os) throws Exception {
993 testedControl.getControl().setOnShowing(onShowing);
994 testedControl.getControl().setOnShown(onShown);
995 testedControl.getControl().setOnHiding(onHiding);
996 testedControl.getControl().setOnHidden(onHidden);
997 }
998 }.dispatch(Root.ROOT.getEnvironment());
999 }
1000
1001 /**
1002 * Method sets four counters to zero
1003 */
1004 private void clearCounters() {
1005 final String counterInitVal = "0";
1006 changeTextFieldText("SET_ON_SHOWING_COUNTER_COUNTER_TEXT_FIELD_ID", counterInitVal);
1007 changeTextFieldText("SET_ON_SHOWN_COUNTER_COUNTER_TEXT_FIELD_ID", counterInitVal);
1008 changeTextFieldText("SET_ON_HIDING_COUNTER_COUNTER_TEXT_FIELD_ID", counterInitVal);
1009 changeTextFieldText("SET_ON_HIDEN_COUNTER_COUNTER_TEXT_FIELD_ID", counterInitVal);
1010 }
1011
1012 /**
1013 * Method opens and closes ComboBox by all possible means and calls passed
1014 * functors after each opening or closing.
1015 *
1016 * @param checkCountersAfterOpening
1017 * @param checkCountersAfterClosing
1018 * @throws Throwable
1019 */
1020 private void testEvents(CheckFunctor checkCountersAfterOpening,
1021 CheckFunctor checkCountersAfterClosing) throws Throwable {
1022 /**
1023 * make sure that comboBox is closed
1024 */
1025 assertFalse(new GetAction<Boolean>() {
1026 @Override
1027 public void run(Object... os) throws Exception {
1028 setResult(testedControl.getControl().showingProperty().getValue());
1029 }
1030 }.dispatch(Root.ROOT.getEnvironment()));
1031
1032 /**
1033 * Fill ComboBox with elements
1034 */
1035 addElements("aaa", "bbb", "ccc", "ddd", "eee");
1036
1037 clearCounters();
1038
1039 int counterVal = 1;
1040
1041 /**
1042 * Open ComboBox by clicking on it's text field
1043 */
1044 testedControl.mouse().click();
1045 checkPopupShowing(true);
1046 checkCountersAfterOpening.call(counterVal);
1047 /**
1048 * Close it the same way
1049 */
1050 testedControl.mouse().click();
1051 checkPopupShowing(false);
1052 checkCountersAfterClosing.call(counterVal);
1053
1054 /**
1055 * Counter should have increased
1056 */
1057 counterVal++;
1058
1059 /**
1060 * Click on drop down arrow
1061 */
1062 clickDropDownButton();
1063 checkPopupShowing(true);
1064 checkCountersAfterOpening.call(counterVal);
1065
1066 clickDropDownButton();
1067 checkPopupShowing(false);
1068 checkCountersAfterClosing.call(counterVal);
1069
1070 counterVal++;
1071
1072 /**
1073 * Press f4
1074 */
1075 testedControl.keyboard().pushKey(KeyboardButtons.F4);
1076 checkPopupShowing(true);
1077 checkCountersAfterOpening.call(counterVal);
1078
1079 testedControl.keyboard().pushKey(KeyboardButtons.F4);
1080 checkPopupShowing(false);
1081 checkCountersAfterClosing.call(counterVal);
1082
1083 counterVal++;
1084
1085 /**
1086 * Alt+down arrow
1087 */
1088 testedControl.keyboard().pushKey(KeyboardButtons.DOWN, KeyboardModifiers.ALT_DOWN_MASK);
1089 checkPopupShowing(true);
1090 checkCountersAfterOpening.call(counterVal);
1091
1092 testedControl.keyboard().pushKey(KeyboardButtons.DOWN, KeyboardModifiers.ALT_DOWN_MASK);
1093 checkPopupShowing(false);
1094 checkCountersAfterClosing.call(counterVal);
1095
1096 counterVal++;
1097
1098 /**
1099 * Alt+up arrow
1100 */
1101 testedControl.keyboard().pushKey(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
1102 checkPopupShowing(true);
1103 checkCountersAfterOpening.call(counterVal);
1104
1105 testedControl.keyboard().pushKey(KeyboardButtons.UP, KeyboardModifiers.ALT_DOWN_MASK);
1106 checkPopupShowing(false);
1107 checkCountersAfterClosing.call(counterVal);
1108 }
1109
1110 private static interface CheckFunctor {
1111
1112 public void call(int counterVal) throws Throwable;
1113
1114 static class NullCounter implements CheckFunctor {
1115
1116 public void call(int counterVal) throws Throwable {
1117 }
1118 };
1119
1120 static class IdCounter implements CheckFunctor {
1121
1122 private final String id;
1123
1124 public IdCounter(String id) {
1125 this.id = id;
1126 }
1127
1128 public void call(int counterVal) throws Throwable {
1129 ComboBoxTest.checkCounterValue(id, counterVal);
1130 }
1131 }
1132 };
1133
1134 /**
1135 * Test adds an element to ComboBox when onShowing event is fired and checks
1136 * that new element was rendered properly
1137 *
1138 * @throws Throwable
1139 */
1140 @Smoke
1141 @Test(timeout = 300000)
1142 public void testOnShowingByModifyingContent() throws Throwable {
1143
1144 final int initialSize = 4;
1145 addElements("1", "2", "3", "4");
1146
1147 clickButtonForTestPurpose(SET_ADDING_ELEMENTS_ON_SHOWING);
1148 testedControl.mouse().click();
1149 checkPopupShowing(true);
1150
1151 Wrap<? extends ListView> list = getPopupWrap()
1152 .as(Parent.class, Node.class)
1153 .lookup(ListView.class)
1154 .wrap();
1155
1156 Wrap<? extends ListCell> testCell = list
1157 .as(Parent.class, Node.class)
1158 .lookup(ListCell.class, new ListItemByObjectLookup<String>(INITIAL_VALUE))
1159 .wrap();
1160
1161 Wrap<? extends ListCell> previousCell = list
1162 .as(Parent.class, Node.class)
1163 .lookup(ListCell.class, new ListItemByObjectLookup<String>("4"))
1164 .wrap();
1165
1166 assertTrue(testCell.getScreenBounds().getY()
1167 >= previousCell.getScreenBounds().getY()
1168 + previousCell.getScreenBounds().getHeight());
1169
1170 /* Check that size of ComboBox list has increased */
1171 Boolean result = new GetAction<Boolean>() {
1172 @Override
1173 public void run(Object... os) throws Exception {
1174 setResult(testedControl.getControl().getItems().size() == (initialSize + 1));
1175 }
1176 }.dispatch(Root.ROOT.getEnvironment());
1177 assertTrue(result);
1178
1179 clickButtonForTestPurpose(RESTORE_ON_SHOWING_EVENT_HANDLER);
1180 }
1181
1182 /**
1183 * Test that not editable ComboBox's getEditor() method must return null
1184 */
1185 @Smoke
1186 @Test(timeout = 300000)
1187 public void testNotEditableGetEditorMethod() {
1188 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable, false);
1189 checkTextFieldText(Properties.text, "");
1190 }
1191
1192 /**
1193 * Test that text entered in TextField doesn't change ComboBox's value
1194 */
1195 @Smoke
1196 @Test(timeout = 300000)
1197 public void testInputByEditorProperty() throws Throwable {
1198 addElements("1", "2", "3", "4");
1199
1200 setPropertyByToggleClick(SettingType.BIDIRECTIONAL, Properties.editable);
1201
1202 final String selectedVal = "2";
1203 testedControl.as(Selectable.class).selector().select(selectedVal);
1204
1205 /**
1206 * Change text in TextField
1207 */
1208 final String testedText = "aaa";
1209 setPropertyByTextField(SettingType.SETTER, Properties.text, testedText);
1210
1211 /**
1212 * Value shouldn't have changed
1213 */
1214 checkTextFieldText(Properties.value, selectedVal);
1215
1216 checkTextFieldText(Properties.text, testedText);
1217 }
1218
1219 /**
1220 * Test that TextField returned by getEditor() method remains the same after
1221 * changing editable property
1222 */
1223 @Smoke
1224 @Test(timeout = 300000)
1225 public void testEditorProperty() throws Throwable {
1226 new PropertyTest.EditorPropertyTest(testedControl).test();
1227 }
1228
1229 /**
1230 * Test that TextField's parent remains the same after changing editable
1231 * property
1232 *
1233 */
1234 @Smoke
1235 @Test(timeout = 300000)
1236 public void testEditorPropertyParent() throws Throwable {
1237 new PropertyTest.EditorParentPropertyTest(testedControl).test();
1238 }
1239
1240 /**
1241 * Test that text entered via TextField becomes ComboBox's value when
1242 * ComboBox looses focus
1243 */
1244 @Smoke
1245 @Test(timeout = 300000)
1246 public void textEditorPropertyCommitOnFocusLost() throws Throwable {
1247 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable);
1248
1249 final String testedText = "test test test";
1250 getEditTextFieldWrap().as(Text.class).type(testedText);
1251
1252 Wrap<? extends TextField> textFieldWrap = findTextField("ARMED_LISTENER_ID");
1253 textFieldWrap.mouse().click();
1254
1255 checkTextFieldText(Properties.value, testedText);
1256
1257 final String anotherText = "another string";
1258 setPropertyByTextField(SettingType.SETTER, Properties.text, anotherText);
1259
1260 testedControl.keyboard().pushKey(KeyboardButtons.TAB);
1261 checkTextFieldText(Properties.value, anotherText);
1262 }
1263
1264 /**
1265 * Test different cell rendering of ComboBox button and list (pop up) Button
1266 * height must remain the same. Height of cells of ComboBox must increase.
1267 *
1268 * http://javafx-jira.kenai.com/browse/RT-24528
1269 */
1270 @Smoke
1271 @Test(timeout = 300000)
1272 public void testCellRenderingHeight() throws Throwable {
1273
1274 clickButtonForTestPurpose(POPULATE_COMBOBOX_WITH_FONT_SIZES);
1275
1276 for (boolean isEditable : new boolean[]{false, true}) {
1277
1278 if (!isEditable) {
1279 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable, false);
1280 } else {
1281 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable);
1282 }
1283
1284 final double initialButtonHeight = testedControl.getScreenBounds().getHeight();
1285 double prevCellTextHeight = 0f;
1286
1287 for (int fontSize = INITIAL_FONT_SIZE; fontSize <= MAX_FONT_SIZE; fontSize += 2) {
1288 String testVal = String.valueOf(fontSize);
1289
1290 testedControl.as(Selectable.class).selector().select(String.valueOf(fontSize));
1291
1292 /* check heighgt of the button */
1293 assertEquals(initialButtonHeight, testedControl.getScreenBounds().getHeight(), 0.001);
1294
1295 /* text node should be alwas rendered inside ComboBox button */
1296 Wrap<? extends javafx.scene.text.Text> textFieldWrap = testedControl.as(Parent.class, Node.class)
1297 .lookup(javafx.scene.text.Text.class).wrap();
1298 assertTrue(textFieldWrap.getScreenBounds().getY() >= testedControl.getScreenBounds().getY());
1299 assertTrue(textFieldWrap.getScreenBounds().getY() + textFieldWrap.getScreenBounds().getHeight()
1300 <= testedControl.getScreenBounds().getY() + testedControl.getScreenBounds().getHeight());
1301
1302 /* get wraps of cell and cell text node to compare coordinates */
1303 clickDropDownButton();
1304
1305 Wrap<? extends ListView> listWrap = getPopupWrap().as(Parent.class, Node.class)
1306 .lookup(ListView.class).wrap();
1307
1308 Wrap<? extends ListCell> cellWrap = listWrap.as(Parent.class, Node.class)
1309 .lookup(ListCell.class, new ByText(testVal, StringComparePolicy.EXACT)).wrap();
1310
1311 Wrap<? extends javafx.scene.text.Text> cellTextWrap = cellWrap.as(Parent.class, Node.class)
1312 .lookup(javafx.scene.text.Text.class).wrap();
1313
1314 /* cell text should be always inside cell */
1315 assertTrue(cellTextWrap.getScreenBounds().getY() >= cellWrap.getScreenBounds().getY());
1316 assertTrue(cellWrap.getScreenBounds().getY() + cellWrap.getScreenBounds().getHeight()
1317 >= cellTextWrap.getScreenBounds().getY() + cellTextWrap.getScreenBounds().getHeight());
1318
1319 if (prevCellTextHeight == 0) {
1320 prevCellTextHeight = cellTextWrap.getScreenBounds().getHeight();
1321 } else {
1322 assertTrue(prevCellTextHeight < cellTextWrap.getScreenBounds().getHeight());
1323 prevCellTextHeight = cellTextWrap.getScreenBounds().getHeight();
1324 }
1325
1326 if (fontSize == INITIAL_FONT_SIZE) {
1327 continue;
1328 }
1329
1330 Wrap<? extends ListCell> prevCellWrap = listWrap.as(Parent.class, Node.class)
1331 .lookup(ListCell.class, new ByText(String.valueOf(fontSize - 2), StringComparePolicy.EXACT)).wrap();
1332
1333 /* compare cell coordinates with previous cell coordinates */
1334 assertTrue(cellWrap.getScreenBounds().getY()
1335 >= prevCellWrap.getScreenBounds().getY() + prevCellWrap.getScreenBounds().getHeight());
1336 }
1337 }
1338 }
1339
1340 /**
1341 * Test different cell rendering of ComboBox button and list (pop up).
1342 * Button width must remain the same. Width of cells of ComboBox must also
1343 * remain the same.
1344 *
1345 * http://javafx-jira.kenai.com/browse/RT-24528
1346 */
1347 @Test(timeout = 300000)
1348 public void testCellRenderingWidth() throws Throwable {
1349
1350 clickButtonForTestPurpose(POPULATE_COMBOBOX_WITH_FONT_SIZES);
1351
1352 for (boolean isEditable : new boolean[]{false, true}) {
1353
1354 if (!isEditable) {
1355 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable, false);
1356 } else {
1357 setPropertyByToggleClick(SettingType.UNIDIRECTIONAL, Properties.editable, true);
1358 }
1359
1360 //Wait editable state application.
1361 Thread.sleep(1000);
1362
1363 final double initialButtonWidth = testedControl.getScreenBounds().getWidth();
1364
1365 if (!isPopupVisible()) {
1366 clickDropDownButton();
1367 }
1368 final double initialPopupWidth = getPopupWrap().getScreenBounds().getWidth();
1369 clickDropDownButton();
1370
1371 for (int fontSize = INITIAL_FONT_SIZE; fontSize <= MAX_FONT_SIZE; fontSize += 2) {
1372 String testVal = String.valueOf(fontSize);
1373
1374 testedControl.as(Selectable.class).selector().select(String.valueOf(fontSize));
1375
1376 /* check width of the button */
1377 assertEquals(initialButtonWidth, testedControl.getScreenBounds().getWidth(), 2.001);
1378
1379 if (!isPopupVisible()) {
1380 clickDropDownButton();
1381 }
1382
1383 /* check width of the popup */
1384 assertEquals(initialPopupWidth, getPopupWrap().getScreenBounds().getWidth(), 1.001);
1385
1386 /* get wraps of cell and cell text node to compare coordinates */
1387 Wrap<? extends ListView> listWrap = getPopupWrap().as(Parent.class, Node.class)
1388 .lookup(ListView.class).wrap();
1389
1390 Wrap<? extends ListCell> cellWrap = listWrap.as(Parent.class, Node.class)
1391 .lookup(ListCell.class, new ByText(testVal, StringComparePolicy.EXACT)).wrap();
1392
1393 Wrap<? extends javafx.scene.text.Text> cellTextWrap = cellWrap.as(Parent.class, Node.class)
1394 .lookup(javafx.scene.text.Text.class).wrap();
1395
1396 /* cell text should be always inside cell */
1397 assertTrue(cellTextWrap.getScreenBounds().getX() >= cellWrap.getScreenBounds().getX());
1398 assertTrue(cellWrap.getScreenBounds().getY() + cellWrap.getScreenBounds().getHeight()
1399 >= cellTextWrap.getScreenBounds().getY() + cellTextWrap.getScreenBounds().getHeight());
1400
1401 if (fontSize == INITIAL_FONT_SIZE) {
1402 continue;
1403 }
1404
1405 Wrap<? extends ListCell> prevCellWrap = listWrap.as(Parent.class, Node.class)
1406 .lookup(ListCell.class, new ByText(String.valueOf(fontSize - 2), StringComparePolicy.EXACT)).wrap();
1407
1408 /* compare cell coordinates with previous cell coordinates */
1409 assertEquals(prevCellWrap.getScreenBounds().getX(), cellWrap.getScreenBounds().getX(), 0.001);
1410 assertEquals(prevCellWrap.getScreenBounds().getWidth(), cellWrap.getScreenBounds().getWidth(), 0.001);
1411 }
1412 }
1413 }
1414
1415 /**
1416 * This test checks that a custom string converter fromString() method is
1417 * called only once when some value is entered in the editable ComboBox
1418 */
1419 @Smoke
1420 @Test(timeout = 300000)
1421 public void testStringConvertersFromStringMethod() throws InterruptedException {
1422 setPropertyBySlider(SettingType.SETTER, Properties.prefWidth, 150);
1423
1424 applyCustomStringConverter();
1425
1426 setPropertyByToggleClick(SettingType.SETTER, Properties.editable, true);
1427
1428 final String testString = "test";
1429 setPropertyByTextField(SettingType.SETTER, Properties.text, testString);
1430
1431 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
1432
1433 checkTextFieldText(Properties.value, FROM_STRING_PREFIX);
1434 }
1435
1436 /**
1437 * Tests format string converter and checks that transformation is performed
1438 * properly
1439 */
1440 @Smoke
1441 @Test(timeout = 300000)
1442 public void testFormatStringConverter() throws InterruptedException {
1443 setPropertyBySlider(SettingType.SETTER, Properties.prefWidth, 150);
1444
1445 int itemsCount = 3;
1446 String prefix = "value #";
1447
1448 final List<String> testedValues = new ArrayList<String>(itemsCount);
1449 for (int i = 0; i < itemsCount; i++) {
1450 testedValues.add(prefix + i);
1451 }
1452
1453 final String pattern = "Before text. {0} After text.";
1454 MessageFormat m = new MessageFormat(pattern);
1455 final Format fmt = new ComboBoxApp.MyMessageFormat(m);
1456
1457 //Set format string converter
1458 new GetAction<Object>() {
1459 @Override
1460 public void run(Object... parameters) throws Exception {
1461
1462 testedControl.getControl().setConverter(new FormatStringConverter<String>(fmt));
1463
1464 //populate control
1465 testedControl.getControl().getItems().addAll(testedValues);
1466 }
1467 }.dispatch(Root.ROOT.getEnvironment());
1468
1469 setPropertyByToggleClick(SettingType.SETTER, Properties.editable, true);
1470
1471 //#toString
1472 for (int i = 0; i < testedValues.size(); i++) {
1473 testedControl.as(Selectable.class).selector().select(testedValues.get(i));
1474 assertEquals(getTextFieldText(), fmt.format(testedValues.get(i)));
1475 }
1476
1477 //#fromString
1478 for (int i = 0; i < testedValues.size(); i++) {
1479 testedControl.as(Text.class).clear();
1480 testedControl.as(Text.class).type(fmt.format(testedValues.get(i)));
1481 testedControl.keyboard().pushKey(KeyboardButtons.ENTER);
1482
1483 checkTextFieldText(Properties.value, testedValues.get(i));
1484 }
1485
1486 doNextResetHard();
1487 }
1488
1489 /**
1490 * Checks that when the sorting is applied to the underlying data collection
1491 * the cells are rendered in the right order.
1492 */
1493 @Smoke
1494 @Test(timeout = 30000)
1495 public void renderingAfterSortingTest() {
1496 addElements("1", "2", "3", "4", "1", "2", "3", "4", "1", "42");
1497
1498 final int ITEMS_COUNT = 9;
1499
1500 StringConverter<String> conv = new StringConverter<String>() {
1501 @Override
1502 public String toString(String s) {
1503 return s;
1504 }
1505
1506 @Override
1507 public String fromString(String s) {
1508 return s;
1509 }
1510 };
1511
1512 SortValidator<String, ListCell> validator = new SortValidator<String, ListCell>(ITEMS_COUNT, conv) {
1513 @Override
1514 protected void setControlData(final ObservableList<String> ls) {
1515 new GetAction<Object>() {
1516 @Override
1517 public void run(Object... parameters) throws Exception {
1518 testedControl.getControl().setItems(ls);
1519 }
1520 }.dispatch(testedControl.getEnvironment());
1521 }
1522
1523 @Override
1524 protected Lookup<? extends ListCell> getCellsLookup() {
1525 testedControl.mouse().click();
1526
1527 Wrap<? extends ListView> listWrap = getPopupWrap().as(Parent.class, Node.class)
1528 .lookup(ListView.class).wrap();
1529
1530 Lookup lookup = listWrap.as(Parent.class, Node.class)
1531 .lookup(ListCell.class, new LookupCriteria<ListCell>() {
1532 public boolean check(ListCell cell) {
1533 return cell.isVisible();
1534 }
1535 });
1536
1537 testedControl.keyboard().pushKey(KeyboardButtons.ESCAPE);
1538
1539 return lookup;
1540 }
1541
1542 @Override
1543 protected String getTextFromCell(ListCell cell) {
1544 return cell.getText();
1545 }
1546 };
1547
1548 boolean result = validator.check();
1549 String msg = validator.getFailureReason();
1550 assertTrue(msg, result);
1551 }
1552
1553 /**
1554 * When there are no items, or items list is null, placeholder about items
1555 * emptyness is shown in the popup. This test changes placeholder and
1556 * checks, that it is shown when popup is shown.
1557 */
1558 @Smoke
1559 @Test(timeout = 30000)
1560 public void emptyListDropDownPlaceholderTest() throws Throwable {
1561 placeholderTestLoop(true);
1562 placeholderTestLoop(false);
1563
1564 selectObjectFromChoiceBox(SettingType.UNIDIRECTIONAL, Properties.placeholder, Label.class);
1565 if (!isPopupVisible(false)) {
1566 clickDropDownButton();
1567 }
1568
1569 //wait for animation
1570 try {
1571 Thread.sleep(SLEEP);
1572 } catch (Exception ignore) {
1573 }
1574
1575 checkScreenshot("combobox_placeholder_dimmed",
1576 new NodeWrap(testedControl.getEnvironment(), new GetAction<Node>() {
1577 @Override
1578 public void run(Object... os) throws Exception {
1579 setResult(((javafx.scene.Parent) getPopupWrap().getControl().getRoot().getChildrenUnmodifiable().get(0)).getChildrenUnmodifiable().get(0));
1580 }
1581 }.dispatch(Root.ROOT.getEnvironment())));
1582 throwScreenshotError();
1583 }
1584
1585 private void placeholderTestLoop(boolean withPopupClosedState) {
1586 assertEquals("Check initial emptyness of items list.", new GetAction<Integer>() {
1587 @Override
1588 public void run(Object... os) throws Exception {
1589 setResult(testedControl.getControl().getItems().size());
1590 }
1591 }.dispatch(testedControl.getEnvironment()), 0, 0);
1592
1593 selectObjectFromChoiceBox(SettingType.SETTER, Properties.placeholder, Rectangle.class);
1594 checkTextFieldTextContaining(Properties.placeholder, "Rectangle");
1595 testEmptyPlaceholder(Rectangle.class, true, withPopupClosedState);
1596
1597 addElement("0", 0);
1598 testEmptyPlaceholder(Rectangle.class, false, withPopupClosedState);
1599
1600 removeFromPos(0);
1601 testEmptyPlaceholder(Rectangle.class, true, withPopupClosedState);
1602
1603 selectObjectFromChoiceBox(SettingType.BIDIRECTIONAL, Properties.placeholder, Polygon.class);
1604 checkTextFieldTextContaining(Properties.placeholder, "Polygon");
1605 testEmptyPlaceholder(Polygon.class, true, withPopupClosedState);
1606
1607 clickButtonForTestPurpose(SET_ITEMS_NULL_BUTTON_ID);
1608 testEmptyPlaceholder(Polygon.class, true, withPopupClosedState);
1609
1610 selectObjectFromChoiceBox(SettingType.UNIDIRECTIONAL, Properties.placeholder, Rectangle.class);
1611 checkTextFieldTextContaining(Properties.placeholder, "Rectangle");
1612 testEmptyPlaceholder(Rectangle.class, true, withPopupClosedState);
1613
1614 new GetAction() {
1615 @Override
1616 public void run(Object... os) throws Exception {
1617 testedControl.getControl().setItems(FXCollections.<String>observableArrayList("1"));
1618 }
1619 }.dispatch(testedControl.getEnvironment());
1620 testEmptyPlaceholder(Rectangle.class, false, withPopupClosedState);
1621
1622 removeFromPos(0);
1623 }
1624
1625 private void testEmptyPlaceholder(final Class classOfPlaceholder, boolean expectedToBeShown, boolean closePopupAfter) {
1626 if (!isPopupVisible()) {
1627 clickDropDownButton();
1628 }
1629
1630 testedControl.waitState(new State<Integer>() {
1631 public Integer reached() {
1632 final Lookup<Node> lookup = getPopupWrap().as(Parent.class, Node.class).lookup(classOfPlaceholder);
1633 final int size = lookup.size();
1634 if (size == 0) {
1635 return 0;
1636 } else {
1637 final Wrap placeholderPane = getPopupWrap().as(Parent.class, Node.class).lookup(new ByStyleClass("placeholder")).wrap(0);
1638 final Parent<Node> parent = (Parent<Node>) placeholderPane.as(Parent.class, Node.class);
1639 assertTrue("Double check : there still must be a placeholder.", parent.lookup(classOfPlaceholder).size() > 0);
1640 if (!new GetAction<Boolean>() {
1641 @Override
1642 public void run(Object... os) throws Exception {
1643 setResult(((Wrap<Node>) os[0]).getControl().isVisible());
1644 }
1645 }.dispatch(testedControl.getEnvironment(), placeholderPane)) {
1646 return 0;
1647 } else {
1648 return 1;
1649 }
1650 }
1651 }
1652 }, expectedToBeShown ? 1 : 0);
1653
1654 if (closePopupAfter) {
1655 clickDropDownButton();
1656 }
1657 }
1658 }