changeset 4002:b4f3debd7092

Automated merge with ssh://jfxsrc.us.oracle.com//javafx/8.0/scrum/controls/jfx/rt
author jgiles
date Wed, 19 Jun 2013 09:18:39 +1200
parents 12d2d28f86b8 92d455c3783b
children 9d368dc0822d 1925630fc297
files
diffstat 12 files changed, 1201 insertions(+), 1024 deletions(-) [+]
line wrap: on
line diff
--- a/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/ContextMenuContent.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/ContextMenuContent.java	Wed Jun 19 09:18:39 2013 +1200
@@ -601,29 +601,6 @@
                 // on the Menu whose submenu is open.
                 if (submenu != null && submenu.isShowing()) return;
                   
-                // RT-15339 : if this context menu has another context menu part 
-                // of its content, then do nothing similar to the submenu case.
-                // walk thru all windows open to see if if this context menu is
-                // the owner window for another context menu, if so return.
-                final Iterator<Window> iter =
-                        AccessController.doPrivileged(
-                                new PrivilegedAction<Iterator<Window>>() {
-                                    @Override
-                                    public Iterator<Window> run() {
-                                        return Window.impl_getWindows();
-                                    }
-                                });
-                while(iter.hasNext()) {
-                    Window w = iter.next();
-                    if (w instanceof ContextMenu && !(contextMenu == w)) {
-                        Window ownerWin = ((ContextMenu)w).getOwnerWindow();
-                        if (contextMenu == ownerWin && ownerWin.isShowing()) {
-                            return;
-                        }
-                        
-                    }
-                    
-                }
                 requestFocus();
             }
         });
--- a/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/FXVKSkin.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/FXVKSkin.java	Wed Jun 19 09:18:39 2013 +1200
@@ -29,8 +29,6 @@
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.lang.reflect.Field;
-import java.security.AccessController;
-import java.security.PrivilegedAction;
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -138,28 +136,6 @@
         }
     }
 
-
-    /**
-     * If true, places the virtual keyboard(s) in a new root wrapper
-     * on the scene instead of in a popup. The children of the wrapper
-     * are the original root container and a Group of one or more
-     * keyboards.
-     *
-     * This is suitable for a fullscreen application that does not use
-     * dialogs with text input controls.
-     *
-     * The root wrapper pans up/down automatically as needed to keep
-     * the focused input control visible, and allows the user to drag
-     * up/down with mouse or touch.
-     */
-    private final static boolean inScene =
-        AccessController.doPrivileged(new PrivilegedAction<Boolean>() {
-            @Override public Boolean run() {
-                String value = System.getProperty("com.sun.javafx.fxvkContainerType");
-                return ("inscene".equalsIgnoreCase(value));
-            }
-    });
-
     private final static boolean USE_SECONDARY_POPUP = false;
 
     private static Region oldRoot;
@@ -204,13 +180,6 @@
         });
     }
 
-    private static Boolean enableCaching = AccessController.doPrivileged(
-    new PrivilegedAction<Boolean>() {
-        @Override public Boolean run() {
-            return Boolean.getBoolean("com.sun.javafx.scene.control.skin.FXVK.cache");
-        }
-    });
-
     private static void startSlideIn() {
         slideOutTimeline.stop();
         winY.set(vkPopup.getY());
--- a/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/Utils.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/Utils.java	Wed Jun 19 09:18:39 2013 +1200
@@ -547,195 +547,6 @@
         }
     }
 
