31 import javax.swing.event.*;

    31 import javax.swing.event.*;

    32 import javax.swing.tree.*;

    32 import javax.swing.tree.*;

    33 import java.awt.*;

    33 import java.awt.*;

    34 import java.awt.event.*;

    34 import java.awt.event.*;

    35 import java.lang.reflect.InvocationTargetException;

    35 import java.lang.reflect.InvocationTargetException;

    37 

    36 

    38 public class bug4927934 implements TreeSelectionListener, TreeExpansionListener, FocusListener {

    37 public class bug4927934 implements TreeSelectionListener, TreeExpansionListener, FocusListener {

    39 

    38 

    40     final static Object listener = new bug4927934();

    39     final static Object listener = new bug4927934();

    41 

    40 

    71                 frame.setSize(300, 300);

    70                 frame.setSize(300, 300);

    72                 frame.setVisible(true);

    71                 frame.setVisible(true);

    73             }

    72             }

    74         });

    73         });

    75 

    74 

    78         Thread.sleep(1000);

    76         Thread.sleep(1000);

    79 

    77 

    80         SwingUtilities.invokeLater(new Runnable() {

    78         SwingUtilities.invokeLater(new Runnable() {

    81             public void run() {

    79             public void run() {

    82                 tree.requestFocus();

    80                 tree.requestFocus();

    95         }

    93         }

    96 

    94 

    97         // GO TO RIGHT

    95         // GO TO RIGHT

    98         selectionChanged = false;

    96         selectionChanged = false;

    99         hitKey(KeyEvent.VK_RIGHT);

    97         hitKey(KeyEvent.VK_RIGHT);

   101         if (!checkSelectionChanged(tree, 0)) {

    99         if (!checkSelectionChanged(tree, 0)) {

   102             throw new RuntimeException("Root should be selected");

   100             throw new RuntimeException("Root should be selected");

   103         }

   101         }

   104 

   102 

   105         selectionChanged = false;

   103         selectionChanged = false;

   106         hitKey(KeyEvent.VK_RIGHT);

   104         hitKey(KeyEvent.VK_RIGHT);

   108         if (!checkSelectionChanged(tree, 1)) {

   106         if (!checkSelectionChanged(tree, 1)) {

   109             throw new RuntimeException("Node should be selected");

   107             throw new RuntimeException("Node should be selected");

   110         }

   108         }

   111 

   109 

   112         treeExpanded = false;

   110         treeExpanded = false;

   113         hitKey(KeyEvent.VK_RIGHT);

   111         hitKey(KeyEvent.VK_RIGHT);

   115         if (!isTreeExpanded()) {

   113         if (!isTreeExpanded()) {

   116             throw new RuntimeException("Node should be expanded");

   114             throw new RuntimeException("Node should be expanded");

   117         }

   115         }

   118 

   116 

   119         selectionChanged = false;

   117         selectionChanged = false;

   120         hitKey(KeyEvent.VK_RIGHT);

   118         hitKey(KeyEvent.VK_RIGHT);

   122         if (!checkSelectionChanged(tree, 2)) {

   120         if (!checkSelectionChanged(tree, 2)) {

   123             throw new RuntimeException("Leaf1 should be selected");

   121             throw new RuntimeException("Leaf1 should be selected");

   124         }

   122         }

   125 

   123 

   126         selectionChanged = false;

   124         selectionChanged = false;

   127         hitKey(KeyEvent.VK_RIGHT);

   125         hitKey(KeyEvent.VK_RIGHT);

   129         if (!checkSelectionChanged(tree, 2)) {

   127         if (!checkSelectionChanged(tree, 2)) {

   130             throw new RuntimeException("Leaf1 should be selected");

   128             throw new RuntimeException("Leaf1 should be selected");

   131         }

   129         }

   132 

   130 

   133         // GO TO LEFT

   131         // GO TO LEFT

   134         selectionChanged = false;

   132         selectionChanged = false;

   135         hitKey(KeyEvent.VK_LEFT);

   133         hitKey(KeyEvent.VK_LEFT);

   137         if (!checkSelectionChanged(tree, 1)) {

   135         if (!checkSelectionChanged(tree, 1)) {

   138             throw new RuntimeException("Node should be selected");

   136             throw new RuntimeException("Node should be selected");

   139         }

   137         }

   140 

   138 

   141         treeCollapsed = false;

   139         treeCollapsed = false;

   144             throw new RuntimeException("Node should be collapsed");

   142             throw new RuntimeException("Node should be collapsed");

   145         }

   143         }

   146 

   144 

   147         selectionChanged = false;

   145         selectionChanged = false;

   148         hitKey(KeyEvent.VK_LEFT);

   146         hitKey(KeyEvent.VK_LEFT);

   150         if (!checkSelectionChanged(tree, 0)) {

   148         if (!checkSelectionChanged(tree, 0)) {

   151             throw new RuntimeException("Root should be selected");

   149             throw new RuntimeException("Root should be selected");

   152         }

   150         }

   153 

   151 

   154         treeCollapsed = false;

   152         treeCollapsed = false;

   155         hitKey(KeyEvent.VK_LEFT);

   153         hitKey(KeyEvent.VK_LEFT);

   157         if (!isTreeCollapsed()) {

   155         if (!isTreeCollapsed()) {

   158             throw new RuntimeException("Root should be collapsed");

   156             throw new RuntimeException("Root should be collapsed");

   159         }

   157         }

   160     }

   158     }

   161 

   159