tests/org.eclipse.rap.rwt.test/src/org/eclipse/swt/widgets/TableColumn_Test.java - rap/org.eclipse.rap - Git at Google

 /*******************************************************************************
  * Copyright (c) 2007, 2019 Innoopract Informationssysteme GmbH and others.
  * All rights reserved. This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License v1.0
  * which accompanies this distribution, and is available at
  * http://www.eclipse.org/legal/epl-v10.html
  *
  * Contributors:
  *    Innoopract Informationssysteme GmbH - initial API and implementation
  *    EclipseSource - ongoing development
  ******************************************************************************/
 package org.eclipse.swt.widgets;

 import static org.eclipse.rap.rwt.testfixture.internal.TestUtil.createImage;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNull;
 import static org.junit.Assert.assertSame;
 import static org.junit.Assert.assertTrue;
 import static org.junit.Assert.fail;
 import static org.mockito.Mockito.mock;

 import java.io.IOException;
 import java.util.ArrayList;

 import org.eclipse.rap.rwt.RWT;
 import org.eclipse.rap.rwt.internal.lifecycle.WidgetLCA;
 import org.eclipse.rap.rwt.testfixture.TestContext;
 import org.eclipse.rap.rwt.testfixture.internal.Fixture;
 import org.eclipse.swt.SWT;
 import org.eclipse.swt.SWTException;
 import org.eclipse.swt.events.ControlAdapter;
 import org.eclipse.swt.events.ControlEvent;
 import org.eclipse.swt.events.ControlListener;
 import org.eclipse.swt.events.SelectionListener;
 import org.eclipse.swt.graphics.Image;
 import org.eclipse.swt.internal.widgets.ITableAdapter;
 import org.eclipse.swt.internal.widgets.MarkupValidator;
 import org.eclipse.swt.internal.widgets.tablecolumnkit.TableColumnLCA;
 import org.junit.Before;
 import org.junit.Rule;
 import org.junit.Test;


 public class TableColumn_Test {

   @Rule
   public TestContext context = new TestContext();

   private Display display;
   private Shell shell;
   private Table table;
   private TableColumn column;

   @Before
   public void setUp() {
     display = new Display();
     shell = new Shell( display );
     table = new Table( shell, SWT.NONE );
     column = new TableColumn( table, SWT.NONE );
   }

   @Test
   public void testCreation() {
     assertEquals( 1, table.getColumnCount() );
     assertSame( column, table.getColumn( 0 ) );
     // Insert an item before first item
     TableColumn col0 = new TableColumn( table, SWT.NONE, 0 );
     assertEquals( 2, table.getColumnCount() );
     assertSame( col0, table.getColumn( 0 ) );
     // Try to add an item whit an index which is out of bounds
     try {
       new TableColumn ( table, SWT.NONE, table.getColumnCount() + 8 );
       fail();
     } catch( IllegalArgumentException expected ) {
     }
   }

   @Test
   public void testParent() {
     // Test creating column with valid parent
     assertSame( table, column.getParent() );
     // Test creating column without parent
     try {
       new TableColumn( null, SWT.NONE );
       fail( "Must not allow to create TableColumn withh null-parent." );
     } catch( IllegalArgumentException iae ) {
       // expected
     }
   }

   @Test
   public void testDisplay() {
     assertSame( display, column.getDisplay() );
   }

   @Test
   public void testStyle() {
     assertTrue( ( column.getStyle() & SWT.LEFT ) != 0 );
     column = new TableColumn( table, SWT.LEFT | SWT.RIGHT | SWT.CENTER );
     assertTrue( ( column.getStyle() & SWT.LEFT ) != 0 );
     column = new TableColumn( table, SWT.RIGHT );
     assertTrue( ( column.getStyle() & SWT.RIGHT ) != 0 );
   }

   @Test
   public void testInitialValues() {
     assertEquals( 0, column.getWidth() );
     assertEquals( "", column.getText() );
     assertEquals( null, column.getToolTipText() );
     assertNull( column.getImage() );
     assertTrue( column.getResizable() );
     assertFalse( column.getMoveable() );
     assertEquals( SWT.LEFT, column.getAlignment() );
   }

   @Test
   public void testAlignment() {
     assertEquals( SWT.LEFT, column.getAlignment() );
     column = new TableColumn( table, SWT.LEFT );
     assertEquals( SWT.LEFT, column.getAlignment() );
     column = new TableColumn( table, SWT.CENTER );
     assertEquals( SWT.CENTER, column.getAlignment() );
     column = new TableColumn( table, SWT.RIGHT );
     assertEquals( SWT.RIGHT, column.getAlignment() );

     column.setAlignment( SWT.LEFT );
     assertEquals( SWT.LEFT, column.getAlignment() );
     column.setAlignment( 4712 );
     assertEquals( SWT.LEFT, column.getAlignment() );
   }

   @Test
   public void testInitialWidth() {
     assertEquals( 0, column.getWidth() );
   }

   @Test
   public void testWidth() {
     column.setWidth( 70 );
     assertEquals( 70, column.getWidth() );
     column.setWidth( 0 );
     assertEquals( 0, column.getWidth() );
   }

   @Test
   public void testWidthWithNegativeValue() {
     column.setWidth( 4711 );
     column.setWidth( -1 );
     assertEquals( 4711, column.getWidth() );
     column.setWidth( -2 );
     assertEquals( 4711, column.getWidth() );
     column.setWidth( -3 );
     assertEquals( 4711, column.getWidth() );
   }

   @Test
   public void testPack() throws IOException {
     final java.util.List<Widget> log = new ArrayList<Widget>();
     ControlAdapter resizeListener = new ControlAdapter() {
       @Override
       public void controlResized( ControlEvent e ) {
         log.add( e.widget );
       }
     };
     table.setHeaderVisible( true );
     column.addControlListener( resizeListener );

     // Ensure that controlResized is fired when pack changes the width
     column.setWidth( 12312 );
     log.clear();
     column.pack();
     assertSame( log.get( 0 ), column );

     // Ensure that controlResized is *not* fired when pack doesn't change the
     // width
     log.clear();
     column.pack();
     assertEquals( 0, log.size() );

     column.removeControlListener( resizeListener );

     // pack calculates a minimal width for an empty column
     column = new TableColumn( table, SWT.NONE );
     column.pack();
     assertTrue( column.getWidth() > 0 );

     // Test that an image on a column is taken into account
     column = new TableColumn( table, SWT.NONE );
     Image image = createImage( display, Fixture.IMAGE_50x100 );
     column.setImage( image );
     column.pack();
     assertTrue( column.getWidth() >= image.getBounds().width );

     // An item wider than the column itself strechtes the column
     while( table.getColumnCount() > 0 ) {
       table.getColumn( 0 ).dispose();
     }
     table.removeAll();
     column = new TableColumn( table, SWT.NONE );
     TableItem item = new TableItem( table, SWT.NONE );
     item.setImage( image );
     column.pack();
     assertTrue( column.getWidth() >= item.getBounds().width );
   }

   @Test
   public void testGetPreferredWidthWithInvisibleHeader() {
     table.setHeaderVisible( true );
     column.setText( "column" );
     int preferredWidth = column.getPreferredWidth();

     table.setHeaderVisible( false );

     assertEquals( preferredWidth, column.getPreferredWidth() );
   }

   @Test
   public void testGetPreferredWidthMultiLineHeader() {
     for( int i = 0; i < 3; i++ ) {
       TableColumn column1 = new TableColumn( table, SWT.NONE );
       column1.setWidth( 50 );
       column1.setText( "Column " + i );
     }
     table.setHeaderVisible( true );
     TableColumn column = table.getColumn( 1 );

     column.setText( "Multi\nLineText" );

     assertEquals( 61, column.getPreferredWidth() );
   }

   @Test
   public void testPackWithVirtual() {
     final java.util.List<Widget> log = new ArrayList<Widget>();
     Listener setDataListener = new Listener() {
       @Override
       public void handleEvent( Event event ) {
         log.add( event.item );
       }
     };
     ControlListener resizeListener = new ControlAdapter() {
       @Override
       public void controlResized( ControlEvent event ) {
         log.add( event.widget );
       }
     };
     // Must not try to access items if there aren't any
     log.clear();
     table = new Table( shell, SWT.VIRTUAL );
     column = new TableColumn( table, SWT.NONE );
     column.setWidth( 200 );
     column.addControlListener( resizeListener );
     column.pack();
     assertEquals( 1, log.size() ); // ensure that pack() did something

     // Ensure that pack resolves only first virtual item
     log.clear();
     table = new Table( shell, SWT.VIRTUAL );
     column = new TableColumn( table, SWT.NONE );
     table.setSize( 100, 50 );
     table.setItemCount( 100 );
     table.addListener( SWT.SetData, setDataListener );
     column.pack();
     assertEquals( 1, log.size() );
   }

   @Test
   public void testResizeEvent() {
     final java.util.List<ControlEvent> log = new ArrayList<ControlEvent>();
     column.addControlListener( new ControlListener() {
       @Override
       public void controlMoved( ControlEvent event ) {
         fail( "unexpected event: controlMoved" );
       }
       @Override
       public void controlResized( ControlEvent event ) {
         log.add( event );
       }
     } );
     ControlEvent event;
     // Changing column width leads to resize event
     log.clear();
     column.setWidth( column.getWidth() + 1 );
     assertEquals( 1, log.size() );
     event = log.get( 0 );
     assertSame( column, event.getSource() );
     // Setting the column width to the same value it already has as well leads
     // to resize event
     log.clear();
     column.setWidth( column.getWidth() );
     assertEquals( 1, log.size() );
     event = log.get( 0 );
     assertEquals( column, event.getSource() );
   }

   @Test
   public void testMoveEvent() {
     final java.util.List<ControlEvent> log = new ArrayList<ControlEvent>();
     column.addControlListener( new ControlListener() {
       @Override
       public void controlMoved( ControlEvent event ) {
         fail( "unexpected event: controlMoved" );
       }
       @Override
       public void controlResized( ControlEvent event ) {
         log.add( event );
       }
     } );
     final TableColumn column1 = new TableColumn( table, SWT.NONE );
     column1.addControlListener( new ControlListener() {
       @Override
       public void controlMoved( ControlEvent event ) {
         log.add( event );
       }
       @Override
       public void controlResized( ControlEvent event ) {
         fail( "unexpected event: controlResized" );
       }
     } );
     ControlEvent event;
     // Changing column width leads to resize event and move event of the next
     // columns
     log.clear();
     column.setWidth( column.getWidth() + 1 );
     assertEquals( 2, log.size() );
     event = log.get( 0 );
     assertSame( column, event.getSource() );
     event = log.get( 1 );
     assertSame( column1, event.getSource() );
   }

   @Test
   public void testDisposeLast() {
     TableColumn column1 = new TableColumn( table, SWT.NONE );
     TableItem item = new TableItem( table, SWT.NONE );
     item.setText( "itemText for column 0" );
     item.setText( 1, "itemText for column 1" );

     column1.dispose();
     assertEquals( "", item.getText( 1 ) );
     assertEquals( "itemText for column 0", item.getText() );

     column.dispose();
     assertEquals( 0, table.getColumnCount() );
     assertEquals( 1, table.getItemCount() );
     assertEquals( "itemText for column 0", item.getText() );
   }

   // 323179: Creating and disposing a TableColumn (without updating the
   // TableItems) results in an ArrayIndexOutOfBoundsException
   // https://bugs.eclipse.org/bugs/show_bug.cgi?id=323179
   @Test
   public void testCreateDisposeColumnWithoutDataUpdate() {
     column.setText( "First Column" );
     int number = 5;
     TableItem[] items = new TableItem[ number ];
     for( int i = 0; i < number; i++ ) {
       items[ i ] = new TableItem( table, SWT.NONE );
       items[ i ].setText( 0, "x1" );
     }
     TableColumn column2 = new TableColumn( table, SWT.NONE );
     column2.setText( "Second Column" );
     column2.dispose();
   }

   @Test
   public void testIsFixedColumn() {
     shell.setSize( 800, 600 );
     Table table = createFixedColumnsTable( shell );
     table.setSize( 300, 100 );
     ITableAdapter adapter = table.getAdapter( ITableAdapter.class );
     assertTrue( adapter.isFixedColumn( table.getColumn( 0 ) ) );
     assertFalse( adapter.isFixedColumn( table.getColumn( 1 ) ) );
     table.setColumnOrder( new int[]{ 1, 0, 2, 3, 4, 5, 6, 7, 8, 9 } );
     assertFalse( adapter.isFixedColumn( table.getColumn( 0 ) ) );
     assertTrue( adapter.isFixedColumn( table.getColumn( 1 ) ) );
   }

   @Test
   public void testAddSelectionListener() {
     column.addSelectionListener( mock( SelectionListener.class ) );

     assertTrue( column.isListening( SWT.Selection ) );
     assertTrue( column.isListening( SWT.DefaultSelection ) );
   }

   @Test
   public void testRemoveSelectionListener() {
     SelectionListener listener = mock( SelectionListener.class );
     column.addSelectionListener( listener );

     column.removeSelectionListener( listener );

     assertFalse( column.isListening( SWT.Selection ) );
     assertFalse( column.isListening( SWT.DefaultSelection ) );
   }

   @Test
   public void testAddSelectionListenerWithNullArgument() {
     try {
       column.addSelectionListener( null );
     } catch( IllegalArgumentException expected ) {
     }
   }

   @Test
   public void testRemoveSelectionListenerWithNullArgument() {
     try {
       column.removeSelectionListener( null );
     } catch( IllegalArgumentException expected ) {
     }
   }

   @Test
   public void testAddControlListenerWithNullArgument() {
     try {
       column.addControlListener( null );
     } catch( IllegalArgumentException expected ) {
     }
   }

   @Test
   public void testAddControlListener() {
     column.addControlListener( mock( ControlListener.class ) );

     assertTrue( column.isListening( SWT.Move ) );
     assertTrue( column.isListening( SWT.Resize ) );
   }

   @Test
   public void testRemoveControlListenerWithNullArgument() {
     try {
       column.removeControlListener( null );
     } catch( IllegalArgumentException expected ) {
     }
   }

   @Test
   public void testRemoveControlListener() {
     ControlListener listener = mock( ControlListener.class );
     column.addControlListener( listener );

     column.removeControlListener( listener );

     assertFalse( column.isListening( SWT.Move ) );
     assertFalse( column.isListening( SWT.Resize ) );
   }

   @Test
   public void testMarkupToolTipTextWithoutMarkupEnabled() {
     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.FALSE );

     try {
       column.setToolTipText( "invalid xhtml: <<&>>" );
     } catch( IllegalArgumentException notExpected ) {
       fail();
     }
   }

   @Test( expected = IllegalArgumentException.class )
   public void testMarkupToolTipTextWithMarkupEnabled() {
     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );

     column.setToolTipText( "invalid xhtml: <<&>>" );
   }

   @Test
   public void testMarkupTextWithMarkupEnabled_ValidationDisabled() {
     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
     column.setData( MarkupValidator.MARKUP_VALIDATION_DISABLED, Boolean.TRUE );

     try {
       column.setToolTipText( "invalid xhtml: <<&>>" );
     } catch( IllegalArgumentException notExpected ) {
       fail();
     }
   }

   @Test
   public void testSetToolTipMarkupEnabled_onDirtyWidget() {
     column.setToolTipText( "something" );

     try {
       column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
       fail();
     } catch( SWTException expected ) {
       assertTrue( expected.throwable instanceof IllegalStateException );
     }
   }

   @Test
   public void testSetToolTipMarkupEnabled_onDirtyWidget_onceEnabledBefore() {
     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
     column.setToolTipText( "something" );

     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
   }

   @Test
   public void testDisableMarkupIsIgnored() {
     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );

     column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.FALSE );

     assertEquals( Boolean.TRUE, column.getData( RWT.TOOLTIP_MARKUP_ENABLED ) );
   }

   @Test
   public void testSetData() {
     column.setData( "foo", "bar" );

     assertEquals( "bar", column.getData( "foo" ) );
   }

   private Table createFixedColumnsTable( Shell shell ) {
     Table result = new Table( shell, SWT.NONE );
     result.setData( RWT.FIXED_COLUMNS, new Integer( 1 ) );
     for( int i = 0; i < 10; i++ ) {
       TableColumn column = new TableColumn( result, SWT.NONE );
       column.setWidth( 50 );
     }
     return result;
   }

   @Test
   public void testGetAdapter_LCA() {
     assertTrue( column.getAdapter( WidgetLCA.class ) instanceof TableColumnLCA );
     assertSame( column.getAdapter( WidgetLCA.class ), column.getAdapter( WidgetLCA.class ) );
   }

 }
	/*******************************************************************************
	* Copyright (c) 2007, 2019 Innoopract Informationssysteme GmbH and others.
	* All rights reserved. This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License v1.0
	* which accompanies this distribution, and is available at
	* http://www.eclipse.org/legal/epl-v10.html
	*
	* Contributors:
	* Innoopract Informationssysteme GmbH - initial API and implementation
	* EclipseSource - ongoing development
	******************************************************************************/
	package org.eclipse.swt.widgets;

	import static org.eclipse.rap.rwt.testfixture.internal.TestUtil.createImage;
	import static org.junit.Assert.assertEquals;
	import static org.junit.Assert.assertFalse;
	import static org.junit.Assert.assertNull;
	import static org.junit.Assert.assertSame;
	import static org.junit.Assert.assertTrue;
	import static org.junit.Assert.fail;
	import static org.mockito.Mockito.mock;

	import java.io.IOException;
	import java.util.ArrayList;

	import org.eclipse.rap.rwt.RWT;
	import org.eclipse.rap.rwt.internal.lifecycle.WidgetLCA;
	import org.eclipse.rap.rwt.testfixture.TestContext;
	import org.eclipse.rap.rwt.testfixture.internal.Fixture;
	import org.eclipse.swt.SWT;
	import org.eclipse.swt.SWTException;
	import org.eclipse.swt.events.ControlAdapter;
	import org.eclipse.swt.events.ControlEvent;
	import org.eclipse.swt.events.ControlListener;
	import org.eclipse.swt.events.SelectionListener;
	import org.eclipse.swt.graphics.Image;
	import org.eclipse.swt.internal.widgets.ITableAdapter;
	import org.eclipse.swt.internal.widgets.MarkupValidator;
	import org.eclipse.swt.internal.widgets.tablecolumnkit.TableColumnLCA;
	import org.junit.Before;
	import org.junit.Rule;
	import org.junit.Test;


	public class TableColumn_Test {

	@Rule
	public TestContext context = new TestContext();

	private Display display;
	private Shell shell;
	private Table table;
	private TableColumn column;

	@Before
	public void setUp() {
	display = new Display();
	shell = new Shell( display );
	table = new Table( shell, SWT.NONE );
	column = new TableColumn( table, SWT.NONE );
	}

	@Test
	public void testCreation() {
	assertEquals( 1, table.getColumnCount() );
	assertSame( column, table.getColumn( 0 ) );
	// Insert an item before first item
	TableColumn col0 = new TableColumn( table, SWT.NONE, 0 );
	assertEquals( 2, table.getColumnCount() );
	assertSame( col0, table.getColumn( 0 ) );
	// Try to add an item whit an index which is out of bounds
	try {
	new TableColumn ( table, SWT.NONE, table.getColumnCount() + 8 );
	fail();
	} catch( IllegalArgumentException expected ) {
	}
	}

	@Test
	public void testParent() {
	// Test creating column with valid parent
	assertSame( table, column.getParent() );
	// Test creating column without parent
	try {
	new TableColumn( null, SWT.NONE );
	fail( "Must not allow to create TableColumn withh null-parent." );
	} catch( IllegalArgumentException iae ) {
	// expected
	}
	}

	@Test
	public void testDisplay() {
	assertSame( display, column.getDisplay() );
	}

	@Test
	public void testStyle() {
	assertTrue( ( column.getStyle() & SWT.LEFT ) != 0 );
	column = new TableColumn( table, SWT.LEFT \| SWT.RIGHT \| SWT.CENTER );
	assertTrue( ( column.getStyle() & SWT.LEFT ) != 0 );
	column = new TableColumn( table, SWT.RIGHT );
	assertTrue( ( column.getStyle() & SWT.RIGHT ) != 0 );
	}

	@Test
	public void testInitialValues() {
	assertEquals( 0, column.getWidth() );
	assertEquals( "", column.getText() );
	assertEquals( null, column.getToolTipText() );
	assertNull( column.getImage() );
	assertTrue( column.getResizable() );
	assertFalse( column.getMoveable() );
	assertEquals( SWT.LEFT, column.getAlignment() );
	}

	@Test
	public void testAlignment() {
	assertEquals( SWT.LEFT, column.getAlignment() );
	column = new TableColumn( table, SWT.LEFT );
	assertEquals( SWT.LEFT, column.getAlignment() );
	column = new TableColumn( table, SWT.CENTER );
	assertEquals( SWT.CENTER, column.getAlignment() );
	column = new TableColumn( table, SWT.RIGHT );
	assertEquals( SWT.RIGHT, column.getAlignment() );

	column.setAlignment( SWT.LEFT );
	assertEquals( SWT.LEFT, column.getAlignment() );
	column.setAlignment( 4712 );
	assertEquals( SWT.LEFT, column.getAlignment() );
	}

	@Test
	public void testInitialWidth() {
	assertEquals( 0, column.getWidth() );
	}

	@Test
	public void testWidth() {
	column.setWidth( 70 );
	assertEquals( 70, column.getWidth() );
	column.setWidth( 0 );
	assertEquals( 0, column.getWidth() );
	}

	@Test
	public void testWidthWithNegativeValue() {
	column.setWidth( 4711 );
	column.setWidth( -1 );
	assertEquals( 4711, column.getWidth() );
	column.setWidth( -2 );
	assertEquals( 4711, column.getWidth() );
	column.setWidth( -3 );
	assertEquals( 4711, column.getWidth() );
	}

	@Test
	public void testPack() throws IOException {
	final java.util.List<Widget> log = new ArrayList<Widget>();
	ControlAdapter resizeListener = new ControlAdapter() {
	@Override
	public void controlResized( ControlEvent e ) {
	log.add( e.widget );
	}
	};
	table.setHeaderVisible( true );
	column.addControlListener( resizeListener );

	// Ensure that controlResized is fired when pack changes the width
	column.setWidth( 12312 );
	log.clear();
	column.pack();
	assertSame( log.get( 0 ), column );

	// Ensure that controlResized is not fired when pack doesn't change the
	// width
	log.clear();
	column.pack();
	assertEquals( 0, log.size() );

	column.removeControlListener( resizeListener );

	// pack calculates a minimal width for an empty column
	column = new TableColumn( table, SWT.NONE );
	column.pack();
	assertTrue( column.getWidth() > 0 );

	// Test that an image on a column is taken into account
	column = new TableColumn( table, SWT.NONE );
	Image image = createImage( display, Fixture.IMAGE_50x100 );
	column.setImage( image );
	column.pack();
	assertTrue( column.getWidth() >= image.getBounds().width );

	// An item wider than the column itself strechtes the column
	while( table.getColumnCount() > 0 ) {
	table.getColumn( 0 ).dispose();
	}
	table.removeAll();
	column = new TableColumn( table, SWT.NONE );
	TableItem item = new TableItem( table, SWT.NONE );
	item.setImage( image );
	column.pack();
	assertTrue( column.getWidth() >= item.getBounds().width );
	}

	@Test
	public void testGetPreferredWidthWithInvisibleHeader() {
	table.setHeaderVisible( true );
	column.setText( "column" );
	int preferredWidth = column.getPreferredWidth();

	table.setHeaderVisible( false );

	assertEquals( preferredWidth, column.getPreferredWidth() );
	}

	@Test
	public void testGetPreferredWidthMultiLineHeader() {
	for( int i = 0; i < 3; i++ ) {
	TableColumn column1 = new TableColumn( table, SWT.NONE );
	column1.setWidth( 50 );
	column1.setText( "Column " + i );
	}
	table.setHeaderVisible( true );
	TableColumn column = table.getColumn( 1 );

	column.setText( "Multi\nLineText" );

	assertEquals( 61, column.getPreferredWidth() );
	}

	@Test
	public void testPackWithVirtual() {
	final java.util.List<Widget> log = new ArrayList<Widget>();
	Listener setDataListener = new Listener() {
	@Override
	public void handleEvent( Event event ) {
	log.add( event.item );
	}
	};
	ControlListener resizeListener = new ControlAdapter() {
	@Override
	public void controlResized( ControlEvent event ) {
	log.add( event.widget );
	}
	};
	// Must not try to access items if there aren't any
	log.clear();
	table = new Table( shell, SWT.VIRTUAL );
	column = new TableColumn( table, SWT.NONE );
	column.setWidth( 200 );
	column.addControlListener( resizeListener );
	column.pack();
	assertEquals( 1, log.size() ); // ensure that pack() did something

	// Ensure that pack resolves only first virtual item
	log.clear();
	table = new Table( shell, SWT.VIRTUAL );
	column = new TableColumn( table, SWT.NONE );
	table.setSize( 100, 50 );
	table.setItemCount( 100 );
	table.addListener( SWT.SetData, setDataListener );
	column.pack();
	assertEquals( 1, log.size() );
	}

	@Test
	public void testResizeEvent() {
	final java.util.List<ControlEvent> log = new ArrayList<ControlEvent>();
	column.addControlListener( new ControlListener() {
	@Override
	public void controlMoved( ControlEvent event ) {
	fail( "unexpected event: controlMoved" );
	}
	@Override
	public void controlResized( ControlEvent event ) {
	log.add( event );
	}
	} );
	ControlEvent event;
	// Changing column width leads to resize event
	log.clear();
	column.setWidth( column.getWidth() + 1 );
	assertEquals( 1, log.size() );
	event = log.get( 0 );
	assertSame( column, event.getSource() );
	// Setting the column width to the same value it already has as well leads
	// to resize event
	log.clear();
	column.setWidth( column.getWidth() );
	assertEquals( 1, log.size() );
	event = log.get( 0 );
	assertEquals( column, event.getSource() );
	}

	@Test
	public void testMoveEvent() {
	final java.util.List<ControlEvent> log = new ArrayList<ControlEvent>();
	column.addControlListener( new ControlListener() {
	@Override
	public void controlMoved( ControlEvent event ) {
	fail( "unexpected event: controlMoved" );
	}
	@Override
	public void controlResized( ControlEvent event ) {
	log.add( event );
	}
	} );
	final TableColumn column1 = new TableColumn( table, SWT.NONE );
	column1.addControlListener( new ControlListener() {
	@Override
	public void controlMoved( ControlEvent event ) {
	log.add( event );
	}
	@Override
	public void controlResized( ControlEvent event ) {
	fail( "unexpected event: controlResized" );
	}
	} );
	ControlEvent event;
	// Changing column width leads to resize event and move event of the next
	// columns
	log.clear();
	column.setWidth( column.getWidth() + 1 );
	assertEquals( 2, log.size() );
	event = log.get( 0 );
	assertSame( column, event.getSource() );
	event = log.get( 1 );
	assertSame( column1, event.getSource() );
	}

	@Test
	public void testDisposeLast() {
	TableColumn column1 = new TableColumn( table, SWT.NONE );
	TableItem item = new TableItem( table, SWT.NONE );
	item.setText( "itemText for column 0" );
	item.setText( 1, "itemText for column 1" );

	column1.dispose();
	assertEquals( "", item.getText( 1 ) );
	assertEquals( "itemText for column 0", item.getText() );

	column.dispose();
	assertEquals( 0, table.getColumnCount() );
	assertEquals( 1, table.getItemCount() );
	assertEquals( "itemText for column 0", item.getText() );
	}

	// 323179: Creating and disposing a TableColumn (without updating the
	// TableItems) results in an ArrayIndexOutOfBoundsException
	// https://bugs.eclipse.org/bugs/show_bug.cgi?id=323179
	@Test
	public void testCreateDisposeColumnWithoutDataUpdate() {
	column.setText( "First Column" );
	int number = 5;
	TableItem[] items = new TableItem[ number ];
	for( int i = 0; i < number; i++ ) {
	items[ i ] = new TableItem( table, SWT.NONE );
	items[ i ].setText( 0, "x1" );
	}
	TableColumn column2 = new TableColumn( table, SWT.NONE );
	column2.setText( "Second Column" );
	column2.dispose();
	}

	@Test
	public void testIsFixedColumn() {
	shell.setSize( 800, 600 );
	Table table = createFixedColumnsTable( shell );
	table.setSize( 300, 100 );
	ITableAdapter adapter = table.getAdapter( ITableAdapter.class );
	assertTrue( adapter.isFixedColumn( table.getColumn( 0 ) ) );
	assertFalse( adapter.isFixedColumn( table.getColumn( 1 ) ) );
	table.setColumnOrder( new int[]{ 1, 0, 2, 3, 4, 5, 6, 7, 8, 9 } );
	assertFalse( adapter.isFixedColumn( table.getColumn( 0 ) ) );
	assertTrue( adapter.isFixedColumn( table.getColumn( 1 ) ) );
	}

	@Test
	public void testAddSelectionListener() {
	column.addSelectionListener( mock( SelectionListener.class ) );

	assertTrue( column.isListening( SWT.Selection ) );
	assertTrue( column.isListening( SWT.DefaultSelection ) );
	}

	@Test
	public void testRemoveSelectionListener() {
	SelectionListener listener = mock( SelectionListener.class );
	column.addSelectionListener( listener );

	column.removeSelectionListener( listener );

	assertFalse( column.isListening( SWT.Selection ) );
	assertFalse( column.isListening( SWT.DefaultSelection ) );
	}

	@Test
	public void testAddSelectionListenerWithNullArgument() {
	try {
	column.addSelectionListener( null );
	} catch( IllegalArgumentException expected ) {
	}
	}

	@Test
	public void testRemoveSelectionListenerWithNullArgument() {
	try {
	column.removeSelectionListener( null );
	} catch( IllegalArgumentException expected ) {
	}
	}

	@Test
	public void testAddControlListenerWithNullArgument() {
	try {
	column.addControlListener( null );
	} catch( IllegalArgumentException expected ) {
	}
	}

	@Test
	public void testAddControlListener() {
	column.addControlListener( mock( ControlListener.class ) );

	assertTrue( column.isListening( SWT.Move ) );
	assertTrue( column.isListening( SWT.Resize ) );
	}

	@Test
	public void testRemoveControlListenerWithNullArgument() {
	try {
	column.removeControlListener( null );
	} catch( IllegalArgumentException expected ) {
	}
	}

	@Test
	public void testRemoveControlListener() {
	ControlListener listener = mock( ControlListener.class );
	column.addControlListener( listener );

	column.removeControlListener( listener );

	assertFalse( column.isListening( SWT.Move ) );
	assertFalse( column.isListening( SWT.Resize ) );
	}

	@Test
	public void testMarkupToolTipTextWithoutMarkupEnabled() {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.FALSE );

	try {
	column.setToolTipText( "invalid xhtml: <<&>>" );
	} catch( IllegalArgumentException notExpected ) {
	fail();
	}
	}

	@Test( expected = IllegalArgumentException.class )
	public void testMarkupToolTipTextWithMarkupEnabled() {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );

	column.setToolTipText( "invalid xhtml: <<&>>" );
	}

	@Test
	public void testMarkupTextWithMarkupEnabled_ValidationDisabled() {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
	column.setData( MarkupValidator.MARKUP_VALIDATION_DISABLED, Boolean.TRUE );

	try {
	column.setToolTipText( "invalid xhtml: <<&>>" );
	} catch( IllegalArgumentException notExpected ) {
	fail();
	}
	}

	@Test
	public void testSetToolTipMarkupEnabled_onDirtyWidget() {
	column.setToolTipText( "something" );

	try {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
	fail();
	} catch( SWTException expected ) {
	assertTrue( expected.throwable instanceof IllegalStateException );
	}
	}

	@Test
	public void testSetToolTipMarkupEnabled_onDirtyWidget_onceEnabledBefore() {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
	column.setToolTipText( "something" );

	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );
	}

	@Test
	public void testDisableMarkupIsIgnored() {
	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.TRUE );

	column.setData( RWT.TOOLTIP_MARKUP_ENABLED, Boolean.FALSE );

	assertEquals( Boolean.TRUE, column.getData( RWT.TOOLTIP_MARKUP_ENABLED ) );
	}

	@Test
	public void testSetData() {
	column.setData( "foo", "bar" );

	assertEquals( "bar", column.getData( "foo" ) );
	}

	private Table createFixedColumnsTable( Shell shell ) {
	Table result = new Table( shell, SWT.NONE );
	result.setData( RWT.FIXED_COLUMNS, new Integer( 1 ) );
	for( int i = 0; i < 10; i++ ) {
	TableColumn column = new TableColumn( result, SWT.NONE );
	column.setWidth( 50 );
	}
	return result;
	}

	@Test
	public void testGetAdapter_LCA() {
	assertTrue( column.getAdapter( WidgetLCA.class ) instanceof TableColumnLCA );
	assertSame( column.getAdapter( WidgetLCA.class ), column.getAdapter( WidgetLCA.class ) );
	}

	}