bundles/org.eclipse.ui.workbench/Eclipse UI/org/eclipse/ui/internal/PartTester.java

/*******************************************************************************
 * Copyright (c) 2005, 2006 IBM Corporation 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.ui.internal;

import org.eclipse.core.runtime.Assert;
import org.eclipse.ui.IEditorInput;
import org.eclipse.ui.IEditorPart;
import org.eclipse.ui.IPersistableElement;
import org.eclipse.ui.IPropertyListener;
import org.eclipse.ui.IViewPart;
import org.eclipse.ui.IWorkbenchPart;
import org.eclipse.ui.IWorkbenchPart2;

public class PartTester {
    private PartTester() {
    }
    
    /**
     * Sanity-check the public interface of the editor. This is called on every editor after it
     * is fully initiallized, but before it is actually connected to the editor reference or the
     * layout. Calls as much of the editor's public interface as possible to test for exceptions,
     * and tests the return values for glaring faults. This does not need to be an exhaustive conformance
     * test, as it is called every time an editor is opened and it needs to be efficient.
     * The part should be unmodified when the method exits. 
     *
     * @param part
     */
    public static void testEditor(IEditorPart part) throws Exception {
        testWorkbenchPart(part);
        
        Assert.isTrue(part.getEditorSite() == part.getSite(),
				"The part's editor site must be the same as the part's site"); //$NON-NLS-1$
		IEditorInput input = part.getEditorInput();
		Assert.isNotNull(input, "The editor input must be non-null"); //$NON-NLS-1$
		testEditorInput(input);
        
        part.isDirty();
        part.isSaveAsAllowed();
        part.isSaveOnCloseNeeded();
    }
    
    public static void testEditorInput(IEditorInput input) throws Exception {
        input.getAdapter(Object.class);
        
        // Don't test input.getImageDescriptor() -- the workbench never uses that
        // method and most editor inputs would fail the test. It should really be
        // deprecated.
        
        Assert.isNotNull(input.getName(),
				"The editor input must have a non-null name"); //$NON-NLS-1$
		Assert.isNotNull(input.getToolTipText(),
				"The editor input must have a non-null tool tip"); //$NON-NLS-1$

		// Persistable element may be null
		IPersistableElement persistableElement = input.getPersistable();
		if (persistableElement != null) {
			Assert
					.isNotNull(persistableElement.getFactoryId(),
							"The persistable element for the editor input must have a non-null factory id"); //$NON-NLS-1$
        }
    }
    
    /**
     * Sanity-checks a workbench part. Excercises the public interface and tests for any
     * obviously bogus return values. The part should be unmodified when the method exits.
     *
     * @param part
     * @throws Exception
     */
    private static void testWorkbenchPart(IWorkbenchPart part) throws Exception {
        IPropertyListener testListener = new IPropertyListener() {
            public void propertyChanged(Object source, int propId) {
                
            }
        };
        
        // Test addPropertyListener
        part.addPropertyListener(testListener);
        
        // Test removePropertyListener
        part.removePropertyListener(testListener);
        
        // Test equals
		Assert.isTrue(part.equals(part), "A part must be equal to itself"); //$NON-NLS-1$
		Assert.isTrue(!part.equals(new Integer(32)),
				"A part must have a meaningful equals method"); //$NON-NLS-1$
        
        // Test getAdapter   
        Object partAdapter = part.getAdapter(part.getClass());
        Assert.isTrue(partAdapter == null || partAdapter == part,
				"A part must adapter to itself or return null"); //$NON-NLS-1$
        
        // Test getTitle
		Assert.isNotNull(part.getTitle(), "A part's title must be non-null"); //$NON-NLS-1$

		// Test getTitleImage
		Assert.isNotNull(part.getTitleImage(),
				"A part's title image must be non-null"); //$NON-NLS-1$

		// Test getTitleToolTip
		Assert.isNotNull(part.getTitleToolTip(),
				"A part's title tool tip must be non-null"); //$NON-NLS-1$

		// Test toString
		Assert.isNotNull(part.toString(),
				"A part's toString method must return a non-null value"); //$NON-NLS-1$
        
        // Compute hashCode
        part.hashCode();
        
        if (part instanceof IWorkbenchPart2) {
            testWorkbenchPart2((IWorkbenchPart2)part);
        }
    }

    private static void testWorkbenchPart2(IWorkbenchPart2 part)
			throws Exception {
		Assert.isNotNull(part.getContentDescription(),
				"A part must return a non-null content description"); //$NON-NLS-1$
		Assert.isNotNull(part.getPartName(),
				"A part must return a non-null part name"); //$NON-NLS-1$
    }
    
    /**
     * Sanity-check the public interface of a view. This is called on every view after it
     * is fully initiallized, but before it is actually connected to the part reference or the
     * layout. Calls as much of the part's public interface as possible without modifying the part 
     * to test for exceptions and check the return values for glaring faults. This does not need 
     * to be an exhaustive conformance test, as it is called every time an editor is opened and 
     * it needs to be efficient. 
     *
     * @param part
     */    
    public static void testView(IViewPart part) throws Exception {
       Assert.isTrue(part.getSite() == part.getViewSite(),
				"A part's site must be the same as a part's view site"); //$NON-NLS-1$
       testWorkbenchPart(part);
    }
}