gridsort: grid control related unit tests (first set, more to come)

6 files changed, 1080 insertions, 6 deletions

diff --git a/toolkit/qa/complex/toolkit/GridControl.java b/toolkit/qa/complex/toolkit/GridControl.java
new file mode 100755
index 000000000000..9cefa51aae30
--- /dev/null
+++ b/toolkit/qa/complex/toolkit/GridControl.java
@@ -0,0 +1,521 @@
+/*************************************************************************
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2011 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ *************************************************************************/
+
+package complex.toolkit;
+
+import com.sun.star.awt.grid.XGridColumn;
+import com.sun.star.awt.grid.XGridColumnModel;
+import com.sun.star.awt.grid.XGridDataModel;
+import com.sun.star.awt.grid.XMutableGridDataModel;
+import com.sun.star.awt.grid.XSortableMutableGridDataModel;
+import com.sun.star.beans.XPropertySet;
+import com.sun.star.container.ContainerEvent;
+import com.sun.star.container.XContainerListener;
+import com.sun.star.lang.EventObject;
+import com.sun.star.lang.IndexOutOfBoundsException;
+import com.sun.star.lang.XComponent;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.uno.Exception;
+import com.sun.star.uno.UnoRuntime;
+import com.sun.star.uno.XComponentContext;
+import com.sun.star.uno.XInterface;
+import com.sun.star.util.XCloneable;
+import complex.toolkit.awtgrid.DummyColumn;
+import complex.toolkit.awtgrid.TMutableGridDataModel;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import org.junit.AfterClass;
+import org.junit.BeforeClass;
+import org.junit.Test;
+import static org.junit.Assert.*;
+import org.openoffice.test.OfficeConnection;
+
+/** is a unit test for the grid control related implementations
+ * @author frank.schoenheit@sun.com
+ */
+public class GridControl
+{
+    // -----------------------------------------------------------------------------------------------------------------
+    public GridControl()
+    {
+        m_context = m_connection.getComponentContext();
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private static void impl_dispose( final Object... i_components )
+    {
+        for ( int i=0; i<i_components.length; ++i )
+        {
+            if ( i_components[i] != null )
+            {
+                final XComponent component = UnoRuntime.queryInterface( XComponent.class, i_components[i] );
+                component.dispose();
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private void impl_recreateGridModel() throws Exception
+    {
+        impl_dispose( m_gridControlModel, m_columnModel, m_dataModel );
+
+        // create a grid control model, and ensure it has a proper data and column model already
+        m_gridControlModel = UnoRuntime.queryInterface( XPropertySet.class,
+            createInstance( "com.sun.star.awt.grid.UnoControlGridModel" ) );
+        assertNotNull( "grid control model does not provide XPropertySet interface", m_gridControlModel );
+
+        // ensure that the model has default column/data models
+        m_columnModel = UnoRuntime.queryInterface( XGridColumnModel.class, m_gridControlModel.getPropertyValue( "ColumnModel" ) );
+        assertNotNull( "the control model is expected to have an initial column model", m_columnModel );
+        final XGridDataModel dataModel = UnoRuntime.queryInterface( XGridDataModel.class, m_gridControlModel.getPropertyValue( "GridDataModel" ) );
+        assertNotNull( "the control model is expected to have an initial data model", dataModel );
+        m_dataModel = UnoRuntime.queryInterface( XSortableMutableGridDataModel.class,
+            dataModel );
+        assertNotNull( "the out-of-the-box data model should be mutable and sortable", m_dataModel );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    @Test
+    public void testGridControlCloning() throws Exception
+    {
+        impl_recreateGridModel();
+
+        // give the test something to compare, actually
+        XGridColumnModel columnModel = UnoRuntime.queryInterface( XGridColumnModel.class,
+            m_gridControlModel.getPropertyValue( "ColumnModel" ) );
+        columnModel.setDefaultColumns( 10 );
+
+        // clone the grid model
+        final XCloneable cloneable = UnoRuntime.queryInterface( XCloneable.class, m_gridControlModel );
+        assertNotNull( "all UnoControlModel's are expected to be cloneable", cloneable );
+
+        final XInterface clone = cloneable.createClone();
+        final XPropertySet clonedProps = UnoRuntime.queryInterface( XPropertySet.class, clone );
+
+        // TODO: check all those generic properties for equality
+
+        // the data model and the column model should have been cloned, too
+        // in particular, the clone should not share the sub models with the orignal
+        final XMutableGridDataModel originalDataModel = UnoRuntime.queryInterface( XMutableGridDataModel.class,
+            m_gridControlModel.getPropertyValue( "GridDataModel" ) );
+        final XMutableGridDataModel clonedDataModel = UnoRuntime.queryInterface( XMutableGridDataModel.class,
+            clonedProps.getPropertyValue( "GridDataModel" ) );
+        assertFalse( "data model should not be shared after cloning", UnoRuntime.areSame( originalDataModel, clonedDataModel ) );
+        impl_assertEquality( originalDataModel, clonedDataModel );
+
+        final XGridColumnModel originalColumnModel = columnModel;
+        final XGridColumnModel clonedColumnModel = UnoRuntime.queryInterface( XGridColumnModel.class,
+            clonedProps.getPropertyValue( "ColumnModel" ) );
+        assertFalse( "column model should not be shared after cloning", UnoRuntime.areSame( originalColumnModel, clonedColumnModel ) );
+        impl_assertEquality( originalColumnModel, clonedColumnModel );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    @Test
+    public void testDisposal() throws Exception
+    {
+        impl_recreateGridModel();
+
+        final int columnCount = 3;
+        m_columnModel.setDefaultColumns( columnCount );
+
+        // add disposal listeners to all columns so far
+        final XGridColumn[] columns = m_columnModel.getColumns();
+        assertEquals( "creating default columns resulted in unexpected column count", columnCount, columns.length );
+        final DisposeListener[] columnListeners = new DisposeListener[columnCount];
+        for ( int i=0; i<columnCount; ++i )
+            columnListeners[i] = new DisposeListener( columns[i] );
+
+        // add another column, and check that upon removal, it is disposed
+        final int newColumnIndex = m_columnModel.addColumn( m_columnModel.createColumn() );
+        final DisposeListener columnListener = new DisposeListener( m_columnModel.getColumn( newColumnIndex ) );
+        m_columnModel.removeColumn( newColumnIndex );
+        assertTrue( "explicit column removal is expected to dispose the column", columnListener.isDisposed() );
+
+        // by definition, the grid control model is the owner of both the column and the data model. So, setting
+        // a new column/data model should implicitly dispose the old models
+        final DisposeListener oldDataModelListener = new DisposeListener( m_dataModel );
+        final DisposeListener oldColumnModelListener = new DisposeListener( m_columnModel );
+
+        final Object newDataModel = createInstance( "com.sun.star.awt.grid.DefaultGridDataModel" );
+        final Object newColumnModel = createInstance( "com.sun.star.awt.grid.DefaultGridColumnModel" );
+        final DisposeListener newDataModelListener = new DisposeListener( newDataModel );
+        final DisposeListener newColumnModelListener = new DisposeListener( newColumnModel );
+
+        m_gridControlModel.setPropertyValue( "GridDataModel", newDataModel );
+        assertTrue( "setting a new data model failed", impl_areSameInterface( newDataModel, m_gridControlModel.getPropertyValue( "GridDataModel" ) ) );
+        m_gridControlModel.setPropertyValue( "ColumnModel", newColumnModel );
+        assertTrue( "setting a new column model failed", impl_areSameInterface( newColumnModel, m_gridControlModel.getPropertyValue( "ColumnModel" ) ) );
+
+        assertTrue( "old data model has not been disposed", oldDataModelListener.isDisposed() );
+        assertTrue( "old column model has not been disposed", oldColumnModelListener.isDisposed() );
+        for ( int i=0; i<columnCount; ++i )
+            assertTrue( "column no. " + i + " has not been disposed", columnListeners[i].isDisposed() );
+
+        // the same holds if the grid control model itself is disposed - it should dispose the depending models, too
+        assertFalse( "new data model is already disposed - this is unexpected", newDataModelListener.isDisposed() );
+        assertFalse( "new column model is already disposed - this is unexpected", newColumnModelListener.isDisposed() );
+        impl_dispose( m_gridControlModel );
+        assertTrue( "new data model is not disposed after disposing the grid column model", newDataModelListener.isDisposed() );
+        assertTrue( "new column model is not disposed after disposing the grid column model", newColumnModelListener.isDisposed() );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    /**
+     * tests various aspects of the <code>XMutableGridDataModel</code> interface
+     */
+    @Test
+    public void testMutableGridDataModel() throws Exception
+    {
+        impl_recreateGridModel();
+
+        TMutableGridDataModel test = new TMutableGridDataModel( m_dataModel );
+        test.testAddRow();
+        test.testAddRows();
+        test.testRemoveRow();
+        test.testRemoveAllRows();
+        test.testUpdateCellData();
+        test.testUpdateRowData();
+        test.testUpdateRowHeading();
+        test.cleanup();
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    @Test
+    public void testGridColumnModel() throws Exception
+    {
+        impl_recreateGridModel();
+
+        ColumnModelListener listener = new ColumnModelListener();
+        m_columnModel.addContainerListener( listener );
+
+        // insert default columns into the previously empty model, ensure we get the right notifications
+        final int defaultColumnsCount = 3;
+        m_columnModel.setDefaultColumns( defaultColumnsCount );
+        impl_assertColumnModelConsistency();
+        List< ContainerEvent > events = listener.assertExclusiveInsertionEvents();
+        listener.reset();
+        assertEquals( "wrong number of events fired by setDefaulColumns", defaultColumnsCount, events.size() );
+        for ( int i=0; i<defaultColumnsCount; ++i )
+        {
+            final ContainerEvent event = events.get(i);
+            final int index = impl_assertInteger( event.Accessor );
+            assertEquals( "unexpected Accessor value in insert notification", i, index );
+            assertTrue( "wrong column object notified in insert notification",
+                impl_areSameInterface( event.Element, m_columnModel.getColumn(i) ) );
+        }
+
+        // insert some more default columns, ensure that all previously existing columns are removed
+        final int moreDefaultColumnsCount = 5;
+        m_columnModel.setDefaultColumns( moreDefaultColumnsCount );
+        impl_assertColumnModelConsistency();
+        assertEquals( "setting default columns is expected to remove all previously existing columns",
+            moreDefaultColumnsCount, m_columnModel.getColumnCount() );
+
+        // in this situation, both removal and insertion events have been notified
+        final List< ContainerEvent > removalEvents = listener.getRemovalEvents();
+        final List< ContainerEvent > insertionEvents = listener.getInsertionEvents();
+        listener.reset();
+
+        // for the removal events, check the indexes
+        assertEquals( "wrong number of columns removed (or notified) upon setting default columns",
+            defaultColumnsCount, removalEvents.size() );
+        for ( int i=0; i<removalEvents.size(); ++i )
+        {
+            final ContainerEvent event = removalEvents.get(i);
+            final int removedIndex = impl_assertInteger( event.Accessor );
+
+            // The implementation is allowed to remove the columns from the beginning, in which case the
+            // index of the removed column must always be 0, since e.g. the second column has index 0
+            // after the first column (which previously had index 0) had been removed.
+            // Alternatively, the implementation is allowed to remove columns from the end, which means
+            // that the column index given in the event is steadily increasing.
+            assertTrue( "unexpected column removal event column index",
+                ( removedIndex == 0 ) || ( removedIndex == removalEvents.size() - 1 - i ) );
+        }
+
+        // for the insertion events, check the indexes as well
+        assertEquals( "wrong number of insertion events when setting default columns over existing columns",
+            moreDefaultColumnsCount, insertionEvents.size() );
+        for ( int i=0; i<insertionEvents.size(); ++i )
+        {
+            final ContainerEvent event = insertionEvents.get(i);
+            final int index = impl_assertInteger( event.Accessor );
+            assertEquals( i, index );
+        }
+
+        // okay, remove all those columns
+        while ( m_columnModel.getColumnCount() != 0 )
+        {
+            final int columnCount = m_columnModel.getColumnCount();
+            final int removeColumnIndex = (new Random()).nextInt( columnCount );
+            m_columnModel.removeColumn( removeColumnIndex );
+            events = listener.assertExclusiveRemovalEvents();
+            listener.reset();
+            assertEquals( "removing a single column should notify a single event", 1, events.size() );
+            final ContainerEvent event = events.get(0);
+            final int removalIndex = impl_assertInteger( event.Accessor );
+            assertEquals( "removing an arbitrary column does not notify the proper accessor",
+                removeColumnIndex, removalIndex );
+        }
+
+        // calling addColumn with a column not created by the given model/implementatoion should not succeed
+        boolean caughtExpected = false;
+        try
+        {
+            m_columnModel.addColumn( new DummyColumn() );
+        }
+        catch( final com.sun.star.lang.IllegalArgumentException e )
+        {
+            assertTrue( impl_areSameInterface( e.Context, m_columnModel ) );
+            caughtExpected = true;
+        }
+        assertTrue( "adding a dummy (self-implemented) grid column to the model should not succeed", caughtExpected );
+
+        // adding a single column to the end should succeed, properly notify, and still be consistent
+        final XGridColumn newColumn = m_columnModel.createColumn();
+        m_columnModel.addColumn( newColumn );
+        impl_assertColumnModelConsistency();
+        events = listener.assertExclusiveInsertionEvents();
+        listener.reset();
+        assertEquals( "addColumn notifies the wrong number of insertion events", 1, events.size() );
+        final int insertionIndex = impl_assertInteger( events.get(0).Accessor );
+        assertEquals( insertionIndex, newColumn.getIndex() );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private int impl_assertInteger( final Object i_object )
+    {
+        assertTrue( i_object instanceof Integer );
+        return ((Integer)i_object).intValue();
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private void impl_assertColumnModelConsistency() throws IndexOutOfBoundsException
+    {
+        for ( int col = 0; col < m_columnModel.getColumnCount(); ++col )
+        {
+            final XGridColumn column = m_columnModel.getColumn( col );
+            assertNotNull( column );
+            assertEquals( "column/model inconsistency: column " + col + " has a wrong index!", col, column.getIndex() );
+        }
+
+        final XGridColumn[] allColumns = m_columnModel.getColumns();
+        assertEquals( "getColumns returns the wrong number of column objects",
+            m_columnModel.getColumnCount(), allColumns.length );
+        for ( int col = 0; col < m_columnModel.getColumnCount(); ++col )
+        {
+            assertTrue( "getColumns inconsistency", impl_areSameInterface( allColumns[col], m_columnModel.getColumn(col) ) );
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private void impl_assertEquality( final XGridDataModel i_reference, final XGridDataModel i_compare ) throws IndexOutOfBoundsException
+    {
+        assertNotNull( i_reference );
+        assertNotNull( i_compare );
+
+        assertEquals( "data model comparison: wrong column counts", i_reference.getColumnCount(), i_compare.getColumnCount() );
+        assertEquals( "data model comparison: wrong row counts", i_reference.getRowCount(), i_compare.getRowCount() );
+
+        for ( int row = 0; row < i_reference.getRowCount(); ++row )
+        {
+            assertEquals( "data model comparison: wrong row heading content in row " + row,
+                    i_reference.getRowHeading( row ) );
+            for ( int col = 0; col < i_reference.getRowCount(); ++col )
+            {
+                assertEquals( "data model comparison: wrong cell content in cell (" + col + ", " + row + ")",
+                    i_reference.getCellData( col, row ) );
+                assertEquals( "data model comparison: wrong tooltip content in cell (" + col + ", " + row + ")",
+                    i_reference.getCellToolTip( col, row ) );
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private void impl_assertEquality( final XGridColumnModel i_reference, final XGridColumnModel i_compare ) throws IndexOutOfBoundsException
+    {
+        assertEquals( "column model comparison: wrong column counts", i_reference.getColumnCount(), i_compare.getColumnCount() );
+        for ( int col = 0; col < i_reference.getColumnCount(); ++col )
+        {
+            final XGridColumn referenceColumn = i_reference.getColumn( col );
+            final XGridColumn compareColumn = i_compare.getColumn( col );
+            impl_assertEquality( referenceColumn, compareColumn );
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private void impl_assertEquality( final XGridColumn i_reference, final XGridColumn i_compare )
+    {
+        final Method[] methods = XGridColumn.class.getMethods();
+        for ( int m=0; m<methods.length; ++m )
+        {
+            if ( !methods[m].getName().startsWith( "get" ) )
+                continue;
+            try
+            {
+                final Object referenceValue = methods[m].invoke( i_reference );
+                final Object compareValue = methods[m].invoke( i_compare );
+                assertEquals( "grid column comparison: column attribute '" + methods[m].getName().substring(3) + "' does not match",
+                    referenceValue, compareValue );
+            }
+            catch ( java.lang.Exception ex )
+            {
+                fail( " could not retrieve object attributes: " + ex.toString() );
+            }
+        }
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private boolean impl_areSameInterface( final Object i_lhs, final Object i_rhs )
+    {
+        final XInterface lhs = UnoRuntime.queryInterface( XInterface.class, i_lhs );
+        final XInterface rhs = UnoRuntime.queryInterface( XInterface.class, i_rhs );
+        return UnoRuntime.areSame( lhs, rhs );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    @BeforeClass
+    public static void setUpConnection() throws java.lang.Exception
+    {
+        System.out.println( "--------------------------------------------------------------------------------" );
+        System.out.println( "starting class: " + GridControl.class.getName() );
+        System.out.println( "connecting ..." );
+        m_connection.setUp();
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    @AfterClass
+    public static void tearDownConnection()
+        throws InterruptedException, com.sun.star.uno.Exception
+    {
+        System.out.println();
+        System.out.println( "tearing down connection" );
+        m_connection.tearDown();
+        System.out.println( "finished class: " + GridControl.class.getName() );
+        System.out.println( "--------------------------------------------------------------------------------" );
+    }
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private Object createInstance( final String i_serviceName ) throws Exception
+    {
+        Object instance = m_context.getServiceManager().createInstanceWithContext( i_serviceName, m_context );
+        assertNotNull( "could not create an instance of '" + i_serviceName + "'", instance );
+        return instance;
+    }
+    // -----------------------------------------------------------------------------------------------------------------
+    private static final class DisposeListener implements XEventListener
+    {
+        DisposeListener( final Object i_component )
+        {
+            m_component = UnoRuntime.queryInterface( XComponent.class, i_component );
+            assertNotNull( m_component );
+            m_component.addEventListener( this );
+        }
+
+        public void disposing( EventObject i_event )
+        {
+            assertTrue( UnoRuntime.areSame( i_event.Source, m_component ) );
+            m_isDisposed = true;
+        }
+
+        final boolean isDisposed() { return m_isDisposed; }
+
+        private final XComponent    m_component;
+        private boolean             m_isDisposed;
+    };
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private static final class ColumnModelListener implements XContainerListener
+    {
+        ColumnModelListener()
+        {
+        }
+
+        public void elementInserted( ContainerEvent i_event )
+        {
+            m_insertionEvents.add( i_event );
+        }
+
+        public void elementRemoved( ContainerEvent i_event )
+        {
+            m_removalEvents.add( i_event );
+        }
+
+        public void elementReplaced( ContainerEvent i_event )
+        {
+            m_replacementEvents.add( i_event );
+        }
+
+        public void disposing( EventObject eo )
+        {
+            m_isDisposed = true;
+        }
+
+        private List< ContainerEvent > assertExclusiveInsertionEvents()
+        {
+            assertFalse( m_insertionEvents.isEmpty() );
+            assertTrue( m_removalEvents.isEmpty() );
+            assertTrue( m_replacementEvents.isEmpty() );
+            return m_insertionEvents;
+        }
+
+        private List< ContainerEvent > assertExclusiveRemovalEvents()
+        {
+            assertTrue( m_insertionEvents.isEmpty() );
+            assertFalse( m_removalEvents.isEmpty() );
+            assertTrue( m_replacementEvents.isEmpty() );
+            return m_removalEvents;
+        }
+
+        private void reset()
+        {
+            m_insertionEvents = new ArrayList< ContainerEvent >();
+            m_removalEvents = new ArrayList< ContainerEvent >();
+            m_replacementEvents = new ArrayList< ContainerEvent >();
+        }
+
+        private List< ContainerEvent > getInsertionEvents() { return m_insertionEvents; }
+        private List< ContainerEvent > getRemovalEvents() { return m_removalEvents; }
+
+        final boolean isDisposed() { return m_isDisposed; }
+
+        private List< ContainerEvent > m_insertionEvents = new ArrayList< ContainerEvent >();
+        private List< ContainerEvent > m_removalEvents = new ArrayList< ContainerEvent >();
+        private List< ContainerEvent > m_replacementEvents = new ArrayList< ContainerEvent >();
+        private boolean m_isDisposed = false;
+    };
+
+    // -----------------------------------------------------------------------------------------------------------------
+    private static final OfficeConnection m_connection = new OfficeConnection();
+    private final XComponentContext m_context;
+
+    private XPropertySet                    m_gridControlModel;
+    private XGridColumnModel                m_columnModel;
+    private XSortableMutableGridDataModel   m_dataModel;
+}
diff --git a/toolkit/qa/complex/toolkit/UnitConversion.java b/toolkit/qa/complex/toolkit/UnitConversion.java
index 6441a7ecb4ff..b4cf8a8e1490 100644
--- a/toolkit/qa/complex/toolkit/UnitConversion.java
+++ b/toolkit/qa/complex/toolkit/UnitConversion.java
@@ -223,11 +223,12 @@ public class UnitConversion
         xWindow.dispose();
     }
 
-
-
     @BeforeClass
-    public static void setUpConnection() throws Exception {
-        System.out.println("setUpConnection()");
+    public static void setUpConnection() throws Exception
+    {
+        System.out.println( "--------------------------------------------------------------------------------" );
+        System.out.println( "starting class: " + UnitConversion.class.getName() );
+        System.out.println( "connecting ..." );
         connection.setUp();
     }
 
@@ -235,10 +236,12 @@ public class UnitConversion
     public static void tearDownConnection()
         throws InterruptedException, com.sun.star.uno.Exception
     {
-        System.out.println("tearDownConnection()");
+        System.out.println();
+        System.out.println( "tearing down connection" );
         connection.tearDown();
+        System.out.println( "finished class: " + UnitConversion.class.getName() );
+        System.out.println( "--------------------------------------------------------------------------------" );
     }
 
     private static final OfficeConnection connection = new OfficeConnection();
-
 }
diff --git a/toolkit/qa/complex/toolkit/awtgrid/DummyColumn.java b/toolkit/qa/complex/toolkit/awtgrid/DummyColumn.java
new file mode 100755
index 000000000000..11e4a4b19f80
--- /dev/null
+++ b/toolkit/qa/complex/toolkit/awtgrid/DummyColumn.java
@@ -0,0 +1,180 @@
+/*************************************************************************
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ *************************************************************************/
+
+package complex.toolkit.awtgrid;
+
+import com.sun.star.awt.grid.XGridColumn;
+import com.sun.star.awt.grid.XGridColumnListener;
+import com.sun.star.lang.IllegalArgumentException;
+import com.sun.star.lang.XEventListener;
+import com.sun.star.style.HorizontalAlignment;
+import com.sun.star.util.XCloneable;
+
+/**
+ * a dummy implementation of css.awt.grid.XGridColumn
+ * @author frank.schoenheit@oracle.com
+ */
+public class DummyColumn implements XGridColumn
+{
+    public DummyColumn()
+    {
+    }
+
+    public Object getIdentifier()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setIdentifier( Object o )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getColumnWidth()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setColumnWidth( int i )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getMinWidth()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setMinWidth( int i )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getMaxWidth()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setMaxWidth( int i )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public boolean getResizeable()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setResizeable( boolean bln )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getFlexibility()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setFlexibility( int i ) throws IllegalArgumentException
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public HorizontalAlignment getHorizontalAlign()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setHorizontalAlign( HorizontalAlignment ha )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public String getTitle()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setTitle( String string )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public String getHelpText()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setHelpText( String string )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getIndex()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public int getDataColumnIndex()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void setDataColumnIndex( int i )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void addGridColumnListener( XGridColumnListener xl )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void removeGridColumnListener( XGridColumnListener xl )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void dispose()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void addEventListener( XEventListener xl )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public void removeEventListener( XEventListener xl )
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+
+    public XCloneable createClone()
+    {
+        throw new UnsupportedOperationException( "Not supported yet." );
+    }
+}
diff --git a/toolkit/qa/complex/toolkit/awtgrid/GridDataListener.java b/toolkit/qa/complex/toolkit/awtgrid/GridDataListener.java
new file mode 100755
index 000000000000..c31f27796cf1
--- /dev/null
+++ b/toolkit/qa/complex/toolkit/awtgrid/GridDataListener.java
@@ -0,0 +1,98 @@
+package complex.toolkit.awtgrid;
+
+import com.sun.star.awt.grid.GridDataEvent;
+import com.sun.star.awt.grid.XGridDataListener;
+import com.sun.star.lang.EventObject;
+import static org.junit.Assert.*;
+
+final public class GridDataListener implements XGridDataListener
+{
+    public GridDataListener()
+    {
+    }
+
+    public void rowsInserted( GridDataEvent i_event )
+    {
+        assertNull( m_rowInsertionEvent );
+        m_rowInsertionEvent = i_event;
+    }
+
+    public void rowsRemoved( GridDataEvent i_event )
+    {
+        assertNull( m_rowRemovalEvent );
+        m_rowRemovalEvent = i_event;
+    }
+
+    public void dataChanged( GridDataEvent i_event )
+    {
+        assertNull( m_dataChangeEvent );
+        m_dataChangeEvent = i_event;
+    }
+
+    public void rowHeadingChanged( GridDataEvent i_event )
+    {
+        assertNull( m_rowHeadingChangeEvent );
+        m_rowHeadingChangeEvent = i_event;
+    }
+
+    public void disposing( EventObject eo )
+    {
+        m_disposed = true;
+    }
+
+    public final GridDataEvent assertSingleRowInsertionEvent()
+    {
+        assertNotNull( m_rowInsertionEvent );
+        assertNull( m_rowRemovalEvent );
+        assertNull( m_dataChangeEvent );
+        assertNull( m_rowHeadingChangeEvent );
+        assertFalse( m_disposed );
+        return m_rowInsertionEvent;
+    }
+
+    public final GridDataEvent assertSingleRowRemovalEvent()
+    {
+        assertNull( m_rowInsertionEvent );
+        assertNotNull( m_rowRemovalEvent );
+        assertNull( m_dataChangeEvent );
+        assertNull( m_rowHeadingChangeEvent );
+        assertFalse( m_disposed );
+        return m_rowRemovalEvent;
+    }
+
+    public final GridDataEvent assertSingleDataChangeEvent()
+    {
+        assertNull( m_rowInsertionEvent );
+        assertNull( m_rowRemovalEvent );
+        assertNotNull( m_dataChangeEvent );
+        assertNull( m_rowHeadingChangeEvent );
+        assertFalse( m_disposed );
+        return m_dataChangeEvent;
+    }
+
+    public final GridDataEvent assertSingleRowHeadingChangeEvent()
+    {
+        assertNull( m_rowInsertionEvent );
+        assertNull( m_rowRemovalEvent );
+        assertNull( m_dataChangeEvent );
+        assertNotNull( m_rowHeadingChangeEvent );
+        assertFalse( m_disposed );
+        return m_rowHeadingChangeEvent;
+    }
+
+    public final boolean isDisposed()
+    {
+        return m_disposed;
+    }
+
+    public final void reset()
+    {
+        m_rowInsertionEvent = m_rowRemovalEvent = m_dataChangeEvent = m_rowHeadingChangeEvent = null;
+        // m_disposed is not reset intentionally
+    }
+    private GridDataEvent m_rowInsertionEvent = null;
+    private GridDataEvent m_rowRemovalEvent = null;
+    private GridDataEvent m_dataChangeEvent = null;
+    private GridDataEvent m_rowHeadingChangeEvent = null;
+    private boolean m_disposed = false;
+}
diff --git a/toolkit/qa/complex/toolkit/awtgrid/TMutableGridDataModel.java b/toolkit/qa/complex/toolkit/awtgrid/TMutableGridDataModel.java
new file mode 100755
index 000000000000..4413118f4e80
--- /dev/null
+++ b/toolkit/qa/complex/toolkit/awtgrid/TMutableGridDataModel.java
@@ -0,0 +1,269 @@
+/*************************************************************************
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+ *
+ * Copyright 2000, 2010 Oracle and/or its affiliates.
+ *
+ * OpenOffice.org - a multi-platform office productivity suite
+ *
+ * This file is part of OpenOffice.org.
+ *
+ * OpenOffice.org is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3
+ * only, as published by the Free Software Foundation.
+ *
+ * OpenOffice.org is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License version 3 for more details
+ * (a copy is included in the LICENSE file that accompanied this code).
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * version 3 along with OpenOffice.org.  If not, see
+ * <http://www.openoffice.org/license.html>
+ * for a copy of the LGPLv3 License.
+ *
+ *************************************************************************/
+
+package complex.toolkit.awtgrid;
+
+import com.sun.star.awt.grid.GridDataEvent;
+import com.sun.star.awt.grid.XMutableGridDataModel;
+import com.sun.star.lang.IllegalArgumentException;
+import com.sun.star.lang.IndexOutOfBoundsException;
+import static org.junit.Assert.*;
+
+/** test for the <code>css.awt.grid.XMutableGridData</code> interface
+ *
+ * @author frank.schoenheit@oracle.com
+ */
+public class TMutableGridDataModel
+{
+    public TMutableGridDataModel( final XMutableGridDataModel i_dataModel )
+    {
+        m_dataModel = i_dataModel;
+
+        m_listener = new GridDataListener();
+        m_dataModel.addGridDataListener( m_listener );
+    }
+
+    /*
+     * tests the XMutableGridDataModel.addRow method
+     */
+    public void testAddRow()
+    {
+        m_dataModel.addRow( 1, m_rowValues[0] );
+        GridDataEvent event = m_listener.assertSingleRowInsertionEvent();
+        assertEquals( "row insertion: wrong FirstRow (1)", 0, event.FirstRow );
+        assertEquals( "row insertion: wrong LastRow (1)", 0, event.LastRow );
+        m_listener.reset();
+
+        m_dataModel.addRow( 2, m_rowValues[1] );
+        event = m_listener.assertSingleRowInsertionEvent();
+        assertEquals( "row insertion: wrong FirstRow (2)", 1, event.FirstRow );
+        assertEquals( "row insertion: wrong LastRow (2)", 1, event.LastRow );
+        m_listener.reset();
+    }
+
+    /**
+     * tests the XMutableGridDataModel.addRows method
+     */
+    public void testAddRows() throws IndexOutOfBoundsException, IllegalArgumentException
+    {
+        assertEquals( "precondition not met: call this directly after testAddRow, please!", 2, m_dataModel.getRowCount() );
+
+        m_dataModel.addRows( new Object[] { "3", 4.0, "5" }, new Object[][] { m_rowValues[2], m_rowValues[3], m_rowValues[4] } );
+        GridDataEvent event = m_listener.assertSingleRowInsertionEvent();
+        assertEquals( "row insertion: wrong FirstRow (1)", 2, event.FirstRow );
+        assertEquals( "row insertion: wrong LastRow (1)", 4, event.LastRow );
+        m_listener.reset();
+
+        assertEquals( "data model's row count is not adjusted when adding rows", m_rowValues.length, m_dataModel.getRowCount() );
+        assertEquals( "data model's column count is not adjusted when adding rows", m_rowValues[0].length, m_dataModel.getColumnCount() );
+        for ( int row=0; row<m_rowValues.length; ++row )
+        {
+            for ( int col=0; col<m_rowValues[row].length; ++col )
+            {
+                assertEquals( "added row values are not preserved",
+                    m_rowValues[row][col], m_dataModel.getCellData( col, row ) );
+            }
+        }
+    }
+
+    /**
+     * tests the XMutableGridDataModel.removeRow method
+     */
+    public void testRemoveRow() throws IndexOutOfBoundsException
+    {
+        assertEquals( "precondition not met: call this directly after testAddRows, please!", m_rowValues.length, m_dataModel.getRowCount() );
+
+        final int rowToRemove = 2;
+        m_dataModel.removeRow( rowToRemove );
+        GridDataEvent event = m_listener.assertSingleRowRemovalEvent();
+        assertEquals( "incorrect notification of row removal (FirstRow)", rowToRemove, event.FirstRow );
+        assertEquals( "incorrect notification of row removal (LastRow)", rowToRemove, event.LastRow );
+        m_listener.reset();
+
+        assertEquals( "data model's row count does not reflect the removed row", m_rowValues.length - 1, m_dataModel.getRowCount() );
+        for ( int row = rowToRemove; row<m_rowValues.length-1; ++row )
+        {
+            for ( int col=0; col<m_rowValues[row].length; ++col )
+            {
+                assertEquals( "unexpected row values after removing a row (col: " + col + ", row: " + row + ")",
+                    m_rowValues[row+1][col], m_dataModel.getCellData( col, row ) );
+            }
+        }
+    }
+
+    /**
+     * tests the XMutableGridDataModel.removeAllRows method
+     */
+    public void testRemoveAllRows()
+    {
+        assertEquals( "precondition not met: call this directly after testRemoveRow, please!", m_rowValues.length - 1, m_dataModel.getRowCount() );
+
+        m_dataModel.removeAllRows();
+        final GridDataEvent event = m_listener.assertSingleRowRemovalEvent();
+        if ( event.FirstRow != -1 )
+        {   // notifying "-1" is allowed, this means "all rows affected", by definition
+            assertEquals( "removeAllRows is not notifying properly (1)", 0, event.FirstRow );
+            assertEquals( "removeAllRows is not notifying properly (2)", m_rowValues.length - 1, event.LastRow );
+        }
+        m_listener.reset();
+    }
+
+    /**
+     * tests the XMutableGridDataModel.updateCellData method
+     */
+    public void testUpdateCellData() throws IndexOutOfBoundsException, IllegalArgumentException
+    {
+        assertEquals( "precondition not met: call this directly after testRemoveAllRows, please!", 0, m_dataModel.getRowCount() );
+
+        m_dataModel.addRows( new Object[] { 1, 2, 3, 4, 5 }, m_rowValues );
+        m_listener.assertSingleRowInsertionEvent();
+        m_listener.reset();
+
+        final Object[][] modifyValues = new Object[][] {
+            new Object[] { 2, 1, "text" },
+            new Object[] { 3, 0, null },
+            new Object[] { 0, 4, new Double( 33.0 ) }
+        };
+        for ( int i = 0; i < modifyValues.length; ++i )
+        {
+            final int row = ((Integer)modifyValues[i][0]).intValue();
+            final int col = ((Integer)modifyValues[i][1]).intValue();
+            final Object value = modifyValues[i][2];
+            m_dataModel.updateCellData( col, row, value );
+
+            final GridDataEvent event = m_listener.assertSingleDataChangeEvent();
+            assertEquals( "data change notification: FirstRow is invalid", row, event.FirstRow );
+            assertEquals( "data change notification: LastRow is invalid", row, event.LastRow );
+            assertEquals( "data change notification: FirstColumn is invalid", col, event.FirstColumn );
+            assertEquals( "data change notification: LastColumn is invalid", col, event.LastColumn );
+            m_listener.reset();
+
+            assertEquals( "data change at (" + col + ", " + row + ") not successful", value, m_dataModel.getCellData( col, row ) );
+        }
+    }
+
+    /**
+     * tests the XMutableGridDataModel.updateRowData method
+     */
+    public void testUpdateRowData() throws IndexOutOfBoundsException, IllegalArgumentException
+    {
+        assertEquals( "precondition not met: call this directly after testRemoveAllRows, please!", m_rowValues.length, m_dataModel.getRowCount() );
+
+        // get data from before the update
+        final Object[][] preUpdateValues = impl_getCurrentData();
+
+        // do the update
+        final int[] colIndexes = new int[] {
+            0, 3, 4
+        };
+        final Object[] values = new Object[] {
+            13, null, 42.0
+        };
+        final int rowToUpdate = 2;
+        m_dataModel.updateRowData( colIndexes, rowToUpdate, values );
+        final GridDataEvent event = m_listener.assertSingleDataChangeEvent();
+        assertEquals( "row update notification: FirstRow is invalid", rowToUpdate, event.FirstRow );
+        assertEquals( "row update notification: LastRow is invalid", rowToUpdate, event.LastRow );
+        assertEquals( "row update notification: FirstColumn is invalid", 0, event.FirstColumn );
+        assertEquals( "row update notification: LastColumn is invalid", 4, event.LastColumn );
+        m_listener.reset();
+
+        // reflect the changes made in the pre-update data
+        for ( int i=0; i<colIndexes.length; ++i )
+        {
+            preUpdateValues[rowToUpdate][colIndexes[i]] = values[i];
+        }
+
+        // get data from after the update
+        final Object[][] postUpdateValues = impl_getCurrentData();
+
+        // ensure both the manually updated pre-update data and the post-update data are identical
+        assertArrayEquals( preUpdateValues, postUpdateValues );
+    }
+
+    /**
+     * tests the XMutableGridDataModel.setRowHeading method
+     */
+    public void testUpdateRowHeading() throws IndexOutOfBoundsException
+    {
+        assertEquals( "precondition not met: call this directly after testUpdateRowData, please!", m_rowValues.length, m_dataModel.getRowCount() );
+
+        final Object[] preUpdateHeadings = impl_getCurrentRowHeadings();
+
+        final int rowToUpdate = 2;
+        final String valueToUpdate = "some text";
+        m_dataModel.setRowHeading( rowToUpdate, valueToUpdate );
+        final GridDataEvent event = m_listener.assertSingleRowHeadingChangeEvent();
+        assertEquals( "row heading update notification: FirstRow is invalid", rowToUpdate, event.FirstRow );
+        assertEquals( "row heading update notification: FirstRow is invalid", rowToUpdate, event.LastRow );
+        m_listener.reset();
+
+        preUpdateHeadings[rowToUpdate] = valueToUpdate;
+
+        final Object[] postUpdateHeadings = impl_getCurrentRowHeadings();
+        assertArrayEquals( preUpdateHeadings, postUpdateHeadings );
+    }
+
+    public void cleanup()
+    {
+        m_dataModel.removeGridDataListener( m_listener );
+    }
+
+    private Object[][] impl_getCurrentData() throws IndexOutOfBoundsException
+    {
+        final int rowCount = m_dataModel.getRowCount();
+        final int colCount = m_dataModel.getColumnCount();
+        final Object[][] data = new Object[rowCount][colCount];
+        for ( int row=0; row<rowCount; ++row )
+        {
+            for ( int col=0; col<colCount; ++col )
+            {
+                data[row][col] = m_dataModel.getCellData( col, row );
+            }
+        }
+        return data;
+    }
+
+    private Object[] impl_getCurrentRowHeadings() throws IndexOutOfBoundsException
+    {
+        final int rowCount = m_dataModel.getRowCount();
+        final Object[] headings = new Object[rowCount];
+        for ( int row=0; row<rowCount; ++row )
+            headings[row] = m_dataModel.getRowHeading( row );
+        return headings;
+    }
+
+    private final XMutableGridDataModel m_dataModel;
+    private final GridDataListener      m_listener;
+
+    private final static Object[][] m_rowValues = new Object[][] {
+            new Object[] { 1, 2, "3", 4, 5 },
+            new Object[] { 2, 3, 4, "5", 6 },
+            new Object[] { "3", 4, 5, 6, 7 },
+            new Object[] { 4, 5, 6, 7, "8" },
+            new Object[] { 5, "6", 7, 8, 9 },
+        };
+}
diff --git a/toolkit/qa/complex/toolkit/makefile.mk b/toolkit/qa/complex/toolkit/makefile.mk
index 63605dace711..3d90b5e343ec 100755
--- a/toolkit/qa/complex/toolkit/makefile.mk
+++ b/toolkit/qa/complex/toolkit/makefile.mk
@@ -52,6 +52,8 @@ JAVAFILES = \
     accessibility/_XAccessibleEventBroadcaster.java \
     accessibility/_XAccessibleExtendedComponent.java \
     accessibility/_XAccessibleText.java \
+    awtgrid/GridDataListener.java \
+    awtgrid/TMutableGridDataModel.java \
 
 #----- create a jar from compiled files ----------------------------
 
@@ -60,6 +62,7 @@ JARTARGET       = $(TARGET).jar
 #----- JUnit tests class -------------------------------------------
 
 JAVATESTFILES = \
+    GridControl.java \
     UnitConversion.java \
     AccessibleStatusBar.java \