path: root/org.eclipse.debug.tests/src/org/eclipse/debug/tests/viewer/model/ColumnPresentationTests.java

/*******************************************************************************
 * Copyright (c) 2009, 2013 Wind River Systems 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:
 *     Wind River Systems - initial API and implementation
 *     IBM Corporation - bug fixing
 *******************************************************************************/
package org.eclipse.debug.tests.viewer.model;

import java.util.Arrays;

import junit.framework.TestCase;

import org.eclipse.debug.internal.ui.viewers.model.provisional.IColumnPresentation;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IColumnPresentation2;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IColumnPresentationFactory;
import org.eclipse.debug.internal.ui.viewers.model.provisional.IPresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.PresentationContext;
import org.eclipse.debug.internal.ui.viewers.model.provisional.TreeModelViewer;
import org.eclipse.debug.tests.viewer.model.TestModel.TestElement;
import org.eclipse.jface.resource.ImageDescriptor;
import org.eclipse.jface.viewers.TreePath;
import org.eclipse.swt.SWT;
import org.eclipse.swt.events.ControlEvent;
import org.eclipse.swt.events.ControlListener;
import org.eclipse.swt.layout.FillLayout;
import org.eclipse.swt.widgets.Display;
import org.eclipse.swt.widgets.Shell;
import org.eclipse.swt.widgets.Tree;
import org.eclipse.swt.widgets.TreeColumn;
import org.eclipse.ui.PlatformUI;
import org.eclipse.ui.XMLMemento;

/**
 * Tests to verify that the viewer properly handles initial columns width.
 */
public class ColumnPresentationTests extends TestCase implements ITestModelUpdatesListenerConstants {
	private Display fDisplay;
	private Shell fShell;
	private TreeModelViewer fViewer;
	private TestModelUpdatesListener fListener;
	private boolean fResized = false;

	public ColumnPresentationTests(String name) {
		super(name);
	}

	/**
	 * @throws java.lang.Exception
	 */
	@Override
	protected void setUp() throws Exception {
		createViewer();
	}

	/**
	 * @throws java.lang.Exception
	 */
	@Override
	protected void tearDown() throws Exception {
		destroyViewer();
	}

	void createViewer() {
		fDisplay = PlatformUI.getWorkbench().getDisplay();
        fShell = new Shell(fDisplay);
        fShell.setSize(800, 600);
		fShell.setLayout(new FillLayout());
		fViewer = new TreeModelViewer(fShell, SWT.VIRTUAL, new PresentationContext("TestViewer")); //$NON-NLS-1$
        fViewer.getTree().addControlListener(new ControlListener() {
            @Override
			public void controlResized(ControlEvent e) {
                fResized = true;
            }

            @Override
			public void controlMoved(ControlEvent e) {
            }
        });
		fListener = new TestModelUpdatesListener(fViewer, false, false);
		fShell.open();
	}

	void destroyViewer() throws InterruptedException {
		fListener.dispose();
		fViewer.getPresentationContext().dispose();
		// Close the shell.
		fShell.close();
		while (!fShell.isDisposed()) {
			if (!fDisplay.readAndDispatch()) {
				Thread.sleep(0);
			}
		}
	}

	void recreateViewer() throws InterruptedException {
		destroyViewer();
		createViewer();
	}

	static class MyColumnPresentation implements IColumnPresentation {
		private IPresentationContext fContext;
		protected String[] columnIds;

		MyColumnPresentation() {
		    this (makeDefaultColumnIds());
        }

		static String[] makeDefaultColumnIds() {
            String[] columnIds = new String[5];
            for (int i = 0; i < columnIds.length; i++) {
				columnIds[i] = "ColumnId_" + i; //$NON-NLS-1$
            }
            return columnIds;
		}

		MyColumnPresentation(String[] columnIds) {
			this.columnIds = columnIds;
		}

		@Override
		public void init(IPresentationContext context) {
			fContext = context;
		}

		@Override
		public void dispose() {
			fContext = null;
		}

		@Override
		public ImageDescriptor getImageDescriptor(String id) {
			return null;
		}

		protected IPresentationContext getPresentationContext() {
			return fContext;
		}

		@Override
		public String[] getAvailableColumns() {
			return columnIds;
		}

		@Override
		public String[] getInitialColumns() {
			return columnIds;
		}

		@Override
		public String getHeader(String id) {
		    if (Arrays.asList(columnIds).indexOf(id) != -1) {
		        return id;
		    }
		    return null;
		}

		@Override
		public String getId() {
			return "MyColumnPresentationID"; //$NON-NLS-1$
		}

		@Override
		public boolean isOptional() {
			return true;
		}

	}

	static class MyColumnPresentation2 extends MyColumnPresentation implements IColumnPresentation2 {
		int[] repliedWidths;

		MyColumnPresentation2() {
			super();
			for (int i = 0; i < columnIds.length; i++) {
				columnIds[i] += "_2"; //$NON-NLS-1$
			}
			repliedWidths = new int[columnIds.length];
			Arrays.fill(repliedWidths, -2);
		}

