--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/jdk/test/javax/swing/JTree/4633594/JTreeFocusTest.java	Wed Jan 18 11:35:31 2017 +0530
@@ -0,0 +1,232 @@
+/*
+ * Copyright (c) 2002, 2017, 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.
+ *
+ * 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.
+ */
+/* @test
+   @bug 4633594 8172012
+   @summary No way to pass focus from a JTree to a GUI placed inside the tree node
+   @run main JTreeFocusTest
+*/
+import java.awt.Component;
+import java.awt.GridLayout;
+import java.awt.Point;
+import java.awt.Robot;
+import java.awt.event.FocusAdapter;
+import java.awt.event.FocusEvent;
+import java.awt.event.KeyEvent;
+import java.util.EventObject;
+import javax.swing.JComponent;
+import javax.swing.JFrame;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+import javax.swing.JTextField;
+import javax.swing.JTree;
+import javax.swing.SwingUtilities;
+import javax.swing.UIManager;
+import javax.swing.border.BevelBorder;
+import javax.swing.border.CompoundBorder;
+import javax.swing.border.LineBorder;
+import javax.swing.event.TreeSelectionEvent;
+import javax.swing.event.TreeSelectionListener;
+import javax.swing.tree.DefaultMutableTreeNode;
+import javax.swing.tree.DefaultTreeCellEditor;
+import javax.swing.tree.DefaultTreeCellRenderer;
+import javax.swing.tree.DefaultTreeModel;
+
+public class JTreeFocusTest {
+
+    private static DefaultMutableTreeNode root;
+    Robot robot;
+    static boolean passed = false;
+    boolean rootSelected = false;
+    boolean keysTyped = false;
+    private volatile Point p = null;
+    private static JFrame fr;
+    private static volatile JTree tree = null;
+
+    public static void main(String[] args) throws Exception{
+         new JTreeFocusTest();
+    }
+
+    void blockTillDisplayed(JComponent comp) throws Exception {
+        while (p == null) {
+            try {
+                SwingUtilities.invokeAndWait(() -> {
+                    p = comp.getLocationOnScreen();
+                });
+            } catch (IllegalStateException e) {
+                try {
+                    Thread.sleep(1000);
+                } catch (InterruptedException ie) {
+                }
+            }
+        }
+    }
+
+    public JTreeFocusTest() throws Exception {
+        SwingUtilities.invokeAndWait(() -> {
+            fr = new JFrame("Test");
+
+            root = new DefaultMutableTreeNode("root");
+            JPanel p = new JPanel();
+            p.setBorder(new CompoundBorder(new BevelBorder(BevelBorder.RAISED),
+                    new LineBorder(UIManager.getColor("control"), 7)));
+            p.setLayout(new GridLayout(2,2));
+            p.add(new JLabel("one"));
+            JTextField tf1  = new JTextField(10);
+            p.add(tf1);
+            p.add(new JLabel("two"));
+            p.add(new JTextField(10));
+            root.add(new DefaultMutableTreeNode(p));
+
+            tf1.addFocusListener(new FocusAdapter() {
+                public void focusGained(FocusEvent e) {
+                    setPassed(true);
+                }
+            });
+
+            DefaultTreeModel model = new DefaultTreeModel(root);
+            tree = new JTree(model) {
+                public void processKeyEvent(KeyEvent e) {
+                    super.processKeyEvent(e);
+                    if (e.getKeyCode()==KeyEvent.VK_F2) {
+                        synchronized (JTreeFocusTest.this) {
+                            keysTyped = true;
+                            JTreeFocusTest.this.notifyAll();
+                        }
+                    }
+                }
+            };
+
+            tree.addTreeSelectionListener(new TreeSelectionListener() {
+                public void valueChanged(TreeSelectionEvent e) {
+                    if ( root.equals(e.getPath().getLastPathComponent()) ) {
+                        synchronized (JTreeFocusTest.this) {
+                            rootSelected = true;
+                            JTreeFocusTest.this.notifyAll();
+                        }
+                    }
+                }
+            });
+
+            tree.setEditable(true);
+            DefaultTreeCellRenderer renderer = new FormRenderer();
+            tree.setCellRenderer(renderer);
+            DefaultTreeCellEditor editor = new FormEditor(tree, renderer);
+            tree.setCellEditor(editor);
+            fr.getContentPane().add(tree);
+
+            fr.setSize(300,400);
+            fr.setVisible(true);
+        });
+        blockTillDisplayed(tree);
+        SwingUtilities.invokeAndWait(() -> {
+            tree.requestFocus();
+            tree.setSelectionRow(0);
+        });
+
+        try {
+            synchronized (this) {
+                while (!rootSelected) {
+                    JTreeFocusTest.this.wait();
+                }
+            }
+
+            robot = new Robot();
+            robot.setAutoDelay(50);
+            robot.delay(150);
+            robot.keyPress(KeyEvent.VK_DOWN);
+            robot.keyRelease(KeyEvent.VK_DOWN);
+            robot.keyPress(KeyEvent.VK_RIGHT);
+            robot.keyRelease(KeyEvent.VK_RIGHT);
+            robot.keyPress(KeyEvent.VK_F2);
+            robot.keyRelease(KeyEvent.VK_F2);
+
+            synchronized (this) {
+                while (!keysTyped) {
+                    JTreeFocusTest.this.wait();
+                }
+            }
+            Thread.sleep(3000);
+        } catch(Throwable t) {
+            t.printStackTrace();
+        }
+        destroy();
+    }
+
+    public void destroy() throws Exception {
+        SwingUtilities.invokeAndWait(()->fr.dispose());
+        if ( !isPassed() ) {
+            throw new RuntimeException("Focus wasn't transferred to the proper component");
+        }
+    }
+
+    synchronized void setPassed(boolean passed) {
+        this.passed = passed;
+    }
+
+    synchronized boolean isPassed() {
+        return passed;
+    }
+
+    static JTree createTree() {
+        return tree;
+    }
+
+    class FormRenderer extends DefaultTreeCellRenderer {
+        public Component getTreeCellRendererComponent(JTree tree, Object value,
+                                                      boolean sel,
+                                                      boolean expanded,
+                                                      boolean leaf, int row,
+                                                      boolean hasFocus) {
+            Object obj = ((DefaultMutableTreeNode)value).getUserObject();
+            if (obj instanceof Component){
+                return (Component)((DefaultMutableTreeNode)value).getUserObject();
+            }
+            return super.getTreeCellRendererComponent(tree, value, sel,
+                                                      expanded, leaf, row,
+                                                      hasFocus);
+        }
+    }
+
+    class FormEditor extends DefaultTreeCellEditor {
+        public FormEditor(JTree tree, DefaultTreeCellRenderer renderer) {
+            super(tree, renderer);
+        }
+
+        public Component getTreeCellEditorComponent(JTree tree, Object value,
+                                                      boolean sel,
+                                                      boolean expanded,
+                                                      boolean leaf, int row) {
+            Object obj = ((DefaultMutableTreeNode)value).getUserObject();
+            if (obj instanceof Component){
+                return (Component)((DefaultMutableTreeNode)value).getUserObject();
+            }
+            return super.getTreeCellEditorComponent(tree, value, sel,
+                                                    expanded, leaf, row);
+        }
+
+        public boolean shouldSelectCell(EventObject anEvent) {
+            //return super.shouldSelectCell(anEvent);
+            return true;
+        }
+    }
+}