1 /*
2 * Copyright (c) 2012, 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
26 package test.javafx.scene.layout;
27
28 import test.com.sun.javafx.pgstub.StubImageLoaderFactory;
29 import test.com.sun.javafx.pgstub.StubPlatformImageInfo;
30 import test.com.sun.javafx.pgstub.StubToolkit;
31 import com.sun.javafx.tk.Toolkit;
32 import javafx.geometry.Insets;
33 import javafx.geometry.Side;
34 import javafx.scene.Scene;
35 import javafx.scene.paint.Color;
36 import org.junit.Before;
37 import org.junit.Ignore;
38 import org.junit.Test;
39
40 import java.net.MalformedURLException;
41 import java.net.URI;
42 import java.net.URISyntaxException;
43 import java.net.URL;
44 import javafx.scene.layout.BackgroundFill;
45 import javafx.scene.layout.BackgroundImage;
46 import javafx.scene.layout.BackgroundPosition;
47 import javafx.scene.layout.BackgroundRepeat;
48 import javafx.scene.layout.BackgroundSize;
49 import javafx.scene.layout.BorderImage;
50 import javafx.scene.layout.BorderRepeat;
51 import javafx.scene.layout.BorderStroke;
52 import javafx.scene.layout.BorderStrokeStyle;
53 import javafx.scene.layout.BorderWidths;
54 import javafx.scene.layout.CornerRadii;
55 import javafx.scene.layout.Region;
56
57 import static javafx.scene.layout.BackgroundSize.*;
58 import static org.junit.Assert.*;
59
60 /**
61 * All of these tests are based on information contained in the CSS 3 borders
62 * and backgrounds specification: http://www.w3.org/TR/css3-background/
63 *
64 * The "Example" tests are pulled directly from one of the examples in the
65 * spec, and is numbered such as example1_3, meaning "Example 1" in the spec
66 * which is a box with multiple declarations, so declaration 3 (or whatnot).
67 */
68 public class RegionCSSTest {
69 // The color is drawn behind any background images.
70 // The background color is clipped according to the ???background-clip??? value associated with the bottom-most background image.
71 // Background images are drawn such that the first specified is on "top", closer to the user. But our BackgroundFill's are completely backwards from that!
72
73 // Test "none" in terms of supplying an insets to the first and third but not specifying the second?
74 // Failures to load images should result in "none" equivalence, not in exceptions
75 //
76 private Region region;
77 private Scene scene;
78 private static final String NL = System.getProperty("line.separator");
79
80 private void processCSS() {
81 scene.getRoot().applyCss();
82 }
83
84 private static void installImage(final String str) {
85
86 if (str == null || str.trim().isEmpty()) return;
87
88 URL imageUrl = null;
89
90 try {
91
92 URI uri = new URI(str.trim());
93
94 // if url doesn't have a scheme
95 if (uri.isAbsolute() == false) {
96
97 final ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
98 final String path = uri.getPath();
99
100 URL resource = null;
101
102 if (path.startsWith("/")) {
103 resource = contextClassLoader.getResource(path.substring(1));
104 } else {
105 resource = contextClassLoader.getResource(path);
106 }
107
108 imageUrl = resource;
109
110 } else {
111 // else, url does have a scheme
112 imageUrl = uri.toURL();
113 }
114
115 } catch (MalformedURLException malf) {
116
117 } catch (URISyntaxException urise) {
118 }
119
120 if (imageUrl != null) {
121
122 StubImageLoaderFactory imageLoaderFactory =
123 ((StubToolkit) Toolkit.getToolkit()).getImageLoaderFactory();
124
125 imageLoaderFactory.registerImage(
126 imageUrl.toExternalForm(), new StubPlatformImageInfo(100, 100));
127 }
128
129 }
130
131 @Before public void setUp() {
132 region = new Region();
133 scene = new Scene(region);
134
135 installImage("test/javafx/scene/layout/red.png");
136 installImage("test/javafx/scene/layout/green.png");
137 installImage("test/javafx/scene/layout/blue.png");
138 installImage("test/javafx/scene/layout/center-btn.png");
139 }
140
141 /**************************************************************************
142 * *
143 * Basic tests *
144 * *
145 *************************************************************************/
146
147 @Test public void nothingSpecified() {
148 region.setStyle("-fx-padding: 1;");
149 processCSS();
150
151 assertEquals(new Insets(1), region.getPadding());
152 assertNull(region.getBackground());
153 assertNull(region.getBorder());
154 }
155
156 /**************************************************************************
157 * *
158 * Background Color tests *
159 * *
160 * These include -fx-background-color, -fx-background-radius, and *
161 * -fx-background-insets. *
162 * *
163 *************************************************************************/
164
165 @Test public void fillIsNull() {
166 region.setStyle("-fx-background-color: null;");
167 processCSS();
168
169 assertEquals(new Insets(0), region.getPadding());
170 assertNull(region.getBackground());
171 assertNull(region.getBorder());
172 }
173
174 @Test public void fillIsTransparent() {
175 region.setStyle("-fx-background-color: transparent;");
176 processCSS();
177
178 assertNull(region.getBorder());
179 assertEquals(1, region.getBackground().getFills().size(), 0);
180
181 BackgroundFill fill = region.getBackground().getFills().get(0);
182 BackgroundFill expected = new BackgroundFill(Color.TRANSPARENT, null, null);
183 assertEquals(expected, fill);
184 }
185
186 @Test public void fillIsSpecifiedOnly() {
187 region.setStyle("-fx-background-color: purple;");
188 processCSS();
189
190 assertNull(region.getBorder());
191 assertEquals(1, region.getBackground().getFills().size(), 0);
192
193 BackgroundFill fill = region.getBackground().getFills().get(0);
194 BackgroundFill expected = new BackgroundFill(Color.PURPLE, null, null);
195 assertEquals(expected, fill);
196 }
197
198 @Test public void insetsIsSpecifiedOnly() {
199 region.setStyle("-fx-background-insets: 1;");
200 processCSS();
201
202 assertNull(region.getBackground());
203 assertNull(region.getBorder());
204 }
205
206 @Test public void radiusIsSpecifiedOnly() {
207 region.setStyle("-fx-background-radius: 1;");
208 processCSS();
209
210 assertNull(region.getBackground());
211 assertNull(region.getBorder());
212 }
213
214 @Test public void testWithExcessInsets() {
215 region.setStyle(
216 "-fx-background-color: red;" +
217 "-fx-background-insets: 0 0 -1 0, 0, 1, 2;");
218 processCSS();
219
220 assertEquals(1, region.getBackground().getFills().size(), 0);
221 assertEquals(0, region.getBackground().getImages().size(), 0);
222 assertNull(region.getBorder());
223
224 BackgroundFill fill = region.getBackground().getFills().get(0);
225 BackgroundFill expected = new BackgroundFill(Color.RED, null, new Insets(0, 0, -1, 0));
226 assertEquals(expected, fill);
227 }
228
229 @Test public void testWithExcessRadius() {
230 region.setStyle(
231 "-fx-background-color: red;" +
232 "-fx-background-radius: 0 0 0 0, 0, 1, 2;");
233 processCSS();
234
235 assertEquals(1, region.getBackground().getFills().size(), 0);
236 assertEquals(0, region.getBackground().getImages().size(), 0);
237 assertNull(region.getBorder());
238
239 BackgroundFill fill = region.getBackground().getFills().get(0);
240 BackgroundFill expected = new BackgroundFill(Color.RED, new CornerRadii(0), null);
241 assertEquals(expected, fill);
242 }
243
244 @Test public void backgroundScenario1() {
245 region.setStyle(
246 "-fx-background-color: red;" +
247 "-fx-background-insets: 0 0 -1 0, 0, 1, 2;" +
248 "-fx-background-radius: 1 2 3 4;" +
249 "-fx-padding: 10 20 30 40;");
250 processCSS();
251
252 assertEquals(new Insets(10, 20, 30, 40), region.getPadding());
253 assertEquals(1, region.getBackground().getFills().size(), 0);
254 assertEquals(0, region.getBackground().getImages().size(), 0);
255 assertNull(region.getBorder());
256
257 BackgroundFill fill = region.getBackground().getFills().get(0);
258 BackgroundFill expected = new BackgroundFill(Color.RED, new CornerRadii(1, 2, 3, 4, false), new Insets(0, 0, -1, 0));
259 assertEquals(expected, fill);
260 }
261
262 @Test public void backgroundScenario2() {
263 region.setStyle(
264 "-fx-background-color: red, green, blue, yellow;" +
265 "-fx-background-insets: 0 0 -1 0, 1;" +
266 "-fx-background-radius: 1 2 3 4, 5, 6 7 8 9;" +
267 "-fx-padding: 10 20 30 40;");
268 processCSS();
269
270 assertEquals(new Insets(10, 20, 30, 40), region.getPadding());
271 assertEquals(4, region.getBackground().getFills().size(), 0);
272 assertEquals(0, region.getBackground().getImages().size(), 0);
273 assertNull(region.getBorder());
274
275 BackgroundFill fill = region.getBackground().getFills().get(0);
276 BackgroundFill expected = new BackgroundFill(Color.RED, new CornerRadii(1, 2, 3, 4, false), new Insets(0, 0, -1, 0));
277 assertEquals(expected, fill);
278
279 fill = region.getBackground().getFills().get(1);
280 expected = new BackgroundFill(Color.GREEN, new CornerRadii(5), new Insets(1));
281 assertEquals(expected, fill);
282
283 fill = region.getBackground().getFills().get(2);
284 expected = new BackgroundFill(Color.BLUE, new CornerRadii(6, 7, 8, 9, false), new Insets(1));
285 assertEquals(expected, fill);
286
287 fill = region.getBackground().getFills().get(3);
288 expected = new BackgroundFill(Color.YELLOW, new CornerRadii(6, 7, 8, 9, false), new Insets(1));
289 assertEquals(expected, fill);
290 }
291
292 @Test public void backgroundScenario3() {
293 region.setStyle(
294 "-fx-background-color: red, green, blue, yellow;" +
295 "-fx-background-insets: 0 0 -1 0, 0, 1, 2;" +
296 "-fx-background-radius: 1 2 3 4;" +
297 "-fx-padding: 10 20 30 40;");
298 processCSS();
299
300 assertEquals(new Insets(10, 20, 30, 40), region.getPadding());
301 assertEquals(4, region.getBackground().getFills().size(), 0);
302
303 BackgroundFill fill = region.getBackground().getFills().get(0);
304 BackgroundFill expected = new BackgroundFill(Color.RED, new CornerRadii(1, 2, 3, 4, false), new Insets(0, 0, -1, 0));
305 assertEquals(expected, fill);
306
307 fill = region.getBackground().getFills().get(1);
308 expected = new BackgroundFill(Color.GREEN, new CornerRadii(1, 2, 3, 4, false), new Insets(0));
309 assertEquals(expected, fill);
310
311 fill = region.getBackground().getFills().get(2);
312 expected = new BackgroundFill(Color.BLUE, new CornerRadii(1, 2, 3, 4, false), new Insets(1));
313 assertEquals(expected, fill);
314
315 fill = region.getBackground().getFills().get(3);
316 expected = new BackgroundFill(Color.YELLOW, new CornerRadii(1, 2, 3, 4, false), new Insets(2));
317 assertEquals(expected, fill);
318 }
319
320 /**
321 * From the specification: http://www.w3.org/TR/css3-background/
322 * This is "Example 1", except modified for multiple background fills
323 */
324 @Test public void specExample1_ModifiedForBackgroundFill() {
325 region.setStyle(
326 "-fx-background-color: red, green, blue;" +
327 "-fx-background-insets: 1, 2, 3, 4;" + // An extra value here, which should be ignored
328 "-fx-background-radius: 1;");
329 processCSS();
330
331 assertEquals(3, region.getBackground().getFills().size());
332
333 BackgroundFill fill = region.getBackground().getFills().get(0);
334 BackgroundFill expected = new BackgroundFill(Color.RED, new CornerRadii(1), new Insets(1));
335 assertEquals(expected, fill);
336
337 fill = region.getBackground().getFills().get(1);
338 expected = new BackgroundFill(Color.GREEN, new CornerRadii(1), new Insets(2));
339 assertEquals(expected, fill);
340
341 fill = region.getBackground().getFills().get(2);
342 expected = new BackgroundFill(Color.BLUE, new CornerRadii(1), new Insets(3));
343 assertEquals(expected, fill);
344 }
345
346 // See example 23 in http://www.w3.org/TR/css3-background/#the-border-radius
347 @Test public void testBackgroundRadiusWithHorizontalAndVerticalRadii() {
348
349 region.setStyle("-fx-background-color: black; -fx-background-radius: 2px 1px 4px / 0.5px 3px;");
350 processCSS();
351
352 assertNull(region.getBorder());
353 assertEquals(1, region.getBackground().getFills().size(), 0);
354 assertEquals(0, region.getBackground().getImages().size(), 0);
355
356 BackgroundFill fill = region.getBackground().getFills().get(0);
357 BackgroundFill expected = new BackgroundFill(Color.BLACK,
358 new CornerRadii(2, .5, 3, 1, 4, .5, 3, 1, false, false, false, false, false, false, false, false),
359 Insets.EMPTY);
360
361 assertEquals(expected, fill);
362
363 }
364
365
366 /**************************************************************************
367 * *
368 * Background Image tests *
369 * *
370 * These include -fx-background-image, -fx-background-repeat, *
371 * -fx-background-position, -fx-background-clip, -fx-background-origin, *
372 * and -fx-background-size. -fx-background-attachment does not yet exist *
373 * and is not supported. *
374 * *
375 *************************************************************************/
376
377
378 /**
379 * From the specification: http://www.w3.org/TR/css3-background/.
380 *
381 * This is something of a comprehensive test, whereas most of the unit tests
382 * in this file are checking one specific aspect of the functionality tested
383 * herein.
384 */
385 @Test public void specExample1() {
386 region.setStyle(
387 "-fx-background-image: url(test/javafx/scene/layout/red.png), url(test/javafx/scene/layout/green.png), url(test/javafx/scene/layout/blue.png);" +
388 "-fx-background-position: center center, 20% 80%, top left, bottom right;" +
389 // TODO re-enable once I know how to test for background-origin
390 //"-fx-background-origin: border-box, content-box;" +
391 "-fx-background-repeat: no-repeat;");
392 processCSS();
393
394 assertEquals(0, region.getBackground().getFills().size(), 0);
395 assertEquals(3, region.getBackground().getImages().size(), 0);
396 assertNull(region.getBorder());
397
398 BackgroundImage image = region.getBackground().getImages().get(0);
399 BackgroundImage expected = new BackgroundImage(image.getImage(),
400 BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
401 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, .5, true),
402 BackgroundSize.DEFAULT);
403 assertEquals(expected, image);
404
405 image = region.getBackground().getImages().get(1);
406 expected = new BackgroundImage(image.getImage(),
407 BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
408 new BackgroundPosition(Side.LEFT, .2, true, Side.TOP, .8, true),
409 BackgroundSize.DEFAULT);
410 assertEquals(expected, image);
411
412 image = region.getBackground().getImages().get(2);
413 expected = new BackgroundImage(image.getImage(),
414 BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
415 BackgroundPosition.DEFAULT,
416 BackgroundSize.DEFAULT);
417 assertEquals(expected, image);
418 }
419
420 @Test public void backgroundImageRepeat_repeatX() {
421 region.setStyle(
422 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
423 "-fx-background-repeat: repeat-x;");
424 processCSS();
425
426 assertEquals(0, region.getBackground().getFills().size(), 0);
427 assertEquals(1, region.getBackground().getImages().size(), 0);
428 assertNull(region.getBorder());
429
430 BackgroundImage image = region.getBackground().getImages().get(0);
431 BackgroundImage expected = new BackgroundImage(image.getImage(),
432 BackgroundRepeat.REPEAT, BackgroundRepeat.NO_REPEAT,
433 BackgroundPosition.DEFAULT,
434 new BackgroundSize(AUTO, AUTO, true, true, false, false));
435 assertEquals(expected, image);
436 }
437
438 @Test public void backgroundImageRepeat_repeatY() {
439 region.setStyle(
440 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
441 "-fx-background-repeat: repeat-y;");
442 processCSS();
443
444 assertEquals(0, region.getBackground().getFills().size(), 0);
445 assertEquals(1, region.getBackground().getImages().size(), 0);
446 assertNull(region.getBorder());
447
448 BackgroundImage image = region.getBackground().getImages().get(0);
449 BackgroundImage expected = new BackgroundImage(image.getImage(),
450 BackgroundRepeat.NO_REPEAT, BackgroundRepeat.REPEAT,
451 BackgroundPosition.DEFAULT,
452 new BackgroundSize(AUTO, AUTO, true, true, false, false));
453 assertEquals(expected, image);
454 }
455
456 @Test public void backgroundImageRepeat_repeat() {
457 region.setStyle(
458 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
459 "-fx-background-repeat: repeat;");
460 processCSS();
461
462 assertEquals(0, region.getBackground().getFills().size(), 0);
463 assertEquals(1, region.getBackground().getImages().size(), 0);
464 assertNull(region.getBorder());
465
466 BackgroundImage image = region.getBackground().getImages().get(0);
467 BackgroundImage expected = new BackgroundImage(image.getImage(),
468 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
469 BackgroundPosition.DEFAULT,
470 new BackgroundSize(AUTO, AUTO, true, true, false, false));
471 assertEquals(expected, image);
472 }
473
474 @Test public void backgroundImageRepeat_space() {
475 region.setStyle(
476 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
477 "-fx-background-repeat: space;");
478 processCSS();
479
480 assertEquals(0, region.getBackground().getFills().size(), 0);
481 assertEquals(1, region.getBackground().getImages().size(), 0);
482 assertNull(region.getBorder());
483
484 BackgroundImage image = region.getBackground().getImages().get(0);
485 BackgroundImage expected = new BackgroundImage(image.getImage(),
486 BackgroundRepeat.SPACE, BackgroundRepeat.SPACE,
487 BackgroundPosition.DEFAULT,
488 new BackgroundSize(AUTO, AUTO, true, true, false, false));
489 assertEquals(expected, image);
490 }
491
492 @Test public void backgroundImageRepeat_round() {
493 region.setStyle(
494 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
495 "-fx-background-repeat: round;");
496 processCSS();
497
498 assertEquals(0, region.getBackground().getFills().size(), 0);
499 assertEquals(1, region.getBackground().getImages().size(), 0);
500 assertNull(region.getBorder());
501
502 BackgroundImage image = region.getBackground().getImages().get(0);
503 BackgroundImage expected = new BackgroundImage(image.getImage(),
504 BackgroundRepeat.ROUND, BackgroundRepeat.ROUND,
505 BackgroundPosition.DEFAULT,
506 new BackgroundSize(AUTO, AUTO, true, true, false, false));
507 assertEquals(expected, image);
508 }
509
510 @Test public void backgroundImageRepeat_noRepeat() {
511 region.setStyle(
512 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
513 "-fx-background-repeat: no-repeat;");
514 processCSS();
515
516 assertEquals(0, region.getBackground().getFills().size(), 0);
517 assertEquals(1, region.getBackground().getImages().size(), 0);
518 assertNull(region.getBorder());
519
520 BackgroundImage image = region.getBackground().getImages().get(0);
521 BackgroundImage expected = new BackgroundImage(image.getImage(),
522 BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
523 BackgroundPosition.DEFAULT,
524 new BackgroundSize(AUTO, AUTO, true, true, false, false));
525 assertEquals(expected, image);
526 }
527
528 @Test public void backgroundImageRepeat_repeat_space() {
529 region.setStyle(
530 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
531 "-fx-background-repeat: repeat space;");
532 processCSS();
533
534 assertEquals(0, region.getBackground().getFills().size(), 0);
535 assertEquals(1, region.getBackground().getImages().size(), 0);
536 assertNull(region.getBorder());
537
538 BackgroundImage image = region.getBackground().getImages().get(0);
539 BackgroundImage expected = new BackgroundImage(image.getImage(),
540 BackgroundRepeat.REPEAT, BackgroundRepeat.SPACE,
541 BackgroundPosition.DEFAULT,
542 new BackgroundSize(AUTO, AUTO, true, true, false, false));
543 assertEquals(expected, image);
544 }
545
546 @Test public void backgroundImageRepeat_round_noRepeat() {
547 region.setStyle(
548 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
549 "-fx-background-repeat: round no-repeat;");
550 processCSS();
551
552 assertEquals(0, region.getBackground().getFills().size(), 0);
553 assertEquals(1, region.getBackground().getImages().size(), 0);
554 assertNull(region.getBorder());
555
556 BackgroundImage image = region.getBackground().getImages().get(0);
557 BackgroundImage expected = new BackgroundImage(image.getImage(),
558 BackgroundRepeat.ROUND, BackgroundRepeat.NO_REPEAT,
559 BackgroundPosition.DEFAULT,
560 new BackgroundSize(AUTO, AUTO, true, true, false, false));
561 assertEquals(expected, image);
562 }
563
564 // try "center left"
565 // try "50% left" -- shouldn't work
566 // try 3 values... remaining one should be 0
567 // If only one value is specified, the second value is assumed to be ???center??? -- whatever this means...
568 @Test public void backgroundImagePosition_right_bottom() {
569 region.setStyle(
570 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
571 "-fx-background-position: right 20px bottom 10px;");
572 processCSS();
573
574 assertEquals(0, region.getBackground().getFills().size(), 0);
575 assertEquals(1, region.getBackground().getImages().size(), 0);
576 assertNull(region.getBorder());
577
578 BackgroundImage image = region.getBackground().getImages().get(0);
579 BackgroundImage expected = new BackgroundImage(image.getImage(),
580 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
581 new BackgroundPosition(Side.RIGHT, 20, false, Side.BOTTOM, 10, false),
582 new BackgroundSize(AUTO, AUTO, true, true, false, false));
583 assertEquals(expected, image);
584 }
585
586 private static String dump(BackgroundImage image) {
587 StringBuilder b = new StringBuilder("BackgroundImage[");
588 b.append(NL + " image: " + image.getImage());
589 b.append(NL + " position: " + dump(image.getPosition()));
590 b.append(NL + " repeat-x: " + image.getRepeatX());
591 b.append(NL + " repeat-y: " + image.getRepeatY());
592 b.append(NL + " size: " + dump(image.getSize()));
593 b.append(NL + "]");
594 return b.toString();
595 }
596
597 private static String dump(BackgroundSize size) {
598 StringBuilder b = new StringBuilder("BackgroundSize[");
599 b.append(NL + " width: " + size.getWidth());
600 b.append(NL + " height: " + size.getHeight());
601 b.append(NL + " widthAsPercentage: " + size.isHeightAsPercentage());
602 b.append(NL + " heightAsPercentage: " + size.isWidthAsPercentage());
603 b.append(NL + " contain: " + size.isContain());
604 b.append(NL + " cover: " + size.isCover());
605 b.append(NL + " ]");
606 return b.toString();
607 }
608
609 private static String dump(BackgroundPosition position) {
610 StringBuilder b = new StringBuilder("BackgroundPosition[");
611 b.append(NL + " hSide: " + position.getHorizontalSide());
612 b.append(NL + " hPosition: " + position.getHorizontalPosition());
613 b.append(NL + " hAsPercentage: " + position.isHorizontalAsPercentage());
614 b.append(NL + " vSide: " + position.getVerticalSide());
615 b.append(NL + " vPosition: " + position.getVerticalPosition());
616 b.append(NL + " vAsPercentage: " + position.isVerticalAsPercentage());
617 b.append(NL + " ]");
618 return b.toString();
619 }
620
621 @Test public void backgroundImagePosition_bottom_right() {
622 region.setStyle(
623 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
624 "-fx-background-position: bottom 10px right 20px;");
625 processCSS();
626
627 assertEquals(0, region.getBackground().getFills().size(), 0);
628 assertEquals(1, region.getBackground().getImages().size(), 0);
629 assertNull(region.getBorder());
630
631 BackgroundImage image = region.getBackground().getImages().get(0);
632 BackgroundImage expected = new BackgroundImage(image.getImage(),
633 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
634 new BackgroundPosition(Side.RIGHT, 20, false, Side.BOTTOM, 10, false),
635 new BackgroundSize(AUTO, AUTO, true, true, false, false));
636 assertEquals(expected, image);
637 }
638
639 @Test public void backgroundImagePosition_top() {
640 region.setStyle(
641 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
642 "-fx-background-position: top;");
643 processCSS();
644
645 assertEquals(0, region.getBackground().getFills().size(), 0);
646 assertEquals(1, region.getBackground().getImages().size(), 0);
647 assertNull(region.getBorder());
648
649 BackgroundImage image = region.getBackground().getImages().get(0);
650 BackgroundImage expected = new BackgroundImage(image.getImage(),
651 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
652 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, 0, true),
653 new BackgroundSize(AUTO, AUTO, true, true, false, false));
654 assertEquals(expected, image);
655 }
656
657 @Test public void backgroundImagePosition_left() {
658 region.setStyle(
659 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
660 "-fx-background-position: left;");
661 processCSS();
662
663 assertEquals(0, region.getBackground().getFills().size(), 0);
664 assertEquals(1, region.getBackground().getImages().size(), 0);
665 assertNull(region.getBorder());
666
667 BackgroundImage image = region.getBackground().getImages().get(0);
668 BackgroundImage expected = new BackgroundImage(image.getImage(),
669 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
670 new BackgroundPosition(Side.LEFT, 0, true, Side.TOP, .5, true),
671 new BackgroundSize(AUTO, AUTO, true, true, false, false));
672 assertEquals(expected, image);
673 }
674
675 @Test public void backgroundImagePosition_center() {
676 region.setStyle(
677 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
678 "-fx-background-position: center;");
679 processCSS();
680
681 assertEquals(0, region.getBackground().getFills().size(), 0);
682 assertEquals(1, region.getBackground().getImages().size(), 0);
683 assertNull(region.getBorder());
684
685 BackgroundImage image = region.getBackground().getImages().get(0);
686 BackgroundImage expected = new BackgroundImage(image.getImage(),
687 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
688 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, .5, true),
689 new BackgroundSize(AUTO, AUTO, true, true, false, false));
690 assertEquals(expected, image);
691 }
692
693 @Test public void backgroundImagePosition_right() {
694 region.setStyle(
695 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
696 "-fx-background-position: right;");
697 processCSS();
698
699 assertEquals(0, region.getBackground().getFills().size(), 0);
700 assertEquals(1, region.getBackground().getImages().size(), 0);
701 assertNull(region.getBorder());
702
703 BackgroundImage image = region.getBackground().getImages().get(0);
704 BackgroundImage expected = new BackgroundImage(image.getImage(),
705 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
706 new BackgroundPosition(Side.LEFT, 1, true, Side.TOP, .5, true),
707 new BackgroundSize(AUTO, AUTO, true, true, false, false));
708 assertEquals(expected, image);
709 }
710
711 @Test public void backgroundImagePosition_bottom() {
712 region.setStyle(
713 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
714 "-fx-background-position: bottom;");
715 processCSS();
716
717 assertEquals(0, region.getBackground().getFills().size(), 0);
718 assertEquals(1, region.getBackground().getImages().size(), 0);
719 assertNull(region.getBorder());
720
721 BackgroundImage image = region.getBackground().getImages().get(0);
722 BackgroundImage expected = new BackgroundImage(image.getImage(),
723 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
724 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, 1, true),
725 new BackgroundSize(AUTO, AUTO, true, true, false, false));
726 assertEquals(expected, image);
727 }
728
729 @Test public void backgroundImagePosition_center_top() {
730 region.setStyle(
731 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
732 "-fx-background-position: center top;");
733 processCSS();
734
735 assertEquals(0, region.getBackground().getFills().size(), 0);
736 assertEquals(1, region.getBackground().getImages().size(), 0);
737 assertNull(region.getBorder());
738
739 BackgroundImage image = region.getBackground().getImages().get(0);
740 BackgroundImage expected = new BackgroundImage(image.getImage(),
741 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
742 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, 0, true),
743 new BackgroundSize(AUTO, AUTO, true, true, false, false));
744 assertEquals(expected, image);
745 }
746
747 @Test public void backgroundImagePosition_Example8_1() {
748 region.setStyle(
749 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
750 "-fx-background-position: left 10px top 15px;");
751 processCSS();
752
753 assertEquals(0, region.getBackground().getFills().size(), 0);
754 assertEquals(1, region.getBackground().getImages().size(), 0);
755 assertNull(region.getBorder());
756
757 BackgroundImage image = region.getBackground().getImages().get(0);
758 BackgroundImage expected = new BackgroundImage(image.getImage(),
759 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
760 new BackgroundPosition(Side.LEFT, 10, false, Side.TOP, 15, false),
761 new BackgroundSize(AUTO, AUTO, true, true, false, false));
762 assertEquals(expected, image);
763 }
764
765 @Test public void backgroundImagePosition_Example8_2() {
766 region.setStyle(
767 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
768 "-fx-background-position: left top;");
769 processCSS();
770
771 assertEquals(0, region.getBackground().getFills().size(), 0);
772 assertEquals(1, region.getBackground().getImages().size(), 0);
773 assertNull(region.getBorder());
774
775 BackgroundImage image = region.getBackground().getImages().get(0);
776 BackgroundImage expected = new BackgroundImage(image.getImage(),
777 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
778 BackgroundPosition.DEFAULT,
779 new BackgroundSize(AUTO, AUTO, true, true, false, false));
780 assertEquals(expected, image);
781 }
782
783 @Test public void backgroundImagePosition_Example8_3() {
784 region.setStyle(
785 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
786 "-fx-background-position: 10px 15px;");
787 processCSS();
788
789 assertEquals(0, region.getBackground().getFills().size(), 0);
790 assertEquals(1, region.getBackground().getImages().size(), 0);
791 assertNull(region.getBorder());
792
793 BackgroundImage image = region.getBackground().getImages().get(0);
794 BackgroundImage expected = new BackgroundImage(image.getImage(),
795 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
796 new BackgroundPosition(Side.LEFT, 10, false, Side.TOP, 15, false),
797 new BackgroundSize(AUTO, AUTO, true, true, false, false));
798 assertEquals(expected, image);
799 }
800
801 @Test public void backgroundImagePosition_Example8_4() {
802 region.setStyle(
803 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
804 "-fx-background-position: left 15px;");
805 processCSS();
806
807 assertEquals(0, region.getBackground().getFills().size(), 0);
808 assertEquals(1, region.getBackground().getImages().size(), 0);
809 assertNull(region.getBorder());
810
811 BackgroundImage image = region.getBackground().getImages().get(0);
812 BackgroundImage expected = new BackgroundImage(image.getImage(),
813 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
814 new BackgroundPosition(Side.LEFT, 0, true, Side.TOP, 15, false),
815 new BackgroundSize(AUTO, AUTO, true, true, false, false));
816 assertEquals(expected, image);
817 }
818
819 @Test public void backgroundImagePosition_Example8_5() {
820 region.setStyle(
821 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
822 "-fx-background-position: 10px top;");
823 processCSS();
824
825 assertEquals(0, region.getBackground().getFills().size(), 0);
826 assertEquals(1, region.getBackground().getImages().size(), 0);
827 assertNull(region.getBorder());
828
829 BackgroundImage image = region.getBackground().getImages().get(0);
830 BackgroundImage expected = new BackgroundImage(image.getImage(),
831 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
832 new BackgroundPosition(Side.LEFT, 10, false, Side.TOP, 0, true),
833 new BackgroundSize(AUTO, AUTO, true, true, false, false));
834 assertEquals(expected, image);
835 }
836
837 @Test public void backgroundImagePosition_Example8_6() {
838 region.setStyle(
839 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
840 "-fx-background-position: left top 15px;");
841 processCSS();
842
843 assertEquals(0, region.getBackground().getFills().size(), 0);
844 assertEquals(1, region.getBackground().getImages().size(), 0);
845 assertNull(region.getBorder());
846
847 BackgroundImage image = region.getBackground().getImages().get(0);
848 BackgroundImage expected = new BackgroundImage(image.getImage(),
849 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
850 new BackgroundPosition(Side.LEFT, 0, true, Side.TOP, 15, false),
851 new BackgroundSize(AUTO, AUTO, true, true, false, false));
852 assertEquals(expected, image);
853 }
854
855 @Test public void backgroundImagePosition_Example8_7() {
856 region.setStyle(
857 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
858 "-fx-background-position: left 10px top;");
859 processCSS();
860
861 assertEquals(0, region.getBackground().getFills().size(), 0);
862 assertEquals(1, region.getBackground().getImages().size(), 0);
863 assertNull(region.getBorder());
864
865 BackgroundImage image = region.getBackground().getImages().get(0);
866 BackgroundImage expected = new BackgroundImage(image.getImage(),
867 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
868 new BackgroundPosition(Side.LEFT, 10, false, Side.TOP, 0, true),
869 new BackgroundSize(AUTO, AUTO, true, true, false, false));
870 assertEquals(expected, image);
871 }
872
873 @Test public void backgroundImagePosition_Example10_1() {
874 region.setStyle(
875 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
876 "-fx-background-position: right top;");
877 processCSS();
878
879 assertEquals(0, region.getBackground().getFills().size(), 0);
880 assertEquals(1, region.getBackground().getImages().size(), 0);
881 assertNull(region.getBorder());
882
883 BackgroundImage image = region.getBackground().getImages().get(0);
884 BackgroundImage expected = new BackgroundImage(image.getImage(),
885 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
886 new BackgroundPosition(Side.LEFT, 1, true, Side.TOP, 0, true),
887 new BackgroundSize(AUTO, AUTO, true, true, false, false));
888 assertEquals(expected, image);
889 }
890
891 @Test public void backgroundImagePosition_Example10_2() {
892 region.setStyle(
893 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
894 "-fx-background-position: top center;");
895 processCSS();
896
897 assertEquals(0, region.getBackground().getFills().size(), 0);
898 assertEquals(1, region.getBackground().getImages().size(), 0);
899 assertNull(region.getBorder());
900
901 BackgroundImage image = region.getBackground().getImages().get(0);
902 BackgroundImage expected = new BackgroundImage(image.getImage(),
903 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
904 new BackgroundPosition(Side.LEFT, .5, true, Side.TOP, 0, true),
905 new BackgroundSize(AUTO, AUTO, true, true, false, false));
906 assertEquals(expected, image);
907 }
908
909 @Test public void backgroundImagePosition_Example11() {
910 region.setStyle(
911 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
912 "-fx-background-position: 100% 100%;");
913 processCSS();
914
915 assertEquals(0, region.getBackground().getFills().size(), 0);
916 assertEquals(1, region.getBackground().getImages().size(), 0);
917 assertNull(region.getBorder());
918
919 BackgroundImage image = region.getBackground().getImages().get(0);
920 BackgroundImage expected = new BackgroundImage(image.getImage(),
921 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
922 new BackgroundPosition(Side.LEFT, 1, true, Side.TOP, 1, true),
923 new BackgroundSize(AUTO, AUTO, true, true, false, false));
924 assertEquals(expected, image);
925 }
926
927 @Test public void backgroundImagePosition_75Percent() {
928 region.setStyle(
929 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
930 "-fx-background-position: 75% 75%;");
931 processCSS();
932
933 assertEquals(0, region.getBackground().getFills().size(), 0);
934 assertEquals(1, region.getBackground().getImages().size(), 0);
935 assertNull(region.getBorder());
936
937 BackgroundImage image = region.getBackground().getImages().get(0);
938 BackgroundImage expected = new BackgroundImage(image.getImage(),
939 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
940 new BackgroundPosition(Side.LEFT, .75, true, Side.TOP, .75, true),
941 new BackgroundSize(AUTO, AUTO, true, true, false, false));
942 assertEquals(expected, image);
943 }
944
945 @Test public void backgroundImagePosition_Example12() {
946 region.setStyle(
947 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
948 "-fx-background-position: right 10% bottom 10%;");
949 processCSS();
950
951 assertEquals(0, region.getBackground().getFills().size(), 0);
952 assertEquals(1, region.getBackground().getImages().size(), 0);
953 assertNull(region.getBorder());
954
955 BackgroundImage image = region.getBackground().getImages().get(0);
956 BackgroundImage expected = new BackgroundImage(image.getImage(),
957 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
958 new BackgroundPosition(Side.RIGHT, .1, true, Side.BOTTOM, .1, true),
959 new BackgroundSize(AUTO, AUTO, true, true, false, false));
960 assertEquals(expected, image);
961 }
962
963 @Ignore("We do not presently implement -fx-background-clip")
964 @Test public void backgroundClip_defaultValue() {
965 region.setStyle(
966 "-fx-background-image: url('test/javafx/scene/layout/red.png');");
967 processCSS();
968
969 assertEquals(0, region.getBackground().getFills().size(), 0);
970 assertEquals(1, region.getBackground().getImages().size(), 0);
971 assertNull(region.getBorder());
972
973 // BackgroundImage image = region.getBackground().getImages().get(0);
974 // TODO backgroundClip needs to be set to border-box by default
975 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
976 // 0, .1, .1, 0, // top, right, bottom, left
977 // 1, 1,
978 // true, true, // asHorizontalPercentage, asVerticalPercentage
979 // true, true,
980 // false, false);
981 // assertEquals(expected, image);
982 }
983
984 @Ignore("We do not presently implement -fx-background-clip")
985 @Test public void backgroundClip_BorderBox() {
986 region.setStyle(
987 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
988 "-fx-background-clip: border-box");
989 processCSS();
990
991 assertEquals(0, region.getBackground().getFills().size(), 0);
992 assertEquals(1, region.getBackground().getImages().size(), 0);
993 assertNull(region.getBorder());
994
995 // BackgroundImage image = region.getBackground().getImages().get(0);
996 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
997 // 0, .1, .1, 0, // top, right, bottom, left
998 // 1, 1,
999 // true, true, // asHorizontalPercentage, asVerticalPercentage
1000 // true, true,
1001 // false, false);
1002 // assertEquals(expected, image);
1003 }
1004
1005 @Ignore("We do not presently implement -fx-background-clip")
1006 @Test public void backgroundClip_PaddingBox() {
1007 region.setStyle(
1008 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1009 "-fx-background-clip: padding-box");
1010 processCSS();
1011
1012 assertEquals(0, region.getBackground().getFills().size(), 0);
1013 assertEquals(1, region.getBackground().getImages().size(), 0);
1014 assertNull(region.getBorder());
1015
1016 // BackgroundImage image = region.getBackground().getImages().get(0);
1017 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1018 // 0, .1, .1, 0, // top, right, bottom, left
1019 // 1, 1,
1020 // true, true, // asHorizontalPercentage, asVerticalPercentage
1021 // true, true,
1022 // false, false);
1023 // assertEquals(expected, image);
1024 }
1025
1026 @Ignore("We do not presently implement -fx-background-clip")
1027 @Test public void backgroundClip_ContentBox() {
1028 region.setStyle(
1029 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1030 "-fx-background-clip: content-box");
1031 processCSS();
1032
1033 assertEquals(0, region.getBackground().getFills().size(), 0);
1034 assertEquals(1, region.getBackground().getImages().size(), 0);
1035 assertNull(region.getBorder());
1036
1037 // BackgroundImage image = region.getBackground().getImages().get(0);
1038 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1039 // 0, .1, .1, 0, // top, right, bottom, left
1040 // 1, 1,
1041 // true, true, // asHorizontalPercentage, asVerticalPercentage
1042 // true, true,
1043 // false, false);
1044 // assertEquals(expected, image);
1045 }
1046
1047 @Ignore("We do not presently implement -fx-background-origin")
1048 @Test public void backgroundOrigin_defaultValue() {
1049 region.setStyle(
1050 "-fx-background-image: url('test/javafx/scene/layout/red.png');");
1051 processCSS();
1052
1053 assertEquals(0, region.getBackground().getFills().size(), 0);
1054 assertEquals(1, region.getBackground().getImages().size(), 0);
1055 assertNull(region.getBorder());
1056
1057 // BackgroundImage image = region.getBackground().getImages().get(0);
1058 // TODO backgroundOrigin needs to be set to padding-box by default
1059 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1060 // 0, .1, .1, 0, // top, right, bottom, left
1061 // 1, 1,
1062 // true, true, // asHorizontalPercentage, asVerticalPercentage
1063 // true, true,
1064 // false, false);
1065 // assertEquals(expected, image);
1066 }
1067
1068 @Ignore("We do not presently implement -fx-background-origin")
1069 @Test public void backgroundOrigin_BorderBox() {
1070 region.setStyle(
1071 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1072 "-fx-background-origin: border-box");
1073 processCSS();
1074
1075 // assertEquals(0, region.getBackground().getFills().size(), 0);
1076 // assertEquals(1, region.getBackground().getImages().size(), 0);
1077 // assertEquals(0, region.getImageBorders().size(), 0);
1078 // assertEquals(0, region.getStrokeBorders().size(), 0);
1079
1080 // BackgroundImage image = region.getBackground().getImages().get(0);
1081 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1082 // 0, .1, .1, 0, // top, right, bottom, left
1083 // 1, 1,
1084 // true, true, // asHorizontalPercentage, asVerticalPercentage
1085 // true, true,
1086 // false, false);
1087 // assertEquals(expected, image);
1088 }
1089
1090 @Ignore("We do not presently implement -fx-background-origin")
1091 @Test public void backgroundOrigin_PaddingBox() {
1092 region.setStyle(
1093 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1094 "-fx-background-origin: padding-box");
1095 processCSS();
1096
1097 assertEquals(0, region.getBackground().getFills().size(), 0);
1098 assertEquals(1, region.getBackground().getImages().size(), 0);
1099 assertNull(region.getBorder());
1100
1101 // BackgroundImage image = region.getBackground().getImages().get(0);
1102 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1103 // 0, .1, .1, 0, // top, right, bottom, left
1104 // 1, 1,
1105 // true, true, // asHorizontalPercentage, asVerticalPercentage
1106 // true, true,
1107 // false, false);
1108 // assertEquals(expected, image);
1109 }
1110
1111 @Ignore("We do not presently implement -fx-background-origin")
1112 @Test public void backgroundOrigin_ContentBox() {
1113 region.setStyle(
1114 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1115 "-fx-background-origin: content-box");
1116 processCSS();
1117
1118 assertEquals(0, region.getBackground().getFills().size(), 0);
1119 assertEquals(1, region.getBackground().getImages().size(), 0);
1120 assertNull(region.getBorder());
1121
1122 // BackgroundImage image = region.getBackground().getImages().get(0);
1123 // BackgroundImage expected = new BackgroundImage(image.getImage(), BackgroundRepeat.NO_REPEAT, BackgroundRepeat.NO_REPEAT,
1124 // 0, .1, .1, 0, // top, right, bottom, left
1125 // 1, 1,
1126 // true, true, // asHorizontalPercentage, asVerticalPercentage
1127 // true, true,
1128 // false, false);
1129 // assertEquals(expected, image);
1130 }
1131
1132 @Test public void backgroundSize_defaultValue() {
1133 region.setStyle("-fx-background-image: url('test/javafx/scene/layout/red.png');");
1134 processCSS();
1135
1136 assertEquals(0, region.getBackground().getFills().size(), 0);
1137 assertEquals(1, region.getBackground().getImages().size(), 0);
1138 assertNull(region.getBorder());
1139
1140 BackgroundImage image = region.getBackground().getImages().get(0);
1141 BackgroundImage expected = new BackgroundImage(image.getImage(),
1142 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1143 BackgroundPosition.DEFAULT,
1144 new BackgroundSize(AUTO, AUTO, true, true, false, false));
1145 assertEquals(expected, image);
1146 }
1147
1148 @Test public void backgroundSize_cover() {
1149 region.setStyle(
1150 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1151 "-fx-background-size: cover;");
1152 processCSS();
1153
1154 assertEquals(0, region.getBackground().getFills().size(), 0);
1155 assertEquals(1, region.getBackground().getImages().size(), 0);
1156 assertNull(region.getBorder());
1157
1158 BackgroundImage image = region.getBackground().getImages().get(0);
1159 BackgroundImage expected = new BackgroundImage(image.getImage(),
1160 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1161 BackgroundPosition.DEFAULT,
1162 new BackgroundSize(AUTO, AUTO, true, true, false, true));
1163 assertEquals(expected, image);
1164 }
1165
1166 @Test public void backgroundSize_contain() {
1167 region.setStyle(
1168 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1169 "-fx-background-size: contain;");
1170 processCSS();
1171
1172 assertEquals(0, region.getBackground().getFills().size(), 0);
1173 assertEquals(1, region.getBackground().getImages().size(), 0);
1174 assertNull(region.getBorder());
1175
1176 BackgroundImage image = region.getBackground().getImages().get(0);
1177 BackgroundImage expected = new BackgroundImage(image.getImage(),
1178 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1179 BackgroundPosition.DEFAULT,
1180 new BackgroundSize(AUTO, AUTO, true, true, true, false));
1181 assertEquals(expected, image);
1182 }
1183
1184 @Test public void backgroundSize_length() {
1185 region.setStyle(
1186 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1187 "-fx-background-size: 170px;");
1188 processCSS();
1189
1190 assertEquals(0, region.getBackground().getFills().size(), 0);
1191 assertEquals(1, region.getBackground().getImages().size(), 0);
1192 assertNull(region.getBorder());
1193
1194 BackgroundImage image = region.getBackground().getImages().get(0);
1195 BackgroundImage expected = new BackgroundImage(image.getImage(),
1196 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1197 BackgroundPosition.DEFAULT,
1198 new BackgroundSize(170, AUTO, false, true, false, false));
1199 assertEquals(expected, image);
1200 }
1201
1202 @Test public void backgroundSize_percent() {
1203 region.setStyle(
1204 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1205 "-fx-background-size: 65%;");
1206 processCSS();
1207
1208 assertEquals(0, region.getBackground().getFills().size(), 0);
1209 assertEquals(1, region.getBackground().getImages().size(), 0);
1210 assertNull(region.getBorder());
1211
1212 BackgroundImage image = region.getBackground().getImages().get(0);
1213 BackgroundImage expected = new BackgroundImage(image.getImage(),
1214 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1215 BackgroundPosition.DEFAULT,
1216 new BackgroundSize(.65, AUTO, true, true, false, false));
1217 assertEquals(expected, image);
1218 }
1219
1220 @Test public void backgroundSize_auto() {
1221 region.setStyle(
1222 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1223 "-fx-background-size: auto;");
1224 processCSS();
1225
1226 assertEquals(0, region.getBackground().getFills().size(), 0);
1227 assertEquals(1, region.getBackground().getImages().size(), 0);
1228 assertNull(region.getBorder());
1229
1230 BackgroundImage image = region.getBackground().getImages().get(0);
1231 BackgroundImage expected = new BackgroundImage(image.getImage(),
1232 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1233 BackgroundPosition.DEFAULT,
1234 new BackgroundSize(AUTO, AUTO, true, true, false, false));
1235 assertEquals(expected, image);
1236 }
1237
1238 @Test public void backgroundSize_length_length() {
1239 region.setStyle(
1240 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1241 "-fx-background-size: 10px 20px;");
1242 processCSS();
1243
1244 assertEquals(0, region.getBackground().getFills().size(), 0);
1245 assertEquals(1, region.getBackground().getImages().size(), 0);
1246 assertNull(region.getBorder());
1247
1248 BackgroundImage image = region.getBackground().getImages().get(0);
1249 BackgroundImage expected = new BackgroundImage(image.getImage(),
1250 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1251 BackgroundPosition.DEFAULT,
1252 new BackgroundSize(10, 20, false, false, false, false));
1253 assertEquals(expected, image);
1254 }
1255
1256 @Test public void backgroundSize_length_percent() {
1257 region.setStyle(
1258 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1259 "-fx-background-size: 50px 25%;");
1260 processCSS();
1261
1262 assertEquals(0, region.getBackground().getFills().size(), 0);
1263 assertEquals(1, region.getBackground().getImages().size(), 0);
1264 assertNull(region.getBorder());
1265
1266 BackgroundImage image = region.getBackground().getImages().get(0);
1267 BackgroundImage expected = new BackgroundImage(image.getImage(),
1268 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1269 BackgroundPosition.DEFAULT,
1270 new BackgroundSize(50, .25, false, true, false, false));
1271 assertEquals(expected, image);
1272 }
1273
1274 @Test public void backgroundSize_length_auto() {
1275 region.setStyle(
1276 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1277 "-fx-background-size: 40px auto;");
1278 processCSS();
1279
1280 assertEquals(0, region.getBackground().getFills().size(), 0);
1281 assertEquals(1, region.getBackground().getImages().size(), 0);
1282 assertNull(region.getBorder());
1283
1284 BackgroundImage image = region.getBackground().getImages().get(0);
1285 BackgroundImage expected = new BackgroundImage(image.getImage(),
1286 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1287 BackgroundPosition.DEFAULT,
1288 new BackgroundSize(40, AUTO, false, true, false, false));
1289 assertEquals(expected, image);
1290 }
1291
1292 @Test public void backgroundSize_percent_length() {
1293 region.setStyle(
1294 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1295 "-fx-background-size: 25% 30px;");
1296 processCSS();
1297
1298 assertEquals(0, region.getBackground().getFills().size(), 0);
1299 assertEquals(1, region.getBackground().getImages().size(), 0);
1300 assertNull(region.getBorder());
1301
1302 BackgroundImage image = region.getBackground().getImages().get(0);
1303 BackgroundImage expected = new BackgroundImage(image.getImage(),
1304 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1305 BackgroundPosition.DEFAULT,
1306 new BackgroundSize(.25, 30, true, false, false, false));
1307 assertEquals(expected, image);
1308 }
1309
1310 @Test public void backgroundSize_percent_percent() {
1311 region.setStyle(
1312 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1313 "-fx-background-size: 25% 75%;");
1314 processCSS();
1315
1316 assertEquals(0, region.getBackground().getFills().size(), 0);
1317 assertEquals(1, region.getBackground().getImages().size(), 0);
1318 assertNull(region.getBorder());
1319
1320 BackgroundImage image = region.getBackground().getImages().get(0);
1321 BackgroundImage expected = new BackgroundImage(image.getImage(),
1322 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1323 BackgroundPosition.DEFAULT,
1324 new BackgroundSize(.25, .75, true, true, false, false));
1325 assertEquals(expected, image);
1326 }
1327
1328 @Test public void backgroundSize_percent_auto() {
1329 region.setStyle(
1330 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1331 "-fx-background-size: 25% auto;");
1332 processCSS();
1333
1334 assertEquals(0, region.getBackground().getFills().size(), 0);
1335 assertEquals(1, region.getBackground().getImages().size(), 0);
1336 assertNull(region.getBorder());
1337
1338 BackgroundImage image = region.getBackground().getImages().get(0);
1339 BackgroundImage expected = new BackgroundImage(image.getImage(),
1340 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1341 BackgroundPosition.DEFAULT,
1342 new BackgroundSize(.25, AUTO, true, true, false, false));
1343 assertEquals(expected, image);
1344 }
1345
1346 @Test public void backgroundSize_auto_length() {
1347 region.setStyle(
1348 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1349 "-fx-background-size: auto 25px;");
1350 processCSS();
1351
1352 assertEquals(0, region.getBackground().getFills().size(), 0);
1353 assertEquals(1, region.getBackground().getImages().size(), 0);
1354 assertNull(region.getBorder());
1355
1356 BackgroundImage image = region.getBackground().getImages().get(0);
1357 BackgroundImage expected = new BackgroundImage(image.getImage(),
1358 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1359 BackgroundPosition.DEFAULT,
1360 new BackgroundSize(AUTO, 25, true, false, false, false));
1361 assertEquals(expected, image);
1362 }
1363
1364 @Test public void backgroundSize_auto_percent() {
1365 region.setStyle(
1366 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1367 "-fx-background-size: auto 50%;");
1368 processCSS();
1369
1370 assertEquals(0, region.getBackground().getFills().size(), 0);
1371 assertEquals(1, region.getBackground().getImages().size(), 0);
1372 assertNull(region.getBorder());
1373
1374 BackgroundImage image = region.getBackground().getImages().get(0);
1375 BackgroundImage expected = new BackgroundImage(image.getImage(),
1376 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1377 BackgroundPosition.DEFAULT,
1378 new BackgroundSize(AUTO, .5, true, true, false, false));
1379 assertEquals(expected, image);
1380 }
1381
1382 @Test public void backgroundSize_auto_auto() {
1383 region.setStyle(
1384 "-fx-background-image: url('test/javafx/scene/layout/red.png');" +
1385 "-fx-background-size: auto auto;");
1386 processCSS();
1387
1388 assertEquals(0, region.getBackground().getFills().size(), 0);
1389 assertEquals(1, region.getBackground().getImages().size(), 0);
1390 assertNull(region.getBorder());
1391
1392 BackgroundImage image = region.getBackground().getImages().get(0);
1393 BackgroundImage expected = new BackgroundImage(image.getImage(),
1394 BackgroundRepeat.REPEAT, BackgroundRepeat.REPEAT,
1395 BackgroundPosition.DEFAULT,
1396 new BackgroundSize(AUTO, AUTO, true, true, false, false));
1397 assertEquals(expected, image);
1398 }
1399
1400
1401 /**************************************************************************
1402 * *
1403 * Stroke Border tests *
1404 * *
1405 * These include -fx-border-color, -fx-border-style, and *
1406 * -fx-border-width properties. *
1407 * *
1408 *************************************************************************/
1409
1410 @Test public void borderStrokeStyleIsNull() {
1411 region.setStyle("-fx-border-style: null;");
1412 processCSS();
1413
1414 assertEquals(new Insets(0), region.getPadding());
1415 assertNull(region.getBackground());
1416 assertNull(region.getBorder());
1417 }
1418
1419 @Ignore("-fx-border-style-top is not supported")
1420 @Test public void borderStyle_top() {
1421 region.setStyle("-fx-border-style-top: solid;");
1422 processCSS();
1423
1424 assertEquals(0, region.getBackground().getFills().size(), 0);
1425 assertEquals(0, region.getBackground().getImages().size(), 0);
1426 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1427 assertEquals(0, region.getBorder().getImages().size(), 0);
1428
1429 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1430 BorderStroke expected = new BorderStroke(
1431 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1432 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
1433 null, null, Insets.EMPTY);
1434 assertEquals(expected, stroke);
1435 }
1436
1437 @Ignore("-fx-border-style-right is not supported")
1438 @Test public void borderStyle_right() {
1439 region.setStyle("-fx-border-style-right: solid;");
1440 processCSS();
1441
1442 assertEquals(0, region.getBackground().getFills().size(), 0);
1443 assertEquals(0, region.getBackground().getImages().size(), 0);
1444 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1445 assertEquals(0, region.getBorder().getImages().size(), 0);
1446
1447 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1448 BorderStroke expected = new BorderStroke(
1449 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1450 BorderStrokeStyle.NONE, BorderStrokeStyle.SOLID, BorderStrokeStyle.NONE, BorderStrokeStyle.SOLID,
1451 null, null, Insets.EMPTY);
1452 assertEquals(expected, stroke);
1453 }
1454
1455 @Ignore("-fx-border-style-bottom is not supported")
1456 @Test public void borderStyle_bottom() {
1457 region.setStyle("-fx-border-style-bottom: solid;");
1458 processCSS();
1459
1460 assertEquals(0, region.getBackground().getFills().size(), 0);
1461 assertEquals(0, region.getBackground().getImages().size(), 0);
1462 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1463 assertEquals(0, region.getBorder().getImages().size(), 0);
1464
1465 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1466 BorderStroke expected = new BorderStroke(
1467 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1468 BorderStrokeStyle.NONE, BorderStrokeStyle.NONE, BorderStrokeStyle.SOLID, BorderStrokeStyle.NONE,
1469 null, null, Insets.EMPTY);
1470 assertEquals(expected, stroke);
1471 }
1472
1473 @Ignore("-fx-border-style-left is not supported")
1474 @Test public void borderStyle_left() {
1475 region.setStyle("-fx-border-style-left: solid;");
1476 processCSS();
1477
1478 assertEquals(0, region.getBackground().getFills().size(), 0);
1479 assertEquals(0, region.getBackground().getImages().size(), 0);
1480 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1481 assertEquals(0, region.getBorder().getImages().size(), 0);
1482
1483 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1484 BorderStroke expected = new BorderStroke(
1485 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1486 BorderStrokeStyle.NONE, BorderStrokeStyle.NONE, BorderStrokeStyle.NONE, BorderStrokeStyle.SOLID,
1487 null, null, Insets.EMPTY);
1488 assertEquals(expected, stroke);
1489 }
1490
1491 @Ignore("-fx-border-style-top and -fx-border-style-right are not supported")
1492 @Test public void borderStyle_top_right() {
1493 region.setStyle(
1494 "-fx-border-style-top: solid;" +
1495 "-fx-border-style-right: dashed;");
1496 processCSS();
1497
1498 assertEquals(0, region.getBackground().getFills().size(), 0);
1499 assertEquals(0, region.getBackground().getImages().size(), 0);
1500 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1501 assertEquals(0, region.getBorder().getImages().size(), 0);
1502
1503 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1504 BorderStroke expected = new BorderStroke(
1505 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1506 BorderStrokeStyle.SOLID, BorderStrokeStyle.DASHED, BorderStrokeStyle.SOLID, BorderStrokeStyle.DASHED,
1507 null, null, Insets.EMPTY);
1508 assertEquals(expected, stroke);
1509 }
1510
1511 @Ignore("-fx-border-style-top and -fx-border-style-bottom are not supported")
1512 @Test public void borderStyle_bottom_top() {
1513 region.setStyle(
1514 "-fx-border-style-top: solid;" +
1515 "-fx-border-style-bottom: dashed;");
1516 processCSS();
1517
1518 assertEquals(0, region.getBackground().getFills().size(), 0);
1519 assertEquals(0, region.getBackground().getImages().size(), 0);
1520 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1521 assertEquals(0, region.getBorder().getImages().size(), 0);
1522
1523 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1524 BorderStroke expected = new BorderStroke(
1525 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1526 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.DASHED, BorderStrokeStyle.SOLID,
1527 null, null, Insets.EMPTY);
1528 assertEquals(expected, stroke);
1529 }
1530
1531 @Ignore("-fx-border-style-bottom and -fx-border-style-left are not supported")
1532 @Test public void borderStyle_left_bottom() {
1533 region.setStyle(
1534 "-fx-border-style-bottom: solid;" +
1535 "-fx-border-style-left: dashed;");
1536 processCSS();
1537
1538 assertEquals(0, region.getBackground().getFills().size(), 0);
1539 assertEquals(0, region.getBackground().getImages().size(), 0);
1540 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1541 assertEquals(0, region.getBorder().getImages().size(), 0);
1542
1543 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1544 BorderStroke expected = new BorderStroke(
1545 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1546 BorderStrokeStyle.NONE, BorderStrokeStyle.NONE, BorderStrokeStyle.SOLID, BorderStrokeStyle.DASHED,
1547 null, null, Insets.EMPTY);
1548 assertEquals(expected, stroke);
1549 }
1550
1551 @Test public void borderStyle_none() {
1552 region.setStyle("-fx-border-style: none;");
1553 processCSS();
1554
1555 assertEquals(new Insets(0), region.getPadding());
1556 assertNull(region.getBackground());
1557 assertNull(region.getBorder());
1558 }
1559
1560 @Test public void borderStyle_hidden() {
1561 region.setStyle("-fx-border-style: hidden;");
1562 processCSS();
1563
1564 assertEquals(new Insets(0), region.getPadding());
1565 assertNull(region.getBackground());
1566 assertNull(region.getBorder());
1567 }
1568
1569 @Test public void borderStyle_dotted() {
1570 region.setStyle("-fx-border-color: black; -fx-border-style: dotted;");
1571 processCSS();
1572
1573 assertNull(region.getBackground());
1574 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1575 assertEquals(0, region.getBorder().getImages().size(), 0);
1576
1577 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1578 BorderStroke expected = new BorderStroke(
1579 Color.BLACK, BorderStrokeStyle.DOTTED,
1580 null, null);
1581 assertEquals(expected, stroke);
1582 }
1583
1584 // border-style: dashed
1585 @Test public void borderStyle_dashed() {
1586 region.setStyle("-fx-border-color: black; -fx-border-style: dashed;");
1587 processCSS();
1588
1589 assertNull(region.getBackground());
1590 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1591 assertEquals(0, region.getBorder().getImages().size(), 0);
1592
1593 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1594 BorderStroke expected = new BorderStroke(
1595 Color.BLACK, BorderStrokeStyle.DASHED,
1596 null, null);
1597 assertEquals(expected, stroke);
1598 }
1599
1600 @Test public void borderStyle_solid() {
1601 region.setStyle("-fx-border-color: black; -fx-border-style: solid;");
1602 processCSS();
1603
1604 assertNull(region.getBackground());
1605 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1606 assertEquals(0, region.getBorder().getImages().size(), 0);
1607
1608 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1609 BorderStroke expected = new BorderStroke(
1610 Color.BLACK, BorderStrokeStyle.SOLID,
1611 null, null);
1612 assertEquals(expected, stroke);
1613 }
1614
1615 @Ignore ("double not supported yet")
1616 @Test public void borderStyle_double() {
1617 region.setStyle("-fx-border-color: black; -fx-border-style: double;");
1618 processCSS();
1619
1620 assertEquals(0, region.getBackground().getFills().size(), 0);
1621 assertEquals(0, region.getBackground().getImages().size(), 0);
1622 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1623 assertEquals(0, region.getBorder().getImages().size(), 0);
1624
1625 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1626 // BorderStroke expected = new BorderStroke(
1627 // Color.BLACK, BorderStrokeStyle.DOUBLE,
1628 // null, null);
1629 // assertEquals(expected, stroke);
1630 }
1631
1632 @Ignore ("groove not supported yet")
1633 @Test public void borderStyle_groove() {
1634 region.setStyle("-fx-border-color: black; -fx-border-style: groove;");
1635 processCSS();
1636
1637 assertEquals(0, region.getBackground().getFills().size(), 0);
1638 assertEquals(0, region.getBackground().getImages().size(), 0);
1639 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1640 assertEquals(0, region.getBorder().getImages().size(), 0);
1641
1642 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1643 // BorderStroke expected = new BorderStroke(
1644 // Color.BLACK, BorderStrokeStyle.GROOVE,
1645 // null, null);
1646 // assertEquals(expected, stroke);
1647 }
1648
1649 @Ignore ("ridge not supported yet")
1650 @Test public void borderStyle_ridge() {
1651 region.setStyle("-fx-border-color: black; -fx-border-style: ridge;");
1652 processCSS();
1653
1654 assertEquals(0, region.getBackground().getFills().size(), 0);
1655 assertEquals(0, region.getBackground().getImages().size(), 0);
1656 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1657 assertEquals(0, region.getBorder().getImages().size(), 0);
1658
1659 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1660 // BorderStroke expected = new BorderStroke(
1661 // Color.BLACK, BorderStrokeStyle.RIDGE,
1662 // null, null);
1663 // assertEquals(expected, stroke);
1664 }
1665
1666 @Ignore ("inset not supported yet")
1667 @Test public void borderStyle_inset() {
1668 region.setStyle("-fx-border-color: black; -fx-border-style: inset;");
1669 processCSS();
1670
1671 assertEquals(0, region.getBackground().getFills().size(), 0);
1672 assertEquals(0, region.getBackground().getImages().size(), 0);
1673 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1674 assertEquals(0, region.getBorder().getImages().size(), 0);
1675
1676 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1677 // BorderStroke expected = new BorderStroke(
1678 // Color.BLACK, BorderStrokeStyle.INSET,
1679 // null, null);
1680 // assertEquals(expected, stroke);
1681 }
1682
1683 @Ignore ("outset not supported yet")
1684 @Test public void borderStyle_outset() {
1685 region.setStyle("-fx-border-color: black; -fx-border-style: outset;");
1686 processCSS();
1687
1688 assertEquals(0, region.getBackground().getFills().size(), 0);
1689 assertEquals(0, region.getBackground().getImages().size(), 0);
1690 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1691 assertEquals(0, region.getBorder().getImages().size(), 0);
1692
1693 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1694 // BorderStroke expected = new BorderStroke(
1695 // Color.BLACK, BorderStrokeStyle.OUTSET,
1696 // null, null);
1697 // assertEquals(expected, stroke);
1698 }
1699
1700 @Test public void borderStyle_solid_dotted() {
1701 region.setStyle("-fx-border-color: black; -fx-border-style: solid dotted;");
1702 processCSS();
1703
1704 assertNull(region.getBackground());
1705 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1706 assertEquals(0, region.getBorder().getImages().size(), 0);
1707
1708 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1709 BorderStroke expected = new BorderStroke(
1710 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1711 BorderStrokeStyle.SOLID, BorderStrokeStyle.DOTTED, BorderStrokeStyle.SOLID, BorderStrokeStyle.DOTTED,
1712 null, null, Insets.EMPTY);
1713 assertEquals(expected, stroke);
1714 }
1715
1716 @Test public void borderStyle_solid_dotted_dashed() {
1717 region.setStyle("-fx-border-color: black; -fx-border-style: solid dotted dashed;");
1718 processCSS();
1719
1720 assertNull(region.getBackground());
1721 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1722 assertEquals(0, region.getBorder().getImages().size(), 0);
1723
1724 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1725 BorderStroke expected = new BorderStroke(
1726 Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1727 BorderStrokeStyle.SOLID, BorderStrokeStyle.DOTTED, BorderStrokeStyle.DASHED, BorderStrokeStyle.DOTTED,
1728 null, null, Insets.EMPTY);
1729 assertEquals(expected, stroke);
1730 }
1731
1732 @Ignore ("ridge not supported yet")
1733 @Test public void borderStyle_solid_dotted_dashed_ridge() {
1734 region.setStyle("-fx-border-color: black; -fx-border-style: solid dotted dashed ridge;");
1735 processCSS();
1736
1737 assertEquals(0, region.getBackground().getFills().size(), 0);
1738 assertEquals(0, region.getBackground().getImages().size(), 0);
1739 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1740 assertEquals(0, region.getBorder().getImages().size(), 0);
1741
1742 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1743 // BorderStroke expected = new BorderStroke(
1744 // Color.BLACK, Color.BLACK, Color.BLACK, Color.BLACK,
1745 // BorderStrokeStyle.SOLID, BorderStrokeStyle.DOTTED, BorderStrokeStyle.DASHED, BorderStrokeStyle.RIDGE,
1746 // null, null, Insets.EMPTY);
1747 // assertEquals(expected, stroke);
1748 }
1749
1750 @Ignore ("-fx-border-width-top is not supported")
1751 @Test public void borderStrokeWidth_top() {
1752 region.setStyle(
1753 "-fx-border-color: black;" +
1754 "-fx-border-width-top: 10px;");
1755 processCSS();
1756
1757 assertEquals(0, region.getBackground().getFills().size(), 0);
1758 assertEquals(0, region.getBackground().getImages().size(), 0);
1759 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1760 assertEquals(0, region.getBorder().getImages().size(), 0);
1761
1762 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1763 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(10, 0, 0, 0));
1764 assertEquals(expected, stroke);
1765 }
1766
1767 @Ignore ("-fx-border-width-right is not supported")
1768 @Test public void borderStrokeWidth_right() {
1769 region.setStyle(
1770 "-fx-border-color: black;" +
1771 "-fx-border-width-right: 10px;");
1772 processCSS();
1773
1774 assertEquals(0, region.getBackground().getFills().size(), 0);
1775 assertEquals(0, region.getBackground().getImages().size(), 0);
1776 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1777 assertEquals(0, region.getBorder().getImages().size(), 0);
1778
1779 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1780 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(0, 10, 0, 0));
1781 assertEquals(expected, stroke);
1782 }
1783
1784 @Ignore ("-fx-border-width-bottom is not supported")
1785 @Test public void borderStrokeWidth_bottom() {
1786 region.setStyle(
1787 "-fx-border-color: black;" +
1788 "-fx-border-width-bottom: 10px;");
1789 processCSS();
1790
1791 assertEquals(0, region.getBackground().getFills().size(), 0);
1792 assertEquals(0, region.getBackground().getImages().size(), 0);
1793 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1794 assertEquals(0, region.getBorder().getImages().size(), 0);
1795
1796 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1797 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(0, 0, 10, 0));
1798 assertEquals(expected, stroke);
1799 }
1800
1801 @Ignore ("-fx-border-width-left is not supported")
1802 @Test public void borderStrokeWidth_left() {
1803 region.setStyle(
1804 "-fx-border-color: black;" +
1805 "-fx-border-width-left: 10px;");
1806 processCSS();
1807
1808 assertEquals(0, region.getBackground().getFills().size(), 0);
1809 assertEquals(0, region.getBackground().getImages().size(), 0);
1810 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1811 assertEquals(0, region.getBorder().getImages().size(), 0);
1812
1813 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1814 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(0, 0, 0, 10));
1815 assertEquals(expected, stroke);
1816 }
1817
1818 @Ignore ("-fx-border-width-top and -fx-border-width-right are not supported")
1819 @Test public void borderStrokeWidth_top_right() {
1820 region.setStyle(
1821 "-fx-border-color: black;" +
1822 "-fx-border-width-top: 10px;" +
1823 "-fx-border-width-right: 20px;");
1824 processCSS();
1825
1826 assertEquals(0, region.getBackground().getFills().size(), 0);
1827 assertEquals(0, region.getBackground().getImages().size(), 0);
1828 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1829 assertEquals(0, region.getBorder().getImages().size(), 0);
1830
1831 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1832 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(10, 20, 0, 0));
1833 assertEquals(expected, stroke);
1834 }
1835
1836 @Ignore ("-fx-border-width-top and -fx-border-width-bottom are not supported")
1837 @Test public void borderStrokeWidth_top_bottom() {
1838 region.setStyle(
1839 "-fx-border-color: black;" +
1840 "-fx-border-width-top: 10px;" +
1841 "-fx-border-width-bottom: 20px;");
1842 processCSS();
1843
1844 assertEquals(0, region.getBackground().getFills().size(), 0);
1845 assertEquals(0, region.getBackground().getImages().size(), 0);
1846 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1847 assertEquals(0, region.getBorder().getImages().size(), 0);
1848
1849 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1850 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(10, 0, 20, 0));
1851 assertEquals(expected, stroke);
1852 }
1853
1854 @Ignore ("-fx-border-width-left and -fx-border-width-bottom are not supported")
1855 @Test public void borderStrokeWidth_left_bottom() {
1856 region.setStyle(
1857 "-fx-border-color: black;" +
1858 "-fx-border-width-left: 10px;" +
1859 "-fx-border-width-bottom: 20px;");
1860 processCSS();
1861
1862 assertEquals(0, region.getBackground().getFills().size(), 0);
1863 assertEquals(0, region.getBackground().getImages().size(), 0);
1864 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1865 assertEquals(0, region.getBorder().getImages().size(), 0);
1866
1867 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1868 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(0, 0, 20, 10));
1869 assertEquals(expected, stroke);
1870 }
1871
1872 @Test public void borderStrokeWidth2() {
1873 region.setStyle(
1874 "-fx-border-color: black;" +
1875 "-fx-border-width: 1px 2px;");
1876 processCSS();
1877
1878 assertNull(region.getBackground());
1879 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1880 assertEquals(0, region.getBorder().getImages().size(), 0);
1881
1882 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1883 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(1, 2, 1, 2));
1884 assertEquals(expected, stroke);
1885 }
1886
1887 @Test public void borderStrokeWidth3() {
1888 region.setStyle(
1889 "-fx-border-color: black;" +
1890 "-fx-border-width: 1px 2px 3px;");
1891 processCSS();
1892
1893 assertNull(region.getBackground());
1894 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1895 assertEquals(0, region.getBorder().getImages().size(), 0);
1896
1897 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1898 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(1, 2, 3, 2));
1899 assertEquals(expected, stroke);
1900 }
1901
1902 @Test public void borderStrokeWidth4() {
1903 region.setStyle(
1904 "-fx-border-color: black;" +
1905 "-fx-border-width: 1px 2px 3px 4px;");
1906 processCSS();
1907
1908 assertNull(region.getBackground());
1909 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1910 assertEquals(0, region.getBorder().getImages().size(), 0);
1911
1912 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1913 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(1, 2, 3, 4));
1914 assertEquals(expected, stroke);
1915 }
1916
1917 @Ignore("thin keyword is not supported")
1918 @Test public void borderStrokeWidth_thin() {
1919 region.setStyle(
1920 "-fx-border-color: black;" +
1921 "-fx-border-width: thin;");
1922 processCSS();
1923
1924 assertEquals(0, region.getBackground().getFills().size(), 0);
1925 assertEquals(0, region.getBackground().getImages().size(), 0);
1926 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1927 assertEquals(0, region.getBorder().getImages().size(), 0);
1928
1929 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1930 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(1, 1, 1, 1));
1931 assertEquals(expected, stroke);
1932 }
1933
1934 @Ignore("thick keyword is not supported")
1935 @Test public void borderStrokeWidth_thick() {
1936 region.setStyle(
1937 "-fx-border-color: black;" +
1938 "-fx-border-width: thick;");
1939 processCSS();
1940
1941 assertEquals(0, region.getBackground().getFills().size(), 0);
1942 assertEquals(0, region.getBackground().getImages().size(), 0);
1943 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1944 assertEquals(0, region.getBorder().getImages().size(), 0);
1945
1946 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1947 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(5, 5, 5, 5));
1948 assertEquals(expected, stroke);
1949 }
1950
1951 @Ignore("medium keyword is not supported")
1952 @Test public void borderStrokeWidth_medium() {
1953 region.setStyle(
1954 "-fx-border-color: black;" +
1955 "-fx-border-width: medium;");
1956 processCSS();
1957
1958 assertEquals(0, region.getBackground().getFills().size(), 0);
1959 assertEquals(0, region.getBackground().getImages().size(), 0);
1960 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1961 assertEquals(0, region.getBorder().getImages().size(), 0);
1962
1963 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1964 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(3, 3, 3, 3));
1965 assertEquals(expected, stroke);
1966 }
1967
1968 @Ignore("thin, medium, and thick keywords are not supported")
1969 @Test public void borderStrokeWidth_thin_medium_thick() {
1970 region.setStyle(
1971 "-fx-border-color: black;" +
1972 "-fx-border-width: thin medium thick;");
1973 processCSS();
1974
1975 assertEquals(0, region.getBackground().getFills().size(), 0);
1976 assertEquals(0, region.getBackground().getImages().size(), 0);
1977 assertEquals(1, region.getBorder().getStrokes().size(), 0);
1978 assertEquals(0, region.getBorder().getImages().size(), 0);
1979
1980 BorderStroke stroke = region.getBorder().getStrokes().get(0);
1981 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID, null, new BorderWidths(1, 3, 5, 3));
1982 assertEquals(expected, stroke);
1983 }
1984
1985 // TODO example 20
1986 // TODO example 21
1987
1988 // TODO!! The initial width of a border is MEDIUM, NOT 0!
1989
1990 @Ignore("-fx-border-top-left-radius not supported")
1991 @Test public void borderStrokeRadius_topLeft1() {
1992 region.setStyle(
1993 "-fx-border-color: black;" +
1994 "-fx-border-top-left-radius: 5px;");
1995 processCSS();
1996
1997 assertEquals(0, region.getBackground().getFills().size(), 0);
1998 assertEquals(0, region.getBackground().getImages().size(), 0);
1999 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2000 assertEquals(0, region.getBorder().getImages().size(), 0);
2001
2002 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2003 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2004 new CornerRadii(5, 0, 0, 0, false), BorderStroke.DEFAULT_WIDTHS);
2005 assertEquals(expected, stroke);
2006 }
2007
2008 @Ignore("-fx-border-top-left-radius not supported")
2009 @Test public void borderStrokeRadius_topLeft2() {
2010 region.setStyle(
2011 "-fx-border-color: black;" +
2012 "-fx-border-top-left-radius: 5px, 10px;");
2013 processCSS();
2014
2015 assertEquals(0, region.getBackground().getFills().size(), 0);
2016 assertEquals(0, region.getBackground().getImages().size(), 0);
2017 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2018 assertEquals(0, region.getBorder().getImages().size(), 0);
2019
2020 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2021 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2022 new CornerRadii(
2023 5, 10, // top left
2024 0, 0, // top right
2025 0, 0, // bottom right
2026 0, 0, // bottom left
2027 false, false, // top left as percent
2028 false, false, // top right as percent
2029 false, false, // bottom right as percent
2030 false, false), // bottom left as percent
2031 BorderStroke.DEFAULT_WIDTHS);
2032 assertEquals(expected, stroke);
2033 }
2034
2035 @Ignore("-fx-border-top-left-radius not supported")
2036 @Test public void borderStrokeRadius_topLeft3() {
2037 region.setStyle(
2038 "-fx-border-color: black;" +
2039 "-fx-border-top-left-radius: 5%;");
2040 processCSS();
2041
2042 assertEquals(0, region.getBackground().getFills().size(), 0);
2043 assertEquals(0, region.getBackground().getImages().size(), 0);
2044 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2045 assertEquals(0, region.getBorder().getImages().size(), 0);
2046
2047 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2048 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2049 new CornerRadii(
2050 5, 5, // top left
2051 0, 0, // top right
2052 0, 0, // bottom right
2053 0, 0, // bottom left
2054 true, true, // top left as percent
2055 false, false, // top right as percent
2056 false, false, // bottom right as percent
2057 false, false), // bottom left as percent
2058 BorderStroke.DEFAULT_WIDTHS);
2059 assertEquals(expected, stroke);
2060 }
2061
2062 @Ignore("-fx-border-top-left-radius not supported")
2063 @Test public void borderStrokeRadius_topLeft4() {
2064 region.setStyle(
2065 "-fx-border-color: black;" +
2066 "-fx-border-top-left-radius: 5%, 10%;");
2067 processCSS();
2068
2069 assertEquals(0, region.getBackground().getFills().size(), 0);
2070 assertEquals(0, region.getBackground().getImages().size(), 0);
2071 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2072 assertEquals(0, region.getBorder().getImages().size(), 0);
2073
2074 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2075 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2076 new CornerRadii(
2077 5, 10, // top left
2078 0, 0, // top right
2079 0, 0, // bottom right
2080 0, 0, // bottom left
2081 true, true, // top left as percent
2082 false, false, // top right as percent
2083 false, false, // bottom right as percent
2084 false, false), // bottom left as percent
2085 BorderStroke.DEFAULT_WIDTHS);
2086 assertEquals(expected, stroke);
2087 }
2088
2089 @Ignore("-fx-border-top-left-radius not supported")
2090 @Test public void borderStrokeRadius_topLeft5() {
2091 region.setStyle(
2092 "-fx-border-color: black;" +
2093 "-fx-border-top-left-radius: 5% 10px;");
2094 processCSS();
2095
2096 assertEquals(0, region.getBackground().getFills().size(), 0);
2097 assertEquals(0, region.getBackground().getImages().size(), 0);
2098 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2099 assertEquals(0, region.getBorder().getImages().size(), 0);
2100
2101 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2102 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2103 new CornerRadii(
2104 5, 10, // top left
2105 0, 0, // top right
2106 0, 0, // bottom right
2107 0, 0, // bottom left
2108 true, false, // top left as percent
2109 false, false, // top right as percent
2110 false, false, // bottom right as percent
2111 false, false), // bottom left as percent
2112 BorderStroke.DEFAULT_WIDTHS);
2113 assertEquals(expected, stroke);
2114 }
2115
2116 @Ignore("-fx-border-top-left-radius not supported")
2117 @Test public void borderStrokeRadius_topLeft6() {
2118 region.setStyle(
2119 "-fx-border-color: black;" +
2120 "-fx-border-top-left-radius: 5px, 10%;");
2121 processCSS();
2122
2123 assertEquals(0, region.getBackground().getFills().size(), 0);
2124 assertEquals(0, region.getBackground().getImages().size(), 0);
2125 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2126 assertEquals(0, region.getBorder().getImages().size(), 0);
2127
2128 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2129 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2130 new CornerRadii(
2131 5, 10, // top left
2132 0, 0, // top right
2133 0, 0, // bottom right
2134 0, 0, // bottom left
2135 false, true, // top left as percent
2136 false, false, // top right as percent
2137 false, false, // bottom right as percent
2138 false, false), // bottom left as percent
2139 BorderStroke.DEFAULT_WIDTHS);
2140 assertEquals(expected, stroke);
2141 }
2142
2143 @Ignore("-fx-border-top-right-radius not supported")
2144 @Test public void borderStrokeRadius_topRight1() {
2145 region.setStyle(
2146 "-fx-border-color: black;" +
2147 "-fx-border-top-right-radius: 5px;");
2148 processCSS();
2149
2150 assertEquals(0, region.getBackground().getFills().size(), 0);
2151 assertEquals(0, region.getBackground().getImages().size(), 0);
2152 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2153 assertEquals(0, region.getBorder().getImages().size(), 0);
2154
2155 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2156 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2157 new CornerRadii(0, 5, 0, 0, false), BorderStroke.DEFAULT_WIDTHS);
2158 assertEquals(expected, stroke);
2159 }
2160
2161 @Ignore("-fx-border-top-right-radius not supported")
2162 @Test public void borderStrokeRadius_topRight2() {
2163 region.setStyle(
2164 "-fx-border-color: black;" +
2165 "-fx-border-top-right-radius: 5px, 10px;");
2166 processCSS();
2167
2168 assertEquals(0, region.getBackground().getFills().size(), 0);
2169 assertEquals(0, region.getBackground().getImages().size(), 0);
2170 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2171 assertEquals(0, region.getBorder().getImages().size(), 0);
2172
2173 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2174 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2175 new CornerRadii(
2176 0, 0, // top left
2177 5, 10, // top right
2178 0, 0, // bottom right
2179 0, 0, // bottom left
2180 false, false, // top left as percent
2181 false, false, // top right as percent
2182 false, false, // bottom right as percent
2183 false, false), // bottom left as percent
2184 BorderStroke.DEFAULT_WIDTHS);
2185 assertEquals(expected, stroke);
2186 }
2187
2188 @Ignore("-fx-border-top-right-radius not supported")
2189 @Test public void borderStrokeRadius_topRight3() {
2190 region.setStyle(
2191 "-fx-border-color: black;" +
2192 "-fx-border-top-right-radius: 5%;");
2193 processCSS();
2194
2195 assertEquals(0, region.getBackground().getFills().size(), 0);
2196 assertEquals(0, region.getBackground().getImages().size(), 0);
2197 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2198 assertEquals(0, region.getBorder().getImages().size(), 0);
2199
2200 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2201 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2202 new CornerRadii(
2203 0, 0, // top left
2204 5, 5, // top right
2205 0, 0, // bottom right
2206 0, 0, // bottom left
2207 false, false, // top left as percent
2208 true, true, // top right as percent
2209 false, false, // bottom right as percent
2210 false, false), // bottom left as percent
2211 BorderStroke.DEFAULT_WIDTHS);
2212 assertEquals(expected, stroke);
2213 }
2214
2215 @Ignore("-fx-border-top-right-radius not supported")
2216 @Test public void borderStrokeRadius_topRight4() {
2217 region.setStyle(
2218 "-fx-border-color: black;" +
2219 "-fx-border-top-right-radius: 5%, 10%;");
2220 processCSS();
2221
2222 assertEquals(0, region.getBackground().getFills().size(), 0);
2223 assertEquals(0, region.getBackground().getImages().size(), 0);
2224 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2225 assertEquals(0, region.getBorder().getImages().size(), 0);
2226
2227 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2228 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2229 new CornerRadii(
2230 0, 0, // top left
2231 5, 10, // top right
2232 0, 0, // bottom right
2233 0, 0, // bottom left
2234 false, false, // top left as percent
2235 true, true, // top right as percent
2236 false, false, // bottom right as percent
2237 false, false), // bottom left as percent
2238 BorderStroke.DEFAULT_WIDTHS);
2239 assertEquals(expected, stroke);
2240 }
2241
2242 @Ignore("-fx-border-top-right-radius not supported")
2243 @Test public void borderStrokeRadius_topRight5() {
2244 region.setStyle(
2245 "-fx-border-color: black;" +
2246 "-fx-border-top-right-radius: 5% 10px;");
2247 processCSS();
2248
2249 assertEquals(0, region.getBackground().getFills().size(), 0);
2250 assertEquals(0, region.getBackground().getImages().size(), 0);
2251 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2252 assertEquals(0, region.getBorder().getImages().size(), 0);
2253
2254 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2255 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2256 new CornerRadii(
2257 0, 0, // top left
2258 5, 10, // top right
2259 0, 0, // bottom right
2260 0, 0, // bottom left
2261 false, false, // top left as percent
2262 true, false, // top right as percent
2263 false, false, // bottom right as percent
2264 false, false), // bottom left as percent
2265 BorderStroke.DEFAULT_WIDTHS);
2266 assertEquals(expected, stroke);
2267 }
2268
2269 @Ignore("-fx-border-top-right-radius not supported")
2270 @Test public void borderStrokeRadius_topRight6() {
2271 region.setStyle(
2272 "-fx-border-color: black;" +
2273 "-fx-border-top-right-radius: 5px, 10%;");
2274 processCSS();
2275
2276 assertEquals(0, region.getBackground().getFills().size(), 0);
2277 assertEquals(0, region.getBackground().getImages().size(), 0);
2278 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2279 assertEquals(0, region.getBorder().getImages().size(), 0);
2280
2281 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2282 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2283 new CornerRadii(
2284 0, 0, // top left
2285 5, 10, // top right
2286 0, 0, // bottom right
2287 0, 0, // bottom left
2288 false, false, // top left as percent
2289 false, true, // top right as percent
2290 false, false, // bottom right as percent
2291 false, false), // bottom left as percent
2292 BorderStroke.DEFAULT_WIDTHS);
2293 assertEquals(expected, stroke);
2294 }
2295
2296 @Ignore("-fx-border-bottom-right-radius not supported")
2297 @Test public void borderStrokeRadius_bottomRight1() {
2298 region.setStyle(
2299 "-fx-border-color: black;" +
2300 "-fx-border-bottom-right-radius: 5px;");
2301 processCSS();
2302
2303 assertEquals(0, region.getBackground().getFills().size(), 0);
2304 assertEquals(0, region.getBackground().getImages().size(), 0);
2305 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2306 assertEquals(0, region.getBorder().getImages().size(), 0);
2307
2308 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2309 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2310 new CornerRadii(0, 0, 5, 0, false), BorderStroke.DEFAULT_WIDTHS);
2311 assertEquals(expected, stroke);
2312 }
2313
2314 @Ignore("-fx-border-bottom-right-radius not supported")
2315 @Test public void borderStrokeRadius_bottomRight2() {
2316 region.setStyle(
2317 "-fx-border-color: black;" +
2318 "-fx-border-bottom-right-radius: 5px, 10px;");
2319 processCSS();
2320
2321 assertEquals(0, region.getBackground().getFills().size(), 0);
2322 assertEquals(0, region.getBackground().getImages().size(), 0);
2323 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2324 assertEquals(0, region.getBorder().getImages().size(), 0);
2325
2326 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2327 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2328 new CornerRadii(
2329 0, 0, // top left
2330 0, 0, // top right
2331 5, 10, // bottom right
2332 0, 0, // bottom left
2333 false, false, // top left as percent
2334 false, false, // top right as percent
2335 false, false, // bottom right as percent
2336 false, false), // bottom left as percent
2337 BorderStroke.DEFAULT_WIDTHS);
2338 assertEquals(expected, stroke);
2339 }
2340
2341 @Ignore("-fx-border-bottom-right-radius not supported")
2342 @Test public void borderStrokeRadius_bottomRight3() {
2343 region.setStyle(
2344 "-fx-border-color: black;" +
2345 "-fx-border-bottom-right-radius: 5%;");
2346 processCSS();
2347
2348 assertEquals(0, region.getBackground().getFills().size(), 0);
2349 assertEquals(0, region.getBackground().getImages().size(), 0);
2350 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2351 assertEquals(0, region.getBorder().getImages().size(), 0);
2352
2353 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2354 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2355 new CornerRadii(
2356 0, 0, // top left
2357 0, 0, // top right
2358 5, 5, // bottom right
2359 0, 0, // bottom left
2360 false, false, // top left as percent
2361 false, false, // top right as percent
2362 true, true, // bottom right as percent
2363 false, false), // bottom left as percent
2364 BorderStroke.DEFAULT_WIDTHS);
2365 assertEquals(expected, stroke);
2366 }
2367
2368 @Ignore("-fx-border-bottom-right-radius not supported")
2369 @Test public void borderStrokeRadius_bottomRight4() {
2370 region.setStyle(
2371 "-fx-border-color: black;" +
2372 "-fx-border-bottom-right-radius: 5%, 10%;");
2373 processCSS();
2374
2375 assertEquals(0, region.getBackground().getFills().size(), 0);
2376 assertEquals(0, region.getBackground().getImages().size(), 0);
2377 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2378 assertEquals(0, region.getBorder().getImages().size(), 0);
2379
2380 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2381 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2382 new CornerRadii(
2383 0, 0, // top left
2384 0, 0, // top right
2385 5, 10, // bottom right
2386 0, 0, // bottom left
2387 false, false, // top left as percent
2388 false, false, // top right as percent
2389 true, true, // bottom right as percent
2390 false, false), // bottom left as percent
2391 BorderStroke.DEFAULT_WIDTHS);
2392 assertEquals(expected, stroke);
2393 }
2394
2395 @Ignore("-fx-border-bottom-right-radius not supported")
2396 @Test public void borderStrokeRadius_bottomRight5() {
2397 region.setStyle(
2398 "-fx-border-color: black;" +
2399 "-fx-border-bottom-right-radius: 5% 10px;");
2400 processCSS();
2401
2402 assertEquals(0, region.getBackground().getFills().size(), 0);
2403 assertEquals(0, region.getBackground().getImages().size(), 0);
2404 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2405 assertEquals(0, region.getBorder().getImages().size(), 0);
2406
2407 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2408 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2409 new CornerRadii(
2410 0, 0, // top left
2411 0, 0, // top right
2412 5, 10, // bottom right
2413 0, 0, // bottom left
2414 false, false, // top left as percent
2415 false, false, // top right as percent
2416 true, false, // bottom right as percent
2417 false, false), // bottom left as percent
2418 BorderStroke.DEFAULT_WIDTHS);
2419 assertEquals(expected, stroke);
2420 }
2421
2422 @Ignore("-fx-border-bottom-right-radius not supported")
2423 @Test public void borderStrokeRadius_bottomRight6() {
2424 region.setStyle(
2425 "-fx-border-color: black;" +
2426 "-fx-border-bottom-right-radius: 5px, 10%;");
2427 processCSS();
2428
2429 assertEquals(0, region.getBackground().getFills().size(), 0);
2430 assertEquals(0, region.getBackground().getImages().size(), 0);
2431 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2432 assertEquals(0, region.getBorder().getImages().size(), 0);
2433
2434 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2435 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2436 new CornerRadii(
2437 0, 0, // top left
2438 0, 0, // top right
2439 5, 10, // bottom right
2440 0, 0, // bottom left
2441 false, false, // top left as percent
2442 false, false, // top right as percent
2443 false, true, // bottom right as percent
2444 false, false), // bottom left as percent
2445 BorderStroke.DEFAULT_WIDTHS);
2446 assertEquals(expected, stroke);
2447 }
2448
2449 @Ignore("-fx-border-bottom-left-radius not supported")
2450 @Test public void borderStrokeRadius_bottomLeft1() {
2451 region.setStyle(
2452 "-fx-border-color: black;" +
2453 "-fx-border-bottom-left-radius: 5px;");
2454 processCSS();
2455
2456 assertEquals(0, region.getBackground().getFills().size(), 0);
2457 assertEquals(0, region.getBackground().getImages().size(), 0);
2458 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2459 assertEquals(0, region.getBorder().getImages().size(), 0);
2460
2461 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2462 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2463 new CornerRadii(0, 0, 0, 5, false), BorderStroke.DEFAULT_WIDTHS);
2464 assertEquals(expected, stroke);
2465 }
2466
2467 @Ignore("-fx-border-bottom-left-radius not supported")
2468 @Test public void borderStrokeRadius_bottomLeft2() {
2469 region.setStyle(
2470 "-fx-border-color: black;" +
2471 "-fx-border-bottom-left-radius: 5px, 10px;");
2472 processCSS();
2473
2474 assertEquals(0, region.getBackground().getFills().size(), 0);
2475 assertEquals(0, region.getBackground().getImages().size(), 0);
2476 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2477 assertEquals(0, region.getBorder().getImages().size(), 0);
2478
2479 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2480 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2481 new CornerRadii(
2482 0, 0, // top left
2483 0, 0, // top right
2484 0, 0, // bottom right
2485 5, 10, // bottom left
2486 false, false, // top left as percent
2487 false, false, // top right as percent
2488 false, false, // bottom right as percent
2489 false, false), // bottom left as percent
2490 BorderStroke.DEFAULT_WIDTHS);
2491 assertEquals(expected, stroke);
2492 }
2493
2494 @Ignore("-fx-border-bottom-left-radius not supported")
2495 @Test public void borderStrokeRadius_bottomLeft3() {
2496 region.setStyle(
2497 "-fx-border-color: black;" +
2498 "-fx-border-bottom-left-radius: 5%;");
2499 processCSS();
2500
2501 assertEquals(0, region.getBackground().getFills().size(), 0);
2502 assertEquals(0, region.getBackground().getImages().size(), 0);
2503 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2504 assertEquals(0, region.getBorder().getImages().size(), 0);
2505
2506 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2507 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2508 new CornerRadii(
2509 0, 0, // top left
2510 0, 0, // top right
2511 0, 0, // bottom right
2512 5, 5, // bottom left
2513 false, false, // top left as percent
2514 false, false, // top right as percent
2515 false, false, // bottom right as percent
2516 true, true), // bottom left as percent
2517 BorderStroke.DEFAULT_WIDTHS);
2518 assertEquals(expected, stroke);
2519 }
2520
2521 @Ignore("-fx-border-bottom-left-radius not supported")
2522 @Test public void borderStrokeRadius_bottomLeft4() {
2523 region.setStyle(
2524 "-fx-border-color: black;" +
2525 "-fx-border-bottom-left-radius: 5%, 10%;");
2526 processCSS();
2527
2528 assertEquals(0, region.getBackground().getFills().size(), 0);
2529 assertEquals(0, region.getBackground().getImages().size(), 0);
2530 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2531 assertEquals(0, region.getBorder().getImages().size(), 0);
2532
2533 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2534 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2535 new CornerRadii(
2536 0, 0, // top left
2537 0, 0, // top right
2538 0, 0, // bottom right
2539 5, 10, // bottom left
2540 false, false, // top left as percent
2541 false, false, // top right as percent
2542 false, false, // bottom right as percent
2543 true, true), // bottom left as percent
2544 BorderStroke.DEFAULT_WIDTHS);
2545 assertEquals(expected, stroke);
2546 }
2547
2548 @Ignore("-fx-border-bottom-left-radius not supported")
2549 @Test public void borderStrokeRadius_bottomLeft5() {
2550 region.setStyle(
2551 "-fx-border-color: black;" +
2552 "-fx-border-bottom-left-radius: 5% 10px;");
2553 processCSS();
2554
2555 assertEquals(0, region.getBackground().getFills().size(), 0);
2556 assertEquals(0, region.getBackground().getImages().size(), 0);
2557 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2558 assertEquals(0, region.getBorder().getImages().size(), 0);
2559
2560 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2561 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2562 new CornerRadii(
2563 0, 0, // top left
2564 0, 0, // top right
2565 0, 0, // bottom right
2566 5, 10, // bottom left
2567 false, false, // top left as percent
2568 false, false, // top right as percent
2569 false, false, // bottom right as percent
2570 true, false), // bottom left as percent
2571 BorderStroke.DEFAULT_WIDTHS);
2572 assertEquals(expected, stroke);
2573 }
2574
2575 @Ignore("-fx-border-bottom-left-radius not supported")
2576 @Test public void borderStrokeRadius_bottomLeft6() {
2577 region.setStyle(
2578 "-fx-border-color: black;" +
2579 "-fx-border-bottom-left-radius: 5px, 10%;");
2580 processCSS();
2581
2582 assertEquals(0, region.getBackground().getFills().size(), 0);
2583 assertEquals(0, region.getBackground().getImages().size(), 0);
2584 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2585 assertEquals(0, region.getBorder().getImages().size(), 0);
2586
2587 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2588 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2589 new CornerRadii(
2590 0, 0, // top left
2591 0, 0, // top right
2592 0, 0, // bottom right
2593 5, 10, // bottom left
2594 false, false, // top left as percent
2595 false, false, // top right as percent
2596 false, false, // bottom right as percent
2597 false, true), // bottom left as percent
2598 BorderStroke.DEFAULT_WIDTHS);
2599 assertEquals(expected, stroke);
2600 }
2601
2602 @Ignore("-fx-border-top-left-radius and -fx-border-top-right-radius are not supported")
2603 @Test public void borderStrokeRadius_topLeft_topRight() {
2604 region.setStyle(
2605 "-fx-border-color: black;" +
2606 "-fx-border-top-left-radius: 5px 10%;" +
2607 "-fx-border-top-right-radius: 20px 30%;");
2608 processCSS();
2609
2610 assertEquals(0, region.getBackground().getFills().size(), 0);
2611 assertEquals(0, region.getBackground().getImages().size(), 0);
2612 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2613 assertEquals(0, region.getBorder().getImages().size(), 0);
2614
2615 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2616 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2617 new CornerRadii(
2618 5, 10, // top left
2619 20, 30, // top right
2620 0, 0, // bottom right
2621 0, 0, // bottom left
2622 false, true, // top left as percent
2623 false, true, // top right as percent
2624 false, false, // bottom right as percent
2625 false, false), // bottom left as percent
2626 BorderStroke.DEFAULT_WIDTHS);
2627 assertEquals(expected, stroke);
2628 }
2629
2630 @Test public void borderStrokeRadius1() {
2631 region.setStyle(
2632 "-fx-border-color: black;" +
2633 "-fx-border-radius: 5px;");
2634 processCSS();
2635
2636 assertNull(region.getBackground());
2637 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2638 assertEquals(0, region.getBorder().getImages().size(), 0);
2639
2640 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2641 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2642 new CornerRadii(5, 5, 5, 5, false),
2643 BorderStroke.DEFAULT_WIDTHS);
2644 assertEquals(expected, stroke);
2645 }
2646
2647 @Test public void borderStrokeRadius1_Percent() {
2648 region.setStyle(
2649 "-fx-border-color: black;" +
2650 "-fx-border-radius: 5%;");
2651 processCSS();
2652
2653 assertNull(region.getBackground());
2654 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2655 assertEquals(0, region.getBorder().getImages().size(), 0);
2656
2657 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2658 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2659 new CornerRadii(.05, .05, .05, .05, true),
2660 BorderStroke.DEFAULT_WIDTHS);
2661 assertEquals(expected, stroke);
2662 }
2663
2664 @Test public void borderStrokeRadius2() {
2665 region.setStyle(
2666 "-fx-border-color: black;" +
2667 "-fx-border-radius: 5px 10px;");
2668 processCSS();
2669
2670 assertNull(region.getBackground());
2671 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2672 assertEquals(0, region.getBorder().getImages().size(), 0);
2673
2674 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2675 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2676 new CornerRadii(5, 10, 5, 10, false),
2677 BorderStroke.DEFAULT_WIDTHS);
2678 assertEquals(expected, stroke);
2679 }
2680
2681 @Test public void borderStrokeRadius2_Percent() {
2682 region.setStyle(
2683 "-fx-border-color: black;" +
2684 "-fx-border-radius: 5% 10%;");
2685 processCSS();
2686
2687 assertNull(region.getBackground());
2688 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2689 assertEquals(0, region.getBorder().getImages().size(), 0);
2690
2691 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2692 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2693 new CornerRadii(.05, .10, .05, .10, true),
2694 BorderStroke.DEFAULT_WIDTHS);
2695 assertEquals(expected, stroke);
2696 }
2697
2698 @Test public void borderStrokeRadius3() {
2699 region.setStyle(
2700 "-fx-border-color: black;" +
2701 "-fx-border-radius: 5px 10px 15px;");
2702 processCSS();
2703
2704 assertNull(region.getBackground());
2705 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2706 assertEquals(0, region.getBorder().getImages().size(), 0);
2707
2708 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2709 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2710 new CornerRadii(5, 10, 15, 10, false),
2711 BorderStroke.DEFAULT_WIDTHS);
2712 assertEquals(expected, stroke);
2713 }
2714
2715 @Test public void borderStrokeRadius3_Percent() {
2716 region.setStyle(
2717 "-fx-border-color: black;" +
2718 "-fx-border-radius: 5% 10% 15%;");
2719 processCSS();
2720
2721 assertNull(region.getBackground());
2722 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2723 assertEquals(0, region.getBorder().getImages().size(), 0);
2724
2725 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2726 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2727 new CornerRadii(.05, .10, .15, .10, true),
2728 BorderStroke.DEFAULT_WIDTHS);
2729 assertEquals(expected, stroke);
2730 }
2731
2732 @Test public void borderStrokeRadius4() {
2733 region.setStyle(
2734 "-fx-border-color: black;" +
2735 "-fx-border-radius: 5px 10px 15px 20px;");
2736 processCSS();
2737
2738 assertNull(region.getBackground());
2739 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2740 assertEquals(0, region.getBorder().getImages().size(), 0);
2741
2742 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2743 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2744 new CornerRadii(5, 10, 15, 20, false),
2745 BorderStroke.DEFAULT_WIDTHS);
2746 assertEquals(expected, stroke);
2747 }
2748
2749 @Test public void borderStrokeRadius4_Percent() {
2750 region.setStyle(
2751 "-fx-border-color: black;" +
2752 "-fx-border-radius: 5% 10% 15% 20%;");
2753 processCSS();
2754
2755 assertNull(region.getBackground());
2756 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2757 assertEquals(0, region.getBorder().getImages().size(), 0);
2758
2759 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2760 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2761 new CornerRadii(.05, .10, .15, .20, true),
2762 BorderStroke.DEFAULT_WIDTHS);
2763 assertEquals(expected, stroke);
2764 }
2765
2766 // TODO Example 22
2767
2768 // http://www.w3.org/TR/css3-background/#the-border-radius
2769 // Example 23 (except using px here instead of em)
2770 @Test public void testBorderRadiusWithHorizontalAndVerticalRadii() {
2771
2772 region.setStyle("-fx-border-color: black; -fx-border-radius: 2px 1px 4px / 0.5px 3px;");
2773 processCSS();
2774
2775 assertNull(region.getBackground());
2776 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2777 assertEquals(0, region.getBorder().getImages().size(), 0);
2778
2779 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2780 BorderStroke expected = new BorderStroke(Color.BLACK, BorderStrokeStyle.SOLID,
2781 new CornerRadii(2, .5, 3, 1, 4, .5, 3, 1, false, false, false, false, false, false, false, false),
2782 BorderStroke.DEFAULT_WIDTHS);
2783
2784 assertEquals(expected, stroke);
2785
2786 }
2787
2788
2789
2790 @Test public void borderStrokeIsTransparent() {
2791 region.setStyle(
2792 "-fx-border-style: solid;" +
2793 "-fx-border-color: transparent;");
2794 processCSS();
2795
2796 assertNull(region.getBackground());
2797 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2798 assertEquals(0, region.getBorder().getImages().size(), 0);
2799
2800 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2801 BorderStroke expected = new BorderStroke(Color.TRANSPARENT, BorderStrokeStyle.SOLID, null, null);
2802 assertEquals(expected, stroke);
2803 }
2804
2805 @Test public void borderStrokeIsSpecifiedOnly() {
2806 region.setStyle(
2807 "-fx-border-style: solid;" +
2808 "-fx-border-color: red;");
2809 processCSS();
2810
2811 assertNull(region.getBackground());
2812 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2813 assertEquals(0, region.getBorder().getImages().size(), 0);
2814
2815 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2816 BorderStroke expected = new BorderStroke(Color.RED, BorderStrokeStyle.SOLID, null, null);
2817 assertEquals(expected, stroke);
2818 }
2819
2820 @Test public void borderStroke2IsSpecifiedOnly() {
2821 region.setStyle(
2822 "-fx-border-style: solid;" +
2823 "-fx-border-color: red green;");
2824 processCSS();
2825
2826 assertNull(region.getBackground());
2827 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2828 assertEquals(0, region.getBorder().getImages().size(), 0);
2829
2830 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2831 BorderStroke expected = new BorderStroke(
2832 Color.RED, Color.GREEN, Color.RED, Color.GREEN,
2833 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2834 null, null, Insets.EMPTY);
2835 assertEquals(expected, stroke);
2836 }
2837
2838 @Test public void borderStroke3IsSpecifiedOnly() {
2839 region.setStyle(
2840 "-fx-border-style: solid;" +
2841 "-fx-border-color: red green blue;");
2842 processCSS();
2843
2844 assertNull(region.getBackground());
2845 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2846 assertEquals(0, region.getBorder().getImages().size(), 0);
2847
2848 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2849 BorderStroke expected = new BorderStroke(
2850 Color.RED, Color.GREEN, Color.BLUE, Color.GREEN,
2851 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2852 null, null, Insets.EMPTY);
2853 assertEquals(expected, stroke);
2854 }
2855
2856 @Test public void borderStroke4IsSpecifiedOnly() {
2857 region.setStyle(
2858 "-fx-border-style: solid;" +
2859 "-fx-border-color: red green blue yellow;");
2860 processCSS();
2861
2862 assertNull(region.getBackground());
2863 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2864 assertEquals(0, region.getBorder().getImages().size(), 0);
2865
2866 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2867 BorderStroke expected = new BorderStroke(
2868 Color.RED, Color.GREEN, Color.BLUE, Color.YELLOW,
2869 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2870 null, null, Insets.EMPTY);
2871 assertEquals(expected, stroke);
2872 }
2873
2874 @Ignore ("-fx-border-top-color is not supported by the CSS parser")
2875 @Test public void borderStroke_top_IsSpecifiedOnly() {
2876 region.setStyle(
2877 "-fx-border-style: solid;" +
2878 "-fx-border-top-color: purple;");
2879 processCSS();
2880
2881 assertEquals(0, region.getBackground().getFills().size(), 0);
2882 assertEquals(0, region.getBackground().getImages().size(), 0);
2883 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2884 assertEquals(0, region.getBorder().getImages().size(), 0);
2885
2886 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2887 BorderStroke expected = new BorderStroke(
2888 Color.PURPLE, Color.BLACK, Color.BLACK, Color.BLACK,
2889 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2890 null, null, Insets.EMPTY);
2891 assertEquals(expected, stroke);
2892 }
2893
2894 @Ignore ("-fx-border-right-color is not supported by the CSS parser")
2895 @Test public void borderStroke_right_IsSpecifiedOnly() {
2896 region.setStyle(
2897 "-fx-border-style: solid;" +
2898 "-fx-border-right-color: purple;");
2899 processCSS();
2900
2901 assertEquals(0, region.getBackground().getFills().size(), 0);
2902 assertEquals(0, region.getBackground().getImages().size(), 0);
2903 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2904 assertEquals(0, region.getBorder().getImages().size(), 0);
2905
2906 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2907 BorderStroke expected = new BorderStroke(
2908 Color.BLACK, Color.PURPLE, Color.BLACK, Color.BLACK,
2909 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2910 null, null, Insets.EMPTY);
2911 assertEquals(expected, stroke);
2912 }
2913
2914 @Ignore ("-fx-border-bottom-color is not supported by the CSS parser")
2915 @Test public void borderStroke_bottom_IsSpecifiedOnly() {
2916 region.setStyle(
2917 "-fx-border-style: solid;" +
2918 "-fx-border-bottom-color: purple;");
2919 processCSS();
2920
2921 assertEquals(0, region.getBackground().getFills().size(), 0);
2922 assertEquals(0, region.getBackground().getImages().size(), 0);
2923 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2924 assertEquals(0, region.getBorder().getImages().size(), 0);
2925
2926 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2927 BorderStroke expected = new BorderStroke(
2928 Color.BLACK, Color.BLACK, Color.PURPLE, Color.BLACK,
2929 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2930 null, null, Insets.EMPTY);
2931 assertEquals(expected, stroke);
2932 }
2933
2934 @Ignore ("-fx-border-left-color is not supported by the CSS parser")
2935 @Test public void borderStroke_left_IsSpecifiedOnly() {
2936 region.setStyle(
2937 "-fx-border-style: solid;" +
2938 "-fx-border-left-color: purple;");
2939 processCSS();
2940
2941 assertEquals(0, region.getBackground().getFills().size(), 0);
2942 assertEquals(0, region.getBackground().getImages().size(), 0);
2943 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2944 assertEquals(0, region.getBorder().getImages().size(), 0);
2945
2946 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2947 BorderStroke expected = new BorderStroke(
2948 Color.BLACK, Color.BLACK, Color.BLACK, Color.PURPLE,
2949 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2950 null, null, Insets.EMPTY);
2951 assertEquals(expected, stroke);
2952 }
2953
2954 @Ignore ("-fx-border-top-color and -fx-border-right-color is not supported by the CSS parser")
2955 @Test public void borderStroke_top_right_IsSpecifiedOnly() {
2956 region.setStyle(
2957 "-fx-border-style: solid;" +
2958 "-fx-border-top-color: red;" +
2959 "-fx-border-right-color: green;");
2960 processCSS();
2961
2962 assertEquals(0, region.getBackground().getFills().size(), 0);
2963 assertEquals(0, region.getBackground().getImages().size(), 0);
2964 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2965 assertEquals(0, region.getBorder().getImages().size(), 0);
2966
2967 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2968 BorderStroke expected = new BorderStroke(
2969 Color.RED, Color.GREEN, Color.BLACK, Color.BLACK,
2970 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2971 null, null, Insets.EMPTY);
2972 assertEquals(expected, stroke);
2973 }
2974
2975 @Ignore ("-fx-border-left-color and -fx-border-right-color is not supported by the CSS parser")
2976 @Test public void borderStroke_right_left_IsSpecifiedOnly() {
2977 region.setStyle(
2978 "-fx-border-style: solid;" +
2979 "-fx-border-right-color: red;" +
2980 "-fx-border-left-color: green;");
2981 processCSS();
2982
2983 assertEquals(0, region.getBackground().getFills().size(), 0);
2984 assertEquals(0, region.getBackground().getImages().size(), 0);
2985 assertEquals(1, region.getBorder().getStrokes().size(), 0);
2986 assertEquals(0, region.getBorder().getImages().size(), 0);
2987
2988 BorderStroke stroke = region.getBorder().getStrokes().get(0);
2989 BorderStroke expected = new BorderStroke(
2990 Color.BLACK, Color.RED, Color.BLACK, Color.GREEN,
2991 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
2992 null, null, Insets.EMPTY);
2993 assertEquals(expected, stroke);
2994 }
2995
2996 @Ignore ("-fx-border-top-color and -fx-border-bottom-color is not supported by the CSS parser")
2997 @Test public void borderStroke_bottom_top_IsSpecifiedOnly() {
2998 region.setStyle(
2999 "-fx-border-style: solid;" +
3000 "-fx-border-bottom-color: red;" +
3001 "-fx-border-top-color: green;");
3002 processCSS();
3003
3004 assertEquals(0, region.getBackground().getFills().size(), 0);
3005 assertEquals(0, region.getBackground().getImages().size(), 0);
3006 assertEquals(1, region.getBorder().getStrokes().size(), 0);
3007 assertEquals(0, region.getBorder().getImages().size(), 0);
3008
3009 BorderStroke stroke = region.getBorder().getStrokes().get(0);
3010 BorderStroke expected = new BorderStroke(
3011 Color.GREEN, Color.BLACK, Color.RED, Color.BLACK,
3012 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
3013 null, null, Insets.EMPTY);
3014 assertEquals(expected, stroke);
3015 }
3016
3017 @Test public void borderRadiusIsSpecifiedOnly() {
3018 region.setStyle("-fx-border-radius: 1px;");
3019 processCSS();
3020
3021 assertNull(region.getBackground());
3022 assertNull(region.getBorder());
3023 }
3024
3025 @Test public void borderWidthIsSpecifiedOnly() {
3026 region.setStyle("-fx-border-width: 1;");
3027 processCSS();
3028
3029 assertNull(region.getBackground());
3030 assertNull(region.getBorder());
3031 }
3032
3033 @Test public void testWithExcessBorderWidths() {
3034 region.setStyle(
3035 "-fx-border-style: solid;" +
3036 "-fx-border-color: red;" +
3037 "-fx-border-width: 0 0 0 0, 0, 1, 2;");
3038 processCSS();
3039
3040 assertNull(region.getBackground());
3041 assertEquals(1, region.getBorder().getStrokes().size(), 0);
3042 assertEquals(0, region.getBorder().getImages().size(), 0);
3043
3044 BorderStroke stroke = region.getBorder().getStrokes().get(0);
3045 BorderStroke expected = new BorderStroke(
3046 Color.RED, Color.RED, Color.RED, Color.RED,
3047 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
3048 null, new BorderWidths(0, 0, 0, 0), Insets.EMPTY);
3049 assertEquals(expected, stroke);
3050 }
3051
3052 @Test public void testWithExcessBorderRadii() {
3053 region.setStyle(
3054 "-fx-border-style: solid;" +
3055 "-fx-border-color: red;" +
3056 "-fx-border-radius: 5%, 0, 10%, 2;");
3057 processCSS();
3058
3059 assertNull(region.getBackground());
3060 assertEquals(1, region.getBorder().getStrokes().size(), 0);
3061 assertEquals(0, region.getBorder().getImages().size(), 0);
3062
3063 BorderStroke stroke = region.getBorder().getStrokes().get(0);
3064 BorderStroke expected = new BorderStroke(
3065 Color.RED, Color.RED, Color.RED, Color.RED,
3066 BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID, BorderStrokeStyle.SOLID,
3067 new CornerRadii(.05, .05, .05, .05, true),
3068 null, Insets.EMPTY);
3069 assertEquals(expected, stroke);
3070 }
3071
3072 // Finally, the image borders!!
3073 // I probably have to rework things. The image border do depend on some settings from
3074 // the stroke borders (or at least, they can depend on them). As such I might not be
3075 // able to short-circuit the creation of stroke borders, even if they have no style.
3076
3077 @Test public void borderImageSourceIsNull() {
3078 region.setStyle("-fx-border-image-source: null;");
3079 processCSS();
3080
3081 assertEquals(new Insets(0), region.getPadding());
3082 assertNull(region.getBackground());
3083 assertNull(region.getBorder());
3084 }
3085
3086 @Test public void borderImageSource() {
3087 region.setStyle("-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png')");
3088 processCSS();
3089
3090 assertNull(region.getBackground());
3091 assertEquals(0, region.getBorder().getStrokes().size(), 0);
3092 assertEquals(1, region.getBorder().getImages().size(), 0);
3093 }
3094
3095 @Test public void defaultBorderImageValues() {
3096 region.setStyle("-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png')");
3097 processCSS();
3098
3099 BorderImage image = region.getBorder().getImages().get(0);
3100 BorderImage expected = new BorderImage(
3101 image.getImage(),
3102 BorderWidths.DEFAULT,
3103 Insets.EMPTY,
3104 BorderWidths.FULL,
3105 false,
3106 BorderRepeat.STRETCH,
3107 BorderRepeat.STRETCH
3108 );
3109 assertEquals(expected, image);
3110 }
3111
3112 @Test public void borderImageSlice_1() {
3113 region.setStyle(
3114 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3115 "-fx-border-image-slice: 1;");
3116 processCSS();
3117
3118 BorderImage image = region.getBorder().getImages().get(0);
3119 BorderImage expected = new BorderImage(
3120 image.getImage(),
3121 BorderWidths.DEFAULT,
3122 Insets.EMPTY,
3123 new BorderWidths(1, 1, 1, 1, false, false, false, false),
3124 false,
3125 BorderRepeat.STRETCH,
3126 BorderRepeat.STRETCH
3127 );
3128 assertEquals(expected, image);
3129 }
3130
3131 @Test public void borderImageSlice_1_2() {
3132 region.setStyle(
3133 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3134 "-fx-border-image-slice: 1 2;");
3135 processCSS();
3136
3137 BorderImage image = region.getBorder().getImages().get(0);
3138 BorderImage expected = new BorderImage(
3139 image.getImage(),
3140 BorderWidths.DEFAULT,
3141 Insets.EMPTY,
3142 new BorderWidths(1, 2, 1, 2, false, false, false, false),
3143 false,
3144 BorderRepeat.STRETCH,
3145 BorderRepeat.STRETCH
3146 );
3147 assertEquals(expected, image);
3148 }
3149
3150 @Test public void borderImageSlice_1_2_3() {
3151 region.setStyle(
3152 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3153 "-fx-border-image-slice: 1 2 3;");
3154 processCSS();
3155
3156 BorderImage image = region.getBorder().getImages().get(0);
3157 BorderImage expected = new BorderImage(
3158 image.getImage(),
3159 BorderWidths.DEFAULT,
3160 Insets.EMPTY,
3161 new BorderWidths(1, 2, 3, 2, false, false, false, false),
3162 false,
3163 BorderRepeat.STRETCH,
3164 BorderRepeat.STRETCH
3165 );
3166 assertEquals(expected, image);
3167 }
3168
3169 @Test public void borderImageSlice_1_2_3_4() {
3170 region.setStyle(
3171 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3172 "-fx-border-image-slice: 1 2 3 4;");
3173 processCSS();
3174
3175 BorderImage image = region.getBorder().getImages().get(0);
3176 BorderImage expected = new BorderImage(
3177 image.getImage(),
3178 BorderWidths.DEFAULT,
3179 Insets.EMPTY,
3180 new BorderWidths(1, 2, 3, 4, false, false, false, false),
3181 false,
3182 BorderRepeat.STRETCH,
3183 BorderRepeat.STRETCH
3184 );
3185 assertEquals(expected, image);
3186 }
3187
3188 @Test public void borderImageSlice_1_fill() {
3189 region.setStyle(
3190 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3191 "-fx-border-image-slice: 1 fill;");
3192 processCSS();
3193
3194 BorderImage image = region.getBorder().getImages().get(0);
3195 BorderImage expected = new BorderImage(
3196 image.getImage(),
3197 BorderWidths.DEFAULT,
3198 Insets.EMPTY,
3199 new BorderWidths(1, 1, 1, 1),
3200 true,
3201 BorderRepeat.STRETCH,
3202 BorderRepeat.STRETCH
3203 );
3204 assertEquals(expected, image);
3205 }
3206
3207 @Test public void borderImageSlice_1_2_fill() {
3208 region.setStyle(
3209 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3210 "-fx-border-image-slice: 1 2 fill;");
3211 processCSS();
3212
3213 BorderImage image = region.getBorder().getImages().get(0);
3214 BorderImage expected = new BorderImage(
3215 image.getImage(),
3216 BorderWidths.DEFAULT,
3217 Insets.EMPTY,
3218 new BorderWidths(1, 2, 1, 2),
3219 true,
3220 BorderRepeat.STRETCH,
3221 BorderRepeat.STRETCH
3222 );
3223 assertEquals(expected, image);
3224 }
3225
3226 @Test public void borderImageSlice_1_2_3_fill() {
3227 region.setStyle(
3228 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3229 "-fx-border-image-slice: 1 2 3 fill;");
3230 processCSS();
3231
3232 BorderImage image = region.getBorder().getImages().get(0);
3233 BorderImage expected = new BorderImage(
3234 image.getImage(),
3235 BorderWidths.DEFAULT,
3236 Insets.EMPTY,
3237 new BorderWidths(1, 2, 3, 2),
3238 true,
3239 BorderRepeat.STRETCH,
3240 BorderRepeat.STRETCH
3241 );
3242 assertEquals(expected, image);
3243 }
3244
3245 @Test public void borderImageSlice_1_2_3_4_fill() {
3246 region.setStyle(
3247 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3248 "-fx-border-image-slice: 1 2 3 4 fill;");
3249 processCSS();
3250
3251 BorderImage image = region.getBorder().getImages().get(0);
3252 BorderImage expected = new BorderImage(
3253 image.getImage(),
3254 BorderWidths.DEFAULT,
3255 Insets.EMPTY,
3256 new BorderWidths(1, 2, 3, 4),
3257 true,
3258 BorderRepeat.STRETCH,
3259 BorderRepeat.STRETCH
3260 );
3261 assertEquals(expected, image);
3262 }
3263
3264 @Test public void borderImageWidth_1() {
3265 region.setStyle(
3266 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3267 "-fx-border-image-width: 1;");
3268 processCSS();
3269
3270 BorderImage image = region.getBorder().getImages().get(0);
3271 BorderImage expected = new BorderImage(
3272 image.getImage(),
3273 new BorderWidths(1, 1, 1, 1, false, false, false, false),
3274 Insets.EMPTY,
3275 BorderWidths.FULL,
3276 false,
3277 BorderRepeat.STRETCH,
3278 BorderRepeat.STRETCH
3279 );
3280 assertEquals(expected, image);
3281 }
3282
3283 @Test public void borderImageWidth_1_2() {
3284 region.setStyle(
3285 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3286 "-fx-border-image-width: 1 2;");
3287 processCSS();
3288
3289 BorderImage image = region.getBorder().getImages().get(0);
3290 BorderImage expected = new BorderImage(
3291 image.getImage(),
3292 new BorderWidths(1, 2, 1, 2, false, false, false, false),
3293 Insets.EMPTY,
3294 BorderWidths.FULL,
3295 false,
3296 BorderRepeat.STRETCH,
3297 BorderRepeat.STRETCH
3298 );
3299 assertEquals(expected, image);
3300 }
3301
3302 @Test public void borderImageWidth_1_2_3() {
3303 region.setStyle(
3304 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3305 "-fx-border-image-width: 1 2 3;");
3306 processCSS();
3307
3308 BorderImage image = region.getBorder().getImages().get(0);
3309 BorderImage expected = new BorderImage(
3310 image.getImage(),
3311 new BorderWidths(1, 2, 3, 2, false, false, false, false),
3312 Insets.EMPTY,
3313 BorderWidths.FULL,
3314 false,
3315 BorderRepeat.STRETCH,
3316 BorderRepeat.STRETCH
3317 );
3318 assertEquals(expected, image);
3319 }
3320
3321 @Test public void borderImageWidth_1_2_3_4() {
3322 region.setStyle(
3323 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3324 "-fx-border-image-width: 1 2 3 4;");
3325 processCSS();
3326
3327 BorderImage image = region.getBorder().getImages().get(0);
3328 BorderImage expected = new BorderImage(
3329 image.getImage(),
3330 new BorderWidths(1, 2, 3, 4, false, false, false, false),
3331 Insets.EMPTY,
3332 BorderWidths.FULL,
3333 false,
3334 BorderRepeat.STRETCH,
3335 BorderRepeat.STRETCH
3336 );
3337 assertEquals(expected, image);
3338 }
3339
3340 @Test public void borderImageWidth_1_2Percent() {
3341 region.setStyle(
3342 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3343 "-fx-border-image-width: 1 2%;");
3344 processCSS();
3345
3346 BorderImage image = region.getBorder().getImages().get(0);
3347 BorderImage expected = new BorderImage(
3348 image.getImage(),
3349 new BorderWidths(1, .02, 1, .02, false, true, false, true),
3350 Insets.EMPTY,
3351 BorderWidths.FULL,
3352 false,
3353 BorderRepeat.STRETCH,
3354 BorderRepeat.STRETCH
3355 );
3356 assertEquals(expected, image);
3357 }
3358
3359 @Test public void borderImageWidth_1Percent_2Percent_3Percent_4Percent() {
3360 region.setStyle(
3361 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3362 "-fx-border-image-width: 1% 2% 3% 4%;");
3363 processCSS();
3364
3365 BorderImage image = region.getBorder().getImages().get(0);
3366 BorderImage expected = new BorderImage(
3367 image.getImage(),
3368 new BorderWidths(.01, .02, .03, .04, true, true, true, true),
3369 Insets.EMPTY,
3370 BorderWidths.FULL,
3371 false,
3372 BorderRepeat.STRETCH,
3373 BorderRepeat.STRETCH
3374 );
3375 assertEquals(expected, image);
3376 }
3377
3378 @Ignore("I am not certain that supporting auto makes sense for us, and if it does, is it anything other than 1?")
3379 @Test public void borderImageWidth_auto() {
3380 region.setStyle(
3381 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3382 "-fx-border-image-width: auto;");
3383 processCSS();
3384
3385 BorderImage image = region.getBorder().getImages().get(0);
3386 BorderImage expected = new BorderImage(
3387 image.getImage(),
3388 new BorderWidths(
3389 BorderWidths.AUTO, BorderWidths.AUTO,
3390 BorderWidths.AUTO, BorderWidths.AUTO, false, false, false, false),
3391 Insets.EMPTY,
3392 BorderWidths.FULL,
3393 false,
3394 BorderRepeat.STRETCH,
3395 BorderRepeat.STRETCH
3396 );
3397 assertEquals(expected, image);
3398 }
3399
3400 @Ignore("I am not certain that supporting auto makes sense for us, and if it does, is it anything other than 1?")
3401 @Test public void borderImageWidth_1_auto() {
3402 region.setStyle(
3403 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3404 "-fx-border-image-width: 1 auto;");
3405 processCSS();
3406
3407 BorderImage image = region.getBorder().getImages().get(0);
3408 BorderImage expected = new BorderImage(
3409 image.getImage(),
3410 new BorderWidths(1, BorderWidths.AUTO,
3411 1, BorderWidths.AUTO, false, false, false, false),
3412 Insets.EMPTY,
3413 BorderWidths.FULL,
3414 false,
3415 BorderRepeat.STRETCH,
3416 BorderRepeat.STRETCH
3417 );
3418 assertEquals(expected, image);
3419 }
3420
3421 @Ignore("I am not certain that supporting auto makes sense for us, and if it does, is it anything other than 1?")
3422 @Test public void borderImageWidth_1_2Percent_auto() {
3423 region.setStyle(
3424 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3425 "-fx-border-image-width: 1 2% auto;");
3426 processCSS();
3427
3428 BorderImage image = region.getBorder().getImages().get(0);
3429 BorderImage expected = new BorderImage(
3430 image.getImage(),
3431 new BorderWidths(1, .02,
3432 BorderWidths.AUTO, .02, false, true, false, true),
3433 Insets.EMPTY,
3434 BorderWidths.FULL,
3435 false,
3436 BorderRepeat.STRETCH,
3437 BorderRepeat.STRETCH
3438 );
3439 assertEquals(expected, image);
3440 }
3441
3442 @Test public void borderImageOutset_1() {
3443 region.setStyle(
3444 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3445 "-fx-border-image-insets: 1;");
3446 processCSS();
3447
3448 BorderImage image = region.getBorder().getImages().get(0);
3449 BorderImage expected = new BorderImage(
3450 image.getImage(),
3451 BorderWidths.DEFAULT,
3452 new Insets(1),
3453 BorderWidths.FULL,
3454 false,
3455 BorderRepeat.STRETCH,
3456 BorderRepeat.STRETCH
3457 );
3458 assertEquals(expected, image);
3459 }
3460
3461 @Test public void borderImageOutset_1_2() {
3462 region.setStyle(
3463 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3464 "-fx-border-image-insets: 1 2;");
3465 processCSS();
3466
3467 BorderImage image = region.getBorder().getImages().get(0);
3468 BorderImage expected = new BorderImage(
3469 image.getImage(),
3470 BorderWidths.DEFAULT,
3471 new Insets(1, 2, 1, 2),
3472 BorderWidths.FULL,
3473 false,
3474 BorderRepeat.STRETCH,
3475 BorderRepeat.STRETCH
3476 );
3477 assertEquals(expected, image);
3478 }
3479
3480 @Test public void borderImageOutset_1_2_3() {
3481 region.setStyle(
3482 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3483 "-fx-border-image-insets: 1 2 3;");
3484 processCSS();
3485
3486 BorderImage image = region.getBorder().getImages().get(0);
3487 BorderImage expected = new BorderImage(
3488 image.getImage(),
3489 BorderWidths.DEFAULT,
3490 new Insets(1, 2, 3, 2),
3491 BorderWidths.FULL,
3492 false,
3493 BorderRepeat.STRETCH,
3494 BorderRepeat.STRETCH
3495 );
3496 assertEquals(expected, image);
3497 }
3498
3499 @Test public void borderImageOutset_1_2_3_4() {
3500 region.setStyle(
3501 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3502 "-fx-border-image-insets: 1 2 3 4;");
3503 processCSS();
3504
3505 BorderImage image = region.getBorder().getImages().get(0);
3506 BorderImage expected = new BorderImage(
3507 image.getImage(),
3508 BorderWidths.DEFAULT,
3509 new Insets(1, 2, 3, 4),
3510 BorderWidths.FULL,
3511 false,
3512 BorderRepeat.STRETCH,
3513 BorderRepeat.STRETCH
3514 );
3515 assertEquals(expected, image);
3516 }
3517
3518 @Test public void borderImageRepeat_stretch() {
3519 region.setStyle(
3520 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3521 "-fx-border-image-repeat: stretch;");
3522 processCSS();
3523
3524 BorderImage image = region.getBorder().getImages().get(0);
3525 BorderImage expected = new BorderImage(
3526 image.getImage(),
3527 BorderWidths.DEFAULT,
3528 Insets.EMPTY,
3529 BorderWidths.FULL,
3530 false,
3531 BorderRepeat.STRETCH,
3532 BorderRepeat.STRETCH
3533 );
3534 assertEquals(expected, image);
3535 }
3536
3537 @Test public void borderImageRepeat_repeat() {
3538 region.setStyle(
3539 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3540 "-fx-border-image-repeat: repeat;");
3541 processCSS();
3542
3543 BorderImage image = region.getBorder().getImages().get(0);
3544 BorderImage expected = new BorderImage(
3545 image.getImage(),
3546 BorderWidths.DEFAULT,
3547 Insets.EMPTY,
3548 BorderWidths.FULL,
3549 false,
3550 BorderRepeat.REPEAT,
3551 BorderRepeat.REPEAT
3552 );
3553 assertEquals(expected, image);
3554 }
3555
3556 @Test public void borderImageRepeat_round() {
3557 region.setStyle(
3558 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3559 "-fx-border-image-repeat: round;");
3560 processCSS();
3561
3562 BorderImage image = region.getBorder().getImages().get(0);
3563 BorderImage expected = new BorderImage(
3564 image.getImage(),
3565 BorderWidths.DEFAULT,
3566 Insets.EMPTY,
3567 BorderWidths.FULL,
3568 false,
3569 BorderRepeat.ROUND,
3570 BorderRepeat.ROUND
3571 );
3572 assertEquals(expected, image);
3573 }
3574
3575 @Test public void borderImageRepeat_space() {
3576 region.setStyle(
3577 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3578 "-fx-border-image-repeat: space;");
3579 processCSS();
3580
3581 BorderImage image = region.getBorder().getImages().get(0);
3582 BorderImage expected = new BorderImage(
3583 image.getImage(),
3584 BorderWidths.DEFAULT,
3585 Insets.EMPTY,
3586 BorderWidths.FULL,
3587 false,
3588 BorderRepeat.SPACE,
3589 BorderRepeat.SPACE
3590 );
3591 assertEquals(expected, image);
3592 }
3593
3594 @Test public void borderImageRepeat_round_stretch() {
3595 region.setStyle(
3596 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3597 "-fx-border-image-repeat: round stretch;");
3598 processCSS();
3599
3600 BorderImage image = region.getBorder().getImages().get(0);
3601 BorderImage expected = new BorderImage(
3602 image.getImage(),
3603 BorderWidths.DEFAULT,
3604 Insets.EMPTY,
3605 BorderWidths.FULL,
3606 false,
3607 BorderRepeat.ROUND,
3608 BorderRepeat.STRETCH
3609 );
3610 assertEquals(expected, image);
3611 }
3612
3613 @Test public void borderImageRepeat_round_repeat() {
3614 region.setStyle(
3615 "-fx-border-image-source: url('test/javafx/scene/layout/center-btn.png');" +
3616 "-fx-border-image-repeat: round repeat;");
3617 processCSS();
3618
3619 BorderImage image = region.getBorder().getImages().get(0);
3620 BorderImage expected = new BorderImage(
3621 image.getImage(),
3622 BorderWidths.DEFAULT,
3623 Insets.EMPTY,
3624 BorderWidths.FULL,
3625 false,
3626 BorderRepeat.ROUND,
3627 BorderRepeat.REPEAT
3628 );
3629 assertEquals(expected, image);
3630 }
3631
3632 // TODO multiple image borders
3633 // TODO complex background fill, background image, stroke border, image border scenario
3634 }