		@Override
		public int getInitialColumnWidth(String id, int treeWidgetWidth,
				String[] visibleColumnIds) {
			for (int i = 0; i < columnIds.length; i++) {
				if (id.equals(columnIds[i]) && i == 0) {
					repliedWidths[i] = 2 * (treeWidgetWidth / visibleColumnIds.length);
					return repliedWidths[i];
				}
				if (id.equals(columnIds[i]) && (i == 1 || i == 2)) {
					repliedWidths[i] = (treeWidgetWidth / visibleColumnIds.length) / 2;
					return repliedWidths[i];
				}
				if (id.equals(columnIds[i]) && i == 3) {
					repliedWidths[i] = (treeWidgetWidth / visibleColumnIds.length);
					return repliedWidths[i];
				}
				if (id.equals(columnIds[i]) && i == 4) {
					repliedWidths[i] = -1;
					return repliedWidths[i];
				}
			}
			return -1;
		}

		@Override
		public String getId() {
			return "MyColumnPresentation2ID"; //$NON-NLS-1$
		}
	}

	class MyModel extends TestModel implements IColumnPresentationFactory {
		MyColumnPresentation colPresenation;

		MyModel(MyColumnPresentation cp1) {
			colPresenation = cp1;
		}

		@Override
		public IColumnPresentation createColumnPresentation(
				IPresentationContext context, Object element) {
			if (colPresenation != null) {
				return colPresenation;
			}
			return null;
		}

		@Override
		public String getColumnPresentationId(IPresentationContext context,
				Object element) {
			if (colPresenation != null) {
				return colPresenation.getId();
			}
			return null;
		}

	}

	private TestModel makeModel(MyColumnPresentation cp, String rootSufffix) throws InterruptedException {
		MyModel model = new MyModel(cp);
		model.setRoot(new TestElement(model, "root" + rootSufffix, new TestElement[] { //$NON-NLS-1$
		new TestElement(model, "1", true, true, new TestElement[0]), //$NON-NLS-1$
		new TestElement(model, "2", true, false, new TestElement[0]), //$NON-NLS-1$
		new TestElement(model, "3", false, true, new TestElement[0]), //$NON-NLS-1$
		new TestElement(model, "4", false, false, new TestElement[0]), //$NON-NLS-1$
		new TestElement(model, "5", new TestElement[0]), //$NON-NLS-1$
		new TestElement(model, "6", new TestElement[0]) })); //$NON-NLS-1$
		fListener.reset(TreePath.EMPTY, model.getRootElement(), -1, true, false);
		fViewer.setInput(model.getRootElement());
		while (!fListener.isFinished()) {
			if (!fDisplay.readAndDispatch()) {
				Thread.sleep(0);
			}
		}
		model.validateData(fViewer, TreePath.EMPTY);
		return model;
	}

	/**
	 * In this test: verify that tree viewer can handle IColumnPresentation
	 * implementation without requiring the presentation being
	 * IColumnPresentation2 (i.e. ensure we do not break backward compatibility
	 * of interface). Also, we verify that the initial columns width is the
	 * average of tree width / number of visible columns, which is the logic
	 * in InternalTreeModelViewer.
	 */
	public void testInitialColumnAverageWidth() throws InterruptedException {
        // Try to wait for the shell painting to settle
        if (!fDisplay.readAndDispatch ()) {
			Thread.sleep(0);
		}
        fResized = false;

		MyColumnPresentation colPre = new MyColumnPresentation();
		makeModel(colPre, "m1"); //$NON-NLS-1$
		Tree tree = fViewer.getTree();
		TreeColumn[] columns = tree.getColumns();
		int treeWidth = tree.getSize().x;
		int avgWidth = treeWidth / columns.length;

        // Resizing the tree invalidates the test.
		if (fResized) {
		    return;
		}

		for (int i = 0; i < columns.length - 1; i++) {
			assertEquals(avgWidth, columns[i].getWidth());
		}
		// Checking of the width of the last column is not reliable.
		// I.e. it's handled differenty on different platforms.
        //int remainder = treeWidth % columns.length;
        //assertEquals(avgWidth + remainder, columns[columns.length - 1].getWidth());
	}

	/**
	 * In this test: verify that tree viewer can handle IColumnPresentation2.
	 * Also, we verify that the initial columns width is the width computed by
	 * the IColumnPresentation2 implementation.
	 */
	public void testInitialColumnWidth() throws InterruptedException {
        // Try to wait for the shell painting to settle
        if (!fDisplay.readAndDispatch ()) {
			Thread.sleep(0);
		}
        fResized = false;

        MyColumnPresentation2 colPre = new MyColumnPresentation2();
		makeModel(colPre, "m2"); //$NON-NLS-1$
		Tree tree = fViewer.getTree();
		TreeColumn[] columns = tree.getColumns();

        // Resizing the tree invalidates the test.
		if (fResized) {
		    return;
		}

		for (int i = 0; i < columns.length; i++) {
			int width = colPre.repliedWidths[i];
			if (width != -1) {
	            assertEquals(width, columns[i].getWidth());
			}
		}
	}

