--- /dev/null	2017-02-06 10:30:55.634050603 +0300
+++ new/functional/FxmlTests/src/test/fxmltests/app/staticPropertyLoadApp.java.excluded	2017-02-10 15:02:05.553501982 +0300
@@ -0,0 +1,2781 @@
+// https://bugs.openjdk.java.net/browse/INTJDK-7624138
+/*
+ * Copyright (c) 2014, Oracle and/or its affiliates. All rights reserved.
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * This code is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License version 2 only, as
+ * published by the Free Software Foundation. Oracle designates this
+ * particular file as subject to the "Classpath" exception as provided
+ * by Oracle in the LICENSE file that accompanied this code.
+ *
+ * This code is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ * version 2 for more details (a copy is included in the LICENSE file that
+ * accompanied this code).
+ *
+ * You should have received a copy of the GNU General Public License version
+ * 2 along with this work; if not, write to the Free Software Foundation,
+ * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
+ * or visit www.oracle.com if you need additional information or have any
+ * questions.
+ */
+package test.fxmltests.app;
+
+import javafx.fxml.LoadListener;
+import com.sun.javafx.fxml.ParseTraceElement;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URL;
+import java.nio.charset.Charset;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Locale;
+import java.util.ResourceBundle;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.css.CssMetaData;
+import javafx.css.Styleable;
+import javafx.event.ActionEvent;
+import javafx.event.EventHandler;
+import javafx.fxml.FXMLLoader;
+import javafx.fxml.JavaFXBuilderFactory;
+import javafx.fxml.LoadException;
+import javafx.scene.Group;
+
+
+import javafx.scene.Node;
+import javafx.scene.Scene;
+import javafx.scene.control.Button;
+import javafx.scene.control.Label;
+import javafx.scene.control.Labeled;
+import javafx.scene.control.ListView;
+import javafx.scene.control.Menu;
+import javafx.scene.control.MenuBar;
+import javafx.scene.control.MenuItem;
+import javafx.scene.control.RadioButton;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.ToggleGroup;
+import javafx.scene.control.cell.PropertyValueFactory;
+import javafx.scene.input.KeyCombination;
+import javafx.scene.layout.*;
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Rectangle;
+import javafx.scene.text.Font;
+import javafx.scene.text.Text;
+import javafx.util.Callback;
+import javafx.util.Pair;
+
+import test.javaclient.shared.BasicButtonChooserApp;
+import test.javaclient.shared.PageWithSlots;
+import test.javaclient.shared.TestNode;
+import test.javaclient.shared.Utils;
+
+public class staticPropertyLoadApp extends BasicButtonChooserApp {
+
+    public static final String RESOURCE_BASE = "/test/fxmltests/resources/";
+    public static final String staticPropertyResourcePath = RESOURCE_BASE + "static-property.fxml";
+    public static final String hashmapResourcePath = RESOURCE_BASE + "hashmap.fxml";
+    public static final String customClassLoadResourcePath = RESOURCE_BASE + "include.fxml";
+    public static final String factoryResourcePath = RESOURCE_BASE + "factory.fxml";
+    public static final String builderResourcePath = RESOURCE_BASE + "builder.fxml";
+    public static final String propertyElementsResourcePath = RESOURCE_BASE + "propertyElements.fxml";
+    public static final String referenceResourcePath = RESOURCE_BASE + "reference.fxml";
+    public static final String copyResourcePath = RESOURCE_BASE + "fxcopy.fxml";
+    public static final String propertySetterResourcePath = RESOURCE_BASE + "propertySetter.fxml";
+    public static final String roListResourcePath = RESOURCE_BASE + "rolist.fxml";
+    public static final String roMapResourcePath = RESOURCE_BASE + "romap.fxml";
+    public static final String defaultPropertyResourcePath = RESOURCE_BASE + "defaultProperty.fxml";
+    public static final String fxdefineResourcePath = RESOURCE_BASE + "fxdefine.fxml";
+    public static final String fxdefine2ResourcePath = RESOURCE_BASE + "fxdefine2.fxml";
+    public static final String namespaceBindingResourcePath = RESOURCE_BASE + "namespaceBinding.fxml";
+    public static final String staticPropertiesResourcePath = RESOURCE_BASE + "static-properties.fxml";
+    public static final String rootMethodEventHandlerResourcePath = RESOURCE_BASE + "rootMethodEventHandler.fxml";
+    public static final String scriptEventHandlerResourcePath = RESOURCE_BASE + "scriptEventHandler.fxml";
+    public static final String scriptResourcePath = RESOURCE_BASE + "script.fxml";
+    public static final String menuitemResourcePath = RESOURCE_BASE + "menuitem.fxml";
+    public static final String resourceResourcePath = RESOURCE_BASE + "resourcefxml.fxml";
+    public static final String splitpanebugResourcePath = RESOURCE_BASE + "vt1.fxml";
+    public static final String throw1ResourcePath = RESOURCE_BASE + "throw1.fxml";
+    public static final String throw2ResourcePath = RESOURCE_BASE + "throw2.fxml";
+    public static final String rt19133ResourcePath = RESOURCE_BASE + "rt19133.fxml";
+
+    public static enum Pages {
+        staticProperty,HashMap,customClassAndInclude,factory,simple,
+        propertyElements,reference,copy,prSetter,roList,roMap,
+        defaultProperty,fxdefine,namespaceBinding,staticProperties,rootMethodEventHandler,
+        scriptEventHandler,script,menuItem,resources1,resources2,namespace,
+        splitpanebug,charset, loadExceptions,
+        slotDefaultLabeled, slotDefaultListview, slotDefaultMenu, slotDefaultMenuBar,
+        slotDefaultScrollpane, slotDefaultTabpane, slotDefaultTableView,
+        slotDefaultTextinput,  slotDefaultTitledpane, slotDefaultTreeview,
+        slotDefaultImageview, slotDefaultPane, slotControllerFactory,
+        specificSignatureMethod, loadfontSlot, scenebuilderSlot,
+        scenebuilderNoRoot, references2, apConstraints, coerce, listviewItems, listenerNullArg,
+        gridapplet, csspath, errorFXML, colorValueOF, escapeCharacter, collectionEventsHandlers,
+        noArgControllerMethod, overloadedControllerMethod, customIDProperty, unknownCustomType,
+        baseControllerProperty, relativeStylesheet, FXMLLoaderAPI, fullyQualifiedNames, importPI,
+    beanInstantiation, valueOf, root, fxId, fxController, noDefaultController, lateRoot,
+    lateController, variableResolution, externalScript
+
+    }
+
+    public staticPropertyLoadApp() {
+        super(800, 600, "LoadFXML", false);
+    }
+
+    Rectangle retRec = new Rectangle(10,10){{setFill(Color.GREEN);}};
+    Rectangle redRectangle = new Rectangle(10,10){{setFill(Color.RED);}};
+
+    abstract private class TestNodeWithIOExceptionProcessing extends TestNode {
+
+        abstract protected Node impl_drawNode() throws IOException;
+        protected String impl_getPathToResource() { return null; };
+        protected URL resource = null;
+        protected File f = null;
+
+        @Override
+        public Node drawNode() {
+            Node result = redRectangle;
+
+            VBox vb = null;
+
+            if (null != impl_getPathToResource()) {
+                resource = getClass().getResource(impl_getPathToResource());
+                if (null != resource && null != (f = new File(resource.getFile()))) {
+                    System.out.println("loading " + f.getPath());
+                } else {
+                    String tmpMsg = "resource file error. [" + impl_getPathToResource() + "]";
+                    System.out.println(tmpMsg);
+                    reportGetterFailure(tmpMsg);
+                    return result;
+                }
+            }
+            try {
+                result = impl_drawNode();
+            } catch (IOException ex) {
+                reportGetterFailure("TestNodeWithIOExceptionProcessing: IOException");
+                Logger.getLogger(staticPropertyLoadApp.class.getName()).log(Level.SEVERE, null, ex);
+            } catch (Exception ex) {
+                reportGetterFailure("TestNodeWithIOExceptionProcessing: Exception");
+                Logger.getLogger(staticPropertyLoadApp.class.getName()).log(Level.SEVERE, null, ex);
+            }
+            return result;
+        }
+    }
+
+    private class slotStaticProperty extends TestNodeWithIOExceptionProcessing {
+        @Override
+        protected String impl_getPathToResource() {
+            return staticPropertyResourcePath;
+        }
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    private class hashmaptest extends TestNodeWithIOExceptionProcessing {
+
+        HashMap hm = null;
+        String value1;
+        String value2;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return hashmapResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+
+            try {
+                hm = FXMLLoader.load(resource);
+                value1 = (String) hm.get("foo");
+                value2 = (String) hm.get("bar");
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (value1.equals("123") && value2.equals("456")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    CustomClass cc;
+    private class customClassLoadSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return customClassLoadResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            FXMLLoader fxmlLoader = new FXMLLoader();
+
+            InputStream is = null;
+            try {
+                fxmlLoader.setLocation(resource);
+                is = resource.openStream();
+                cc = (CustomClass) fxmlLoader.load(is);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+//            System.out.println("   includes: " + fxmlLoader.getIncludes());
+            System.out.println("cc.getFld(): " + cc.getFld());
+
+            if (cc.getFld().equals("fine!")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class factorySlot extends TestNodeWithIOExceptionProcessing {
+
+        ObservableList<String> ss = FXCollections.observableArrayList();
+
+        @Override
+        protected String impl_getPathToResource() {
+            return factoryResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            try {
+                ss = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (ss.get(0).equals("A") && ss.get(1).equals("B") && ss.get(2).equals("C")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class simpleSlot extends TestNodeWithIOExceptionProcessing {
+
+        Color color = Color.ALICEBLUE;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return builderResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                ClassLoader defaultClassLoader = fxmlLoader2.getClassLoader();
+
+                fxmlLoader2.setBuilderFactory(new JavaFXBuilderFactory(defaultClassLoader));
+                color = (Color) fxmlLoader2.load(is); // see RT-18091
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            System.out.println("color: " + color);
+            if (color.equals(Color.color(1., 0., 0.))) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class propertyElementsSlot extends TestNodeWithIOExceptionProcessing {
+
+        Label label;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return propertyElementsResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                label = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (label.getText().equals("label")) {
+                return label;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class referenceSlot extends TestNodeWithIOExceptionProcessing {
+
+        List<Label> lst = new ArrayList();
+
+        @Override
+        protected String impl_getPathToResource() {
+            return referenceResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                lst = FXMLLoader.load(resource); // was: f.toURI().toURL(). does not work with jnlp http://javafx-jira.kenai.com/browse/RT-17736
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (lst.get(0).getText().equals(lst.get(1).getText())) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class copySlot extends TestNodeWithIOExceptionProcessing {
+
+        List<Label> lst = new ArrayList();
+
+        @Override
+        protected String impl_getPathToResource() {
+            return copyResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                lst = (List<Label>) FXMLLoader.load(resource);  //inputStream
+            } catch (Exception e) {
+                System.out.println("message2: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+            if (3 == lst.size()) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class propertySetterSlot extends TestNodeWithIOExceptionProcessing {
+
+        Label label;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return propertySetterResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                label = FXMLLoader.load(resource);
+
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (label.getText().equals("txt")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class roListSlot extends TestNodeWithIOExceptionProcessing {
+
+        Group gr;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return roListResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                gr = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+            Node n =((Rectangle) gr.getChildren().get(0));
+            String strId = n.getId();
+            if (strId.equals("rectangle1")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class roMapSlot extends TestNodeWithIOExceptionProcessing {
+
+        JavaFXBuilderFactory builderFactory = new JavaFXBuilderFactory();
+        FXMLLoader fxmlLoader = new FXMLLoader();
+        Button btn;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return roMapResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            InputStream is = getClass().getResourceAsStream(impl_getPathToResource());
+
+            try {
+                fxmlLoader.setBuilderFactory(builderFactory);
+                btn = (Button) fxmlLoader.load(is);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (builderFactory != fxmlLoader.getBuilderFactory()) {
+                reportGetterFailure("fxmlLoader.getBuilderFactory() failed.");
+            }
+
+            if (btn.getProperties().get("foo").equals("123")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class defaultPropertySlot extends TestNodeWithIOExceptionProcessing {
+
+        Group gr;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                gr = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (((Rectangle) gr.getChildren().get(1)).getId().equals("rectangle2")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class fxdefineSlot extends TestNodeWithIOExceptionProcessing {
+
+        VBox vb;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return fxdefineResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                vb = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            if (((RadioButton) vb.getChildren().get(0)).getText().equals("A")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class namespaceBindingSlot extends TestNodeWithIOExceptionProcessing {
+
+        public VBox vb;
+        FXMLLoader fxmlLoader2 = new FXMLLoader();
+
+        @Override
+        protected String impl_getPathToResource() {
+            return namespaceBindingResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                is = resource.openStream();
+                vb = (VBox) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            if (null == vb) {
+                System.out.println("Custom class instance is null");
+                reportGetterFailure("failed 1.");
+            }
+
+            Button b = (Button) vb.getChildren().get(0);
+
+            if (null == vb.getChildren().get(0)) {
+                System.out.println("button field  is null");
+                reportGetterFailure("failed 2.");
+            }
+            if (!(null != vb && null != b && null != b.getOnAction())) {
+                reportGetterFailure("failed.");
+            }
+
+            MyRootElement mr = (MyRootElement) fxmlLoader2.getController();
+            System.out.println("mr: " + mr.toString());
+            System.out.println("getController(): " + fxmlLoader2.getController());
+
+            if ((null != mr)
+                    && (mr.toString().contains("MyRootElement"))) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class staticPropertiesSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return staticPropertiesResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+
+            try {
+                FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+                return redRectangle;
+            }
+
+            return retRec;
+        }
+    }
+
+    private class rootMethodEventHandlerSlot extends TestNodeWithIOExceptionProcessing {
+
+        MyRootElement2 mr;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return rootMethodEventHandlerResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                mr = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+
+            Button bbb = (Button) mr.getChildren().get(0);
+            EventHandler<ActionEvent> hndlr = bbb.getOnAction();
+            if (null != hndlr) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class scriptEventHandlerSlot extends TestNodeWithIOExceptionProcessing {
+
+        MyRootElement2 mr;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return scriptEventHandlerResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+
+            try {
+                mr = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            Button bbb = (Button) mr.getChildren().get(0);
+            EventHandler<ActionEvent> hndlr = bbb.getOnAction();
+            if (null != hndlr) {
+                return mr;//retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class scriptSlot extends TestNodeWithIOExceptionProcessing {
+
+        VBox vb;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return scriptResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+
+            try {
+                vb = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+            Button bbb = (Button) vb.getChildren().get(0);
+            EventHandler<ActionEvent> hndlr = bbb.getOnAction();
+            if (null != hndlr) {
+                return vb;//retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+    private class menuitemSlot extends TestNodeWithIOExceptionProcessing {
+        //http://javafx-jira.kenai.com/browse/RT-17715
+
+        MenuItem mi2;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return menuitemResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            /*
+            MenuItem mi = new MenuItem();
+            mi.setText("open...");
+            mi.setGraphic(new ImageView());
+            mi.setAccelerator(KeyCombination.keyCombination("CTRL+N"));
+             */
+
+            try {
+                mi2 = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+            System.out.println("DEBUG: menuItem.getText()=" + ((null != mi2) ? mi2.getText() : "(null)"));
+            if ((null != mi2)
+                    && (0 == "open...".compareTo(mi2.getText()))
+                    && (KeyCombination.keyCombination("CTRL+N").equals(mi2.getAccelerator()))) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+        }
+    }
+
+
+/*
+ * localization using setResources()
+ */
+    private class resource1Slot extends TestNodeWithIOExceptionProcessing {
+
+        MenuItem mi2;
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                URL resourceURL = getClass().getResource(resourceResourcePath);
+                Locale currentLocale = new Locale("en", "US");
+                ResourceBundle resourceBundle = ResourceBundle.getBundle("test.fxmltests.resources.resource1", currentLocale);
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+
+                fxmlLoader2.setResources(resourceBundle);
+                System.out.println("resources: " + fxmlLoader2.getResources());
+                fxmlLoader2.setBuilderFactory(new JavaFXBuilderFactory());
+
+                System.out.println("xxx loading " + resourceURL);
+                InputStream is = null;
+                try {
+
+                    is = resourceURL.openStream();
+                    mi2 = (MenuItem) fxmlLoader2.load(is);
+
+                } catch (Exception e) {
+                    System.out.println("message: " + e.getMessage());
+                    e.printStackTrace();
+                    reportGetterFailure("exception thrown.");
+                } finally {
+                    is.close();
+                }
+
+                System.out.println("resources: " + fxmlLoader2.getResources());
+                System.out.println("charset: " + fxmlLoader2.getCharset());
+                System.out.println("location: " + fxmlLoader2.getLocation());
+                System.out.println("bf: " + fxmlLoader2.getBuilderFactory());
+                System.out.println("namespace: " + fxmlLoader2.getNamespace());
+//                System.out.println("includes: " + fxmlLoader2.getIncludes());
+
+
+                System.out.println("DEBUG: menuItem.getText()=" + ((null != mi2) ? mi2.getText() : "(null)"));
+                if ((null != mi2)
+                        && (0 == "close".compareTo(mi2.getText()))) {
+                    boolean pass = true;
+                } else {
+                    reportGetterFailure("failed.");
+                }
+            } catch (IOException ex) {
+                Logger.getLogger(staticPropertyLoadApp.class.getName()).log(Level.SEVERE, null, ex);
+            }
+            return retRec;
+        }
+    }
+
+
+/*
+ * localization wirh resources mentioned in load()
+ */
+    private class resource2Slot extends TestNodeWithIOExceptionProcessing {
+
+        MenuItem mi2;
+
+        @Override
+        public Node impl_drawNode() {
+            URL resourceURL = getClass().getResource(resourceResourcePath);
+            Locale currentLocale = new Locale("en", "US");
+            ResourceBundle resourceBundle = ResourceBundle.getBundle("test.fxmltests.resources.resource1", currentLocale);
+
+            System.out.println("xxx loading " + resourceURL);
+            try {
+
+                mi2 = (MenuItem) FXMLLoader.load(resourceURL, resourceBundle);
+
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+
+            System.out.println("DEBUG: menuItem.getText()=" + ((null != mi2) ? mi2.getText() : "(null)"));
+            if ((null != mi2)
+                    && (0 == "close".compareTo(mi2.getText()))) {
+                boolean pass = true;
+            } else {
+                reportGetterFailure("failed.");
+            }
+            return retRec;
+        }
+    }
+
+/*
+ * getNamespace test
+ */
+    private class namespaceSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            URL resourceURL = getClass().getResource(fxdefine2ResourcePath);
+            JavaFXBuilderFactory builderFactory = new JavaFXBuilderFactory();
+            FXMLLoader fxmlLoader = new FXMLLoader();
+            fxmlLoader.setBuilderFactory(builderFactory);
+
+            InputStream is = null;
+            System.out.println("xxx loading " + resourceURL);
+            try {
+                is = resourceURL.openStream();
+                fxmlLoader.load(is);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+            System.out.println("namespace: " + fxmlLoader.getNamespace());
+            System.out.println("empty: " + fxmlLoader.getNamespace().isEmpty());
+            System.out.println("nonexisting key vb5: " + fxmlLoader.getNamespace().get("vb5"));
+
+            Node n = (Node)fxmlLoader.getNamespace().get("vb1");
+            String xxx = (null != n)?(n.getId()):"";
+            System.out.println("existing key vb1: " + fxmlLoader.getNamespace().get("vb1") + " / id=" + xxx);
+            System.out.println("getRoot: " + fxmlLoader.getRoot());
+
+            if ((null != (fxmlLoader.getNamespace().get("vb1")))
+                    && (null == (fxmlLoader.getNamespace().get("vb5")))
+                    && (fxmlLoader.getRoot().toString().equals("VBox[id=vb1]"))) {
+                boolean pass = true;
+            } else {
+                reportGetterFailure("failed.");
+            }
+            return retRec;
+        }
+    }
+
+
+    private class splitpanebugSlot extends TestNodeWithIOExceptionProcessing {
+        // http://javafx-jira.kenai.com/browse/RT-16977
+        @Override
+        public Node impl_drawNode() throws IOException {
+            URL resourceURL = getClass().getResource(splitpanebugResourcePath);
+            JavaFXBuilderFactory builderFactory = new JavaFXBuilderFactory();
+            FXMLLoader fxmlLoader = new FXMLLoader();
+            fxmlLoader.setBuilderFactory(builderFactory);
+
+            InputStream is = null;
+            System.out.println("loading " + resourceURL);
+            try {
+                //  fxmlLoader.setLocation(new URL(RESOURCE_BASE));
+                //  ResourceBundle rb = new ResourceBundle();
+                //   fxmlLoader.setResources(rb);
+                is = resourceURL.openStream();
+                fxmlLoader.load(is);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } catch (Throwable e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            System.out.println("loaded. ");
+            return retRec;
+        }
+    }
+
+    private class charsetSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return "/test/fxmltests/resources/include3.fxml"; // customClassLoadResourcePath
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Charset encoding = Charset.forName("UTF-16");
+            FXMLLoader fxmlLoader = new FXMLLoader(encoding);
+            fxmlLoader.setBuilderFactory(new JavaFXBuilderFactory());
+
+            //Locale currentLocale = new Locale("en", "US");
+            //ResourceBundle resourceBundle = ResourceBundle.getBundle("test.fxmltests.resources.resource1", currentLocale);
+            //fxmlLoader.setResources(resourceBundle);
+
+            InputStream is = null;
+            try {
+                // fxmlLoader.setLocation(resource);
+                System.out.println("   charset: " + fxmlLoader.getCharset());
+                is = resource.openStream();
+                fxmlLoader.load(is);
+
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+            System.out.println("   location: " + fxmlLoader.getLocation());
+            System.out.println("   charset: " + fxmlLoader.getCharset());
+
+            if (fxmlLoader.getCharset().toString().equals("UTF-16")) {
+                return retRec;
+            } else {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            }
+
+        }
+    }
+
+    /*
+     * LoadExceptions test
+     */
+    private class loadExceptionsSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        public Node impl_drawNode() throws IOException{
+
+            URL resourceURL1 = getClass().getResource(throw1ResourcePath);
+            URL resourceURL2 = getClass().getResource(throw2ResourcePath);
+            FXMLLoader fxmlLoader = new FXMLLoader();
+            fxmlLoader.setBuilderFactory(new JavaFXBuilderFactory());
+            boolean exception1Thrown = false;
+            boolean exception2Thrown = false;
+
+            InputStream is = null;
+            System.out.println("loading RES 1 / " + resourceURL1);
+            try {
+                is = resourceURL1.openStream();
+                fxmlLoader.load(is);
+            } catch (LoadException e) {
+                System.out.println("THROWN   msg: " + e.getMessage());
+                System.out.println("THROWN cause: " + e.getCause());
+                exception1Thrown = true;
+
+                ParseTraceElement ptes[] = fxmlLoader.impl_getParseTrace();
+                for (ParseTraceElement pte: ptes) {
+                    // see rt-19329
+                    System.out.println("trace element: " + pte);
+                }
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+            is = null;
+            System.out.println("loading RES 2 / " + resourceURL2);
+            try {
+                is = resourceURL2.openStream();
+                fxmlLoader.load(is);
+            } catch (LoadException e) {
+                exception2Thrown = true;
+                System.out.println("2 THROWN   msg: " + e.getMessage());
+                System.out.println("2 THROWN cause: " + e.getCause());
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+
+            if ((true == exception1Thrown) && (true == exception2Thrown)) {
+                boolean pass = true;
+            } else {
+                reportGetterFailure("failed.");
+            }
+            return retRec;
+        }
+    }
+
+
+
+/*
+ *
+Class javafx/fxml/FXMLLoader
+ *
++ getBuilderFactory()Ljavafx/util/BuilderFactory;     -     -     -     -     -     -     -     -     -     -     -     -
++ getCharset()Ljava/nio/charset/Charset;     -     -     -     -     -     -     -     -     -     -     -     -
++ getController()Ljava/lang/Object;     -     -     -     -     -     -     -     -     -     -     -     -
++ getIncludes()Ljava/util/List;     -     -     -     -     -     -     -     -     -     -     -     -
+getLoadListener()Lcom/sun/javafx/fxml/LoadListener;     -     -     -     -     -     -     -     -     -     -     -     -
++ getLocation()Ljava/net/URL;     -     -     -     -     -     -     -     -     -     -     -     -
++ getNamespace()Ljavafx/collections/ObservableMap;     -     -     -     -     -     -     -     -     -     -     -     -
++ getResources()Ljava/util/ResourceBundle;     -     -     -     -     -     -     -     -     -     -     -     -
++ getRoot()Ljava/lang/Object;     -     -     -     -     -     -     -     -     -     -     -     -
+isStaticLoad()Z
+ */
+ //   Button b;
+
+    public static final String defaultPropertyLabeledResourcePath = RESOURCE_BASE + "rt14879-labeled.fxml";
+
+    private class slotDefaultLabeled extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyLabeledResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyListViewResourcePath = RESOURCE_BASE + "rt14879-listview.fxml";
+
+    private class slotDefaultListview extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyListViewResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            /* DEBUG.   let it be here for a while
+            ListView lv = new ListView();
+            String st = "str";
+            lv.getItems().add(st);
+            lv.getItems().add(st);
+            lv.getItems().add(st);
+             *
+             */
+
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyMenuResourcePath = RESOURCE_BASE + "rt14879-menu.fxml";
+
+    private class slotDefaultMenu extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyMenuResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Menu uplevelNode = null;
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            try {
+                    uplevelNode = (Menu)fxmlLoader.load();
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+                ParseTraceElement ptes[] = fxmlLoader.impl_getParseTrace();
+                for (ParseTraceElement pte: ptes) {
+                    // see rt-19329
+                    System.out.println("trace element: " + pte);
+                }
+
+            }
+            MenuBar mb = new MenuBar();
+            mb.getMenus().add(uplevelNode);
+            // debug: uplevelNode.getItems().add(new MenuItem("open!!"));
+            return mb;
+        }
+    }
+
+    public static final String defaultPropertyMenuBarResourcePath = RESOURCE_BASE + "rt14879-menubar.fxml";
+
+    private class slotDefaultMenuBar extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyMenuBarResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyScrollpaneResourcePath = RESOURCE_BASE + "rt14879-scrollpane.fxml";
+
+    private class slotDefaultScrollpane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyScrollpaneResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyTabpaneResourcePath = RESOURCE_BASE + "rt14879-tabpane.fxml";
+
+    private class slotDefaultTabpane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyTabpaneResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyTableViewResourcePath = RESOURCE_BASE + "rt14879-tableview.fxml";
+
+    private class slotDefaultTableview extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyTableViewResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            TableView<Text> table = new TableView<Text>();
+
+            try {
+                table =
+                        FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            TableColumn<Text, String> firstNameCol = new TableColumn<Text, String>("First Name");
+            firstNameCol.setCellValueFactory(new PropertyValueFactory("text"));
+            table.getColumns().setAll(firstNameCol);
+
+            Object o = table.getItems().get(0);
+            System.out.println("item0 type: " + o.getClass().getName());
+            System.out.println("item0 text: " + table.getItems().get(0).getText());
+
+            return table;
+        }
+    }
+
+    public static final String defaultPropertyTextinputResourcePath = RESOURCE_BASE + "rt14879-textinput.fxml";
+
+    private class slotDefaultTextinput extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyTextinputResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyTitledpaneResourcePath = RESOURCE_BASE + "rt14879-titledpane.fxml";
+
+    private class slotDefaultTitledpane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyTitledpaneResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyTreeviewResourcePath = RESOURCE_BASE + "rt14879-treeview.fxml";
+
+    private class slotDefaultTreeview extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyTreeviewResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            //Font f = null;
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyImageviewResourcePath = RESOURCE_BASE + "rt14879-imageview.fxml";
+
+    private class slotDefaultImageview extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyImageviewResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String defaultPropertyPaneResourcePath = RESOURCE_BASE + "rt14879-pane.fxml";
+
+    private class slotDefaultPane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return defaultPropertyPaneResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Node uplevelNode = null;
+            try {
+                uplevelNode = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return uplevelNode;
+        }
+    }
+
+    public static final String controllerFactoryPath = RESOURCE_BASE + "rt_16724.fxml";
+
+    private class controllerFactoryPane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return controllerFactoryPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            LoadableEntity uplevelNode = null;
+            boolean cntrlrFctryInvoked = false;
+            boolean cntrlrInvoked = false;
+            FXMLLoader fxmlLoader2 = new FXMLLoader();
+            Callback cfViaGetter = null;
+
+            RT_16724ControllerFactory cf = new RT_16724ControllerFactory();
+            try {
+
+                uplevelNode =
+                    FXMLLoader.load(resource, null, null,  cf);
+
+                cntrlrFctryInvoked = cf.isInvoked();
+                RT_16724Controller cntrlr = cf.getCntrlr();
+                cntrlrInvoked = cntrlr.isInvoked();
+
+                fxmlLoader2.setControllerFactory(cf);
+                cfViaGetter = fxmlLoader2.getControllerFactory();
+
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            System.out.println("name: " + uplevelNode.getName());
+
+            if ( cf != cfViaGetter ){
+                reportGetterFailure("cf via getter failed");
+            }
+
+            if ( 0 != "nameLoadedViaDefaultProperty".compareTo(uplevelNode.getName())) {
+                reportGetterFailure("load using defaultProperty in custom class failed");
+            }
+            if ( false == cntrlrFctryInvoked || false == cntrlrInvoked ) {
+                reportGetterFailure("failed.");
+                return redRectangle;
+            } else {
+                return retRec;
+            }
+
+        }
+    }
+
+
+    public static final String specificSignatureMethodPath = RESOURCE_BASE + "rt_18229.fxml";
+
+    private class specificSignatureMethodPane extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return specificSignatureMethodPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            try {
+                    fxmlLoader.load();
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+        RT_18229Controller controller = (RT_18229Controller)fxmlLoader.getController();
+        if ( 0 != "abc".compareTo(controller.getRootName1())) {
+            reportGetterFailure("compare 1");
+        }
+        if ( 0 != "def".compareTo(controller.getRootName2())) {
+            reportGetterFailure("compare 2");
+        }
+
+        final String rootName1 = "123";
+        controller.getRoot().setName1(rootName1);
+        if ( 0 != rootName1.compareTo(controller.getRootName1())) {
+            reportGetterFailure("compare 3");
+        }
+
+        final String rootName2 = "456";
+        controller.getRoot().setName2(rootName2);
+
+        if ( 0 != rootName2.compareTo(controller.getRootName2())) {
+            reportGetterFailure("compare 4");
+        }
+
+            return retRec;
+        }
+    }
+
+    public static final String loadfontPath = RESOURCE_BASE + "fontload.fxml";
+
+    private class loadfontSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return loadfontPath ;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Font fnt = null;
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            try {
+                 fnt = (Font) fxmlLoader.load();
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            System.out.println("font name: " + fnt.getName());
+            if ( 0 != "Lucida Bright Demibold".compareTo(fnt.getName())) {
+                reportGetterFailure("font name check failed");
+            }
+
+            return retRec;
+        }
+    }
+
+    public static final String scenebuilderPath = RESOURCE_BASE + "scenebuilder.fxml";
+
+    private class scenebuilderSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return scenebuilderPath ;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Scene tmpScene = null;
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            try {
+                 tmpScene = (Scene) fxmlLoader.load();
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            if ( 150 != tmpScene.getHeight()) {
+                reportGetterFailure("sceneHeight check failed");
+            }
+            if ( 100 != tmpScene.getWidth()) {
+                reportGetterFailure("sceneWidth check failed");
+            }
+
+            return tmpScene.getRoot();
+        }
+    }
+
+
+    public static final String rt18299ResourcePath = RESOURCE_BASE + "rt18299-scene-without-root.fxml";
+    private class scenebuilderNoRootSlot extends scenebuilderSlot
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18299ResourcePath;
+        }
+
+    }
+
+    public static final String rt19329ResourcePath = RESOURCE_BASE + "rt19329-error-FXML.fxml";
+    public static final String ERROR_INFO_ID = "error_info";
+    //public static final String FXML_ERROR_LOCATION = "<ErrorTag is not a valid type.>fxml:12";
+    private class errorFXMLLoader extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt19329ResourcePath;
+        }
+
+        @Override
+        protected Node impl_drawNode() throws IOException
+        {
+            final Label label = new Label();
+            label.setId(ERROR_INFO_ID);
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            try
+            {
+                 fxmlLoader.load();
+            }
+            catch(IOException e)
+            {
+                boolean lineNumberPresentAndCorrect = false;
+                System.out.println("Exception text=" + e.getMessage());
+                if (e.getMessage().contains("ErrorTag") &&
+                     e.getMessage().contains("fxml:12"))
+                {
+                    return retRec;
+                }
+            }
+            reportGetterFailure("wrong error message");
+            return label;
+        }
+
+    }
+
+    public static final String rt18218ResourcePath = RESOURCE_BASE + "rt18218-unknown-custom-type.fxml";
+    public static final String LOADER_LOG_ID = "loader_log";
+    public static final String SUCCESSFUL_STATIC_LOAD = "success";
+    private class UnknownCustomType extends TestNodeWithIOExceptionProcessing
+    {
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18218ResourcePath;
+        }
+
+        @Override
+        protected Node impl_drawNode() throws IOException
+        {
+            final Label label = new Label();
+            label.setId(LOADER_LOG_ID);
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            fxmlLoader.impl_setStaticLoad(true);
+            try
+            {
+                 fxmlLoader.load();
+                 label.setText(SUCCESSFUL_STATIC_LOAD);
+            }
+            catch(LoadException e)
+            {
+                e.printStackTrace();
+                for(ParseTraceElement trace: fxmlLoader.impl_getParseTrace())
+                {
+                    label.setText(label.getText() + trace.toString() + '\n');
+                }
+            }
+
+            return label;
+        }
+
+    }
+
+    public static final String rt14345ResourcePath = RESOURCE_BASE + "rt14345-color-valueOf.fxml";
+    private class ColorValueOf extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt14345ResourcePath;
+        }
+
+        @Override
+        protected Node impl_drawNode() throws IOException
+        {
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            Node node = null;
+            try
+            {
+                 node = (Node) fxmlLoader.load();
+            }
+            catch(Exception e)
+            {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            return node;
+        }
+
+    }
+
+    public static final String rt18680ResourcePath = RESOURCE_BASE + "rt18680-escape-character.fxml";
+    private class EscapeCharacter extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18680ResourcePath;
+        }
+
+        @Override
+        protected Node impl_drawNode() throws IOException
+        {
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            VBox node = null;
+            try
+            {
+                 node = (VBox) fxmlLoader.load();
+                 for(Node child: node.getChildren())
+                 {
+                     if((child.getId().equals("label_1")
+                             || child.getId().equals("label_2"))
+                         && !((Label) child).getText().equals("${foo}"))
+                     {
+                         reportGetterFailure(child.getId() + " text check failed");
+                     }
+                     if((child.getId().equals("label_3")
+                             || child.getId().equals("label_4"))
+                         && !((Label) child).getText().equals("@{foo}"))
+                     {
+                         reportGetterFailure(child.getId() + " text check failed");
+                     }
+                     if((child.getId().equals("label_5")
+                             || child.getId().equals("label_6"))
+                         && !((Label) child).getText().equals("%{foo}"))
+                     {
+                         reportGetterFailure(child.getId() + " text check failed");
+                     }
+                 }
+            }
+            catch(Exception e)
+            {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            return node;
+        }
+
+    }
+
+    public static final String rt17714ResourcePath = RESOURCE_BASE + "rt17714-collection-events-handlers.fxml";
+    private class CollectionEventsHandlers extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt17714ResourcePath;
+        }
+
+        @Override
+        protected Node impl_drawNode() throws IOException
+        {
+            FXMLLoader fxmlLoader = new FXMLLoader(resource);
+            ObservableList<String> observableArrayList = null;
+            //javafx.collections.FXCollections.observableArrayList();
+            try
+            {
+                 observableArrayList = (ObservableList<String>) fxmlLoader.load();
+                 System.out.println(fxmlLoader.getController().getClass());
+                 observableArrayList.add("New added string");
+            }
+            catch(Exception e)
+            {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+
+            if(1 != CollectionController.callCount)
+            {
+                reportGetterFailure("Controller didn't handle event");
+            }
+
+            return new Label(observableArrayList.get(0).toString());
+        }
+
+    }
+
+    public static final String rt18229ResourcePath = RESOURCE_BASE + "rt18229-no-args-controller-method.fxml";
+    private class NoArgsControllerMethod extends TestNodeWithIOExceptionProcessing
+    {
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18229ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            Button button = null;
+            try
+            {
+                button = (Button) loader.load();
+                System.out.println(button.getId());
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return button;
+        }
+    }
+
+    public static final String rt18229OverloadedResourcePath = RESOURCE_BASE + "rt18229-overloaded-controller-method.fxml";
+    private class OverloadedControllerMethod extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18229OverloadedResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            Button button = null;
+            try
+            {
+                button = (Button) loader.load();
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return button;
+        }
+
+    }
+
+    public static final String rt17657ResourcePath = RESOURCE_BASE + "rt17657-custom-id-property.fxml";
+    private class CustomIDProperty extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt17657ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            CustomIDButton button = null;
+            try
+            {
+                button = (CustomIDButton) loader.load();
+                System.out.println(button.getCustomID());
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return button;
+
+        }
+
+    }
+
+    public static final String rt16722ResourcePath = RESOURCE_BASE + "rt16722-base-controller-properties.fxml";
+    private class BaseColntrollerProperty extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt16722ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            VBox vBox = null;
+            try
+            {
+                vBox = (VBox) loader.load();
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return vBox;
+
+        }
+
+    }
+
+    public static final String rt18956ResourcePath = RESOURCE_BASE + "rt18956-relative-stylesheets.fxml";
+    private class RelativeStylesheet extends TestNodeWithIOExceptionProcessing
+    {
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt18956ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            Label label = null;
+            try
+            {
+                label = (Label) loader.load();
+                System.out.println("font:" + label.getFont().toString());
+
+                System.out.println("Style:");
+                System.out.println(label.getStyle());
+                final ObservableList<String> sheets = label.getStylesheets();
+                for (String str : sheets)
+                    System.out.println("sheet:" + str);
+                if (null != label.getBackground()) {
+                final List<BackgroundFill> lbf =
+                    label.getBackground().getFills();
+
+
+                for (BackgroundFill bf : lbf)
+                    System.out.println("fill:" + bf.toString());
+                } else {
+                    System.out.println("null == label.getBackground() ");
+                }
+                final List<CssMetaData<? extends Styleable, ?>> ls =
+                    label.getControlCssMetaData();
+
+
+                for (CssMetaData<? extends Styleable, ?> md : ls)
+                {
+                    System.out.println("css:" + md.toString());
+                    if (md.getProperty().equals("-fx-region-background")){
+                        final List<CssMetaData<? extends Styleable, ?>> subList =
+                            md.getSubProperties();
+                            for (CssMetaData<? extends Styleable, ?> smd : subList){
+                                System.out.println("   subcss:" + smd.toString());
+                                if (smd.getProperty().equals("-fx-background-color")){
+
+                                }
+                            }
+                    }
+
+                }
+
+
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return label;
+
+        }
+
+    }
+
+    public static final String rt16815ResourcePath = RESOURCE_BASE + "FXMLLoaderAPI.fxml";
+    private class FXMLLoaderAPI extends TestNodeWithIOExceptionProcessing
+    {
+
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return rt16815ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            ResourceBundle rb = ResourceBundle.getBundle("test.fxmltests.resources.resource1",  new Locale("en", "US"));
+            FXMLLoader loader2 = new FXMLLoader(resource, rb);
+            FXMLLoader loader3 = new FXMLLoader(resource, rb, new JavaFXBuilderFactory());
+            ObservableList<Labeled> list = FXCollections.observableArrayList();
+            try
+            {
+                list.add((Labeled) loader.load());
+//                System.out.println(label.getStyle());
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            try
+            {
+                list.add((Labeled) loader2.load());
+//                System.out.println(label.getStyle());
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            try
+            {
+                list.add((Labeled) loader3.load());
+//                System.out.println(label.getStyle());
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            VBox vb = new VBox();
+            vb.getChildren().addAll(list);
+            return vb;
+
+        }
+
+    }
+
+    public static final String references2Path = RESOURCE_BASE + "ref_test.fxml";
+    private class references2Slot extends TestNodeWithIOExceptionProcessing {
+        // RT-18178
+        AnchorPane anchorPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return references2Path;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                anchorPane = (AnchorPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+
+            Button button = null;
+            Label label = null;
+            for (Node node : anchorPane.getChildren()) {
+                if (node instanceof Button) {
+                    button = (Button)node;
+                }
+                if (node instanceof Label) {
+                    label = (Label)node;
+                }
+            }
+
+            if ( null != label && null != button ) {
+                System.out.println("label: " + label.getFont() + " / " + label.getTextFill());
+                System.out.println("button: " + button.getFont() + " / " + button.getTextFill());
+
+                if (label.getTextFill().equals(button.getTextFill()) &&
+                    label.getFont().equals(button.getFont())) {
+                        return retRec;
+                }
+            }
+            reportGetterFailure("failed.");
+            return redRectangle;
+        }
+    }
+
+
+
+    public static final String apConstraintsPath = RESOURCE_BASE + "project-with-all-AnchorPane-constraints.fxml";
+    private class apConstraintsSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-18178
+        AnchorPane anchorPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return apConstraintsPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                anchorPane = (AnchorPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+                        return retRec;
+        }
+    }
+
+
+
+
+    public static final String coercePath = RESOURCE_BASE + "project-with-all-p2-components.fxml";
+    private class coerceSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-18178
+        AnchorPane anchorPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return coercePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                anchorPane = (AnchorPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return retRec;
+        }
+    }
+
+    public static final String gridappletPath = RESOURCE_BASE + "rt19752.fxml";
+    private class gridappletSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-18178
+        GridPane gridPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return gridappletPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                gridPane = (GridPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return retRec;
+        }
+    }
+
+    /*
+    public static final String csspathPath = RESOURCE_BASE + "rt18956.xml";
+    private class csspathSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-18956
+        BorderPane gridPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return csspathPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                fxmlLoader2.setLocation(resource);
+
+                is = resource.openStream();
+                URL ggg;
+                AnchorPane sc = (AnchorPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return retRec;
+        }
+    }
+    */
+
+    public static final String listviewPath = RESOURCE_BASE + "listview-items.fxml";
+    private class listviewSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-18178
+        AnchorPane anchorPane = null;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return listviewPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader2 = new FXMLLoader();
+                is = resource.openStream();
+                anchorPane = (AnchorPane) fxmlLoader2.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+
+            ListView lv = null;
+            for (Node node : anchorPane.getChildren()) {
+                System.out.println("anchorpane child: " + node);
+                if (node instanceof ListView) {
+                    lv = (ListView)node;
+                }
+            }
+
+            int hboxcount = 0;
+            if (null != lv) {
+                for (Object node : lv.getItems()) {
+                    if (node  instanceof HBox) {
+                        hboxcount = hboxcount + 1;
+                    }
+                    System.out.println("listview child: " + node);
+                }
+
+            }
+
+            if ( 3 != hboxcount ) {
+                reportGetterFailure("wrong items/items count.");
+                return redRectangle;
+            } else {
+                return retRec;
+            }
+        }
+    }
+
+    private class listenerNullArgSlot extends TestNodeWithIOExceptionProcessing {
+        // RT-19133
+
+        @Override
+        protected String impl_getPathToResource() {
+            return rt19133ResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            //InputStream is = null;
+            try {
+                //is = resource.openStream();
+                FXMLLoader fxmlLoader = new FXMLLoader(resource);
+
+                fxmlLoader.impl_setStaticLoad(true);
+                fxmlLoader.setLoadListener(new LoadListener() {
+
+                    @Override
+                    public void readImportProcessingInstruction(String target) {
+                    }
+
+                    @Override
+                    public void readLanguageProcessingInstruction(String language) {
+                    }
+
+                    @Override
+                    public void readComment(String comment) {
+                    }
+
+                    @Override
+                    public void beginInstanceDeclarationElement(Class<?> type) {
+                    }
+
+                    @Override
+                    public void beginUnknownTypeElement(String name) {
+                    }
+
+                    @Override
+                    public void beginIncludeElement() {
+                    }
+
+                    @Override
+                    public void beginReferenceElement() {
+                    }
+
+                    @Override
+                    public void beginCopyElement() {
+                    }
+
+                    @Override
+                    public void beginPropertyElement(String name, Class<?> sourceType) {
+                    }
+
+                    @Override
+                    public void beginUnknownStaticPropertyElement(String name) {
+                    }
+
+                    @Override
+                    public void beginScriptElement() {
+                    }
+
+                    @Override
+                    public void beginDefineElement() {
+                    }
+
+                    @Override
+                    public void readInternalAttribute(String name, String value) {
+                    }
+
+                    @Override
+                    public void readPropertyAttribute(String name, Class<?> sourceType, String value) {
+                    }
+
+                    @Override
+                    public void readUnknownStaticPropertyAttribute(String name, String value) {
+                    }
+
+                    @Override
+                    public void readEventHandlerAttribute(String name, String value) {
+                    }
+
+                    @Override
+                    public void endElement(Object value) {
+                        if (null == value) {
+                            System.out.println("endElement() arg is null: rt-19133");
+                            reportGetterFailure("endElement() arg is null: rt-19133");
+                        } else {
+                            System.out.println("endElement() arg:" + value);
+                        }
+                    }
+
+                    @Override
+                    public void beginRootElement() {
+                        throw new UnsupportedOperationException("Not supported yet.");
+                    }
+                });
+
+
+                fxmlLoader.load();
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                //is.close();
+            }
+            return retRec;
+        }
+    }
+
+    public static final String fullyQualifiedNamesResPath = RESOURCE_BASE + "fully-qualified-name.fxml";
+    private class FullyQualifiedNamesSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return fullyQualifiedNamesResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Label label = null;
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader = new FXMLLoader();
+                is = resource.openStream();
+                label = (Label) fxmlLoader.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return label;
+        }
+    }
+
+    public static final String importResPath = RESOURCE_BASE + "import.fxml";
+    private class ImportSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return importResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Label label = null;
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader = new FXMLLoader();
+                is = resource.openStream();
+                label = (Label) fxmlLoader.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return label;
+        }
+    }
+
+    public static final String beanInstantiationResPath = RESOURCE_BASE + "bean-instantiation.fxml";
+    private class BeanInstantiationSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return beanInstantiationResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Label label = new Label();
+        label.setId("label_from_bean");
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader = new FXMLLoader();
+                is = resource.openStream();
+        SimpleBean bean = (SimpleBean) fxmlLoader.load(is);
+                label.setText(bean.getContent());
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return label;
+        }
+    }
+
+    public static final String valueOfResPath = RESOURCE_BASE + "value-of.fxml";
+    private class ValueOfSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return valueOfResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+            Label label = new Label();
+        label.setId("value_of_label");
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader = new FXMLLoader();
+                is = resource.openStream();
+        Double d = (Double) fxmlLoader.load(is);
+                label.setText(d.toString());
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return label;
+        }
+    }
+
+    public static final String rootResPath = RESOURCE_BASE + "root.fxml";
+    private class RootSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return rootResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        VBox vb = new VBox();
+        vb.setId("vb_root");
+            InputStream is = null;
+            try {
+                FXMLLoader fxmlLoader = new FXMLLoader();
+        fxmlLoader.setRoot(vb);
+                is = resource.openStream();
+        fxmlLoader.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+            return vb;
+        }
+    }
+
+    public static final String fxIdResPath = RESOURCE_BASE + "fx-id.fxml";
+    private class FxIdSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return fxIdResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        AnchorPane ap = null;
+            InputStream is = null;
+        FXMLLoader fxmlLoader = null;
+            try {
+                fxmlLoader = new FXMLLoader();
+        is = resource.openStream();
+        ap = (AnchorPane) fxmlLoader.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+        Object label = fxmlLoader.getNamespace().get("cat_o_dog_label");
+        if(label == null || !(label instanceof Label))
+        {
+        reportGetterFailure("no label with id cat_o_dog_label");
+        }
+        if(label instanceof Label && !((Label) label).getText().equals("cat-o-dog"))
+        {
+        reportGetterFailure("invalid text in label");
+        }
+            return ap;
+        }
+    }
+
+    private class controllerAttributeSlot extends TestNodeWithIOExceptionProcessing {
+
+        MyRootElement2 mr;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return rootMethodEventHandlerResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+        FXMLLoader loader = new FXMLLoader();
+            try {
+                // https://javafx-jira.kenai.com/browse/RT-26774
+        //mr = (MyRootElement2) FXMLLoader.load(resource);
+                loader.setLocation(resource);
+                mr = (MyRootElement2)loader.load();
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                e.printStackTrace();
+                reportGetterFailure("exception thrown.");
+            }
+
+            if(!(loader.getController() instanceof MyRootElement2))
+        {
+        reportGetterFailure("wrong controller");
+        }
+
+        return mr;
+        }
+    }
+
+    public static final String noDefControllerResPath = RESOURCE_BASE + "no-default-controller.fxml";
+    private class NoDefaultControllerSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return noDefControllerResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        Button button = null;
+        InputStream is = null;
+        FXMLLoader fxmlLoader = null;
+        MyRootElement myRootElement = new MyRootElement();
+            try {
+                fxmlLoader = new FXMLLoader();
+        fxmlLoader.setController(myRootElement);
+                is = resource.openStream();
+        button = (Button) fxmlLoader.load(is);
+            } catch (Exception e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+        if(fxmlLoader.getController() != myRootElement)
+        {
+        reportGetterFailure("Wrong controller");
+        }
+            return button;
+        }
+    }
+
+    private class LateRootSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return rootResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        VBox vb = new VBox();
+        vb.setId("vb_root");
+        Node node = null;
+        FXMLLoader fxmlLoader = new FXMLLoader();
+            InputStream is = null;
+            try {
+        is = resource.openStream();
+        node = (Node) fxmlLoader.load(is);
+        fxmlLoader.setRoot(vb);
+            } catch (LoadException e) {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                return retRec;
+            } catch (Exception exc) {
+                exc.printStackTrace();
+                System.out.println("message: " + exc.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+//        if(node.getId() == null || !node.getId().equals("default_root"))
+//        {
+//        reportGetterFailure("Root id: " + node.getId());
+//        }
+        return redRectangle;
+        }
+    }
+
+    private class LateControllerSlot extends TestNodeWithIOExceptionProcessing {
+
+        @Override
+        protected String impl_getPathToResource() {
+            return noDefControllerResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException {
+        Button button = null;
+        InputStream is = null;
+        FXMLLoader fxmlLoader = new FXMLLoader();
+        MyRootElement myRootElement = new MyRootElement();
+            try {
+        is = resource.openStream();
+        fxmlLoader.load(is);
+        fxmlLoader.setController(myRootElement);
+            } catch (Exception e) {
+
+        if(e instanceof LoadException && e.getMessage().contains("No controller specified."))
+        {
+            return retRec;
+        }
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            } finally {
+                is.close();
+            }
+        reportGetterFailure("Controller is not null.");
+        return redRectangle;
+        }
+    }
+
+    private class VariableResolutionSlot extends TestNodeWithIOExceptionProcessing {
+
+        VBox vb;
+
+        @Override
+        protected String impl_getPathToResource() {
+            return fxdefineResourcePath;
+        }
+
+        @Override
+        public Node impl_drawNode() {
+            try {
+                vb = FXMLLoader.load(resource);
+            } catch (Exception e) {
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("exception thrown.");
+            }
+        LinkedList<ToggleGroup> toggleGroups = new LinkedList<ToggleGroup>();
+        for(Node child: vb.getChildren())
+        {
+        toggleGroups.add(((RadioButton) child).getToggleGroup());
+        }
+        for(int i = 0; i < toggleGroups.size() - 2; i ++)
+        {
+        if(!toggleGroups.get(i).equals(toggleGroups.get(i + 1)))
+        {
+            reportGetterFailure("failed.");
+            return redRectangle;
+        }
+        }
+            return retRec;
+        }
+    }
+
+    public static final String externalScriptResPath = RESOURCE_BASE + "external-script.fxml";
+    private class ExternalScriptCodeSlot extends TestNodeWithIOExceptionProcessing
+    {
+        @Override
+        protected String impl_getPathToResource()
+        {
+            return externalScriptResPath;
+        }
+
+        @Override
+        public Node impl_drawNode() throws IOException
+        {
+            FXMLLoader loader = new FXMLLoader(resource);
+            VBox vb = null;
+            try
+            {
+                vb = (VBox) loader.load();
+            }
+            catch(Exception e)
+            {
+                e.printStackTrace();
+                System.out.println("message: " + e.getMessage());
+                reportGetterFailure("message: " + e.getMessage());
+            }
+            return vb;
+        }
+    }
+
+
+    @Override
+    public TestNode setup() {
+        System.out.println("java.library.path=" + System.getProperty("java.library.path"));
+        TestNode rootTestNode = new TestNode();
+
+        final int heightPageContentPane = 800;
+        final int widthPageContentPane = 800;
+
+        List<Pair<String, TestNode>> hm = new ArrayList();
+
+        hm.add(new Pair<String, TestNode>(Pages.staticProperty.name(), new slotStaticProperty()));
+        hm.add(new Pair<String, TestNode>(Pages.HashMap.name(), new hashmaptest()));
+        hm.add(new Pair<String, TestNode>(Pages.customClassAndInclude.name(), new customClassLoadSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.factory.name(), new factorySlot()));
+        hm.add(new Pair<String, TestNode>(Pages.simple.name(), new simpleSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.propertyElements.name(), new propertyElementsSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.reference.name(), new referenceSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.copy.name(), new copySlot()));
+        hm.add(new Pair<String, TestNode>(Pages.prSetter.name(), new propertySetterSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.roList.name(), new roListSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.roMap.name(), new roMapSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.defaultProperty.name(), new defaultPropertySlot()));
+        hm.add(new Pair<String, TestNode>(Pages.fxdefine.name(), new fxdefineSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.namespaceBinding.name(), new namespaceBindingSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.staticProperties.name(), new staticPropertiesSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.rootMethodEventHandler.name(), new rootMethodEventHandlerSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.scriptEventHandler.name(), new scriptEventHandlerSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.script.name(), new scriptSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.menuItem.name(), new menuitemSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.resources1.name(), new resource1Slot()));
+        hm.add(new Pair<String, TestNode>(Pages.resources2.name(), new resource2Slot()));
+        hm.add(new Pair<String, TestNode>(Pages.namespace.name(), new namespaceSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.splitpanebug.name(), new splitpanebugSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.charset.name(), new charsetSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.loadExceptions.name(), new loadExceptionsSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultLabeled.name(), new slotDefaultLabeled()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultListview.name(), new   slotDefaultListview()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultMenu.name(), new   slotDefaultMenu()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultMenuBar.name(), new   slotDefaultMenuBar()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultScrollpane.name(), new   slotDefaultScrollpane()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultTabpane.name(), new   slotDefaultTabpane()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultTableView.name(), new   slotDefaultTableview()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultTextinput.name(), new   slotDefaultTextinput()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultTitledpane.name(), new   slotDefaultTitledpane()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultTreeview.name(), new   slotDefaultTreeview()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultImageview.name(), new   slotDefaultImageview()));
+        hm.add(new Pair<String, TestNode>(Pages.slotDefaultPane.name(), new   slotDefaultPane()));
+        hm.add(new Pair<String, TestNode>(Pages.slotControllerFactory.name(), new  controllerFactoryPane()));
+        hm.add(new Pair<String, TestNode>(Pages.specificSignatureMethod.name(), new  specificSignatureMethodPane()));
+        hm.add(new Pair<String, TestNode>(Pages.loadfontSlot.name(), new  loadfontSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.scenebuilderSlot.name(), new  scenebuilderSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.references2.name(), new  references2Slot()));
+        hm.add(new Pair<String, TestNode>(Pages.apConstraints.name(), new  apConstraintsSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.coerce.name(), new  coerceSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.listviewItems.name(), new listviewSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.listenerNullArg.name(), new listenerNullArgSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.gridapplet.name(), new gridappletSlot()));
+        //hm.add(new Pair<String, TestNode>(Pages.csspath.name(), new csspathSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.scenebuilderNoRoot.name(), new scenebuilderNoRootSlot()));
+        hm.add(new Pair<String, TestNode>(Pages.errorFXML.name(), new errorFXMLLoader()));
+        hm.add(new Pair<String, TestNode>(Pages.colorValueOF.name(), new ColorValueOf()));
+        hm.add(new Pair<String, TestNode>(Pages.escapeCharacter.name(), new EscapeCharacter()));
+        hm.add(new Pair<String, TestNode>(Pages.collectionEventsHandlers.name(), new CollectionEventsHandlers()));
+        hm.add(new Pair<String, TestNode>(Pages.noArgControllerMethod.name(), new NoArgsControllerMethod()));
+        hm.add(new Pair<String, TestNode>(Pages.overloadedControllerMethod.name(), new OverloadedControllerMethod()));
+        hm.add(new Pair<String, TestNode>(Pages.customIDProperty.name(), new CustomIDProperty()));
+        hm.add(new Pair<String, TestNode>(Pages.unknownCustomType.name(), new UnknownCustomType()));
+        hm.add(new Pair<String, TestNode>(Pages.baseControllerProperty.name(), new BaseColntrollerProperty()));
+        hm.add(new Pair<String, TestNode>(Pages.relativeStylesheet.name(), new RelativeStylesheet()));
+        hm.add(new Pair<String, TestNode>(Pages.FXMLLoaderAPI.name(), new FXMLLoaderAPI()));
+        hm.add(new Pair<String, TestNode>(Pages.fullyQualifiedNames.name(), new FullyQualifiedNamesSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.importPI.name(), new ImportSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.beanInstantiation.name(), new BeanInstantiationSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.valueOf.name(), new ValueOfSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.root.name(), new RootSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.fxId.name(), new FxIdSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.fxController.name(), new controllerAttributeSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.noDefaultController.name(), new NoDefaultControllerSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.lateRoot.name(), new LateRootSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.lateController.name(), new LateControllerSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.variableResolution.name(), new VariableResolutionSlot()));
+    hm.add(new Pair<String, TestNode>(Pages.externalScript.name(), new ExternalScriptCodeSlot()));
+
+
+        for (Pair<String, TestNode> tn : hm) {
+            final PageWithSlots xPage = new PageWithSlots(tn.getKey(), heightPageContentPane, widthPageContentPane);
+            xPage.setSlotSize(240, 180);
+            xPage.add(tn.getValue(), tn.getKey());
+            rootTestNode.add(xPage);
+
+        }
+        return rootTestNode;
+
+    }
+
+    public static void main(String[] args) {
+        Utils.launch(staticPropertyLoadApp.class, args);
+    }
+
+}