1 /*
   2  * Copyright (c) 2010, 2014, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package javafx.scene.control;
  27 
  28 import javafx.css.CssMetaData;
  29 import java.io.File;
  30 import java.lang.reflect.InvocationTargetException;
  31 import java.lang.reflect.Method;
  32 import java.lang.reflect.Modifier;
  33 import java.net.URL;
  34 import java.util.Arrays;
  35 import java.util.List;
  36 import javafx.beans.property.DoubleProperty;
  37 import javafx.beans.property.ObjectProperty;
  38 import javafx.beans.property.SimpleDoubleProperty;
  39 import javafx.beans.property.SimpleObjectProperty;
  40 import javafx.beans.value.ChangeListener;
  41 import javafx.beans.value.ObservableValue;
  42 import javafx.beans.value.WritableValue;
  43 import javafx.scene.Group;
  44 import javafx.scene.Node;
  45 import javafx.scene.shape.Rectangle;
  46 import com.sun.javafx.scene.control.Logging;
  47 import javafx.css.Styleable;
  48 import javafx.css.StyleableProperty;
  49 import org.junit.Before;
  50 import org.junit.Ignore;
  51 import org.junit.Test;
  52 import sun.util.logging.PlatformLogger;
  53 import sun.util.logging.PlatformLogger.Level;
  54 
  55 import static org.junit.Assert.*;
  56 
  57 /**
  58  * Things every Control needs to test:
  59  *  - Properties
  60  *     - Set the value, see that it changes
  61  *     - Set an illegal value, see that it is rejected
  62  *     - Bind to some other value, see that when the binding fires, the property is updated (vague)
  63  *  - CSS
  64  *     - Change state, watch the pseudo class state change
  65  *     - Default style-class has what you expect
  66  *     - (2nd order) impl_cssSettable returns true for thing in their default state
  67  *     - (2nd order) impl_cssSettable returns false for things manually specified
  68  *     - (3rd order) impl_cssKeys includes all the public properties
  69  *  - Methods
  70  *     - For all methods, calling the method mutates the state appropriately
  71  */
  72 public class ControlTest {
  73     private static final double MIN_WIDTH = 35;
  74     private static final double MIN_HEIGHT = 45;
  75     private static final double MAX_WIDTH = 2000;
  76     private static final double MAX_HEIGHT = 2011;
  77     private static final double PREF_WIDTH = 100;
  78     private static final double PREF_HEIGHT = 130;
  79     private static final double BASELINE_OFFSET = 10;
  80 
  81     private ControlStub c;
  82     private SkinStub<ControlStub> s;
  83     private ResizableRectangle skinNode;
  84 
  85     private Level originalLogLevel = null;
  86 
  87     @Before public void setUp() {
  88         c = new ControlStub();
  89         s = new SkinStub<ControlStub>(c);
  90         skinNode = new ResizableRectangle();
  91         skinNode.resize(20, 20);
  92         skinNode.minWidth = MIN_WIDTH;
  93         skinNode.minHeight = MIN_HEIGHT;
  94         skinNode.maxWidth = MAX_WIDTH;
  95         skinNode.maxHeight = MAX_HEIGHT;
  96         skinNode.prefWidth = PREF_WIDTH;
  97         skinNode.prefHeight = PREF_HEIGHT;
  98         skinNode.baselineOffset = BASELINE_OFFSET;
  99         s.setNode(skinNode);
 100     }
 101 
 102     private void disableLogging() {
 103         final PlatformLogger logger = Logging.getControlsLogger();
 104         originalLogLevel = logger.level();
 105         logger.setLevel(Level.OFF);
 106     }
 107 
 108     private void enableLogging() {
 109         final PlatformLogger logger = Logging.getControlsLogger();
 110 //        logger.setLevel(originalLogLevel);
 111         logger.setLevel(Level.FINE);
 112     }
 113 
 114     @Test public void focusTraversableIsTrueByDefault() {
 115         assertTrue(c.isFocusTraversable());
 116     }
 117 
 118     @Test public void resizableIsTrueByDefault() {
 119         assertTrue(c.isResizable());
 120     }
 121 
 122     @Test public void modifyingTheControlWidthUpdatesTheLayoutBounds() {
 123         c.resize(173, c.getHeight());
 124         assertEquals(173, c.getLayoutBounds().getWidth(), 0);
 125     }
 126 
 127     @Test public void modifyingTheControlWidthLeadsToRequestLayout() {
 128         // Make sure the Control has it's needsLayout flag cleared
 129         c.layout();
 130         assertTrue(!c.isNeedsLayout());
 131         // Run the test
 132         c.resize(173, c.getHeight());
 133         assertTrue(c.isNeedsLayout());
 134     }
 135 
 136     @Test public void modifyingTheControlHeightUpdatesTheLayoutBounds() {
 137         c.resize(c.getWidth(), 173);
 138         assertEquals(173, c.getLayoutBounds().getHeight(), 0);
 139     }
 140 
 141     @Test public void modifyingTheControlHeightLeadsToRequestLayout() {
 142         // Make sure the Control has it's needsLayout flag cleared
 143         c.layout();
 144         assertTrue(!c.isNeedsLayout());
 145         // Run the test
 146         c.resize(c.getWidth(), 173);
 147         assertTrue(c.isNeedsLayout());
 148     }
 149 
 150     @Test public void multipleModificationsToWidthAndHeightAreReflectedInLayoutBounds() {
 151         c.resize(723, 234);
 152         c.resize(992, 238);
 153         assertEquals(992, c.getLayoutBounds().getWidth(), 0);
 154         assertEquals(238, c.getLayoutBounds().getHeight(), 0);
 155     }
 156 
 157     @Test public void containsDelegatesToTheSkinWhenSet() {
 158         c.setSkin(s);
 159         skinNode.resize(100, 100);
 160         assertTrue(c.getSkin().getNode() != null);
 161         assertTrue(c.contains(50, 50));
 162     }
 163 
 164     @Test public void intersectsReturnsTrueWhenThereIsNoSkin() {
 165         c.relocate(0, 0);
 166         c.resize(100, 100);
 167         assertTrue(c.intersects(50, 50, 100, 100));
 168     }
 169 
 170     @Test public void intersectsDelegatesToTheSkinWhenSet() {
 171         c.setSkin(s);
 172         skinNode.resize(100, 100);
 173         assertTrue(c.intersects(50, 50, 100, 100));
 174     }
 175 
 176     @Test public void skinIsResizedToExactSizeOfControlOnLayout() {
 177         c.setSkin(s);
 178         c.resize(67, 998);
 179         c.layout();
 180         assertEquals(0, s.getNode().getLayoutBounds().getMinX(), 0);
 181         assertEquals(0, s.getNode().getLayoutBounds().getMinY(), 0);
 182         assertEquals(67, s.getNode().getLayoutBounds().getWidth(), 0);
 183         assertEquals(998, s.getNode().getLayoutBounds().getHeight(), 0);
 184     }
 185 
 186     @Test public void skinWithNodeLargerThanControlDoesntAffectLayoutBounds() {
 187         s.setNode(new Rectangle(0, 0, 1000, 1001));
 188         c.setSkin(s);
 189         c.resize(50, 40);
 190         c.layout();
 191         // Sanity check: the layout bounds of the skin node itself is large
 192         assertEquals(1000, c.getSkin().getNode().getLayoutBounds().getWidth(), 0);
 193         assertEquals(1001, c.getSkin().getNode().getLayoutBounds().getHeight(), 0);
 194         // Test: the layout bounds of the control is still 50, 40
 195         assertEquals(50, c.getLayoutBounds().getWidth(), 0);
 196         assertEquals(40, c.getLayoutBounds().getHeight(), 0);
 197     }
 198 
 199     /****************************************************************************
 200      * minWidth Tests                                                           *
 201      ***************************************************************************/
 202 
 203     @Test public void callsToSetMinWidthResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 204         // Setup and sanity check
 205         Group parent = new Group();
 206         parent.getChildren().add(c);
 207         parent.layout();
 208         assertTrue(!parent.isNeedsLayout());
 209         assertTrue(!c.isNeedsLayout());
 210         // Test
 211         c.setMinWidth(123.45);
 212         assertTrue(parent.isNeedsLayout());
 213         assertTrue(!c.isNeedsLayout());
 214     }
 215 
 216     @Test public void getMinWidthReturnsTheMinWidthOfTheSkinNode() {
 217         c.setSkin(s);
 218         assertEquals(MIN_WIDTH, c.minWidth(-1), 0.0);
 219     }
 220 
 221     @Test public void getMinWidthReturnsTheCustomSetMinWidthWhenSpecified() {
 222         c.setSkin(s);
 223         c.setMinWidth(123.45);
 224         assertEquals(123.45, c.minWidth(-1), 0.0);
 225     }
 226 
 227     @Test public void getMinWidthReturnsTheCustomSetMinWidthWhenSpecifiedEvenWhenThereIsNoSkin() {
 228         c.setMinWidth(123.45);
 229         assertEquals(123.45, c.minWidth(-1), 0.0);
 230     }
 231 
 232     @Test public void minWidthWhenNoSkinIsSetIsZeroByDefault() {
 233         assertEquals(0, c.minWidth(-1), 0.0);
 234     }
 235 
 236     @Test public void resettingMinWidthTo_USE_PREF_SIZE_ReturnsThePrefWidthOfTheSkinNodeWhenThereIsASkin() {
 237         c.setSkin(s);
 238         c.setMinWidth(123.45);
 239         c.setMinWidth(Control.USE_PREF_SIZE);
 240         assertEquals(PREF_WIDTH, c.minWidth(-1), 0.0);
 241     }
 242 
 243     @Test public void resettingMinWidthTo_USE_PREF_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefWidthIsNotSet() {
 244         c.setMinWidth(123.45);
 245         c.setMinWidth(Control.USE_PREF_SIZE);
 246         assertEquals(0, c.minWidth(-1), 0.0);
 247     }
 248 
 249     @Test public void resettingMinWidthTo_USE_PREF_SIZE_ReturnsPrefWidthWhenThereIsNoSkinAndPrefWidthIsSet() {
 250         c.setMinWidth(123.45);
 251         c.setPrefWidth(98.6);
 252         c.setMinWidth(Control.USE_PREF_SIZE);
 253         assertEquals(98.6, c.minWidth(-1), 0.0);
 254     }
 255 
 256     @Test public void resettingMinWidthTo_USE_COMPUTED_SIZE_ReturnsTheMinWidthOfTheSkinNodeWhenThereIsASkin() {
 257         c.setSkin(s);
 258         c.setMinWidth(123.45);
 259         c.setMinWidth(Control.USE_COMPUTED_SIZE);
 260         assertEquals(MIN_WIDTH, c.minWidth(-1), 0.0);
 261     }
 262 
 263     @Test public void resettingMinWidthTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefWidthIsNotSet() {
 264         c.setMinWidth(123.45);
 265         c.setMinWidth(Control.USE_COMPUTED_SIZE);
 266         assertEquals(0, c.minWidth(-1), 0.0);
 267     }
 268 
 269     @Test public void minWidthIs_USE_COMPUTED_SIZE_ByDefault() {
 270         assertEquals(Control.USE_COMPUTED_SIZE, c.getMinWidth(), 0);
 271         assertEquals(Control.USE_COMPUTED_SIZE, c.minWidthProperty().get(), 0);
 272     }
 273 
 274     @Test public void minWidthCanBeSet() {
 275         c.setMinWidth(234);
 276         assertEquals(234, c.getMinWidth(), 0);
 277         assertEquals(234, c.minWidthProperty().get(), 0);
 278     }
 279 
 280     @Test public void minWidthCanBeBound() {
 281         DoubleProperty other = new SimpleDoubleProperty(939);
 282         c.minWidthProperty().bind(other);
 283         assertEquals(939, c.getMinWidth(), 0);
 284         other.set(332);
 285         assertEquals(332, c.getMinWidth(), 0);
 286     }
 287 
 288     @Test public void minWidthPropertyHasBeanReference() {
 289         assertSame(c, c.minWidthProperty().getBean());
 290     }
 291 
 292     @Test public void minWidthPropertyHasName() {
 293         assertEquals("minWidth", c.minWidthProperty().getName());
 294     }
 295 
 296     /****************************************************************************
 297      * minHeight Tests                                                          *
 298      ***************************************************************************/
 299 
 300     @Test public void callsToSetMinHeightResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 301         // Setup and sanity check
 302         Group parent = new Group();
 303         parent.getChildren().add(c);
 304         parent.layout();
 305         assertTrue(!parent.isNeedsLayout());
 306         assertTrue(!c.isNeedsLayout());
 307         // Test
 308         c.setMinHeight(98.76);
 309         assertTrue(parent.isNeedsLayout());
 310         assertTrue(!c.isNeedsLayout());
 311     }
 312 
 313     @Test public void getMinHeightReturnsTheMinHeightOfTheSkinNode() {
 314         c.setSkin(s);
 315         assertEquals(MIN_HEIGHT, c.minHeight(-1), 0.0);
 316     }
 317 
 318     @Test public void getMinHeightReturnsTheCustomSetMinHeightWhenSpecified() {
 319         c.setSkin(s);
 320         c.setMinHeight(98.76);
 321         assertEquals(98.76, c.minHeight(-1), 0.0);
 322     }
 323 
 324     @Test public void getMinHeightReturnsTheCustomSetMinHeightWhenSpecifiedEvenWhenThereIsNoSkin() {
 325         c.setMinHeight(98.76);
 326         assertEquals(98.76, c.minHeight(-1), 0.0);
 327     }
 328 
 329     @Test public void minHeightWhenNoSkinIsSetIsZeroByDefault() {
 330         assertEquals(0, c.minHeight(-1), 0.0);
 331     }
 332 
 333     @Test public void resettingMinHeightTo_USE_PREF_SIZE_ReturnsThePrefHeightOfTheSkinNodeWhenThereIsASkin() {
 334         c.setSkin(s);
 335         c.setMinHeight(98.76);
 336         c.setMinHeight(Control.USE_PREF_SIZE);
 337         assertEquals(PREF_HEIGHT, c.minHeight(-1), 0.0);
 338     }
 339 
 340     @Test public void resettingMinHeightTo_USE_PREF_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefHeightIsNotSet() {
 341         c.setMinHeight(98.76);
 342         c.setMinHeight(Control.USE_PREF_SIZE);
 343         assertEquals(0, c.minHeight(-1), 0.0);
 344     }
 345 
 346     @Test public void resettingMinHeightTo_USE_PREF_SIZE_ReturnsPrefHeightWhenThereIsNoSkinAndPrefHeightIsSet() {
 347         c.setMinHeight(98.76);
 348         c.setPrefHeight(105.2);
 349         c.setMinHeight(Control.USE_PREF_SIZE);
 350         assertEquals(105.2, c.minHeight(-1), 0.0);
 351     }
 352 
 353     @Test public void resettingMinHeightTo_USE_COMPUTED_SIZE_ReturnsTheMinHeightOfTheSkinNodeWhenThereIsASkin() {
 354         c.setSkin(s);
 355         c.setMinHeight(98.76);
 356         c.setMinHeight(Control.USE_COMPUTED_SIZE);
 357         assertEquals(MIN_HEIGHT, c.minHeight(-1), 0.0);
 358     }
 359 
 360     @Test public void resettingMinHeightTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefHeightIsNotSet() {
 361         c.setMinHeight(98.76);
 362         c.setMinHeight(Control.USE_COMPUTED_SIZE);
 363         assertEquals(0, c.minHeight(-1), 0.0);
 364     }
 365 
 366     @Test public void minHeightIs_USE_COMPUTED_SIZE_ByDefault() {
 367         assertEquals(Control.USE_COMPUTED_SIZE, c.getMinHeight(), 0);
 368         assertEquals(Control.USE_COMPUTED_SIZE, c.minHeightProperty().get(), 0);
 369     }
 370 
 371     @Test public void minHeightCanBeSet() {
 372         c.setMinHeight(98.76);
 373         assertEquals(98.76, c.getMinHeight(), 0);
 374         assertEquals(98.76, c.minHeightProperty().get(), 0);
 375     }
 376 
 377     @Test public void minHeightCanBeBound() {
 378         DoubleProperty other = new SimpleDoubleProperty(939);
 379         c.minHeightProperty().bind(other);
 380         assertEquals(939, c.getMinHeight(), 0);
 381         other.set(332);
 382         assertEquals(332, c.getMinHeight(), 0);
 383     }
 384 
 385     @Test public void minHeightPropertyHasBeanReference() {
 386         assertSame(c, c.minHeightProperty().getBean());
 387     }
 388 
 389     @Test public void minHeightPropertyHasName() {
 390         assertEquals("minHeight", c.minHeightProperty().getName());
 391     }
 392 
 393     /****************************************************************************
 394      * maxWidth Tests                                                           *
 395      ***************************************************************************/
 396 
 397     @Test public void callsToSetMaxWidthResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 398         // Setup and sanity check
 399         Group parent = new Group();
 400         parent.getChildren().add(c);
 401         parent.layout();
 402         assertTrue(!parent.isNeedsLayout());
 403         assertTrue(!c.isNeedsLayout());
 404         // Test
 405         c.setMaxWidth(500);
 406         assertTrue(parent.isNeedsLayout());
 407         assertTrue(!c.isNeedsLayout());
 408     }
 409 
 410     @Test public void getMaxWidthReturnsTheMaxWidthOfTheSkinNode() {
 411         c.setSkin(s);
 412         assertEquals(MAX_WIDTH, c.maxWidth(-1), 0.0);
 413     }
 414 
 415     @Test public void getMaxWidthReturnsTheCustomSetMaxWidthWhenSpecified() {
 416         c.setSkin(s);
 417         c.setMaxWidth(500);
 418         assertEquals(500, c.maxWidth(-1), 0.0);
 419     }
 420 
 421     @Test public void getMaxWidthReturnsTheCustomSetMaxWidthWhenSpecifiedEvenWhenThereIsNoSkin() {
 422         c.setMaxWidth(500);
 423         assertEquals(500, c.maxWidth(-1), 0.0);
 424     }
 425 
 426     @Test public void maxWidthWhenNoSkinIsSetIsZeroByDefault() {
 427         assertEquals(0, c.maxWidth(-1), 0.0);
 428     }
 429 
 430     @Test public void resettingMaxWidthTo_USE_PREF_SIZE_ReturnsThePrefWidthOfTheSkinNodeWhenThereIsASkin() {
 431         c.setSkin(s);
 432         c.setMaxWidth(500);
 433         c.setMaxWidth(Control.USE_PREF_SIZE);
 434         assertEquals(PREF_WIDTH, c.maxWidth(-1), 0.0);
 435     }
 436 
 437     @Test public void resettingMaxWidthTo_USE_PREF_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefWidthIsNotSet() {
 438         c.setMaxWidth(500);
 439         c.setMaxWidth(Control.USE_PREF_SIZE);
 440         assertEquals(0, c.maxWidth(-1), 0.0);
 441     }
 442 
 443     @Test public void resettingMaxWidthTo_USE_PREF_SIZE_ReturnsPrefWidthWhenThereIsNoSkinAndPrefWidthIsSet() {
 444         c.setMaxWidth(500);
 445         c.setPrefWidth(98.6);
 446         c.setMaxWidth(Control.USE_PREF_SIZE);
 447         assertEquals(98.6, c.maxWidth(-1), 0.0);
 448     }
 449 
 450     @Test public void resettingMaxWidthTo_USE_COMPUTED_SIZE_ReturnsTheMaxWidthOfTheSkinNodeWhenThereIsASkin() {
 451         c.setSkin(s);
 452         c.setMaxWidth(500);
 453         c.setMaxWidth(Control.USE_COMPUTED_SIZE);
 454         assertEquals(MAX_WIDTH, c.maxWidth(-1), 0.0);
 455     }
 456 
 457     @Test public void resettingMaxWidthTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefWidthIsNotSet() {
 458         c.setMaxWidth(500);
 459         c.setMaxWidth(Control.USE_COMPUTED_SIZE);
 460         assertEquals(0, c.maxWidth(-1), 0.0);
 461     }
 462 
 463     @Test public void maxWidthIs_USE_COMPUTED_SIZE_ByDefault() {
 464         assertEquals(Control.USE_COMPUTED_SIZE, c.getMaxWidth(), 0);
 465         assertEquals(Control.USE_COMPUTED_SIZE, c.maxWidthProperty().get(), 0);
 466     }
 467 
 468     @Test public void maxWidthCanBeSet() {
 469         c.setMaxWidth(500);
 470         assertEquals(500, c.getMaxWidth(), 0);
 471         assertEquals(500, c.maxWidthProperty().get(), 0);
 472     }
 473 
 474     @Test public void maxWidthCanBeBound() {
 475         DoubleProperty other = new SimpleDoubleProperty(939);
 476         c.maxWidthProperty().bind(other);
 477         assertEquals(939, c.getMaxWidth(), 0);
 478         other.set(332);
 479         assertEquals(332, c.getMaxWidth(), 0);
 480     }
 481 
 482     @Test public void maxWidthPropertyHasBeanReference() {
 483         assertSame(c, c.maxWidthProperty().getBean());
 484     }
 485 
 486     @Test public void maxWidthPropertyHasName() {
 487         assertEquals("maxWidth", c.maxWidthProperty().getName());
 488     }
 489 
 490     /****************************************************************************
 491      * maxHeight Tests                                                          *
 492      ***************************************************************************/
 493 
 494     @Test public void callsToSetMaxHeightResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 495         // Setup and sanity check
 496         Group parent = new Group();
 497         parent.getChildren().add(c);
 498         parent.layout();
 499         assertTrue(!parent.isNeedsLayout());
 500         assertTrue(!c.isNeedsLayout());
 501         // Test
 502         c.setMaxHeight(450);
 503         assertTrue(parent.isNeedsLayout());
 504         assertTrue(!c.isNeedsLayout());
 505     }
 506 
 507     @Test public void getMaxHeightReturnsTheMaxHeightOfTheSkinNode() {
 508         c.setSkin(s);
 509         assertEquals(MAX_HEIGHT, c.maxHeight(-1), 0.0);
 510     }
 511 
 512     @Test public void getMaxHeightReturnsTheCustomSetMaxHeightWhenSpecified() {
 513         c.setSkin(s);
 514         c.setMaxHeight(450);
 515         assertEquals(450, c.maxHeight(-1), 0.0);
 516     }
 517 
 518     @Test public void getMaxHeightReturnsTheCustomSetMaxHeightWhenSpecifiedEvenWhenThereIsNoSkin() {
 519         c.setMaxHeight(500);
 520         assertEquals(500, c.maxHeight(-1), 0.0);
 521     }
 522 
 523     @Test public void maxHeightWhenNoSkinIsSetIsZeroByDefault() {
 524         assertEquals(0, c.maxHeight(-1), 0.0);
 525     }
 526 
 527     @Test public void resettingMaxHeightTo_USE_PREF_SIZE_ReturnsThePrefHeightOfTheSkinNodeWhenThereIsASkin() {
 528         c.setSkin(s);
 529         c.setMaxHeight(500);
 530         c.setMaxHeight(Control.USE_PREF_SIZE);
 531         assertEquals(PREF_HEIGHT, c.maxHeight(-1), 0.0);
 532     }
 533 
 534     @Test public void resettingMaxHeightTo_USE_PREF_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefHeightIsNotSet() {
 535         c.setMaxHeight(500);
 536         c.setMaxHeight(Control.USE_PREF_SIZE);
 537         assertEquals(0, c.maxHeight(-1), 0.0);
 538     }
 539 
 540     @Test public void resettingMaxHeightTo_USE_PREF_SIZE_ReturnsPrefHeightWhenThereIsNoSkinAndPrefHeightIsSet() {
 541         c.setMaxHeight(500);
 542         c.setPrefHeight(105.2);
 543         c.setMaxHeight(Control.USE_PREF_SIZE);
 544         assertEquals(105.2, c.maxHeight(-1), 0.0);
 545     }
 546 
 547     @Test public void resettingMaxHeightTo_USE_COMPUTED_SIZE_ReturnsTheMaxHeightOfTheSkinNodeWhenThereIsASkin() {
 548         c.setSkin(s);
 549         c.setMaxHeight(500);
 550         c.setMaxHeight(Control.USE_COMPUTED_SIZE);
 551         assertEquals(MAX_HEIGHT, c.maxHeight(-1), 0.0);
 552     }
 553 
 554     @Test public void resettingMaxHeightTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefHeightIsNotSet() {
 555         c.setMaxHeight(500);
 556         c.setMaxHeight(Control.USE_COMPUTED_SIZE);
 557         assertEquals(0, c.maxHeight(-1), 0.0);
 558     }
 559 
 560     @Test public void maxHeightIs_USE_COMPUTED_SIZE_ByDefault() {
 561         assertEquals(Control.USE_COMPUTED_SIZE, c.getMaxHeight(), 0);
 562         assertEquals(Control.USE_COMPUTED_SIZE, c.maxHeightProperty().get(), 0);
 563     }
 564 
 565     @Test public void maxHeightCanBeSet() {
 566         c.setMaxHeight(500);
 567         assertEquals(500, c.getMaxHeight(), 0);
 568         assertEquals(500, c.maxHeightProperty().get(), 0);
 569     }
 570 
 571     @Test public void maxHeightCanBeBound() {
 572         DoubleProperty other = new SimpleDoubleProperty(939);
 573         c.maxHeightProperty().bind(other);
 574         assertEquals(939, c.getMaxHeight(), 0);
 575         other.set(332);
 576         assertEquals(332, c.getMaxHeight(), 0);
 577     }
 578 
 579     @Test public void maxHeightPropertyHasBeanReference() {
 580         assertSame(c, c.maxHeightProperty().getBean());
 581     }
 582 
 583     @Test public void maxHeightPropertyHasName() {
 584         assertEquals("maxHeight", c.maxHeightProperty().getName());
 585     }
 586 
 587     /****************************************************************************
 588      * prefWidth Tests                                                          *
 589      ***************************************************************************/
 590 
 591     @Test public void callsToSetPrefWidthResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 592         // Setup and sanity check
 593         Group parent = new Group();
 594         parent.getChildren().add(c);
 595         parent.layout();
 596         assertTrue(!parent.isNeedsLayout());
 597         assertTrue(!c.isNeedsLayout());
 598         // Test
 599         c.setPrefWidth(80);
 600         assertTrue(parent.isNeedsLayout());
 601         assertTrue(!c.isNeedsLayout());
 602     }
 603 
 604     @Test public void getPrefWidthReturnsThePrefWidthOfTheSkinNode() {
 605         c.setSkin(s);
 606         assertEquals(PREF_WIDTH, c.prefWidth(-1), 0.0);
 607     }
 608 
 609     @Test public void getPrefWidthReturnsTheCustomSetPrefWidthWhenSpecified() {
 610         c.setSkin(s);
 611         c.setPrefWidth(80);
 612         assertEquals(80, c.prefWidth(-1), 0.0);
 613     }
 614 
 615     @Test public void getPrefWidthReturnsTheCustomSetPrefWidthWhenSpecifiedEvenWhenThereIsNoSkin() {
 616         c.setPrefWidth(80);
 617         assertEquals(80, c.prefWidth(-1), 0.0);
 618     }
 619 
 620     @Test public void prefWidthWhenNoSkinIsSetIsZeroByDefault() {
 621         assertEquals(0, c.prefWidth(-1), 0.0);
 622     }
 623 
 624     @Ignore ("What should happen when the pref width is set to USE_PREF_SIZE? Seems it should be an exception")
 625     @Test public void resettingPrefWidthTo_USE_PREF_SIZE_ThrowsExceptionWhenThereIsASkin() {
 626         c.setSkin(s);
 627         c.setPrefWidth(80);
 628         c.setPrefWidth(Control.USE_PREF_SIZE);
 629         assertEquals(PREF_WIDTH, c.prefWidth(-1), 0.0);
 630     }
 631 
 632     @Test public void resettingPrefWidthTo_USE_COMPUTED_SIZE_ReturnsThePrefWidthOfTheSkinNodeWhenThereIsASkin() {
 633         c.setSkin(s);
 634         c.setPrefWidth(80);
 635         c.setPrefWidth(Control.USE_COMPUTED_SIZE);
 636         assertEquals(PREF_WIDTH, c.prefWidth(-1), 0.0);
 637     }
 638 
 639     @Test public void resettingPrefWidthTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefWidthIsNotSet() {
 640         c.setPrefWidth(80);
 641         c.setPrefWidth(Control.USE_COMPUTED_SIZE);
 642         assertEquals(0, c.prefWidth(-1), 0.0);
 643     }
 644 
 645     @Test public void prefWidthIs_USE_COMPUTED_SIZE_ByDefault() {
 646         assertEquals(Control.USE_COMPUTED_SIZE, c.getPrefWidth(), 0);
 647         assertEquals(Control.USE_COMPUTED_SIZE, c.prefWidthProperty().get(), 0);
 648     }
 649 
 650     @Test public void prefWidthCanBeSet() {
 651         c.setPrefWidth(80);
 652         assertEquals(80, c.getPrefWidth(), 0);
 653         assertEquals(80, c.prefWidthProperty().get(), 0);
 654     }
 655 
 656     @Test public void prefWidthCanBeBound() {
 657         DoubleProperty other = new SimpleDoubleProperty(939);
 658         c.prefWidthProperty().bind(other);
 659         assertEquals(939, c.getPrefWidth(), 0);
 660         other.set(332);
 661         assertEquals(332, c.getPrefWidth(), 0);
 662     }
 663 
 664     @Test public void prefWidthPropertyHasBeanReference() {
 665         assertSame(c, c.prefWidthProperty().getBean());
 666     }
 667 
 668     @Test public void prefWidthPropertyHasName() {
 669         assertEquals("prefWidth", c.prefWidthProperty().getName());
 670     }
 671 
 672     /****************************************************************************
 673      * prefHeight Tests                                                         *
 674      ***************************************************************************/
 675 
 676     @Test public void callsToSetPrefHeightResultInRequestLayoutBeingCalledOnParentNotOnControl() {
 677         // Setup and sanity check
 678         Group parent = new Group();
 679         parent.getChildren().add(c);
 680         parent.layout();
 681         assertTrue(!parent.isNeedsLayout());
 682         assertTrue(!c.isNeedsLayout());
 683         // Test
 684         c.setPrefHeight(92);
 685         assertTrue(parent.isNeedsLayout());
 686         assertTrue(!c.isNeedsLayout());
 687     }
 688 
 689     @Test public void getPrefHeightReturnsThePrefHeightOfTheSkinNode() {
 690         c.setSkin(s);
 691         assertEquals(PREF_HEIGHT, c.prefHeight(-1), 0.0);
 692     }
 693 
 694     @Test public void getPrefHeightReturnsTheCustomSetPrefHeightWhenSpecified() {
 695         c.setSkin(s);
 696         c.setPrefHeight(92);
 697         assertEquals(92, c.prefHeight(-1), 0.0);
 698     }
 699 
 700     @Test public void getPrefHeightReturnsTheCustomSetPrefHeightWhenSpecifiedEvenWhenThereIsNoSkin() {
 701         c.setPrefHeight(92);
 702         assertEquals(92, c.prefHeight(-1), 0.0);
 703     }
 704 
 705     @Test public void prefHeightWhenNoSkinIsSetIsZeroByDefault() {
 706         assertEquals(0, c.prefHeight(-1), 0.0);
 707     }
 708 
 709     @Ignore ("What should happen when the pref width is set to USE_PREF_SIZE? Seems it should be an exception")
 710     @Test public void resettingPrefHeightTo_USE_PREF_SIZE_ThrowsExceptionWhenThereIsASkin() {
 711         c.setSkin(s);
 712         c.setPrefHeight(92);
 713         c.setPrefHeight(Control.USE_PREF_SIZE);
 714         assertEquals(PREF_HEIGHT, c.prefHeight(-1), 0.0);
 715     }
 716 
 717     @Test public void resettingPrefHeightTo_USE_COMPUTED_SIZE_ReturnsThePrefHeightOfTheSkinNodeWhenThereIsASkin() {
 718         c.setSkin(s);
 719         c.setPrefHeight(92);
 720         c.setPrefHeight(Control.USE_COMPUTED_SIZE);
 721         assertEquals(PREF_HEIGHT, c.prefHeight(-1), 0.0);
 722     }
 723 
 724     @Test public void resettingPrefHeightTo_USE_COMPUTED_SIZE_ReturnsZeroWhenThereIsNoSkinAndPrefHeightIsNotSet() {
 725         c.setPrefHeight(92);
 726         c.setPrefHeight(Control.USE_COMPUTED_SIZE);
 727         assertEquals(0, c.prefHeight(-1), 0.0);
 728     }
 729 
 730     @Test public void prefHeightIs_USE_COMPUTED_SIZE_ByDefault() {
 731         assertEquals(Control.USE_COMPUTED_SIZE, c.getPrefHeight(), 0);
 732         assertEquals(Control.USE_COMPUTED_SIZE, c.prefHeightProperty().get(), 0);
 733     }
 734 
 735     @Test public void prefHeightCanBeSet() {
 736         c.setPrefHeight(98.76);
 737         assertEquals(98.76, c.getPrefHeight(), 0);
 738         assertEquals(98.76, c.prefHeightProperty().get(), 0);
 739     }
 740 
 741     @Test public void prefHeightCanBeBound() {
 742         DoubleProperty other = new SimpleDoubleProperty(939);
 743         c.prefHeightProperty().bind(other);
 744         assertEquals(939, c.getPrefHeight(), 0);
 745         other.set(332);
 746         assertEquals(332, c.getPrefHeight(), 0);
 747     }
 748 
 749     @Test public void prefHeightPropertyHasBeanReference() {
 750         assertSame(c, c.prefHeightProperty().getBean());
 751     }
 752 
 753     @Test public void prefHeightPropertyHasName() {
 754         assertEquals("prefHeight", c.prefHeightProperty().getName());
 755     }
 756 
 757     /*********************************************************************
 758      * Tests for the skin property                                       *
 759      ********************************************************************/
 760 
 761     @Test public void skinIsNullByDefault() {
 762         assertNull(c.getSkin());
 763         assertNull(c.contextMenuProperty().get());
 764     }
 765 
 766     @Test public void skinCanBeSet() {
 767         c.setSkin(s);
 768         assertSame(s, c.getSkin());
 769         assertSame(s, c.skinProperty().get());
 770     }
 771 
 772     @Test public void skinCanBeCleared() {
 773         c.setSkin(s);
 774         c.setSkin(null);
 775         assertNull(c.getSkin());
 776         assertNull(c.skinProperty().get());
 777     }
 778 
 779     @Test public void skinCanBeBound() {
 780         ObjectProperty other = new SimpleObjectProperty(s);
 781         c.skinProperty().bind(other);
 782         assertSame(s, c.getSkin());
 783         other.set(null);
 784         assertNull(c.getSkin());
 785     }
 786 
 787     @Test public void skinPropertyHasBeanReference() {
 788         assertSame(c, c.skinProperty().getBean());
 789     }
 790 
 791     @Test public void skinPropertyHasName() {
 792         assertEquals("skin", c.skinProperty().getName());
 793     }
 794 
 795     @Test public void canSpecifySkinViaCSS() {
 796         disableLogging();
 797         try {
 798             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "javafx.scene.control.SkinStub");
 799             assertNotNull(c.getSkin());
 800             assertTrue(c.getSkin() instanceof SkinStub);
 801             assertSame(c, c.getSkin().getSkinnable());
 802         } finally {
 803             enableLogging();
 804         }
 805     }
 806 
 807     @Test public void specifyingSameSkinTwiceViaCSSDoesntSetTwice() {
 808         disableLogging();
 809         try {
 810             SkinChangeListener listener = new SkinChangeListener();
 811             c.skinProperty().addListener(listener);
 812             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "javafx.scene.control.SkinStub");
 813             assertTrue(listener.changed);
 814             listener.changed = false;
 815             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "javafx.scene.control.SkinStub");
 816             assertFalse(listener.changed);
 817         } finally {
 818             enableLogging();
 819         }
 820     }
 821 
 822     @Test public void specifyingNullSkinNameHasNoEffect() {
 823         disableLogging();
 824         try {
 825             SkinChangeListener listener = new SkinChangeListener();
 826             c.skinProperty().addListener(listener);
 827             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, null);
 828             assertFalse(listener.changed);
 829             assertNull(c.getSkin());
 830         } finally {
 831             enableLogging();
 832         }
 833     }
 834 
 835     @Test public void specifyingEmptyStringSkinNameHasNoEffect() {
 836         disableLogging();
 837         try {
 838             SkinChangeListener listener = new SkinChangeListener();
 839             c.skinProperty().addListener(listener);
 840             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "");
 841             assertFalse(listener.changed);
 842             assertNull(c.getSkin());
 843         } finally {
 844             enableLogging();
 845         }
 846     }
 847 
 848     @Test public void loadingSkinWithNoAppropriateConstructorResultsInNoSkin() {
 849         disableLogging();
 850         try {
 851             SkinChangeListener listener = new SkinChangeListener();
 852             c.skinProperty().addListener(listener);
 853             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "javafx.scene.control.ControlTest$BadSkin");
 854             assertFalse(listener.changed);
 855             assertNull(c.getSkin());
 856         } finally {
 857             enableLogging();
 858         }
 859     }
 860 
 861     @Test public void exceptionThrownDuringSkinConstructionResultsInNoSkin() {
 862         disableLogging();
 863         try {
 864             SkinChangeListener listener = new SkinChangeListener();
 865             c.skinProperty().addListener(listener);
 866             ((StyleableProperty)c.skinClassNameProperty()).applyStyle(null, "javafx.scene.control.ControlTest$ExceptionalSkin");
 867             assertFalse(listener.changed);
 868             assertNull(c.getSkin());
 869         } finally {
 870             enableLogging();
 871         }
 872     }
 873 
 874     /*********************************************************************
 875      * Tests for the tooltip property                                    *
 876      ********************************************************************/
 877 
 878     @Test public void tooltipIsNullByDefault() {
 879         assertNull(c.getTooltip());
 880         assertNull(c.tooltipProperty().get());
 881     }
 882 
 883     @Test public void tooltipCanBeSet() {
 884         Tooltip tip = new Tooltip("Hello");
 885         c.setTooltip(tip);
 886         assertSame(tip, c.getTooltip());
 887         assertSame(tip, c.tooltipProperty().get());
 888     }
 889 
 890     @Test public void tooltipCanBeCleared() {
 891         Tooltip tip = new Tooltip("Hello");
 892         c.setTooltip(tip);
 893         c.setTooltip(null);
 894         assertNull(c.getTooltip());
 895         assertNull(c.tooltipProperty().get());
 896     }
 897 
 898     @Test public void tooltipCanBeBound() {
 899         Tooltip tip = new Tooltip("Hello");
 900         ObjectProperty<Tooltip> other = new SimpleObjectProperty<Tooltip>(tip);
 901         c.tooltipProperty().bind(other);
 902         assertSame(tip, c.getTooltip());
 903         assertSame(tip, c.tooltipProperty().get());
 904         other.set(null);
 905         assertNull(c.getTooltip());
 906         assertNull(c.tooltipProperty().get());
 907     }
 908 
 909     @Test public void tooltipPropertyHasBeanReference() {
 910         assertSame(c, c.tooltipProperty().getBean());
 911     }
 912 
 913     @Test public void tooltipPropertyHasName() {
 914         assertEquals("tooltip", c.tooltipProperty().getName());
 915     }
 916 
 917     /*********************************************************************
 918      * Tests for the contextMenu property                                    *
 919      ********************************************************************/
 920 
 921     @Test public void contextMenuIsNullByDefault() {
 922         assertNull(c.getContextMenu());
 923         assertNull(c.contextMenuProperty().get());
 924     }
 925 
 926     @Test public void contextMenuCanBeSet() {
 927         ContextMenu menu = new ContextMenu();
 928         c.setContextMenu(menu);
 929         assertSame(menu, c.getContextMenu());
 930         assertSame(menu, c.contextMenuProperty().get());
 931     }
 932 
 933     @Test public void contextMenuCanBeCleared() {
 934         ContextMenu menu = new ContextMenu();
 935         c.setContextMenu(menu);
 936         c.setContextMenu(null);
 937         assertNull(c.getContextMenu());
 938         assertNull(c.getContextMenu());
 939     }
 940 
 941     @Test public void contextMenuCanBeBound() {
 942         ContextMenu menu = new ContextMenu();
 943         ObjectProperty<ContextMenu> other = new SimpleObjectProperty<ContextMenu>(menu);
 944         c.contextMenuProperty().bind(other);
 945         assertSame(menu, c.getContextMenu());
 946         assertSame(menu, c.contextMenuProperty().get());
 947         other.set(null);
 948         assertNull(c.getContextMenu());
 949         assertNull(c.contextMenuProperty().get());
 950     }
 951 
 952     @Test public void contextMenuPropertyHasBeanReference() {
 953         assertSame(c, c.contextMenuProperty().getBean());
 954     }
 955 
 956     @Test public void contextMenuPropertyHasName() {
 957         assertEquals("contextMenu", c.contextMenuProperty().getName());
 958     }
 959 
 960     /*********************************************************************
 961      * Miscellaneous tests                                               *
 962      ********************************************************************/
 963 
 964     @Test public void setMinSizeUpdatesBothMinWidthAndMinHeight() {
 965         c.setMinSize(123.45, 98.6);
 966         assertEquals(123.45, c.getMinWidth(), 0);
 967         assertEquals(98.6, c.getMinHeight(), 0);
 968     }
 969 
 970     @Test public void setMaxSizeUpdatesBothMaxWidthAndMaxHeight() {
 971         c.setMaxSize(658.9, 373.4);
 972         assertEquals(658.9, c.getMaxWidth(), 0);
 973         assertEquals(373.4, c.getMaxHeight(), 0);
 974     }
 975 
 976     @Test public void setPrefSizeUpdatesBothPrefWidthAndPrefHeight() {
 977         c.setPrefSize(720, 540);
 978         assertEquals(720, c.getPrefWidth(), 0);
 979         assertEquals(540, c.getPrefHeight(), 0);
 980     }
 981 
 982     @Test public void baselineOffsetIsZeroWhenThereIsNoSkin() {
 983         assertEquals(0, c.getBaselineOffset(), 0f);
 984     }
 985 
 986     @Test public void baselineOffsetUpdatedWhenTheSkinChanges() {
 987         c.setSkin(s);
 988         assertEquals(BASELINE_OFFSET, c.getBaselineOffset(), 0);
 989     }
 990 
 991     @Test
 992     public void testRT18097() {
 993         try {
 994             File f = System.getProperties().containsKey("CSS_META_DATA_TEST_DIR") ?
 995                     new File(System.getProperties().get("CSS_META_DATA_TEST_DIR").toString()) :
 996                     null;
 997             if (f == null) {
 998                 ClassLoader cl = Thread.currentThread().getContextClassLoader();
 999                 URL base = cl.getResource("javafx/../javafx");
1000                 f = new File(base.toURI());
1001             }
1002             //System.err.println(f.getPath());
1003             assertTrue("" + f.getCanonicalPath() + " is not a directory", f.isDirectory());
1004             recursiveCheck(f, f.getPath().length() - 7);
1005         } catch (Exception ex) {
1006             ex.printStackTrace(System.err);
1007             fail(ex.getMessage());
1008         }
1009     }
1010 
1011     private static void checkClass(Class someClass) {
1012 
1013         // Ignore inner classes
1014         if (someClass.getEnclosingClass() != null) return;
1015 
1016         if (javafx.scene.control.Control.class.isAssignableFrom(someClass) &&
1017                 Modifier.isAbstract(someClass.getModifiers()) == false) {
1018             String what = someClass.getName();
1019             try {
1020                 // should get NoSuchMethodException if ctor is not public
1021 //                Constructor ctor = someClass.getConstructor((Class[])null);
1022                 Method m = someClass.getMethod("getClassCssMetaData", (Class[]) null);
1023 //                Node node = (Node)ctor.newInstance((Object[])null);
1024                 Node node = (Node)someClass.newInstance();
1025                 for (CssMetaData styleable : (List<CssMetaData<? extends Styleable, ?>>) m.invoke(null)) {
1026 
1027                     what = someClass.getName() + " " + styleable.getProperty();
1028                     WritableValue writable = styleable.getStyleableProperty(node);
1029                     assertNotNull(what, writable);
1030 
1031                     Object defaultValue = writable.getValue();
1032                     Object initialValue = styleable.getInitialValue((Node) someClass.newInstance());
1033 
1034                     if (defaultValue instanceof Number) {
1035                         // 5 and 5.0 are not the same according to equals,
1036                         // but they should be...
1037                         assert(initialValue instanceof Number);
1038                         double d1 = ((Number)defaultValue).doubleValue();
1039                         double d2 = ((Number)initialValue).doubleValue();
1040                         assertEquals(what, d1, d2, .001);
1041 
1042                     } else if (defaultValue != null && defaultValue.getClass().isArray()) {
1043                         assertTrue(what, Arrays.equals((Object[])defaultValue, (Object[])initialValue));
1044                     } else {
1045                         assertEquals(what, defaultValue, initialValue);
1046                     }
1047 
1048                 }
1049 
1050             } catch (NoSuchMethodException ex) {
1051                 fail("NoSuchMethodException: RT-18097 cannot be tested on " + what);
1052             } catch (IllegalAccessException ex) {
1053                 System.err.println("IllegalAccessException:  RT-18097 cannot be tested on " + what);
1054             } catch (IllegalArgumentException ex) {
1055                 fail("IllegalArgumentException:  RT-18097 cannot be tested on " + what);
1056             } catch (InvocationTargetException ex) {
1057                 fail("InvocationTargetException:  RT-18097 cannot be tested on " + what);
1058             } catch (InstantiationException ex) {
1059                 fail("InstantiationException:  RT-18097 cannot be tested on " + what);
1060             }
1061         }
1062     }
1063 
1064     private static void checkDirectory(File directory, final int pathLength) {
1065         if (directory.isDirectory()) {
1066 
1067             for (File file : directory.listFiles()) {
1068                 if (file.isFile() && file.getName().endsWith(".class")) {
1069                     final String filePath = file.getPath();
1070                     final int len = file.getPath().length() - ".class".length();
1071                     final String clName =
1072                         file.getPath().substring(pathLength+1, len).replace(File.separatorChar,'.');
1073                     if (clName.startsWith("javafx.scene") == false) continue;
1074                     try {
1075                         final Class cl = Class.forName(clName);
1076                         if (cl != null) checkClass(cl);
1077                     } catch(ClassNotFoundException ex) {
1078                         System.err.println(ex.toString() + " " + clName);
1079                     }
1080                 }
1081             }
1082         }
1083     }
1084 
1085     private static void recursiveCheck(File directory, int pathLength) {
1086         if (directory.isDirectory()) {
1087 //            System.out.println(directory.getPath());
1088             checkDirectory(directory, pathLength);
1089 
1090             for (File subFile : directory.listFiles()) {
1091                 recursiveCheck(subFile, pathLength);
1092             }
1093         }
1094     }
1095 
1096 
1097     // TODO need to test key event dispatch
1098 
1099 //    // test that the Control.Behavior methods correctly fix the coordinate
1100 //    // space values to match based on old node & new
1101 //    function testControlBehaviorCorrectlyMapsEventCoordinates() {
1102 //        var c = ControlStub { width: 20, height: 20, skin: SkinStub {} }
1103 //        var n = Rectangle { width: 100, height: 100 }
1104 //        var g:Group;
1105 //        // setting up a fairly complicated scene to see if the coordinate
1106 //        // values on the copied event are correct. This scene has two different
1107 //        // groups, and each group has a translate transform applied.
1108 //        // The node "n" where the event originated is in a different group
1109 //        // from the "c" node.
1110 //        //
1111 //        // in scene coords, n is 100x100 at 40, 52
1112 //        //                  c is 20x20 at 5, 30
1113 //        // in local coords n is 100x100 at 0, 0
1114 //        //                 c is 20x20 at 0, 0
1115 //        Scene {
1116 //            content: g = Group {
1117 //                // n is 100x100, child group is 40x10
1118 //                translateX: 40
1119 //                translateY: 52
1120 //                content: [
1121 //                    n,
1122 //                    Group {
1123 //                        // the content is 20x20. Scale makes it 40x10
1124 //                        translateX: -35
1125 //                        translateY: -22
1126 //                        content: c // this is 20x20
1127 //                    }
1128 //                ]
1129 //            }
1130 //        }
1131 //
1132 //        // BEGIN SANITY CHECK
1133 //        // start off with a couple sanity checks to make sure I have my math
1134 //        // right such that if the real portion of this test fails, I know it
1135 //        // is not due to a faulty test
1136 //
1137 //        // test local coords of n
1138 //        assertEquals(0, n.boundsInLocal.minX);
1139 //        assertEquals(0, n.boundsInLocal.minY);
1140 //        assertEquals(100, n.boundsInLocal.width);
1141 //        assertEquals(100, n.boundsInLocal.height);
1142 //
1143 //        // test local coords of c
1144 //        assertEquals(0, c.boundsInLocal.minX);
1145 //        assertEquals(0, c.boundsInLocal.minY);
1146 //        assertEquals(20, c.boundsInLocal.width);
1147 //        assertEquals(20, c.boundsInLocal.height);
1148 //
1149 //        // test scene coords of n
1150 //        assertEquals(40, n.localToScene(n.boundsInLocal).minX);
1151 //        assertEquals(52, n.localToScene(n.boundsInLocal).minY);
1152 //        assertEquals(100, n.localToScene(n.boundsInLocal).width);
1153 //        assertEquals(100, n.localToScene(n.boundsInLocal).height);
1154 //
1155 //        // test scene coords of c
1156 //        assertEquals(5, c.localToScene(c.boundsInLocal).minX);
1157 //        assertEquals(30, c.localToScene(c.boundsInLocal).minY);
1158 //        assertEquals(20, c.localToScene(c.boundsInLocal).width);
1159 //        assertEquals(20, c.localToScene(c.boundsInLocal).height);
1160 //        // END SANITY CHECK
1161 //
1162 //        // create a simple mouse event on node. The x/y are 0,0, thus in the
1163 //        // top left corner of the fill area of the rectangle.
1164 //        c.onMousePressed = function(evt:MouseEvent):Void {
1165 //            // this mouse event should have been translated from "g" space
1166 //            // to "c" space. Relative to "g", "c" is 40x10 at -35, -22
1167 //            //  so (0,0) in c space relative to n would be at 35, 22
1168 //            assertEquals(35.0, evt.x);
1169 //            assertEquals(22.0, evt.y);
1170 //        }
1171 //        // invoke the code path that leads to calling the previously defined
1172 //        // onMousePressed function handler
1173 //        mousePress(g, 0, 0);
1174 //    }
1175 
1176     /**
1177      * Used for representing the "node" of the Skin, such that each of the fields
1178      * minWidth, minHeight, maxWidth, maxHeight, prefWidth, and prefHeight have
1179      * different values, and thus can more easily detect bugs if the various
1180      * test methods fail (if they all had the same value, it would potentially
1181      * mask bugs where maxWidth was called instead of minWidth, and so forth).
1182      */
1183     public class ResizableRectangle extends Rectangle {
1184         private double minWidth;
1185         private double maxWidth;
1186         private double minHeight;
1187         private double maxHeight;
1188         private double prefWidth;
1189         private double prefHeight;
1190         private double baselineOffset;
1191 
1192         @Override public boolean isResizable() { return true; }
1193         @Override public double minWidth(double h) { return minWidth; }
1194         @Override public double minHeight(double w) { return minHeight; }
1195         @Override public double prefWidth(double height) { return prefWidth; }
1196         @Override public double prefHeight(double width) { return prefHeight; }
1197         @Override public double maxWidth(double h) { return maxWidth; }
1198         @Override public double maxHeight(double w) { return maxHeight; }
1199         @Override public double getBaselineOffset() { return baselineOffset; }
1200 
1201         @Override public void resize(double width, double height) {
1202             setWidth(width);
1203             setHeight(height);
1204         }
1205     }
1206 
1207     /**
1208      * This is a Skin without an appropriate constructor, and will fail
1209      * to load!
1210      * @param <C>
1211      */
1212     public static final class BadSkin<C extends Control> extends SkinStub<C> {
1213         public BadSkin() {
1214             super(null);
1215         }
1216     }
1217 
1218     /**
1219      * This is a Skin without an appropriate constructor, and will fail
1220      * to load!
1221      * @param <C>
1222      */
1223     public static final class ExceptionalSkin<C extends Control> extends SkinStub<C> {
1224         public ExceptionalSkin(C control) {
1225             super(control);
1226             throw new NullPointerException("I am EXCEPTIONAL!");
1227         }
1228     }
1229 
1230     public class SkinChangeListener implements ChangeListener<Skin> {
1231         boolean changed = false;
1232         @Override public void changed(ObservableValue<? extends Skin> observable, Skin oldValue, Skin newValue) {
1233             changed = true;
1234         }
1235     }
1236 }