	/**
	 * In this test: verify that tree viewer can handle IColumnPresentation2.
	 * Also, we verify that the initial columns width from IColumnPresentation2
	 * is not used when there are user settings inside the viewer which are
	 * created from user resizing columns.
	 */
	public void testRespectUserSettings() throws InterruptedException {
		MyColumnPresentation2 colPre = new MyColumnPresentation2();
		makeModel(colPre, "m2"); //$NON-NLS-1$
		TreeColumn[] columns = fViewer.getTree().getColumns();
		// simulate user resizing each column width
		int[] newWidths = new int[columns.length];
		for (int i = 0; i < columns.length; i++) {
			newWidths[i] = columns[i].getWidth() + 10;
			columns[i].setWidth(newWidths[i]);
		}
		for (int i = 0; i < columns.length; i++) {
			assertEquals(newWidths[i], columns[i].getWidth());
		}
		// get InternalTreeModelViewer to rebuild columns due to change of
		// model and presentation - first set to another model and column
		// presentation, then switch to a model with original presentation.
		makeModel(new MyColumnPresentation(), "m1"); //$NON-NLS-1$
		makeModel(colPre, "m3"); //$NON-NLS-1$
		// verify user resized widths are used instead of the initial widths from IColumnPresentation2
		columns = fViewer.getTree().getColumns();
		for (int i = 0; i < columns.length; i++) {
			assertEquals(newWidths[i], columns[i].getWidth());
		}

		// get InternalTreeModelViewer to rebuild columns due to hide and show columns
		fViewer.setShowColumns(false);
		do {
			if (!fDisplay.readAndDispatch()) {
				Thread.sleep(0);
			}
		} while (fViewer.getTree().getColumns().length > 0);
		fViewer.setShowColumns(true);
		do {
			if (!fDisplay.readAndDispatch()) {
				Thread.sleep(0);
			}
		} while (fViewer.getTree().getColumns().length != newWidths.length);
		// verify user resized widths are used instead of the initial widths from IColumnPresentation2
		columns = fViewer.getTree().getColumns();
		for (int i = 0; i < columns.length; i++) {
			assertEquals(newWidths[i], columns[i].getWidth());
		}
	}

	/**
	 * In this test: verify that tree viewer can handle IColumnPresentation2.
	 * Also, we verify that the initial columns width from IColumnPresentation2
	 * is not used when there are user settings inside the viewer which are
	 * restored from memento, e.g., restoring workspace, etc.
	 */
	public void testRespectMemento() throws InterruptedException {
		MyColumnPresentation2 colPre = new MyColumnPresentation2();
		makeModel(colPre, "m2"); //$NON-NLS-1$
		TreeColumn[] columns = fViewer.getTree().getColumns();
		// simulate user resizing each column width
		int[] newWidths = new int[columns.length];
		for (int i = 0; i < columns.length; i++) {
			newWidths[i] = columns[i].getWidth() + 10;
			columns[i].setWidth(newWidths[i]);
		}
		for (int i = 0; i < columns.length; i++) {
			assertEquals(newWidths[i], columns[i].getWidth());
		}
		// save memento
		final XMLMemento memento = XMLMemento.createWriteRoot("TEST"); //$NON-NLS-1$
		fViewer.saveState(memento);
		// throw away any settings inside the viewer and create a new viewer
		// with memento settings, this is the same effect resulted from closing
		// and opening workspace again.
		recreateViewer();
		fViewer.initState(memento);
		// get InternalTreeModelViewer to rebuild columns
		makeModel(colPre, "m2"); //$NON-NLS-1$
		// verify widths from memento are used instead of the initial widths from IColumnPresentation2
		columns = fViewer.getTree().getColumns();
		for (int i = 0; i < columns.length; i++) {
			assertEquals(newWidths[i], columns[i].getWidth());
		}
	}

	/**
     * In this test: verify that tree viewer can handle the column presentation changing
     * its available column IDs between runs (bug 360015).
     */
    public void testChangedColumnIds() throws InterruptedException {
        MyColumnPresentation colPre = new MyColumnPresentation();

		makeModel(colPre, "m1"); //$NON-NLS-1$
        TreeColumn[] columns = fViewer.getTree().getColumns();
        // Select visible columns
        fViewer.setVisibleColumns(new String[] { colPre.columnIds[0] });
        do {
            if (!fDisplay.readAndDispatch()) {
                Thread.sleep(0);
            }
        } while (fViewer.getTree().getColumns().length != 1);

        // get InternalTreeModelViewer to rebuild columns due to change of
        // model and presentation - first set to another model and column
        // presentation, then switch to a model with original presentation.
		makeModel(new MyColumnPresentation2(), "m2"); //$NON-NLS-1$

        String[] newColumnIds = MyColumnPresentation.makeDefaultColumnIds();
		newColumnIds[0] = "new_column_id"; //$NON-NLS-1$
        colPre = new MyColumnPresentation(newColumnIds);

		makeModel(colPre, "m3"); //$NON-NLS-1$

        // verify user resized widths are used instead of the initial widths from IColumnPresentation2
        columns = fViewer.getTree().getColumns();
        for (int i = 0; i < columns.length; i++) {
            assertEquals(newColumnIds[i], columns[i].getText());
        }
    }

}