-
-    /*    private static Object KERNING;
-       private static Object KERNING_ON;
-       private static Object LIGATURES;
-       private static Object LIGATURES_ON;
-       private static Object TRACKING;
-
-       static {
-       try {
-       KERNING = TextAttribute.class.getField("KERNING").get(null);
-       KERNING_ON = TextAttribute.class.getField("KERNING_ON").get(null);
-       LIGATURES = TextAttribute.class.getField("LIGATURES").get(null);
-       LIGATURES_ON = TextAttribute.class.getField("LIGATURES_ON").get(null);
-       TRACKING = TextAttribute.class.getField("TRACKING").get(null);
-       }
-       catch (Exception e) {
-       // running on 1.5
-       KERNING = KERNING_ON = LIGATURES = LIGATURES_ON = TRACKING = "unsupported";
-       }
-       }
-
-       private static FontRenderContext DEFAULT_FRC = new FontRenderContext(null, false, false);
-
-       private Utils() {}
-
-       static FontMetrics getFontMetrics(Font font) {
-       return getFontMetrics(font, DEFAULT_FRC);
-       }
-
-       static double computeLineHeight(Font font) {
-       if (font == null) return 0;
-       FontMetrics metrics = getFontMetrics(font, DEFAULT_FRC);
-       return metrics.getMaxAscent() + metrics.getMaxDescent();
-       }
-
-       static double computeXHeight(Font font) {
-       if (font == null) return 0;
-       return font.createGlyphVector(DEFAULT_FRC, "x").getGlyphMetrics(0).getBounds2D().getHeight();
-       }
-
-       // computes an offset from the baseline that would be the location of
-       // the center of the font. basically, this is where strikthrough would
-       // happen
-       static double computeCenterline(Font font) {
-       FontMetrics metrics = getFontMetrics(font, DEFAULT_FRC);
-       return metrics.getAscent() / 2;
-       }*/
-
-    /**
-     * Computes the width of the string if displayed with a default font
-     * render context (typically useful for display but not for printing).
-     * Nodes in the scene graph don't have a way to fetch the font render
-     * context, and computation of string widths typically happens outside
-     * of a paint cycle (since the scene graph is a retained mode API and not
-     * an immediate mode API).
-     *
-     * @param font this is an AWT font because I cannot refer to the fx font
-     *        from this java file.
-     * @param string
-     * @return
-     */
-    /*    static double computeStringWidth(Font font, String string) {
-       if (string == null || string.equals("")) return 0;
-       FontMetrics metrics = getFontMetrics(font, DEFAULT_FRC);
-       return computeStringWidth(metrics, string);
-       }
-
-       static double computeStringWidth(FontMetrics metrics, String string) {
-       if (string == null || string.equals("")) return 0;
-       return metrics.stringWidth(string);
-       }
-
-       private static boolean contains(Map map, Object key, Object value) {
-       Object o = map.get(key);
-       return o != null && o.equals(value);
-       }
-
-       private static boolean fontDesignMetricsInitialized = false;
-       private static Class<?> fontDesignMetricsClass;
-       private static Method getFontDesignMetrics;
-       private static Constructor newFontDesignMetrics;
-
-       private static synchronized FontMetrics getFontMetrics(final Font font, final FontRenderContext frc) {
-       FontMetrics rv = null;
-       if (! fontDesignMetricsInitialized) {
-       AccessController.doPrivileged(
-       new PrivilegedAction<Void>() {
-       public Void run() {
-       fontDesignMetricsInitialized = true;
-       try {
-       fontDesignMetricsClass =
-       Class.forName("sun.font.FontDesignMetrics", true, null);
-       } catch (ClassNotFoundException e) {
-       return null;
-       }
-       try {
-       newFontDesignMetrics =
-       fontDesignMetricsClass.getConstructor(Font.class,
-       FontRenderContext.class);
-       getFontDesignMetrics =
-       fontDesignMetricsClass.getMethod("getMetrics",
-       Font.class, FontRenderContext.class);
-       } catch (NoSuchMethodException ignore) {
-       }
-       return null;
-       }
-       });
-       }
-       try {
-       if (getFontDesignMetrics != null) {
-       rv = (FontMetrics) getFontDesignMetrics.invoke(null, font, frc);
-       } else if (newFontDesignMetrics != null) {
-       rv = (FontMetrics) newFontDesignMetrics.newInstance(font, frc);
-       }
-       } catch(IllegalAccessException ignore) {
-       } catch(InstantiationException ignore) {
-       } catch(InvocationTargetException exception) {
-       if (exception.getTargetException() instanceof RuntimeException) {
-       throw (RuntimeException) exception.getTargetException();
-       }
-       }
-       if (rv == null) {
-       //can not create FontDesignMetrics. Fall back to toolkit's fontMetrics.
-       rv = Toolkit.getDefaultToolkit().getFontMetrics(font);
-       }
-       return rv;
-       }*/
-
-    // ---- begin code included from SwingUtilities2 ----
-    // This code is present in sun.swing.SwingUtilities2 in JRE 1.6 or higher, but
-    // was copied into our codebase to handle running on Java 1.5.  Arguably we
-    // shouldn't be depending on sun.* APIs if at all possible anyway.
-
-    /**
-     * Indic, Thai, and surrogate char values require complex
-     * text layout and cursor support.
-     *
-     * @param ch character to be tested
-     * @return <tt>true</tt> if TextLayout is required
-     */
-    /*    private static final boolean isComplexLayout(char ch) {
-       return (ch >= '\u0900' && ch <= '\u0D7F') || // Indic
-       (ch >= '\u0E00' && ch <= '\u0E7F') || // Thai
-       (ch >= '\u1780' && ch <= '\u17ff') || // Khmer
-       (ch >= '\uD800' && ch <= '\uDFFF');   // surrogate value range
-       }*/
-
-    /**
-     * Fast method to check that TextLayout is not required for the
-     * character.
-     * if returns <tt>true</tt> TextLayout is not required
-     * if returns <tt>false</tt> TextLayout might be required
-     *
-     * @param ch character to be tested
-     * @return <tt>true</tt> if TextLayout is not required
-     */
-    /*    private static final boolean isSimpleLayout(char ch) {
-       return ch < 0x590 || (0x2E00 <= ch && ch < 0xD800);
-       }*/
-
-    /**
-     * checks whether TextLayout is required to handle characters.
-     *
-     * @param text characters to be tested
-     * @param start start
-     * @param limit limit
-     * @return <tt>true</tt>  if TextLayout is required
-     *         <tt>false</tt> if TextLayout is not required
-     */
-    /*    public static final boolean isComplexLayout(char[] text, int start, int limit) {
-       boolean simpleLayout = true;
-       char ch;
-       for (int i = start; i < limit; ++i) {
-       ch = text[i];
-       if (isComplexLayout(ch)) {
-       return true;
-       }
-       if (simpleLayout) {
-       simpleLayout = isSimpleLayout(ch);
-       }
-       }
-       if (simpleLayout) {
-       return false;
-       } else {
-       return Bidi.requiresBidi(text, start, limit);
-       }
-       }*/
-    // ---- end code included from SwingUtilities2 ----
-
     private static boolean requiresComplexLayout(Font font, String string) {
         /*        Map attrs = font.getAttributes();
            if (contains(attrs, KERNING, KERNING_ON) ||
--- a/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/resources/ControlResources.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/resources/ControlResources.java	Wed Jun 19 09:18:39 2013 +1200
@@ -38,6 +38,10 @@
     // Do not cache the bundle here. It is cached by the ResourceBundle
     // class and may be updated if the default locale changes.
 
+    private ControlResources() {
+        // no-op
+    }
+
     /*
      * Look up a string in the properties file corresponding to the
      * default locale (i.e. the application's locale). If not found, the
--- a/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/resources/EmbeddedResources.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/com/sun/javafx/scene/control/skin/resources/EmbeddedResources.java	Wed Jun 19 09:18:39 2013 +1200
@@ -31,6 +31,10 @@
 
     private static ResourceBundle embeddedResourceBundle;
 
+    private EmbeddedResources() {
+        // no-op
+    }
+
     public static ResourceBundle getBundle() {
         if (embeddedResourceBundle == null) {
             embeddedResourceBundle = ResourceBundle.getBundle("com/sun/javafx/scene/control/skin/resources/embedded");
--- a/javafx-ui-controls/src/javafx/scene/control/SkinBase.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/src/javafx/scene/control/SkinBase.java	Wed Jun 19 09:18:39 2013 +1200
@@ -113,15 +113,6 @@
         
         // Default behavior for controls is to consume all mouse events
         consumeMouseEvents(true);
-        
-        // RT-28337: request layout on prefWidth / prefHeight changes
-        InvalidationListener prefSizeListener = new InvalidationListener() {
-            @Override public void invalidated(Observable o) {
-                control.requestLayout();
-            }
-        };
-        this.control.prefWidthProperty().addListener(prefSizeListener);
-        this.control.prefHeightProperty().addListener(prefSizeListener);
     }
     
     
--- a/javafx-ui-controls/test/javafx/scene/control/cell/ChoiceBoxTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/ChoiceBoxTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -29,6 +29,7 @@
 import javafx.collections.ObservableList;
 import javafx.scene.control.TableCell;
 import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
 import javafx.util.Callback;
 import javafx.util.StringConverter;
 import org.junit.Before;
@@ -161,6 +162,38 @@
         ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>(converter);
         assertNull(cell.getGraphic());
     }
+
+
+    /**************************************************************************
+     *
+     * Constructor tests for one-arg (varargs items) constructor
+     *
+     **************************************************************************/
+
+    @Test public void testConstructor_varargs_defaultStringConverterIsNotNull() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>(items);
+        assertNotNull(cell.getConverter());
+    }
+
+    @Test public void testConstructor_varargs_defaultStyleClass() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>(items);
+        assertTrue(cell.getStyleClass().contains("choice-box-table-cell"));
+    }
+
+    @Test public void testConstructor_varargs_defaultGraphicIsACheckBox() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>(items);
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void testConstructor_varargs_itemsListIsNotNullOrEmpty() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>(items);
+        assertNotNull(cell.getItems());
+        assertEquals(3, cell.getItems().size());
+    }
     
     
     /**************************************************************************
@@ -214,131 +247,174 @@
     }
 
 
-//    /**************************************************************************
-//     *
-//     * editing tests
-//     *
-//     **************************************************************************/
-//
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isEmpty() {
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isNotEmpty() {
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTableCell<Object> cell = new ChoiceBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+    /**************************************************************************
+     *
+     * editing tests
+     *
+     **************************************************************************/
+
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TableView tableView = new TableView();
+        tableView.setEditable(false);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isEmpty() {
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_tableViewEditableIsTrue_tableColumnIsNull() {
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.setEditable(true);
+        cell.updateTableView(tableView);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        ChoiceBoxTableCell<Object, Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isNotEmpty() {
+        TableView tableView = new TableView();
+        tableView.setEditable(false);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isNotEmpty() {
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTableCell<Object,Object> cell = new ChoiceBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }
--- a/javafx-ui-controls/test/javafx/scene/control/cell/ChoiceBoxTreeTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/ChoiceBoxTreeTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -27,8 +27,10 @@
 
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeTableCell;
 import javafx.scene.control.TreeTableColumn;
+import javafx.scene.control.TreeTableView;
 import javafx.util.Callback;
 import javafx.util.StringConverter;
 import org.junit.Before;
@@ -161,6 +163,38 @@
         ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>(converter);
         assertNull(cell.getGraphic());
     }
+
+
+    /**************************************************************************
+     *
+     * Constructor tests for one-arg (varargs items) constructor
+     *
+     **************************************************************************/
+
+    @Test public void testConstructor_varargs_defaultStringConverterIsNotNull() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>(items);
+        assertNotNull(cell.getConverter());
+    }
+
+    @Test public void testConstructor_varargs_defaultStyleClass() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>(items);
+        assertTrue(cell.getStyleClass().contains("choice-box-tree-table-cell"));
+    }
+
+    @Test public void testConstructor_varargs_defaultGraphicIsACheckBox() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>(items);
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void testConstructor_varargs_itemsListIsNotNullOrEmpty() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>(items);
+        assertNotNull(cell.getItems());
+        assertEquals(3, cell.getItems().size());
+    }
     
     
     /**************************************************************************
@@ -214,131 +248,174 @@
     }
 
 
-//    /**************************************************************************
-//     *
-//     * editing tests
-//     *
-//     **************************************************************************/
-//
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isEmpty() {
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isNotEmpty() {
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ChoiceBoxTreeTableCell<Object> cell = new ChoiceBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+    /**************************************************************************
+     *
+     * editing tests
+     *
+     **************************************************************************/
+
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(false);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isEmpty() {
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_tableViewEditableIsTrue_tableColumnIsNull() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.setEditable(true);
+        cell.updateTreeTableView(tableView);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        ChoiceBoxTreeTableCell<Object, Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isNotEmpty() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(false);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isNotEmpty() {
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ChoiceBoxTreeTableCell<Object,Object> cell = new ChoiceBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }
--- a/javafx-ui-controls/test/javafx/scene/control/cell/ComboBoxTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/ComboBoxTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -140,11 +140,17 @@
         ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
         assertNull(cell.getGraphic());
     }
+
+    @Test public void testConstructor_noArgs_itemsListIsNotNull() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+        assertNotNull(cell.getItems());
+        assertTrue(cell.getItems().isEmpty());
+    }
     
     
     /**************************************************************************
      * 
-     * Constructor tests for one-arg constructor
+     * Constructor tests for one-arg (converter, no varargs items) constructor
      * 
      **************************************************************************/
     
@@ -162,6 +168,65 @@
         ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(converter);
         assertNull(cell.getGraphic());
     }
+
+    @Test public void testConstructor_converter_itemsListIsNotNull() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(converter);
+        assertNotNull(cell.getItems());
+        assertTrue(cell.getItems().isEmpty());
+    }
+
+    /**************************************************************************
+     *
+     * Constructor tests for one-arg (varargs items) constructor
+     *
+     **************************************************************************/
+
+    @Test public void testConstructor_varargs_defaultStringConverterIsNotNull() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNotNull(cell.getConverter());
+    }
+
+    @Test public void testConstructor_varargs_defaultStyleClass() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertTrue(cell.getStyleClass().contains("combo-box-table-cell"));
+    }
+
+    @Test public void testConstructor_varargs_defaultGraphicIsACheckBox() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void testConstructor_varargs_itemsListIsNotNullOrEmpty() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNotNull(cell.getItems());
+        assertEquals(3, cell.getItems().size());
+    }
+
+
+    /**************************************************************************
+     *
+     * Property tests
+     *
+     **************************************************************************/
+
+    @Test public void testComboBoxEditable_falseByDefault() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+        assertFalse(cell.isComboBoxEditable());
+    }
+
+    @Test public void testComboBoxEditable_setter() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+
+        cell.setComboBoxEditable(true);
+        assertTrue(cell.isComboBoxEditable());
+
+        cell.setComboBoxEditable(false);
+        assertFalse(cell.isComboBoxEditable());
+    }
     
     
     /**************************************************************************
@@ -215,131 +280,174 @@
     }
 
 
-//    /**************************************************************************
-//     *
-//     * editing tests
-//     *
-//     **************************************************************************/
-//
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isEmpty() {
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isNotEmpty() {
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTableCell<Object> cell = new ComboBoxTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+    /**************************************************************************
+     *
+     * editing tests
+     *
+     **************************************************************************/
+
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TableView tableView = new TableView();
+        tableView.setEditable(false);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isEmpty() {
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_tableViewEditableIsTrue_tableColumnIsNull() {
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.setEditable(true);
+        cell.updateTableView(tableView);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isNotEmpty() {
+        TableView tableView = new TableView();
+        tableView.setEditable(false);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isNotEmpty() {
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTableCell<Object,Object> cell = new ComboBoxTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }
--- a/javafx-ui-controls/test/javafx/scene/control/cell/ComboBoxTreeTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/ComboBoxTreeTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -27,8 +27,10 @@
 
 import javafx.collections.FXCollections;
 import javafx.collections.ObservableList;
+import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeTableCell;
 import javafx.scene.control.TreeTableColumn;
+import javafx.scene.control.TreeTableView;
 import javafx.util.Callback;
 import javafx.util.StringConverter;
 import org.junit.Before;
@@ -161,6 +163,60 @@
         ComboBoxTreeTableCell<Object, Object> cell = new ComboBoxTreeTableCell<>(converter);
         assertNull(cell.getGraphic());
     }
+
+
+    /**************************************************************************
+     *
+     * Constructor tests for one-arg (varargs items) constructor
+     *
+     **************************************************************************/
+
+    @Test public void testConstructor_varargs_defaultStringConverterIsNotNull() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNotNull(cell.getConverter());
+    }
+
+    @Test public void testConstructor_varargs_defaultStyleClass() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertTrue(cell.getStyleClass().contains("combo-box-table-cell"));
+    }
+
+    @Test public void testConstructor_varargs_defaultGraphicIsACheckBox() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void testConstructor_varargs_itemsListIsNotNullOrEmpty() {
+        Object[] items = new Object[] { "Item 1", "Item 2", "Item 3" };
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>(items);
+        assertNotNull(cell.getItems());
+        assertEquals(3, cell.getItems().size());
+    }
+
+
+    /**************************************************************************
+     *
+     * Property tests
+     *
+     **************************************************************************/
+
+    @Test public void testComboBoxEditable_falseByDefault() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+        assertFalse(cell.isComboBoxEditable());
+    }
+
+    @Test public void testComboBoxEditable_setter() {
+        ComboBoxTableCell<Object, Object> cell = new ComboBoxTableCell<>();
+
+        cell.setComboBoxEditable(true);
+        assertTrue(cell.isComboBoxEditable());
+
+        cell.setComboBoxEditable(false);
+        assertFalse(cell.isComboBoxEditable());
+    }
     
     
     /**************************************************************************
@@ -214,131 +270,174 @@
     }
 
 
-//    /**************************************************************************
-//     *
-//     * editing tests
-//     *
-//     **************************************************************************/
-//
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isEmpty() {
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsFalse_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(false);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_listViewIsNull_isNotEmpty() {
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_listViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TableView listView = new TableView();
-//        listView.setEditable(true);
-//        ComboBoxTreeTableCell<Object> cell = new ComboBoxTreeTableCell<>();
-//        cell.updateTableView(listView);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+    /**************************************************************************
+     *
+     * editing tests
+     *
+     **************************************************************************/
+
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(false);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isEmpty() {
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_tableViewEditableIsTrue_tableColumnIsNull() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.setEditable(true);
+        cell.updateTreeTableView(tableView);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        ComboBoxTreeTableCell<Object, Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isNotEmpty() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(false);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableViewIsNull_isNotEmpty() {
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        ComboBoxTreeTableCell<Object,Object> cell = new ComboBoxTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }
--- a/javafx-ui-controls/test/javafx/scene/control/cell/TextFieldTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/TextFieldTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -25,6 +25,7 @@
 
 package javafx.scene.control.cell;
 
+import javafx.collections.FXCollections;
 import javafx.scene.control.TableCell;
 import javafx.scene.control.TableColumn;
 import javafx.scene.control.TableView;
@@ -214,131 +215,164 @@
      *
      **************************************************************************/
 
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TableView tableView = new TableView();
+        tableView.setEditable(false);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isEmpty() {
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView();
+        tableView.setEditable(true);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+//    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isEmpty() {
+//        TableColumn tc = new TableColumn();
+//        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+//        tableView.getColumns().add(tc);
+//        tableView.setEditable(true);
 //        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
+//        cell.updateTableView(tableView);
+//        cell.updateIndex(0);
+//        cell.updateTableColumn(tc);
+//        cell.setEditable(true);
+//
+//        tableView.edit(0, tc);
 //        assertFalse(cell.isEditing());
 //        assertNull(cell.getGraphic());
 //    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsFalse_isEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(false);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateTableColumn(tableColumn);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isEmpty() {
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_isEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateTableColumn(tableColumn);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableColumn(tableColumn);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsFalse_isNotEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(false);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateTableColumn(tableColumn);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isNotEmpty() {
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_isNotEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateTableColumn(tableColumn);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTableColumn(tableColumn);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TableView tableView = new TableView<>();
-//        tableView.setEditable(true);
-//        tableView.getItems().add("TEST");
-//        TableColumn<Object,Object> tableColumn = new TableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
-//        cell.updateTableView(tableView);
-//        cell.updateTableColumn(tableColumn);
-////        cell.updateItem("TEST", false);
-//        cell.updateIndex(0);
-//
-////        cell.startEdit();
-//        tableView.edit(0, tableColumn);
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableColumnEditableIsFalse_isNotEmpty() {
+        TableColumn<Object,Object> tableColumn = new TableColumn<>();
+        tableColumn.setEditable(false);
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tableColumn);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableColumn(tableColumn);
+        cell.updateTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isNotEmpty() {
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TableColumn tc = new TableColumn();
+        TableView tableView = new TableView(FXCollections.observableArrayList("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTableCell<Object,Object> cell = new TextFieldTableCell<>();
+        cell.updateTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }
--- a/javafx-ui-controls/test/javafx/scene/control/cell/TextFieldTreeTableCellTest.java	Mon Jun 17 19:31:36 2013 -0400
+++ b/javafx-ui-controls/test/javafx/scene/control/cell/TextFieldTreeTableCellTest.java	Wed Jun 19 09:18:39 2013 +1200
@@ -25,6 +25,7 @@
 
 package javafx.scene.control.cell;
 
+import javafx.collections.FXCollections;
 import javafx.scene.control.TreeItem;
 import javafx.scene.control.TreeTableCell;
 import javafx.scene.control.TreeTableColumn;
@@ -209,144 +210,170 @@
     }
 
 
-//    /**************************************************************************
-//     *
-//     * editing tests
-//     *
-//     **************************************************************************/
-//
-//    // --- is Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsFalse_isEmpty() {
-//        TreeItem root = new TreeItem("Root");
-//        TreeTableView treeView = new TreeTableView(root);
-//
-//        TreeTableColumn<Object,Object> tableColumn = new TreeTableColumn<>();
-//        tableColumn.setEditable(false);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableColumn(tableColumn);
-//        cell.updateTreeTableView(treeView);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isEmpty() {
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_isEmpty() {
-//        TreeTableColumn<Object,Object> tableColumn = new TreeTableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableColumn(tableColumn);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isEmpty() {
-//        TreeTableColumn<Object,Object> tableColumn = new TreeTableColumn<>();
-//        tableColumn.setEditable(true);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.setEditable(true);
-//        cell.updateTreeTableColumn(tableColumn);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    // --- is Not Empty
-//    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(false);
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_tableColumnEditableIsFalse_isNotEmpty() {
-//        TreeItem root = new TreeItem("Root");
-//        TreeTableView treeView = new TreeTableView(root);
-//
-//        TreeTableColumn<Object,Object> tableColumn = new TreeTableColumn<>();
-//        tableColumn.setEditable(false);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableView(treeView);
-//        cell.updateTreeTableColumn(tableColumn);
-//        cell.updateItem("TEST", false);
-//
-//        cell.startEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
-//
-//    @Test(expected = NullPointerException.class)
-//    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isNotEmpty() {
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateItem("TEST", false);
-//        cell.setEditable(true);
-//        cell.startEdit();
-//    }
-//
-//    @Test public void test_startEdit_treeViewEditableIsTrue_isNotEmpty() {
-//        TreeItem root = new TreeItem("Root");
-//        TreeTableView treeView = new TreeTableView(root);
-//        treeView.setEditable(true);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableView(treeView);
-//        cell.updateIndex(0);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    @Test public void test_startEdit_treeViewEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
-//        TreeItem root = new TreeItem("Root");
-//        TreeTableView treeView = new TreeTableView(root);
-//        treeView.setEditable(true);
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableView(treeView);
-//        cell.setEditable(true);
-//        cell.updateIndex(0);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//    }
-//
-//    // --- cancel edit
-//    @Test public void test_cancelEdit() {
-//        TreeItem root = new TreeItem("Root");
-//        TreeTableView treeView = new TreeTableView(root);
-//        treeView.setEditable(true);
-//        TreeTableColumn col = new TreeTableColumn();
-//        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
-//        cell.updateTreeTableView(treeView);
-//        cell.updateTreeTableColumn(col);
-//        cell.updateIndex(0);
-//
-//        cell.startEdit();
-//        assertTrue(cell.isEditing());
-//        assertNotNull(cell.getGraphic());
-//
-//        cell.cancelEdit();
-//        assertFalse(cell.isEditing());
-//        assertNull(cell.getGraphic());
-//    }
+    /**************************************************************************
+     *
+     * editing tests
+     *
+     **************************************************************************/
+
+    // --- is Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isEmpty() {
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsFalse_isEmpty() {
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(false);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isEmpty() {
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView();
+        tableView.setEditable(true);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    //    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isEmpty() {
+    //        TreeTableColumn tc = new TreeTableColumn();
+    //        TreeTableView tableView = new TreeTableView(FXCollections.observableArrayList("TEST"));
+    //        tableView.getColumns().add(tc);
+    //        tableView.setEditable(true);
+    //        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+    //        cell.updateTreeTableView(tableView);
+    //        cell.updateIndex(0);
+    //        cell.updateTreeTableColumn(tc);
+    //        cell.setEditable(true);
+    //
+    //        tableView.edit(0, tc);
+    //        assertFalse(cell.isEditing());
+    //        assertNull(cell.getGraphic());
+    //    }
+
+    // --- is Not Empty
+    @Test public void test_startEdit_cellEditableIsFalse_isNotEmpty() {
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(false);
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableColumnEditableIsFalse_isNotEmpty() {
+        TreeTableColumn<Object,Object> tableColumn = new TreeTableColumn<>();
+        tableColumn.setEditable(false);
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tableColumn);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableColumn(tableColumn);
+        cell.updateTreeTableView(tableView);
+        cell.updateItem("TEST", false);
+
+        cell.startEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test(expected = NullPointerException.class)
+    public void test_startEdit_cellEditableIsTrue_tableColumnIsNull_isNotEmpty() {
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateItem("TEST", false);
+        cell.setEditable(true);
+        cell.startEdit();
+    }
+
+    @Test public void test_startEdit_tableViewEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    @Test public void test_startEdit_tableColumnEditableIsTrue_cellEditableIsTrue_isNotEmpty() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+    }
+
+    // --- cancel edit
+    @Test public void test_cancelEdit_usingCellCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        cell.cancelEdit();
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
+
+    @Test public void test_cancelEdit_usingTableCancelEdit() {
+        TreeTableColumn tc = new TreeTableColumn();
+        TreeTableView tableView = new TreeTableView(new TreeItem("TEST"));
+        tableView.getColumns().add(tc);
+        tableView.setEditable(true);
+        TextFieldTreeTableCell<Object,Object> cell = new TextFieldTreeTableCell<>();
+        cell.updateTreeTableView(tableView);
+        cell.updateIndex(0);
+        cell.updateTreeTableColumn(tc);
+        cell.setEditable(true);
+
+        tableView.edit(0, tc);
+        assertTrue(cell.isEditing());
+        assertNotNull(cell.getGraphic());
+
+        tableView.edit(-1, null);
+        assertFalse(cell.isEditing());
+        assertNull(cell.getGraphic());
+    }
 }