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