tests/org.eclipse.ui.tests.rcp/Eclipse RCP Tests/org/eclipse/ui/tests/rcp/WorkbenchWindowConfigurerTest.java - platform/eclipse.platform.ui - Git at Google

 /*******************************************************************************
  * Copyright (c) 2004, 2007 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.tests.rcp;

 import java.util.ArrayList;
 import java.util.Iterator;

 import junit.framework.TestCase;

 import org.eclipse.core.runtime.IStatus;
 import org.eclipse.jface.action.IAction;
 import org.eclipse.jface.action.ICoolBarManager;
 import org.eclipse.jface.action.IMenuManager;
 import org.eclipse.jface.action.IStatusLineManager;
 import org.eclipse.swt.widgets.Composite;
 import org.eclipse.swt.widgets.Control;
 import org.eclipse.swt.widgets.Display;
 import org.eclipse.swt.widgets.Shell;
 import org.eclipse.ui.IMemento;
 import org.eclipse.ui.IWorkbenchWindow;
 import org.eclipse.ui.PlatformUI;
 import org.eclipse.ui.WorkbenchException;
 import org.eclipse.ui.application.ActionBarAdvisor;
 import org.eclipse.ui.application.IActionBarConfigurer;
 import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
 import org.eclipse.ui.application.WorkbenchAdvisor;
 import org.eclipse.ui.application.WorkbenchWindowAdvisor;
 import org.eclipse.ui.internal.WorkbenchWindow;
 import org.eclipse.ui.tests.rcp.util.RCPTestWorkbenchAdvisor;
 import org.eclipse.ui.tests.rcp.util.WorkbenchAdvisorObserver;

 public class WorkbenchWindowConfigurerTest extends TestCase {

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

     private Display display = null;

     protected void setUp() throws Exception {
         super.setUp();

         assertNull(display);
         display = PlatformUI.createDisplay();
         assertNotNull(display);
     }

     protected void tearDown() throws Exception {
         assertNotNull(display);
         display.dispose();
         assertTrue(display.isDisposed());

         super.tearDown();
     }

     public void testDefaults() {
         WorkbenchAdvisor wa = new WorkbenchAdvisorObserver(1) {

             public void fillActionBars(IWorkbenchWindow window,
                     IActionBarConfigurer actionBarConfig, int flags) {
                 super.fillActionBars(window, actionBarConfig, flags);

                 String tempTitle = "title"; //$NON-NLS-1$

                 IWorkbenchWindowConfigurer windowConfig = workbenchConfig
                         .getWindowConfigurer(window);
                 assertNotNull(windowConfig);

                 assertEquals(window, windowConfig.getWindow());
                 assertEquals(workbenchConfig, windowConfig
                         .getWorkbenchConfigurer());
                 assertEquals(actionBarConfig, windowConfig
                         .getActionBarConfigurer());
                 assertNotNull(windowConfig.getTitle());
                 assertTrue(windowConfig.getShowCoolBar());
                 assertTrue(windowConfig.getShowMenuBar());
                 assertFalse(windowConfig.getShowPerspectiveBar());
                 assertTrue(windowConfig.getShowStatusLine());

                 windowConfig.setTitle(tempTitle);
                 windowConfig.setShowCoolBar(false);
                 windowConfig.setShowMenuBar(false);
                 windowConfig.setShowPerspectiveBar(true);
                 windowConfig.setShowStatusLine(false);
                 assertEquals(tempTitle, windowConfig.getTitle());
                 assertFalse(windowConfig.getShowCoolBar());
                 assertFalse(windowConfig.getShowMenuBar());
                 assertTrue(windowConfig.getShowPerspectiveBar());
                 assertFalse(windowConfig.getShowStatusLine());

                 // *** title is orginally null, but cannot set it back to null,
                 // should that
                 //     check be allowed?
                 windowConfig.setTitle("");//$NON-NLS-1$
                 windowConfig.setShowCoolBar(true);
                 windowConfig.setShowMenuBar(true);
                 windowConfig.setShowPerspectiveBar(false);
                 windowConfig.setShowStatusLine(true);
             }
         };

         int code = PlatformUI.createAndRunWorkbench(display, wa);
         assertEquals(PlatformUI.RETURN_OK, code);
     }

 	public void test104558_T_T() throws Throwable {
 		doTest104558(true, true);
 	}

 	public void test104558_F_T() throws Throwable {
 		doTest104558(false, true);
 	}

 	public void test104558_T_F() throws Throwable {
 		doTest104558(true, false);
 	}

 	public void test104558_F_F() throws Throwable {
 		doTest104558(false, false);
 	}

 	private void doTest104558(final boolean showPerspectiveBar, final boolean showCoolBar) {
 		WorkbenchAdvisor wa = new WorkbenchAdvisorObserver(1) {
 			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
 					IWorkbenchWindowConfigurer workbenchWindowConfigurer) {
 				return new WorkbenchWindowAdvisor(workbenchWindowConfigurer) {
 					public void preWindowOpen() {
 						super.preWindowOpen();
 						getWindowConfigurer().setShowCoolBar(showCoolBar);
 						getWindowConfigurer().setShowPerspectiveBar(showPerspectiveBar);
 					}
 					public void createWindowContents(Shell shell) {
 						IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
 						configurer.createPageComposite(shell);
 					}
 				};
 			}

 			public void eventLoopIdle(Display disp) {
 				IWorkbenchWindow activeWorkbenchWindow = getWorkbenchConfigurer()
 						.getWorkbench().getActiveWorkbenchWindow();
 				assertEquals("testing showCoolBar=" + showCoolBar, showCoolBar, ((WorkbenchWindow)activeWorkbenchWindow).getCoolBarVisible());
 				assertEquals("testing showPerspectiveBar=" + showPerspectiveBar, showPerspectiveBar, ((WorkbenchWindow)activeWorkbenchWindow).getPerspectiveBarVisible());
 				super.eventLoopIdle(disp);
 			}

 			public void eventLoopException(Throwable exception) {
 				throw new RuntimeException(exception);
 			}
 		};

 		int code = PlatformUI.createAndRunWorkbench(display, wa);
 		assertEquals(PlatformUI.RETURN_OK, code);
 	}


 	// tests to ensure that all WorkbenchAdvisor API is called from the UI thread.
 	public void testThreading() {
 		final ArrayList results = new ArrayList();

 		WorkbenchAdvisor advisor = new RCPTestWorkbenchAdvisor(1) {

 			public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
 					IWorkbenchWindowConfigurer configurer) {
 				WorkbenchWindowAdvisor advisor = new WorkbenchWindowAdvisor(configurer) {

 					private void ensureThread() {
 						if (Display.getCurrent() != null)
 							return;

 						Exception e = new Exception();
 						e.fillInStackTrace();
 						StackTraceElement element = e.getStackTrace()[1];
 						results.add(element.getClassName() + '.' + element.getMethodName());
 					}

 					public ActionBarAdvisor createActionBarAdvisor(
 							IActionBarConfigurer configurer) {
 						ensureThread();

 						ActionBarAdvisor advisor = new ActionBarAdvisor(configurer) {

 							public void dispose() {
 								ensureThread();
 								super.dispose();
 							}

 							protected void disposeAction(IAction action) {
 								ensureThread();
 								super.disposeAction(action);
 							}

 							protected void disposeActions() {
 								ensureThread();
 								super.disposeActions();
 							}

 							public void fillActionBars(int flags) {
 								ensureThread();
 								super.fillActionBars(flags);
 							}

 							protected void fillCoolBar(ICoolBarManager coolBar) {
 								ensureThread();
 								super.fillCoolBar(coolBar);
 							}

 							protected void fillMenuBar(IMenuManager menuBar) {
 								ensureThread();
 								super.fillMenuBar(menuBar);
 							}

 							protected void fillStatusLine(
 									IStatusLineManager statusLine) {
 								ensureThread();
 								super.fillStatusLine(statusLine);
 							}

 							protected IAction getAction(String id) {
 								ensureThread();
 								return super.getAction(id);
 							}

 							protected IActionBarConfigurer getActionBarConfigurer() {
 								ensureThread();
 								return super.getActionBarConfigurer();
 							}

 							public boolean isApplicationMenu(String menuId) {
 								ensureThread();
 								return super.isApplicationMenu(menuId);
 							}

 							protected void makeActions(IWorkbenchWindow window) {
 								ensureThread();
 								super.makeActions(window);
 							}

 							protected void register(IAction action) {
 								ensureThread();
 								super.register(action);
 							}

 							public IStatus restoreState(IMemento memento) {
 								ensureThread();
 								return super.restoreState(memento);
 							}

 							public IStatus saveState(IMemento memento) {
 								ensureThread();
 								return super.saveState(memento);
 							}};
 						return advisor;
 					}

 					public Control createEmptyWindowContents(Composite parent) {
 						ensureThread();
 						return super.createEmptyWindowContents(parent);
 					}

 					public void createWindowContents(Shell shell) {
 						ensureThread();
 						super.createWindowContents(shell);
 					}

 					public void dispose() {
 						ensureThread();
 						super.dispose();
 					}

 					protected IWorkbenchWindowConfigurer getWindowConfigurer() {
 						ensureThread();
 						return super.getWindowConfigurer();
 					}

 					public void openIntro() {
 						ensureThread();
 						super.openIntro();
 					}

 					public void postWindowClose() {
 						ensureThread();
 						super.postWindowClose();
 					}

 					public void postWindowCreate() {
 						ensureThread();
 						super.postWindowCreate();
 					}

 					public void postWindowOpen() {
 						ensureThread();
 						super.postWindowOpen();
 					}

 					public void postWindowRestore() throws WorkbenchException {
 						ensureThread();
 						super.postWindowRestore();
 					}

 					public void preWindowOpen() {
 						ensureThread();
 						super.preWindowOpen();
 					}

 					public boolean preWindowShellClose() {
 						ensureThread();
 						return super.preWindowShellClose();
 					}

 					public IStatus restoreState(IMemento memento) {
 						ensureThread();
 						return super.restoreState(memento);
 					}

 					public IStatus saveState(IMemento memento) {
 						ensureThread();
 						return super.saveState(memento);
 					}

 				};
 				return advisor;
 			}
 		};

 		int code = PlatformUI.createAndRunWorkbench(display, advisor);
 		assertEquals(PlatformUI.RETURN_OK, code);

 		if (!results.isEmpty()) {
 			StringBuffer buffer = new StringBuffer("Window/action bar advisor methods called from non-UI threads:\n");
 			for (Iterator i = results.iterator(); i.hasNext();) {
 				String string = (String) i.next();
 				buffer.append(string).append('\n');
 			}
 			fail(buffer.toString());
 		}

 	}
 }
	/*******************************************************************************
	* Copyright (c) 2004, 2007 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.tests.rcp;

	import java.util.ArrayList;
	import java.util.Iterator;

	import junit.framework.TestCase;

	import org.eclipse.core.runtime.IStatus;
	import org.eclipse.jface.action.IAction;
	import org.eclipse.jface.action.ICoolBarManager;
	import org.eclipse.jface.action.IMenuManager;
	import org.eclipse.jface.action.IStatusLineManager;
	import org.eclipse.swt.widgets.Composite;
	import org.eclipse.swt.widgets.Control;
	import org.eclipse.swt.widgets.Display;
	import org.eclipse.swt.widgets.Shell;
	import org.eclipse.ui.IMemento;
	import org.eclipse.ui.IWorkbenchWindow;
	import org.eclipse.ui.PlatformUI;
	import org.eclipse.ui.WorkbenchException;
	import org.eclipse.ui.application.ActionBarAdvisor;
	import org.eclipse.ui.application.IActionBarConfigurer;
	import org.eclipse.ui.application.IWorkbenchWindowConfigurer;
	import org.eclipse.ui.application.WorkbenchAdvisor;
	import org.eclipse.ui.application.WorkbenchWindowAdvisor;
	import org.eclipse.ui.internal.WorkbenchWindow;
	import org.eclipse.ui.tests.rcp.util.RCPTestWorkbenchAdvisor;
	import org.eclipse.ui.tests.rcp.util.WorkbenchAdvisorObserver;

	public class WorkbenchWindowConfigurerTest extends TestCase {

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

	private Display display = null;

	protected void setUp() throws Exception {
	super.setUp();

	assertNull(display);
	display = PlatformUI.createDisplay();
	assertNotNull(display);
	}

	protected void tearDown() throws Exception {
	assertNotNull(display);
	display.dispose();
	assertTrue(display.isDisposed());

	super.tearDown();
	}

	public void testDefaults() {
	WorkbenchAdvisor wa = new WorkbenchAdvisorObserver(1) {

	public void fillActionBars(IWorkbenchWindow window,
	IActionBarConfigurer actionBarConfig, int flags) {
	super.fillActionBars(window, actionBarConfig, flags);

	String tempTitle = "title"; //$NON-NLS-1$

	IWorkbenchWindowConfigurer windowConfig = workbenchConfig
	.getWindowConfigurer(window);
	assertNotNull(windowConfig);

	assertEquals(window, windowConfig.getWindow());
	assertEquals(workbenchConfig, windowConfig
	.getWorkbenchConfigurer());
	assertEquals(actionBarConfig, windowConfig
	.getActionBarConfigurer());
	assertNotNull(windowConfig.getTitle());
	assertTrue(windowConfig.getShowCoolBar());
	assertTrue(windowConfig.getShowMenuBar());
	assertFalse(windowConfig.getShowPerspectiveBar());
	assertTrue(windowConfig.getShowStatusLine());

	windowConfig.setTitle(tempTitle);
	windowConfig.setShowCoolBar(false);
	windowConfig.setShowMenuBar(false);
	windowConfig.setShowPerspectiveBar(true);
	windowConfig.setShowStatusLine(false);
	assertEquals(tempTitle, windowConfig.getTitle());
	assertFalse(windowConfig.getShowCoolBar());
	assertFalse(windowConfig.getShowMenuBar());
	assertTrue(windowConfig.getShowPerspectiveBar());
	assertFalse(windowConfig.getShowStatusLine());

	// *** title is orginally null, but cannot set it back to null,
	// should that
	// check be allowed?
	windowConfig.setTitle("");//$NON-NLS-1$
	windowConfig.setShowCoolBar(true);
	windowConfig.setShowMenuBar(true);
	windowConfig.setShowPerspectiveBar(false);
	windowConfig.setShowStatusLine(true);
	}
	};

	int code = PlatformUI.createAndRunWorkbench(display, wa);
	assertEquals(PlatformUI.RETURN_OK, code);
	}

	public void test104558_T_T() throws Throwable {
	doTest104558(true, true);
	}

	public void test104558_F_T() throws Throwable {
	doTest104558(false, true);
	}

	public void test104558_T_F() throws Throwable {
	doTest104558(true, false);
	}

	public void test104558_F_F() throws Throwable {
	doTest104558(false, false);
	}

	private void doTest104558(final boolean showPerspectiveBar, final boolean showCoolBar) {
	WorkbenchAdvisor wa = new WorkbenchAdvisorObserver(1) {
	public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
	IWorkbenchWindowConfigurer workbenchWindowConfigurer) {
	return new WorkbenchWindowAdvisor(workbenchWindowConfigurer) {
	public void preWindowOpen() {
	super.preWindowOpen();
	getWindowConfigurer().setShowCoolBar(showCoolBar);
	getWindowConfigurer().setShowPerspectiveBar(showPerspectiveBar);
	}
	public void createWindowContents(Shell shell) {
	IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
	configurer.createPageComposite(shell);
	}
	};
	}

	public void eventLoopIdle(Display disp) {
	IWorkbenchWindow activeWorkbenchWindow = getWorkbenchConfigurer()
	.getWorkbench().getActiveWorkbenchWindow();
	assertEquals("testing showCoolBar=" + showCoolBar, showCoolBar, ((WorkbenchWindow)activeWorkbenchWindow).getCoolBarVisible());
	assertEquals("testing showPerspectiveBar=" + showPerspectiveBar, showPerspectiveBar, ((WorkbenchWindow)activeWorkbenchWindow).getPerspectiveBarVisible());
	super.eventLoopIdle(disp);
	}

	public void eventLoopException(Throwable exception) {
	throw new RuntimeException(exception);
	}
	};

	int code = PlatformUI.createAndRunWorkbench(display, wa);
	assertEquals(PlatformUI.RETURN_OK, code);
	}


	// tests to ensure that all WorkbenchAdvisor API is called from the UI thread.
	public void testThreading() {
	final ArrayList results = new ArrayList();

	WorkbenchAdvisor advisor = new RCPTestWorkbenchAdvisor(1) {

	public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(
	IWorkbenchWindowConfigurer configurer) {
	WorkbenchWindowAdvisor advisor = new WorkbenchWindowAdvisor(configurer) {

	private void ensureThread() {
	if (Display.getCurrent() != null)
	return;

	Exception e = new Exception();
	e.fillInStackTrace();
	StackTraceElement element = e.getStackTrace()[1];
	results.add(element.getClassName() + '.' + element.getMethodName());
	}

	public ActionBarAdvisor createActionBarAdvisor(
	IActionBarConfigurer configurer) {
	ensureThread();

	ActionBarAdvisor advisor = new ActionBarAdvisor(configurer) {

	public void dispose() {
	ensureThread();
	super.dispose();
	}

	protected void disposeAction(IAction action) {
	ensureThread();
	super.disposeAction(action);
	}

	protected void disposeActions() {
	ensureThread();
	super.disposeActions();
	}

	public void fillActionBars(int flags) {
	ensureThread();
	super.fillActionBars(flags);
	}

	protected void fillCoolBar(ICoolBarManager coolBar) {
	ensureThread();
	super.fillCoolBar(coolBar);
	}

	protected void fillMenuBar(IMenuManager menuBar) {
	ensureThread();
	super.fillMenuBar(menuBar);
	}

	protected void fillStatusLine(
	IStatusLineManager statusLine) {
	ensureThread();
	super.fillStatusLine(statusLine);
	}

	protected IAction getAction(String id) {
	ensureThread();
	return super.getAction(id);
	}

	protected IActionBarConfigurer getActionBarConfigurer() {
	ensureThread();
	return super.getActionBarConfigurer();
	}

	public boolean isApplicationMenu(String menuId) {
	ensureThread();
	return super.isApplicationMenu(menuId);
	}

	protected void makeActions(IWorkbenchWindow window) {
	ensureThread();
	super.makeActions(window);
	}

	protected void register(IAction action) {
	ensureThread();
	super.register(action);
	}

	public IStatus restoreState(IMemento memento) {
	ensureThread();
	return super.restoreState(memento);
	}

	public IStatus saveState(IMemento memento) {
	ensureThread();
	return super.saveState(memento);
	}};
	return advisor;
	}

	public Control createEmptyWindowContents(Composite parent) {
	ensureThread();
	return super.createEmptyWindowContents(parent);
	}

	public void createWindowContents(Shell shell) {
	ensureThread();
	super.createWindowContents(shell);
	}

	public void dispose() {
	ensureThread();
	super.dispose();
	}

	protected IWorkbenchWindowConfigurer getWindowConfigurer() {
	ensureThread();
	return super.getWindowConfigurer();
	}

	public void openIntro() {
	ensureThread();
	super.openIntro();
	}

	public void postWindowClose() {
	ensureThread();
	super.postWindowClose();
	}

	public void postWindowCreate() {
	ensureThread();
	super.postWindowCreate();
	}

	public void postWindowOpen() {
	ensureThread();
	super.postWindowOpen();
	}

	public void postWindowRestore() throws WorkbenchException {
	ensureThread();
	super.postWindowRestore();
	}

	public void preWindowOpen() {
	ensureThread();
	super.preWindowOpen();
	}

	public boolean preWindowShellClose() {
	ensureThread();
	return super.preWindowShellClose();
	}

	public IStatus restoreState(IMemento memento) {
	ensureThread();
	return super.restoreState(memento);
	}

	public IStatus saveState(IMemento memento) {
	ensureThread();
	return super.saveState(memento);
	}

	};
	return advisor;
	}
	};

	int code = PlatformUI.createAndRunWorkbench(display, advisor);
	assertEquals(PlatformUI.RETURN_OK, code);

	if (!results.isEmpty()) {
	StringBuffer buffer = new StringBuffer("Window/action bar advisor methods called from non-UI threads:\n");
	for (Iterator i = results.iterator(); i.hasNext();) {
	String string = (String) i.next();
	buffer.append(string).append('\n');
	}
	fail(buffer.toString());
	}

	}
	}